Force UTC timezone to make some tests (e.g. typeorm-query-service.spec) deterministic

Implement type-based custom filters + field specific custom filters
Filter registration through decorators performed on module initialization
Tests

Author: luca-nardelli

package.json

@@ -14,9 +14,9 @@
     "lint": "eslint --cache --ext=.ts .",
     "lint:no-cache": "eslint --ext=.ts .",
     "lint:fix": "eslint --fix --ext=.ts .",
-    "jest": "jest --runInBand --coverage",
-    "jest:e2e": "jest --runInBand --config=./jest.e2e.config.js",
-    "jest:unit": "jest --coverage --config=./jest.unit.config.js",
+    "jest": "TZ=UTC jest --runInBand --coverage",
+    "jest:e2e": "TZ=UTC jest --runInBand --config=./jest.e2e.config.js",
+    "jest:unit": "TZ=UTC jest --coverage --config=./jest.unit.config.js",
     "coverage": "cat ./coverage/lcov.info | coveralls",
     "prepare": "husky install"
   },

packages/core/src/helpers/filter.builder.ts

@@ -58,6 +58,6 @@ export class FilterBuilder {
       throw new Error(`unknown comparison ${JSON.stringify(fieldOrNested)}`);
     }
     const nestedFilterFn = this.build(value);
-    return (dto?: DTO) => nestedFilterFn(dto ? dto[fieldOrNested] : null);
+    return (dto?: DTO) => nestedFilterFn(dto ? dto[fieldOrNested] : undefined);
   }
 }

packages/core/src/interfaces/filter.interface.ts

@@ -111,5 +111,6 @@ type FilterGrouping<T> = {
  * ```
  *
  * @typeparam T - the type of object to filter on.
+ * @typeparam C - custom filters defined on the object.
  */
-export type Filter<T> = FilterGrouping<T> & FilterComparisons<T>;
+export type Filter<T, C = Record<string, any>> = FilterGrouping<T> & FilterComparisons<T> & { [K in keyof C]: C[K] };

packages/query-typeorm/__tests__/__fixtures__/connection.fixture.ts

@@ -16,8 +16,13 @@ export const CONNECTION_OPTIONS: ConnectionOptions = {
   logging: false,
 };
 
-export function createTestConnection(): Promise<Connection> {
-  return createConnection(CONNECTION_OPTIONS);
+// eslint-disable-next-line @typescript-eslint/ban-types
+export function createTestConnection(opts?: { extraEntities: (string | Function)[] }): Promise<Connection> {
+  const connOpts: ConnectionOptions = {
+    ...CONNECTION_OPTIONS,
+    entities: [...(CONNECTION_OPTIONS.entities || []), ...(opts?.extraEntities ?? [])],
+  };
+  return createConnection(connOpts);
 }
 
 export function closeTestConnection(): Promise<void> {

packages/query-typeorm/__tests__/__fixtures__/custom-filters.services.ts

@@ -0,0 +1,63 @@
+import { ColumnType } from 'typeorm';
+import { randomString } from '../../src/common';
+import { CustomFilter, CustomFilterResult } from '../../src/query/custom-filter.registry';
+import { TypeOrmQueryFilter } from '../../src/decorators/typeorm-query-filter.decorator';
+
+type IsMultipleOfOpType = 'isMultipleOf';
+
+@TypeOrmQueryFilter()
+export class IsMultipleOfCustomFilter implements CustomFilter<IsMultipleOfOpType> {
+  readonly operations: IsMultipleOfOpType[] = ['isMultipleOf'];
+
+  readonly types: ColumnType[] = [Number, 'integer'];
+
+  apply(field: string, cmp: IsMultipleOfOpType, val: unknown, alias?: string): CustomFilterResult {
+    alias = alias ? alias : '';
+    const pname = `param${randomString()}`;
+    return {
+      sql: `(${alias}.${field} % :${pname}) == 0`,
+      params: { [pname]: val },
+    };
+  }
+}
+
+@TypeOrmQueryFilter()
+export class IsMultipleOfDateCustomFilter implements CustomFilter<IsMultipleOfOpType> {
+  readonly operations: IsMultipleOfOpType[] = ['isMultipleOf'];
+
+  readonly types: ColumnType[] = [Date, 'date', 'datetime'];
+
+  apply(field: string, cmp: IsMultipleOfOpType, val: unknown, alias?: string): CustomFilterResult {
+    alias = alias ? alias : '';
+    const pname = `param${randomString()}`;
+    return {
+      sql: `(EXTRACT(EPOCH FROM ${alias}.${field}) / 3600 / 24) % :${pname}) == 0`,
+      params: { [pname]: val },
+    };
+  }
+}
+
+type RadiusCustomFilterOp = 'distanceFrom';
+
+@TypeOrmQueryFilter({
+  autoRegister: false,
+})
+export class RadiusCustomFilter implements CustomFilter<RadiusCustomFilterOp> {
+  readonly operations: RadiusCustomFilterOp[] = ['distanceFrom'];
+
+  apply(
+    field: string,
+    cmp: RadiusCustomFilterOp,
+    val: { point: { lat: number; lng: number }; radius: number },
+    alias?: string,
+  ): CustomFilterResult {
+    alias = alias ? alias : '';
+    const plat = `param${randomString()}`;
+    const plng = `param${randomString()}`;
+    const prad = `param${randomString()}`;
+    return {
+      sql: `ST_Distance(${alias}.${field}, ST_MakePoint(:${plat},:${plng})) <= :${prad}`,
+      params: { [plat]: val.point.lat, [plng]: val.point.lng, [prad]: val.radius },
+    };
+  }
+}

packages/query-typeorm/__tests__/__fixtures__/seeds.ts

@@ -23,30 +23,33 @@ export const TEST_SOFT_DELETE_ENTITIES: TestSoftDeleteEntity[] = [1, 2, 3, 4, 5,
   };
 });
 
-export const TEST_RELATIONS: TestRelation[] = TEST_ENTITIES.reduce(
-  (relations, te) => [
+// Generate different numberTypes so we can use them for filters later on
+export const TEST_RELATIONS: TestRelation[] = TEST_ENTITIES.reduce((relations, te) => {
+  return [
     ...relations,
     {
       testRelationPk: `test-relations-${te.testEntityPk}-1`,
       relationName: `${te.stringType}-test-relation-one`,
       testEntityId: te.testEntityPk,
       uniDirectionalTestEntityId: te.testEntityPk,
+      numberType: te.numberType * 10 + 1,
     },
     {
       testRelationPk: `test-relations-${te.testEntityPk}-2`,
       relationName: `${te.stringType}-test-relation-two`,
       testEntityId: te.testEntityPk,
       uniDirectionalTestEntityId: te.testEntityPk,
+      numberType: te.numberType * 10 + 2,
     },
     {
       testRelationPk: `test-relations-${te.testEntityPk}-3`,
       relationName: `${te.stringType}-test-relation-three`,
       testEntityId: te.testEntityPk,
       uniDirectionalTestEntityId: te.testEntityPk,
+      numberType: te.numberType * 10 + 3,
     },
-  ],
-  [] as TestRelation[],
-);
+  ];
+}, [] as TestRelation[]);
 
 export const TEST_RELATIONS_OF_RELATION = TEST_RELATIONS.map<Partial<RelationOfTestRelationEntity>>((testRelation) => ({
   relationName: `test-relation-of-${testRelation.relationName}`,

packages/query-typeorm/__tests__/__fixtures__/test-relation.entity.ts

@@ -1,4 +1,4 @@
-import { ManyToOne, Column, Entity, JoinColumn, ManyToMany, OneToOne, OneToMany, PrimaryColumn } from 'typeorm';
+import { Column, Entity, JoinColumn, ManyToMany, ManyToOne, OneToMany, OneToOne, PrimaryColumn } from 'typeorm';
 import { TestEntityRelationEntity } from './test-entity-relation.entity';
 import { TestEntity } from './test.entity';
 import { RelationOfTestRelationEntity } from './relation-of-test-relation.entity';
@@ -17,6 +17,9 @@ export class TestRelation {
   @Column({ name: 'uni_directional_test_entity_id', nullable: true })
   uniDirectionalTestEntityId?: string;
 
+  @Column({ name: 'number_type' })
+  numberType?: number;
+
   @ManyToOne(() => TestEntity, (te) => te.testRelations, { onDelete: 'CASCADE' })
   @JoinColumn({ name: 'test_entity_id' })
   testEntity?: TestEntity;

packages/query-typeorm/__tests__/__fixtures__/test.entity.ts

@@ -1,8 +1,14 @@
-import { Column, Entity, OneToMany, ManyToMany, JoinTable, OneToOne, JoinColumn, PrimaryColumn } from 'typeorm';
+import { Column, Entity, JoinColumn, JoinTable, ManyToMany, OneToMany, OneToOne, PrimaryColumn } from 'typeorm';
+import { WithTypeormQueryFilter } from '../../src/decorators/with-typeorm-entity-query-filter.decorator';
+import { RadiusCustomFilter } from './custom-filters.services';
 import { TestEntityRelationEntity } from './test-entity-relation.entity';
 import { TestRelation } from './test-relation.entity';
 
 @Entity()
+@WithTypeormQueryFilter<TestEntity>({
+  filter: RadiusCustomFilter,
+  fields: ['fakePointType'],
+})
 export class TestEntity {
   @PrimaryColumn({ name: 'test_entity_pk' })
   testEntityPk!: string;

packages/query-typeorm/__tests__/metadata/typeorm-metadata.spec.ts

@@ -0,0 +1,73 @@
+import { Column, Entity, PrimaryColumn } from 'typeorm';
+import { getQueryTypeormMetadata, QueryTypeormEntityMetadata } from '../../src/common';
+import { closeTestConnection, createTestConnection, getTestConnection } from '../__fixtures__/connection.fixture';
+import { TestEntityRelationEntity } from '../__fixtures__/test-entity-relation.entity';
+import { TestRelation } from '../__fixtures__/test-relation.entity';
+import { TestEntity } from '../__fixtures__/test.entity';
+
+describe('TypeormMetadata', (): void => {
+  class TestEmbedded {
+    @Column({ type: 'text' })
+    stringType!: string;
+
+    @Column({ type: 'boolean' })
+    boolType!: boolean;
+  }
+
+  @Entity()
+  class TestMetadataEntity {
+    @PrimaryColumn({ type: 'text' })
+    pk!: string;
+
+    @Column({ type: 'text' })
+    stringType!: string;
+
+    @Column({ type: 'boolean' })
+    boolType!: boolean;
+
+    @Column({ type: 'integer' })
+    numberType!: number;
+
+    @Column({ type: 'date' })
+    dateType!: Date;
+
+    @Column({ type: 'datetime' })
+    datetimeType!: Date;
+
+    @Column({ type: 'simple-json' })
+    jsonType!: any;
+
+    @Column(() => TestEmbedded)
+    embeddedType!: TestEmbedded;
+  }
+
+  beforeEach(() => createTestConnection({ extraEntities: [TestMetadataEntity] }));
+  afterEach(() => closeTestConnection());
+
+  it('Test metadata', (): void => {
+    const meta = getQueryTypeormMetadata(getTestConnection());
+    console.log(meta);
+    // Implicit column types
+    expect(meta.get(TestEntity)).toMatchObject({
+      testEntityPk: { metaType: 'property', type: String },
+      stringType: { metaType: 'property', type: String },
+      dateType: { metaType: 'property', type: Date },
+      boolType: { metaType: 'property', type: Boolean },
+      oneTestRelation: { metaType: 'relation', type: TestRelation },
+      testRelations: { metaType: 'relation', type: TestRelation },
+      manyTestRelations: { metaType: 'relation', type: TestRelation },
+      manyToManyUniDirectional: { metaType: 'relation', type: TestRelation },
+      testEntityRelation: { metaType: 'relation', type: TestEntityRelationEntity },
+    } as QueryTypeormEntityMetadata<TestEntity>);
+    // Explicit column types
+    expect(meta.get(TestMetadataEntity)).toMatchObject({
+      pk: { metaType: 'property', type: 'text' },
+      stringType: { metaType: 'property', type: 'text' },
+      boolType: { metaType: 'property', type: 'boolean' },
+      numberType: { metaType: 'property', type: 'integer' },
+      dateType: { metaType: 'property', type: 'date' },
+      datetimeType: { metaType: 'property', type: 'datetime' },
+      jsonType: { metaType: 'property', type: 'simple-json' },
+    } as QueryTypeormEntityMetadata<TestMetadataEntity>);
+  });
+});

packages/query-typeorm/__tests__/module.spec.ts

@@ -3,10 +3,11 @@ import { NestjsQueryTypeOrmModule } from '../src';
 describe('NestjsQueryTypeOrmModule', () => {
   it('should create a module', () => {
     class TestEntity {}
+
     const typeOrmModule = NestjsQueryTypeOrmModule.forFeature([TestEntity]);
     expect(typeOrmModule.imports).toHaveLength(1);
     expect(typeOrmModule.module).toBe(NestjsQueryTypeOrmModule);
-    expect(typeOrmModule.providers).toHaveLength(1);
+    expect(typeOrmModule.providers).toHaveLength(3);
     expect(typeOrmModule.exports).toHaveLength(2);
   });
 });