fix(files): create empty file

Author: MatthewPattell

microservices/files/__tests__/methods/file/create-empty.ts

@@ -1,12 +1,17 @@
+import { RemoteConfig } from '@lomray/microservice-helpers';
 import { TypeormMock } from '@lomray/microservice-helpers/mocks';
 import { endpointOptions, waitResult } from '@lomray/microservice-helpers/test-helpers';
 import { expect } from 'chai';
 import rewiremock from 'rewiremock';
 import sinon from 'sinon';
+import StorageStub from '@__mocks__/storage-stub';
 import FileType from '@constants/file-type';
+import File from '@entities/file';
 import OriginalEndpointCreateEmpty from '@methods/file/create-empty';
+import Factory from '@services/file/factory';
+import StorageFactory from '@services/storage/factory';
 
-const { default: Create } = rewiremock.proxy<{
+const { default: CreateEmpty } = rewiremock.proxy<{
   default: typeof OriginalEndpointCreateEmpty;
 }>(() => require('@methods/file/create-empty'), {
   typeorm: TypeormMock.mock,
@@ -21,22 +26,52 @@ describe('methods/file/create-empty', () => {
 
   it('should throw error: validation failed', async () => {
     // @ts-ignore
-    const res = Create({}, endpointOptions);
+    const res = CreateEmpty({}, endpointOptions);
 
-    expect(await waitResult(res)).to.throw('Validation failed for one or more entities.');
+    expect(await waitResult(res)).to.throw('Invalid request params');
   });
 
   it('should correctly create file', async () => {
-    const fields = {
+    let serviceParams: Parameters<typeof Factory.create> | undefined;
+    let saveStub;
+
+    sandbox.stub(RemoteConfig, 'get').resolves({});
+
+    const methodParams = {
+      fileName: 'file.mp4',
       userId: 'user_id',
-      type: FileType.image,
-      url: '/',
+      alt: 'alt',
+      type: FileType.video,
     };
+    const file = {
+      id: 'file_id',
+      url: 'url',
+      userId: methodParams.userId,
+      alt: methodParams.alt,
+    };
+
+    const serviceStub = sandbox.stub(Factory, 'create').callsFake(async (...args) => {
+      serviceStub.restore();
+
+      sandbox.stub(StorageFactory, 'create').resolves(StorageStub);
+
+      const service = await Factory.create(...args);
+
+      serviceParams = args;
+      saveStub = sandbox.stub(service, 'save').resolves(file as File);
 
-    TypeormMock.entityManager.save.resolves([fields]);
+      return service;
+    });
 
-    const res = await Create({ fields }, endpointOptions);
+    const res = await CreateEmpty(methodParams, endpointOptions);
 
-    expect(res?.entity).to.deep.equal(fields);
+    expect(res).to.deep.equal({ entity: file });
+    expect(serviceParams?.[0]).to.be.equal(FileType.video);
+    expect(serviceParams?.[1]).to.deep.equal(TypeormMock.entityManager);
+    expect(saveStub).to.calledOnceWith(
+      methodParams.fileName,
+      methodParams.userId,
+      methodParams.alt,
+    );
   });
 });

microservices/files/__tests__/services/file/any-file-test.ts

@@ -98,7 +98,6 @@ describe('services/file/any-file', () => {
     });
 
     sandbox.stub(service, <any>'uploadFile');
-
     sandbox.stub(storage, 'delete');
 
     const entity = await service.update(fileData, 'file');

microservices/files/__tests__/services/file/empty-file-test.ts

@@ -0,0 +1,81 @@
+import { RemoteConfig } from '@lomray/microservice-helpers';
+import { TypeormMock } from '@lomray/microservice-helpers/mocks';
+import { expect } from 'chai';
+import sinon from 'sinon';
+import { getRepository } from 'typeorm';
+import { bucketNameMock } from '@__mocks__/common';
+import FileType from '@constants/file-type';
+import CONST from '@constants/index';
+import File from '@entities/file';
+import EmptyFile from '@services/file/empty-file';
+import StorageFactory from '@services/storage/factory';
+
+describe('services/file/empty-file', () => {
+  const sandbox = sinon.createSandbox();
+  const fileData = getRepository(File).create({
+    id: 'file_id',
+  });
+  const resultFile = {
+    id: 'file_id',
+    type: FileType.video,
+    meta: { mime: 'video/mp4' },
+  };
+
+  /**
+   * Create service
+   */
+  const getService = async (): Promise<EmptyFile> => {
+    sandbox.stub(RemoteConfig, 'get').resolves({ s3: { bucketName: bucketNameMock } });
+
+    const storage = await StorageFactory.create();
+
+    return new EmptyFile(FileType.video, TypeormMock.entityManager, storage, {
+      storagePathPrefix: CONST.STORAGE_PATH_PREFIX,
+    });
+  };
+
+  beforeEach(() => {
+    TypeormMock.sandbox.reset();
+  });
+
+  afterEach(() => {
+    sandbox.restore();
+  });
+
+  it('should successfully save file', async () => {
+    // first call - create empty file
+    TypeormMock.entityManager.save.onFirstCall().resolves(fileData);
+    // second call - return from transaction
+    TypeormMock.entityManager.save.onSecondCall().callsFake((_, entity) => entity);
+
+    const service = await getService();
+    const entity = await service.save('file.mp4', 'user_id');
+
+    const [, file] = TypeormMock.entityManager.save.secondCall.args;
+
+    const fileUrl = entity.url;
+
+    expect(fileUrl.startsWith(`/${fileData.id}`)).to.true;
+    expect(fileUrl.endsWith('.mp4')).to.true;
+    expect(entity).to.deep.equal({
+      ...resultFile,
+      url: fileUrl,
+    });
+    expect(file).to.deep.equal({
+      ...resultFile,
+      url: fileUrl,
+    });
+  });
+
+  it('should throw error remove file', async () => {
+    const service = await getService();
+
+    expect(() => service.remove()).to.throw('Use files.file.remove instead.');
+  });
+
+  it('should throw update file', async () => {
+    const service = await getService();
+
+    expect(() => service.remove()).to.throw('Use files.file.remove instead.');
+  });
+});

microservices/files/__tests__/services/file/factory-test.ts

@@ -1,9 +1,12 @@
 import { RemoteConfig } from '@lomray/microservice-helpers';
 import { TypeormMock } from '@lomray/microservice-helpers/mocks';
+import { waitResult } from '@lomray/microservice-helpers/test-helpers';
 import { expect } from 'chai';
 import sinon from 'sinon';
+import { bucketNameMock } from '@__mocks__/common';
 import FileType from '@constants/file-type';
 import AnyFile from '@services/file/any-file';
+import EmptyFile from '@services/file/empty-file';
 import Factory from '@services/file/factory';
 import Image from '@services/file/image';
 import StorageFactory from '@services/storage/factory';
@@ -41,4 +44,21 @@ describe('services/file/factory', () => {
 
     expect(service).instanceof(AnyFile);
   });
+
+  it('should successful create EmptyFile instance', async () => {
+    sandbox.stub(RemoteConfig, 'get').resolves({});
+    sandbox.stub(StorageFactory, 'create');
+
+    const service = await Factory.create(FileType.video, TypeormMock.entityManager, true);
+
+    expect(service).instanceof(EmptyFile);
+  });
+
+  it('should throw error: unknown type', async () => {
+    sandbox.stub(RemoteConfig, 'get').resolves({ s3: { bucketName: bucketNameMock } });
+    // @ts-ignore
+    const service = Factory.create('unknown', TypeormMock.entityManager);
+
+    expect(await waitResult(service)).to.throw('Unknown file type.');
+  });
 });

microservices/files/package-lock.json

@@ -47,12 +47,14 @@
 		"class-validator-jsonschema": "^5.0.0",
 		"file-type": "^16.5.4",
 		"mime": "^3.0.0",
+		"mime-types": "^2.1.35",
 		"sharp": "^0.32.1",
 		"typeorm": "0.2.41",
 		"uuid": "^9.0.0"
 	},
 	"devDependencies": {
 		"@types/mime": "^3.0.1",
+		"@types/mime-types": "^2.1.1",
 		"@types/node": "^18.13.0",
 		"@types/uuid": "^9.0.1"
 	},

microservices/files/package.json

@@ -1,12 +1,51 @@
-import { Endpoint } from '@lomray/microservice-helpers';
-import { getRepository } from 'typeorm';
+import { Endpoint, IsUndefinable } from '@lomray/microservice-helpers';
+import { Type } from 'class-transformer';
+import { IsEnum, IsObject, Length } from 'class-validator';
+import { getManager } from 'typeorm';
+import FileType from '@constants/file-type';
 import File from '@entities/file';
+import Factory from '@services/file/factory';
+import FilePostProcess from '@services/file-post-process';
+
+class FileCreateEmptyInput {
+  @IsEnum(FileType)
+  type: FileType;
+
+  @Length(3)
+  fileName: string;
+
+  @Length(1, 36)
+  @IsUndefinable()
+  userId: string;
+
+  @Length(1, 150)
+  @IsUndefinable()
+  alt: string;
+}
+
+class FileCreateEmptyOutput {
+  @IsObject()
+  @Type(() => File)
+  entity: File;
+}
 
 /**
  * Create empty file
  */
-const create = Endpoint.create(() => ({
-  repository: getRepository(File),
-}));
+const createEmpty = Endpoint.custom(
+  () => ({
+    input: FileCreateEmptyInput,
+    output: FileCreateEmptyOutput,
+    description: 'Create empty file',
+  }),
+  async ({ type, fileName, alt, userId, payload }) => {
+    const service = await Factory.create(type, getManager(), true);
+    const file = await service.save(fileName, userId, alt);
+
+    return {
+      entity: await FilePostProcess.handle(file, payload),
+    };
+  },
+);
 
-export default create;
+export default createEmpty;

microservices/files/src/methods/file/create-empty.ts

@@ -40,9 +40,10 @@ const create = Endpoint.custom(
   }),
   async ({ type, file, userId, alt, payload }) => {
     const service = await Factory.create(type, getManager());
+    const entity = await service.save(file, userId, alt);
 
     return {
-      entity: await FilePostProcess.handle(await service.save(file, userId, alt), payload),
+      entity: await FilePostProcess.handle(entity, payload),
     };
   },
 );

microservices/files/src/methods/file/create.ts

@@ -49,9 +49,10 @@ const update = Endpoint.custom(
     }
 
     const service = await Factory.create(fileEntity.type, manager);
+    const entity = await service.update(fileEntity, file, alt);
 
     return {
-      entity: await FilePostProcess.handle(await service.update(fileEntity, file, alt), payload),
+      entity: await FilePostProcess.handle(entity, payload),
     };
   },
 );

microservices/files/src/methods/file/update.ts

@@ -23,6 +23,7 @@ class AnyFile extends Abstract {
       const fileRepository = transactionManager.getRepository(File);
       const fileEntity = await fileRepository.save(
         fileRepository.create({ userId, alt, url: '/', type: this.type }),
+        { listeners: false },
       );
 
       const { fileData, fileBuffer } = await this.composeData(file, fileEntity.id);