@mikro-orm/sql 7.1.0-dev.3 → 7.1.0-dev.31

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,8 +105,10 @@ 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);
         }
     }
     createTable(table, alter) {
@@ -140,6 +147,9 @@ export class SqliteSchemaHelper extends SchemaHelper {
         for (const index of table.getIndexes()) {
             this.append(ret, this.createIndex(index, table));
         }
+        for (const trigger of table.getTriggers()) {
+            this.append(ret, this.createTrigger(table, trigger));
+        }
         return ret;
     }
     createTableColumn(column, table, _changedProperties) {
@@ -159,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);
@@ -211,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 = {};
@@ -285,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,
@@ -295,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,
             };
         });
     }
@@ -321,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);
@@ -350,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({
@@ -362,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);
@@ -501,8 +536,102 @@ export class SqliteSchemaHelper extends SchemaHelper {
                 this.append(ret, this.getRenameIndexSQL(diff.name, index, oldIndexName));
             }
         }
+        for (const trigger of Object.values(diff.removedTriggers)) {
+            this.append(ret, this.dropTrigger(diff.toTable, trigger));
+        }
+        for (const trigger of Object.values(diff.changedTriggers)) {
+            this.append(ret, this.dropTrigger(diff.toTable, trigger));
+            this.append(ret, this.createTrigger(diff.toTable, trigger));
+        }
+        for (const trigger of Object.values(diff.addedTriggers)) {
+            this.append(ret, this.createTrigger(diff.toTable, trigger));
+        }
         return ret;
     }
+    /** Generates SQL to create SQLite triggers. SQLite requires one trigger per event. */
+    createTrigger(table, trigger) {
+        if (trigger.expression) {
+            return trigger.expression;
+        }
+        const timing = trigger.timing.toUpperCase();
+        const forEach = trigger.forEach === 'statement' ? 'STATEMENT' : 'ROW';
+        const ret = [];
+        for (const event of trigger.events) {
+            const name = trigger.events.length > 1 ? `${trigger.name}_${event}` : trigger.name;
+            const when = trigger.when ? `\n  when ${trigger.when}` : '';
+            ret.push(`create trigger ${this.quote(name)} ${timing} ${event.toUpperCase()} on ${table.getQuotedName()} for each ${forEach}${when} begin ${trigger.body}; end`);
+        }
+        return ret.join(';\n');
+    }
+    async getTableTriggers(connection, tableName) {
+        const rows = await connection.execute(`select name, sql from sqlite_master where type = 'trigger' and tbl_name = ?`, [tableName]);
+        // First pass: parse all triggers and collect names to detect multi-event groups
+        const parsedRows = [];
+        for (const row of rows) {
+            /* v8 ignore next 3 */
+            if (!row.sql) {
+                continue;
+            }
+            const parsed = this.parseTriggerDDL(row.sql, row.name);
+            if (parsed) {
+                parsedRows.push({ name: row.name, parsed });
+            }
+        }
+        const allNames = parsedRows.map(r => r.name);
+        const triggers = [];
+        const triggerMap = new Map();
+        for (const { name, parsed } of parsedRows) {
+            // Only strip event suffix when another trigger with the same base exists
+            const eventLower = parsed.events[0];
+            const candidateBase = name.endsWith(`_${eventLower}`) ? name.slice(0, -eventLower.length - 1) : null;
+            const baseName = candidateBase && allNames.some(n => n !== name && n.startsWith(`${candidateBase}_`)) ? candidateBase : name;
+            if (triggerMap.has(baseName)) {
+                const existing = triggerMap.get(baseName);
+                if (!existing.events.includes(parsed.events[0])) {
+                    existing.events.push(parsed.events[0]);
+                }
+                continue;
+            }
+            const trigger = { ...parsed, name: baseName };
+            triggers.push(trigger);
+            triggerMap.set(baseName, trigger);
+        }
+        return triggers;
+    }
+    parseTriggerDDL(sql, name) {
+        // Split at the last top-level BEGIN to separate header from body,
+        // so that a WHEN clause containing the word "begin" in a string literal doesn't confuse parsing.
+        const beginIdx = sql.search(/\bbegin\b(?=[^]*$)/i);
+        /* v8 ignore next 3 */
+        if (beginIdx === -1) {
+            return null;
+        }
+        const header = sql.slice(0, beginIdx);
+        const bodyPart = sql.slice(beginIdx);
+        const headerMatch = /create\s+trigger\s+["`]?\w+["`]?\s+(before|after|instead\s+of)\s+(insert|update|delete)\s+on\s+["`]?\w+["`]?\s*(?:for\s+each\s+(row|statement))?\s*(?:when\s+([\s\S]*?))?\s*$/i.exec(header);
+        /* v8 ignore next 3 */
+        if (!headerMatch) {
+            return null;
+        }
+        const bodyMatch = /^begin\s+([\s\S]*?)\s*end/i.exec(bodyPart);
+        /* v8 ignore next 3 */
+        if (!bodyMatch) {
+            return null;
+        }
+        const timing = headerMatch[1].toLowerCase();
+        const event = headerMatch[2].toLowerCase();
+        const forEach = (headerMatch[3]?.toLowerCase() ?? 'row');
+        const when = headerMatch[4]?.trim() || undefined;
+        const body = bodyMatch[1].trim().replace(/;\s*$/, '');
+        return {
+            name,
+            timing,
+            events: [event],
+            forEach,
+            body,
+            when,
+        };
+    }
     getAlterTempTableSQL(changedTable) {
         const tempName = `${changedTable.toTable.name}__temp_alter`;
         const quotedName = this.quote(changedTable.toTable.name);

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.3",
+  "version": "7.1.0-dev.31",
   "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.0"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^7.0.11"
+    "@mikro-orm/core": "^7.0.15"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.1.0-dev.3"
+    "@mikro-orm/core": "7.1.0-dev.31"
   },
   "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

@@ -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.
@@ -952,6 +977,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.
      */