feat(query-mikro-orm): export buildMikroOrmQuery

packages/query-mikro-orm/__tests__/query/build-mikro-orm-query.spec.ts

@@ -0,0 +1,107 @@
+import { buildMikroOrmQuery } from '../../src'
+
+interface E {
+  id: string
+  name: string
+  age: number
+  active: boolean
+}
+
+describe('buildMikroOrmQuery', () => {
+  it('returns empty object for undefined filter', () => {
+    expect(buildMikroOrmQuery<E>(undefined)).toEqual({})
+  })
+
+  it('returns empty object for empty filter', () => {
+    expect(buildMikroOrmQuery<E>({})).toEqual({})
+  })
+
+  it('translates eq', () => {
+    expect(buildMikroOrmQuery<E>({ name: { eq: 'foo' } })).toEqual({ name: { $eq: 'foo' } })
+  })
+
+  it('translates is', () => {
+    expect(buildMikroOrmQuery<E>({ active: { is: true } })).toEqual({ active: { $eq: true } })
+  })
+
+  it('translates neq', () => {
+    expect(buildMikroOrmQuery<E>({ name: { neq: 'foo' } })).toEqual({ name: { $ne: 'foo' } })
+  })
+
+  it('translates isNot', () => {
+    expect(buildMikroOrmQuery<E>({ active: { isNot: null } })).toEqual({ active: { $ne: null } })
+  })
+
+  it('translates gt/gte/lt/lte', () => {
+    expect(buildMikroOrmQuery<E>({ age: { gt: 1, gte: 2, lt: 10, lte: 9 } })).toEqual({
+      age: { $gt: 1, $gte: 2, $lt: 10, $lte: 9 }
+    })
+  })
+
+  it('translates in/notIn', () => {
+    expect(buildMikroOrmQuery<E>({ id: { in: ['a', 'b'], notIn: ['c'] } })).toEqual({
+      id: { $in: ['a', 'b'], $nin: ['c'] }
+    })
+  })
+
+  it('translates like/notLike', () => {
+    expect(buildMikroOrmQuery<E>({ name: { like: 'a%', notLike: 'b%' } })).toEqual({
+      name: { $like: 'a%', $not: { $like: 'b%' } }
+    })
+  })
+
+  it('translates iLike/notILike', () => {
+    expect(buildMikroOrmQuery<E>({ name: { iLike: 'a%', notILike: 'b%' } })).toEqual({
+      name: { $ilike: 'a%', $not: { $ilike: 'b%' } }
+    })
+  })
+
+  it('translates and', () => {
+    expect(
+      buildMikroOrmQuery<E>({
+        and: [{ age: { gt: 3 } }, { age: { lt: 7 } }]
+      })
+    ).toEqual({
+      $and: [{ age: { $gt: 3 } }, { age: { $lt: 7 } }]
+    })
+  })
+
+  it('translates or', () => {
+    expect(
+      buildMikroOrmQuery<E>({
+        or: [{ age: { eq: 1 } }, { age: { eq: 10 } }]
+      })
+    ).toEqual({
+      $or: [{ age: { $eq: 1 } }, { age: { $eq: 10 } }]
+    })
+  })
+
+  it('translates nested and/or', () => {
+    expect(
+      buildMikroOrmQuery<E>({
+        or: [{ and: [{ age: { gt: 1 } }, { age: { lt: 5 } }] }, { name: { eq: 'foo' } }]
+      })
+    ).toEqual({
+      $or: [{ $and: [{ age: { $gt: 1 } }, { age: { $lt: 5 } }] }, { name: { $eq: 'foo' } }]
+    })
+  })
+
+  it('throws when and/or is mixed with field comparisons', () => {
+    expect(() =>
+      buildMikroOrmQuery<E>({
+        and: [{ age: { gt: 1 } }],
+        name: { eq: 'foo' }
+      } as never)
+    ).toThrow('filter must contain either only `and` or `or` property, or other properties')
+  })
+
+  it('passes through unknown comparison keys recursively', () => {
+    expect(
+      buildMikroOrmQuery({
+        relation: { nested: { eq: 1 } }
+      } as never)
+    ).toEqual({
+      relation: { nested: { $eq: 1 } }
+    })
+  })
+})

packages/query-mikro-orm/src/index.ts

@@ -1,4 +1,5 @@
 export { MikroOrmAssembler } from './assemblers'
 export { NestjsQueryMikroOrmModule } from './module'
 export { createMikroOrmQueryServiceProviders, EntityServiceOptions } from './providers'
+export { buildMikroOrmQuery } from './query'
 export { MikroOrmQueryService } from './services'

packages/query-mikro-orm/src/query/build-mikro-orm-query.ts

@@ -0,0 +1,95 @@
+import { FilterQuery } from '@mikro-orm/core'
+import { OperatorMap } from '@mikro-orm/core/typings'
+import { Filter, FilterComparisons } from '@ptc-org/nestjs-query-core'
+
+function expandFilterComparison(k: string, v: unknown): [string, unknown] {
+  if (k === 'eq' || k === 'is') {
+    return ['$eq', v as string] satisfies ['$eq', OperatorMap<string>['$eq']]
+  }
+
+  if (k === 'neq' || k === 'isNot') {
+    return ['$ne', v as string] satisfies ['$ne', OperatorMap<string>['$ne']]
+  }
+
+  if (k === 'gt') {
+    return ['$gt', v as string] satisfies ['$gt', OperatorMap<string>['$gt']]
+  }
+
+  if (k === 'gte') {
+    return ['$gte', v as string] satisfies ['$gte', OperatorMap<string>['$gte']]
+  }
+
+  if (k === 'lt') {
+    return ['$lt', v as string] satisfies ['$lt', OperatorMap<string>['$lt']]
+  }
+
+  if (k === 'lte') {
+    return ['$lte', v as string] satisfies ['$lte', OperatorMap<string>['$lte']]
+  }
+
+  if (k === 'in') {
+    return ['$in', v as string[]] satisfies ['$in', OperatorMap<string>['$in']]
+  }
+
+  if (k === 'notIn') {
+    return ['$nin', v as string[]] satisfies ['$nin', OperatorMap<string>['$nin']]
+  }
+
+  if (k === 'like') {
+    return ['$like', v as string] satisfies ['$like', OperatorMap<string>['$like']]
+  }
+
+  if (k === 'notLike') {
+    return ['$not', { $like: v as string }]
+  }
+
+  if (k === 'iLike') {
+    return ['$ilike', v as string] satisfies ['$ilike', OperatorMap<string>['$ilike']]
+  }
+
+  if (k === 'notILike') {
+    return ['$not', { $ilike: v as string }]
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-use-before-define
+  return [k, expandFilter(v as FilterComparisons<unknown>)]
+}
+
+function expandFilter<E>(comparisons: FilterComparisons<unknown>): FilterQuery<E> {
+  const entries = Object.entries(comparisons).map(([k, v]) => expandFilterComparison(k, v))
+  return Object.fromEntries(entries) as FilterQuery<E>
+}
+
+/**
+ * Translate a nestjs-query `Filter<E>` into a MikroORM `FilterQuery<E>`.
+ *
+ * Pure function — no entity metadata, no repository, no assembler.
+ * The input is expected to already reference entity fields (run any DTO→Entity
+ * conversion such as an assembler's `convertQuery` before calling this).
+ *
+ * Consumers outside nestjs-query resolvers (custom resolvers, domain services)
+ * use this to reuse the same filter dialect the `@Authorize` pipeline produces.
+ */
+export function buildMikroOrmQuery<E>(filter: Filter<E> | undefined): FilterQuery<E> {
+  if (!filter) {
+    return {} as FilterQuery<E>
+  }
+
+  if ((filter.and || filter.or) && Object.keys(filter).length > 1) {
+    throw new Error('filter must contain either only `and` or `or` property, or other properties')
+  }
+
+  if (filter.and) {
+    return {
+      $and: filter.and.map((f) => buildMikroOrmQuery(f))
+    } as FilterQuery<E>
+  }
+
+  if (filter.or) {
+    return {
+      $or: filter.or.map((f) => buildMikroOrmQuery(f))
+    } as FilterQuery<E>
+  }
+
+  return expandFilter<E>(filter as FilterComparisons<unknown>)
+}

packages/query-mikro-orm/src/query/index.ts

@@ -0,0 +1 @@
+export { buildMikroOrmQuery } from './build-mikro-orm-query'

packages/query-mikro-orm/src/services/mikro-orm-query.service.ts

@@ -1,15 +1,4 @@
-import {
-  Collection,
-  EntityData,
-  EntityKey,
-  EntityRepository,
-  FilterQuery,
-  QueryOrder,
-  QueryOrderMap,
-  Reference,
-  wrap
-} from '@mikro-orm/core'
-import { OperatorMap } from '@mikro-orm/core/typings'
+import { Collection, EntityKey, EntityRepository, FilterQuery, QueryOrder, QueryOrderMap, Reference, wrap } from '@mikro-orm/core'
 import {
   AggregateOptions,
   AggregateQuery,
@@ -23,7 +12,6 @@ import {
   DeleteManyResponse,
   DeleteOneOptions,
   Filter,
-  FilterComparisons,
   FindByIdOptions,
   FindRelationOptions,
   GetByIdOptions,
@@ -38,6 +26,8 @@ import {
   UpdateOneOptions
 } from '@ptc-org/nestjs-query-core'
 
+import { buildMikroOrmQuery } from '../query'
+
 export class MikroOrmQueryService<DTO extends object, Entity extends object = DTO> extends NoOpQueryService<DTO, Entity> {
   constructor(
     protected repo: EntityRepository<Entity>,
@@ -352,84 +342,7 @@ export class MikroOrmQueryService<DTO extends object, Entity extends object = DT
     }
 
     const convertedFilter = this.assembler?.convertQuery?.({ filter } as Query<DTO>)?.filter ?? filter
-
-    if ((convertedFilter?.and || convertedFilter?.or) && Object.keys(convertedFilter).length > 1) {
-      throw new Error('filter must contain either only `and` or `or` property, or other properties')
-    }
-
-    if (convertedFilter?.and) {
-      return {
-        $and: convertedFilter.and.map((f) => this.convertFilter(f as Filter<DTO> | Filter<Entity>))
-      } as FilterQuery<Entity>
-    }
-
-    if (convertedFilter?.or) {
-      return {
-        $or: convertedFilter.or.map((f) => this.convertFilter(f as Filter<DTO> | Filter<Entity>))
-      } as FilterQuery<Entity>
-    }
-
-    return this.expandFilter(convertedFilter)
-  }
-
-  protected expandFilter(comparisons: FilterComparisons<unknown>): FilterQuery<Entity> {
-    const filters = Object.entries(comparisons).map(([k, v]) => {
-      return this.expandFilterComparison(k, v)
-    })
-
-    return Object.fromEntries(filters) as FilterQuery<Entity>
-  }
-
-  protected expandFilterComparison(k: string, v: unknown): [string, unknown] {
-    if (k === 'eq' || k === 'is') {
-      return ['$eq', v as string] satisfies ['$eq', OperatorMap<string>['$eq']]
-    }
-
-    if (k === 'neq' || k === 'isNot') {
-      return ['$ne', v as string] satisfies ['$ne', OperatorMap<string>['$ne']]
-    }
-
-    if (k === 'gt') {
-      return ['$gt', v as string] satisfies ['$gt', OperatorMap<string>['$gt']]
-    }
-
-    if (k === 'gte') {
-      return ['$gte', v as string] satisfies ['$gte', OperatorMap<string>['$gte']]
-    }
-
-    if (k === 'lt') {
-      return ['$lt', v as string] satisfies ['$lt', OperatorMap<string>['$lt']]
-    }
-
-    if (k === 'lte') {
-      return ['$lte', v as string] satisfies ['$lte', OperatorMap<string>['$lte']]
-    }
-
-    if (k === 'in') {
-      return ['$in', v as string[]] satisfies ['$in', OperatorMap<string>['$in']]
-    }
-
-    if (k === 'notIn') {
-      return ['$nin', v as string[]] satisfies ['$nin', OperatorMap<string>['$nin']]
-    }
-
-    if (k === 'like') {
-      return ['$like', v as string] satisfies ['$like', OperatorMap<string>['$like']]
-    }
-
-    if (k === 'notLike') {
-      return ['$not', { $like: v as string }]
-    }
-
-    if (k === 'iLike') {
-      return ['$ilike', v as string] satisfies ['$ilike', OperatorMap<string>['$ilike']]
-    }
-
-    if (k === 'notILike') {
-      return ['$not', { $ilike: v as string }]
-    }
-
-    return [k, this.expandFilter(v as FilterComparisons<unknown>)]
+    return buildMikroOrmQuery<Entity>(convertedFilter as Filter<Entity>)
   }
 
   async findRelation<Relation extends object>(