@mikro-orm/sql 7.0.4 → 7.0.5-dev.0

package/AbstractSqlConnection.js

@@ -1,257 +1,260 @@
 import { CompiledQuery, Kysely } from 'kysely';
-import { Connection, EventType, RawQueryFragment, Utils } from '@mikro-orm/core';
+import { Connection, EventType, RawQueryFragment, Utils, } from '@mikro-orm/core';
 import { NativeQueryBuilder } from './query/NativeQueryBuilder.js';
 /** Base class for SQL database connections, built on top of Kysely. */
 export class AbstractSqlConnection extends Connection {
-  #client;
-  /** Establishes the database connection and runs the onConnect hook. */
-  async connect(options) {
-    await this.initClient();
-    this.connected = true;
-    if (options?.skipOnConnect !== true) {
-      await this.onConnect();
-    }
-  }
-  /** Initializes the Kysely client from driver options or a user-provided Kysely instance. */
-  createKysely() {
-    let driverOptions = this.options.driverOptions ?? this.config.get('driverOptions');
-    if (typeof driverOptions === 'function') {
-      driverOptions = driverOptions();
-    }
-    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({ dialect: driverOptions });
-    } else {
-      const dialect = this.createKyselyDialect(driverOptions);
-      if (dialect instanceof Promise) {
-        return dialect.then(d => {
-          this.#client = new Kysely({ dialect: d });
-        });
-      }
-      this.#client = new Kysely({ dialect });
-    }
-  }
-  /**
-   * @inheritDoc
-   */
-  async close(force) {
-    await super.close(force);
-    await this.#client?.destroy();
-    this.connected = false;
-    this.#client = undefined;
-  }
-  /**
-   * @inheritDoc
-   */
-  async isConnected() {
-    const check = await this.checkConnection();
-    return check.ok;
-  }
-  /**
-   * @inheritDoc
-   */
-  async checkConnection() {
-    if (!this.connected) {
-      return { ok: false, reason: 'Connection not established' };
-    }
-    try {
-      await this.getClient().executeQuery(CompiledQuery.raw('select 1'));
-      return { ok: true };
-    } catch (error) {
-      return { ok: false, reason: error.message, error };
-    }
-  }
-  /** Returns the underlying Kysely client, creating it synchronously if needed. */
-  getClient() {
-    if (!this.#client) {
-      const maybePromise = this.createKysely();
-      /* v8 ignore next */
-      if (maybePromise instanceof Promise) {
-        throw new Error(
-          'Current driver requires async initialization, use `MikroORM.init()` instead of the constructor',
-        );
-      }
-    }
-    return this.#client;
-  }
-  /** Ensures the Kysely client is initialized, creating it asynchronously if needed. */
-  async initClient() {
-    if (!this.#client) {
-      await this.createKysely();
+    #client;
+    /** Establishes the database connection and runs the onConnect hook. */
+    async connect(options) {
+        await this.initClient();
+        this.connected = true;
+        if (options?.skipOnConnect !== true) {
+            await this.onConnect();
+        }
     }
-  }
-  /** Executes a callback within a transaction, committing on success and rolling back on error. */
-  async transactional(cb, options = {}) {
-    const trx = await this.begin(options);
-    try {
-      const ret = await cb(trx);
-      await this.commit(trx, options.eventBroadcaster, options.loggerContext);
-      return ret;
-    } catch (error) {
-      await this.rollback(trx, options.eventBroadcaster, options.loggerContext);
-      throw error;
+    /** Initializes the Kysely client from driver options or a user-provided Kysely instance. */
+    createKysely() {
+        let driverOptions = this.options.driverOptions ?? this.config.get('driverOptions');
+        if (typeof driverOptions === 'function') {
+            driverOptions = driverOptions();
+        }
+        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({ dialect: driverOptions });
+        }
+        else {
+            const dialect = this.createKyselyDialect(driverOptions);
+            if (dialect instanceof Promise) {
+                return dialect.then(d => {
+                    this.#client = new Kysely({ dialect: d });
+                });
+            }
+            this.#client = new Kysely({ dialect });
+        }
     }
-  }
-  /** Begins a new transaction or creates a savepoint if a transaction context already exists. */
-  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), options.loggerContext);
-      await options.eventBroadcaster?.dispatchEvent(EventType.afterTransactionStart, trx);
-      return trx;
+    /**
+     * @inheritDoc
+     */
+    async close(force) {
+        await super.close(force);
+        await this.#client?.destroy();
+        this.connected = false;
+        this.#client = undefined;
     }
-    await this.ensureConnection();
-    await options.eventBroadcaster?.dispatchEvent(EventType.beforeTransactionStart);
-    let trxBuilder = this.getClient().startTransaction();
-    if (options.isolationLevel) {
-      trxBuilder = trxBuilder.setIsolationLevel(options.isolationLevel);
+    /**
+     * @inheritDoc
+     */
+    async isConnected() {
+        const check = await this.checkConnection();
+        return check.ok;
     }
-    if (options.readOnly) {
-      trxBuilder = trxBuilder.setAccessMode('read only');
+    /**
+     * @inheritDoc
+     */
+    async checkConnection() {
+        if (!this.connected) {
+            return { ok: false, reason: 'Connection not established' };
+        }
+        try {
+            await this.getClient().executeQuery(CompiledQuery.raw('select 1'));
+            return { ok: true };
+        }
+        catch (error) {
+            return { ok: false, reason: error.message, error };
+        }
     }
-    const trx = await trxBuilder.execute();
-    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);
-      }
+    /** Returns the underlying Kysely client, creating it synchronously if needed. */
+    getClient() {
+        if (!this.#client) {
+            const maybePromise = this.createKysely();
+            /* v8 ignore next */
+            if (maybePromise instanceof Promise) {
+                throw new Error('Current driver requires async initialization, use `MikroORM.init()` instead of the constructor');
+            }
+        }
+        return this.#client;
     }
-    await options.eventBroadcaster?.dispatchEvent(EventType.afterTransactionStart, trx);
-    return trx;
-  }
-  /** Commits the transaction or releases the savepoint. */
-  async commit(ctx, eventBroadcaster, loggerContext) {
-    if (ctx.isRolledBack) {
-      return;
+    /** Ensures the Kysely client is initialized, creating it asynchronously if needed. */
+    async initClient() {
+        if (!this.#client) {
+            await this.createKysely();
+        }
     }
-    await eventBroadcaster?.dispatchEvent(EventType.beforeTransactionCommit, ctx);
-    if ('savepointName' in ctx) {
-      await ctx.releaseSavepoint(ctx.savepointName).execute();
-      this.logQuery(this.platform.getReleaseSavepointSQL(ctx.savepointName), loggerContext);
-    } else {
-      await ctx.commit().execute();
-      this.logQuery(this.platform.getCommitTransactionSQL(), loggerContext);
+    /** Executes a callback within a transaction, committing on success and rolling back on error. */
+    async transactional(cb, options = {}) {
+        const trx = await this.begin(options);
+        try {
+            const ret = await cb(trx);
+            await this.commit(trx, options.eventBroadcaster, options.loggerContext);
+            return ret;
+        }
+        catch (error) {
+            await this.rollback(trx, options.eventBroadcaster, options.loggerContext);
+            throw error;
+        }
     }
-    await eventBroadcaster?.dispatchEvent(EventType.afterTransactionCommit, ctx);
-  }
-  /** Rolls back the transaction or rolls back to the savepoint. */
-  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), loggerContext);
-    } else {
-      await ctx.rollback().execute();
-      this.logQuery(this.platform.getRollbackTransactionSQL(), loggerContext);
+    /** Begins a new transaction or creates a savepoint if a transaction context already exists. */
+    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), options.loggerContext);
+            await options.eventBroadcaster?.dispatchEvent(EventType.afterTransactionStart, trx);
+            return trx;
+        }
+        await this.ensureConnection();
+        await options.eventBroadcaster?.dispatchEvent(EventType.beforeTransactionStart);
+        let trxBuilder = this.getClient().startTransaction();
+        if (options.isolationLevel) {
+            trxBuilder = trxBuilder.setIsolationLevel(options.isolationLevel);
+        }
+        if (options.readOnly) {
+            trxBuilder = trxBuilder.setAccessMode('read only');
+        }
+        const trx = await trxBuilder.execute();
+        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;
     }
-    await eventBroadcaster?.dispatchEvent(EventType.afterTransactionRollback, ctx);
-  }
-  prepareQuery(query, params = []) {
-    if (query instanceof NativeQueryBuilder) {
-      query = query.toRaw();
+    /** Commits the transaction or releases the savepoint. */
+    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), loggerContext);
+        }
+        else {
+            await ctx.commit().execute();
+            this.logQuery(this.platform.getCommitTransactionSQL(), loggerContext);
+        }
+        await eventBroadcaster?.dispatchEvent(EventType.afterTransactionCommit, ctx);
     }
-    if (query instanceof RawQueryFragment) {
-      params = query.params;
-      query = query.sql;
+    /** Rolls back the transaction or rolls back to the savepoint. */
+    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), loggerContext);
+        }
+        else {
+            await ctx.rollback().execute();
+            this.logQuery(this.platform.getRollbackTransactionSQL(), loggerContext);
+        }
+        await eventBroadcaster?.dispatchEvent(EventType.afterTransactionRollback, ctx);
     }
-    query = this.config.get('onQuery')(query, params);
-    const formatted = this.platform.formatQuery(query, params);
-    return { query, params, formatted };
-  }
-  /** Executes a SQL query and returns the result based on the method: `'all'` for rows, `'get'` for single row, `'run'` for affected count. */
-  async execute(query, params = [], method = 'all', ctx, loggerContext) {
-    await this.ensureConnection();
-    const q = this.prepareQuery(query, params);
-    const sql = this.getSql(q.query, q.formatted, loggerContext);
-    return this.executeQuery(
-      sql,
-      async () => {
-        const compiled = CompiledQuery.raw(q.formatted);
-        const res = await (ctx ?? this.#client).executeQuery(compiled);
-        return this.transformRawResult(res, method);
-      },
-      { ...q, ...loggerContext },
-    );
-  }
-  /** Executes a SQL query and returns an async iterable that yields results row by row. */
-  async *stream(query, params = [], ctx, loggerContext) {
-    await this.ensureConnection();
-    const q = this.prepareQuery(query, params);
-    const sql = this.getSql(q.query, q.formatted, loggerContext);
-    // construct the compiled query manually with `kind: 'SelectQueryNode'` to avoid sqlite validation for select queries when streaming
-    const compiled = {
-      query: {
-        kind: 'SelectQueryNode',
-      },
-      sql: q.formatted,
-      parameters: [],
-    };
-    try {
-      const res = (ctx ?? this.getClient()).getExecutor().stream(compiled, 1);
-      this.logQuery(sql, {
-        sql,
-        params,
-        ...loggerContext,
-        affected: Utils.isPlainObject(res) ? res.affectedRows : undefined,
-      });
-      for await (const items of res) {
-        for (const row of this.transformRawResult(items, 'all')) {
-          yield row;
-        }
-      }
-    } catch (e) {
-      this.logQuery(sql, { sql, params, ...loggerContext, level: 'error' });
-      throw e;
+    prepareQuery(query, params = []) {
+        if (query instanceof NativeQueryBuilder) {
+            query = query.toRaw();
+        }
+        if (query instanceof RawQueryFragment) {
+            params = query.params;
+            query = query.sql;
+        }
+        query = this.config.get('onQuery')(query, params);
+        const formatted = this.platform.formatQuery(query, params);
+        return { query, params, formatted };
     }
-  }
-  /** @inheritDoc */
-  async executeDump(dump) {
-    await this.ensureConnection();
-    try {
-      const raw = CompiledQuery.raw(dump);
-      await this.getClient().executeQuery(raw);
-    } catch (e) {
-      /* v8 ignore next */
-      throw this.platform.getExceptionConverter().convertException(e);
+    /** Executes a SQL query and returns the result based on the method: `'all'` for rows, `'get'` for single row, `'run'` for affected count. */
+    async execute(query, params = [], method = 'all', ctx, loggerContext) {
+        await this.ensureConnection();
+        const q = this.prepareQuery(query, params);
+        const sql = this.getSql(q.query, q.formatted, loggerContext);
+        return this.executeQuery(sql, async () => {
+            const compiled = CompiledQuery.raw(q.formatted);
+            const res = await (ctx ?? this.#client).executeQuery(compiled);
+            return this.transformRawResult(res, method);
+        }, { ...q, ...loggerContext });
     }
-  }
-  getSql(query, formatted, context) {
-    const logger = this.config.getLogger();
-    if (!logger.isEnabled('query', context)) {
-      return query;
+    /** Executes a SQL query and returns an async iterable that yields results row by row. */
+    async *stream(query, params = [], ctx, loggerContext) {
+        await this.ensureConnection();
+        const q = this.prepareQuery(query, params);
+        const sql = this.getSql(q.query, q.formatted, loggerContext);
+        // construct the compiled query manually with `kind: 'SelectQueryNode'` to avoid sqlite validation for select queries when streaming
+        const compiled = {
+            query: {
+                kind: 'SelectQueryNode',
+            },
+            sql: q.formatted,
+            parameters: [],
+        };
+        try {
+            const res = (ctx ?? this.getClient()).getExecutor().stream(compiled, 1);
+            this.logQuery(sql, {
+                sql,
+                params,
+                ...loggerContext,
+                affected: Utils.isPlainObject(res) ? res.affectedRows : undefined,
+            });
+            for await (const items of res) {
+                for (const row of this.transformRawResult(items, 'all')) {
+                    yield row;
+                }
+            }
+        }
+        catch (e) {
+            this.logQuery(sql, { sql, params, ...loggerContext, level: 'error' });
+            throw e;
+        }
     }
-    if (logger.isEnabled('query-params', context)) {
-      return formatted;
+    /** @inheritDoc */
+    async executeDump(dump) {
+        await this.ensureConnection();
+        try {
+            const raw = CompiledQuery.raw(dump);
+            await this.getClient().executeQuery(raw);
+        }
+        catch (e) {
+            /* v8 ignore next */
+            throw this.platform.getExceptionConverter().convertException(e);
+        }
     }
-    return query;
-  }
-  transformRawResult(res, method) {
-    if (method === 'get') {
-      return res.rows[0];
+    getSql(query, formatted, context) {
+        const logger = this.config.getLogger();
+        if (!logger.isEnabled('query', context)) {
+            return query;
+        }
+        if (logger.isEnabled('query-params', context)) {
+            return formatted;
+        }
+        return query;
     }
-    if (method === 'all') {
-      return res.rows;
+    transformRawResult(res, method) {
+        if (method === 'get') {
+            return res.rows[0];
+        }
+        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,
+        };
     }
-    return {
-      affectedRows: Number(res.numAffectedRows ?? res.rows.length),
-      insertId: res.insertId != null ? Number(res.insertId) : res.insertId,
-      row: res.rows[0],
-      rows: res.rows,
-    };
-  }
 }