@mikro-orm/sql 7.0.3-dev.8 → 7.0.3

package/dialects/oracledb/OracleDialect.d.ts

@@ -1,78 +1,107 @@
-import { type AliasNode, CompiledQuery, type DatabaseConnection, type DatabaseIntrospector, DefaultQueryCompiler, type Dialect, DialectAdapterBase, type Driver, type Kysely, type QueryCompiler, type QueryResult, type TransactionSettings } from 'kysely';
+import {
+  type AliasNode,
+  CompiledQuery,
+  type DatabaseConnection,
+  type DatabaseIntrospector,
+  DefaultQueryCompiler,
+  type Dialect,
+  DialectAdapterBase,
+  type Driver,
+  type Kysely,
+  type QueryCompiler,
+  type QueryResult,
+  type TransactionSettings,
+} from 'kysely';
 /**
  * Subset of oracledb's Pool interface used by the dialect.
  * We define our own interface to avoid importing the `oracledb` package directly.
  */
 export interface OraclePool {
-    getConnection(): Promise<OraclePoolConnection>;
-    close(drainTime?: number): Promise<void>;
+  getConnection(): Promise<OraclePoolConnection>;
+  close(drainTime?: number): Promise<void>;
 }
 /**
  * Subset of oracledb's Connection interface used by the dialect.
  */
 export interface OraclePoolConnection {
-    execute<R>(sql: string, params: unknown[], options?: Record<string, unknown>): Promise<{
-        rows?: R[];
-        rowsAffected?: number;
-        resultSet?: OracleResultSet<R>;
-        outBinds?: unknown;
-    }>;
-    commit(): Promise<void>;
-    rollback(): Promise<void>;
-    close(): Promise<void>;
+  execute<R>(
+    sql: string,
+    params: unknown[],
+    options?: Record<string, unknown>,
+  ): Promise<{
+    rows?: R[];
+    rowsAffected?: number;
+    resultSet?: OracleResultSet<R>;
+    outBinds?: unknown;
+  }>;
+  commit(): Promise<void>;
+  rollback(): Promise<void>;
+  close(): Promise<void>;
 }
 interface OracleResultSet<R> {
-    getRow(): Promise<R>;
-    close(): Promise<void>;
+  getRow(): Promise<R>;
+  close(): Promise<void>;
 }
 declare class OracleQueryCompiler extends DefaultQueryCompiler {
-    protected getLeftIdentifierWrapper(): string;
-    protected getRightIdentifierWrapper(): string;
-    protected visitAlias(node: AliasNode): void;
+  protected getLeftIdentifierWrapper(): string;
+  protected getRightIdentifierWrapper(): string;
+  protected visitAlias(node: AliasNode): void;
 }
 declare class OracleAdapter extends DialectAdapterBase {
-    #private;
-    get supportsReturning(): boolean;
-    get supportsTransactionalDdl(): boolean;
-    acquireMigrationLock(_: Kysely<any>): Promise<void>;
-    releaseMigrationLock(_: Kysely<any>): Promise<void>;
+  #private;
+  get supportsReturning(): boolean;
+  get supportsTransactionalDdl(): boolean;
+  acquireMigrationLock(_: Kysely<any>): Promise<void>;
+  releaseMigrationLock(_: Kysely<any>): Promise<void>;
 }
 declare class OracleConnection implements DatabaseConnection {
-    #private;
-    readonly id: number;
-    constructor(connection: OraclePoolConnection, executeOptions?: Record<string, unknown>);
-    executeQuery<R>(compiledQuery: CompiledQuery): Promise<QueryResult<R>>;
-    formatQuery(query: CompiledQuery): {
-        sql: string;
-        bindParams: unknown[];
-    };
-    streamQuery<R>(compiledQuery: CompiledQuery, _chunkSize?: number): AsyncIterableIterator<QueryResult<R>>;
-    get connection(): OraclePoolConnection;
+  #private;
+  readonly id: number;
+  constructor(connection: OraclePoolConnection, executeOptions?: Record<string, unknown>);
+  executeQuery<R>(compiledQuery: CompiledQuery): Promise<QueryResult<R>>;
+  formatQuery(query: CompiledQuery): {
+    sql: string;
+    bindParams: unknown[];
+  };
+  streamQuery<R>(compiledQuery: CompiledQuery, _chunkSize?: number): AsyncIterableIterator<QueryResult<R>>;
+  get connection(): OraclePoolConnection;
 }
 declare class OracleDriver implements Driver {
-    #private;
-    constructor(config: OracleDialectConfig);
-    init(): Promise<void>;
-    acquireConnection(): Promise<OracleConnection>;
-    savepoint(connection: OracleConnection, savepointName: string, compileQuery: QueryCompiler['compileQuery']): Promise<void>;
-    rollbackToSavepoint(connection: OracleConnection, savepointName: string, compileQuery: QueryCompiler['compileQuery']): Promise<void>;
-    releaseSavepoint(connection: OracleConnection, savepointName: string, compileQuery: QueryCompiler['compileQuery']): Promise<void>;
-    beginTransaction(connection: OracleConnection, settings: TransactionSettings): Promise<void>;
-    commitTransaction(connection: OracleConnection): Promise<void>;
-    rollbackTransaction(connection: OracleConnection): Promise<void>;
-    releaseConnection(connection: OracleConnection): Promise<void>;
-    destroy(): Promise<void>;
+  #private;
+  constructor(config: OracleDialectConfig);
+  init(): Promise<void>;
+  acquireConnection(): Promise<OracleConnection>;
+  savepoint(
+    connection: OracleConnection,
+    savepointName: string,
+    compileQuery: QueryCompiler['compileQuery'],
+  ): Promise<void>;
+  rollbackToSavepoint(
+    connection: OracleConnection,
+    savepointName: string,
+    compileQuery: QueryCompiler['compileQuery'],
+  ): Promise<void>;
+  releaseSavepoint(
+    connection: OracleConnection,
+    savepointName: string,
+    compileQuery: QueryCompiler['compileQuery'],
+  ): Promise<void>;
+  beginTransaction(connection: OracleConnection, settings: TransactionSettings): Promise<void>;
+  commitTransaction(connection: OracleConnection): Promise<void>;
+  rollbackTransaction(connection: OracleConnection): Promise<void>;
+  releaseConnection(connection: OracleConnection): Promise<void>;
+  destroy(): Promise<void>;
 }
 export interface OracleDialectConfig {
-    pool: OraclePool;
-    executeOptions?: Record<string, unknown>;
+  pool: OraclePool;
+  executeOptions?: Record<string, unknown>;
 }
 export declare class OracleDialect implements Dialect {
-    #private;
-    constructor(config: OracleDialectConfig);
-    createDriver(): OracleDriver;
-    createAdapter(): OracleAdapter;
-    createIntrospector(db: Kysely<any>): DatabaseIntrospector;
-    createQueryCompiler(): OracleQueryCompiler;
+  #private;
+  constructor(config: OracleDialectConfig);
+  createDriver(): OracleDriver;
+  createAdapter(): OracleAdapter;
+  createIntrospector(db: Kysely<any>): DatabaseIntrospector;
+  createQueryCompiler(): OracleQueryCompiler;
 }
 export {};

package/dialects/oracledb/OracleDialect.js

@@ -1,166 +1,172 @@
 // inlined https://github.com/griffiths-waite/kysely-oracledb with minor adjustments
 /* v8 ignore start: internal Kysely driver integration, tested through the main Oracle driver */
-import { CompiledQuery, createQueryId, DefaultQueryCompiler, DialectAdapterBase, IdentifierNode, RawNode, } from 'kysely';
+import {
+  CompiledQuery,
+  createQueryId,
+  DefaultQueryCompiler,
+  DialectAdapterBase,
+  IdentifierNode,
+  RawNode,
+} from 'kysely';
 function parseSavepointCommand(command, savepointName) {
-    return RawNode.createWithChildren([
-        RawNode.createWithSql(`${command} `),
-        IdentifierNode.create(savepointName), // ensures savepointName gets sanitized
-    ]);
+  return RawNode.createWithChildren([
+    RawNode.createWithSql(`${command} `),
+    IdentifierNode.create(savepointName), // ensures savepointName gets sanitized
+  ]);
 }
 class OracleQueryCompiler extends DefaultQueryCompiler {
-    getLeftIdentifierWrapper() {
-        return '';
-    }
-    getRightIdentifierWrapper() {
-        return '';
-    }
-    visitAlias(node) {
-        this.visitNode(node.node);
-        this.append(' ');
-        this.visitNode(node.alias);
-    }
+  getLeftIdentifierWrapper() {
+    return '';
+  }
+  getRightIdentifierWrapper() {
+    return '';
+  }
+  visitAlias(node) {
+    this.visitNode(node.node);
+    this.append(' ');
+    this.visitNode(node.alias);
+  }
 }
 class OracleAdapter extends DialectAdapterBase {
-    #supportsReturning = false;
-    #supportsTransactionalDdl = false;
-    get supportsReturning() {
-        return this.#supportsReturning;
-    }
-    get supportsTransactionalDdl() {
-        return this.#supportsTransactionalDdl;
-    }
-    async acquireMigrationLock(_) {
-        throw new Error('Not implemented');
-    }
-    async releaseMigrationLock(_) {
-        throw new Error('Not implemented');
-    }
+  #supportsReturning = false;
+  #supportsTransactionalDdl = false;
+  get supportsReturning() {
+    return this.#supportsReturning;
+  }
+  get supportsTransactionalDdl() {
+    return this.#supportsTransactionalDdl;
+  }
+  async acquireMigrationLock(_) {
+    throw new Error('Not implemented');
+  }
+  async releaseMigrationLock(_) {
+    throw new Error('Not implemented');
+  }
 }
 const OUT_FORMAT_OBJECT = 4002;
 let i = 0;
 class OracleConnection {
-    id = i++;
-    #executeOptions;
-    #connection;
-    constructor(connection, executeOptions) {
-        this.#executeOptions = executeOptions ?? {};
-        this.#connection = connection;
-    }
-    async executeQuery(compiledQuery) {
-        const { sql, bindParams } = this.formatQuery(compiledQuery);
-        const result = await this.#connection.execute(sql, bindParams, {
-            autoCommit: compiledQuery.autoCommit,
-            outFormat: OUT_FORMAT_OBJECT,
-            ...this.#executeOptions,
-        });
-        return {
-            rows: result?.rows || [],
-            numAffectedRows: result.rowsAffected ? BigInt(result.rowsAffected) : undefined,
-            // @ts-ignore internal extension for Oracle returning clause
-            outBinds: result.outBinds,
-        };
-    }
-    formatQuery(query) {
-        return {
-            sql: query.sql.replace(/\$(\d+)/g, (_match, p1) => `:${parseInt(p1, 10) - 1}`), // Format bind params in Oracle syntax :0, :1, etc.
-            bindParams: query.parameters,
-        };
-    }
-    async *streamQuery(compiledQuery, _chunkSize) {
-        const { sql, bindParams } = this.formatQuery(compiledQuery);
-        const result = await this.#connection.execute(sql, bindParams, {
-            resultSet: true,
-            autoCommit: compiledQuery.autoCommit,
-            outFormat: OUT_FORMAT_OBJECT,
-            ...this.#executeOptions,
-        });
-        const rs = result.resultSet;
-        try {
-            let row;
-            while ((row = await rs.getRow())) {
-                yield { rows: [row] };
-            }
-        }
-        finally {
-            await rs.close();
-        }
-    }
-    get connection() {
-        return this.#connection;
-    }
+  id = i++;
+  #executeOptions;
+  #connection;
+  constructor(connection, executeOptions) {
+    this.#executeOptions = executeOptions ?? {};
+    this.#connection = connection;
+  }
+  async executeQuery(compiledQuery) {
+    const { sql, bindParams } = this.formatQuery(compiledQuery);
+    const result = await this.#connection.execute(sql, bindParams, {
+      autoCommit: compiledQuery.autoCommit,
+      outFormat: OUT_FORMAT_OBJECT,
+      ...this.#executeOptions,
+    });
+    return {
+      rows: result?.rows || [],
+      numAffectedRows: result.rowsAffected ? BigInt(result.rowsAffected) : undefined,
+      // @ts-ignore internal extension for Oracle returning clause
+      outBinds: result.outBinds,
+    };
+  }
+  formatQuery(query) {
+    return {
+      sql: query.sql.replace(/\$(\d+)/g, (_match, p1) => `:${parseInt(p1, 10) - 1}`), // Format bind params in Oracle syntax :0, :1, etc.
+      bindParams: query.parameters,
+    };
+  }
+  async *streamQuery(compiledQuery, _chunkSize) {
+    const { sql, bindParams } = this.formatQuery(compiledQuery);
+    const result = await this.#connection.execute(sql, bindParams, {
+      resultSet: true,
+      autoCommit: compiledQuery.autoCommit,
+      outFormat: OUT_FORMAT_OBJECT,
+      ...this.#executeOptions,
+    });
+    const rs = result.resultSet;
+    try {
+      let row;
+      while ((row = await rs.getRow())) {
+        yield { rows: [row] };
+      }
+    } finally {
+      await rs.close();
+    }
+  }
+  get connection() {
+    return this.#connection;
+  }
 }
 class OracleDriver {
-    #config;
-    #connections = new Set();
-    constructor(config) {
-        this.#config = config;
-    }
-    async init() {
-        //
-    }
-    async acquireConnection() {
-        const connection = new OracleConnection(await this.#config.pool.getConnection(), this.#config.executeOptions);
-        this.#connections.add(connection);
-        return connection;
-    }
-    async savepoint(connection, savepointName, compileQuery) {
-        await connection.executeQuery(compileQuery(parseSavepointCommand('savepoint', savepointName), createQueryId()));
-    }
-    async rollbackToSavepoint(connection, savepointName, compileQuery) {
-        await connection.executeQuery(compileQuery(parseSavepointCommand('rollback to savepoint', savepointName), createQueryId()));
-    }
-    async releaseSavepoint(connection, savepointName, compileQuery) {
-        //
-    }
-    async beginTransaction(connection, settings) {
-        if (settings.accessMode) {
-            await connection.executeQuery(CompiledQuery.raw(`set transaction ${settings.accessMode}`));
-            return;
-        }
-        if (settings.isolationLevel) {
-            await connection.executeQuery(CompiledQuery.raw(`set transaction isolation level ${settings.isolationLevel}`));
-        }
-    }
-    async commitTransaction(connection) {
-        await connection.connection.commit();
-    }
-    async rollbackTransaction(connection) {
-        await connection.connection.rollback();
-    }
-    async releaseConnection(connection) {
-        try {
-            await connection.connection.close();
-        }
-        catch (err) {
-            //
-        }
-        finally {
-            this.#connections.delete(connection);
-        }
-    }
-    async destroy() {
-        for (const connection of this.#connections) {
-            await this.releaseConnection(connection);
-        }
-        await this.#config.pool?.close(0);
-    }
+  #config;
+  #connections = new Set();
+  constructor(config) {
+    this.#config = config;
+  }
+  async init() {
+    //
+  }
+  async acquireConnection() {
+    const connection = new OracleConnection(await this.#config.pool.getConnection(), this.#config.executeOptions);
+    this.#connections.add(connection);
+    return connection;
+  }
+  async savepoint(connection, savepointName, compileQuery) {
+    await connection.executeQuery(compileQuery(parseSavepointCommand('savepoint', savepointName), createQueryId()));
+  }
+  async rollbackToSavepoint(connection, savepointName, compileQuery) {
+    await connection.executeQuery(
+      compileQuery(parseSavepointCommand('rollback to savepoint', savepointName), createQueryId()),
+    );
+  }
+  async releaseSavepoint(connection, savepointName, compileQuery) {
+    //
+  }
+  async beginTransaction(connection, settings) {
+    if (settings.accessMode) {
+      await connection.executeQuery(CompiledQuery.raw(`set transaction ${settings.accessMode}`));
+      return;
+    }
+    if (settings.isolationLevel) {
+      await connection.executeQuery(CompiledQuery.raw(`set transaction isolation level ${settings.isolationLevel}`));
+    }
+  }
+  async commitTransaction(connection) {
+    await connection.connection.commit();
+  }
+  async rollbackTransaction(connection) {
+    await connection.connection.rollback();
+  }
+  async releaseConnection(connection) {
+    try {
+      await connection.connection.close();
+    } catch (err) {
+      //
+    } finally {
+      this.#connections.delete(connection);
+    }
+  }
+  async destroy() {
+    for (const connection of this.#connections) {
+      await this.releaseConnection(connection);
+    }
+    await this.#config.pool?.close(0);
+  }
 }
 export class OracleDialect {
-    #config;
-    constructor(config) {
-        this.#config = config;
-    }
-    createDriver() {
-        return new OracleDriver(this.#config);
-    }
-    createAdapter() {
-        return new OracleAdapter();
-    }
-    createIntrospector(db) {
-        throw new Error('Not implemented');
-    }
-    createQueryCompiler() {
-        return new OracleQueryCompiler();
-    }
+  #config;
+  constructor(config) {
+    this.#config = config;
+  }
+  createDriver() {
+    return new OracleDriver(this.#config);
+  }
+  createAdapter() {
+    return new OracleAdapter();
+  }
+  createIntrospector(db) {
+    throw new Error('Not implemented');
+  }
+  createQueryCompiler() {
+    return new OracleQueryCompiler();
+  }
 }
 /* v8 ignore stop */

package/dialects/oracledb/OracleNativeQueryBuilder.d.ts

@@ -4,16 +4,16 @@ import { NativeQueryBuilder } from '../../query/NativeQueryBuilder.js';
 export declare function markOutBindings(obj: Dictionary): void;
 /** @internal */
 export declare class OracleNativeQueryBuilder extends NativeQueryBuilder {
-    as(alias: string): this;
-    compile(): {
-        sql: string;
-        params: unknown[];
-    };
-    protected compileTruncate(): void;
-    protected combineParts(): {
-        sql: string;
-        params: unknown[];
-    };
-    private compileUpsert;
-    protected compileSelect(): void;
+  as(alias: string): this;
+  compile(): {
+    sql: string;
+    params: unknown[];
+  };
+  protected compileTruncate(): void;
+  protected combineParts(): {
+    sql: string;
+    params: unknown[];
+  };
+  private compileUpsert;
+  protected compileSelect(): void;
 }