@mikro-orm/knex 7.0.0-dev.3 → 7.0.0-dev.31

package/AbstractSqlConnection.d.ts

@@ -1,11 +1,11 @@
 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 AnyEntity, Connection, type Dictionary, type EntityData, type IsolationLevel, type LogContext, type LoggingOptions, type MaybePromise, type QueryResult, RawQueryFragment, type Transaction, type TransactionEventBroadcaster } from '@mikro-orm/core';
 import type { AbstractSqlPlatform } from './AbstractSqlPlatform.js';
 import { NativeQueryBuilder } from './query/NativeQueryBuilder.js';
 export declare abstract class AbstractSqlConnection extends Connection {
     protected platform: AbstractSqlPlatform;
     protected client: Kysely<any>;
-    abstract createKyselyDialect(overrides: Dictionary): Dialect;
+    abstract createKyselyDialect(overrides: Dictionary): MaybePromise<Dialect>;
     connect(): Promise<void>;
     /**
      * @inheritDoc
@@ -31,15 +31,17 @@ export declare abstract class AbstractSqlConnection extends Connection {
         readOnly?: boolean;
         ctx?: ControlledTransaction<any>;
         eventBroadcaster?: TransactionEventBroadcaster;
+        loggerContext?: LogContext;
     }): Promise<T>;
     begin(options?: {
         isolationLevel?: IsolationLevel;
         readOnly?: boolean;
         ctx?: ControlledTransaction<any, any>;
         eventBroadcaster?: TransactionEventBroadcaster;
+        loggerContext?: LogContext;
     }): Promise<ControlledTransaction<any, any>>;
-    commit(ctx: ControlledTransaction<any, any>, eventBroadcaster?: TransactionEventBroadcaster): Promise<void>;
-    rollback(ctx: ControlledTransaction<any, any>, eventBroadcaster?: TransactionEventBroadcaster): Promise<void>;
+    commit(ctx: ControlledTransaction<any, any>, eventBroadcaster?: TransactionEventBroadcaster, loggerContext?: LogContext): Promise<void>;
+    rollback(ctx: ControlledTransaction<any, any>, eventBroadcaster?: TransactionEventBroadcaster, loggerContext?: LogContext): 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

package/AbstractSqlConnection.js

@@ -19,8 +19,7 @@ export class AbstractSqlConnection extends Connection {
         }
         else {
             this.client = new Kysely({
-                dialect: this.createKyselyDialect(driverOptions),
-                // log: m => console.log(m),
+                dialect: await this.createKyselyDialect(driverOptions),
             });
         }
         this.connected = true;
@@ -62,25 +61,28 @@ export class AbstractSqlConnection extends Connection {
         const trx = await this.begin(options);
         try {
             const ret = await cb(trx);
-            await this.commit(trx, options.eventBroadcaster);
+            await this.commit(trx, options.eventBroadcaster, options.loggerContext);
             return ret;
         }
         catch (error) {
-            await this.rollback(trx, options.eventBroadcaster);
+            await this.rollback(trx, options.eventBroadcaster, options.loggerContext);
             throw error;
         }
     }
     async begin(options = {}) {
         if (options.ctx) {
             const ctx = options.ctx;
+            await options.eventBroadcaster?.dispatchEvent(EventType.beforeTransactionStart, 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));
+            this.logQuery(this.platform.getSavepointSQL(savepointName), options.loggerContext);
+            await options.eventBroadcaster?.dispatchEvent(EventType.afterTransactionStart, trx);
             return trx;
         }
+        await this.ensureConnection();
         await options.eventBroadcaster?.dispatchEvent(EventType.beforeTransactionStart);
         let trxBuilder = this.client.startTransaction();
         if (options.isolationLevel) {
@@ -90,35 +92,47 @@ export class AbstractSqlConnection extends Connection {
             trxBuilder = trxBuilder.setAccessMode('read only');
         }
         const trx = await trxBuilder.execute();
-        for (const query of this.platform.getBeginTransactionSQL(options)) {
-            this.logQuery(query);
+        if (options.ctx) {
+            const ctx = options.ctx;
+            ctx.index ??= 0;
+            const savepointName = `trx${ctx.index + 1}`;
+            Reflect.defineProperty(trx, 'index', { value: ctx.index + 1 });
+            Reflect.defineProperty(trx, 'savepointName', { value: savepointName });
+            this.logQuery(this.platform.getSavepointSQL(savepointName), options.loggerContext);
+        }
+        else {
+            for (const query of this.platform.getBeginTransactionSQL(options)) {
+                this.logQuery(query, options.loggerContext);
+            }
         }
         await options.eventBroadcaster?.dispatchEvent(EventType.afterTransactionStart, trx);
         return trx;
     }
-    async commit(ctx, eventBroadcaster) {
+    async commit(ctx, eventBroadcaster, loggerContext) {
         if (ctx.isRolledBack) {
             return;
         }
+        await eventBroadcaster?.dispatchEvent(EventType.beforeTransactionCommit, ctx);
         if ('savepointName' in ctx) {
             await ctx.releaseSavepoint(ctx.savepointName).execute();
-            this.logQuery(this.platform.getReleaseSavepointSQL(ctx.savepointName));
-            return;
+            this.logQuery(this.platform.getReleaseSavepointSQL(ctx.savepointName), loggerContext);
+        }
+        else {
+            await ctx.commit().execute();
+            this.logQuery(this.platform.getCommitTransactionSQL(), loggerContext);
         }
-        await eventBroadcaster?.dispatchEvent(EventType.beforeTransactionCommit, ctx);
-        await ctx.commit().execute();
-        this.logQuery(this.platform.getCommitTransactionSQL());
         await eventBroadcaster?.dispatchEvent(EventType.afterTransactionCommit, ctx);
     }
-    async rollback(ctx, eventBroadcaster) {
+    async rollback(ctx, eventBroadcaster, loggerContext) {
+        await eventBroadcaster?.dispatchEvent(EventType.beforeTransactionRollback, ctx);
         if ('savepointName' in ctx) {
             await ctx.rollbackToSavepoint(ctx.savepointName).execute();
-            this.logQuery(this.platform.getRollbackToSavepointSQL(ctx.savepointName));
-            return;
+            this.logQuery(this.platform.getRollbackToSavepointSQL(ctx.savepointName), loggerContext);
+        }
+        else {
+            await ctx.rollback().execute();
+            this.logQuery(this.platform.getRollbackTransactionSQL(), loggerContext);
         }
-        await eventBroadcaster?.dispatchEvent(EventType.beforeTransactionRollback, ctx);
-        await ctx.rollback().execute();
-        this.logQuery(this.platform.getRollbackTransactionSQL());
         await eventBroadcaster?.dispatchEvent(EventType.afterTransactionRollback, ctx);
     }
     async execute(query, params = [], method = 'all', ctx, loggerContext) {

package/AbstractSqlDriver.d.ts

@@ -14,12 +14,12 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
     protected constructor(config: Configuration, platform: Platform, connection: Constructor<Connection>, connector: string[]);
     getPlatform(): Platform;
     createEntityManager(useContext?: boolean): this[typeof EntityManagerType];
-    find<T extends object, P extends string = never, F extends string = PopulatePath.ALL, 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 = PopulatePath.ALL, E extends string = never>(entityName: string, where: FilterQuery<T>, options?: FindOneOptions<T, P, F, E>): Promise<EntityData<T> | null>;
+    find<T extends object, P extends string = never, F extends string = PopulatePath.ALL, E extends string = never>(entityName: string, where: ObjectQuery<T>, options?: FindOptions<T, P, F, E>): Promise<EntityData<T>[]>;
+    findOne<T extends object, P extends string = never, F extends string = PopulatePath.ALL, E extends string = never>(entityName: string, where: ObjectQuery<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>;
+    findVirtual<T extends object>(entityName: string, where: ObjectQuery<T>, options: FindOptions<T, any, any, any>): Promise<EntityData<T>[]>;
+    countVirtual<T extends object>(entityName: string, where: ObjectQuery<T>, options: CountOptions<T, any>): Promise<number>;
+    protected findFromVirtual<T extends object>(entityName: string, where: ObjectQuery<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, any, any, any>, map?: Dictionary): EntityData<T> | null;
     private mapJoinedProps;
@@ -72,9 +72,9 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
     protected buildPopulateOrderBy<T extends object>(qb: QueryBuilder<T, any, any, any>, meta: EntityMetadata<T>, populateOrderBy: QueryOrderMap<T>[], parentPath: string, explicit: boolean, parentAlias?: string): QueryOrderMap<T>[];
     protected buildJoinedPropsOrderBy<T extends object>(qb: QueryBuilder<T, any, any, any>, 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, any, any, any>): void;
+    protected processField<T extends object>(meta: EntityMetadata<T>, prop: EntityProperty<T> | undefined, field: string, ret: Field<T>[]): void;
     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>[];
+    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'>): Field<T>[];
 }
 interface FieldsForJoinedLoadOptions<T extends object> {
     explicitFields?: readonly Field<T>[];