@mikro-orm/sql 7.1.0-dev.2 → 7.1.0-dev.21

package/dialects/sqlite/SqlitePlatform.js

@@ -24,6 +24,10 @@ export class SqlitePlatform extends AbstractSqlPlatform {
     getDateTimeTypeDeclarationSQL(column) {
         return 'datetime';
     }
+    // sqlite's datetime DDL drops precision and the current-ts expression hardcodes ms scaling
+    getDefaultVersionLength() {
+        return 0;
+    }
     getBeginTransactionSQL(options) {
         return ['begin'];
     }

package/dialects/sqlite/SqliteSchemaHelper.d.ts

@@ -1,10 +1,11 @@
 import { type Connection, type Transaction } from '@mikro-orm/core';
 import type { AbstractSqlConnection } from '../../AbstractSqlConnection.js';
 import { SchemaHelper } from '../../schema/SchemaHelper.js';
-import type { Column, IndexDef, Table, TableDifference } from '../../typings.js';
+import type { Column, IndexDef, Table, TableDifference, SqlTriggerDef } from '../../typings.js';
 import type { DatabaseTable } from '../../schema/DatabaseTable.js';
 import type { DatabaseSchema } from '../../schema/DatabaseSchema.js';
 export declare class SqliteSchemaHelper extends SchemaHelper {
+    private static readonly PARTIAL_WHERE_RE;
     disableForeignKeysSQL(): string;
     enableForeignKeysSQL(): string;
     supportsSchemaConstraints(): boolean;
@@ -44,7 +45,8 @@ export declare class SqliteSchemaHelper extends SchemaHelper {
      * We need to add them back so they match what we generate in DDL.
      */
     private wrapExpressionDefault;
-    private getEnumDefinitions;
+    /** Extract enum values from `IN (…)` CHECKs only — a `!= 'x'` check would otherwise be misread as a one-item enum. */
+    private extractEnumValuesFromChecks;
     getPrimaryKeys(connection: AbstractSqlConnection, indexes: IndexDef[], tableName: string, schemaName?: string, ctx?: Transaction): Promise<string[]>;
     private getIndexes;
     private getChecks;
@@ -64,5 +66,9 @@ export declare class SqliteSchemaHelper extends SchemaHelper {
      */
     getReferencedTableName(referencedTableName: string, schema?: string): string;
     alterTable(diff: TableDifference, safe?: boolean): string[];
+    /** Generates SQL to create SQLite triggers. SQLite requires one trigger per event. */
+    createTrigger(table: DatabaseTable, trigger: SqlTriggerDef): string;
+    private getTableTriggers;
+    private parseTriggerDDL;
     private getAlterTempTableSQL;
 }

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;';
     }
@@ -100,8 +101,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 +143,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) {
@@ -211,10 +217,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 = {};
@@ -321,23 +327,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 +356,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 +378,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 +519,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/sql",
-  "version": "7.1.0-dev.2",
+  "version": "7.1.0-dev.21",
   "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",
@@ -50,10 +50,10 @@
     "kysely": "0.28.16"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^7.0.11"
+    "@mikro-orm/core": "^7.0.12"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.1.0-dev.2"
+    "@mikro-orm/core": "7.1.0-dev.21"
   },
   "engines": {
     "node": ">= 22.17.0"

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/NativeQueryBuilder.d.ts

@@ -37,6 +37,11 @@ interface Options {
     limit?: number;
     offset?: number;
     data?: Dictionary;
+    insertSubQuery?: {
+        sql: string;
+        params: unknown[];
+        columns: string[];
+    };
     onConflict?: OnConflictClause;
     lockMode?: LockMode;
     lockTables?: string[];
@@ -105,6 +110,7 @@ export declare class NativeQueryBuilder implements Subquery {
     limit(limit: number): this;
     offset(offset: number): this;
     insert(data: Dictionary): this;
+    insertSelect(columns: string[], subQuery: NativeQueryBuilder | RawQueryFragment): this;
     update(data: Dictionary): this;
     delete(): this;
     truncate(): this;

package/query/NativeQueryBuilder.js

@@ -215,6 +215,12 @@ export class NativeQueryBuilder {
         this.options.data = data;
         return this;
     }
+    insertSelect(columns, subQuery) {
+        this.type = QueryType.INSERT;
+        const { sql, params } = subQuery instanceof NativeQueryBuilder ? subQuery.compile() : { sql: subQuery.sql, params: [...subQuery.params] };
+        this.options.insertSubQuery = { sql, params, columns: columns.map(c => this.quote(c)) };
+        return this;
+    }
     update(data) {
         this.type = QueryType.UPDATE;
         this.options.data ??= {};
@@ -352,12 +358,21 @@ export class NativeQueryBuilder {
         return fields;
     }
     compileInsert() {
-        if (!this.options.data) {
+        if (!this.options.data && !this.options.insertSubQuery) {
             throw new Error('No data provided');
         }
         this.parts.push('insert');
         this.addHintComment();
         this.parts.push(`into ${this.getTableName()}`);
+        if (this.options.insertSubQuery) {
+            if (this.options.insertSubQuery.columns.length) {
+                this.parts.push(`(${this.options.insertSubQuery.columns.join(', ')})`);
+            }
+            this.addOutputClause('inserted');
+            this.parts.push(this.options.insertSubQuery.sql);
+            this.params.push(...this.options.insertSubQuery.params);
+            return;
+        }
         if (Object.keys(this.options.data).length === 0) {
             this.addOutputClause('inserted');
             this.parts.push('default values');

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.
      *
@@ -158,6 +172,8 @@ export interface QBState<Entity extends object> {
     schema?: string;
     cond: Dictionary;
     data?: Dictionary;
+    insertSubQuery?: QueryBuilder<any>;
+    insertColumns?: string[];
     orderBy: QueryOrderMap<Entity>[];
     groupBy: InternalField<Entity>[];
     having: Dictionary;
@@ -191,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.
@@ -324,6 +345,35 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
      * ```
      */
     insert(data: RequiredEntityData<Entity> | RequiredEntityData<Entity>[]): InsertQueryBuilder<Entity, RootAlias, Context>;
+    /**
+     * Creates an INSERT ... SELECT query that copies rows from the source query.
+     *
+     * Column resolution (3 tiers):
+     * 1. No explicit select on source, no explicit columns → all cloneable columns derived from entity metadata
+     * 2. Explicit select on source, no explicit columns → columns derived from selected field names
+     * 3. Explicit `columns` option → user-provided column list
+     *
+     * @example
+     * ```ts
+     * // Clone all fields (columns auto-derived from metadata)
+     * const source = em.createQueryBuilder(User).where({ id: 1 });
+     * await em.createQueryBuilder(User).insertFrom(source).execute();
+     *
+     * // Clone with overrides via raw() aliases
+     * const source = em.createQueryBuilder(User)
+     *   .select(['name', raw("'new@email.com'").as('email')])
+     *   .where({ id: 1 });
+     * await em.createQueryBuilder(User).insertFrom(source).execute();
+     *
+     * // Explicit columns for full control
+     * await em.createQueryBuilder(User)
+     *   .insertFrom(source, { columns: ['name', 'email'] })
+     *   .execute();
+     * ```
+     */
+    insertFrom(subQuery: QueryBuilder<any>, options?: {
+        columns?: Field<Entity, RootAlias, Context>[];
+    }): InsertQueryBuilder<Entity, RootAlias, Context>;
     /**
      * Creates an UPDATE query with the given data.
      * Use `where()` to specify which rows to update.
@@ -644,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.
@@ -877,6 +933,16 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
     protected resolveNestedPath(field: string): string | string[];
     protected init(type: QueryType, data?: any, cond?: any): this;
     private getQueryBase;
+    /**
+     * Resolves the INSERT column list for `insertFrom()`.
+     *
+     * Tier 1: Explicit `insertColumns` from `options.columns` → map property names to field names
+     * Tier 2: Source QB has explicit select fields → derive from those
+     * Tier 3: Derive from target entity metadata (all cloneable columns), auto-populate source select
+     */
+    private resolveInsertFromColumns;
+    /** Returns properties that are safe to clone (persistable, non-PK, non-generated). */
+    private getCloneableProps;
     private applyDiscriminatorCondition;
     /**
      * Ensures TPT joins are applied. Can be called early before finalize() to populate
@@ -911,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.
      */