@mikro-orm/sql 7.0.0-dev.312 → 7.0.0-dev.314

package/AbstractSqlConnection.d.ts

@@ -1,15 +1,15 @@
 import { type ControlledTransaction, type Dialect, Kysely } from 'kysely';
-import { type AnyEntity, Connection, type Dictionary, type EntityData, type IsolationLevel, type LogContext, type LoggingOptions, type QueryResult, RawQueryFragment, type Transaction, type TransactionEventBroadcaster } from '@mikro-orm/core';
+import { type AnyEntity, Connection, type Dictionary, type EntityData, type IsolationLevel, type LogContext, type LoggingOptions, type MaybePromise, type QueryResult, RawQueryFragment, type Transaction, type TransactionEventBroadcaster } from '@mikro-orm/core';
 import type { AbstractSqlPlatform } from './AbstractSqlPlatform.js';
 import { NativeQueryBuilder } from './query/NativeQueryBuilder.js';
 export declare abstract class AbstractSqlConnection extends Connection {
     #private;
     protected platform: AbstractSqlPlatform;
-    abstract createKyselyDialect(overrides: Dictionary): Dialect;
+    abstract createKyselyDialect(overrides: Dictionary): MaybePromise<Dialect>;
     connect(options?: {
         skipOnConnect?: boolean;
     }): Promise<void>;
-    createKysely(): void;
+    createKysely(): MaybePromise<void>;
     /**
      * @inheritDoc
      */
@@ -29,6 +29,7 @@ export declare abstract class AbstractSqlConnection extends Connection {
         error?: Error;
     }>;
     getClient<T = any>(): Kysely<T>;
+    initClient(): Promise<void>;
     transactional<T>(cb: (trx: Transaction<ControlledTransaction<any, any>>) => Promise<T>, options?: {
         isolationLevel?: IsolationLevel;
         readOnly?: boolean;
@@ -50,6 +51,6 @@ export declare abstract class AbstractSqlConnection extends Connection {
     stream<T extends EntityData<AnyEntity>>(query: string | NativeQueryBuilder | RawQueryFragment, params?: readonly unknown[], ctx?: Transaction<Kysely<any>>, loggerContext?: LoggingOptions): AsyncIterableIterator<T>;
     /** @inheritDoc */
     executeDump(dump: string): Promise<void>;
-    private getSql;
+    protected getSql(query: string, formatted: string, context?: LogContext): string;
     protected transformRawResult<T>(res: any, method?: 'all' | 'get' | 'run'): T;
 }

package/AbstractSqlConnection.js

@@ -4,7 +4,7 @@ import { NativeQueryBuilder } from './query/NativeQueryBuilder.js';
 export class AbstractSqlConnection extends Connection {
     #client;
     async connect(options) {
-        this.getClient();
+        await this.initClient();
         this.connected = true;
         if (options?.skipOnConnect !== true) {
             await this.onConnect();
@@ -24,9 +24,13 @@ export class AbstractSqlConnection extends Connection {
             this.#client = new Kysely({ dialect: driverOptions });
         }
         else {
-            this.#client = new Kysely({
-                dialect: this.createKyselyDialect(driverOptions),
-            });
+            const dialect = this.createKyselyDialect(driverOptions);
+            if (dialect instanceof Promise) {
+                return dialect.then(d => {
+                    this.#client = new Kysely({ dialect: d });
+                });
+            }
+            this.#client = new Kysely({ dialect });
         }
     }
     /**
@@ -62,10 +66,19 @@ export class AbstractSqlConnection extends Connection {
     }
     getClient() {
         if (!this.#client) {
-            this.createKysely();
+            const maybePromise = this.createKysely();
+            /* v8 ignore next */
+            if (maybePromise instanceof Promise) {
+                throw new Error('Current driver requires async initialization, use `MikroORM.init()` instead of the constructor');
+            }
         }
         return this.#client;
     }
+    async initClient() {
+        if (!this.#client) {
+            await this.createKysely();
+        }
+    }
     async transactional(cb, options = {}) {
         const trx = await this.begin(options);
         try {

package/AbstractSqlDriver.d.ts

@@ -53,7 +53,7 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
     nativeInsert<T extends object>(entityName: EntityName<T>, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T>): Promise<QueryResult<T>>;
     nativeInsertMany<T extends object>(entityName: EntityName<T>, data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T>, transform?: (sql: string) => string): Promise<QueryResult<T>>;
     nativeUpdate<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T> & UpsertOptions<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>>;
+    nativeUpdateMany<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>[], data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T> & UpsertManyOptions<T>, transform?: (sql: string, params: any[]) => string): Promise<QueryResult<T>>;
     nativeDelete<T extends object>(entityName: EntityName<T>, where: FilterQuery<T> | string | any, options?: DeleteOptions<T>): Promise<QueryResult<T>>;
     /**
      * Fast comparison for collection snapshots that are represented by PK arrays.

package/AbstractSqlDriver.js

@@ -200,7 +200,8 @@ export class AbstractSqlDriver extends DatabaseDriver {
         if (type === QueryType.COUNT) {
             native.clear('select').clear('limit').clear('offset').count();
         }
-        native.from(raw(`(${expression}) as ${this.platform.quoteIdentifier(qb.alias)}`));
+        const asKeyword = this.platform.usesAsKeyword() ? ' as ' : ' ';
+        native.from(raw(`(${expression})${asKeyword}${this.platform.quoteIdentifier(qb.alias)}`));
         const query = native.compile();
         const res = await this.execute(query.sql, query.params, 'all', options.ctx);
         if (type === QueryType.COUNT) {
@@ -215,7 +216,8 @@ export class AbstractSqlDriver extends DatabaseDriver {
         const qb = await this.createQueryBuilderFromOptions(meta, where, this.forceBalancedStrategy(options));
         qb.unsetFlag(QueryFlag.DISABLE_PAGINATE);
         const native = qb.getNativeQuery(false);
-        native.from(raw(`(${expression}) as ${this.platform.quoteIdentifier(qb.alias)}`));
+        const asKeyword = this.platform.usesAsKeyword() ? ' as ' : ' ';
+        native.from(raw(`(${expression})${asKeyword}${this.platform.quoteIdentifier(qb.alias)}`));
         const query = native.compile();
         const connectionType = this.resolveConnectionType({ ctx: options.ctx, connectionType: options.connectionType });
         const res = this.getConnection(connectionType).stream(query.sql, query.params, options.ctx, options.loggerContext);
@@ -556,7 +558,12 @@ export class AbstractSqlDriver extends DatabaseDriver {
         else {
             /* v8 ignore next */
             res.insertId = data[meta.primaryKeys[0]] ?? res.insertId ?? res.row[meta.primaryKeys[0]];
-            pk = [res.insertId];
+            if (options.convertCustomTypes && meta?.getPrimaryProp().customType) {
+                pk = [meta.getPrimaryProp().customType.convertToDatabaseValue(res.insertId, this.platform)];
+            }
+            else {
+                pk = [res.insertId];
+            }
         }
         await this.processManyToMany(meta, pk, collections, false, options);
         return res;
@@ -780,7 +787,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
         await this.processManyToMany(meta, pk, collections, true, options);
         return res;
     }
-    async nativeUpdateMany(entityName, where, data, options = {}) {
+    async nativeUpdateMany(entityName, where, data, options = {}, transform) {
         options.processCollections ??= true;
         options.convertCustomTypes ??= true;
         const meta = this.metadata.get(entityName);
@@ -923,6 +930,9 @@ export class AbstractSqlDriver extends DatabaseDriver {
                     ? ` returning ${returningFields.map(field => this.platform.quoteIdentifier(field)).join(', ')}`
                     : '';
         }
+        if (transform) {
+            sql = transform(sql, params);
+        }
         const res = await this.rethrow(this.execute(sql, params, 'run', options.ctx, options.loggerContext));
         for (let i = 0; i < collections.length; i++) {
             await this.processManyToMany(meta, where[i], collections[i], false, options);
@@ -1050,8 +1060,17 @@ export class AbstractSqlDriver extends DatabaseDriver {
         const pivotProp1 = pivotMeta.relations[prop.owner ? 1 : 0];
         const pivotProp2 = pivotMeta.relations[prop.owner ? 0 : 1];
         const ownerMeta = pivotProp2.targetMeta;
+        // The pivot query builder doesn't convert custom types, so we need to manually
+        // convert owner PKs to DB format for the query and convert result FKs back to
+        // JS format for consistent key hashing in buildPivotResultMap.
+        const pkProp = ownerMeta.properties[ownerMeta.primaryKeys[0]];
+        const needsConversion = pkProp?.customType?.ensureComparable(ownerMeta, pkProp) && !ownerMeta.compositePK;
+        let ownerPks = ownerMeta.compositePK ? owners : owners.map(o => o[0]);
+        if (needsConversion) {
+            ownerPks = ownerPks.map(v => pkProp.customType.convertToDatabaseValue(v, this.platform, { mode: 'query' }));
+        }
         const cond = {
-            [pivotProp2.name]: { $in: ownerMeta.compositePK ? owners : owners.map(o => o[0]) },
+            [pivotProp2.name]: { $in: ownerPks },
         };
         if (!Utils.isEmpty(where)) {
             cond[pivotProp1.name] = { ...where };
@@ -1084,6 +1103,16 @@ export class AbstractSqlDriver extends DatabaseDriver {
             _populateWhere: 'infer',
             populateFilter: this.wrapPopulateFilter(options, pivotProp2.name),
         });
+        // Convert result FK values back to JS format so key hashing
+        // in buildPivotResultMap is consistent with the owner keys.
+        if (needsConversion) {
+            for (const item of res) {
+                const fk = item[pivotProp2.name];
+                if (fk != null) {
+                    item[pivotProp2.name] = pkProp.customType.convertToJSValue(fk, this.platform);
+                }
+            }
+        }
         return this.buildPivotResultMap(owners, res, pivotProp2.name, pivotProp1.name);
     }
     /**

package/AbstractSqlPlatform.d.ts

@@ -42,4 +42,10 @@ export declare abstract class AbstractSqlPlatform extends Platform {
     quoteCollation(collation: string): string;
     /** @internal */
     protected validateCollationName(collation: string): void;
+    /**
+     * Maps a runtime type name (e.g. 'string', 'number') to a driver-specific bind type constant.
+     * Used by NativeQueryBuilder for output bindings.
+     * @internal
+     */
+    mapToBindType(type: string): unknown;
 }

package/AbstractSqlPlatform.js

@@ -116,4 +116,12 @@ export class AbstractSqlPlatform extends Platform {
             throw new Error(`Invalid collation name: '${collation}'. Collation names must contain only word characters.`);
         }
     }
+    /**
+     * Maps a runtime type name (e.g. 'string', 'number') to a driver-specific bind type constant.
+     * Used by NativeQueryBuilder for output bindings.
+     * @internal
+     */
+    mapToBindType(type) {
+        return type;
+    }
 }

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 and SQLite (including libSQL) 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, SQLite (including libSQL), MSSQL and Oracle databases. 
 
 > Heavily inspired by [Doctrine](https://www.doctrine-project.org/) and [Hibernate](https://hibernate.org/).
 
@@ -181,6 +181,7 @@ yarn add @mikro-orm/core @mikro-orm/mysql         # for mysql/mariadb
 yarn add @mikro-orm/core @mikro-orm/mariadb       # for mysql/mariadb
 yarn add @mikro-orm/core @mikro-orm/postgresql    # for postgresql
 yarn add @mikro-orm/core @mikro-orm/mssql         # for mssql
+yarn add @mikro-orm/core @mikro-orm/oracledb      # for oracle
 yarn add @mikro-orm/core @mikro-orm/sqlite        # for sqlite
 yarn add @mikro-orm/core @mikro-orm/libsql        # for libsql
 ```

package/dialects/index.d.ts

@@ -2,3 +2,4 @@ export * from './mssql/index.js';
 export * from './mysql/index.js';
 export * from './postgresql/index.js';
 export * from './sqlite/index.js';
+export * from './oracledb/index.js';

package/dialects/index.js

@@ -2,3 +2,4 @@ export * from './mssql/index.js';
 export * from './mysql/index.js';
 export * from './postgresql/index.js';
 export * from './sqlite/index.js';
+export * from './oracledb/index.js';

package/dialects/oracledb/OracleDialect.d.ts

@@ -0,0 +1,78 @@
+import { type AliasNode, CompiledQuery, type DatabaseConnection, type DatabaseIntrospector, DefaultQueryCompiler, type Dialect, DialectAdapterBase, type Driver, type Kysely, type QueryCompiler, type QueryResult, type TransactionSettings } from 'kysely';
+/**
+ * Subset of oracledb's Pool interface used by the dialect.
+ * We define our own interface to avoid importing the `oracledb` package directly.
+ */
+export interface OraclePool {
+    getConnection(): Promise<OraclePoolConnection>;
+    close(drainTime?: number): Promise<void>;
+}
+/**
+ * Subset of oracledb's Connection interface used by the dialect.
+ */
+export interface OraclePoolConnection {
+    execute<R>(sql: string, params: unknown[], options?: Record<string, unknown>): Promise<{
+        rows?: R[];
+        rowsAffected?: number;
+        resultSet?: OracleResultSet<R>;
+        outBinds?: unknown;
+    }>;
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+    close(): Promise<void>;
+}
+interface OracleResultSet<R> {
+    getRow(): Promise<R>;
+    close(): Promise<void>;
+}
+declare class OracleQueryCompiler extends DefaultQueryCompiler {
+    protected getLeftIdentifierWrapper(): string;
+    protected getRightIdentifierWrapper(): string;
+    protected visitAlias(node: AliasNode): void;
+}
+declare class OracleAdapter extends DialectAdapterBase {
+    #private;
+    get supportsReturning(): boolean;
+    get supportsTransactionalDdl(): boolean;
+    acquireMigrationLock(_: Kysely<any>): Promise<void>;
+    releaseMigrationLock(_: Kysely<any>): Promise<void>;
+}
+declare class OracleConnection implements DatabaseConnection {
+    #private;
+    readonly id: number;
+    constructor(connection: OraclePoolConnection, executeOptions?: Record<string, unknown>);
+    executeQuery<R>(compiledQuery: CompiledQuery): Promise<QueryResult<R>>;
+    formatQuery(query: CompiledQuery): {
+        sql: string;
+        bindParams: unknown[];
+    };
+    streamQuery<R>(compiledQuery: CompiledQuery, _chunkSize?: number): AsyncIterableIterator<QueryResult<R>>;
+    get connection(): OraclePoolConnection;
+}
+declare class OracleDriver implements Driver {
+    #private;
+    constructor(config: OracleDialectConfig);
+    init(): Promise<void>;
+    acquireConnection(): Promise<OracleConnection>;
+    savepoint(connection: OracleConnection, savepointName: string, compileQuery: QueryCompiler['compileQuery']): Promise<void>;
+    rollbackToSavepoint(connection: OracleConnection, savepointName: string, compileQuery: QueryCompiler['compileQuery']): Promise<void>;
+    releaseSavepoint(connection: OracleConnection, savepointName: string, compileQuery: QueryCompiler['compileQuery']): Promise<void>;
+    beginTransaction(connection: OracleConnection, settings: TransactionSettings): Promise<void>;
+    commitTransaction(connection: OracleConnection): Promise<void>;
+    rollbackTransaction(connection: OracleConnection): Promise<void>;
+    releaseConnection(connection: OracleConnection): Promise<void>;
+    destroy(): Promise<void>;
+}
+export interface OracleDialectConfig {
+    pool: OraclePool;
+    executeOptions?: Record<string, unknown>;
+}
+export declare class OracleDialect implements Dialect {
+    #private;
+    constructor(config: OracleDialectConfig);
+    createDriver(): OracleDriver;
+    createAdapter(): OracleAdapter;
+    createIntrospector(db: Kysely<any>): DatabaseIntrospector;
+    createQueryCompiler(): OracleQueryCompiler;
+}
+export {};

package/dialects/oracledb/OracleDialect.js

@@ -0,0 +1,166 @@
+// inlined https://github.com/griffiths-waite/kysely-oracledb with minor adjustments
+/* v8 ignore start: internal Kysely driver integration, tested through the main Oracle driver */
+import { CompiledQuery, createQueryId, DefaultQueryCompiler, DialectAdapterBase, IdentifierNode, RawNode, } from 'kysely';
+function parseSavepointCommand(command, savepointName) {
+    return RawNode.createWithChildren([
+        RawNode.createWithSql(`${command} `),
+        IdentifierNode.create(savepointName), // ensures savepointName gets sanitized
+    ]);
+}
+class OracleQueryCompiler extends DefaultQueryCompiler {
+    getLeftIdentifierWrapper() {
+        return '';
+    }
+    getRightIdentifierWrapper() {
+        return '';
+    }
+    visitAlias(node) {
+        this.visitNode(node.node);
+        this.append(' ');
+        this.visitNode(node.alias);
+    }
+}
+class OracleAdapter extends DialectAdapterBase {
+    #supportsReturning = false;
+    #supportsTransactionalDdl = false;
+    get supportsReturning() {
+        return this.#supportsReturning;
+    }
+    get supportsTransactionalDdl() {
+        return this.#supportsTransactionalDdl;
+    }
+    async acquireMigrationLock(_) {
+        throw new Error('Not implemented');
+    }
+    async releaseMigrationLock(_) {
+        throw new Error('Not implemented');
+    }
+}
+const OUT_FORMAT_OBJECT = 4002;
+let i = 0;
+class OracleConnection {
+    id = i++;
+    #executeOptions;
+    #connection;
+    constructor(connection, executeOptions) {
+        this.#executeOptions = executeOptions ?? {};
+        this.#connection = connection;
+    }
+    async executeQuery(compiledQuery) {
+        const { sql, bindParams } = this.formatQuery(compiledQuery);
+        const result = await this.#connection.execute(sql, bindParams, {
+            autoCommit: compiledQuery.autoCommit,
+            outFormat: OUT_FORMAT_OBJECT,
+            ...this.#executeOptions,
+        });
+        return {
+            rows: result?.rows || [],
+            numAffectedRows: result.rowsAffected ? BigInt(result.rowsAffected) : undefined,
+            // @ts-ignore internal extension for Oracle returning clause
+            outBinds: result.outBinds,
+        };
+    }
+    formatQuery(query) {
+        return {
+            sql: query.sql.replace(/\$(\d+)/g, (_match, p1) => `:${parseInt(p1, 10) - 1}`), // Format bind params in Oracle syntax :0, :1, etc.
+            bindParams: query.parameters,
+        };
+    }
+    async *streamQuery(compiledQuery, _chunkSize) {
+        const { sql, bindParams } = this.formatQuery(compiledQuery);
+        const result = await this.#connection.execute(sql, bindParams, {
+            resultSet: true,
+            autoCommit: compiledQuery.autoCommit,
+            outFormat: OUT_FORMAT_OBJECT,
+            ...this.#executeOptions,
+        });
+        const rs = result.resultSet;
+        try {
+            let row;
+            while ((row = await rs.getRow())) {
+                yield { rows: [row] };
+            }
+        }
+        finally {
+            await rs.close();
+        }
+    }
+    get connection() {
+        return this.#connection;
+    }
+}
+class OracleDriver {
+    #config;
+    #connections = new Set();
+    constructor(config) {
+        this.#config = config;
+    }
+    async init() {
+        //
+    }
+    async acquireConnection() {
+        const connection = new OracleConnection(await this.#config.pool.getConnection(), this.#config.executeOptions);
+        this.#connections.add(connection);
+        return connection;
+    }
+    async savepoint(connection, savepointName, compileQuery) {
+        await connection.executeQuery(compileQuery(parseSavepointCommand('savepoint', savepointName), createQueryId()));
+    }
+    async rollbackToSavepoint(connection, savepointName, compileQuery) {
+        await connection.executeQuery(compileQuery(parseSavepointCommand('rollback to savepoint', savepointName), createQueryId()));
+    }
+    async releaseSavepoint(connection, savepointName, compileQuery) {
+        //
+    }
+    async beginTransaction(connection, settings) {
+        if (settings.accessMode) {
+            await connection.executeQuery(CompiledQuery.raw(`set transaction ${settings.accessMode}`));
+            return;
+        }
+        if (settings.isolationLevel) {
+            await connection.executeQuery(CompiledQuery.raw(`set transaction isolation level ${settings.isolationLevel}`));
+        }
+    }
+    async commitTransaction(connection) {
+        await connection.connection.commit();
+    }
+    async rollbackTransaction(connection) {
+        await connection.connection.rollback();
+    }
+    async releaseConnection(connection) {
+        try {
+            await connection.connection.close();
+        }
+        catch (err) {
+            //
+        }
+        finally {
+            this.#connections.delete(connection);
+        }
+    }
+    async destroy() {
+        for (const connection of this.#connections) {
+            await this.releaseConnection(connection);
+        }
+        await this.#config.pool?.close(0);
+    }
+}
+export class OracleDialect {
+    #config;
+    constructor(config) {
+        this.#config = config;
+    }
+    createDriver() {
+        return new OracleDriver(this.#config);
+    }
+    createAdapter() {
+        return new OracleAdapter();
+    }
+    createIntrospector(db) {
+        throw new Error('Not implemented');
+    }
+    createQueryCompiler() {
+        return new OracleQueryCompiler();
+    }
+}
+/* v8 ignore stop */

package/dialects/oracledb/OracleNativeQueryBuilder.d.ts

@@ -0,0 +1,19 @@
+import { type Dictionary } from '@mikro-orm/core';
+import { NativeQueryBuilder } from '../../query/NativeQueryBuilder.js';
+/** @internal */
+export declare function markOutBindings(obj: Dictionary): void;
+/** @internal */
+export declare class OracleNativeQueryBuilder extends NativeQueryBuilder {
+    as(alias: string): this;
+    compile(): {
+        sql: string;
+        params: unknown[];
+    };
+    protected compileTruncate(): void;
+    protected combineParts(): {
+        sql: string;
+        params: unknown[];
+    };
+    private compileUpsert;
+    protected compileSelect(): void;
+}