@mikro-orm/oracledb 7.1.0-dev.3 → 7.1.0-dev.30

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.js

@@ -203,7 +203,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/OracleSchemaHelper.d.ts

@@ -2,7 +2,13 @@ import { type AbstractSqlConnection, type CheckDef, type Column, type DatabaseSc
 /** 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;

package/OracleSchemaHelper.js

@@ -7,9 +7,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 +141,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 +198,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 +236,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 +260,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 +378,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 +391,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 +496,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 +520,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 +557,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 +588,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);
             })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/oracledb",
-  "version": "7.1.0-dev.3",
+  "version": "7.1.0-dev.30",
   "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.3",
-    "kysely": "0.28.16",
+    "@mikro-orm/sql": "7.1.0-dev.30",
+    "kysely": "0.28.17",
     "oracledb": "6.10.0"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^7.0.11"
+    "@mikro-orm/core": "^7.0.15"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.1.0-dev.3"
+    "@mikro-orm/core": "7.1.0-dev.30"
   },
   "engines": {
     "node": ">= 22.17.0"