feat(mikro-orm-query-builder): init

package.json

@@ -10,11 +10,12 @@
   },
   "devDependencies": {
     "@atls/code-runtime": "2.1.2",
-    "@atls/schematics": "^0.0.26",
-    "@types/node": "^20.6.0",
-    "typescript": "^5.3.3"
+    "@types/eslint": "9.6.1",
+    "@types/node": "22.10.2",
+    "eslint": "9.17.0",
+    "typescript": "5.5.4"
   },
-  "packageManager": "yarn@4.7.0",
+  "packageManager": "yarn@4.6.0",
   "tools": {
     "schematic": {
       "collection": "@atls/schematics",

packages/mikro-orm-query-builder/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@atls/mikro-orm-query-builder",
+  "version": "0.0.0",
+  "license": "BSD-3-Clause",
+  "type": "module",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": "./src/index.ts"
+  },
+  "main": "src/index.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "yarn library build",
+    "prepack": "yarn run build",
+    "postpack": "rm -rf dist"
+  },
+  "dependencies": {
+    "@atls/query-types": "^0.0.1",
+    "@mikro-orm/postgresql": "*",
+    "lodash.set": "^4.3.2"
+  },
+  "devDependencies": {
+    "@types/lodash.set": "^4.3.9"
+  },
+  "peerDependencies": {
+    "@mikro-orm/postgresql": "*"
+  },
+  "peerDependenciesMeta": {
+    "@mikro-orm/core": {
+      "optional": true
+    }
+  },
+  "publishConfig": {
+    "exports": {
+      "./package.json": "./package.json",
+      ".": {
+        "import": "./dist/index.js",
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    },
+    "main": "dist/index.js",
+    "typings": "dist/index.d.ts"
+  }
+}

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

@@ -0,0 +1 @@
+export * from './mikro-orm.query-builder.js'

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

@@ -0,0 +1,233 @@
+import type { QueryBuilder } from '@mikro-orm/postgresql'
+
+import { Query }             from '@atls/query-types'
+import set                   from 'lodash.set'
+
+export class MikroORMQueryBuilder<T extends object> {
+  #take?: number
+
+  constructor(private readonly qb: QueryBuilder<T>) {}
+
+  order(order?: Query.Order): MikroORMQueryBuilder<T> {
+    if (order) {
+      this.qb.orderBy({
+        [order.field]: order.direction === Query.OrderDirection.ASC ? 'ASC' : 'DESC',
+      })
+    }
+
+    return this
+  }
+
+  pager(pager?: Query.Pager): MikroORMQueryBuilder<T> {
+    if (pager?.take) {
+      this.#take = pager.take + 1
+
+      this.qb.limit(this.#take, pager?.offset || 0)
+    }
+
+    return this
+  }
+
+  search(fields?: Array<Query.SearchField>, value?: string): MikroORMQueryBuilder<T> {
+    if (value && fields && fields.length > 0) {
+      this.qb.andWhere({
+        $or: fields.map((field) =>
+          set({}, field.path, {
+            $ilike: value,
+          })),
+      })
+    }
+
+    return this
+  }
+
+  id(field: string, query?: Query.IDType): MikroORMQueryBuilder<T> {
+    if (field && query?.conditions && Object.keys(query.conditions).length > 0) {
+      const queries: { $eq?: string; $in?: Array<string>; $exists?: boolean } = {}
+
+      if (query.conditions.eq) {
+        queries.$eq = query.conditions.eq.value
+      }
+
+      if (query.conditions.in) {
+        queries.$in = query.conditions.in.values
+      }
+
+      if (query.conditions.exists) {
+        queries.$exists = query.conditions.exists.value
+      }
+
+      if (Object.keys(queries).length === 1) {
+        this.qb.andWhere(
+          set(
+            {},
+            field,
+            Object.keys(queries).reduce(
+              (result, key) => ({
+                ...result,
+                [key]: queries[key as keyof typeof queries],
+              }),
+              {}
+            )
+          )
+        )
+      } else if (Object.keys(queries).length > 1) {
+        const operator =
+          (query.operator || Query.Operator.AND) === Query.Operator.AND ? '$and' : '$or'
+
+        this.qb.andWhere(
+          set({}, field, {
+            [operator]: Object.keys(queries).map((key) => ({
+              [key]: queries[key as keyof typeof queries],
+            })),
+          })
+        )
+      }
+    }
+
+    return this
+  }
+
+  date(field: string, query?: Query.DateType): MikroORMQueryBuilder<T> {
+    if (field && query?.conditions && Object.keys(query.conditions).length > 0) {
+      const queries: { $eq?: Date; $exists?: boolean } = {}
+
+      if (query.conditions.eq) {
+        queries.$eq = query.conditions.eq.value
+      }
+
+      if (query.conditions.exists) {
+        queries.$exists = query.conditions.exists.value
+      }
+
+      if (Object.keys(queries).length === 1) {
+        this.qb.andWhere(
+          set(
+            {},
+            field,
+            Object.keys(queries).reduce(
+              (result, key) => ({
+                ...result,
+                [key]: queries[key as keyof typeof queries],
+              }),
+              {}
+            )
+          )
+        )
+      } else if (Object.keys(queries).length > 1) {
+        const operator =
+          (query.operator || Query.Operator.AND) === Query.Operator.AND ? '$and' : '$or'
+
+        this.qb.andWhere(
+          set({}, field, {
+            [operator]: Object.keys(queries).map((key) => ({
+              [key]: queries[key as keyof typeof queries],
+            })),
+          })
+        )
+      }
+    }
+
+    return this
+  }
+
+  string(field: string, query?: Query.StringType): MikroORMQueryBuilder<T> {
+    if (field && query?.conditions && Object.keys(query.conditions).length > 0) {
+      const queries: { $eq?: string; $in?: Array<string>; $ilike?: string } = {}
+
+      if (query.conditions.eq) {
+        queries.$eq = query.conditions.eq.value
+      }
+
+      if (query.conditions.in) {
+        queries.$in = query.conditions.in.values
+      }
+
+      if (query.conditions.contains) {
+        queries.$ilike = query.conditions.contains.value
+      }
+
+      if (Object.keys(queries).length === 1) {
+        this.qb.andWhere(
+          set(
+            {},
+            field,
+            Object.keys(queries).reduce(
+              (result, key) => ({
+                ...result,
+                [key]: queries[key as keyof typeof queries],
+              }),
+              {}
+            )
+          )
+        )
+      } else if (Object.keys(queries).length > 1) {
+        const operator =
+          (query.operator || Query.Operator.AND) === Query.Operator.AND ? '$and' : '$or'
+
+        this.qb.andWhere(
+          set({}, field, {
+            [operator]: Object.keys(queries).map((key) => ({
+              [key]: queries[key as keyof typeof queries],
+            })),
+          })
+        )
+      }
+    }
+
+    return this
+  }
+
+  number(field: string, query?: Query.NumberType): MikroORMQueryBuilder<T> {
+    if (field && query?.conditions && Object.keys(query.conditions).length > 0) {
+      const queries: { $eq?: number; $in?: Array<number> } = {}
+
+      if (query.conditions.eq) {
+        queries.$eq = query.conditions.eq.value
+      }
+
+      if (query.conditions.in) {
+        queries.$in = query.conditions.in.values
+      }
+
+      if (Object.keys(queries).length === 1) {
+        this.qb.andWhere(
+          set(
+            {},
+            field,
+            Object.keys(queries).reduce(
+              (result, key) => ({
+                ...result,
+                [key]: queries[key as keyof typeof queries],
+              }),
+              {}
+            )
+          )
+        )
+      } else if (Object.keys(queries).length > 1) {
+        const operator =
+          (query.operator || Query.Operator.AND) === Query.Operator.AND ? '$and' : '$or'
+
+        this.qb.andWhere(
+          set({}, field, {
+            [operator]: Object.keys(queries).map((key) => ({
+              [key]: queries[key as keyof typeof queries],
+            })),
+          })
+        )
+      }
+    }
+
+    return this
+  }
+
+  async execute(): Promise<[Array<T>, boolean]> {
+    const result = await this.qb.getResultList()
+
+    if (!this.#take) {
+      return [result, false]
+    }
+
+    return [result.slice(0, this.#take - 1), result.length >= this.#take]
+  }
+}

project.types.d.ts

@@ -0,0 +1 @@
+/// <reference types="@atls/code-runtime/types" />

tsconfig.json

@@ -1,30 +1,54 @@
 {
   "compilerOptions": {
-    "lib": ["dom", "dom.iterable", "esnext"],
+    "lib": [
+      "dom",
+      "dom.iterable",
+      "esnext",
+      "dom",
+      "dom.iterable",
+      "esnext",
+      "dom",
+      "dom.iterable",
+      "esnext",
+      "dom",
+      "dom.iterable",
+      "esnext",
+      "dom",
+      "dom.iterable",
+      "esnext",
+      "dom",
+      "dom.iterable",
+      "esnext",
+      "dom",
+      "dom.iterable",
+      "esnext"
+    ],
     "declaration": false,
     "emitDecoratorMetadata": true,
     "experimentalDecorators": true,
     "esModuleInterop": true,
     "forceConsistentCasingInFileNames": true,
     "importHelpers": false,
     "isolatedModules": false,
-    "module": "esnext",
-    "moduleResolution": "node",
+    "moduleResolution": "nodenext",
     "noFallthroughCasesInSwitch": true,
-    "noImplicitAny": false,
-    "noImplicitReturns": false,
-    "noImplicitThis": false,
-    "noUnusedLocals": false,
-    "noUnusedParameters": false,
+    "noImplicitAny": true,
+    "noImplicitReturns": true,
+    "noImplicitThis": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
     "pretty": true,
     "removeComments": true,
     "resolveJsonModule": true,
     "strict": true,
+    "strictPropertyInitialization": false,
     "sourceMap": false,
-    "target": "es2019",
-    "jsx": "react"
+    "module": "nodenext",
+    "target": "es2021",
+    "jsx": "react",
+    "outDir": "./dist",
+    "noImplicitOverride": true,
+    "skipLibCheck": true
   },
-  "include": [
-    "packages/**/*"
-  ]
+  "include": ["project.types.d.ts", "packages/**/*"]
 }