@mikro-orm/oracledb 7.0.0-dev.316

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Martin Adámek
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/OracleConnection.d.ts

@@ -0,0 +1,11 @@
+import { AbstractSqlConnection, type AnyEntity, type EntityData, type LoggingOptions, NativeQueryBuilder, OracleDialect, type QueryResult, RawQueryFragment, type Transaction } from '@mikro-orm/sql';
+import { type PoolAttributes } from 'oracledb';
+export declare class OracleConnection extends AbstractSqlConnection {
+    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>;
+    private stripTrailingSemicolon;
+    protected transformRawResult<T>(res: any, method: 'all' | 'get' | 'run'): T;
+}

package/OracleConnection.js

@@ -0,0 +1,176 @@
+import { AbstractSqlConnection, NativeQueryBuilder, OracleDialect, RawQueryFragment, Utils, } from '@mikro-orm/sql';
+import { CompiledQuery } from 'kysely';
+import oracledb from 'oracledb';
+export class OracleConnection extends AbstractSqlConnection {
+    async createKyselyDialect(overrides) {
+        const options = this.mapOptions(overrides);
+        const password = options.password;
+        const onCreateConnection = this.options.onCreateConnection ?? this.config.get('onCreateConnection');
+        const poolOptions = {
+            ...options,
+            /* v8 ignore next: password-as-function branch requires mocking pool creation */
+            password: typeof password === 'function' ? await password() : password,
+            sessionCallback: onCreateConnection,
+        };
+        // Retry pool creation for transient Oracle errors (e.g. ORA-01017 under load)
+        let pool;
+        const maxRetries = 3;
+        for (let attempt = 1;; attempt++) {
+            try {
+                pool = await oracledb.createPool(poolOptions);
+                break;
+                /* v8 ignore start: transient Oracle pool-creation errors are not reproducible in tests */
+            }
+            catch (e) {
+                if (attempt < maxRetries && (e.errorNum === 1017 || e.errorNum === 12514 || e.errorNum === 12541)) {
+                    await new Promise(resolve => setTimeout(resolve, 250 * attempt));
+                    continue;
+                }
+                throw e;
+            }
+            /* v8 ignore stop */
+        }
+        const executeOptions = {
+            fetchTypeHandler: metaData => {
+                const bigInt = metaData.dbType === oracledb.DB_TYPE_NUMBER && (metaData.precision ?? 0) > 10;
+                metaData.name = metaData.name.toLowerCase();
+                if (bigInt || metaData.dbType === oracledb.DB_TYPE_CLOB) {
+                    return {
+                        type: oracledb.DB_TYPE_VARCHAR,
+                    };
+                }
+                if (metaData.dbType === oracledb.DB_TYPE_BLOB) {
+                    return {
+                        type: oracledb.BUFFER,
+                    };
+                }
+                return undefined;
+            },
+        };
+        return new OracleDialect({
+            pool,
+            executeOptions: executeOptions,
+        });
+    }
+    mapOptions(overrides) {
+        const ret = { ...this.getConnectionOptions() };
+        const dbName = this.config.get('dbName');
+        const pool = this.config.get('pool');
+        ret.poolMin = pool?.min;
+        ret.poolMax = pool?.max;
+        ret.poolTimeout = pool?.idleTimeoutMillis;
+        const user = this.config.get('user', dbName);
+        ret.user = user.startsWith('"') || user === 'system' ? user : this.platform.quoteIdentifier(user);
+        ret.connectionString = this.options.clientUrl ?? this.platform.getDefaultClientUrl();
+        Reflect.deleteProperty(ret, 'database');
+        Reflect.deleteProperty(ret, 'port');
+        Reflect.deleteProperty(ret, 'host');
+        return Utils.mergeConfig(ret, overrides);
+    }
+    async execute(query, params = [], method = 'all', ctx, loggerContext) {
+        await this.ensureConnection();
+        if (query instanceof NativeQueryBuilder) {
+            query = query.toRaw();
+        }
+        if (query instanceof RawQueryFragment) {
+            params = query.params;
+            query = query.sql;
+        }
+        query = this.stripTrailingSemicolon(query);
+        let last;
+        let rawQuery;
+        const lastParam = params[params.length - 1];
+        if (Utils.isObject(lastParam) && '__outBindings' in lastParam && lastParam.__outBindings) {
+            rawQuery = lastParam.__rawQuery;
+            const { __outBindings, ...rest } = lastParam;
+            last = rest;
+            params = [...params.slice(0, -1), last];
+        }
+        query = this.config.get('onQuery')(query, params);
+        const formatted = this.platform.formatQuery(query, params);
+        const sql = this.getSql(rawQuery ?? query, formatted, loggerContext);
+        return this.executeQuery(sql, async () => {
+            const compiled = CompiledQuery.raw(formatted, last);
+            if (ctx) {
+                const res = await ctx.executeQuery(compiled);
+                return this.transformRawResult(res, method);
+            }
+            const res = await this.getClient().executeQuery({
+                ...compiled,
+                autoCommit: true,
+            });
+            return this.transformRawResult(res, method);
+        }, { query, params, ...loggerContext });
+    }
+    /** @inheritDoc */
+    async executeDump(dump) {
+        await this.ensureConnection();
+        const lines = dump.split('\n').filter(i => i.trim());
+        for (let line of lines) {
+            if (line.startsWith('--')) {
+                continue;
+            }
+            line = this.stripTrailingSemicolon(line);
+            const raw = CompiledQuery.raw(line);
+            const now = Date.now();
+            try {
+                await this.getClient().executeQuery(raw);
+            }
+            catch (e) {
+                this.logQuery(line, { took: Date.now() - now, level: 'error', query: line });
+                throw e;
+            }
+        }
+    }
+    stripTrailingSemicolon(sql) {
+        if (sql.endsWith(';') && !/end(\s+\w+)?;$/i.test(sql)) {
+            return sql.slice(0, -1);
+        }
+        return sql;
+    }
+    transformRawResult(res, method) {
+        if (method === 'get') {
+            return res.rows[0];
+        }
+        if (method === 'all') {
+            return res.rows;
+        }
+        if (res.numAffectedRows > 0n && res.outBinds) {
+            const keys = Object.keys(res.outBinds);
+            const rows = [];
+            res.rows = rows;
+            for (let i = 0; i < res.numAffectedRows; i++) {
+                const o = {};
+                for (const key of keys) {
+                    o[key.replace(/^out_/, '')] = res.outBinds[key][i];
+                }
+                rows.push(o);
+            }
+        }
+        else if (res.outBinds) {
+            const keys = Object.keys(res.outBinds);
+            const rows = [];
+            for (const key of keys) {
+                const [k, i] = key.split('__');
+                rows[+i] ??= {};
+                rows[+i][k.replace(/^out_/, '')] = res.outBinds[key];
+            }
+            res.rows = rows;
+        }
+        const rowCount = res.rows.length;
+        /* v8 ignore start: internal result-shape branches depend on Oracle driver internals */
+        const hasEmptyCount = rowCount === 1 && '' in res.rows[0];
+        const emptyRow = hasEmptyCount && Number(res.rows[0]['']);
+        const affectedRows = hasEmptyCount
+            ? emptyRow
+            : res.numAffectedRows == null
+                ? rowCount
+                : Number(res.numAffectedRows ?? rowCount);
+        /* v8 ignore stop */
+        return {
+            affectedRows,
+            row: res.rows[0],
+            rows: res.rows,
+        };
+    }
+}

package/OracleDriver.d.ts

@@ -0,0 +1,14 @@
+import { type AnyEntity, type Configuration, type ConnectionType, type Constructor, type EntityDictionary, type EntityName, type FilterQuery, type LoggingOptions, type NativeInsertUpdateManyOptions, type QueryResult, type Transaction, type UpsertManyOptions } from '@mikro-orm/core';
+import { AbstractSqlDriver, type SqlEntityManager } from '@mikro-orm/sql';
+import { OracleConnection } from './OracleConnection.js';
+import { OracleMikroORM } from './OracleMikroORM.js';
+import { OracleQueryBuilder } from './OracleQueryBuilder.js';
+import { OraclePlatform } from './OraclePlatform.js';
+export declare class OracleDriver extends AbstractSqlDriver<OracleConnection, OraclePlatform> {
+    constructor(config: Configuration);
+    createQueryBuilder<T extends AnyEntity<T>>(entityName: EntityName<T>, ctx?: Transaction, preferredConnectionType?: ConnectionType, convertCustomTypes?: boolean, loggerContext?: LoggingOptions, alias?: string, em?: SqlEntityManager): OracleQueryBuilder<T, any, any, any>;
+    nativeInsertMany<T extends object>(entityName: EntityName<T>, data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T>): Promise<QueryResult<T>>;
+    nativeUpdateMany<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>[], data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T> & UpsertManyOptions<T>): Promise<QueryResult<T>>;
+    /** @inheritDoc */
+    getORMClass(): Constructor<OracleMikroORM>;
+}

package/OracleDriver.js

@@ -0,0 +1,80 @@
+import { isRaw, QueryFlag, Utils, } from '@mikro-orm/core';
+import { AbstractSqlDriver } from '@mikro-orm/sql';
+import { OracleConnection } from './OracleConnection.js';
+import { OracleMikroORM } from './OracleMikroORM.js';
+import { OracleQueryBuilder } from './OracleQueryBuilder.js';
+import { OraclePlatform } from './OraclePlatform.js';
+export class OracleDriver extends AbstractSqlDriver {
+    constructor(config) {
+        super(config, new OraclePlatform(), OracleConnection, ['kysely', 'oracledb']);
+    }
+    createQueryBuilder(entityName, ctx, preferredConnectionType, convertCustomTypes, loggerContext, alias, em) {
+        // do not compute the connectionType if EM is provided as it will be computed from it in the QB later on
+        const connectionType = em
+            ? preferredConnectionType
+            : this.resolveConnectionType({ ctx, connectionType: preferredConnectionType });
+        const qb = new OracleQueryBuilder(entityName, this.metadata, this, ctx, alias, connectionType, em, loggerContext);
+        if (!convertCustomTypes) {
+            qb.unsetFlag(QueryFlag.CONVERT_CUSTOM_TYPES);
+        }
+        return qb;
+    }
+    async nativeInsertMany(entityName, data, options = {}) {
+        options.processCollections ??= true;
+        options.convertCustomTypes ??= true;
+        const meta = this.metadata.get(entityName);
+        const pks = this.getPrimaryKeyFields(meta);
+        const collections = options.processCollections ? data.map(d => this.extractManyToMany(meta, d)) : [];
+        const qb = this.createQueryBuilder(entityName, options.ctx, 'write', options.convertCustomTypes).withSchema(this.getSchemaName(meta, options));
+        qb.insert(data);
+        const res = await this.rethrow(qb.execute('run'));
+        let pk;
+        if (pks.length > 1) {
+            // owner has composite pk
+            pk = data.map(d => Utils.getPrimaryKeyCond(d, pks));
+        }
+        else {
+            res.row ??= {};
+            res.rows ??= [];
+            pk = data.map((d, i) => d[pks[0]] ?? res.rows[i]?.[pks[0]]).map(d => [d]);
+            res.insertId = res.insertId || res.row[pks[0]];
+        }
+        for (let i = 0; i < collections.length; i++) {
+            await this.processManyToMany(meta, pk[i], collections[i], false, options);
+        }
+        return res;
+    }
+    async nativeUpdateMany(entityName, where, data, options = {}) {
+        const meta = this.metadata.get(entityName);
+        const returning = new Set();
+        const into = [];
+        const outBindingsMap = {};
+        for (const row of data) {
+            for (const k of Utils.keys(row)) {
+                if (isRaw(row[k])) {
+                    returning.add(k);
+                }
+            }
+        }
+        // reload generated columns and version fields
+        meta.props.filter(prop => prop.generated || prop.version || prop.primary).forEach(prop => returning.add(prop.name));
+        for (const propName of returning) {
+            const prop = meta.properties[propName];
+            into.push(`:out_${prop.fieldNames[0]}`);
+            outBindingsMap[`out_${prop.fieldNames[0]}`] = prop.runtimeType;
+        }
+        const outBindings = this.platform.createOutBindings(outBindingsMap);
+        return super.nativeUpdateMany(entityName, where, data, options, (sql, params) => {
+            /* v8 ignore next 2: defensive guard — PKs are always added to `returning` above */
+            if (into.length === 0) {
+                return sql;
+            }
+            params.push(outBindings);
+            return `${sql} into ${into.join(', ')}`;
+        });
+    }
+    /** @inheritDoc */
+    getORMClass() {
+        return OracleMikroORM;
+    }
+}

package/OracleExceptionConverter.d.ts

@@ -0,0 +1,7 @@
+import { ExceptionConverter, type Dictionary, type DriverException } from '@mikro-orm/core';
+export declare class OracleExceptionConverter extends ExceptionConverter {
+    /**
+     * @link https://docs.oracle.com/cd/B28359_01/server.111/b28278/toc.htm
+     */
+    convertException(exception: Error & Dictionary): DriverException;
+}

package/OracleExceptionConverter.js

@@ -0,0 +1,145 @@
+import { CheckConstraintViolationException, ExceptionConverter, InvalidFieldNameException, NonUniqueFieldNameException, NotNullConstraintViolationException, SyntaxErrorException, TableExistsException, TableNotFoundException, UniqueConstraintViolationException, DatabaseObjectNotFoundException, ForeignKeyConstraintViolationException, ReadOnlyException, ConnectionException, DeadlockException, LockWaitTimeoutException, } from '@mikro-orm/core';
+/* v8 ignore start */
+export class OracleExceptionConverter extends ExceptionConverter {
+    /**
+     * @link https://docs.oracle.com/cd/B28359_01/server.111/b28278/toc.htm
+     */
+    convertException(exception) {
+        switch (exception.errorNum) {
+            case 1: // ORA-00001: unique constraint (string.string) violated
+                return new UniqueConstraintViolationException(exception);
+            case 54: // ORA-00054: resource busy and acquire with NOWAIT specified or timeout expired
+                return new LockWaitTimeoutException(exception);
+            case 18: // ORA-00018: maximum number of sessions exceeded
+            case 19: // ORA-00019: maximum number of session licenses exceeded
+            case 20: // ORA-00020: maximum number of processes (string) exceeded
+            case 22: // ORA-00022: invalid session ID; access denied
+            case 107: // ORA-00107: failed to connect to ORACLE listener process
+            case 1017: // ORA-01017: invalid username/password; logon denied
+            case 2010: // ORA-02010: missing host connect string
+            case 3113: // ORA-03113: end-of-file on communication channel
+            case 3135: // ORA-03135: connection lost contact
+            case 12154: // ORA-12154: TNS:could not resolve service name
+            case 12198: // ORA-12198: TNS:could not find path to destination
+            case 12203: // ORA-12203: TNS:unable to connect to destination
+            case 12500: // ORA-12500: TNS:listener failed to start a dedicated server process
+            case 12504: // ORA-12504: TNS:listener was not given the SERVICE_NAME in CONNECT_DATA
+            case 12505: // ORA-12505: TNS:listener does not currently know of SID given in connect descriptor
+            case 12511: // ORA-12511: TNS:service handler found but it is not accepting connections
+            case 12513: // ORA-12513: TNS:service handler found but it has registered for a different protocol
+            case 12514: // ORA-12514: TNS:listener does not currently know of service requested in connect descriptor
+            case 12533: // ORA-12533: TNS:illegal ADDRESS parameters
+            case 12545: // ORA-12545: TNS:name lookup failure
+            case 12560: // ORA-12560: TNS:protocol adapter error
+            case 12537: // ORA-12537: TNS:connection closed
+                return new ConnectionException(exception);
+            case 28: // ORA-00028: your session has been killed
+                return new ConnectionException(exception);
+            case 60: // ORA-00060: deadlock detected while waiting for resource
+                return new DeadlockException(exception);
+            case 904: // ORA-00904: invalid column name
+                return new InvalidFieldNameException(exception);
+            case 918: // ORA-00918: column ambiguously defined
+            case 957: // ORA-00957: duplicate column name
+            case 960: // ORA-00960: ambiguous column naming in select list
+                return new NonUniqueFieldNameException(exception);
+            case 900: // ORA-00900: invalid SQL statement
+            case 901: // ORA-00901: invalid CREATE command
+            case 902: // ORA-00902: invalid datatype
+            case 905: // ORA-00905: missing keyword
+            case 906: // ORA-00906: missing left parenthesis
+            case 907: // ORA-00907: missing right parenthesis
+            case 908: // ORA-00908: missing NULL keyword
+            case 909: // ORA-00909: invalid number of arguments
+            case 910: // ORA-00910: specified length too long for its datatype
+            case 911: // ORA-00911: invalid character
+            case 912: // ORA-00912: input parameter too long
+            case 913: // ORA-00913: too many values
+            case 914: // ORA-00914: missing ADD keyword
+            case 917: // ORA-00917: missing comma
+            case 919: // ORA-00919: invalid function
+            case 920: // ORA-00920: invalid relational operator
+            case 921: // ORA-00921: unexpected end of SQL command
+            case 922: // ORA-00922: missing or invalid option
+            case 923: // ORA-00923: FROM keyword not found where expected
+            case 924: // ORA-00924: missing BY keyword
+            case 925: // ORA-00925: missing INTO keyword
+            case 926: // ORA-00926: missing VALUES keyword
+            case 927: // ORA-00927: missing equal sign
+            case 928: // ORA-00928: missing SELECT keyword
+            case 929: // ORA-00929: missing period
+            case 930: // ORA-00930: missing asterisk
+            case 931: // ORA-00931: missing identifier
+            case 932: // ORA-00932: inconsistent datatypes
+            case 933: // ORA-00933: SQL command not properly ended
+            case 934: // ORA-00934: group function is not allowed here
+            case 935: // ORA-00935: group function is nested too deeply
+            case 936: // ORA-00936: missing expression
+            case 937: // ORA-00937: not a single-group group function
+            case 938: // ORA-00938: not enough arguments for function
+            case 939: // ORA-00939: too many arguments for function
+            case 940: // ORA-00940: invalid ALTER command
+            case 941: // ORA-00941: missing cluster name
+            case 946: // ORA-00946: missing TO keyword
+            case 947: // ORA-00947: not enough values
+            case 950: // ORA-00950: invalid DROP option
+            case 952: // ORA-00952: missing GROUP keyword
+            case 954: // ORA-00954: missing IDENTIFIED keyword
+            case 956: // ORA-00956: missing or invalid auditing option
+            case 962: // ORA-00962: too many group-by or order-by expressions
+            case 964: // ORA-00964: table name not in FROM list
+            case 965: // ORA-00965: column aliases not allowed for "*"
+            case 966: // ORA-00966: missing TABLE keyword
+            case 967: // ORA-00967: missing WHERE keyword
+            case 968: // ORA-00968: missing INDEX keyword
+            case 969: // ORA-00969: missing ON keyword
+            case 970: // ORA-00970: missing WITH keyword
+            case 971: // ORA-00971: missing SET keyword
+            case 972: // ORA-00972: identifier is too long
+            case 974: // ORA-00974: invalid PCTFREE value percentage
+            case 975: // ORA-00975: date + date not allowed
+            case 976: // ORA-00976: LEVEL, PRIOR, or ROWNUM not allowed here
+            case 977: // ORA-00977: duplicate auditing option
+            case 978: // ORA-00978: nested group function without GROUP BY
+            case 979: // ORA-00979: not a GROUP BY expression
+            case 980: // ORA-00980: synonym translation is no longer valid
+            case 981: // ORA-00981: cannot mix table and system auditing options
+            case 982: // ORA-00982: missing plus sign
+            case 984: // ORA-00984: column not allowed here
+            case 985: // ORA-00985: invalid program name
+            case 986: // ORA-00986: missing or invalid group names(s)
+            case 987: // ORA-00987: missing or invalid username(s)
+            case 988: // ORA-00988: missing or invalid password(s)
+            case 989: // ORA-00989: too many passwords for usernames given
+            case 990: // ORA-00990: missing or invalid privilege
+            case 992: // ORA-00992: invalid format for REVOKE command
+            case 993: // ORA-00993: missing GRANT keyword
+            case 994: // ORA-00994: missing OPTION keyword
+            case 995: // ORA-00995: missing or invalid synonym identifier
+            case 996: // ORA-00996: the concatenate operator is ||, not |
+            case 997: // ORA-00997: illegal use of LONG datatype
+            case 998: // ORA-00998: must name this expression with a column alias
+                return new SyntaxErrorException(exception);
+            case 953: // ORA-00953: invalid index name
+            case 999: // ORA-00999: invalid view name
+            case 4063: // ORA-04063: <object> has errors
+                return new DatabaseObjectNotFoundException(exception);
+            case 2291: // ORA-02291: integrity constraint violated - parent key not found
+            case 2292: // ORA-02292: integrity constraint violated - child record found
+                return new ForeignKeyConstraintViolationException(exception);
+            case 903: // ORA-00903: invalid table name
+            case 942: // ORA-00942: table or view does not exist
+                return new TableNotFoundException(exception);
+            case 955: // ORA-00955: name is already used by an existing object
+                return new TableExistsException(exception);
+            case 1400: // ORA-01400: cannot insert null into
+                return new NotNullConstraintViolationException(exception);
+            case 2290: // ORA-02290: check constraint violated
+                return new CheckConstraintViolationException(exception);
+            case 16000: // ORA-16000 Database open for read only access
+                return new ReadOnlyException(exception);
+        }
+        return super.convertException(exception);
+    }
+}
+/* v8 ignore stop */

package/OracleMikroORM.d.ts

@@ -0,0 +1,18 @@
+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 { OracleDriver } from './OracleDriver.js';
+export type OracleOptions<EM extends SqlEntityManager<OracleDriver> = SqlEntityManager<OracleDriver>, Entities extends (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]> = Options<OracleDriver, EM, Entities>;
+export declare function defineOracleConfig<EM extends SqlEntityManager<OracleDriver> = SqlEntityManager<OracleDriver>, Entities extends (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]>(options: Options<OracleDriver, EM, Entities>): Options<OracleDriver, EM, Entities>;
+/**
+ * @inheritDoc
+ */
+export declare class OracleMikroORM<EM extends SqlEntityManager<OracleDriver> = SqlEntityManager<OracleDriver>, Entities extends (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]> extends MikroORM<OracleDriver, EM, Entities> {
+    /**
+     * @inheritDoc
+     */
+    static init<D extends IDatabaseDriver = OracleDriver, EM extends EntityManager<D> = D[typeof EntityManagerType] & EntityManager<D>, Entities extends (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]>(options: Options<D, EM, Entities>): Promise<MikroORM<D, EM, Entities>>;
+    /**
+     * @inheritDoc
+     */
+    constructor(options: Options<OracleDriver, EM, Entities>);
+}

package/OracleMikroORM.js

@@ -0,0 +1,22 @@
+import { defineConfig, MikroORM, } from '@mikro-orm/core';
+import { OracleDriver } from './OracleDriver.js';
+export function defineOracleConfig(options) {
+    return defineConfig({ driver: OracleDriver, ...options });
+}
+/**
+ * @inheritDoc
+ */
+export class OracleMikroORM extends MikroORM {
+    /**
+     * @inheritDoc
+     */
+    static async init(options) {
+        return super.init(defineOracleConfig(options));
+    }
+    /**
+     * @inheritDoc
+     */
+    constructor(options) {
+        super(defineOracleConfig(options));
+    }
+}

package/OraclePlatform.d.ts

@@ -0,0 +1,120 @@
+import { AbstractSqlPlatform, type Dictionary, type EntityKey, type EntityManager, type EntityValue, type FilterQuery, type IDatabaseDriver, type IsolationLevel, type MikroORM, OracleNativeQueryBuilder, Type } from '@mikro-orm/sql';
+import { OracleSchemaHelper } from './OracleSchemaHelper.js';
+import { OracleExceptionConverter } from './OracleExceptionConverter.js';
+import { OracleSchemaGenerator } from './OracleSchemaGenerator.js';
+export declare class OraclePlatform extends AbstractSqlPlatform {
+    protected readonly schemaHelper: OracleSchemaHelper;
+    protected readonly exceptionConverter: OracleExceptionConverter;
+    /** @inheritDoc */
+    lookupExtensions(orm: MikroORM): void;
+    getRollbackToSavepointSQL(savepointName: string): string;
+    getSavepointSQL(savepointName: string): string;
+    getBeginTransactionSQL(options?: {
+        isolationLevel?: IsolationLevel;
+        readOnly?: boolean;
+    }): string[];
+    usesAsKeyword(): boolean;
+    compareUuids(): string;
+    convertUuidToJSValue(value: Buffer): string;
+    convertUuidToDatabaseValue(value: string): Buffer;
+    /** @internal */
+    createNativeQueryBuilder(): OracleNativeQueryBuilder;
+    usesOutputStatement(): boolean;
+    usesReturningStatement(): boolean;
+    convertsJsonAutomatically(): boolean;
+    indexForeignKeys(): boolean;
+    supportsSchemas(): boolean;
+    getCurrentTimestampSQL(length: number): string;
+    getDateTimeTypeDeclarationSQL(column: {
+        length?: number;
+    }): string;
+    getDefaultDateTimeLength(): number;
+    getFloatDeclarationSQL(): string;
+    getDoubleDeclarationSQL(): string;
+    getDecimalTypeDeclarationSQL(column: {
+        precision?: number;
+        scale?: number;
+    }): string;
+    getBooleanTypeDeclarationSQL(): string;
+    getRegExpOperator(): string;
+    mapRegExpCondition(mappedKey: string, value: {
+        $re: string;
+        $flags?: string;
+    }): {
+        sql: string;
+        params: unknown[];
+    };
+    getBlobDeclarationSQL(): string;
+    getJsonDeclarationSQL(): string;
+    getDefaultSchemaName(): string | undefined;
+    getVarcharTypeDeclarationSQL(column: {
+        length?: number;
+    }): string;
+    getDateTypeDeclarationSQL(length?: number): string;
+    getTimeTypeDeclarationSQL(length?: number): string;
+    getIntegerTypeDeclarationSQL(column: {
+        length?: number;
+        unsigned?: boolean;
+        autoincrement?: boolean;
+    }): string;
+    /**
+     * @inheritDoc
+     */
+    getBigIntTypeDeclarationSQL(column: {
+        length?: number;
+        unsigned?: boolean;
+        autoincrement?: boolean;
+    }): string;
+    getMediumIntTypeDeclarationSQL(column: {
+        length?: number;
+        unsigned?: boolean;
+        autoincrement?: boolean;
+    }): string;
+    getTinyIntTypeDeclarationSQL(column: {
+        length?: number;
+        unsigned?: boolean;
+        autoincrement?: boolean;
+    }): string;
+    getSmallIntTypeDeclarationSQL(column: {
+        length?: number;
+        unsigned?: boolean;
+        autoincrement?: boolean;
+    }): string;
+    getArrayDeclarationSQL(): string;
+    getEnumTypeDeclarationSQL(column: {
+        items?: unknown[];
+        fieldNames: string[];
+        length?: number;
+        unsigned?: boolean;
+        autoincrement?: boolean;
+    }): string;
+    getTextTypeDeclarationSQL(_column: {
+        length?: number;
+    }): string;
+    normalizeColumnType(type: string, options: {
+        length?: number;
+        precision?: number;
+        scale?: number;
+    }): string;
+    getDefaultMappedType(type: string): Type<unknown>;
+    getUuidTypeDeclarationSQL(column: {
+        length?: number;
+    }): string;
+    usesCascadeStatement(): boolean;
+    getSearchJsonPropertyKey(path: string[], type: string, aliased: boolean, value?: unknown): string;
+    processJsonCondition<T extends object>(o: FilterQuery<T>, value: EntityValue<T>, path: EntityKey<T>[], alias: boolean): FilterQuery<T>;
+    usesEnumCheckConstraints(): boolean;
+    supportsMultipleCascadePaths(): boolean;
+    /** @inheritDoc */
+    supportsOnUpdate(): boolean;
+    supportsMultipleStatements(): boolean;
+    quoteIdentifier(id: string): string;
+    escape(value: any): string;
+    getSchemaGenerator(driver: IDatabaseDriver, em?: EntityManager): OracleSchemaGenerator;
+    allowsComparingTuples(): boolean;
+    getDefaultClientUrl(): string;
+    /** @internal */
+    mapToBindType(type: string): unknown;
+    mapToOracleType(type: string): unknown;
+    createOutBindings(map: Dictionary<string>): Dictionary;
+}