@mikro-orm/oracledb 7.0.8-dev.7 → 7.0.8

package/OracleQueryBuilder.js

@@ -1,86 +1,93 @@
-import { isRaw, raw, Utils, } from '@mikro-orm/core';
+import { isRaw, raw, Utils } from '@mikro-orm/core';
 import { QueryBuilder, QueryType } from '@mikro-orm/sql';
 /** Query builder with Oracle-specific behavior such as RETURNING clause handling and lock table conversion. */
 export class OracleQueryBuilder extends QueryBuilder {
-    insert(data) {
-        for (const row of Utils.asArray(data)) {
-            if (this.mainAlias.meta && Object.keys(row).length === 0) {
-                // ensure that we insert at least one column, otherwise Oracle will throw an error
-                row[this.mainAlias.meta.primaryKeys[0]] = raw('default');
-            }
-        }
-        return this.init(QueryType.INSERT, data);
+  insert(data) {
+    for (const row of Utils.asArray(data)) {
+      if (this.mainAlias.meta && Object.keys(row).length === 0) {
+        // ensure that we insert at least one column, otherwise Oracle will throw an error
+        row[this.mainAlias.meta.primaryKeys[0]] = raw('default');
+      }
     }
-    setLockMode(mode, tables) {
-        if (tables) {
-            this.convertLockTablesToColumnRefs(tables);
-        }
-        return super.setLockMode(mode, tables);
+    return this.init(QueryType.INSERT, data);
+  }
+  setLockMode(mode, tables) {
+    if (tables) {
+      this.convertLockTablesToColumnRefs(tables);
     }
-    getNativeQuery(processVirtualEntity = true) {
-        const qb = super.getNativeQuery(processVirtualEntity);
-        // Convert lockTables from table aliases to column references for Oracle
-        // This handles the case where lockTables are auto-computed from joins
-        const lockTables = qb.options?.lockTables;
-        if (lockTables?.length) {
-            this.convertLockTablesToColumnRefs(lockTables);
-        }
-        return qb;
+    return super.setLockMode(mode, tables);
+  }
+  getNativeQuery(processVirtualEntity = true) {
+    const qb = super.getNativeQuery(processVirtualEntity);
+    // Convert lockTables from table aliases to column references for Oracle
+    // This handles the case where lockTables are auto-computed from joins
+    const lockTables = qb.options?.lockTables;
+    if (lockTables?.length) {
+      this.convertLockTablesToColumnRefs(lockTables);
     }
-    convertLockTablesToColumnRefs(tables) {
-        for (let i = 0; i < tables.length; i++) {
-            if (!tables[i].includes('.')) {
-                const aliasInfo = this.state.aliases[tables[i]];
-                /* v8 ignore next 3: defensive — alias always has meta when called from ORM */
-                if (aliasInfo?.meta) {
-                    tables[i] += '.' + aliasInfo.meta.getPrimaryProp().fieldNames[0];
-                }
-            }
+    return qb;
+  }
+  convertLockTablesToColumnRefs(tables) {
+    for (let i = 0; i < tables.length; i++) {
+      if (!tables[i].includes('.')) {
+        const aliasInfo = this.state.aliases[tables[i]];
+        /* v8 ignore next 3: defensive — alias always has meta when called from ORM */
+        if (aliasInfo?.meta) {
+          tables[i] += '.' + aliasInfo.meta.getPrimaryProp().fieldNames[0];
         }
+      }
     }
-    processReturningStatement(qb, meta, data, returning) {
-        if (!meta || !data) {
-            return;
-        }
-        const arr = Utils.asArray(data);
-        // always respect explicit returning hint
-        if (returning && returning.length > 0) {
-            qb.returning(
-            /* v8 ignore next 8: non-string field branch */
-            returning.map(field => {
-                if (typeof field === 'string') {
-                    const prop = this.helper.getProperty(field);
-                    return [prop?.fieldNames[0] ?? field, prop?.runtimeType ?? 'string'];
-                }
-                return this.helper.mapper(field, this.type);
-            }));
-            return;
-        }
-        if (this.type === QueryType.INSERT) {
-            const returningProps = meta.hydrateProps
-                .filter(prop => prop.returning || (prop.persist !== false && ((prop.primary && prop.autoincrement) || prop.defaultRaw)))
-                .filter(prop => !(prop.fieldNames[0] in arr[0]) || isRaw(arr[0][prop.fieldNames[0]]));
-            if (returningProps.length > 0) {
-                qb.returning(returningProps.map(prop => [prop.fieldNames[0], prop.runtimeType]));
-            }
-            return;
-        }
-        /* v8 ignore next: implicit fallthrough for non-INSERT/UPDATE types */
-        if (this.type === QueryType.UPDATE) {
-            const returningProps = meta.hydrateProps.filter(prop => prop.fieldNames && isRaw(arr[0][prop.fieldNames[0]]));
-            if (returningProps.length > 0) {
-                qb.returning(returningProps.map(prop => {
-                    /* v8 ignore next 7: NativeQueryBuilder does not support raw fragments in returning yet */
-                    if (prop.hasConvertToJSValueSQL) {
-                        const aliased = this.platform.quoteIdentifier(prop.fieldNames[0]);
-                        const sql = prop.customType.convertToJSValueSQL(aliased, this.platform) +
-                            ' as ' +
-                            this.platform.quoteIdentifier(prop.fieldNames[0]);
-                        return raw(sql);
-                    }
-                    return [prop.fieldNames[0], prop.runtimeType];
-                }));
+  }
+  processReturningStatement(qb, meta, data, returning) {
+    if (!meta || !data) {
+      return;
+    }
+    const arr = Utils.asArray(data);
+    // always respect explicit returning hint
+    if (returning && returning.length > 0) {
+      qb.returning(
+        /* v8 ignore next 8: non-string field branch */
+        returning.map(field => {
+          if (typeof field === 'string') {
+            const prop = this.helper.getProperty(field);
+            return [prop?.fieldNames[0] ?? field, prop?.runtimeType ?? 'string'];
+          }
+          return this.helper.mapper(field, this.type);
+        }),
+      );
+      return;
+    }
+    if (this.type === QueryType.INSERT) {
+      const returningProps = meta.hydrateProps
+        .filter(
+          prop =>
+            prop.returning || (prop.persist !== false && ((prop.primary && prop.autoincrement) || prop.defaultRaw)),
+        )
+        .filter(prop => !(prop.fieldNames[0] in arr[0]) || isRaw(arr[0][prop.fieldNames[0]]));
+      if (returningProps.length > 0) {
+        qb.returning(returningProps.map(prop => [prop.fieldNames[0], prop.runtimeType]));
+      }
+      return;
+    }
+    /* v8 ignore next: implicit fallthrough for non-INSERT/UPDATE types */
+    if (this.type === QueryType.UPDATE) {
+      const returningProps = meta.hydrateProps.filter(prop => prop.fieldNames && isRaw(arr[0][prop.fieldNames[0]]));
+      if (returningProps.length > 0) {
+        qb.returning(
+          returningProps.map(prop => {
+            /* v8 ignore next 7: NativeQueryBuilder does not support raw fragments in returning yet */
+            if (prop.hasConvertToJSValueSQL) {
+              const aliased = this.platform.quoteIdentifier(prop.fieldNames[0]);
+              const sql =
+                prop.customType.convertToJSValueSQL(aliased, this.platform) +
+                ' as ' +
+                this.platform.quoteIdentifier(prop.fieldNames[0]);
+              return raw(sql);
             }
-        }
+            return [prop.fieldNames[0], prop.runtimeType];
+          }),
+        );
+      }
     }
+  }
 }

package/OracleSchemaGenerator.d.ts

@@ -1,42 +1,50 @@
-import { type DropSchemaOptions, type MikroORM, type UpdateSchemaOptions, SchemaGenerator, DatabaseSchema, type EnsureDatabaseOptions, type ClearDatabaseOptions } from '@mikro-orm/sql';
+import {
+  type DropSchemaOptions,
+  type MikroORM,
+  type UpdateSchemaOptions,
+  SchemaGenerator,
+  DatabaseSchema,
+  type EnsureDatabaseOptions,
+  type ClearDatabaseOptions,
+} from '@mikro-orm/sql';
 import type { OracleSchemaHelper } from './OracleSchemaHelper.js';
 import type { OracleConnection } from './OracleConnection.js';
 /** Schema generator with Oracle-specific behavior for multi-schema support and privilege management. */
 export declare class OracleSchemaGenerator extends SchemaGenerator {
-    protected helper: OracleSchemaHelper;
-    protected connection: OracleConnection;
-    /** Tracks whether the main user has been granted DBA (or equivalent) privileges. */
-    private hasDbaGrant;
-    static register(orm: MikroORM): void;
-    /**
-     * creates new database and connects to it
-     */
-    createDatabase(name?: string): Promise<void>;
-    dropDatabase(name?: string): Promise<void>;
-    /**
-     * Oracle uses CASCADE CONSTRAINT in DROP TABLE and has no native enums,
-     * so we can generate drop SQL from metadata alone — no DB introspection needed.
-     */
-    getDropSchemaSQL(options?: Omit<DropSchemaOptions, 'dropDb'>): Promise<string>;
-    ensureDatabase(options?: EnsureDatabaseOptions): Promise<boolean>;
-    private getOriginalUser;
-    /**
-     * Connects as the management (system) user if not already connected as admin.
-     * Returns the original user to restore later, or undefined if no reconnect was needed.
-     */
-    private connectAsAdmin;
-    /**
-     * Restores the connection to the original user after admin operations.
-     */
-    private restoreConnection;
-    /**
-     * Grants DBA (or fallback individual privileges) to the main user.
-     * Only executed once — subsequent calls are no-ops.
-     */
-    private ensureDbaGrant;
-    createNamespace(name: string): Promise<void>;
-    dropNamespace(name: string): Promise<void>;
-    update(options?: UpdateSchemaOptions<DatabaseSchema>): Promise<void>;
-    clear(options?: ClearDatabaseOptions): Promise<void>;
-    private grantReferencesForSchema;
+  protected helper: OracleSchemaHelper;
+  protected connection: OracleConnection;
+  /** Tracks whether the main user has been granted DBA (or equivalent) privileges. */
+  private hasDbaGrant;
+  static register(orm: MikroORM): void;
+  /**
+   * creates new database and connects to it
+   */
+  createDatabase(name?: string): Promise<void>;
+  dropDatabase(name?: string): Promise<void>;
+  /**
+   * Oracle uses CASCADE CONSTRAINT in DROP TABLE and has no native enums,
+   * so we can generate drop SQL from metadata alone — no DB introspection needed.
+   */
+  getDropSchemaSQL(options?: Omit<DropSchemaOptions, 'dropDb'>): Promise<string>;
+  ensureDatabase(options?: EnsureDatabaseOptions): Promise<boolean>;
+  private getOriginalUser;
+  /**
+   * Connects as the management (system) user if not already connected as admin.
+   * Returns the original user to restore later, or undefined if no reconnect was needed.
+   */
+  private connectAsAdmin;
+  /**
+   * Restores the connection to the original user after admin operations.
+   */
+  private restoreConnection;
+  /**
+   * Grants DBA (or fallback individual privileges) to the main user.
+   * Only executed once — subsequent calls are no-ops.
+   */
+  private ensureDbaGrant;
+  createNamespace(name: string): Promise<void>;
+  dropNamespace(name: string): Promise<void>;
+  update(options?: UpdateSchemaOptions<DatabaseSchema>): Promise<void>;
+  clear(options?: ClearDatabaseOptions): Promise<void>;
+  private grantReferencesForSchema;
 }