@mikro-orm/knex 6.0.0-dev.9 → 6.0.0-dev.90

package/AbstractSqlConnection.d.ts

@@ -1,5 +1,5 @@
 import type { Knex } from 'knex';
-import type { AnyEntity, Configuration, ConnectionOptions, EntityData, IsolationLevel, QueryResult, Transaction, TransactionEventBroadcaster } from '@mikro-orm/core';
+import type { AnyEntity, Configuration, ConnectionOptions, EntityData, IsolationLevel, LoggingOptions, QueryResult, Transaction, TransactionEventBroadcaster } from '@mikro-orm/core';
 import { Connection } from '@mikro-orm/core';
 import type { AbstractSqlPlatform } from './AbstractSqlPlatform';
 export declare abstract class AbstractSqlConnection extends Connection {
@@ -7,6 +7,9 @@ export declare abstract class AbstractSqlConnection extends Connection {
     protected platform: AbstractSqlPlatform;
     protected client: Knex;
     constructor(config: Configuration, options?: ConnectionOptions, type?: 'read' | 'write');
+    abstract createKnex(): void;
+    /** @inheritDoc */
+    connect(): void | Promise<void>;
     getKnex(): Knex;
     close(force?: boolean): Promise<void>;
     isConnected(): Promise<boolean>;
@@ -22,7 +25,7 @@ export declare abstract class AbstractSqlConnection extends Connection {
     }): 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): Promise<T>;
+    execute<T extends QueryResult | EntityData<AnyEntity> | EntityData<AnyEntity>[] = EntityData<AnyEntity>[]>(queryOrKnex: string | Knex.QueryBuilder | Knex.Raw, params?: unknown[], method?: 'all' | 'get' | 'run', ctx?: Transaction, logging?: LoggingOptions): Promise<T>;
     /**
      * Execute raw SQL queries from file
      */

package/AbstractSqlConnection.js

@@ -14,16 +14,23 @@ class AbstractSqlConnection extends core_1.Connection {
         super(config, options, type);
         this.patchKnexClient();
     }
+    /** @inheritDoc */
+    connect() {
+        this.createKnex();
+    }
     getKnex() {
+        if (!this.client) {
+            this.createKnex();
+        }
         return this.client;
     }
     async close(force) {
         await super.close(force);
-        await this.client.destroy();
+        await this.getKnex().destroy();
     }
     async isConnected() {
         try {
-            await this.client.raw('select 1');
+            await this.getKnex().raw('select 1');
             return true;
         }
         catch {
@@ -46,7 +53,7 @@ class AbstractSqlConnection extends core_1.Connection {
         if (!options.ctx) {
             await options.eventBroadcaster?.dispatchEvent(core_1.EventType.beforeTransactionStart);
         }
-        const trx = await (options.ctx || this.client).transaction(null, { isolationLevel: options.isolationLevel });
+        const trx = await (options.ctx || this.getKnex()).transaction(null, { isolationLevel: options.isolationLevel });
         if (!options.ctx) {
             await options.eventBroadcaster?.dispatchEvent(core_1.EventType.afterTransactionStart, trx);
         }
@@ -76,30 +83,31 @@ class AbstractSqlConnection extends core_1.Connection {
             await eventBroadcaster?.dispatchEvent(core_1.EventType.afterTransactionRollback, ctx);
         }
     }
-    async execute(queryOrKnex, params = [], method = 'all', ctx) {
+    async execute(queryOrKnex, params = [], method = 'all', ctx, logging) {
+        await this.ensureConnection();
         if (core_1.Utils.isObject(queryOrKnex)) {
-            ctx ?? (ctx = queryOrKnex.client.transacting ? queryOrKnex : null);
+            ctx ??= (queryOrKnex.client.transacting ? queryOrKnex : null);
             const q = queryOrKnex.toSQL();
             queryOrKnex = q.sql;
             params = q.bindings;
         }
         const formatted = this.platform.formatQuery(queryOrKnex, params);
-        const sql = this.getSql(queryOrKnex, formatted);
-        const res = await this.executeQuery(sql, () => {
-            const query = this.client.raw(formatted);
+        const sql = this.getSql(queryOrKnex, formatted, logging);
+        return this.executeQuery(sql, async () => {
+            const query = this.getKnex().raw(formatted);
             if (ctx) {
                 query.transacting(ctx);
             }
-            return query;
-        }, { query: queryOrKnex, params });
-        return this.transformRawResult(res, method);
+            const res = await query;
+            return this.transformRawResult(res, method);
+        }, { query: queryOrKnex, params, ...logging });
     }
     /**
      * Execute raw SQL queries from file
      */
     async loadFile(path) {
         const buf = await (0, fs_extra_1.readFile)(path);
-        await this.client.raw(buf.toString());
+        await this.getKnex().raw(buf.toString());
     }
     createKnexClient(type) {
         const driverOptions = this.config.get('driverOptions');
@@ -115,7 +123,7 @@ class AbstractSqlConnection extends core_1.Connection {
         });
     }
     getKnexOptions(type) {
-        const config = core_1.Utils.merge({
+        const config = core_1.Utils.mergeConfig({
             client: type,
             connection: this.getConnectionOptions(),
             pool: this.config.get('pool'),
@@ -138,15 +146,15 @@ class AbstractSqlConnection extends core_1.Connection {
         };
         return config;
     }
-    getSql(query, formatted) {
+    getSql(query, formatted, context) {
         const logger = this.config.getLogger();
-        if (!logger.isEnabled('query')) {
+        if (!logger.isEnabled('query', context)) {
             return query;
         }
-        if (logger.isEnabled('query-params')) {
+        if (logger.isEnabled('query-params', context)) {
             return formatted;
         }
-        return this.client.client.positionBindings(query);
+        return this.getKnex().client.positionBindings(query);
     }
     /**
      * do not call `positionBindings` when there are no bindings - it was messing up with

package/AbstractSqlDriver.d.ts

@@ -1,26 +1,26 @@
 import type { Knex } from 'knex';
-import type { AnyEntity, Collection, ConnectionType, Configuration, Constructor, CountOptions, DeleteOptions, Dictionary, DriverMethodOptions, EntityData, EntityDictionary, EntityField, EntityMetadata, EntityName, EntityProperty, FilterQuery, FindOneOptions, FindOptions, IDatabaseDriver, LockOptions, NativeInsertUpdateManyOptions, NativeInsertUpdateOptions, PopulateOptions, Primary, QueryOrderMap, QueryResult, Transaction } from '@mikro-orm/core';
+import type { AnyEntity, Collection, ConnectionType, Configuration, Constructor, CountOptions, DeleteOptions, Dictionary, DriverMethodOptions, EntityData, EntityDictionary, EntityField, EntityMetadata, EntityName, EntityProperty, FilterQuery, FindOneOptions, FindOptions, IDatabaseDriver, LockOptions, NativeInsertUpdateManyOptions, NativeInsertUpdateOptions, PopulateOptions, Primary, QueryOrderMap, QueryResult, Transaction, OrderDefinition, LoggingOptions } from '@mikro-orm/core';
 import { DatabaseDriver, EntityManagerType } from '@mikro-orm/core';
 import type { AbstractSqlConnection } from './AbstractSqlConnection';
 import type { AbstractSqlPlatform } from './AbstractSqlPlatform';
 import { QueryBuilder, QueryType } from './query';
 import { SqlEntityManager } from './SqlEntityManager';
 import type { Field } from './typings';
-export declare abstract class AbstractSqlDriver<C extends AbstractSqlConnection = AbstractSqlConnection> extends DatabaseDriver<C> {
+export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlConnection = AbstractSqlConnection, Platform extends AbstractSqlPlatform = AbstractSqlPlatform> extends DatabaseDriver<Connection> {
     [EntityManagerType]: SqlEntityManager<this>;
-    protected readonly connection: C;
-    protected readonly replicas: C[];
-    protected readonly platform: AbstractSqlPlatform;
-    protected constructor(config: Configuration, platform: AbstractSqlPlatform, connection: Constructor<C>, connector: string[]);
-    getPlatform(): AbstractSqlPlatform;
+    protected readonly connection: Connection;
+    protected readonly replicas: Connection[];
+    protected readonly platform: Platform;
+    protected constructor(config: Configuration, platform: Platform, connection: Constructor<Connection>, connector: string[]);
+    getPlatform(): Platform;
     createEntityManager<D extends IDatabaseDriver = IDatabaseDriver>(useContext?: boolean): D[typeof EntityManagerType];
-    find<T extends object, P extends string = never>(entityName: string, where: FilterQuery<T>, options?: FindOptions<T, P>): Promise<EntityData<T>[]>;
-    findOne<T extends object, P extends string = never>(entityName: string, where: FilterQuery<T>, options?: FindOneOptions<T, P>): Promise<EntityData<T> | null>;
-    findVirtual<T extends object>(entityName: string, where: FilterQuery<T>, options: FindOptions<T, any>): Promise<EntityData<T>[]>;
+    find<T extends object, P extends string = never, F extends string = '*'>(entityName: string, where: FilterQuery<T>, options?: FindOptions<T, P, F>): Promise<EntityData<T>[]>;
+    findOne<T extends object, P extends string = never, F extends string = '*'>(entityName: string, where: FilterQuery<T>, options?: FindOneOptions<T, P, F>): Promise<EntityData<T> | null>;
+    findVirtual<T extends object>(entityName: string, where: FilterQuery<T>, options: FindOptions<T, any, any>): Promise<EntityData<T>[]>;
     countVirtual<T extends object>(entityName: string, where: FilterQuery<T>, options: CountOptions<T>): Promise<number>;
-    protected wrapVirtualExpressionInSubquery<T extends object>(meta: EntityMetadata<T>, expression: string, where: FilterQuery<T>, options: FindOptions<T, any>, type: QueryType.COUNT): Promise<number>;
-    protected wrapVirtualExpressionInSubquery<T extends object>(meta: EntityMetadata<T>, expression: string, where: FilterQuery<T>, options: FindOptions<T, any>, type: QueryType.SELECT): Promise<T[]>;
-    protected wrapVirtualExpressionInSubquery<T extends object>(meta: EntityMetadata<T>, expression: string, where: FilterQuery<T>, options: FindOptions<T, any>): Promise<T[]>;
+    protected wrapVirtualExpressionInSubquery<T extends object>(meta: EntityMetadata<T>, expression: string, where: FilterQuery<T>, options: FindOptions<T, any, any>, type: QueryType.COUNT): Promise<number>;
+    protected wrapVirtualExpressionInSubquery<T extends object>(meta: EntityMetadata<T>, expression: string, where: FilterQuery<T>, options: FindOptions<T, any, any>, type: QueryType.SELECT): Promise<T[]>;
+    protected wrapVirtualExpressionInSubquery<T extends object>(meta: EntityMetadata<T>, expression: string, where: FilterQuery<T>, options: FindOptions<T, any, any>): Promise<T[]>;
     mapResult<T extends object>(result: EntityData<T>, meta: EntityMetadata<T>, populate?: PopulateOptions<T>[], qb?: QueryBuilder<T>, map?: Dictionary): EntityData<T> | null;
     private mapJoinedProps;
     private appendToCollection;
@@ -31,12 +31,13 @@ export declare abstract class AbstractSqlDriver<C extends AbstractSqlConnection
     nativeUpdateMany<T extends object>(entityName: string, where: FilterQuery<T>[], data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T>): Promise<QueryResult<T>>;
     nativeDelete<T extends object>(entityName: string, where: FilterQuery<T> | string | any, options?: DeleteOptions<T>): Promise<QueryResult<T>>;
     syncCollection<T extends object, O extends object>(coll: Collection<T, O>, options?: DriverMethodOptions): Promise<void>;
-    loadFromPivotTable<T extends object, O extends object>(prop: EntityProperty, owners: Primary<O>[][], where?: FilterQuery<any>, orderBy?: QueryOrderMap<T>[], ctx?: Transaction, options?: FindOptions<T, any>): Promise<Dictionary<T[]>>;
+    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>): 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): Promise<T>;
     /**
      * 1:1 owner side needs to be marked for population so QB auto-joins the owner id
      */
-    protected autoJoinOneToOneOwner<T extends object, P extends string = never>(meta: EntityMetadata, populate: PopulateOptions<T>[], fields?: readonly EntityField<T, P>[]): PopulateOptions<T>[];
+    protected autoJoinOneToOneOwner<T extends object, P extends string = never>(meta: EntityMetadata<T>, populate: PopulateOptions<T>[], fields?: readonly EntityField<T, P>[]): PopulateOptions<T>[];
     protected joinedProps<T>(meta: EntityMetadata, populate: PopulateOptions<T>[]): PopulateOptions<T>[];
     /**
      * @internal
@@ -48,17 +49,17 @@ export declare abstract class AbstractSqlDriver<C extends AbstractSqlConnection
      */
     mapPropToFieldNames<T extends object>(qb: QueryBuilder<T>, prop: EntityProperty<T>, tableAlias?: string): Field<T>[];
     /** @internal */
-    createQueryBuilder<T extends object>(entityName: EntityName<T> | QueryBuilder<T>, ctx?: Transaction<Knex.Transaction>, preferredConnectionType?: ConnectionType, convertCustomTypes?: boolean): QueryBuilder<T>;
+    createQueryBuilder<T extends object>(entityName: EntityName<T> | QueryBuilder<T>, ctx?: Transaction<Knex.Transaction>, preferredConnectionType?: ConnectionType, convertCustomTypes?: boolean, logging?: LoggingOptions): QueryBuilder<T>;
     protected resolveConnectionType(args: {
         ctx?: Transaction<Knex.Transaction>;
         connectionType?: ConnectionType;
     }): ConnectionType;
     protected extractManyToMany<T>(entityName: string, data: EntityDictionary<T>): EntityData<T>;
     protected processManyToMany<T extends object>(meta: EntityMetadata<T> | undefined, pks: Primary<T>[], collections: EntityData<T>, clear: boolean, options?: DriverMethodOptions): Promise<void>;
-    protected updateCollectionDiff<T extends object, O extends object>(meta: EntityMetadata<O>, prop: EntityProperty<T>, pks: Primary<O>[], deleteDiff: Primary<T>[][] | boolean, insertDiff: Primary<T>[][], options?: DriverMethodOptions & {
+    protected updateCollectionDiff<T extends object, O extends object>(meta: EntityMetadata<O>, prop: EntityProperty<O>, pks: Primary<O>[], deleteDiff: Primary<T>[][] | boolean, insertDiff: Primary<T>[][], options?: DriverMethodOptions & {
         ownerSchema?: string;
     }): Promise<void>;
-    lockPessimistic<T>(entity: T, options: LockOptions): Promise<void>;
+    lockPessimistic<T extends object>(entity: T, options: LockOptions): Promise<void>;
     protected buildJoinedPropsOrderBy<T extends object>(entityName: string, qb: QueryBuilder<T>, meta: EntityMetadata<T>, populate: PopulateOptions<T>[], parentPath?: string): QueryOrderMap<T>[];
     protected normalizeFields<T extends object>(fields: Field<T>[], prefix?: string): string[];
     protected processField<T extends object>(meta: EntityMetadata<T>, prop: EntityProperty<T> | undefined, field: string, ret: Field<T>[], populate: PopulateOptions<T>[], joinedProps: PopulateOptions<T>[], qb: QueryBuilder<T>): void;