@mikro-orm/oracledb 7.1.0-dev.9 → 7.1.1-dev.0

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/OracleMikroORM.d.ts

@@ -1,5 +1,5 @@
-import { MikroORM, type Options, type IDatabaseDriver, type EntityManager, type EntityManagerType, type EntityClass, type AnyEntity, type EntitySchema } from '@mikro-orm/core';
-import type { SqlEntityManager } from '@mikro-orm/sql';
+import { type MikroORM, type Options, type IDatabaseDriver, type EntityManager, type EntityManagerType, type EntityClass, type AnyEntity, type EntitySchema } from '@mikro-orm/core';
+import { SqlMikroORM, type SqlEntityManager } from '@mikro-orm/sql';
 import { OracleDriver } from './OracleDriver.js';
 /** Configuration options for the Oracle driver. */
 export type OracleOptions<EM extends SqlEntityManager<OracleDriver> = SqlEntityManager<OracleDriver>, Entities extends readonly (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]> = Partial<Options<OracleDriver, EM, Entities>>;
@@ -8,7 +8,7 @@ export declare function defineOracleConfig<EM extends SqlEntityManager<OracleDri
 /**
  * @inheritDoc
  */
-export declare class OracleMikroORM<EM extends SqlEntityManager<OracleDriver> = SqlEntityManager<OracleDriver>, Entities extends readonly (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]> extends MikroORM<OracleDriver, EM, Entities> {
+export declare class OracleMikroORM<EM extends SqlEntityManager<OracleDriver> = SqlEntityManager<OracleDriver>, Entities extends readonly (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]> extends SqlMikroORM<OracleDriver, EM, Entities> {
     /**
      * @inheritDoc
      */

package/OracleMikroORM.js

@@ -1,4 +1,5 @@
-import { defineConfig, MikroORM, } from '@mikro-orm/core';
+import { defineConfig, } from '@mikro-orm/core';
+import { SqlMikroORM } from '@mikro-orm/sql';
 import { OracleDriver } from './OracleDriver.js';
 /** Creates a type-safe configuration object for the Oracle driver. */
 export function defineOracleConfig(options) {
@@ -7,7 +8,7 @@ export function defineOracleConfig(options) {
 /**
  * @inheritDoc
  */
-export class OracleMikroORM extends MikroORM {
+export class OracleMikroORM extends SqlMikroORM {
     /**
      * @inheritDoc
      */

package/OraclePlatform.d.ts

@@ -16,6 +16,8 @@ export declare class OraclePlatform extends AbstractSqlPlatform {
         readOnly?: boolean;
     }): string[];
     usesAsKeyword(): boolean;
+    /** Oracle 12.2+ identifier limit (pre-12.2 is 30 chars). */
+    getMaxIdentifierLength(): number;
     compareUuids(): string;
     convertUuidToJSValue(value: Buffer): string;
     convertUuidToDatabaseValue(value: string): Buffer;

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,
@@ -48,6 +50,10 @@ export class OraclePlatform extends AbstractSqlPlatform {
     usesAsKeyword() {
         return false;
     }
+    /** Oracle 12.2+ identifier limit (pre-12.2 is 30 chars). */
+    getMaxIdentifierLength() {
+        return 128;
+    }
     compareUuids() {
         return 'any';
     }
@@ -203,7 +209,7 @@ export class OraclePlatform extends AbstractSqlPlatform {
         if (b.length === 0) {
             return raw(`json_equal(${root}, json(?))`, [value]);
         }
-        return raw(`json_value(${root}, '$.${b.map(this.quoteJsonKey).join('.')}')`);
+        return raw(`json_value(${root}, ${this.quoteValue(`$.${b.map(this.quoteJsonKey).join('.')}`)})`);
     }
     processJsonCondition(o, value, path, alias) {
         if (Utils.isPlainObject(value) && !Object.keys(value).some(k => Utils.isOperator(k))) {

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,8 +1,14 @@
-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[]>;
+    private static readonly AUTO_NOT_NULL_RE;
+    private static readonly PARTIAL_INDEX_RE;
     getDatabaseExistsSQL(name: string): string;
+    getSetSchemaSQL(schema: string): string;
+    getResetSchemaSQL(defaultSchema: string): string;
+    supportsMigrationSchema(): boolean;
+    tableExists(connection: AbstractSqlConnection, tableName: string, schemaName: string | undefined, ctx?: Transaction): Promise<boolean>;
     getAllTables(connection: AbstractSqlConnection, schemas?: string[], ctx?: Transaction): Promise<Table[]>;
     getListTablesSQL(schemaName?: string): string;
     getListViewsSQL(): string;
@@ -19,6 +25,7 @@ export declare class OracleSchemaHelper extends SchemaHelper {
     private getEnumDefinitions;
     private getChecksSQL;
     getAllChecks(connection: AbstractSqlConnection, tablesBySchemas: Map<string | undefined, Table[]>, ctx?: Transaction): Promise<Dictionary<CheckDef[]>>;
+    getDatabaseCollation(connection: AbstractSqlConnection, ctx?: Transaction): Promise<string | undefined>;
     loadInformationSchema(schema: DatabaseSchema, connection: AbstractSqlConnection, tables: Table[], schemas?: string[], ctx?: Transaction): Promise<void>;
     getPreAlterTable(tableDiff: TableDifference, safe: boolean): string[];
     getPostAlterTable(tableDiff: TableDifference, safe: boolean): string[];
@@ -35,6 +42,9 @@ export declare class OracleSchemaHelper extends SchemaHelper {
     createTableColumn(column: Column, table: DatabaseTable, changedProperties?: Set<string>): string | undefined;
     alterTableColumn(column: Column, table: DatabaseTable, changedProperties: Set<string>): string[];
     getCreateIndexSQL(tableName: string, index: IndexDef, partialExpression?: boolean): string;
+    protected getIndexColumns(index: IndexDef): string;
+    /** Oracle has no native WHERE clause for indexes; the predicate is folded into CASE-WHEN columns. */
+    protected getIndexWhereClause(_index: IndexDef): string;
     createIndex(index: IndexDef, table: DatabaseTable, createPrimary?: boolean): string;
     dropForeignKey(tableName: string, constraintName: string): string;
     dropViewIfExists(name: string, schema?: string): string;
@@ -43,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 = {
@@ -7,9 +10,29 @@ export class OracleSchemaHelper extends SchemaHelper {
         systimestamp: ['current_timestamp'],
         sysdate: ['current_timestamp'],
     };
+    // `stripAutoNotNullFilter` unwraps balanced per-clause parens before calling `.exec`, so we
+    // only need to match the bare form here.
+    static AUTO_NOT_NULL_RE = /^"?([^"\s()]+)"?\s+is\s+not\s+null$/i;
+    // Greedy `(.+)` so nested CASE expressions inside the predicate don't trip the match on
+    // an inner `then <col> end`.
+    static PARTIAL_INDEX_RE = /^\s*\(?\s*case\s+when\s+(.+)\s+then\s+"?([^"\s)]+)"?\s+end\s*\)?\s*$/is;
     getDatabaseExistsSQL(name) {
         return `select 1 from all_users where username = ${this.platform.quoteValue(name)}`;
     }
+    getSetSchemaSQL(schema) {
+        return `alter session set current_schema = ${this.quote(schema)}`;
+    }
+    getResetSchemaSQL(defaultSchema) {
+        return `alter session set current_schema = ${this.quote(defaultSchema)}`;
+    }
+    supportsMigrationSchema() {
+        return true;
+    }
+    async tableExists(connection, tableName, schemaName, ctx) {
+        const schema = schemaName ?? this.platform.getDefaultSchemaName();
+        const rows = await connection.execute(`select 1 from all_tables where owner = ${this.platform.quoteValue(schema)} and table_name = ${this.platform.quoteValue(tableName)}`, [], 'all', ctx);
+        return rows.length > 0;
+    }
     async getAllTables(connection, schemas, ctx) {
         if (!schemas || schemas.length === 0) {
             return connection.execute(this.getListTablesSQL(), [], 'all', ctx);
@@ -121,7 +144,8 @@ export class OracleSchemaHelper extends SchemaHelper {
       atc.char_length as character_maximum_length,
       atc.data_length as data_length,
       atc.identity_column as is_identity,
-      atc.column_id as ordinal_position
+      atc.column_id as ordinal_position,
+      atc.collation as collation_name
       from all_tab_cols atc
       left join all_col_comments acc on atc.owner = acc.owner and atc.table_name = acc.table_name and atc.column_name = acc.column_name
       where atc.hidden_column = 'NO'
@@ -177,6 +201,11 @@ export class OracleSchemaHelper extends SchemaHelper {
                 precision: col.numeric_precision,
                 scale: col.numeric_scale,
                 comment: col.column_comment,
+                // `USING_NLS_COMP` is the Oracle sentinel for "inherit from the session NLS settings", so
+                // a column without an explicit `COLLATE` clause introspects as `USING_NLS_COMP` rather
+                // than NULL. Treat it as "no explicit collation" so the comparator doesn't flag every
+                // string column as changed when the database default is something else (e.g. `BINARY`).
+                collation: col.collation_name && col.collation_name !== 'USING_NLS_COMP' ? col.collation_name : undefined,
                 generated,
             });
         }
@@ -210,16 +239,19 @@ export class OracleSchemaHelper extends SchemaHelper {
             if (isPrimary) {
                 continue;
             }
+            const partialMatch = typeof index.expression === 'string' ? OracleSchemaHelper.PARTIAL_INDEX_RE.exec(index.expression) : null;
             const indexDef = {
-                columnNames: [index.column_name],
+                columnNames: [partialMatch ? partialMatch[2] : index.column_name],
                 keyName: index.index_name,
                 unique: index.is_unique === 'YES',
-                primary: false, // We skip PK indexes above, so this is always false
+                primary: false,
                 constraint: isConstraintIndex || index.is_unique === 'YES',
             };
-            // Handle function-based indexes (expression indexes)
-            /* v8 ignore start: expression index branches */
-            if (index.expression) {
+            /* v8 ignore start: function-based (non-partial) index branches */
+            if (partialMatch) {
+                indexDef.where = partialMatch[1].trim();
+            }
+            else if (index.expression) {
                 indexDef.expression = index.expression;
             }
             else if (index.column_name?.match(/[(): ,"'`]/)) {
@@ -231,6 +263,17 @@ export class OracleSchemaHelper extends SchemaHelper {
         }
         for (const key of Object.keys(ret)) {
             ret[key] = await this.mapIndexes(ret[key]);
+            for (const idx of ret[key]) {
+                if (idx.where) {
+                    const stripped = this.stripAutoNotNullFilter(idx.where, idx.columnNames, OracleSchemaHelper.AUTO_NOT_NULL_RE);
+                    if (stripped === '') {
+                        delete idx.where;
+                    }
+                    else {
+                        idx.where = stripped;
+                    }
+                }
+            }
         }
         return ret;
     }
@@ -338,6 +381,10 @@ export class OracleSchemaHelper extends SchemaHelper {
         }
         return ret;
     }
+    async getDatabaseCollation(connection, ctx) {
+        const [row] = await connection.execute(`select property_value as collation from database_properties where property_name = 'DEFAULT_COLLATION'`, [], 'all', ctx);
+        return row?.collation;
+    }
     async loadInformationSchema(schema, connection, tables, schemas, ctx) {
         if (tables.length === 0) {
             return;
@@ -347,9 +394,11 @@ export class OracleSchemaHelper extends SchemaHelper {
         const indexes = await this.getAllIndexes(connection, tablesBySchema, ctx);
         const checks = await this.getAllChecks(connection, tablesBySchema, ctx);
         const fks = await this.getAllForeignKeys(connection, tablesBySchema, ctx);
+        const dbCollation = await this.getDatabaseCollation(connection, ctx);
         for (const t of tables) {
             const key = this.getTableKey(t);
             const table = schema.addTable(t.table_name, t.schema_name, t.table_comment);
+            table.collation = dbCollation;
             const pks = await this.getPrimaryKeys(connection, indexes[key], table.name, table.schema);
             const enums = this.getEnumDefinitions(checks[key] ?? []);
             table.init(columns[key], indexes[key], checks[key], pks, fks[key], enums);
@@ -450,6 +499,7 @@ export class OracleSchemaHelper extends SchemaHelper {
         /* v8 ignore next: generated column branch */
         const columnType = column.generated ? `as ${column.generated}` : column.type;
         const col = [this.quote(column.name), columnType];
+        Utils.runIfNotEmpty(() => col.push(this.getCollateSQL(column.collation)), column.collation);
         Utils.runIfNotEmpty(() => col.push('generated by default as identity'), column.autoincrement);
         /* v8 ignore next 3: default value branch */
         const useDefault = changedProperties
@@ -473,8 +523,15 @@ export class OracleSchemaHelper extends SchemaHelper {
         const parts = [];
         const quotedTableName = table.getQuotedName();
         // Oracle uses MODIFY for column changes, and always requires the column type
-        if (changedProperties.has('type') || changedProperties.has('nullable') || changedProperties.has('default')) {
+        if (changedProperties.has('type') ||
+            changedProperties.has('nullable') ||
+            changedProperties.has('default') ||
+            changedProperties.has('collation')) {
             const colParts = [this.quote(column.name), column.type];
+            // Oracle's MODIFY restates the column type, so re-emit COLLATE whenever the column has
+            // one — even if the trigger was a nullable/default change — so we can't accidentally
+            // drop the column collation by omitting it from the new type spec.
+            Utils.runIfNotEmpty(() => colParts.push(this.getCollateSQL(column.collation)), column.collation);
             if (changedProperties.has('default')) {
                 if (column.default != null && column.default !== 'null') {
                     colParts.push(`default ${column.default}`);
@@ -503,6 +560,16 @@ export class OracleSchemaHelper extends SchemaHelper {
         }
         return super.getCreateIndexSQL(tableName, index);
     }
+    getIndexColumns(index) {
+        if (index.where) {
+            return this.emulatePartialIndexColumns(index);
+        }
+        return super.getIndexColumns(index);
+    }
+    /** Oracle has no native WHERE clause for indexes; the predicate is folded into CASE-WHEN columns. */
+    getIndexWhereClause(_index) {
+        return '';
+    }
     createIndex(index, table, createPrimary = false) {
         if (index.primary) {
             return '';
@@ -524,10 +591,21 @@ export class OracleSchemaHelper extends SchemaHelper {
         const quotedTableName = table.getQuotedName();
         if (index.unique) {
             const nullableCols = index.columnNames.filter(column => table.getColumn(column)?.nullable);
+            const autoNotNull = nullableCols.length
+                ? nullableCols.map(c => `${this.quote(c)} is not null`).join(' and ')
+                : '';
+            if (index.where) {
+                // Wrap the user predicate in parens before ANDing the auto-NOT-NULL guard — otherwise a
+                // disjunctive `a = 1 or b = 2` would rebind as `a = 1 or (b = 2 and <col> is not null)`.
+                const predicate = autoNotNull ? `(${index.where}) and ${autoNotNull}` : index.where;
+                return `create unique index ${this.quote(index.keyName)} on ${quotedTableName} (${index.columnNames
+                    .map(c => `case when ${predicate} then ${this.quote(c)} end`)
+                    .join(', ')})`;
+            }
             return `create unique index ${this.quote(index.keyName)} on ${quotedTableName} (${index.columnNames
                 .map(c => {
                 if (table.getColumn(c)?.nullable) {
-                    return `case when ${nullableCols.map(c => `${this.quote(c)} is not null`).join(' and ')} then ${this.quote(c)} end`;
+                    return `case when ${autoNotNull} then ${this.quote(c)} end`;
                 }
                 return this.quote(c);
             })
@@ -589,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/README.md

@@ -2,7 +2,7 @@
   <a href="https://mikro-orm.io"><img src="https://raw.githubusercontent.com/mikro-orm/mikro-orm/master/docs/static/img/logo-readme.svg?sanitize=true" alt="MikroORM" /></a>
 </h1>
 
-TypeScript ORM for Node.js based on Data Mapper, [Unit of Work](https://mikro-orm.io/docs/unit-of-work/) and [Identity Map](https://mikro-orm.io/docs/identity-map/) patterns. Supports MongoDB, MySQL, MariaDB, PostgreSQL, SQLite (including libSQL), MSSQL and Oracle databases.
+TypeScript ORM for Node.js based on Data Mapper, [Unit of Work](https://mikro-orm.io/docs/unit-of-work/) and [Identity Map](https://mikro-orm.io/docs/identity-map/) patterns. Supports MongoDB, MySQL, MariaDB, PostgreSQL (including CockroachDB and PGlite), SQLite (including libSQL), MSSQL and Oracle databases.
 
 > Heavily inspired by [Doctrine](https://www.doctrine-project.org/) and [Hibernate](https://hibernate.org/).
 
@@ -19,6 +19,7 @@ Install a driver package for your database:
 
 ```sh
 npm install @mikro-orm/postgresql   # PostgreSQL
+npm install @mikro-orm/pglite       # PGlite (embedded PostgreSQL in WASM)
 npm install @mikro-orm/mysql        # MySQL
 npm install @mikro-orm/mariadb      # MariaDB
 npm install @mikro-orm/sqlite       # SQLite

package/index.d.ts

@@ -8,3 +8,7 @@ export * from './OracleSchemaGenerator.js';
 export * from './OracleExceptionConverter.js';
 export type { OracleOptions as Options } from './OracleMikroORM.js';
 export { OracleMikroORM as MikroORM, defineOracleConfig as defineConfig } from './OracleMikroORM.js';
+import { type AbstractSqlDriver, SqlEntityManager } from '@mikro-orm/sql';
+import type { OracleDriver } from './OracleDriver.js';
+export type EntityManager<Driver extends AbstractSqlDriver = OracleDriver> = SqlEntityManager<Driver>;
+export declare const EntityManager: typeof SqlEntityManager;

package/index.js

@@ -7,3 +7,5 @@ export * from './OracleSchemaHelper.js';
 export * from './OracleSchemaGenerator.js';
 export * from './OracleExceptionConverter.js';
 export { OracleMikroORM as MikroORM, defineOracleConfig as defineConfig } from './OracleMikroORM.js';
+import { SqlEntityManager } from '@mikro-orm/sql';
+export const EntityManager = SqlEntityManager;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/oracledb",
-  "version": "7.1.0-dev.9",
+  "version": "7.1.1-dev.0",
   "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,15 +42,15 @@
     "copy": "node ../../scripts/copy.mjs"
   },
   "dependencies": {
-    "@mikro-orm/sql": "7.1.0-dev.9",
-    "kysely": "0.28.16",
+    "@mikro-orm/sql": "7.1.1-dev.0",
+    "kysely": "0.29.2",
     "oracledb": "6.10.0"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^7.0.11"
+    "@mikro-orm/core": "^7.1.0"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.1.0-dev.9"
+    "@mikro-orm/core": "7.1.1-dev.0"
   },
   "engines": {
     "node": ">= 22.17.0"