Method callRoutine

packages/oracledb/src/OracleConnection.ts:229–335

* 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 * fu

(routine: Routine, args: Record<string, unknown> = {}, ctx?: Transaction)

   * functions are allowed through.
   */
  override async callRoutine<T>(routine: Routine, args: Record<string, unknown> = {}, ctx?: Transaction): Promise<T> {
    /* 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: Dictionary = { mo_ret: oracleReturnBind(this.platform as OraclePlatform, routine) };

        for (const p of routine.params) {
          bindings[p.name as string] = {
            dir: oracledb.BIND_IN,
            val: this.convertRoutineInbound(args[p.name as string], p),
          };
        }

        const result = await oracleConn.execute(block, bindings, { autoCommit: true });
        return this.convertRoutineOutbound<T>((result.outBinds as Dictionary)?.mo_ret, routine.returnCustomType);
      }

      const argList = routine.params.map(p => `:${p.name}`).join(', ');
      const block = `BEGIN ${qualifiedName}(${argList}); END;`;
      const bindings: Dictionary = {};
      const refCursorParams: string[] = [];

      for (const p of routine.params) {
        const value = this.convertRoutineInbound(args[p.name as string], p);
        const isRefCursor = typeof p.type === 'string' && /sys_refcursor|ref\s*cursor/i.test(p.type);

        if (p.direction === 'in') {
          bindings[p.name as string] = { dir: oracledb.BIND_IN, val: value };
          continue;
        }

        if (isRefCursor) {
          bindings[p.name as string] = { dir: oracledb.BIND_OUT, type: oracledb.DB_TYPE_CURSOR };
          refCursorParams.push(p.name as string);
          continue;
        }