@mikro-orm/knex 6.4.6-dev.9 → 7.0.0-dev.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/knex",
-  "version": "6.4.6-dev.9",
+  "version": "7.0.0-dev.0",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
   "main": "index.js",
   "module": "index.mjs",
@@ -46,7 +46,7 @@
   },
   "homepage": "https://mikro-orm.io",
   "engines": {
-    "node": ">= 18.12.0"
+    "node": ">= 22.11.0"
   },
   "scripts": {
     "build": "yarn clean && yarn compile && yarn copy && yarn run -T gen-esm-wrapper index.js index.mjs",
@@ -59,27 +59,13 @@
   },
   "dependencies": {
     "fs-extra": "11.3.0",
-    "knex": "3.1.0",
+    "kysely": "https://pkg.pr.new/kysely-org/kysely/kysely@74aed5d",
     "sqlstring": "2.3.3"
   },
   "devDependencies": {
     "@mikro-orm/core": "^6.4.5"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "6.4.6-dev.9",
-    "better-sqlite3": "*",
-    "libsql": "*",
-    "mariadb": "*"
-  },
-  "peerDependenciesMeta": {
-    "better-sqlite3": {
-      "optional": true
-    },
-    "libsql": {
-      "optional": true
-    },
-    "mariadb": {
-      "optional": true
-    }
+    "@mikro-orm/core": "7.0.0-dev.0"
   }
 }

package/query/CriteriaNodeFactory.js

@@ -11,7 +11,7 @@ const ScalarCriteriaNode_1 = require("./ScalarCriteriaNode");
 class CriteriaNodeFactory {
     static createNode(metadata, entityName, payload, parent, key) {
         const customExpression = core_1.RawQueryFragment.isKnownFragment(key || '');
-        const scalar = core_1.Utils.isPrimaryKey(payload) || core_1.Utils.isRawSql(payload) || payload instanceof RegExp || payload instanceof Date || customExpression;
+        const scalar = core_1.Utils.isPrimaryKey(payload) || (0, core_1.isRaw)(payload) || payload instanceof RegExp || payload instanceof Date || customExpression;
         if (Array.isArray(payload) && !scalar) {
             return this.createArrayNode(metadata, entityName, payload, parent, key);
         }
@@ -40,10 +40,10 @@ class CriteriaNodeFactory {
     static createObjectNode(metadata, entityName, payload, parent, key) {
         const meta = metadata.find(entityName);
         const node = new ObjectCriteriaNode_1.ObjectCriteriaNode(metadata, entityName, parent, key);
-        node.payload = Object.keys(payload).reduce((o, item) => {
-            o[item] = this.createObjectItemNode(metadata, entityName, node, payload, item, meta);
-            return o;
-        }, {});
+        node.payload = {};
+        for (const key of Object.keys(payload)) {
+            node.payload[key] = this.createObjectItemNode(metadata, entityName, node, payload, key, meta);
+        }
         return node;
     }
     static createObjectItemNode(metadata, entityName, node, payload, key, meta) {

package/query/NativeQueryBuilder.d.ts

@@ -0,0 +1,108 @@
+import { type Dictionary, LockMode, type QueryFlag, RawQueryFragment } from '@mikro-orm/core';
+import { QueryType } from './enums';
+import type { AbstractSqlPlatform } from '../AbstractSqlPlatform';
+interface Options {
+    tableName?: string | RawQueryFragment;
+    indexHint?: string;
+    select?: (string | RawQueryFragment)[];
+    distinct?: boolean;
+    distinctOn?: string[];
+    joins?: {
+        sql: string;
+        params: unknown[];
+    }[];
+    groupBy?: (string | RawQueryFragment)[];
+    where?: {
+        sql: string;
+        params: unknown[];
+    };
+    having?: {
+        sql: string;
+        params: unknown[];
+    };
+    orderBy?: string;
+    limit?: number;
+    offset?: number;
+    data?: Dictionary;
+    onConflict?: OnConflictClause;
+    lockMode?: LockMode;
+    lockTables?: string[];
+    returning?: (string | RawQueryFragment)[];
+    comment?: string[];
+    hintComment?: string[];
+    flags?: Set<QueryFlag>;
+    wrap?: [prefix: string, suffix: string];
+}
+interface TableOptions {
+    schema?: string;
+    indexHint?: string;
+    alias?: string;
+}
+interface OnConflictClause {
+    fields: string[] | RawQueryFragment;
+    ignore?: boolean;
+    merge?: Dictionary | (string | RawQueryFragment)[];
+    where?: {
+        sql: string;
+        params: unknown[];
+    };
+}
+/** @internal */
+export declare class NativeQueryBuilder {
+    protected readonly platform: AbstractSqlPlatform;
+    protected type?: QueryType;
+    protected parts: string[];
+    protected params: unknown[];
+    protected options: Options;
+    constructor(platform: AbstractSqlPlatform);
+    select(fields: string | RawQueryFragment | (string | RawQueryFragment)[]): this;
+    count(fields?: string | RawQueryFragment | (string | RawQueryFragment)[], distinct?: boolean): this;
+    into(tableName: string | RawQueryFragment | NativeQueryBuilder, options?: TableOptions): this;
+    from(tableName: string | RawQueryFragment | NativeQueryBuilder, options?: TableOptions): this;
+    where(sql: string, params: unknown[]): this;
+    having(sql: string, params: unknown[]): this;
+    groupBy(groupBy: (string | RawQueryFragment)[]): this;
+    join(sql: string, params: unknown[]): this;
+    orderBy(orderBy: string): this;
+    toString(): string;
+    compile(): {
+        sql: string;
+        params: unknown[];
+    };
+    protected addLockClause(): void;
+    protected addOnConflictClause(): void;
+    protected combineParts(): {
+        sql: string;
+        params: unknown[];
+    };
+    limit(limit: number): this;
+    offset(offset: number): this;
+    insert(data: Dictionary): this;
+    update(data: Dictionary): this;
+    delete(): this;
+    truncate(): this;
+    distinct(): this;
+    distinctOn(fields: string[]): this;
+    onConflict(options: OnConflictClause): OnConflictClause;
+    returning(fields: (string | RawQueryFragment)[]): this;
+    lockMode(lockMode: LockMode, lockTables?: string[]): this;
+    comment(comment: string | string[]): this;
+    hintComment(comment: string | string[]): this;
+    setFlags(flags: Set<QueryFlag>): this;
+    clear(clause: keyof Options): this;
+    wrap(prefix: string, suffix: string): this;
+    as(alias: string): this;
+    toRaw(): RawQueryFragment;
+    protected compileSelect(): void;
+    protected getFields(): string;
+    protected compileInsert(): void;
+    protected addOutputClause(type: 'inserted' | 'deleted'): void;
+    protected processInsertData(): string[];
+    protected compileUpdate(): void;
+    protected compileDelete(): void;
+    protected compileTruncate(): void;
+    protected addHintComment(): void;
+    protected getTableName(): string;
+    protected quote(id: string | RawQueryFragment | NativeQueryBuilder): string;
+}
+export {};

package/query/NativeQueryBuilder.js

@@ -0,0 +1,429 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NativeQueryBuilder = void 0;
+const core_1 = require("@mikro-orm/core");
+const enums_1 = require("./enums");
+/** @internal */
+class NativeQueryBuilder {
+    platform;
+    type;
+    parts = [];
+    params = [];
+    options = {};
+    constructor(platform) {
+        this.platform = platform;
+    }
+    select(fields) {
+        this.type = enums_1.QueryType.SELECT;
+        this.options.select ??= [];
+        this.options.select.push(...core_1.Utils.asArray(fields));
+        return this;
+    }
+    count(fields = '*', distinct) {
+        this.type = enums_1.QueryType.COUNT;
+        this.options.select = core_1.Utils.asArray(fields);
+        this.options.distinct = distinct;
+        return this;
+    }
+    into(tableName, options) {
+        return this.from(tableName, options);
+    }
+    from(tableName, options) {
+        if (tableName instanceof NativeQueryBuilder) {
+            const { sql, params } = tableName.compile();
+            tableName = (0, core_1.raw)(sql, params);
+        }
+        if (typeof tableName === 'string') {
+            const alias = options?.alias ? ` as ${this.platform.quoteIdentifier(options.alias)}` : '';
+            const schema = options?.schema && options.schema !== this.platform.getDefaultSchemaName() ? `${options.schema}.` : '';
+            tableName = this.quote(schema + tableName) + alias;
+        }
+        this.options.tableName = tableName;
+        this.options.indexHint = options?.indexHint;
+        return this;
+    }
+    where(sql, params) {
+        this.options.where = { sql, params };
+        return this;
+    }
+    having(sql, params) {
+        this.options.having = { sql, params };
+        return this;
+    }
+    groupBy(groupBy) {
+        this.options.groupBy = groupBy;
+        return this;
+    }
+    join(sql, params) {
+        this.options.joins ??= [];
+        this.options.joins.push({ sql, params });
+        return this;
+    }
+    orderBy(orderBy) {
+        this.options.orderBy = orderBy;
+        return this;
+    }
+    toString() {
+        const { sql, params } = this.compile();
+        return this.platform.formatQuery(sql, params);
+    }
+    compile() {
+        if (!this.type) {
+            throw new Error('No query type provided');
+        }
+        this.parts.length = 0;
+        this.params.length = 0;
+        if (this.options.comment) {
+            this.parts.push(...this.options.comment.map(comment => `/* ${comment} */`));
+        }
+        switch (this.type) {
+            case enums_1.QueryType.SELECT:
+            case enums_1.QueryType.COUNT:
+                this.compileSelect();
+                break;
+            case enums_1.QueryType.INSERT:
+                this.compileInsert();
+                break;
+            case enums_1.QueryType.UPDATE:
+                this.compileUpdate();
+                break;
+            case enums_1.QueryType.DELETE:
+                this.compileDelete();
+                break;
+            case enums_1.QueryType.TRUNCATE:
+                this.compileTruncate();
+                break;
+        }
+        this.addOnConflictClause();
+        if (this.options.returning && this.platform.usesReturningStatement()) {
+            const fields = this.options.returning.map(field => this.quote(field));
+            this.parts.push(`returning ${fields.join(', ')}`);
+        }
+        this.addLockClause();
+        return this.combineParts();
+    }
+    addLockClause() {
+        if (!this.options.lockMode) {
+            return;
+        }
+        if ([core_1.LockMode.PESSIMISTIC_READ, core_1.LockMode.PESSIMISTIC_PARTIAL_READ, core_1.LockMode.PESSIMISTIC_READ_OR_FAIL].includes(this.options.lockMode)) {
+            this.parts.push('for share');
+        }
+        if ([core_1.LockMode.PESSIMISTIC_WRITE, core_1.LockMode.PESSIMISTIC_PARTIAL_WRITE, core_1.LockMode.PESSIMISTIC_WRITE_OR_FAIL].includes(this.options.lockMode)) {
+            this.parts.push('for update');
+        }
+        if (this.options.lockTables?.length) {
+            const fields = this.options.lockTables.map(field => this.quote(field));
+            this.parts.push(`of ${fields.join(', ')}`);
+        }
+        if ([core_1.LockMode.PESSIMISTIC_PARTIAL_READ, core_1.LockMode.PESSIMISTIC_PARTIAL_WRITE].includes(this.options.lockMode)) {
+            this.parts.push('skip locked');
+        }
+        if ([core_1.LockMode.PESSIMISTIC_READ_OR_FAIL, core_1.LockMode.PESSIMISTIC_WRITE_OR_FAIL].includes(this.options.lockMode)) {
+            this.parts.push('nowait');
+        }
+    }
+    addOnConflictClause() {
+        const clause = this.options.onConflict;
+        if (!clause) {
+            return;
+        }
+        this.parts.push('on conflict');
+        if (clause.fields instanceof core_1.RawQueryFragment) {
+            this.parts.push(clause.fields.sql);
+            this.params.push(...clause.fields.params);
+        }
+        else if (clause.fields.length > 0) {
+            const fields = clause.fields.map(field => this.quote(field));
+            this.parts.push(`(${fields.join(', ')})`);
+        }
+        if (clause.ignore) {
+            this.parts.push('do nothing');
+        }
+        if (core_1.Utils.isObject(clause.merge)) {
+            this.parts.push('do update set');
+            const fields = Object.keys(clause.merge).map(field => {
+                this.params.push(clause.merge[field]);
+                return `${this.quote(field)} = ?`;
+            });
+            this.parts.push(fields.join(', '));
+        }
+        else if (clause.merge) {
+            this.parts.push('do update set');
+            if (clause.merge.length) {
+                const fields = clause.merge.map(field => `${this.quote(field)} = excluded.${this.quote(field)}`);
+                this.parts.push(fields.join(', '));
+            }
+            else {
+                const dataAsArray = core_1.Utils.asArray(this.options.data);
+                const keys = Object.keys(dataAsArray[0]);
+                const fields = keys.map(field => `${this.quote(field)} = excluded.${this.quote(field)}`);
+                this.parts.push(fields.join(', '));
+            }
+        }
+        if (clause.where) {
+            this.parts.push(`where ${clause.where.sql}`);
+            this.params.push(...clause.where.params);
+        }
+    }
+    combineParts() {
+        let sql = this.parts.join(' ');
+        if (this.options.wrap) {
+            const [a, b] = this.options.wrap;
+            sql = `${a}${sql}${b}`;
+        }
+        return { sql, params: this.params };
+    }
+    limit(limit) {
+        this.options.limit = limit;
+        return this;
+    }
+    offset(offset) {
+        this.options.offset = offset;
+        return this;
+    }
+    insert(data) {
+        this.type = enums_1.QueryType.INSERT;
+        this.options.data = data;
+        return this;
+    }
+    update(data) {
+        this.type = enums_1.QueryType.UPDATE;
+        this.options.data ??= {};
+        Object.assign(this.options.data, data);
+        return this;
+    }
+    delete() {
+        this.type = enums_1.QueryType.DELETE;
+        return this;
+    }
+    truncate() {
+        this.type = enums_1.QueryType.TRUNCATE;
+        return this;
+    }
+    distinct() {
+        this.options.distinct = true;
+        return this;
+    }
+    distinctOn(fields) {
+        this.options.distinctOn = fields;
+        return this;
+    }
+    onConflict(options) {
+        this.options.onConflict = options;
+        return options;
+    }
+    returning(fields) {
+        this.options.returning = fields;
+        return this;
+    }
+    lockMode(lockMode, lockTables) {
+        this.options.lockMode = lockMode;
+        this.options.lockTables = lockTables;
+        return this;
+    }
+    comment(comment) {
+        this.options.comment ??= [];
+        this.options.comment.push(...core_1.Utils.asArray(comment));
+        return this;
+    }
+    hintComment(comment) {
+        this.options.hintComment ??= [];
+        this.options.hintComment.push(...core_1.Utils.asArray(comment));
+        return this;
+    }
+    setFlags(flags) {
+        this.options.flags = flags;
+        return this;
+    }
+    clear(clause) {
+        delete this.options[clause];
+        return this;
+    }
+    wrap(prefix, suffix) {
+        this.options.wrap = [prefix, suffix];
+        return this;
+    }
+    as(alias) {
+        this.wrap('(', `) as ${this.platform.quoteIdentifier(alias)}`);
+        return this;
+    }
+    toRaw() {
+        const { sql, params } = this.compile();
+        return (0, core_1.raw)(sql, params);
+    }
+    compileSelect() {
+        this.parts.push('select');
+        this.addHintComment();
+        this.parts.push(`${this.getFields()} from ${this.getTableName()}`);
+        if (this.options.joins) {
+            for (const join of this.options.joins) {
+                this.parts.push(join.sql);
+                this.params.push(...join.params);
+            }
+        }
+        if (this.options.where?.sql.trim()) {
+            this.parts.push(`where ${this.options.where.sql}`);
+            this.params.push(...this.options.where.params);
+        }
+        if (this.options.groupBy) {
+            const fields = this.options.groupBy.map(field => this.quote(field));
+            this.parts.push(`group by ${fields.join(', ')}`);
+        }
+        if (this.options.having) {
+            this.parts.push(`having ${this.options.having.sql}`);
+            this.params.push(...this.options.having.params);
+        }
+        if (this.options.orderBy) {
+            this.parts.push(`order by ${this.options.orderBy}`);
+        }
+        if (this.options.limit != null) {
+            this.parts.push(`limit ?`);
+            this.params.push(this.options.limit);
+        }
+        if (this.options.offset != null) {
+            this.parts.push(`offset ?`);
+            this.params.push(this.options.offset);
+        }
+    }
+    getFields() {
+        if (!this.options.select || this.options.select.length === 0) {
+            throw new Error('No fields selected');
+        }
+        let fields = this.options.select.map(field => this.quote(field)).join(', ');
+        if (this.options.distinct) {
+            fields = `distinct ${fields}`;
+        }
+        else if (this.options.distinctOn) {
+            fields = `distinct on (${this.options.distinctOn.map(field => this.quote(field)).join(', ')}) ${fields}`;
+        }
+        if (this.type === enums_1.QueryType.COUNT) {
+            fields = `count(${fields}) as ${this.quote('count')}`;
+        }
+        return fields;
+    }
+    compileInsert() {
+        if (!this.options.data) {
+            throw new Error('No data provided');
+        }
+        this.parts.push('insert');
+        this.addHintComment();
+        this.parts.push(`into ${this.getTableName()}`);
+        if (Object.keys(this.options.data).length === 0) {
+            this.addOutputClause('inserted');
+            this.parts.push('default values');
+            return;
+        }
+        const parts = this.processInsertData();
+        this.parts.push(parts.join(', '));
+    }
+    addOutputClause(type) {
+        if (this.options.returning && this.platform.usesOutputStatement()) {
+            const fields = this.options.returning.map(field => `${type}.${this.quote(field)}`);
+            this.parts.push(`output ${fields.join(', ')}`);
+        }
+    }
+    processInsertData() {
+        const dataAsArray = core_1.Utils.asArray(this.options.data);
+        const keys = Object.keys(dataAsArray[0]);
+        const values = keys.map(() => '?');
+        const parts = [];
+        this.parts.push(`(${keys.map(key => this.quote(key)).join(', ')})`);
+        this.addOutputClause('inserted');
+        this.parts.push('values');
+        for (const data of dataAsArray) {
+            for (const key of keys) {
+                if (typeof data[key] === 'undefined') {
+                    this.params.push(this.platform.usesDefaultKeyword() ? (0, core_1.raw)('default') : null);
+                }
+                else {
+                    this.params.push(data[key]);
+                }
+            }
+            parts.push(`(${values.join(', ')})`);
+        }
+        return parts;
+    }
+    compileUpdate() {
+        if (!this.options.data || Object.keys(this.options.data).length === 0) {
+            throw new Error('No data provided');
+        }
+        this.parts.push('update');
+        this.addHintComment();
+        this.parts.push(this.getTableName());
+        if (this.options.joins) {
+            for (const join of this.options.joins) {
+                this.parts.push(join.sql);
+                this.params.push(...join.params);
+            }
+        }
+        this.parts.push('set');
+        if (this.options.data) {
+            const parts = [];
+            for (const key of Object.keys(this.options.data)) {
+                parts.push(`${this.quote(key)} = ?`);
+                this.params.push(this.options.data[key]);
+            }
+            this.parts.push(parts.join(', '));
+        }
+        this.addOutputClause('inserted');
+        if (this.options.where?.sql.trim()) {
+            this.parts.push(`where ${this.options.where.sql}`);
+            this.params.push(...this.options.where.params);
+        }
+    }
+    compileDelete() {
+        this.parts.push('delete');
+        this.addHintComment();
+        this.parts.push(`from ${this.getTableName()}`);
+        this.addOutputClause('deleted');
+        if (this.options.where?.sql.trim()) {
+            this.parts.push(`where ${this.options.where.sql}`);
+            this.params.push(...this.options.where.params);
+        }
+    }
+    compileTruncate() {
+        const sql = `truncate table ${this.getTableName()}`;
+        this.parts.push(sql);
+    }
+    addHintComment() {
+        if (this.options.hintComment) {
+            this.parts.push(`/*+ ${this.options.hintComment.join(' ')} */`);
+        }
+    }
+    getTableName() {
+        if (!this.options.tableName) {
+            throw new Error('No table name provided');
+        }
+        const indexHint = this.options.indexHint ? ' ' + this.options.indexHint : '';
+        if (this.options.tableName instanceof core_1.RawQueryFragment) {
+            this.params.push(...this.options.tableName.params);
+            return this.options.tableName.sql + indexHint;
+        }
+        return this.options.tableName + indexHint;
+    }
+    quote(id) {
+        if (id instanceof core_1.RawQueryFragment) {
+            return this.platform.formatQuery(id.sql, id.params);
+        }
+        if (id instanceof NativeQueryBuilder) {
+            const { sql, params } = id.compile();
+            return this.platform.formatQuery(sql, params);
+        }
+        if (id.endsWith('.*')) {
+            const schema = this.platform.quoteIdentifier(id.substring(0, id.indexOf('.')));
+            return schema + '.*';
+        }
+        if (id.toLowerCase().includes(' as ')) {
+            const parts = id.split(/ as /i);
+            const a = this.platform.quoteIdentifier(parts[0]);
+            const b = this.platform.quoteIdentifier(parts[1]);
+            return `${a} as ${b}`;
+        }
+        if (id === '*') {
+            return id;
+        }
+        return this.platform.quoteIdentifier(id);
+    }
+}
+exports.NativeQueryBuilder = NativeQueryBuilder;

package/query/ObjectCriteriaNode.js

@@ -50,7 +50,7 @@ class ObjectCriteriaNode extends CriteriaNode_1.CriteriaNode {
                     }
                     const op = key === '$some' ? '$in' : '$nin';
                     $and.push({
-                        [core_1.Utils.getPrimaryKeyHash(primaryKeys)]: { [op]: sub.getKnexQuery() },
+                        [core_1.Utils.getPrimaryKeyHash(primaryKeys)]: { [op]: sub.getNativeQuery().toRaw() },
                     });
                 }
                 if ($and.length === 1) {
@@ -68,7 +68,7 @@ class ObjectCriteriaNode extends CriteriaNode_1.CriteriaNode {
             // we need to keep the prefixing for formulas otherwise we would lose aliasing context when nesting inside group operators
             const virtual = childNode.prop?.persist === false && !childNode.prop?.formula;
             // if key is missing, we are inside group operator and we need to prefix with alias
-            const primaryKey = this.key && this.metadata.find(this.entityName).primaryKeys.includes(field);
+            const primaryKey = this.key && this.metadata.find(this.entityName)?.primaryKeys.includes(field);
             if (childNode.shouldInline(payload)) {
                 const childAlias = qb.getAliasForJoinPath(childNode.getPath(), options);
                 const a = qb.helper.isTableNameAliasRequired(qb.type) ? alias : undefined;
@@ -81,7 +81,7 @@ class ObjectCriteriaNode extends CriteriaNode_1.CriteriaNode {
                 const rawField = core_1.RawQueryFragment.getKnownFragment(field);
                 o[(0, core_1.raw)(rawField.sql.replaceAll(core_1.ALIAS_REPLACEMENT, alias), rawField.params)] = payload;
             }
-            else if (primaryKey || virtual || operator || field.includes('.') || ![enums_1.QueryType.SELECT, enums_1.QueryType.COUNT].includes(qb.type ?? enums_1.QueryType.SELECT)) {
+            else if (primaryKey || virtual || operator || field.includes('.') || ![enums_1.QueryType.SELECT, enums_1.QueryType.COUNT].includes(qb.type)) {
                 this.inlineCondition(field.replaceAll(core_1.ALIAS_REPLACEMENT, alias), o, payload);
             }
             else {