@mikro-orm/knex 6.0.0-dev.32 → 6.0.0-dev.321

package/AbstractSqlConnection.d.ts

@@ -1,28 +1,46 @@
-import type { Knex } from 'knex';
-import type { AnyEntity, Configuration, ConnectionOptions, EntityData, IsolationLevel, QueryResult, Transaction, TransactionEventBroadcaster } from '@mikro-orm/core';
-import { Connection } from '@mikro-orm/core';
+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 { AbstractSqlPlatform } from './AbstractSqlPlatform';
 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;
+    /**
+     * @inheritDoc
+     */
     close(force?: boolean): Promise<void>;
+    /**
+     * @inheritDoc
+     */
     isConnected(): Promise<boolean>;
+    /**
+     * @inheritDoc
+     */
+    checkConnection(): Promise<{
+        ok: boolean;
+        reason?: string;
+        error?: Error;
+    }>;
     transactional<T>(cb: (trx: Transaction<Knex.Transaction>) => Promise<T>, options?: {
         isolationLevel?: IsolationLevel;
+        readOnly?: boolean;
         ctx?: Knex.Transaction;
         eventBroadcaster?: TransactionEventBroadcaster;
     }): Promise<T>;
     begin(options?: {
         isolationLevel?: IsolationLevel;
+        readOnly?: boolean;
         ctx?: Knex.Transaction;
         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): 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, loggerContext?: LoggingOptions): Promise<T>;
     /**
      * Execute raw SQL queries from file
      */

package/AbstractSqlConnection.js

@@ -10,24 +10,46 @@ function isRootTransaction(trx) {
     return !Object.getOwnPropertySymbols(trx).includes(parentTransactionSymbol);
 }
 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();
+        }
         return this.client;
     }
+    /**
+     * @inheritDoc
+     */
     async close(force) {
         await super.close(force);
-        await this.client.destroy();
+        await this.getKnex().destroy();
     }
+    /**
+     * @inheritDoc
+     */
     async isConnected() {
+        const check = await this.checkConnection();
+        return check.ok;
+    }
+    /**
+     * @inheritDoc
+     */
+    async checkConnection() {
         try {
-            await this.client.raw('select 1');
-            return true;
+            await this.getKnex().raw('select 1');
+            return { ok: true };
         }
-        catch {
-            return false;
+        catch (error) {
+            return { ok: false, reason: error.message, error };
         }
     }
     async transactional(cb, options = {}) {
@@ -46,7 +68,10 @@ 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,
+            readOnly: options.readOnly,
+        });
         if (!options.ctx) {
             await options.eventBroadcaster?.dispatchEvent(core_1.EventType.afterTransactionStart, trx);
         }
@@ -76,7 +101,8 @@ 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, loggerContext) {
+        await this.ensureConnection();
         if (core_1.Utils.isObject(queryOrKnex)) {
             ctx ??= (queryOrKnex.client.transacting ? queryOrKnex : null);
             const q = queryOrKnex.toSQL();
@@ -84,22 +110,22 @@ class AbstractSqlConnection extends core_1.Connection {
             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, loggerContext);
+        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, ...loggerContext });
     }
     /**
      * 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 +141,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 +164,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
@@ -178,4 +204,3 @@ class AbstractSqlConnection extends core_1.Connection {
     }
 }
 exports.AbstractSqlConnection = AbstractSqlConnection;
-AbstractSqlConnection.__patched = false;

package/AbstractSqlDriver.d.ts

@@ -1,6 +1,5 @@
 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 { DatabaseDriver, EntityManagerType } 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 Options, type OrderDefinition, type PopulateOptions, type Primary, type QueryOrderMap, type QueryResult, 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';
@@ -14,53 +13,60 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
     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>[]>;
-    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[]>;
+    find<T extends object, P extends string = never, F extends string = '*', E extends string = never>(entityName: string, where: FilterQuery<T>, options?: FindOptions<T, P, F, E>): Promise<EntityData<T>[]>;
+    findOne<T extends object, P extends string = never, F extends string = '*', E extends string = never>(entityName: string, where: FilterQuery<T>, options?: FindOneOptions<T, P, F, E>): Promise<EntityData<T> | null>;
+    protected hasToManyJoins<T extends object>(hint: PopulateOptions<T>, meta: EntityMetadata<T>): boolean;
+    findVirtual<T extends object>(entityName: string, where: FilterQuery<T>, options: FindOptions<T, any, any, any>): Promise<EntityData<T>[]>;
+    countVirtual<T extends object>(entityName: string, where: FilterQuery<T>, options: CountOptions<T, any>): Promise<number>;
+    protected findFromVirtual<T extends object>(entityName: string, where: FilterQuery<T>, options: FindOptions<T, any> | CountOptions<T, any>, type: QueryType): Promise<EntityData<T>[] | number>;
+    protected wrapVirtualExpressionInSubquery<T extends object>(meta: EntityMetadata<T>, expression: string, where: FilterQuery<T>, options: FindOptions<T, any>, type: QueryType): Promise<T[] | number>;
     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;
     count<T extends object>(entityName: string, where: any, options?: CountOptions<T>): Promise<number>;
     nativeInsert<T extends object>(entityName: string, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T>): Promise<QueryResult<T>>;
     nativeInsertMany<T extends object>(entityName: string, data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T>): Promise<QueryResult<T>>;
-    nativeUpdate<T extends object>(entityName: string, where: FilterQuery<T>, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T>): Promise<QueryResult<T>>;
-    nativeUpdateMany<T extends object>(entityName: string, where: FilterQuery<T>[], data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T>): Promise<QueryResult<T>>;
+    nativeUpdate<T extends object>(entityName: string, where: FilterQuery<T>, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T> & UpsertOptions<T>): Promise<QueryResult<T>>;
+    nativeUpdateMany<T extends object>(entityName: string, where: FilterQuery<T>[], data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T> & UpsertManyOptions<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[]>>;
+    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): 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<T>, populate: PopulateOptions<T>[], fields?: readonly EntityField<T, P>[]): PopulateOptions<T>[];
-    protected joinedProps<T>(meta: EntityMetadata, populate: PopulateOptions<T>[]): PopulateOptions<T>[];
+    protected autoJoinOneToOneOwner<T extends object>(meta: EntityMetadata<T>, populate: PopulateOptions<T>[], fields?: readonly EntityField<T, any>[]): PopulateOptions<T>[];
     /**
      * @internal
      */
-    mergeJoinedResult<T extends object>(rawResults: EntityData<T>[], meta: EntityMetadata<T>): EntityData<T>[];
-    protected getFieldsForJoinedLoad<T extends object>(qb: QueryBuilder<T>, meta: EntityMetadata<T>, explicitFields?: Field<T>[], populate?: PopulateOptions<T>[], parentTableAlias?: string, parentJoinPath?: string): Field<T>[];
+    joinedProps<T>(meta: EntityMetadata, populate: 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>, meta: EntityMetadata<T>, explicitFields?: Field<T>[], exclude?: Field<T>[], populate?: PopulateOptions<T>[], options?: {
+        strategy?: Options['loadStrategy'];
+        populateWhere?: FindOptions<any>['populateWhere'];
+    }, parentTableAlias?: string, parentJoinPath?: string): Field<T>[];
     /**
      * @internal
      */
     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, loggerContext?: 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 & {
-        ownerSchema?: string;
-    }): 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 buildOrderBy<T extends object>(qb: QueryBuilder<T>, meta: EntityMetadata<T>, populate: PopulateOptions<T>[], options: Pick<FindOptions<any>, 'strategy' | 'orderBy' | 'populateOrderBy'>): QueryOrderMap<T>[];
+    protected buildPopulateOrderBy<T extends object>(qb: QueryBuilder<T>, meta: EntityMetadata<T>, populateOrderBy: QueryOrderMap<T>[], parentPath: string, parentAlias?: string): QueryOrderMap<T>[];
+    protected buildJoinedPropsOrderBy<T extends object>(qb: QueryBuilder<T>, meta: EntityMetadata<T>, populate: PopulateOptions<T>[], options?: Pick<FindOptions<any>, 'strategy' | 'orderBy' | 'populateOrderBy'>, 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;
-    protected buildFields<T extends object>(meta: EntityMetadata<T>, populate: PopulateOptions<T>[], joinedProps: PopulateOptions<T>[], qb: QueryBuilder<T>, fields?: Field<T>[]): Field<T>[];
+    protected buildFields<T extends object>(meta: EntityMetadata<T>, populate: PopulateOptions<T>[], joinedProps: PopulateOptions<T>[], qb: QueryBuilder<T>, alias: string, options: Pick<FindOptions<T, any, any, any>, 'strategy' | 'fields' | 'exclude'>): Field<T>[];
 }