@mikro-orm/sql 7.0.0-dev.97 → 7.0.0-dev.99

package/AbstractSqlConnection.d.ts

@@ -0,0 +1,57 @@
+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 { 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;
+    connect(options?: {
+        skipOnConnect?: boolean;
+    }): Promise<void>;
+    createKysely(): void;
+    /**
+     * @inheritDoc
+     */
+    close(force?: boolean): Promise<void>;
+    /**
+     * @inheritDoc
+     */
+    isConnected(): Promise<boolean>;
+    /**
+     * @inheritDoc
+     */
+    checkConnection(): Promise<{
+        ok: true;
+    } | {
+        ok: false;
+        reason: string;
+        error?: Error;
+    }>;
+    getClient<T = any>(): Kysely<T>;
+    transactional<T>(cb: (trx: Transaction<ControlledTransaction<any, any>>) => Promise<T>, options?: {
+        isolationLevel?: IsolationLevel;
+        readOnly?: boolean;
+        ctx?: ControlledTransaction<any>;
+        eventBroadcaster?: TransactionEventBroadcaster;
+        loggerContext?: LogContext;
+    }): Promise<T>;
+    begin(options?: {
+        isolationLevel?: IsolationLevel;
+        readOnly?: boolean;
+        ctx?: ControlledTransaction<any, any>;
+        eventBroadcaster?: TransactionEventBroadcaster;
+        loggerContext?: LogContext;
+    }): Promise<ControlledTransaction<any, any>>;
+    commit(ctx: ControlledTransaction<any, any>, eventBroadcaster?: TransactionEventBroadcaster, loggerContext?: LogContext): Promise<void>;
+    rollback(ctx: ControlledTransaction<any, any>, eventBroadcaster?: TransactionEventBroadcaster, loggerContext?: LogContext): Promise<void>;
+    private prepareQuery;
+    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>;
+    stream<T extends EntityData<AnyEntity>>(query: string | NativeQueryBuilder | RawQueryFragment, params?: readonly unknown[], ctx?: Transaction<Kysely<any>>, loggerContext?: LoggingOptions): AsyncIterableIterator<T>;
+    /**
+     * Execute raw SQL queries from file
+     */
+    loadFile(path: string): Promise<void>;
+    private getSql;
+    protected transformRawResult<T>(res: any, method?: 'all' | 'get' | 'run'): T;
+}

package/AbstractSqlConnection.js

@@ -0,0 +1,239 @@
+import { CompiledQuery, Kysely } from 'kysely';
+import { Connection, EventType, RawQueryFragment, Utils, } from '@mikro-orm/core';
+import { NativeQueryBuilder } from './query/NativeQueryBuilder.js';
+export class AbstractSqlConnection extends Connection {
+    #client;
+    async connect(options) {
+        this.getClient();
+        this.connected = true;
+        if (options?.skipOnConnect !== true) {
+            await this.onConnect();
+        }
+    }
+    createKysely() {
+        let driverOptions = this.options.driverOptions ?? this.config.get('driverOptions');
+        if (typeof driverOptions === 'function') {
+            driverOptions = driverOptions();
+        }
+        if (driverOptions instanceof Kysely) {
+            this.logger.log('info', 'Reusing Kysely client provided via `driverOptions`');
+            this.#client = driverOptions;
+        }
+        else if ('createDriver' in driverOptions) {
+            this.logger.log('info', 'Reusing Kysely dialect provided via `driverOptions`');
+            this.#client = new Kysely({ dialect: driverOptions });
+        }
+        else {
+            this.#client = new Kysely({
+                dialect: this.createKyselyDialect(driverOptions),
+            });
+        }
+    }
+    /**
+     * @inheritDoc
+     */
+    async close(force) {
+        await super.close(force);
+        await this.#client?.destroy();
+        this.connected = false;
+        this.#client = undefined;
+    }
+    /**
+     * @inheritDoc
+     */
+    async isConnected() {
+        const check = await this.checkConnection();
+        return check.ok;
+    }
+    /**
+     * @inheritDoc
+     */
+    async checkConnection() {
+        if (!this.connected) {
+            return { ok: false, reason: 'Connection not established' };
+        }
+        try {
+            await this.getClient().executeQuery(CompiledQuery.raw('select 1'));
+            return { ok: true };
+        }
+        catch (error) {
+            return { ok: false, reason: error.message, error };
+        }
+    }
+    getClient() {
+        if (!this.#client) {
+            this.createKysely();
+        }
+        return this.#client;
+    }
+    async transactional(cb, options = {}) {
+        const trx = await this.begin(options);
+        try {
+            const ret = await cb(trx);
+            await this.commit(trx, options.eventBroadcaster, options.loggerContext);
+            return ret;
+        }
+        catch (error) {
+            await this.rollback(trx, options.eventBroadcaster, options.loggerContext);
+            throw error;
+        }
+    }
+    async begin(options = {}) {
+        if (options.ctx) {
+            const ctx = options.ctx;
+            await options.eventBroadcaster?.dispatchEvent(EventType.beforeTransactionStart, ctx);
+            ctx.index ??= 0;
+            const savepointName = `trx${ctx.index + 1}`;
+            const trx = await options.ctx.savepoint(savepointName).execute();
+            Reflect.defineProperty(trx, 'index', { value: ctx.index + 1 });
+            Reflect.defineProperty(trx, 'savepointName', { value: savepointName });
+            this.logQuery(this.platform.getSavepointSQL(savepointName), options.loggerContext);
+            await options.eventBroadcaster?.dispatchEvent(EventType.afterTransactionStart, trx);
+            return trx;
+        }
+        await this.ensureConnection();
+        await options.eventBroadcaster?.dispatchEvent(EventType.beforeTransactionStart);
+        let trxBuilder = this.getClient().startTransaction();
+        if (options.isolationLevel) {
+            trxBuilder = trxBuilder.setIsolationLevel(options.isolationLevel);
+        }
+        if (options.readOnly) {
+            trxBuilder = trxBuilder.setAccessMode('read only');
+        }
+        const trx = await trxBuilder.execute();
+        if (options.ctx) {
+            const ctx = options.ctx;
+            ctx.index ??= 0;
+            const savepointName = `trx${ctx.index + 1}`;
+            Reflect.defineProperty(trx, 'index', { value: ctx.index + 1 });
+            Reflect.defineProperty(trx, 'savepointName', { value: savepointName });
+            this.logQuery(this.platform.getSavepointSQL(savepointName), options.loggerContext);
+        }
+        else {
+            for (const query of this.platform.getBeginTransactionSQL(options)) {
+                this.logQuery(query, options.loggerContext);
+            }
+        }
+        await options.eventBroadcaster?.dispatchEvent(EventType.afterTransactionStart, trx);
+        return trx;
+    }
+    async commit(ctx, eventBroadcaster, loggerContext) {
+        if (ctx.isRolledBack) {
+            return;
+        }
+        await eventBroadcaster?.dispatchEvent(EventType.beforeTransactionCommit, ctx);
+        if ('savepointName' in ctx) {
+            await ctx.releaseSavepoint(ctx.savepointName).execute();
+            this.logQuery(this.platform.getReleaseSavepointSQL(ctx.savepointName), loggerContext);
+        }
+        else {
+            await ctx.commit().execute();
+            this.logQuery(this.platform.getCommitTransactionSQL(), loggerContext);
+        }
+        await eventBroadcaster?.dispatchEvent(EventType.afterTransactionCommit, ctx);
+    }
+    async rollback(ctx, eventBroadcaster, loggerContext) {
+        await eventBroadcaster?.dispatchEvent(EventType.beforeTransactionRollback, ctx);
+        if ('savepointName' in ctx) {
+            await ctx.rollbackToSavepoint(ctx.savepointName).execute();
+            this.logQuery(this.platform.getRollbackToSavepointSQL(ctx.savepointName), loggerContext);
+        }
+        else {
+            await ctx.rollback().execute();
+            this.logQuery(this.platform.getRollbackTransactionSQL(), loggerContext);
+        }
+        await eventBroadcaster?.dispatchEvent(EventType.afterTransactionRollback, ctx);
+    }
+    prepareQuery(query, params = []) {
+        if (query instanceof NativeQueryBuilder) {
+            query = query.toRaw();
+        }
+        if (query instanceof RawQueryFragment) {
+            params = query.params;
+            query = query.sql;
+        }
+        query = this.config.get('onQuery')(query, params);
+        const formatted = this.platform.formatQuery(query, params);
+        return { query, params, formatted };
+    }
+    async execute(query, params = [], method = 'all', ctx, loggerContext) {
+        await this.ensureConnection();
+        const q = this.prepareQuery(query, params);
+        const sql = this.getSql(q.query, q.formatted, loggerContext);
+        return this.executeQuery(sql, async () => {
+            const compiled = CompiledQuery.raw(q.formatted);
+            const res = await (ctx ?? this.#client).executeQuery(compiled);
+            return this.transformRawResult(res, method);
+        }, { ...q, ...loggerContext });
+    }
+    async *stream(query, params = [], ctx, loggerContext) {
+        await this.ensureConnection();
+        const q = this.prepareQuery(query, params);
+        const sql = this.getSql(q.query, q.formatted, loggerContext);
+        // construct the compiled query manually with `kind: 'SelectQueryNode'` to avoid sqlite validation for select queries when streaming
+        const compiled = {
+            query: {
+                kind: 'SelectQueryNode',
+            },
+            sql: q.formatted,
+            parameters: [],
+        };
+        try {
+            const res = (ctx ?? this.getClient()).getExecutor().stream(compiled, 1);
+            this.logQuery(sql, {
+                sql, params,
+                ...loggerContext,
+                affected: Utils.isPlainObject(res) ? res.affectedRows : undefined,
+            });
+            for await (const items of res) {
+                for (const row of this.transformRawResult(items, 'all')) {
+                    yield row;
+                }
+            }
+        }
+        catch (e) {
+            this.logQuery(sql, { sql, params, ...loggerContext, level: 'error' });
+            throw e;
+        }
+    }
+    /**
+     * Execute raw SQL queries from file
+     */
+    async loadFile(path) {
+        await this.ensureConnection();
+        const { readFile } = globalThis.process.getBuiltinModule('node:fs/promises');
+        const buf = await readFile(path);
+        try {
+            const raw = CompiledQuery.raw(buf.toString());
+            await this.getClient().executeQuery(raw);
+        }
+        catch (e) {
+            /* v8 ignore next */
+            throw this.platform.getExceptionConverter().convertException(e);
+        }
+    }
+    getSql(query, formatted, context) {
+        const logger = this.config.getLogger();
+        if (!logger.isEnabled('query', context)) {
+            return query;
+        }
+        if (logger.isEnabled('query-params', context)) {
+            return formatted;
+        }
+        return query;
+    }
+    transformRawResult(res, method) {
+        if (method === 'get') {
+            return res.rows[0];
+        }
+        if (method === 'all') {
+            return res.rows;
+        }
+        return {
+            affectedRows: Number(res.numAffectedRows ?? res.rows.length),
+            insertId: res.insertId != null ? Number(res.insertId) : res.insertId,
+            row: res.rows[0],
+            rows: res.rows,
+        };
+    }
+}

package/AbstractSqlDriver.d.ts

@@ -0,0 +1,94 @@
+import { type AnyEntity, type Collection, type Configuration, type ConnectionType, type Constructor, type CountOptions, DatabaseDriver, type DeleteOptions, type Dictionary, type DriverMethodOptions, type EntityData, type EntityDictionary, type EntityField, EntityManagerType, type EntityMetadata, type EntityName, type EntityProperty, type FilterQuery, type FindOneOptions, type FindOptions, type LockOptions, type LoggingOptions, type NativeInsertUpdateManyOptions, type NativeInsertUpdateOptions, type ObjectQuery, type Options, type OrderDefinition, type PopulateOptions, type PopulatePath, type Primary, type QueryOrderMap, type QueryResult, RawQueryFragment, type StreamOptions, type Transaction, type UpsertManyOptions, type UpsertOptions } from '@mikro-orm/core';
+import type { AbstractSqlConnection } from './AbstractSqlConnection.js';
+import type { AbstractSqlPlatform } from './AbstractSqlPlatform.js';
+import { QueryBuilder } from './query/QueryBuilder.js';
+import { type NativeQueryBuilder } from './query/NativeQueryBuilder.js';
+import { QueryType } from './query/enums.js';
+import { SqlEntityManager } from './SqlEntityManager.js';
+import type { Field } from './typings.js';
+export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlConnection = AbstractSqlConnection, Platform extends AbstractSqlPlatform = AbstractSqlPlatform> extends DatabaseDriver<Connection> {
+    [EntityManagerType]: SqlEntityManager<this>;
+    protected readonly connection: Connection;
+    protected readonly replicas: Connection[];
+    protected readonly platform: Platform;
+    protected constructor(config: Configuration, platform: Platform, connection: Constructor<Connection>, connector: string[]);
+    getPlatform(): Platform;
+    createEntityManager(useContext?: boolean): this[typeof EntityManagerType];
+    private createQueryBuilderFromOptions;
+    find<T extends object, P extends string = never, F extends string = PopulatePath.ALL, E extends string = never>(entityName: string, where: ObjectQuery<T>, options?: FindOptions<T, P, F, E>): Promise<EntityData<T>[]>;
+    findOne<T extends object, P extends string = never, F extends string = PopulatePath.ALL, E extends string = never>(entityName: string, where: ObjectQuery<T>, options?: FindOneOptions<T, P, F, E>): Promise<EntityData<T> | null>;
+    protected hasToManyJoins<T extends object>(hint: PopulateOptions<T>, meta: EntityMetadata<T>): boolean;
+    findVirtual<T extends object>(entityName: string, where: ObjectQuery<T>, options: FindOptions<T, any, any, any>): Promise<EntityData<T>[]>;
+    countVirtual<T extends object>(entityName: string, where: ObjectQuery<T>, options: CountOptions<T, any>): Promise<number>;
+    protected findFromVirtual<T extends object>(entityName: string, where: ObjectQuery<T>, options: FindOptions<T, any> | CountOptions<T, any>, type: QueryType): Promise<EntityData<T>[] | number>;
+    protected streamFromVirtual<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, options: StreamOptions<T, any>): AsyncIterableIterator<EntityData<T>>;
+    protected wrapVirtualExpressionInSubquery<T extends object>(meta: EntityMetadata<T>, expression: string, where: FilterQuery<T>, options: FindOptions<T, any>, type: QueryType): Promise<T[] | number>;
+    protected wrapVirtualExpressionInSubqueryStream<T extends object>(meta: EntityMetadata<T>, expression: string, where: FilterQuery<T>, options: FindOptions<T, any, any, any>, type: QueryType.SELECT): AsyncIterableIterator<T>;
+    mapResult<T extends object>(result: EntityData<T>, meta: EntityMetadata<T>, populate?: PopulateOptions<T>[], qb?: QueryBuilder<T, any, any, any>, map?: Dictionary): EntityData<T> | null;
+    private mapJoinedProps;
+    count<T extends object>(entityName: string, where: any, options?: CountOptions<T>): Promise<number>;
+    nativeInsert<T extends object>(entityName: string, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T>): Promise<QueryResult<T>>;
+    nativeInsertMany<T extends object>(entityName: string, data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T>, transform?: (sql: string) => string): Promise<QueryResult<T>>;
+    nativeUpdate<T extends object>(entityName: string, where: FilterQuery<T>, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T> & UpsertOptions<T>): Promise<QueryResult<T>>;
+    nativeUpdateMany<T extends object>(entityName: string, where: FilterQuery<T>[], data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T> & UpsertManyOptions<T>): Promise<QueryResult<T>>;
+    nativeDelete<T extends object>(entityName: string, where: FilterQuery<T> | string | any, options?: DeleteOptions<T>): Promise<QueryResult<T>>;
+    /**
+     * Fast comparison for collection snapshots that are represented by PK arrays.
+     * Compares scalars via `===` and fallbacks to Utils.equals()` for more complex types like Buffer.
+     * Always expects the same length of the arrays, since we only compare PKs of the same entity type.
+     */
+    private comparePrimaryKeyArrays;
+    syncCollections<T extends object, O extends object>(collections: Iterable<Collection<T, O>>, options?: DriverMethodOptions): Promise<void>;
+    loadFromPivotTable<T extends object, O extends object>(prop: EntityProperty, owners: Primary<O>[][], where?: FilterQuery<any>, orderBy?: OrderDefinition<T>, ctx?: Transaction, options?: FindOptions<T, any, any, any>, pivotJoin?: boolean): Promise<Dictionary<T[]>>;
+    private getPivotOrderBy;
+    execute<T extends QueryResult | EntityData<AnyEntity> | EntityData<AnyEntity>[] = EntityData<AnyEntity>[]>(query: string | NativeQueryBuilder | RawQueryFragment, params?: any[], method?: 'all' | 'get' | 'run', ctx?: Transaction, loggerContext?: LoggingOptions): Promise<T>;
+    stream<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, options: StreamOptions<T, any, any, any>): AsyncIterableIterator<T>;
+    /**
+     * 1:1 owner side needs to be marked for population so QB auto-joins the owner id
+     */
+    protected autoJoinOneToOneOwner<T extends object>(meta: EntityMetadata<T>, populate: PopulateOptions<T>[], fields?: readonly EntityField<T, any>[]): PopulateOptions<T>[];
+    /**
+     * @internal
+     */
+    joinedProps<T>(meta: EntityMetadata, populate: readonly PopulateOptions<T>[], options?: {
+        strategy?: Options['loadStrategy'];
+    }): PopulateOptions<T>[];
+    /**
+     * @internal
+     */
+    mergeJoinedResult<T extends object>(rawResults: EntityData<T>[], meta: EntityMetadata<T>, joinedProps: PopulateOptions<T>[]): EntityData<T>[];
+    protected shouldHaveColumn<T, U>(meta: EntityMetadata<T>, prop: EntityProperty<U>, populate: readonly PopulateOptions<U>[], fields?: readonly Field<U>[], exclude?: readonly Field<U>[]): boolean;
+    protected getFieldsForJoinedLoad<T extends object>(qb: QueryBuilder<T, any, any, any>, meta: EntityMetadata<T>, options: FieldsForJoinedLoadOptions<T>): Field<T>[];
+    /**
+     * @internal
+     */
+    mapPropToFieldNames<T extends object>(qb: QueryBuilder<T, any, any, any>, prop: EntityProperty<T>, tableAlias: string, explicitFields?: readonly Field<T>[]): Field<T>[];
+    /** @internal */
+    createQueryBuilder<T extends object>(entityName: EntityName<T> | QueryBuilder<T, any, any, any>, ctx?: Transaction, preferredConnectionType?: ConnectionType, convertCustomTypes?: boolean, loggerContext?: LoggingOptions, alias?: string, em?: SqlEntityManager): QueryBuilder<T, any, any, any>;
+    protected resolveConnectionType(args: {
+        ctx?: Transaction;
+        connectionType?: ConnectionType;
+    }): ConnectionType;
+    protected extractManyToMany<T>(entityName: string, data: EntityDictionary<T>): EntityData<T>;
+    protected processManyToMany<T extends object>(meta: EntityMetadata<T> | undefined, pks: Primary<T>[], collections: EntityData<T>, clear: boolean, options?: DriverMethodOptions): Promise<void>;
+    lockPessimistic<T extends object>(entity: T, options: LockOptions): Promise<void>;
+    protected buildPopulateWhere<T extends object>(meta: EntityMetadata<T>, joinedProps: PopulateOptions<T>[], options: Pick<FindOptions<any>, 'populateWhere'>): ObjectQuery<T>;
+    protected buildOrderBy<T extends object>(qb: QueryBuilder<T, any, any, any>, meta: EntityMetadata<T>, populate: PopulateOptions<T>[], options: Pick<FindOptions<any>, 'strategy' | 'orderBy' | 'populateOrderBy'>): QueryOrderMap<T>[];
+    protected buildPopulateOrderBy<T extends object>(qb: QueryBuilder<T, any, any, any>, meta: EntityMetadata<T>, populateOrderBy: QueryOrderMap<T>[], parentPath: string, explicit: boolean, parentAlias?: string): QueryOrderMap<T>[];
+    protected buildJoinedPropsOrderBy<T extends object>(qb: QueryBuilder<T, any, any, any>, meta: EntityMetadata<T>, populate: PopulateOptions<T>[], options?: Pick<FindOptions<any>, 'strategy' | 'orderBy' | 'populateOrderBy'>, parentPath?: string): QueryOrderMap<T>[];
+    protected normalizeFields<T extends object>(fields: Field<T>[], prefix?: string): string[];
+    protected processField<T extends object>(meta: EntityMetadata<T>, prop: EntityProperty<T> | undefined, field: string, ret: Field<T>[]): void;
+    protected buildFields<T extends object>(meta: EntityMetadata<T>, populate: PopulateOptions<T>[], joinedProps: PopulateOptions<T>[], qb: QueryBuilder<T, any, any, any>, alias: string, options: Pick<FindOptions<T, any, any, any>, 'strategy' | 'fields' | 'exclude'>): Field<T>[];
+}
+interface FieldsForJoinedLoadOptions<T extends object> {
+    explicitFields?: readonly Field<T>[];
+    exclude?: readonly Field<T>[];
+    populate?: readonly PopulateOptions<T>[];
+    strategy?: Options['loadStrategy'];
+    populateWhere?: FindOptions<any>['populateWhere'];
+    populateFilter?: FindOptions<any>['populateFilter'];
+    parentTableAlias: string;
+    parentJoinPath?: string;
+    count?: boolean;
+}
+export {};