@mikro-orm/sql 7.0.2 → 7.0.3-dev.1

package/dialects/oracledb/OracleDialect.d.ts

@@ -1,107 +1,78 @@
-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,172 +1,166 @@
 // 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;
 }