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

package/AbstractSqlConnection.d.ts

@@ -1,15 +1,12 @@
-import { type Knex } from 'knex';
-import { Connection, type AnyEntity, type Configuration, type ConnectionOptions, type EntityData, type IsolationLevel, type QueryResult, type Transaction, type TransactionEventBroadcaster, type LoggingOptions } from '@mikro-orm/core';
+import { type ControlledTransaction, type Dialect, Kysely } from 'kysely';
+import { type AnyEntity, Connection, type Dictionary, type EntityData, type IsolationLevel, type LoggingOptions, type QueryResult, RawQueryFragment, type Transaction, type TransactionEventBroadcaster } from '@mikro-orm/core';
 import type { AbstractSqlPlatform } from './AbstractSqlPlatform';
+import { NativeQueryBuilder } from './query';
 export declare abstract class AbstractSqlConnection extends Connection {
-    private static __patched;
     protected platform: AbstractSqlPlatform;
-    protected client: Knex;
-    constructor(config: Configuration, options?: ConnectionOptions, type?: 'read' | 'write');
-    abstract createKnex(): void;
-    /** @inheritDoc */
-    connect(): void | Promise<void>;
-    getKnex(): Knex;
+    protected client: Kysely<any>;
+    abstract createKyselyDialect(overrides: Dictionary): Dialect;
+    connect(): Promise<void>;
     /**
      * @inheritDoc
      */
@@ -28,33 +25,26 @@ export declare abstract class AbstractSqlConnection extends Connection {
         reason: string;
         error?: Error;
     }>;
-    transactional<T>(cb: (trx: Transaction<Knex.Transaction>) => Promise<T>, options?: {
+    getClient<T = any>(): Kysely<T>;
+    transactional<T>(cb: (trx: Transaction<ControlledTransaction<any, any>>) => Promise<T>, options?: {
         isolationLevel?: IsolationLevel;
         readOnly?: boolean;
-        ctx?: Knex.Transaction;
+        ctx?: ControlledTransaction<any>;
         eventBroadcaster?: TransactionEventBroadcaster;
     }): Promise<T>;
     begin(options?: {
         isolationLevel?: IsolationLevel;
         readOnly?: boolean;
-        ctx?: Knex.Transaction;
+        ctx?: ControlledTransaction<any, any>;
         eventBroadcaster?: TransactionEventBroadcaster;
-    }): Promise<Knex.Transaction>;
-    commit(ctx: Knex.Transaction, eventBroadcaster?: TransactionEventBroadcaster): Promise<void>;
-    rollback(ctx: Knex.Transaction, eventBroadcaster?: TransactionEventBroadcaster): Promise<void>;
-    execute<T extends QueryResult | EntityData<AnyEntity> | EntityData<AnyEntity>[] = EntityData<AnyEntity>[]>(queryOrKnex: string | Knex.QueryBuilder | Knex.Raw, params?: unknown[], method?: 'all' | 'get' | 'run', ctx?: Transaction, loggerContext?: LoggingOptions): Promise<T>;
+    }): Promise<ControlledTransaction<any, any>>;
+    commit(ctx: ControlledTransaction<any, any>, eventBroadcaster?: TransactionEventBroadcaster): Promise<void>;
+    rollback(ctx: ControlledTransaction<any, any>, eventBroadcaster?: TransactionEventBroadcaster): Promise<void>;
+    execute<T extends QueryResult | EntityData<AnyEntity> | EntityData<AnyEntity>[] = EntityData<AnyEntity>[]>(query: string | NativeQueryBuilder | RawQueryFragment, params?: readonly unknown[], method?: 'all' | 'get' | 'run', ctx?: Transaction, loggerContext?: LoggingOptions): Promise<T>;
     /**
      * Execute raw SQL queries from file
      */
     loadFile(path: string): Promise<void>;
-    protected createKnexClient(type: string): Knex;
-    protected getKnexOptions(type: string): Knex.Config;
     private getSql;
-    /**
-     * do not call `positionBindings` when there are no bindings - it was messing up with
-     * already interpolated strings containing `?`, and escaping that was not enough to
-     * support edge cases like `\\?` strings (as `positionBindings` was removing the `\\`)
-     */
-    private patchKnexClient;
-    protected abstract transformRawResult<T>(res: any, method: 'all' | 'get' | 'run'): T;
+    protected transformRawResult<T>(res: any, method?: 'all' | 'get' | 'run'): T;
 }

package/AbstractSqlConnection.js

@@ -1,37 +1,40 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AbstractSqlConnection = void 0;
-const knex_1 = require("knex");
+const kysely_1 = require("kysely");
 const fs_extra_1 = require("fs-extra");
 const core_1 = require("@mikro-orm/core");
-const MonkeyPatchable_1 = require("./MonkeyPatchable");
-const parentTransactionSymbol = Symbol('parentTransaction');
-function isRootTransaction(trx) {
-    return !Object.getOwnPropertySymbols(trx).includes(parentTransactionSymbol);
-}
+const query_1 = require("./query");
 class AbstractSqlConnection extends core_1.Connection {
-    static __patched = false;
     client;
-    constructor(config, options, type) {
-        super(config, options, type);
-        this.patchKnexClient();
-    }
-    /** @inheritDoc */
-    connect() {
-        this.createKnex();
-    }
-    getKnex() {
-        if (!this.client) {
-            this.createKnex();
+    async connect() {
+        let driverOptions = this.options.driverOptions ?? this.config.get('driverOptions');
+        if (typeof driverOptions === 'function') {
+            driverOptions = await driverOptions();
         }
-        return this.client;
+        if (driverOptions instanceof kysely_1.Kysely) {
+            this.logger.log('info', 'Reusing Kysely client provided via `driverOptions`');
+            this.client = driverOptions;
+        }
+        else if ('createDriver' in driverOptions) {
+            this.logger.log('info', 'Reusing Kysely dialect provided via `driverOptions`');
+            this.client = new kysely_1.Kysely({ dialect: driverOptions });
+        }
+        else {
+            this.client = new kysely_1.Kysely({
+                dialect: this.createKyselyDialect(driverOptions),
+                // log: m => console.log(m),
+            });
+        }
+        this.connected = true;
     }
     /**
      * @inheritDoc
      */
     async close(force) {
         await super.close(force);
-        await this.getKnex().destroy();
+        await this.client?.destroy();
+        this.connected = false;
     }
     /**
      * @inheritDoc
@@ -44,14 +47,20 @@ class AbstractSqlConnection extends core_1.Connection {
      * @inheritDoc
      */
     async checkConnection() {
+        if (!this.connected) {
+            return { ok: false, reason: 'Connection not established' };
+        }
         try {
-            await this.getKnex().raw('select 1');
+            await this.client.executeQuery(kysely_1.CompiledQuery.raw('select 1'));
             return { ok: true };
         }
         catch (error) {
             return { ok: false, reason: error.message, error };
         }
     }
+    getClient() {
+        return this.client;
+    }
     async transactional(cb, options = {}) {
         const trx = await this.begin(options);
         try {
@@ -65,61 +74,77 @@ class AbstractSqlConnection extends core_1.Connection {
         }
     }
     async begin(options = {}) {
-        if (!options.ctx) {
-            await options.eventBroadcaster?.dispatchEvent(core_1.EventType.beforeTransactionStart);
-        }
-        const trx = await (options.ctx || this.getKnex()).transaction(null, {
-            isolationLevel: options.isolationLevel,
-            readOnly: options.readOnly,
-        });
-        if (!options.ctx) {
-            await options.eventBroadcaster?.dispatchEvent(core_1.EventType.afterTransactionStart, trx);
-        }
-        else {
-            trx[parentTransactionSymbol] = options.ctx;
-        }
+        if (options.ctx) {
+            const ctx = options.ctx;
+            ctx.index ??= 0;
+            const savepointName = `trx${ctx.index + 1}`;
+            const trx = await options.ctx.savepoint(savepointName).execute();
+            Reflect.defineProperty(trx, 'index', { value: ctx.index + 1 });
+            Reflect.defineProperty(trx, 'savepointName', { value: savepointName });
+            this.logQuery(this.platform.getSavepointSQL(savepointName));
+            return trx;
+        }
+        await options.eventBroadcaster?.dispatchEvent(core_1.EventType.beforeTransactionStart);
+        let trxBuilder = this.client.startTransaction();
+        if (options.isolationLevel) {
+            trxBuilder = trxBuilder.setIsolationLevel(options.isolationLevel);
+        }
+        if (options.readOnly) {
+            trxBuilder = trxBuilder.setAccessMode('read only');
+        }
+        const trx = await trxBuilder.execute();
+        for (const query of this.platform.getBeginTransactionSQL(options)) {
+            this.logQuery(query);
+        }
+        await options.eventBroadcaster?.dispatchEvent(core_1.EventType.afterTransactionStart, trx);
         return trx;
     }
     async commit(ctx, eventBroadcaster) {
-        const runTrxHooks = isRootTransaction(ctx);
-        if (runTrxHooks) {
-            await eventBroadcaster?.dispatchEvent(core_1.EventType.beforeTransactionCommit, ctx);
+        if (ctx.isRolledBack) {
+            return;
         }
-        ctx.commit();
-        await ctx.executionPromise; // https://github.com/knex/knex/issues/3847#issuecomment-626330453
-        if (runTrxHooks) {
-            await eventBroadcaster?.dispatchEvent(core_1.EventType.afterTransactionCommit, ctx);
+        if ('savepointName' in ctx) {
+            await ctx.releaseSavepoint(ctx.savepointName).execute();
+            this.logQuery(this.platform.getReleaseSavepointSQL(ctx.savepointName));
+            return;
         }
+        await eventBroadcaster?.dispatchEvent(core_1.EventType.beforeTransactionCommit, ctx);
+        await ctx.commit().execute();
+        this.logQuery(this.platform.getCommitTransactionSQL());
+        await eventBroadcaster?.dispatchEvent(core_1.EventType.afterTransactionCommit, ctx);
     }
     async rollback(ctx, eventBroadcaster) {
-        const runTrxHooks = isRootTransaction(ctx);
-        if (runTrxHooks) {
-            await eventBroadcaster?.dispatchEvent(core_1.EventType.beforeTransactionRollback, ctx);
-        }
-        await ctx.rollback();
-        if (runTrxHooks) {
-            await eventBroadcaster?.dispatchEvent(core_1.EventType.afterTransactionRollback, ctx);
+        if ('savepointName' in ctx) {
+            await ctx.rollbackToSavepoint(ctx.savepointName).execute();
+            this.logQuery(this.platform.getRollbackToSavepointSQL(ctx.savepointName));
+            return;
         }
+        await eventBroadcaster?.dispatchEvent(core_1.EventType.beforeTransactionRollback, ctx);
+        await ctx.rollback().execute();
+        this.logQuery(this.platform.getRollbackTransactionSQL());
+        await eventBroadcaster?.dispatchEvent(core_1.EventType.afterTransactionRollback, ctx);
     }
-    async execute(queryOrKnex, params = [], method = 'all', ctx, loggerContext) {
+    async execute(query, params = [], method = 'all', ctx, loggerContext) {
         await this.ensureConnection();
-        if (core_1.Utils.isObject(queryOrKnex)) {
-            ctx ??= (queryOrKnex.client.transacting ? queryOrKnex : null);
-            const q = queryOrKnex.toSQL();
-            queryOrKnex = q.sql;
-            params = q.bindings;
-        }
-        queryOrKnex = this.config.get('onQuery')(queryOrKnex, params);
-        const formatted = this.platform.formatQuery(queryOrKnex, params);
-        const sql = this.getSql(queryOrKnex, formatted, loggerContext);
+        if (query instanceof query_1.NativeQueryBuilder) {
+            query = query.toRaw();
+        }
+        if (query instanceof core_1.RawQueryFragment) {
+            params = query.params;
+            query = query.sql;
+        }
+        query = this.config.get('onQuery')(query, params);
+        const formatted = this.platform.formatQuery(query, params);
+        const sql = this.getSql(query, formatted, loggerContext);
         return this.executeQuery(sql, async () => {
-            const query = this.getKnex().raw(formatted);
+            const compiled = kysely_1.CompiledQuery.raw(formatted);
             if (ctx) {
-                query.transacting(ctx);
+                const res = await ctx.executeQuery(compiled);
+                return this.transformRawResult(res, method);
             }
-            const res = await query;
+            const res = await this.client.executeQuery(compiled);
             return this.transformRawResult(res, method);
-        }, { query: queryOrKnex, params, ...loggerContext });
+        }, { query, params, ...loggerContext });
     }
     /**
      * Execute raw SQL queries from file
@@ -127,50 +152,14 @@ class AbstractSqlConnection extends core_1.Connection {
     async loadFile(path) {
         const buf = await (0, fs_extra_1.readFile)(path);
         try {
-            await this.getKnex().raw(buf.toString());
+            const raw = kysely_1.CompiledQuery.raw(buf.toString());
+            await this.client.executeQuery(raw);
         }
         catch (e) {
             /* istanbul ignore next */
             throw this.platform.getExceptionConverter().convertException(e);
         }
     }
-    createKnexClient(type) {
-        const driverOptions = this.config.get('driverOptions');
-        if (driverOptions.context?.client instanceof knex_1.knex.Client) {
-            this.logger.log('info', 'Reusing knex client provided via `driverOptions`');
-            return driverOptions;
-        }
-        return (0, knex_1.knex)(this.getKnexOptions(type))
-            .on('query', data => {
-            if (!data.__knexQueryUid) {
-                this.logQuery(data.sql.toLowerCase().replace(/;$/, ''));
-            }
-        });
-    }
-    getKnexOptions(type) {
-        const config = core_1.Utils.mergeConfig({
-            client: type,
-            connection: this.getConnectionOptions(),
-            pool: this.config.get('pool'),
-        }, this.config.get('driverOptions'), this.options.driverOptions);
-        const options = config.connection;
-        const password = options.password;
-        if (!(password instanceof Function)) {
-            return config;
-        }
-        config.connection = async () => {
-            const pw = await password();
-            if (typeof pw === 'string') {
-                return { ...options, password: pw };
-            }
-            return {
-                ...options,
-                password: pw.password,
-                expirationChecker: pw.expirationChecker,
-            };
-        };
-        return config;
-    }
     getSql(query, formatted, context) {
         const logger = this.config.getLogger();
         if (!logger.isEnabled('query', context)) {
@@ -179,34 +168,20 @@ class AbstractSqlConnection extends core_1.Connection {
         if (logger.isEnabled('query-params', context)) {
             return formatted;
         }
-        return this.getKnex().client.positionBindings(query);
+        return query;
     }
-    /**
-     * do not call `positionBindings` when there are no bindings - it was messing up with
-     * already interpolated strings containing `?`, and escaping that was not enough to
-     * support edge cases like `\\?` strings (as `positionBindings` was removing the `\\`)
-     */
-    patchKnexClient() {
-        const { Client, TableCompiler } = MonkeyPatchable_1.MonkeyPatchable;
-        const query = Client.prototype.query;
-        if (AbstractSqlConnection.__patched) {
-            return;
+    transformRawResult(res, method) {
+        if (method === 'get') {
+            return res.rows[0];
         }
-        AbstractSqlConnection.__patched = true;
-        Client.prototype.query = function (connection, obj) {
-            if (typeof obj === 'string') {
-                obj = { sql: obj };
-            }
-            if ((obj.bindings ?? []).length > 0) {
-                return query.call(this, connection, obj);
-            }
-            // eslint-disable-next-line @typescript-eslint/naming-convention
-            const { __knexUid, __knexTxId } = connection;
-            this.emit('query', Object.assign({ __knexUid, __knexTxId }, obj));
-            return MonkeyPatchable_1.MonkeyPatchable.QueryExecutioner.executeQuery(connection, obj, this);
-        };
-        TableCompiler.prototype.raw = function (query) {
-            this.pushQuery(query);
+        if (method === 'all') {
+            return res.rows;
+        }
+        return {
+            affectedRows: Number(res.numAffectedRows ?? res.rows.length),
+            insertId: res.insertId != null ? Number(res.insertId) : res.insertId,
+            row: res.rows[0],
+            rows: res.rows,
         };
     }
 }

package/AbstractSqlDriver.d.ts

@@ -1,8 +1,7 @@
-import type { Knex } from 'knex';
-import { type AnyEntity, type Collection, type Configuration, type ConnectionType, type Constructor, type CountOptions, DatabaseDriver, type DeleteOptions, type Dictionary, type DriverMethodOptions, type EntityData, type EntityDictionary, type EntityField, EntityManagerType, type EntityMetadata, type EntityName, type EntityProperty, type FilterQuery, type FindOneOptions, type FindOptions, type IDatabaseDriver, type LockOptions, type LoggingOptions, type NativeInsertUpdateManyOptions, type NativeInsertUpdateOptions, type ObjectQuery, type Options, type OrderDefinition, type PopulateOptions, type PopulatePath, type Primary, type QueryOrderMap, type QueryResult, type Transaction, type UpsertManyOptions, type UpsertOptions } from '@mikro-orm/core';
+import { type AnyEntity, type Collection, type Configuration, type ConnectionType, type Constructor, type CountOptions, DatabaseDriver, type DeleteOptions, type Dictionary, type DriverMethodOptions, type EntityData, type EntityDictionary, type EntityField, EntityManagerType, type EntityMetadata, type EntityName, type EntityProperty, type FilterQuery, type FindOneOptions, type FindOptions, type IDatabaseDriver, type LockOptions, type LoggingOptions, type NativeInsertUpdateManyOptions, type NativeInsertUpdateOptions, type ObjectQuery, type Options, type OrderDefinition, type PopulateOptions, type PopulatePath, type Primary, type QueryOrderMap, type QueryResult, RawQueryFragment, type Transaction, type UpsertManyOptions, type UpsertOptions } from '@mikro-orm/core';
 import type { AbstractSqlConnection } from './AbstractSqlConnection';
 import type { AbstractSqlPlatform } from './AbstractSqlPlatform';
-import { QueryBuilder, QueryType } from './query';
+import { type NativeQueryBuilder, QueryBuilder, QueryType } from './query';
 import { SqlEntityManager } from './SqlEntityManager';
 import type { Field } from './typings';
 export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlConnection = AbstractSqlConnection, Platform extends AbstractSqlPlatform = AbstractSqlPlatform> extends DatabaseDriver<Connection> {
@@ -37,7 +36,7 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
     syncCollections<T extends object, O extends object>(collections: Iterable<Collection<T, O>>, options?: DriverMethodOptions): Promise<void>;
     loadFromPivotTable<T extends object, O extends object>(prop: EntityProperty, owners: Primary<O>[][], where?: FilterQuery<any>, orderBy?: OrderDefinition<T>, ctx?: Transaction, options?: FindOptions<T, any, any, any>, pivotJoin?: boolean): Promise<Dictionary<T[]>>;
     private getPivotOrderBy;
-    execute<T extends QueryResult | EntityData<AnyEntity> | EntityData<AnyEntity>[] = EntityData<AnyEntity>[]>(queryOrKnex: string | Knex.QueryBuilder | Knex.Raw, params?: any[], method?: 'all' | 'get' | 'run', ctx?: Transaction, loggerContext?: LoggingOptions): Promise<T>;
+    execute<T extends QueryResult | EntityData<AnyEntity> | EntityData<AnyEntity>[] = EntityData<AnyEntity>[]>(query: string | NativeQueryBuilder | RawQueryFragment, params?: any[], method?: 'all' | 'get' | 'run', ctx?: Transaction, loggerContext?: LoggingOptions): Promise<T>;
     /**
      * 1:1 owner side needs to be marked for population so QB auto-joins the owner id
      */
@@ -45,26 +44,22 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
     /**
      * @internal
      */
-    joinedProps<T>(meta: EntityMetadata, populate: PopulateOptions<T>[], options?: {
+    joinedProps<T>(meta: EntityMetadata, populate: readonly PopulateOptions<T>[], options?: {
         strategy?: Options['loadStrategy'];
     }): PopulateOptions<T>[];
     /**
      * @internal
      */
     mergeJoinedResult<T extends object>(rawResults: EntityData<T>[], meta: EntityMetadata<T>, joinedProps: PopulateOptions<T>[]): EntityData<T>[];
-    protected getFieldsForJoinedLoad<T extends object>(qb: QueryBuilder<T, any, any, any>, meta: EntityMetadata<T>, explicitFields?: Field<T>[], exclude?: Field<T>[], populate?: PopulateOptions<T>[], options?: {
-        strategy?: Options['loadStrategy'];
-        populateWhere?: FindOptions<any>['populateWhere'];
-        populateFilter?: FindOptions<any>['populateFilter'];
-    }, parentTableAlias?: string, parentJoinPath?: string, count?: boolean): Field<T>[];
+    protected getFieldsForJoinedLoad<T extends object>(qb: QueryBuilder<T, any, any, any>, meta: EntityMetadata<T>, options: FieldsForJoinedLoadOptions<T>): Field<T>[];
     /**
      * @internal
      */
-    mapPropToFieldNames<T extends object>(qb: QueryBuilder<T, any, any, any>, prop: EntityProperty<T>, tableAlias?: string): Field<T>[];
+    mapPropToFieldNames<T extends object>(qb: QueryBuilder<T, any, any, any>, prop: EntityProperty<T>, tableAlias: string): Field<T>[];
     /** @internal */
-    createQueryBuilder<T extends object>(entityName: EntityName<T> | QueryBuilder<T, any, any, any>, ctx?: Transaction<Knex.Transaction>, preferredConnectionType?: ConnectionType, convertCustomTypes?: boolean, loggerContext?: LoggingOptions, alias?: string, em?: SqlEntityManager): QueryBuilder<T, any, any, any>;
+    createQueryBuilder<T extends object>(entityName: EntityName<T> | QueryBuilder<T, any, any, any>, ctx?: Transaction, preferredConnectionType?: ConnectionType, convertCustomTypes?: boolean, loggerContext?: LoggingOptions, alias?: string, em?: SqlEntityManager): QueryBuilder<T, any, any, any>;
     protected resolveConnectionType(args: {
-        ctx?: Transaction<Knex.Transaction>;
+        ctx?: Transaction;
         connectionType?: ConnectionType;
     }): ConnectionType;
     protected extractManyToMany<T>(entityName: string, data: EntityDictionary<T>): EntityData<T>;
@@ -79,3 +74,15 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
     protected isPopulated<T extends object>(meta: EntityMetadata<T>, prop: EntityProperty<T>, hint: PopulateOptions<T>, name?: string): boolean;
     protected buildFields<T extends object>(meta: EntityMetadata<T>, populate: PopulateOptions<T>[], joinedProps: PopulateOptions<T>[], qb: QueryBuilder<T, any, any, any>, alias: string, options: Pick<FindOptions<T, any, any, any>, 'strategy' | 'fields' | 'exclude'>, count?: boolean): Field<T>[];
 }
+interface FieldsForJoinedLoadOptions<T extends object> {
+    explicitFields?: readonly Field<T>[];
+    exclude?: readonly Field<T>[];
+    populate?: readonly PopulateOptions<T>[];
+    strategy?: Options['loadStrategy'];
+    populateWhere?: FindOptions<any>['populateWhere'];
+    populateFilter?: FindOptions<any>['populateFilter'];
+    parentTableAlias: string;
+    parentJoinPath?: string;
+    count?: boolean;
+}
+export {};