@mikro-orm/sql 7.1.0-dev.1 → 7.1.0-dev.11

package/dialects/postgresql/PostgreSqlSchemaHelper.d.ts

@@ -1,7 +1,7 @@
 import { type Dictionary, type Transaction } from '@mikro-orm/core';
 import { SchemaHelper } from '../../schema/SchemaHelper.js';
 import type { AbstractSqlConnection } from '../../AbstractSqlConnection.js';
-import type { CheckDef, Column, ForeignKey, IndexDef, Table, TableDifference } from '../../typings.js';
+import type { CheckDef, Column, ForeignKey, IndexDef, Table, TableDifference, SqlTriggerDef } from '../../typings.js';
 import type { DatabaseSchema } from '../../schema/DatabaseSchema.js';
 import type { DatabaseTable } from '../../schema/DatabaseTable.js';
 export declare class PostgreSqlSchemaHelper extends SchemaHelper {
@@ -49,6 +49,13 @@ export declare class PostgreSqlSchemaHelper extends SchemaHelper {
         items: string[];
     }>, ctx?: Transaction): Promise<Dictionary<Column[]>>;
     getAllChecks(connection: AbstractSqlConnection, tablesBySchemas: Map<string | undefined, Table[]>, ctx?: Transaction): Promise<Dictionary<CheckDef[]>>;
+    /** Generates SQL to create a PostgreSQL trigger and its associated function. */
+    createTrigger(table: DatabaseTable, trigger: SqlTriggerDef): string;
+    /** Generates SQL to drop a PostgreSQL trigger and its associated function. */
+    dropTrigger(table: DatabaseTable, trigger: SqlTriggerDef): string;
+    private getSchemaQualifiedTriggerFnName;
+    getAllTriggers(connection: AbstractSqlConnection, tablesBySchemas: Map<string | undefined, Table[]>): Promise<Dictionary<SqlTriggerDef[]>>;
+    private getTriggersSQL;
     getAllForeignKeys(connection: AbstractSqlConnection, tablesBySchemas: Map<string | undefined, Table[]>, ctx?: Transaction): Promise<Dictionary<Dictionary<ForeignKey>>>;
     getNativeEnumDefinitions(connection: AbstractSqlConnection, schemas: string[], ctx?: Transaction): Promise<Dictionary<{
         name: string;

package/dialects/postgresql/PostgreSqlSchemaHelper.js

@@ -118,6 +118,7 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
         const indexes = await this.getAllIndexes(connection, tables, ctx);
         const checks = await this.getAllChecks(connection, tablesBySchema, ctx);
         const fks = await this.getAllForeignKeys(connection, tablesBySchema, ctx);
+        const triggers = await this.getAllTriggers(connection, tablesBySchema);
         for (const t of tables) {
             const key = this.getTableKey(t);
             const table = schema.addTable(t.table_name, t.schema_name, t.table_comment);
@@ -126,6 +127,9 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
             if (columns[key]) {
                 table.init(columns[key], indexes[key], checks[key], pks, fks[key], enums);
             }
+            if (triggers[key]) {
+                table.setTriggers(triggers[key]);
+            }
         }
     }
     async getAllIndexes(connection, tables, ctx) {
@@ -375,6 +379,95 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
         }
         return ret;
     }
+    /** Generates SQL to create a PostgreSQL trigger and its associated function. */
+    createTrigger(table, trigger) {
+        if (trigger.expression) {
+            return trigger.expression;
+        }
+        const timing = trigger.timing.toUpperCase();
+        const events = trigger.events.map(e => e.toUpperCase()).join(' OR ');
+        const forEach = trigger.forEach === 'statement' ? 'STATEMENT' : 'ROW';
+        const when = trigger.when ? `\n  when (${trigger.when})` : '';
+        const fnName = this.getSchemaQualifiedTriggerFnName(table, trigger);
+        const triggerName = this.platform.quoteIdentifier(trigger.name);
+        const fnSql = `create or replace function ${fnName}() returns trigger as $$ begin ${trigger.body}; end; $$ language plpgsql`;
+        const triggerSql = `create trigger ${triggerName} ${timing} ${events} on ${table.getQuotedName()} for each ${forEach}${when} execute function ${fnName}()`;
+        return `${fnSql};\n${triggerSql}`;
+    }
+    /** Generates SQL to drop a PostgreSQL trigger and its associated function. */
+    dropTrigger(table, trigger) {
+        const triggerName = this.platform.quoteIdentifier(trigger.name);
+        const fnName = this.getSchemaQualifiedTriggerFnName(table, trigger);
+        return `drop trigger if exists ${triggerName} on ${table.getQuotedName()};\ndrop function if exists ${fnName}()`;
+    }
+    getSchemaQualifiedTriggerFnName(table, trigger) {
+        const rawName = `${table.name}_${trigger.name}_fn`;
+        const defaultSchema = this.platform.getDefaultSchemaName();
+        if (table.schema && table.schema !== defaultSchema) {
+            return `${this.platform.quoteIdentifier(table.schema)}.${this.platform.quoteIdentifier(rawName)}`;
+        }
+        return this.platform.quoteIdentifier(rawName);
+    }
+    async getAllTriggers(connection, tablesBySchemas) {
+        const sql = this.getTriggersSQL(tablesBySchemas);
+        const allTriggers = await connection.execute(sql);
+        const ret = {};
+        const triggerMap = new Map();
+        for (const row of allTriggers) {
+            const key = this.getTableKey(row);
+            const dedupeKey = `${key}:${row.trigger_name}`;
+            if (triggerMap.has(dedupeKey)) {
+                // Same trigger with multiple events — merge events
+                const existing = triggerMap.get(dedupeKey);
+                const event = row.event.toLowerCase();
+                if (!existing.events.includes(event)) {
+                    existing.events.push(event);
+                }
+                continue;
+            }
+            ret[key] ??= [];
+            // prosrc includes the full function body between $$ delimiters (e.g. " begin RETURN NEW; end;")
+            // Strip the begin/end wrapper to get just the trigger body for round-trip comparison
+            let body = (row.function_body ?? '').trim();
+            const beginEndMatch = /^\s*begin\s+([\s\S]*?)\s*end;?\s*$/i.exec(body);
+            if (beginEndMatch) {
+                body = beginEndMatch[1].trim().replace(/;\s*$/, '');
+            }
+            const trigger = {
+                name: row.trigger_name,
+                timing: row.timing.toLowerCase(),
+                events: [row.event.toLowerCase()],
+                forEach: row.for_each.toLowerCase(),
+                body,
+                when: row.when_clause ?? undefined,
+            };
+            ret[key].push(trigger);
+            triggerMap.set(dedupeKey, trigger);
+        }
+        return ret;
+    }
+    getTriggersSQL(tablesBySchemas) {
+        const conditions = [];
+        for (const [schema, tables] of tablesBySchemas) {
+            const names = tables.map(t => this.platform.quoteValue(t.table_name)).join(', ');
+            const schemaName = this.platform.quoteValue(schema ?? this.platform.getDefaultSchemaName());
+            conditions.push(`(t.event_object_schema = ${schemaName} and t.event_object_table in (${names}))`);
+        }
+        // Function lookup uses the '{table}_{trigger}_fn' convention from createTrigger().
+        // External triggers with different function names will have NULL body;
+        // use the `expression` escape hatch for those.
+        return `select t.trigger_name, t.event_object_schema as schema_name, t.event_object_table as table_name,
+      t.event_manipulation as event, t.action_timing as timing,
+      t.action_orientation as for_each,
+      t.action_condition as when_clause,
+      pg_get_functiondef(p.oid) as function_def,
+      p.prosrc as function_body
+    from information_schema.triggers t
+    left join pg_namespace n on n.nspname = t.event_object_schema
+    left join pg_proc p on p.proname = t.event_object_table || '_' || t.trigger_name || '_fn' and p.pronamespace = n.oid
+    where (${conditions.join(' or ')})
+    order by t.trigger_name, t.event_manipulation`;
+    }
     async getAllForeignKeys(connection, tablesBySchemas, ctx) {
         const sql = `select nsp1.nspname schema_name, cls1.relname table_name, nsp2.nspname referenced_schema_name,
       cls2.relname referenced_table_name, a.attname column_name, af.attname referenced_column_name, conname constraint_name,

package/dialects/sqlite/SqliteSchemaHelper.d.ts

@@ -1,7 +1,7 @@
 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 {
@@ -64,5 +64,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

@@ -101,7 +101,9 @@ export class SqliteSchemaHelper extends SchemaHelper {
             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 triggers = await this.getTableTriggers(connection, table.name);
             table.init(cols, indexes, checks, pks, fks, enums);
+            table.setTriggers(triggers);
         }
     }
     createTable(table, alter) {
@@ -140,6 +142,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) {
@@ -501,8 +506,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.1",
+  "version": "7.1.0-dev.11",
   "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",
@@ -53,7 +53,7 @@
     "@mikro-orm/core": "^7.0.11"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.1.0-dev.1"
+    "@mikro-orm/core": "7.1.0-dev.11"
   },
   "engines": {
     "node": ">= 22.17.0"

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

@@ -158,6 +158,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 +193,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 +331,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 +680,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 +919,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 +963,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.
      */