fix(cat): Remove unnecessary code

Author: adrianmjim

src/cat/fixtures/infrastructure/mikroOrm/command/CatSetQueryMikroOrmFixtures.ts

@@ -1,10 +1,29 @@
 import { EntityData } from '@mikro-orm/core';
 
 import { CatMikroOrm } from '../../../../infrastructure/mikroOrm/model/CatMikroOrm';
+import { CatFixtures } from '../../../domain/model/CatFixtures';
 
 export class CatSetQueryMikroOrmFixtures {
-  public static get any(): EntityData<CatMikroOrm> {
-    const CatSetQueryMikroOrm: EntityData<CatMikroOrm> = {};
+  public static get withBornDate(): EntityData<CatMikroOrm> {
+    const CatSetQueryMikroOrm: EntityData<CatMikroOrm> = {
+      bornDate: CatFixtures.any.bornDate,
+    };
+
+    return CatSetQueryMikroOrm;
+  }
+
+  public static get withColor(): EntityData<CatMikroOrm> {
+    const CatSetQueryMikroOrm: EntityData<CatMikroOrm> = {
+      color: CatFixtures.any.color,
+    };
+
+    return CatSetQueryMikroOrm;
+  }
+
+  public static get withName(): EntityData<CatMikroOrm> {
+    const CatSetQueryMikroOrm: EntityData<CatMikroOrm> = {
+      name: CatFixtures.any.name,
+    };
 
     return CatSetQueryMikroOrm;
   }

src/cat/infrastructure/mikroOrm/converter/CatFindQueryToCatFindQueryMikroOrmConverterAsync.ts

@@ -15,10 +15,10 @@ export class CatFindQueryToCatFindQueryMikroOrmConverterAsync extends BaseEntity
     _input: CatFindQuery,
     baseEntityFindQueryMikroOrm: ObjectQuery<BaseEntityMikroOrm>,
   ): Promise<ObjectQuery<CatMikroOrm>> {
-    const CatFindQueryMikroOrm: ObjectQuery<CatMikroOrm> = {
+    const catFindQueryMikroOrm: ObjectQuery<CatMikroOrm> = {
       ...(baseEntityFindQueryMikroOrm as ObjectQuery<CatMikroOrm>),
     };
 
-    return CatFindQueryMikroOrm;
+    return catFindQueryMikroOrm;
   }
 }

src/cat/infrastructure/mikroOrm/converter/CatSetCommandToCatSetQueryMikroOrmConverterAsync.spec.ts

@@ -14,20 +14,60 @@ describe(CatSetCommandToCatSetQueryMikroOrmConverterAsync.name, () => {
   });
 
   describe('.convert()', () => {
-    describe('when called', () => {
-      let catSetCommandFixture: CatSetCommand;
-      let catSetQueryMikroOrmFixture: EntityData<CatMikroOrm>;
-      let result: unknown;
+    describe('having a CatSetCommand with bornDate', () => {
+      describe('when called', () => {
+        let catSetCommandFixture: CatSetCommand;
+        let catSetQueryMikroOrmFixture: EntityData<CatMikroOrm>;
+        let result: unknown;
 
-      beforeAll(async () => {
-        catSetCommandFixture = CatSetCommandFixtures.any;
-        catSetQueryMikroOrmFixture = CatSetQueryMikroOrmFixtures.any;
+        beforeAll(async () => {
+          catSetCommandFixture = CatSetCommandFixtures.withBornDate;
+          catSetQueryMikroOrmFixture = CatSetQueryMikroOrmFixtures.withBornDate;
 
-        result = await catSetCommandToCatSetQueryMikroOrmConverterAsync.convert(catSetCommandFixture);
+          result = await catSetCommandToCatSetQueryMikroOrmConverterAsync.convert(catSetCommandFixture);
+        });
+
+        it('should return a EntityData<CatMikroOrm>', () => {
+          expect(result).toStrictEqual(catSetQueryMikroOrmFixture);
+        });
       });
+    });
+
+    describe('having a CatSetCommand with color', () => {
+      describe('when called', () => {
+        let catSetCommandFixture: CatSetCommand;
+        let catSetQueryMikroOrmFixture: EntityData<CatMikroOrm>;
+        let result: unknown;
+
+        beforeAll(async () => {
+          catSetCommandFixture = CatSetCommandFixtures.withColor;
+          catSetQueryMikroOrmFixture = CatSetQueryMikroOrmFixtures.withColor;
+
+          result = await catSetCommandToCatSetQueryMikroOrmConverterAsync.convert(catSetCommandFixture);
+        });
+
+        it('should return a EntityData<CatMikroOrm>', () => {
+          expect(result).toStrictEqual(catSetQueryMikroOrmFixture);
+        });
+      });
+    });
+
+    describe('having a CatSetCommand with name', () => {
+      describe('when called', () => {
+        let catSetCommandFixture: CatSetCommand;
+        let catSetQueryMikroOrmFixture: EntityData<CatMikroOrm>;
+        let result: unknown;
+
+        beforeAll(async () => {
+          catSetCommandFixture = CatSetCommandFixtures.withName;
+          catSetQueryMikroOrmFixture = CatSetQueryMikroOrmFixtures.withName;
+
+          result = await catSetCommandToCatSetQueryMikroOrmConverterAsync.convert(catSetCommandFixture);
+        });
 
-      it('should return a EntityData<CatMikroOrm>', () => {
-        expect(result).toStrictEqual(catSetQueryMikroOrmFixture);
+        it('should return a EntityData<CatMikroOrm>', () => {
+          expect(result).toStrictEqual(catSetQueryMikroOrmFixture);
+        });
       });
     });
   });

src/cat/infrastructure/mikroOrm/converter/CatSetCommandToCatSetQueryMikroOrmConverterAsync.ts

@@ -19,11 +19,17 @@ export class CatSetCommandToCatSetQueryMikroOrmConverterAsync extends BaseEntity
       ...baseEntitySetQueryMikroOrm,
     };
 
-    this.setPropertyIfNotUndefined(input, catSetQueryMikroOrm, 'bornDate', 'bornDate');
+    if (input.bornDate !== undefined) {
+      catSetQueryMikroOrm.bornDate = input.bornDate;
+    }
 
-    this.setPropertyIfNotUndefined(input, catSetQueryMikroOrm, 'color', 'color');
+    if (input.color !== undefined) {
+      catSetQueryMikroOrm.color = input.color;
+    }
 
-    this.setPropertyIfNotUndefined(input, catSetQueryMikroOrm, 'name', 'name');
+    if (input.name !== undefined) {
+      catSetQueryMikroOrm.name = input.name;
+    }
 
     return catSetQueryMikroOrm;
   }

src/common/infrastructure/mikroOrm/converter/BaseEntityFindQueryToBaseEntityFindQueryMikroOrmConverterAsync.ts

@@ -30,17 +30,6 @@ export abstract class BaseEntityFindQueryToBaseEntityFindQueryMikroOrmConverterA
     return baseEntityFindQueryMikroOrm;
   }
 
-  protected setPropertyIfNotUndefined(
-    input: TInput,
-    findQueryMikroOrm: TOutput,
-    queryProperty: keyof TInput,
-    entityProperty: keyof TOutput,
-  ): void {
-    if (input[queryProperty] !== undefined) {
-      findQueryMikroOrm[entityProperty] = input[queryProperty] as unknown as TOutput[keyof TOutput];
-    }
-  }
-
   protected abstract convertToSpecificEntityFindQueryMikroOrm(
     input: TInput,
     baseEntityFindQueryMikroOrm: ObjectQuery<BaseEntityMikroOrm>,

src/common/infrastructure/mikroOrm/converter/BaseEntitySetCommandToBaseEntitySetQueryMikroOrmConverterAsync.ts

@@ -26,17 +26,6 @@ export abstract class BaseEntitySetCommandToBaseEntitySetQueryMikroOrmConverterA
     return output;
   }
 
-  protected setPropertyIfNotUndefined(
-    input: TInput,
-    setQueryMikroOrm: TOutput,
-    commandProperty: keyof TInput,
-    entityProperty: keyof TOutput,
-  ): void {
-    if (input[commandProperty] !== undefined) {
-      setQueryMikroOrm[entityProperty] = input[commandProperty] as unknown as TOutput[keyof TOutput];
-    }
-  }
-
   protected abstract convertToSpecificEntitySetQueryMikroOrm(
     input: TInput,
     baseEntitySetQueryMikroOrm: EntityData<BaseEntityMikroOrm>,