@mikro-orm/sql 7.0.17 → 7.0.18-dev.1

package/AbstractSqlConnection.d.ts

@@ -60,7 +60,7 @@ export declare abstract class AbstractSqlConnection extends Connection {
     /** Executes a SQL query and returns the result based on the method: `'all'` for rows, `'get'` for single row, `'run'` for affected count. */
     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>;
     /** Executes a SQL query and returns an async iterable that yields results row by row. */
-    stream<T extends EntityData<AnyEntity>>(query: string | NativeQueryBuilder | RawQueryFragment, params?: readonly unknown[], ctx?: Transaction<Kysely<any>>, loggerContext?: LoggingOptions): AsyncIterableIterator<T>;
+    stream<T extends EntityData<AnyEntity>>(query: string | NativeQueryBuilder | RawQueryFragment, params?: readonly unknown[], ctx?: Transaction<Kysely<any>>, loggerContext?: LoggingOptions, chunkSize?: number): AsyncIterableIterator<T>;
     /** @inheritDoc */
     executeDump(dump: string): Promise<void>;
     protected getSql(query: string, formatted: string, context?: LogContext): string;

package/AbstractSqlConnection.js

@@ -1,6 +1,23 @@
 import { CompiledQuery, Kysely } from 'kysely';
 import { Connection, EventType, isRaw, Utils, } from '@mikro-orm/core';
 import { NativeQueryBuilder } from './query/NativeQueryBuilder.js';
+/**
+ * Pulls cancellation controls out of a `loggerContext` payload, returning the abort options
+ * and a sanitized context that no longer carries them. The QueryBuilder/EM stash
+ * `signal`/`inflightQueryAbortStrategy` on `loggerContext` to avoid widening the public
+ * connection API; stripping them prevents leakage into user `Logger.logQuery` payloads.
+ */
+function extractAbortOptions(loggerContext) {
+    const ctx = loggerContext;
+    if (ctx?.signal == null && ctx?.inflightQueryAbortStrategy == null) {
+        return { loggerContext };
+    }
+    const { signal, inflightQueryAbortStrategy, ...rest } = ctx;
+    return {
+        abort: { signal, inflightQueryAbortStrategy },
+        loggerContext: rest,
+    };
+}
 /** Base class for SQL database connections, built on top of Kysely. */
 export class AbstractSqlConnection extends Connection {
     #client;
@@ -183,17 +200,19 @@ export class AbstractSqlConnection extends Connection {
         await this.ensureConnection();
         const q = this.prepareQuery(query, params);
         const sql = this.getSql(q.query, q.formatted, loggerContext);
+        const { abort, loggerContext: cleanCtx } = extractAbortOptions(loggerContext);
         return this.executeQuery(sql, async () => {
             const compiled = CompiledQuery.raw(q.formatted);
-            const res = await (ctx ?? this.#client).executeQuery(compiled);
+            const res = await (ctx ?? this.#client).executeQuery(compiled, abort);
             return this.transformRawResult(res, method);
-        }, { ...q, ...loggerContext });
+        }, { ...q, ...cleanCtx });
     }
     /** Executes a SQL query and returns an async iterable that yields results row by row. */
-    async *stream(query, params = [], ctx, loggerContext) {
+    async *stream(query, params = [], ctx, loggerContext, chunkSize) {
         await this.ensureConnection();
         const q = this.prepareQuery(query, params);
         const sql = this.getSql(q.query, q.formatted, loggerContext);
+        const { abort, loggerContext: cleanCtx } = extractAbortOptions(loggerContext);
         // construct the compiled query manually with `kind: 'SelectQueryNode'` to avoid sqlite validation for select queries when streaming
         const compiled = {
             query: {
@@ -203,11 +222,13 @@ export class AbstractSqlConnection extends Connection {
             parameters: [],
         };
         try {
-            const res = (ctx ?? this.getClient()).getExecutor().stream(compiled, 1);
+            const res = (ctx ?? this.getClient())
+                .getExecutor()
+                .stream(compiled, chunkSize ?? 100, abort ? { signal: abort.signal } : undefined);
             this.logQuery(sql, {
                 sql,
                 params,
-                ...loggerContext,
+                ...cleanCtx,
                 affected: Utils.isPlainObject(res) ? res.affectedRows : undefined,
             });
             for await (const items of res) {
@@ -217,7 +238,7 @@ export class AbstractSqlConnection extends Connection {
             }
         }
         catch (e) {
-            this.logQuery(sql, { sql, params, ...loggerContext, level: 'error' });
+            this.logQuery(sql, { sql, params, ...cleanCtx, level: 'error' });
             throw e;
         }
     }

package/AbstractSqlDriver.d.ts

@@ -31,7 +31,7 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
     protected findFromVirtual<T extends object>(entityName: EntityName<T>, 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>;
+    protected wrapVirtualExpressionInSubqueryStream<T extends object>(meta: EntityMetadata<T>, expression: string, where: FilterQuery<T>, options: StreamOptions<T, any, any, any>, type: QueryType.SELECT): AsyncIterableIterator<T>;
     /**
      * Virtual entities have no PKs, so to-many populate joins can't be deduplicated.
      * Force balanced strategy to load to-many relations via separate queries.
@@ -52,6 +52,12 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
     private mapJoinedProp;
     count<T extends object>(entityName: EntityName<T>, where: any, options?: CountOptions<T>): Promise<number>;
     nativeInsert<T extends object>(entityName: EntityName<T>, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T>): Promise<QueryResult<T>>;
+    nativeClone<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, overrides?: EntityData<T>, options?: NativeInsertUpdateOptions<T>): Promise<QueryResult<T>>;
+    private nativeCloneSimple;
+    private nativeCloneTPT;
+    private mapCloneOverrides;
+    private buildCloneFields;
+    private getCloneableProps;
     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>, transform?: (sql: string, params: any[]) => string): Promise<QueryResult<T>>;
@@ -77,11 +83,22 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
      * Uses single query with join via virtual relation on pivot.
      */
     protected loadPolymorphicPivotInverseSide<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>): Promise<Dictionary<T[]>>;
+    /**
+     * Load a union-target polymorphic M:N pivot (e.g. Post.attachments -> Image | Video).
+     * Each pivot row's discriminator column selects which target table to hydrate.
+     */
+    protected loadFromUnionTargetPolymorphicPivotTable<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[]>>;
     /**
      * Build a map from owner PKs to their related entities from pivot table results.
      */
     private buildPivotResultMap;
     private wrapPopulateFilter;
+    /**
+     * The pivot query builder doesn't convert custom types — manually convert owner PKs to the DB
+     * representation. Returns `needsConversion` + `pkProp` so the caller can convert result FKs back
+     * to JS format for consistent key hashing in `buildPivotResultMap`.
+     */
+    private convertOwnerPksForPivotQuery;
     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>;
@@ -137,6 +154,13 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
     mapPropToFieldNames<T extends object>(qb: AnyQueryBuilder<T>, prop: EntityProperty<T>, tableAlias: string, meta: EntityMetadata<T>, schema?: string, explicitFields?: readonly InternalField<T>[]): InternalField<T>[];
     /** @internal */
     createQueryBuilder<T extends object>(entityName: EntityName<T> | AnyQueryBuilder<T>, ctx?: Transaction, preferredConnectionType?: ConnectionType, convertCustomTypes?: boolean, loggerContext?: LoggingOptions, alias?: string, em?: SqlEntityManager): AnyQueryBuilder<T>;
+    /**
+     * Renders a `FilterQuery` predicate into a SQL fragment (without the `WHERE` keyword and
+     * without table-alias prefixes) suitable for inlining into a partial-index DDL statement.
+     * Used by `DatabaseTable.addIndex` when the user passes an object `where` on `@Index` /
+     * `@Unique`. Strings are returned unchanged.
+     */
+    renderPartialIndexWhere<T extends object>(entityName: EntityName<T>, where: string | FilterQuery<T>): string;
     protected resolveConnectionType(args: {
         ctx?: Transaction;
         connectionType?: ConnectionType;