@mikro-orm/oracledb 7.0.0-dev.316

package/OraclePlatform.js

@@ -0,0 +1,283 @@
+import { AbstractSqlPlatform, ALIAS_REPLACEMENT, DoubleType, FloatType, markOutBindings, OracleNativeQueryBuilder, raw, Type, Utils, } from '@mikro-orm/sql';
+import oracledb from 'oracledb';
+import { OracleSchemaHelper } from './OracleSchemaHelper.js';
+import { OracleExceptionConverter } from './OracleExceptionConverter.js';
+import { OracleSchemaGenerator } from './OracleSchemaGenerator.js';
+const ORACLE_TYPE_MAP = {
+    string: oracledb.DB_TYPE_VARCHAR,
+    number: oracledb.DB_TYPE_NUMBER,
+    Date: oracledb.DB_TYPE_DATE,
+    boolean: oracledb.DB_TYPE_BOOLEAN,
+    buffer: oracledb.DB_TYPE_RAW,
+    Buffer: oracledb.DB_TYPE_RAW,
+    out: oracledb.BIND_OUT,
+};
+export class OraclePlatform extends AbstractSqlPlatform {
+    schemaHelper = new OracleSchemaHelper(this);
+    exceptionConverter = new OracleExceptionConverter();
+    /** @inheritDoc */
+    lookupExtensions(orm) {
+        OracleSchemaGenerator.register(orm);
+    }
+    getRollbackToSavepointSQL(savepointName) {
+        return `rollback to savepoint ${this.quoteIdentifier(savepointName)}`;
+    }
+    getSavepointSQL(savepointName) {
+        return `savepoint ${this.quoteIdentifier(savepointName)}`;
+    }
+    getBeginTransactionSQL(options) {
+        const parts = [];
+        if (options?.isolationLevel) {
+            parts.push(`isolation level ${options.isolationLevel}`);
+        }
+        if (options?.readOnly) {
+            parts.push('read only');
+        }
+        if (parts.length > 0) {
+            return [`set transaction ${parts.join(' ')}`];
+        }
+        return ['begin'];
+    }
+    usesAsKeyword() {
+        return false;
+    }
+    compareUuids() {
+        return 'any';
+    }
+    convertUuidToJSValue(value) {
+        const hex = value.toString('hex');
+        return (hex.slice(0, 8) + '-' + hex.slice(8, 12) + '-' + hex.slice(12, 16) + '-' + hex.slice(16, 20) + '-' + hex.slice(20));
+    }
+    convertUuidToDatabaseValue(value) {
+        if (Buffer.isBuffer(value)) {
+            return value;
+        }
+        if (typeof value !== 'string') {
+            return value;
+        }
+        return Buffer.from(value.replaceAll('-', ''), 'hex');
+    }
+    /** @internal */
+    createNativeQueryBuilder() {
+        return new OracleNativeQueryBuilder(this);
+    }
+    usesOutputStatement() {
+        return false;
+    }
+    usesReturningStatement() {
+        return true;
+    }
+    convertsJsonAutomatically() {
+        return true;
+    }
+    indexForeignKeys() {
+        return false;
+    }
+    supportsSchemas() {
+        return true;
+    }
+    getCurrentTimestampSQL(length) {
+        return `current_timestamp`;
+    }
+    getDateTimeTypeDeclarationSQL(column) {
+        return 'timestamp' + (column.length != null ? `(${column.length})` : '') + ' with time zone';
+    }
+    getDefaultDateTimeLength() {
+        return 6;
+    }
+    getFloatDeclarationSQL() {
+        return 'binary_float';
+    }
+    getDoubleDeclarationSQL() {
+        return 'binary_double';
+    }
+    getDecimalTypeDeclarationSQL(column) {
+        return `number(${column.precision ?? 10}, ${column.scale ?? 0})`;
+    }
+    getBooleanTypeDeclarationSQL() {
+        return 'boolean';
+    }
+    getRegExpOperator() {
+        return 'regexp_like';
+    }
+    mapRegExpCondition(mappedKey, value) {
+        const quotedKey = this.quoteIdentifier(mappedKey);
+        /* v8 ignore next: $flags branch */
+        const quotedFlags = value.$flags ? `, ${this.quoteValue(value.$flags)}` : '';
+        return { sql: `regexp_like(${quotedKey}, ?${quotedFlags})`, params: [value.$re] };
+    }
+    getBlobDeclarationSQL() {
+        return 'blob';
+    }
+    getJsonDeclarationSQL() {
+        return 'json';
+    }
+    getDefaultSchemaName() {
+        return this.config.get('dbName');
+    }
+    getVarcharTypeDeclarationSQL(column) {
+        return `varchar2(${column.length ?? this.getDefaultVarcharLength()})`;
+    }
+    getDateTypeDeclarationSQL(length) {
+        return this.getVarcharTypeDeclarationSQL({ length: length ?? 10 });
+    }
+    getTimeTypeDeclarationSQL(length) {
+        return this.getVarcharTypeDeclarationSQL({ length: length ?? 8 });
+    }
+    getIntegerTypeDeclarationSQL(column) {
+        return `number(${column.length ?? 10}, 0)`;
+    }
+    /**
+     * @inheritDoc
+     */
+    getBigIntTypeDeclarationSQL(column) {
+        return this.getIntegerTypeDeclarationSQL({ ...column, length: column.length ?? 19 });
+    }
+    getMediumIntTypeDeclarationSQL(column) {
+        return this.getIntegerTypeDeclarationSQL({ ...column, length: column.length ?? 7 });
+    }
+    getTinyIntTypeDeclarationSQL(column) {
+        return this.getIntegerTypeDeclarationSQL({ ...column, length: column.length ?? 3 });
+    }
+    getSmallIntTypeDeclarationSQL(column) {
+        return this.getIntegerTypeDeclarationSQL({ ...column, length: column.length ?? 5 });
+    }
+    getArrayDeclarationSQL() {
+        return 'clob';
+    }
+    getEnumTypeDeclarationSQL(column) {
+        if (column.items?.every(item => typeof item === 'string')) {
+            const length = column.length ?? Math.max(...column.items.map(item => item.length));
+            return this.getVarcharTypeDeclarationSQL({ length });
+        }
+        return this.getSmallIntTypeDeclarationSQL(column);
+    }
+    getTextTypeDeclarationSQL(_column) {
+        return 'clob';
+    }
+    normalizeColumnType(type, options) {
+        const simpleType = this.extractSimpleType(type);
+        // Oracle uses 'number' for all numeric types including integer, decimal, etc.
+        if (['decimal', 'numeric', 'number'].includes(simpleType)) {
+            return this.getDecimalTypeDeclarationSQL(options);
+        }
+        if (['real'].includes(simpleType)) {
+            return this.getFloatDeclarationSQL();
+        }
+        return super.normalizeColumnType(type, options);
+    }
+    getDefaultMappedType(type) {
+        if (type.startsWith('float')) {
+            const len = /float\((\d+)\)/.exec(type)?.[1] ?? 24;
+            return +len > 24 ? Type.getType(DoubleType) : Type.getType(FloatType);
+        }
+        const normalizedType = this.extractSimpleType(type);
+        const map = {
+            int: 'integer',
+            real: 'float',
+            raw: 'uuid',
+            binary_float: 'float',
+            binary_double: 'double',
+            nvarchar2: 'string',
+            nclob: 'text',
+        };
+        return super.getDefaultMappedType(map[normalizedType] ?? type);
+    }
+    getUuidTypeDeclarationSQL(column) {
+        return 'raw(16)';
+    }
+    /* v8 ignore next 3: Oracle overrides all callers but this is part of the platform contract */
+    usesCascadeStatement() {
+        return true;
+    }
+    getSearchJsonPropertyKey(path, type, aliased, value) {
+        const [a, ...b] = path;
+        const root = this.quoteIdentifier(aliased ? `${ALIAS_REPLACEMENT}.${a}` : a);
+        if (b.length === 0) {
+            return raw(`json_equal(${root}, json(?))`, [value]);
+        }
+        /* v8 ignore next: special-char JSON key quoting */
+        const quoteKey = (key) => (/^[a-z]\w*$/i.exec(key) ? key : `"${key}"`);
+        return raw(`json_value(${root}, '$.${b.map(quoteKey).join('.')}')`);
+    }
+    processJsonCondition(o, value, path, alias) {
+        if (Utils.isPlainObject(value) && !Object.keys(value).some(k => Utils.isOperator(k))) {
+            Utils.keys(value).forEach(k => {
+                this.processJsonCondition(o, value[k], [...path, k], alias);
+            });
+            return o;
+        }
+        if (Utils.isPlainObject(value) && Object.keys(value)[0] === '$eq') {
+            value = value.$eq;
+        }
+        const type = this.getJsonValueType(value);
+        const k = this.getSearchJsonPropertyKey(path, type, alias, value);
+        /* v8 ignore next: root-level JSON equality branch */
+        o[k] = path.length > 1 ? value : [];
+        return o;
+    }
+    usesEnumCheckConstraints() {
+        return true;
+    }
+    supportsMultipleCascadePaths() {
+        return false;
+    }
+    /** @inheritDoc */
+    supportsOnUpdate() {
+        return false;
+    }
+    supportsMultipleStatements() {
+        return false;
+    }
+    quoteIdentifier(id) {
+        return super.quoteIdentifier(id, '"');
+    }
+    escape(value) {
+        if (value === null) {
+            return 'null';
+        }
+        if (Array.isArray(value)) {
+            return value.map(v => this.escape(v)).join(', ');
+        }
+        if (typeof value === 'string') {
+            if (value.includes(`'`)) {
+                return `'${value.replaceAll(`'`, `''`)}'`;
+            }
+            return `'${value}'`;
+        }
+        if (Buffer.isBuffer(value)) {
+            return `hextoraw('${value.toString('hex')}')`;
+        }
+        if (value instanceof Date) {
+            return `timestamp '${value.toISOString().replace('T', ' ').substring(0, 23)} UTC'`;
+        }
+        return super.escape(value);
+    }
+    getSchemaGenerator(driver, em) {
+        return new OracleSchemaGenerator(em ?? driver);
+    }
+    allowsComparingTuples() {
+        return false;
+    }
+    getDefaultClientUrl() {
+        return 'localhost:1521/freepdb1';
+    }
+    /** @internal */
+    mapToBindType(type) {
+        return this.mapToOracleType(type);
+    }
+    mapToOracleType(type) {
+        return ORACLE_TYPE_MAP[type] ?? oracledb.DB_TYPE_VARCHAR;
+    }
+    createOutBindings(map) {
+        const outBindings = {};
+        markOutBindings(outBindings);
+        for (const key of Object.keys(map)) {
+            outBindings[key] = {
+                dir: oracledb.BIND_OUT,
+                type: this.mapToOracleType(map[key]),
+            };
+        }
+        return outBindings;
+    }
+}

package/OracleQueryBuilder.d.ts

@@ -0,0 +1,9 @@
+import { type AnyEntity, type Dictionary, type EntityMetadata, type LockMode, type RequiredEntityData } from '@mikro-orm/core';
+import { type InsertQueryBuilder, type NativeQueryBuilder, type Field, QueryBuilder } from '@mikro-orm/sql';
+export declare class OracleQueryBuilder<Entity extends object = AnyEntity, RootAlias extends string = never, Hint extends string = never, Context extends object = never> extends QueryBuilder<Entity, RootAlias, Hint, Context> {
+    insert(data: RequiredEntityData<Entity> | RequiredEntityData<Entity>[]): InsertQueryBuilder<Entity, RootAlias, Context>;
+    setLockMode(mode?: LockMode, tables?: string[]): this;
+    getNativeQuery(processVirtualEntity?: boolean): NativeQueryBuilder;
+    private convertLockTablesToColumnRefs;
+    protected processReturningStatement(qb: NativeQueryBuilder, meta?: EntityMetadata, data?: Dictionary, returning?: Field<any>[]): void;
+}

package/OracleQueryBuilder.js

@@ -0,0 +1,85 @@
+import { isRaw, raw, Utils, } from '@mikro-orm/core';
+import { QueryBuilder, QueryType } from '@mikro-orm/sql';
+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);
+    }
+    setLockMode(mode, tables) {
+        if (tables) {
+            this.convertLockTablesToColumnRefs(tables);
+        }
+        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);
+        }
+        return qb;
+    }
+    convertLockTablesToColumnRefs(tables) {
+        for (let i = 0; i < tables.length; i++) {
+            if (!tables[i].includes('.')) {
+                const aliasInfo = this._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];
+                }));
+            }
+        }
+    }
+}

package/OracleSchemaGenerator.d.ts

@@ -0,0 +1,41 @@
+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';
+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;
+}