@mikro-orm/sql 7.1.0-dev.9 → 7.1.1-dev.0

package/dialects/sqlite/SqliteSchemaHelper.js

@@ -15,6 +15,7 @@ const SPATIALITE_VIEWS = [
     'ElementaryGeometries',
 ];
 export class SqliteSchemaHelper extends SchemaHelper {
+    static PARTIAL_WHERE_RE = /\swhere\s+(.+?)\s*$/is;
     disableForeignKeysSQL() {
         return 'pragma foreign_keys = off;';
     }
@@ -30,6 +31,10 @@ export class SqliteSchemaHelper extends SchemaHelper {
     getDropNamespaceSQL(name) {
         return '';
     }
+    async tableExists(connection, tableName, _schemaName, ctx) {
+        const rows = await connection.execute(`select name from sqlite_master where type = 'table' and name = ${this.platform.quoteValue(tableName)}`, [], 'all', ctx);
+        return rows.length > 0;
+    }
     getListTablesSQL() {
         return (`select name as table_name from sqlite_master where type = 'table' and name != 'sqlite_sequence' and name != 'geometry_columns' and name != 'spatial_ref_sys' ` +
             `union all select name as table_name from sqlite_temp_master where type = 'table' order by name`);
@@ -100,7 +105,7 @@ export class SqliteSchemaHelper extends SchemaHelper {
             const checks = await this.getChecks(connection, table.name, table.schema, ctx);
             const pks = await this.getPrimaryKeys(connection, indexes, table.name, table.schema, ctx);
             const fks = await this.getForeignKeys(connection, table.name, table.schema, ctx);
-            const enums = await this.getEnumDefinitions(connection, table.name, table.schema, ctx);
+            const enums = this.extractEnumValuesFromChecks(checks);
             const triggers = await this.getTableTriggers(connection, table.name);
             table.init(cols, indexes, checks, pks, fks, enums);
             table.setTriggers(triggers);
@@ -164,6 +169,7 @@ export class SqliteSchemaHelper extends SchemaHelper {
             col.push(`check (${checks[check].expression})`);
             checks.splice(check, 1);
         }
+        Utils.runIfNotEmpty(() => col.push(this.getCollateSQL(column.collation)), column.collation);
         Utils.runIfNotEmpty(() => col.push('null'), column.nullable);
         Utils.runIfNotEmpty(() => col.push('not null'), !column.nullable && !column.generated);
         Utils.runIfNotEmpty(() => col.push('primary key'), column.primary);
@@ -216,10 +222,10 @@ export class SqliteSchemaHelper extends SchemaHelper {
         if (index.columnNames.some(column => column.includes('.'))) {
             // JSON columns can have unique index but not unique constraint, and we need to distinguish those, so we can properly drop them
             const columns = this.platform.getJsonIndexDefinition(index);
-            return `${sqlPrefix} (${columns.join(', ')})`;
+            return `${sqlPrefix} (${columns.join(', ')})${this.getIndexWhereClause(index)}`;
         }
         // Use getIndexColumns to support advanced options like sort order and collation
-        return `${sqlPrefix} (${this.getIndexColumns(index)})`;
+        return `${sqlPrefix} (${this.getIndexColumns(index)})${this.getIndexWhereClause(index)}`;
     }
     parseTableDefinition(sql, cols) {
         const columns = {};
@@ -290,6 +296,17 @@ export class SqliteSchemaHelper extends SchemaHelper {
                     generated = `${match[2]} ${storage}`;
                 }
             }
+            // Strip string literals first (their contents could contain unbalanced parens), then
+            // repeatedly strip the innermost balanced `(...)` until none remain — a single pass would
+            // only remove the innermost level, leaving `collate` tokens inside nested CHECK/default
+            // expressions exposed to the column-collation regex.
+            let cleanDef = (columnDefinitions[col.name]?.definition ?? '').replace(/'[^']*'/g, '').replace(/"[^"]*"/g, '');
+            let prev;
+            do {
+                prev = cleanDef;
+                cleanDef = cleanDef.replace(/\([^()]*\)/g, '');
+            } while (cleanDef !== prev);
+            const collationMatch = /\bcollate\s+([`"']?)([\w\-.]+)\1/i.exec(cleanDef);
             return {
                 name: col.name,
                 type: col.type,
@@ -300,6 +317,7 @@ export class SqliteSchemaHelper extends SchemaHelper {
                 unsigned: false,
                 autoincrement: !composite && col.pk && this.platform.isNumericColumn(mappedType) && hasAutoincrement,
                 generated,
+                collation: collationMatch ? collationMatch[2] : undefined,
             };
         });
     }
@@ -326,23 +344,23 @@ export class SqliteSchemaHelper extends SchemaHelper {
         // everything else is an expression that had its outer parens stripped
         return `(${value})`;
     }
-    async getEnumDefinitions(connection, tableName, schemaName, ctx) {
-        const prefix = this.getSchemaPrefix(schemaName);
-        const sql = `select sql from ${prefix}sqlite_master where type = ? and name = ?`;
-        const tableDefinition = await connection.execute(sql, ['table', tableName], 'get', ctx);
-        const checkConstraints = [...(tableDefinition.sql.match(/[`["'][^`\]"']+[`\]"'] text check \(.*?\)/gi) ?? [])];
-        return checkConstraints.reduce((o, item) => {
-            // check constraints are defined as (note that last closing paren is missing):
-            // `type` text check (`type` in ('local', 'global')
-            const match = /[`["']([^`\]"']+)[`\]"'] text check \(.* \((.*)\)/i.exec(item);
-            /* v8 ignore next */
-            if (match) {
-                o[match[1]] = match[2]
-                    .split(/,(?=\s*'(?:[^']|'')*'(?:\s*\)|$))/)
-                    .map((item) => /^\(?'((?:[^']|'')*)'/.exec(item.trim())[1].replace(/''/g, "'"));
+    /** Extract enum values from `IN (…)` CHECKs only — a `!= 'x'` check would otherwise be misread as a one-item enum. */
+    extractEnumValuesFromChecks(checks) {
+        const result = {};
+        for (const check of checks) {
+            if (!check.columnName || typeof check.expression !== 'string') {
+                continue;
             }
-            return o;
-        }, {});
+            const inClause = /\bin\s*\(([^)]*)\)/i.exec(check.expression);
+            if (!inClause) {
+                continue;
+            }
+            const items = [...inClause[1].matchAll(/'((?:[^']|'')*)'/g)].map(m => m[1].replace(/''/g, "'"));
+            if (items.length > 0) {
+                result[check.columnName] = items;
+            }
+        }
+        return result;
     }
     async getPrimaryKeys(connection, indexes, tableName, schemaName, ctx) {
         const prefix = this.getSchemaPrefix(schemaName);
@@ -355,6 +373,16 @@ export class SqliteSchemaHelper extends SchemaHelper {
         const sql = `pragma ${prefix}table_info(\`${tableName}\`)`;
         const cols = await connection.execute(sql, [], 'all', ctx);
         const indexes = await connection.execute(`pragma ${prefix}index_list(\`${tableName}\`)`, [], 'all', ctx);
+        // sqlite_master.sql holds the original CREATE INDEX statement — the only place a partial
+        // index's WHERE predicate is preserved (PRAGMA index_* don't expose it).
+        const indexSqls = await connection.execute(`select name, sql from ${prefix}sqlite_master where type = 'index' and tbl_name = ?`, [tableName], 'all', ctx);
+        const wherePredicates = new Map();
+        for (const row of indexSqls) {
+            const match = row.sql && SqliteSchemaHelper.PARTIAL_WHERE_RE.exec(row.sql);
+            if (match) {
+                wherePredicates.set(row.name, match[1].trim());
+            }
+        }
         const ret = [];
         for (const col of cols.filter(c => c.pk)) {
             ret.push({
@@ -367,12 +395,14 @@ export class SqliteSchemaHelper extends SchemaHelper {
         }
         for (const index of indexes.filter(index => !this.isImplicitIndex(index.name))) {
             const res = await connection.execute(`pragma ${prefix}index_info(\`${index.name}\`)`, [], 'all', ctx);
+            const where = wherePredicates.get(index.name);
             ret.push(...res.map(row => ({
                 columnNames: [row.name],
                 keyName: index.name,
                 unique: !!index.unique,
                 constraint: !!index.unique,
                 primary: false,
+                ...(where ? { where } : {}),
             })));
         }
         return this.mapIndexes(ret);

package/index.d.ts

@@ -17,3 +17,5 @@ export type * from './typings.js';
 export * from './plugin/index.js';
 export { SqlEntityManager as EntityManager } from './SqlEntityManager.js';
 export { SqlEntityRepository as EntityRepository } from './SqlEntityRepository.js';
+export * from './SqlMikroORM.js';
+export { SqlMikroORM as MikroORM, type SqlOptions as Options, defineSqlConfig as defineConfig } from './SqlMikroORM.js';

package/index.js

@@ -16,3 +16,5 @@ export * from './dialects/index.js';
 export * from './plugin/index.js';
 export { SqlEntityManager as EntityManager } from './SqlEntityManager.js';
 export { SqlEntityRepository as EntityRepository } from './SqlEntityRepository.js';
+export * from './SqlMikroORM.js';
+export { SqlMikroORM as MikroORM, defineSqlConfig as defineConfig } from './SqlMikroORM.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/sql",
-  "version": "7.1.0-dev.9",
+  "version": "7.1.1-dev.0",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
   "keywords": [
     "data-mapper",
@@ -47,13 +47,13 @@
     "copy": "node ../../scripts/copy.mjs"
   },
   "dependencies": {
-    "kysely": "0.28.16"
+    "kysely": "0.29.2"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^7.0.11"
+    "@mikro-orm/core": "^7.1.0"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.1.0-dev.9"
+    "@mikro-orm/core": "7.1.1-dev.0"
   },
   "engines": {
     "node": ">= 22.17.0"

package/plugin/transformer.d.ts

@@ -1,5 +1,5 @@
-import { type EntityMetadata, type EntityProperty } from '@mikro-orm/core';
-import { type CommonTableExpressionNameNode, type DeleteQueryNode, type IdentifierNode, type InsertQueryNode, type JoinNode, type MergeQueryNode, type QueryId, type SelectQueryNode, type UpdateQueryNode, type WithNode, ColumnNode, OperationNodeTransformer, TableNode } from 'kysely';
+import { type EntityMetadata, type EntityProperty, type Type } from '@mikro-orm/core';
+import { type CommonTableExpressionNameNode, type DeleteQueryNode, type InsertQueryNode, type JoinNode, type MergeQueryNode, type OperationNode, type QueryId, type SelectQueryNode, type UpdateQueryNode, type WithNode, ColumnNode, IdentifierNode, OperationNodeTransformer, SelectionNode, TableNode, ValueNode } from 'kysely';
 import type { MikroKyselyPluginOptions } from './index.js';
 import type { SqlEntityManager } from '../SqlEntityManager.js';
 export declare class MikroTransformer extends OperationNodeTransformer {
@@ -28,10 +28,18 @@ export declare class MikroTransformer extends OperationNodeTransformer {
     processOnUpdateHooks(node: UpdateQueryNode, meta: EntityMetadata): UpdateQueryNode;
     processInsertValues(node: InsertQueryNode, meta: EntityMetadata): InsertQueryNode;
     processUpdateValues(node: UpdateQueryNode, meta: EntityMetadata): UpdateQueryNode;
+    processInputValueNode(prop: EntityProperty | undefined, fieldName: string | undefined, valueNode: ValueNode): OperationNode;
+    expandSelections(selections: readonly SelectionNode[]): readonly SelectionNode[];
+    expandSelection(sel: SelectionNode): SelectionNode[] | null;
+    expandStar(meta: EntityMetadata | undefined, table: TableNode | undefined, tableName: string | undefined): SelectionNode[] | null;
+    wrapRead(customType: Type<any>, fieldName: string, tableName: string | undefined): SelectionNode;
+    wrapWrite(prop: EntityProperty | undefined, fieldName: string | undefined, valueNode: ValueNode): OperationNode;
+    /** Resolve the customType for a specific field name (handles composite-PK FK fan-out via prop.customTypes[]). */
+    fieldType(prop: EntityProperty, fieldName: string): Type<any> | undefined;
+    findOwnerMeta(name: string | undefined): EntityMetadata | undefined;
     mapColumnsToProperties(columns: readonly ColumnNode[], meta: EntityMetadata): (EntityProperty | undefined)[];
     normalizeColumnName(identifier: IdentifierNode): string;
     findProperty(meta: EntityMetadata | undefined, columnName?: string): EntityProperty | undefined;
-    shouldConvertValues(): boolean;
     prepareInputValue(prop: EntityProperty | undefined, value: unknown, enabled: boolean): unknown;
     /**
      * Look up a table name/alias in the context stack.

package/plugin/transformer.js

@@ -1,5 +1,11 @@
 import { ReferenceKind, isRaw, } from '@mikro-orm/core';
-import { AliasNode, ColumnNode, ColumnUpdateNode, OperationNodeTransformer, PrimitiveValueListNode, ReferenceNode, SchemableIdentifierNode, TableNode, ValueListNode, ValueNode, ValuesNode, } from 'kysely';
+import { AliasNode, ColumnNode, ColumnUpdateNode, IdentifierNode, OperationNodeTransformer, PrimitiveValueListNode, RawNode, ReferenceNode, SchemableIdentifierNode, SelectAllNode, SelectionNode, TableNode, ValueListNode, ValueNode, ValuesNode, } from 'kysely';
+const EXPANDABLE_KINDS = new Set([
+    ReferenceKind.SCALAR,
+    ReferenceKind.EMBEDDED,
+    ReferenceKind.MANY_TO_ONE,
+    ReferenceKind.ONE_TO_ONE,
+]);
 export class MikroTransformer extends OperationNodeTransformer {
     /**
      * Context stack to support nested queries (subqueries, CTEs)
@@ -64,7 +70,14 @@ export class MikroTransformer extends OperationNodeTransformer {
                     this.processJoinNode(join, currentContext);
                 }
             }
-            return super.transformSelectQuery(node, queryId);
+            const transformed = super.transformSelectQuery(node, queryId);
+            if (this.#options.convertValues && transformed.selections?.length) {
+                const selections = this.expandSelections(transformed.selections);
+                if (selections !== transformed.selections) {
+                    return { ...transformed, selections };
+                }
+            }
+            return transformed;
         }
         finally {
             // Pop the context when exiting this query scope
@@ -365,32 +378,38 @@ export class MikroTransformer extends OperationNodeTransformer {
             return node;
         }
         const columnProps = this.mapColumnsToProperties(node.columns, meta);
-        const shouldConvert = this.shouldConvertValues();
+        const fieldNames = node.columns.map(c => this.normalizeColumnName(c.column));
+        // hasConvertToDatabaseValueSQL is set by MetadataDiscovery only when the SQL is non-trivial
+        // (i.e. it actually wraps `?`), so a no-op cast on sqlite won't force a row upgrade.
+        const needsSqlWrap = columnProps.some(p => p?.hasConvertToDatabaseValueSQL);
         let changed = false;
         const convertedRows = node.values.values.map(row => {
-            if (ValueListNode.is(row)) {
-                if (row.values.length !== columnProps.length) {
-                    return row;
-                }
+            if (ValueListNode.is(row) && row.values.length === columnProps.length) {
                 const values = row.values.map((valueNode, idx) => {
                     if (!ValueNode.is(valueNode)) {
                         return valueNode;
                     }
-                    const converted = this.prepareInputValue(columnProps[idx], valueNode.value, shouldConvert);
-                    if (converted === valueNode.value) {
-                        return valueNode;
+                    const newNode = this.processInputValueNode(columnProps[idx], fieldNames[idx], valueNode);
+                    if (newNode !== valueNode) {
+                        changed = true;
                     }
-                    changed = true;
-                    return valueNode.immediate ? ValueNode.createImmediate(converted) : ValueNode.create(converted);
+                    return newNode;
                 });
                 return ValueListNode.create(values);
             }
-            if (PrimitiveValueListNode.is(row)) {
-                if (row.values.length !== columnProps.length) {
-                    return row;
+            if (PrimitiveValueListNode.is(row) && row.values.length === columnProps.length) {
+                // upgrade to ValueListNode when any column needs SQL-side wrapping, since
+                // PrimitiveValueListNode can only hold primitives
+                if (needsSqlWrap) {
+                    changed = true;
+                    return ValueListNode.create(row.values.map((value, idx) => {
+                        const prop = columnProps[idx];
+                        const converted = this.prepareInputValue(prop, value, true);
+                        return this.wrapWrite(prop, fieldNames[idx], ValueNode.create(converted));
+                    }));
                 }
                 const values = row.values.map((value, idx) => {
-                    const converted = this.prepareInputValue(columnProps[idx], value, shouldConvert);
+                    const converted = this.prepareInputValue(columnProps[idx], value, true);
                     if (converted !== value) {
                         changed = true;
                     }
@@ -412,7 +431,6 @@ export class MikroTransformer extends OperationNodeTransformer {
         if (!node.updates?.length) {
             return node;
         }
-        const shouldConvert = this.shouldConvertValues();
         let changed = false;
         const updates = node.updates.map(updateNode => {
             if (!ValueNode.is(updateNode.value)) {
@@ -422,18 +440,12 @@ export class MikroTransformer extends OperationNodeTransformer {
                 ? this.normalizeColumnName(updateNode.column.column)
                 : undefined;
             const property = this.findProperty(meta, columnName);
-            const converted = this.prepareInputValue(property, updateNode.value.value, shouldConvert);
-            if (converted === updateNode.value.value) {
+            const newValue = this.processInputValueNode(property, columnName, updateNode.value);
+            if (newValue === updateNode.value) {
                 return updateNode;
             }
             changed = true;
-            const newValueNode = updateNode.value.immediate
-                ? ValueNode.createImmediate(converted)
-                : ValueNode.create(converted);
-            return {
-                ...updateNode,
-                value: newValueNode,
-            };
+            return { ...updateNode, value: newValue };
         });
         if (!changed) {
             return node;
@@ -443,6 +455,106 @@ export class MikroTransformer extends OperationNodeTransformer {
             updates,
         };
     }
+    processInputValueNode(prop, fieldName, valueNode) {
+        const converted = this.prepareInputValue(prop, valueNode.value, true);
+        const newValueNode = converted === valueNode.value
+            ? valueNode
+            : valueNode.immediate
+                ? ValueNode.createImmediate(converted)
+                : ValueNode.create(converted);
+        return this.wrapWrite(prop, fieldName, newValueNode);
+    }
+    expandSelections(selections) {
+        const out = [];
+        let changed = false;
+        for (const sel of selections) {
+            const replaced = this.expandSelection(sel);
+            if (replaced) {
+                out.push(...replaced);
+                changed = true;
+            }
+            else {
+                out.push(sel);
+            }
+        }
+        return changed ? out : selections;
+    }
+    expandSelection(sel) {
+        const inner = sel.selection;
+        if (SelectAllNode.is(inner)) {
+            return this.expandStar(this.findOwnerMeta(undefined), undefined, undefined);
+        }
+        if (!ReferenceNode.is(inner)) {
+            return null;
+        }
+        const table = inner.table;
+        const tableName = table ? this.getTableName(table) : undefined;
+        const meta = this.findOwnerMeta(tableName);
+        if (!meta) {
+            return null;
+        }
+        if (SelectAllNode.is(inner.column)) {
+            return this.expandStar(meta, table, tableName);
+        }
+        const fieldName = inner.column.column.name;
+        const prop = this.findProperty(meta, fieldName);
+        const ct = prop && this.fieldType(prop, fieldName);
+        return ct?.convertToJSValueSQL ? [this.wrapRead(ct, fieldName, tableName)] : null;
+    }
+    expandStar(meta, table, tableName) {
+        if (!meta || !meta.props.some(p => p.hasConvertToJSValueSQL)) {
+            return null;
+        }
+        const out = [];
+        for (const prop of meta.props) {
+            if (prop.persist === false || !prop.fieldNames?.length || !EXPANDABLE_KINDS.has(prop.kind)) {
+                continue;
+            }
+            for (const fieldName of prop.fieldNames) {
+                const ct = this.fieldType(prop, fieldName);
+                out.push(ct?.convertToJSValueSQL
+                    ? this.wrapRead(ct, fieldName, tableName)
+                    : SelectionNode.create(table ? ReferenceNode.create(ColumnNode.create(fieldName), table) : ColumnNode.create(fieldName)));
+            }
+        }
+        return out;
+    }
+    wrapRead(customType, fieldName, tableName) {
+        const key = this.#platform.quoteIdentifier(tableName ? `${tableName}.${fieldName}` : fieldName);
+        const sql = customType.convertToJSValueSQL(key, this.#platform);
+        return SelectionNode.create(AliasNode.create(RawNode.createWithSql(sql), IdentifierNode.create(fieldName)));
+    }
+    wrapWrite(prop, fieldName, valueNode) {
+        if (!prop?.hasConvertToDatabaseValueSQL || !fieldName || valueNode.value == null || isRaw(valueNode.value)) {
+            return valueNode;
+        }
+        const customType = this.fieldType(prop, fieldName);
+        if (!customType?.convertToDatabaseValueSQL) {
+            return valueNode;
+        }
+        const fragments = customType.convertToDatabaseValueSQL('?', this.#platform).split('?');
+        return RawNode.create(fragments, fragments.slice(0, -1).map(() => valueNode));
+    }
+    /** Resolve the customType for a specific field name (handles composite-PK FK fan-out via prop.customTypes[]). */
+    fieldType(prop, fieldName) {
+        return prop.customType ?? prop.customTypes?.[prop.fieldNames.indexOf(fieldName)];
+    }
+    findOwnerMeta(name) {
+        if (name) {
+            return this.lookupInContextStack(name) ?? this.#subqueryAliasMap.get(name) ?? this.findEntityMetadata(name);
+        }
+        let single;
+        for (const meta of this.#contextStack[this.#contextStack.length - 1].values()) {
+            if (!meta) {
+                continue;
+            }
+            if (single && single !== meta) {
+                return undefined;
+            }
+            single = meta;
+        }
+        return single;
+    }
     mapColumnsToProperties(columns, meta) {
         return columns.map(column => {
             const columnName = this.normalizeColumnName(column.column);
@@ -466,9 +578,6 @@ export class MikroTransformer extends OperationNodeTransformer {
         }
         return meta.props.find(prop => prop.fieldNames?.includes(columnName));
     }
-    shouldConvertValues() {
-        return !!this.#options.convertValues;
-    }
     prepareInputValue(prop, value, enabled) {
         if (!enabled || !prop || value == null) {
             return value;

package/query/CriteriaNode.d.ts

@@ -21,7 +21,7 @@ export declare class CriteriaNode<T extends object> implements ICriteriaNode<T>
     shouldInline(payload: any): boolean;
     willAutoJoin(qb: IQueryBuilder<T>, alias?: string, options?: ICriteriaNodeProcessOptions): boolean;
     shouldRename(payload: any): boolean;
-    renameFieldToPK<T>(qb: IQueryBuilder<T>, ownerAlias?: string): string;
+    renameFieldToPK<T>(qb: IQueryBuilder<T>, ownerAlias?: string, options?: ICriteriaNodeProcessOptions): string;
     getPath(opts?: {
         addIndex?: boolean;
         parentPath?: string;

package/query/CriteriaNode.js

@@ -83,8 +83,8 @@ export class CriteriaNode {
                 return false;
         }
     }
-    renameFieldToPK(qb, ownerAlias) {
-        const joinAlias = qb.getAliasForJoinPath(this.getPath(), { matchPopulateJoins: true });
+    renameFieldToPK(qb, ownerAlias, options) {
+        const joinAlias = qb.getAliasForJoinPath(this.getPath(), { ...options, matchPopulateJoins: true });
         if (!joinAlias &&
             this.parent &&
             [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(this.prop.kind) &&

package/query/ObjectCriteriaNode.js

@@ -105,7 +105,7 @@ export class ObjectCriteriaNode extends CriteriaNode {
                 this.inlineChildPayload(o, payload, field, a, childAlias);
             }
             else if (childNode.shouldRename(payload)) {
-                this.inlineCondition(childNode.renameFieldToPK(qb, alias), o, payload);
+                this.inlineCondition(childNode.renameFieldToPK(qb, alias, options), o, payload);
             }
             else if (isRawField) {
                 const rawField = RawQueryFragment.getKnownFragment(field);

package/query/QueryBuilder.d.ts

@@ -1,4 +1,4 @@
-import { type AnyEntity, type AutoPath, type Collection, type ConnectionType, type Dictionary, type EntityData, type EntityDTOFlat, type EntityDTOProp, type EntityKey, type EntityManager, EntityMetadata, type EntityName, type EntityProperty, type ExpandProperty, type FilterObject, type FilterOptions, type FilterValue, type FlushMode, type GroupOperator, type Loaded, LockMode, type LoggingOptions, type MetadataStorage, type PrimaryProperty, type ObjectQuery, PopulateHint, type PopulateOptions, type PopulatePath, QueryFlag, type QueryOrderKeysFlat, type QueryOrderMap, type QueryResult, RawQueryFragment, type Raw, type RequiredEntityData, type Scalar, type SerializeDTO, type Subquery, type Transaction } from '@mikro-orm/core';
+import { type AbortQueryOptions, type AnyEntity, type AutoPath, type Collection, type ConnectionType, type Dictionary, type EntityData, type EntityDTOFlat, type EntityDTOProp, type EntityKey, type EntityManager, EntityMetadata, type EntityName, type EntityProperty, type ExpandProperty, type FilterObject, type FilterOptions, type FilterValue, type FlushMode, type GroupOperator, type Loaded, LockMode, type LoggingOptions, type MetadataStorage, type PrimaryProperty, type ObjectQuery, PopulateHint, type PopulateOptions, type PopulatePath, QueryFlag, type QueryOrderKeysFlat, type QueryOrderMap, type QueryResult, RawQueryFragment, type Raw, type RequiredEntityData, type Scalar, type SerializeDTO, type Subquery, type Transaction } from '@mikro-orm/core';
 import { JoinType, QueryType } from './enums.js';
 import type { AbstractSqlDriver } from '../AbstractSqlDriver.js';
 import { type Alias, type OnConflictClause, QueryBuilderHelper } from './QueryBuilderHelper.js';
@@ -11,6 +11,20 @@ export interface ExecuteOptions {
     mergeResults?: boolean;
 }
 export interface QBStreamOptions {
+    /**
+     * How many rows to fetch in one round-trip.
+     * Lower values will result in more queries and network bandwidth, but less memory usage.
+     * Higher values will result in fewer queries and network bandwidth, but higher memory usage.
+     * Note that the results are iterated one row at a time regardless of this value.
+     *
+     * Honored on PostgreSQL (cursor-based fetch), MSSQL (tedious stream chunk size)
+     * and Oracle (mapped to `fetchArraySize`). Ignored on MySQL, MariaDB, SQLite and
+     * libSQL, where the underlying driver already streams row-by-row with no batching
+     * knob.
+     *
+     * @default 100 on dialects that honor it.
+     */
+    chunkSize?: number;
     /**
      * Results are mapped to entities, if you set `mapResults: false` you will get POJOs instead.
      *
@@ -193,6 +207,11 @@ export interface QBState<Entity extends object> {
     })[];
     tptJoinsApplied: boolean;
     autoJoinedPaths: string[];
+    partitionLimit?: {
+        partitionBy: string;
+        limit: number;
+        offset?: number;
+    };
 }
 /**
  * SQL query builder with fluent interface.
@@ -675,6 +694,12 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
     setFlag(flag: QueryFlag): this;
     unsetFlag(flag: QueryFlag): this;
     hasFlag(flag: QueryFlag): boolean;
+    /** @internal */
+    setPartitionLimit(opts: {
+        partitionBy: string;
+        limit: number;
+        offset?: number;
+    }): this;
     cache(config?: boolean | number | [string, number]): this;
     /**
      * Adds index hint to the FROM clause.
@@ -890,6 +915,11 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
      * Gets logger context for this query builder.
      */
     getLoggerContext<T extends Dictionary & LoggingOptions = Dictionary>(): T;
+    /**
+     * Configures cancellation behavior for this query builder. The signal is forwarded to the
+     * underlying database client; see {@apilink AbortQueryOptions} for the available strategies.
+     */
+    setAbortOptions(options: AbortQueryOptions | undefined): void;
     private fromVirtual;
     /**
      * Adds a join from a property object. Used internally for TPT joins where the property
@@ -952,6 +982,17 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
     private processNestedJoins;
     private hasToManyJoins;
     protected wrapPaginateSubQuery(meta: EntityMetadata): void;
+    /**
+     * Wraps the inner query (which has ROW_NUMBER in SELECT) with an outer query
+     * that filters by the __rn column to apply per-parent limiting.
+     */
+    protected wrapPartitionLimitSubQuery(innerQb: NativeQueryBuilder): NativeQueryBuilder;
+    /**
+     * Adds ROW_NUMBER() OVER (PARTITION BY ...) to the SELECT list and prepares
+     * the query state for per-parent limiting. The actual wrapping into a subquery
+     * with __rn filtering happens in getNativeQuery().
+     */
+    protected preparePartitionLimit(): void;
     /**
      * Computes the set of populate paths from the _populate hints.
      */