@mikro-orm/oracledb 7.1.0-dev.43 → 7.1.0-dev.44

package/OracleConnection.d.ts

@@ -1,12 +1,21 @@
 import { AbstractSqlConnection, type AnyEntity, type EntityData, type LoggingOptions, NativeQueryBuilder, OracleDialect, type QueryResult, type RawQueryFragment, type Transaction } from '@mikro-orm/sql';
+import type { Routine } from '@mikro-orm/core';
 import { type PoolAttributes } from 'oracledb';
-/** Oracle database connection using the `oracledb` driver. */
 export declare class OracleConnection extends AbstractSqlConnection {
+    private oraclePool?;
+    private acquireOracleConnection?;
     createKyselyDialect(overrides: PoolAttributes): Promise<OracleDialect>;
     mapOptions(overrides: PoolAttributes): PoolAttributes;
     execute<T extends QueryResult | EntityData<AnyEntity> | EntityData<AnyEntity>[] = EntityData<AnyEntity>[]>(query: string | NativeQueryBuilder | RawQueryFragment, params?: readonly unknown[], method?: 'all' | 'get' | 'run', ctx?: Transaction, loggerContext?: LoggingOptions): Promise<T>;
     /** @inheritDoc */
     executeDump(dump: string): Promise<void>;
+    /**
+     * Oracle routines acquire their own pool connection with `autoCommit: true` (refcursor binds
+     * and DML need to resolve in one round-trip), so they cannot share the EM's transaction. Wrapping
+     * a writing routine in `em.transactional(...)` would silently auto-commit its writes. Read-only
+     * functions are allowed through.
+     */
+    callRoutine<T>(routine: Routine, args?: Record<string, unknown>, ctx?: Transaction): Promise<T>;
     private stripTrailingSemicolon;
     protected transformRawResult<T>(res: any, method: 'all' | 'get' | 'run'): T;
 }

package/OracleConnection.js

@@ -1,8 +1,31 @@
 import { AbstractSqlConnection, isRaw, NativeQueryBuilder, OracleDialect, Utils, } from '@mikro-orm/sql';
 import { CompiledQuery } from 'kysely';
 import oracledb from 'oracledb';
-/** Oracle database connection using the `oracledb` driver. */
+/**
+ * Maps a routine's declared runtime type to an oracledb bind descriptor. Delegates the
+ * runtime → DB_TYPE mapping to `OraclePlatform.mapToOracleType`; only the VARCHAR/RAW out-binds
+ * need an extra `maxSize` hint.
+ */
+function oracleBindTypeFromRuntime(platform, runtime) {
+    const type = platform.mapToOracleType(runtime ?? 'string');
+    return type === oracledb.DB_TYPE_VARCHAR || type === oracledb.DB_TYPE_RAW ? { type, maxSize: 4000 } : { type };
+}
+function oracleReturnBind(platform, routine) {
+    const returns = routine.returns;
+    const runtime = returns && typeof returns === 'object' && 'runtimeType' in returns ? returns.runtimeType : undefined;
+    return { dir: oracledb.BIND_OUT, ...oracleBindTypeFromRuntime(platform, runtime) };
+}
+/** Read-only functions can run on a separate Oracle connection inside an EM transaction — write-ish routines would silently auto-commit. */
+function isReadOnlyRoutine(routine) {
+    if (routine.type !== 'function') {
+        return false;
+    }
+    return routine.dataAccess === 'no-sql' || routine.dataAccess === 'reads-sql-data';
+}
 export class OracleConnection extends AbstractSqlConnection {
+    oraclePool;
+    // Resolves `password` callbacks per acquire so `callRoutine` doesn't bypass password rotation.
+    acquireOracleConnection;
     async createKyselyDialect(overrides) {
         const options = this.mapOptions(overrides);
         const password = options.password;
@@ -19,6 +42,7 @@ export class OracleConnection extends AbstractSqlConnection {
         for (let attempt = 1;; attempt++) {
             try {
                 pool = await oracledb.createPool(poolOptions);
+                this.oraclePool = pool;
                 break;
                 /* v8 ignore start: transient Oracle pool-creation errors are not reproducible in tests */
             }
@@ -48,13 +72,13 @@ export class OracleConnection extends AbstractSqlConnection {
                 return undefined;
             },
         };
-        // When password is a callback, wrap the pool to resolve it per-connection.
-        // oracledb supports per-connection password override via getConnection({ password }).
+        this.acquireOracleConnection =
+            typeof password === 'function'
+                ? async () => pool.getConnection({ password: await password() })
+                : () => pool.getConnection();
         const wrappedPool = typeof password === 'function'
             ? {
-                async getConnection() {
-                    return pool.getConnection({ password: await password() });
-                },
+                getConnection: this.acquireOracleConnection,
                 close: (drainTime) => pool.close(drainTime),
             }
             : pool;
@@ -133,6 +157,93 @@ export class OracleConnection extends AbstractSqlConnection {
             }
         }
     }
+    /**
+     * Oracle routines acquire their own pool connection with `autoCommit: true` (refcursor binds
+     * and DML need to resolve in one round-trip), so they cannot share the EM's transaction. Wrapping
+     * a writing routine in `em.transactional(...)` would silently auto-commit its writes. Read-only
+     * functions are allowed through.
+     */
+    async callRoutine(routine, args = {}, ctx) {
+        /* v8 ignore next 3 */
+        if (!this.oraclePool || !this.acquireOracleConnection) {
+            throw new Error('Oracle pool not initialised — call connect() before callRoutine().');
+        }
+        if (ctx && !isReadOnlyRoutine(routine)) {
+            throw new Error(`Routine ${routine.name} was invoked inside an EntityManager transaction, but Oracle's callRoutine runs on its own pool connection with autoCommit. Read-only functions are allowed through; for procedures or routines that may write, call em.callRoutine() outside em.transactional(), or mark the routine as 'dataAccess: \\'reads-sql-data\\'' / 'no-sql' if it really is read-only.`);
+        }
+        const name = routine.name.toUpperCase();
+        // Cross-schema needs an `OWNER.NAME` prefix; mirror the schema helper's quoting on both branches.
+        const quotedName = this.platform.quoteIdentifier(name);
+        /* v8 ignore next 3 — cross-schema invocation isn't reachable from the single-user test DB;
+           the qualified DDL path (createRoutine/dropRoutine) is covered by helpers.test.ts. */
+        const qualifiedName = routine.schema
+            ? `${this.platform.quoteIdentifier(routine.schema.toUpperCase())}.${quotedName}`
+            : quotedName;
+        const oracleConn = await this.acquireOracleConnection();
+        try {
+            if (routine.type === 'function') {
+                const argList = routine.params.map(p => `:${p.name}`).join(', ');
+                const block = `BEGIN :mo_ret := ${qualifiedName}(${argList}); END;`;
+                const bindings = { mo_ret: oracleReturnBind(this.platform, routine) };
+                for (const p of routine.params) {
+                    bindings[p.name] = {
+                        dir: oracledb.BIND_IN,
+                        val: this.convertRoutineInbound(args[p.name], p),
+                    };
+                }
+                const result = await oracleConn.execute(block, bindings, { autoCommit: true });
+                return this.convertRoutineOutbound(result.outBinds?.mo_ret, routine.returnCustomType);
+            }
+            const argList = routine.params.map(p => `:${p.name}`).join(', ');
+            const block = `BEGIN ${qualifiedName}(${argList}); END;`;
+            const bindings = {};
+            const refCursorParams = [];
+            for (const p of routine.params) {
+                const value = this.convertRoutineInbound(args[p.name], p);
+                const isRefCursor = typeof p.type === 'string' && /sys_refcursor|ref\s*cursor/i.test(p.type);
+                if (p.direction === 'in') {
+                    bindings[p.name] = { dir: oracledb.BIND_IN, val: value };
+                    continue;
+                }
+                if (isRefCursor) {
+                    bindings[p.name] = { dir: oracledb.BIND_OUT, type: oracledb.DB_TYPE_CURSOR };
+                    refCursorParams.push(p.name);
+                    continue;
+                }
+                const binding = {
+                    dir: p.direction === 'out' ? oracledb.BIND_OUT : oracledb.BIND_INOUT,
+                    ...oracleBindTypeFromRuntime(this.platform, p.runtimeType),
+                };
+                if (p.direction === 'inout') {
+                    binding.val = value;
+                }
+                bindings[p.name] = binding;
+            }
+            const result = await oracleConn.execute(block, bindings, {
+                autoCommit: true,
+                outFormat: oracledb.OUT_FORMAT_OBJECT,
+            });
+            const outBinds = result.outBinds;
+            if (refCursorParams.length > 0 && outBinds) {
+                const sets = [];
+                for (const name of refCursorParams) {
+                    const cursor = outBinds[name];
+                    const rows = await cursor.getRows(0);
+                    await cursor.close();
+                    // outBinds ResultSets use raw column metadata (uppercase); lowercase for cross-driver parity.
+                    sets.push(rows.map(row => Object.fromEntries(Object.entries(row).map(([k, v]) => [k.toLowerCase(), v]))));
+                }
+                return sets;
+            }
+            if (outBinds) {
+                this.applyRoutineOutParams(outBinds, routine.params.filter(p => p.direction !== 'in'), args);
+            }
+            return undefined;
+        }
+        finally {
+            await oracleConn.close();
+        }
+    }
     stripTrailingSemicolon(sql) {
         if (sql.endsWith(';') && !/end(\s+\w+)?;$/i.test(sql)) {
             return sql.slice(0, -1);

package/OraclePlatform.js

@@ -3,6 +3,8 @@ import oracledb from 'oracledb';
 import { OracleSchemaHelper } from './OracleSchemaHelper.js';
 import { OracleExceptionConverter } from './OracleExceptionConverter.js';
 import { OracleSchemaGenerator } from './OracleSchemaGenerator.js';
+// `bigint` deliberately absent — falls through to DB_TYPE_VARCHAR so oracledb returns a
+// string and the caller doesn't lose precision on values past Number.MAX_SAFE_INTEGER.
 const ORACLE_TYPE_MAP = {
     string: oracledb.DB_TYPE_VARCHAR,
     number: oracledb.DB_TYPE_NUMBER,

package/OracleSchemaGenerator.js

@@ -48,6 +48,10 @@ export class OracleSchemaGenerator extends SchemaGenerator {
         await this.ensureDatabase();
         const metadata = this.getOrderedMetadata(options.schema).reverse();
         const ret = [];
+        // Routines before tables — bodies reference columns and Oracle has no CASCADE for them.
+        for (const routine of this.getTargetSchema(options.schema).getRoutines()) {
+            this.helper.append(ret, this.helper.dropRoutine(routine), true);
+        }
         for (const meta of metadata) {
             const schemaName = options.schema ?? this.config.get('schema');
             /* v8 ignore next: wildcard schema branch */

package/OracleSchemaHelper.d.ts

@@ -1,4 +1,4 @@
-import { type AbstractSqlConnection, type CheckDef, type Column, type DatabaseSchema, type DatabaseTable, type Dictionary, type ForeignKey, type IndexDef, SchemaHelper, type Table, type TableDifference, type Transaction, type Type } from '@mikro-orm/sql';
+import { type AbstractSqlConnection, type CheckDef, type Column, type DatabaseSchema, type DatabaseTable, type Dictionary, type ForeignKey, type IndexDef, SchemaHelper, type Table, type TableDifference, type Transaction, type Type, type SqlRoutineDef } from '@mikro-orm/sql';
 /** Schema introspection helper for Oracle Database. */
 export declare class OracleSchemaHelper extends SchemaHelper {
     static readonly DEFAULT_VALUES: Record<string, string[]>;
@@ -53,4 +53,12 @@ export declare class OracleSchemaHelper extends SchemaHelper {
     appendComments(table: DatabaseTable): string[];
     inferLengthFromColumnType(type: string): number | undefined;
     protected wrap(val: string | undefined, type: Type<unknown>): string | undefined;
+    /** Oracle identifiers are upper-cased before quoting to match `USER_PROCEDURES` introspection. Cross-schema qualifier mirrors `OracleConnection.callRoutine`. */
+    private qualifiedOracleRoutineName;
+    createRoutine(routine: SqlRoutineDef): string;
+    /** Uses `IF EXISTS` (Oracle 23c+); older versions can extend this helper. */
+    dropRoutine(routine: SqlRoutineDef): string;
+    getAllRoutines(connection: AbstractSqlConnection): Promise<SqlRoutineDef[]>;
+    private getAllRoutineParams;
+    private unwrapPlSqlBody;
 }

package/OracleSchemaHelper.js

@@ -1,4 +1,7 @@
 import { DateTimeType, EnumType, SchemaHelper, StringType, TextType, Utils, } from '@mikro-orm/sql';
+function stripTypeLength(type) {
+    return type.replace(/\(\s*[^)]*\)\s*$/, '').trim();
+}
 /** Schema introspection helper for Oracle Database. */
 export class OracleSchemaHelper extends SchemaHelper {
     static DEFAULT_VALUES = {
@@ -664,4 +667,107 @@ export class OracleSchemaHelper extends SchemaHelper {
         const stringType = type instanceof StringType || type instanceof TextType || type instanceof EnumType;
         return typeof val === 'string' && val.length > 0 && stringType ? this.platform.quoteValue(val) : val;
     }
+    /** Oracle identifiers are upper-cased before quoting to match `USER_PROCEDURES` introspection. Cross-schema qualifier mirrors `OracleConnection.callRoutine`. */
+    qualifiedOracleRoutineName(routine) {
+        const name = this.quote(routine.name.toUpperCase());
+        const defaultSchema = this.platform.getDefaultSchemaName();
+        if (routine.schema && routine.schema !== defaultSchema) {
+            return `${this.quote(routine.schema.toUpperCase())}.${name}`;
+        }
+        return name;
+    }
+    createRoutine(routine) {
+        if (routine.expression) {
+            return routine.expression;
+        }
+        const name = this.qualifiedOracleRoutineName(routine);
+        const params = routine.params
+            .map(p => {
+            const dir = p.direction === 'in' ? 'IN' : p.direction === 'out' ? 'OUT' : 'IN OUT';
+            // PL/SQL formal params require unconstrained types — `VARCHAR2`, not `VARCHAR2(255)`.
+            return `${this.quote(p.name.toUpperCase())} ${dir} ${stripTypeLength(p.type)}`;
+        })
+            .join(', ');
+        const argsClause = routine.params.length ? `(${params})` : '';
+        const body = this.wrapRoutineBody(routine.body ?? '');
+        if (routine.type === 'procedure') {
+            return `create or replace procedure ${name}${argsClause} as ${body};`;
+        }
+        const returnType = stripTypeLength(routine.returns?.type ?? 'VARCHAR2');
+        return `create or replace function ${name}${argsClause} return ${returnType} as ${body};`;
+    }
+    /** Uses `IF EXISTS` (Oracle 23c+); older versions can extend this helper. */
+    dropRoutine(routine) {
+        const kind = routine.type === 'procedure' ? 'procedure' : 'function';
+        return `drop ${kind} if exists ${this.qualifiedOracleRoutineName(routine)}`;
+    }
+    async getAllRoutines(connection) {
+        const sql = `
+      select
+        p.OBJECT_NAME as name,
+        p.OBJECT_TYPE as kind,
+        (
+          select listagg(s.TEXT, '') within group (order by s.LINE)
+          from USER_SOURCE s
+          where s.NAME = p.OBJECT_NAME and s.TYPE = p.OBJECT_TYPE
+        ) as source
+      from USER_PROCEDURES p
+      where p.OBJECT_TYPE in ('PROCEDURE', 'FUNCTION')
+        and p.PROCEDURE_NAME is null
+    `;
+        const [rows, paramsAndReturns] = await Promise.all([
+            connection.execute(sql),
+            this.getAllRoutineParams(connection),
+        ]);
+        const { params, returns } = paramsAndReturns;
+        // Surface the connected user as the schema so the comparator's routineKey matches the
+        // metadata side (which fills `schema` from `getDefaultSchemaName()` when not declared).
+        const schemaName = this.platform.getDefaultSchemaName();
+        return rows.map(row => ({
+            name: row.name,
+            schema: schemaName,
+            type: row.kind.toLowerCase(),
+            body: this.unwrapPlSqlBody(row.source ?? ''),
+            params: params.get(row.name) ?? [],
+            returns: row.kind === 'FUNCTION' ? (returns.get(row.name) ?? { type: 'VARCHAR2', nullable: true }) : undefined,
+        }));
+    }
+    async getAllRoutineParams(connection) {
+        // POSITION = 0 / ARGUMENT_NAME = NULL is the function return type; `PACKAGE_NAME is null`
+        // restricts to standalone routines so packaged ones don't leak through name collisions.
+        const sql = `
+      select
+        OBJECT_NAME as routine_name,
+        ARGUMENT_NAME as param_name,
+        DATA_TYPE as type,
+        IN_OUT as direction,
+        POSITION as position
+      from USER_ARGUMENTS
+      where PACKAGE_NAME is null
+      order by OBJECT_NAME, POSITION
+    `;
+        const rows = await connection.execute(sql);
+        const params = new Map();
+        const returns = new Map();
+        for (const row of rows) {
+            if (row.position === 0 && row.param_name == null) {
+                returns.set(row.routine_name, { type: row.type, nullable: true });
+                continue;
+            }
+            if (!params.has(row.routine_name)) {
+                params.set(row.routine_name, []);
+            }
+            const direction = row.direction === 'IN/OUT' ? 'inout' : row.direction === 'OUT' ? 'out' : 'in';
+            params.get(row.routine_name).push({
+                name: row.param_name,
+                type: row.type,
+                direction,
+            });
+        }
+        return { params, returns };
+    }
+    unwrapPlSqlBody(source) {
+        const match = /\b(?:as|is)\s+(?:begin\s+)?([\s\S]*?)\s*end\s*;?\s*$/i.exec(source.trim());
+        return match ? match[1].trim() : source.trim();
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/oracledb",
-  "version": "7.1.0-dev.43",
+  "version": "7.1.0-dev.44",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, MariaDB, PostgreSQL, SQLite, MSSQL and Oracle databases.",
   "keywords": [
     "data-mapper",
@@ -42,7 +42,7 @@
     "copy": "node ../../scripts/copy.mjs"
   },
   "dependencies": {
-    "@mikro-orm/sql": "7.1.0-dev.43",
+    "@mikro-orm/sql": "7.1.0-dev.44",
     "kysely": "0.29.2",
     "oracledb": "6.10.0"
   },
@@ -50,7 +50,7 @@
     "@mikro-orm/core": "^7.0.17"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.1.0-dev.43"
+    "@mikro-orm/core": "7.1.0-dev.44"
   },
   "engines": {
     "node": ">= 22.17.0"