fix(query-typeorm): Fixed getManyToManyOwnerMeta

It was not add the select correctly and mapping the raw relations back

Author: TriPSs

examples/jest.config.ts

@@ -19,7 +19,8 @@
         "coverage/examples"
       ],
       "options": {
-        "jestConfig": "examples/jest.config.ts"
+        "jestConfig": "jest.e2e.ts",
+        "runInBand": true
       }
     }
   },

examples/project.json

@@ -0,0 +1,20 @@
+module.exports = {
+  displayName: 'examples',
+  preset: './jest.preset.ts',
+  globals: {
+    'ts-jest': {
+      tsconfig: './examples/tsconfig.spec.json'
+    }
+  },
+  testEnvironment: 'node',
+  transform: {
+    '^.+\\.[tj]s$': 'ts-jest'
+  },
+  moduleFileExtensions: ['ts', 'js', 'html'],
+  testMatch: ['**/e2e/**/*.spec.ts'],
+
+  setupFilesAfterEnv: ['jest-extended'],
+  snapshotSerializers: ['jest-snapshot-serializer-raw/always'],
+
+  coverageDirectory: '../coverage/examples'
+};

jest.e2e.config.js

@@ -5,15 +5,15 @@ module.exports = {
 
   collectCoverage: true,
   coverageReporters: ['html', 'clover'],
-  collectCoverageFrom: [
-    '!**/node_modules/**',
-    'src/**',
-    '!**/__snapshots__/**',
-    '!**/*.test.js',
-    '!**/index.ts',
-    '!**/*.json'
-  ],
-
+  collectCoverageFrom: ['packages/**/*.ts', '!**/__tests__/**', '!**/dist/**', '!**/node_modules/**'],
+  moduleNameMapper: {
+    '@ptc-org/nestjs-query-core': '<rootDir>/packages/core/src',
+    '@ptc-org/nestjs-query-graphql': '<rootDir>/packages/query-graphql/src',
+    '@ptc-org/nestjs-query-typeorm': '<rootDir>/packages/query-typeorm/src',
+    '@ptc-org/nestjs-query-sequelize': '<rootDir>/packages/query-sequelize/src',
+    '@ptc-org/nestjs-query-typegoose': '<rootDir>/packages/query-typegoose/src',
+    '@ptc-org/nestjs-query-mongoose': '<rootDir>/packages/query-mongoose/src',
+  },
   testEnvironment: 'node',
   setupFilesAfterEnv: ['jest-extended'],
   snapshotSerializers: ['jest-snapshot-serializer-raw/always']

jest.e2e.ts

@@ -23,7 +23,7 @@ export const isBooleanComparisonOperators = (op: unknown): op is BooleanComparis
   op === 'eq' || op === 'neq' || op === 'is' || op === 'isNot';
 
 export const isComparison = <DTO, K extends keyof DTO>(
-  maybeComparison?: FilterFieldComparison<DTO[K]> | Filter<DTO[K]>,
+  maybeComparison?: FilterFieldComparison<DTO[K]> | Filter<DTO[K]>
 ): maybeComparison is FilterFieldComparison<DTO[K]> => {
   if (!maybeComparison) {
     return false;
@@ -35,19 +35,19 @@ export const isComparison = <DTO, K extends keyof DTO>(
       isInComparisonOperators(op) ||
       isBetweenComparisonOperators(op) ||
       isRangeComparisonOperators(op) ||
-      isBooleanComparisonOperators(op),
+      isBooleanComparisonOperators(op)
   );
 };
 
 // TODO: test
 export const getFilterFieldComparison = <DTO, K extends keyof FilterComparisons<DTO>>(
   obj: FilterComparisons<DTO>,
-  field: K,
+  field: K
 ): FilterFieldComparison<DTO[K]> & Filter<DTO[K]> => obj[field] as FilterFieldComparison<DTO[K]> & Filter<DTO[K]>;
 
 export const transformFilter = <From, To>(
   filter: Filter<From> | undefined,
-  fieldMap: QueryFieldMap<From, To>,
+  fieldMap: QueryFieldMap<From, To>
 ): Filter<To> | undefined => {
   if (!filter) {
     return undefined;
@@ -79,33 +79,40 @@ export const getFilterFields = <DTO>(filter: Filter<DTO>): string[] => {
   const fieldSet: Set<string> = Object.keys(filter).reduce((fields: Set<string>, filterField: string): Set<string> => {
     if (filterField === 'and' || filterField === 'or') {
       const andOrFilters = filter[filterField];
+
       if (andOrFilters !== undefined) {
         return andOrFilters.reduce(
           (andOrFields, andOrFilter) => new Set<string>([...andOrFields, ...getFilterFields(andOrFilter)]),
-          fields,
+          fields
         );
       }
+
     } else {
       fields.add(filterField);
     }
+
     return fields;
   }, new Set<string>());
+
   return [...fieldSet];
 };
 
 export const getFilterComparisons = <DTO, K extends keyof FilterComparisons<DTO>>(
   filter: Filter<DTO>,
-  key: K,
+  key: K
 ): FilterFieldComparison<DTO[K]>[] => {
   const results: FilterFieldComparison<DTO[K]>[] = [];
+
   if (filter.and || filter.or) {
     const filters = [...(filter.and ?? []), ...(filter.or ?? [])];
     filters.forEach((f) => getFilterComparisons(f, key).forEach((comparison) => results.push(comparison)));
   }
+
   const comparison = getFilterFieldComparison(filter as FilterComparisons<DTO>, key);
   if (isComparison(comparison)) {
     results.push(comparison);
   }
+
   return [...results];
 };
 

jest.preset.ts

@@ -1,6 +1,6 @@
 {
   "name": "@ptc-org/nestjs-query-typeorm",
-  "version": "1.0.0-alpha.1",
+  "version": "1.0.0-alpha.2",
   "description": "Typeorm adapter for @ptc-org/nestjs-query-core",
   "author": "doug-martin <[email protected]>",
   "homepage": "https://github.com/tripss/nestjs-query#readme",

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

@@ -383,10 +383,9 @@ export class RelationQueryBuilder<Entity, Relation> {
         // First filter the raw relations with the PK of the entity, then filter the relations
         // with the PK of the raw relation
         return lodashFilter(rawRelations, rawFilter).reduce((entityRelations, rawRelation) => {
-          const filter = relation.inverseJoinColumns.reduce((columns, column) => ({
+          const filter = this.getRelationPrimaryKeysPropertyNameAndColumnsName().reduce((columns, column) => ({
             ...columns,
-
-            [column.referencedColumn.propertyName]: rawRelation[`${joinAlias}_${column.propertyName}`]
+            [column.propertyName]: rawRelation[column.columnName]
           }), {} as Partial<Entity>);
 
           return entityRelations.concat(lodashFilter(relations, filter) as any);
@@ -402,7 +401,7 @@ export class RelationQueryBuilder<Entity, Relation> {
           params[paramName] = entities.map((entity) => column.referencedColumn!.getEntityValue(entity));
 
           // We also want to select the field, so we can map them back in the mapper
-          andSelect.push(`${joinAlias}.${column.propertyName}`);
+          andSelect.push(`${joinAlias}.${column.propertyName} AS ${joinAlias}_${column.propertyName}`);
           return `${joinAlias}.${column.propertyName} IN (:...${paramName})`;
         }).join(' AND ');
 
@@ -489,7 +488,7 @@ export class RelationQueryBuilder<Entity, Relation> {
           params[paramName] = entities.map((entity) => column.referencedColumn!.getEntityValue(entity));
 
           // We also want to select the field, so we can map them back in the mapper
-          andSelect.push(`${joinAlias}.${column.propertyName}`);
+          andSelect.push(`${joinAlias}.${column.propertyName} AS ${joinAlias}_${column.propertyName}`);
           return `${joinAlias}.${column.propertyName} IN (:...${paramName})`;
         }).join(' AND ');
 

packages/query-typeorm/package.json

@@ -0,0 +1,17 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist/out-tsc",
+    "module": "commonjs",
+    "types": [
+      "jest",
+      "node"
+    ]
+  },
+  "include": [
+    "jest.config.ts",
+    "**/*.test.ts",
+    "**/*.spec.ts",
+    "**/*.d.ts"
+  ]
+}