@mikro-orm/knex 7.0.0-dev.0 → 7.0.0-dev.10

package/AbstractSqlConnection.d.ts

@@ -1,7 +1,7 @@
 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';
+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>;

package/AbstractSqlConnection.js

@@ -1,27 +1,24 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AbstractSqlConnection = void 0;
-const kysely_1 = require("kysely");
-const fs_extra_1 = require("fs-extra");
-const core_1 = require("@mikro-orm/core");
-const query_1 = require("./query");
-class AbstractSqlConnection extends core_1.Connection {
+import { CompiledQuery, Kysely, } from 'kysely';
+import { readFile } from 'node:fs/promises';
+import { Connection, EventType, RawQueryFragment, } from '@mikro-orm/core';
+import { NativeQueryBuilder } from './query/NativeQueryBuilder.js';
+export class AbstractSqlConnection extends Connection {
     client;
     async connect() {
         let driverOptions = this.options.driverOptions ?? this.config.get('driverOptions');
         if (typeof driverOptions === 'function') {
             driverOptions = await driverOptions();
         }
-        if (driverOptions instanceof kysely_1.Kysely) {
+        if (driverOptions instanceof 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 });
+            this.client = new Kysely({ dialect: driverOptions });
         }
         else {
-            this.client = new kysely_1.Kysely({
+            this.client = new Kysely({
                 dialect: this.createKyselyDialect(driverOptions),
                 // log: m => console.log(m),
             });
@@ -51,7 +48,7 @@ class AbstractSqlConnection extends core_1.Connection {
             return { ok: false, reason: 'Connection not established' };
         }
         try {
-            await this.client.executeQuery(kysely_1.CompiledQuery.raw('select 1'));
+            await this.client.executeQuery(CompiledQuery.raw('select 1'));
             return { ok: true };
         }
         catch (error) {
@@ -76,57 +73,65 @@ class AbstractSqlConnection extends core_1.Connection {
     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));
+            await options.eventBroadcaster?.dispatchEvent(EventType.afterTransactionStart, trx);
             return trx;
         }
-        await options.eventBroadcaster?.dispatchEvent(core_1.EventType.beforeTransactionStart);
+        await this.ensureConnection();
+        await options.eventBroadcaster?.dispatchEvent(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);
+        await options.eventBroadcaster?.dispatchEvent(EventType.afterTransactionStart, trx);
         return trx;
     }
     async commit(ctx, eventBroadcaster) {
         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;
         }
-        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);
+        else {
+            await ctx.commit().execute();
+            this.logQuery(this.platform.getCommitTransactionSQL());
+        }
+        await eventBroadcaster?.dispatchEvent(EventType.afterTransactionCommit, ctx);
     }
     async rollback(ctx, eventBroadcaster) {
+        await eventBroadcaster?.dispatchEvent(EventType.beforeTransactionRollback, 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);
+        else {
+            await ctx.rollback().execute();
+            this.logQuery(this.platform.getRollbackTransactionSQL());
+        }
+        await eventBroadcaster?.dispatchEvent(EventType.afterTransactionRollback, ctx);
     }
     async execute(query, params = [], method = 'all', ctx, loggerContext) {
         await this.ensureConnection();
-        if (query instanceof query_1.NativeQueryBuilder) {
+        if (query instanceof NativeQueryBuilder) {
             query = query.toRaw();
         }
-        if (query instanceof core_1.RawQueryFragment) {
+        if (query instanceof RawQueryFragment) {
             params = query.params;
             query = query.sql;
         }
@@ -134,7 +139,7 @@ class AbstractSqlConnection extends core_1.Connection {
         const formatted = this.platform.formatQuery(query, params);
         const sql = this.getSql(query, formatted, loggerContext);
         return this.executeQuery(sql, async () => {
-            const compiled = kysely_1.CompiledQuery.raw(formatted);
+            const compiled = CompiledQuery.raw(formatted);
             if (ctx) {
                 const res = await ctx.executeQuery(compiled);
                 return this.transformRawResult(res, method);
@@ -147,13 +152,14 @@ class AbstractSqlConnection extends core_1.Connection {
      * Execute raw SQL queries from file
      */
     async loadFile(path) {
-        const buf = await (0, fs_extra_1.readFile)(path);
+        await this.ensureConnection();
+        const buf = await readFile(path);
         try {
-            const raw = kysely_1.CompiledQuery.raw(buf.toString());
+            const raw = CompiledQuery.raw(buf.toString());
             await this.client.executeQuery(raw);
         }
         catch (e) {
-            /* istanbul ignore next */
+            /* v8 ignore next */
             throw this.platform.getExceptionConverter().convertException(e);
         }
     }
@@ -182,4 +188,3 @@ class AbstractSqlConnection extends core_1.Connection {
         };
     }
 }
-exports.AbstractSqlConnection = AbstractSqlConnection;

package/AbstractSqlDriver.d.ts

@@ -1,9 +1,11 @@
-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 { type NativeQueryBuilder, QueryBuilder, QueryType } from './query';
-import { SqlEntityManager } from './SqlEntityManager';
-import type { Field } from './typings';
+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 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.js';
+import type { AbstractSqlPlatform } from './AbstractSqlPlatform.js';
+import { QueryBuilder } from './query/QueryBuilder.js';
+import { type NativeQueryBuilder } from './query/NativeQueryBuilder.js';
+import { QueryType } from './query/enums.js';
+import { SqlEntityManager } from './SqlEntityManager.js';
+import type { Field } from './typings.js';
 export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlConnection = AbstractSqlConnection, Platform extends AbstractSqlPlatform = AbstractSqlPlatform> extends DatabaseDriver<Connection> {
     [EntityManagerType]: SqlEntityManager<this>;
     protected readonly connection: Connection;
@@ -11,13 +13,13 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
     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, 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>;
+    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: 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;