@mikro-orm/sql 7.2.0-dev.2 → 7.2.0-dev.20

package/schema/SchemaHelper.js

@@ -1,7 +1,17 @@
 import { isRaw, Utils, } from '@mikro-orm/core';
-/** Flattens `;\n` boundaries so the schema-generator's statement splitter doesn't break the routine DDL apart. Other whitespace is preserved. */
+/**
+ * Flattens `;\n` boundaries and drops blank lines so the schema-generator's statement splitter
+ * doesn't break the routine or trigger DDL apart — it treats both as statement/group separators.
+ * Blank lines go first, otherwise a `;` followed by one would keep its newline. Like
+ * `normalizeViewDefinition`, this is not string-literal aware, so a blank line inside a multi-line
+ * literal is dropped too. Other whitespace is preserved.
+ */
 export function stripStatementNewlines(body) {
-    return body.replace(/;[\t ]*\r?\n/g, '; ');
+    return body
+        .split('\n')
+        .filter(line => line.trim() !== '')
+        .join('\n')
+        .replace(/;[\t ]*\r?\n/g, '; ');
 }
 /**
  * Strips SQL line comments and blank lines from a view definition. Comments are dropped by the
@@ -157,13 +167,14 @@ export class SchemaHelper {
         tableName = this.quote(tableName);
         const keyName = this.quote(index.keyName);
         const defer = index.deferMode ? ` deferrable initially ${index.deferMode}` : '';
-        let sql = `create ${index.unique ? 'unique ' : ''}index ${keyName} on ${tableName}`;
+        const using = this.getIndexAccessMethodClause(index);
+        let sql = `create ${index.unique ? 'unique ' : ''}index ${keyName} on ${tableName}${using}`;
         if (index.unique && index.constraint) {
             sql = `alter table ${tableName} add constraint ${keyName} unique`;
         }
         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
-            sql = `create ${index.unique ? 'unique ' : ''}index ${keyName} on ${tableName}`;
+            sql = `create ${index.unique ? 'unique ' : ''}index ${keyName} on ${tableName}${using}`;
             const columns = this.platform.getJsonIndexDefinition(index);
             return `${sql} (${columns.join(', ')})${this.getCreateIndexSuffix(index)}${this.getIndexWhereClause(index)}${defer}`;
         }
@@ -182,6 +193,18 @@ export class SchemaHelper {
     getCreateIndexSuffix(_index) {
         return '';
     }
+    /**
+     * Normalized index access method (e.g. `gin` on PostgreSQL), empty string when the
+     * platform default applies. Used for both DDL emission and index diffing.
+     */
+    getIndexAccessMethod(_index) {
+        return '';
+    }
+    /** Emits the access method between the table name and the column list (e.g. ` using gin`). */
+    getIndexAccessMethodClause(index) {
+        const method = this.getIndexAccessMethod(index);
+        return method ? ` using ${method}` : '';
+    }
     /**
      * Default emits ` where <predicate>` for partial indexes. Only Oracle overrides this to
      * return `''` (it emulates partials via CASE-WHEN columns). MySQL sidesteps the whole path
@@ -436,7 +459,8 @@ export class SchemaHelper {
             this.append(ret, this.alterTableColumn(column, diff.fromTable, changedProperties));
         }
         for (const { column, changedProperties } of Object.values(diff.changedColumns).filter(diff => diff.changedProperties.has('comment'))) {
-            if (['type', 'nullable', 'autoincrement', 'unsigned', 'default', 'enumItems', 'collation'].some(t => changedProperties.has(t))) {
+            if (this.hasInlineColumnComment() &&
+                ['type', 'nullable', 'autoincrement', 'unsigned', 'default', 'enumItems', 'collation'].some(t => changedProperties.has(t))) {
                 continue; // will be handled via column update
             }
             ret.push(this.getChangeColumnCommentSQL(tableName, column, schemaName));
@@ -480,6 +504,7 @@ export class SchemaHelper {
         if ('changedComment' in diff) {
             ret.push(this.alterTableComment(diff.toTable, diff.changedComment));
         }
+        this.append(ret, this.getRlsAlterSQL(diff, safe));
         return ret;
     }
     /** Returns SQL to add columns to an existing table. */
@@ -489,7 +514,13 @@ export class SchemaHelper {
             return `add ${this.createTableColumn(column, table)}`;
         })
             .join(', ');
-        return [`alter table ${table.getQuotedName()} ${adds}`];
+        const ret = [`alter table ${table.getQuotedName()} ${adds}`];
+        if (!this.hasInlineColumnComment()) {
+            for (const column of columns.filter(column => column.comment)) {
+                ret.push(this.getChangeColumnCommentSQL(table.name, column, table.schema));
+            }
+        }
+        return ret;
     }
     getDropColumnsSQL(tableName, columns, schemaName) {
         const name = this.quote(this.getTableName(tableName, schemaName));
@@ -504,6 +535,10 @@ export class SchemaHelper {
         const defaultName = this.platform.getDefaultPrimaryName(table.name, pkIndex.columnNames);
         return pkIndex?.keyName !== defaultName;
     }
+    /** Returns the `constraint <name> ` prefix for a primary key definition, empty when the server assigns the default name on its own. */
+    getPrimaryKeyConstraintPrefix(table, index) {
+        return this.hasNonDefaultPrimaryKeyName(table) ? `constraint ${this.quote(index.keyName)} ` : '';
+    }
     /* v8 ignore next */
     castColumn(name, type) {
         return '';
@@ -608,6 +643,22 @@ export class SchemaHelper {
     getChangeColumnCommentSQL(tableName, to, schemaName) {
         return '';
     }
+    /** Whether the column comment is part of the column declaration, as opposed to a separate statement. */
+    hasInlineColumnComment() {
+        return false;
+    }
+    /** Row level security DDL for a freshly created table (enable/force + create policies). Postgres only. */
+    getRlsCreateSQL(table) {
+        return [];
+    }
+    /** Drops removed/changed row level security policies; emitted in the pre-alter phase, before any column drop or type alter a policy expression can block. Postgres only. */
+    getRlsDropSQL(diff, safe) {
+        return [];
+    }
+    /** Row level security DDL for a table difference (enable/disable/force transitions + policy creation). Postgres only. */
+    getRlsAlterSQL(diff, safe) {
+        return [];
+    }
     async getNamespaces(connection, ctx) {
         return [];
     }
@@ -745,7 +796,7 @@ export class SchemaHelper {
         const primaryKey = table.getPrimaryKey();
         const createPrimary = !table.getColumns().some(c => c.autoincrement && c.primary) || this.hasNonDefaultPrimaryKeyName(table);
         if (createPrimary && primaryKey) {
-            const name = this.hasNonDefaultPrimaryKeyName(table) ? `constraint ${this.quote(primaryKey.keyName)} ` : '';
+            const name = this.getPrimaryKeyConstraintPrefix(table, primaryKey);
             sql += `, ${name}primary key (${primaryKey.columnNames.map(c => this.quote(c)).join(', ')})`;
         }
         sql += ')';
@@ -763,6 +814,8 @@ export class SchemaHelper {
             for (const trigger of table.getTriggers()) {
                 this.append(ret, this.createTrigger(table, trigger));
             }
+            // RLS policies can reference other tables, so they are deferred until every table exists (see the
+            // callers of getRlsCreateSQL in SqlSchemaGenerator) rather than emitted inline here
         }
         return ret;
     }
@@ -828,7 +881,7 @@ export class SchemaHelper {
         const columns = index.columnNames.map(c => this.quote(c)).join(', ');
         const defer = index.deferMode ? ` deferrable initially ${index.deferMode}` : '';
         if (index.primary) {
-            const keyName = this.hasNonDefaultPrimaryKeyName(table) ? `constraint ${index.keyName} ` : '';
+            const keyName = this.getPrimaryKeyConstraintPrefix(table, index);
             return `alter table ${table.getQuotedName()} add ${keyName}primary key (${columns})${defer}`;
         }
         if (index.type === 'fulltext') {
@@ -861,7 +914,7 @@ export class SchemaHelper {
         const events = trigger.events.map(e => e.toUpperCase()).join(' OR ');
         const forEach = trigger.forEach === 'statement' ? 'STATEMENT' : 'ROW';
         const when = trigger.when ? ` when (${trigger.when})` : '';
-        return `create trigger ${this.quote(trigger.name)} ${timing} ${events} on ${table.getQuotedName()} for each ${forEach}${when} begin ${trigger.body}; end`;
+        return `create trigger ${this.quote(trigger.name)} ${timing} ${events} on ${table.getQuotedName()} for each ${forEach}${when} begin ${this.normalizeTriggerBody(trigger.body)} end`;
     }
     /**
      * Generates SQL to drop a database trigger from a table.
@@ -885,6 +938,11 @@ export class SchemaHelper {
     async getAllRoutines(_connection, _schemas = []) {
         return [];
     }
+    /** Flattens internal `;\n` so the statement splitter doesn't tear the DDL, and ensures exactly one trailing `;` for the enclosing `begin ... end` block. */
+    normalizeTriggerBody(body) {
+        const trimmed = stripStatementNewlines(body).trim();
+        return /;\s*$/.test(trimmed) ? trimmed : `${trimmed};`;
+    }
     /** Wraps the body in `BEGIN ... END` if not already, and flattens internal `;\n` so the schema-generator's statement splitter doesn't tear the DDL. */
     wrapRoutineBody(body) {
         const trimmed = stripStatementNewlines(body).trim();

package/schema/SqlSchemaGenerator.d.ts

@@ -54,6 +54,10 @@ export declare class SqlSchemaGenerator extends AbstractSchemaGenerator<Abstract
         wrap?: boolean;
         ctx?: Transaction;
     }): Promise<void>;
+    /** Splits the SQL on the separator, keeping the separators that fall inside a string literal. */
+    private splitOutsideLiterals;
+    /** Whether the statement has to be the first one in a query batch, e.g. `create trigger` on MSSQL. */
+    protected startsBatch(_statement: string): boolean;
     dropTableIfExists(name: string, schema?: string): Promise<void>;
     private wrapSchema;
     private append;

package/schema/SqlSchemaGenerator.js

@@ -94,6 +94,10 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
                 this.append(ret, fks, true);
             }
         }
+        // RLS policies are deferred until every table exists, so a policy expression can reference another table
+        for (const table of toSchema.getTables()) {
+            this.append(ret, this.helper.getRlsCreateSQL(table));
+        }
         const sortedViews = this.sortViewsByDependencies(toSchema.getViews());
         for (const view of sortedViews) {
             this.appendViewCreation(ret, view);
@@ -308,22 +312,6 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
         for (const newTable of Object.values(schemaDiff.newTables)) {
             this.append(ret, this.helper.createTable(newTable, true), true);
         }
-        if (this.helper.supportsSchemaConstraints()) {
-            for (const newTable of Object.values(schemaDiff.newTables)) {
-                const sql = [];
-                if (this.options.createForeignKeyConstraints) {
-                    const fks = Object.values(newTable.getForeignKeys()).map(fk => this.helper.createForeignKey(newTable, fk));
-                    this.append(sql, fks);
-                }
-                for (const check of newTable.getChecks()) {
-                    this.append(sql, this.helper.createCheck(newTable, check));
-                }
-                for (const trigger of newTable.getTriggers()) {
-                    this.append(sql, this.helper.createTrigger(newTable, trigger));
-                }
-                this.append(ret, sql, true);
-            }
-        }
         if (options.dropTables && !options.safe) {
             for (const table of Object.values(schemaDiff.removedTables)) {
                 // Drop triggers before the table so driver-specific cleanup runs (e.g. PostgreSQL function removal)
@@ -353,6 +341,24 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
         for (const changedTable of alteredTables) {
             this.append(ret, this.helper.getPostAlterTable(changedTable, options.safe), true);
         }
+        // after the alters, so a new table's FK can reference a unique constraint an existing table gains in the same diff
+        if (this.helper.supportsSchemaConstraints()) {
+            for (const newTable of Object.values(schemaDiff.newTables)) {
+                const sql = [];
+                if (this.options.createForeignKeyConstraints) {
+                    const fks = Object.values(newTable.getForeignKeys()).map(fk => this.helper.createForeignKey(newTable, fk));
+                    this.append(sql, fks);
+                }
+                for (const check of newTable.getChecks()) {
+                    this.append(sql, this.helper.createCheck(newTable, check));
+                }
+                for (const trigger of newTable.getTriggers()) {
+                    this.append(sql, this.helper.createTrigger(newTable, trigger));
+                }
+                this.append(sql, this.helper.getRlsCreateSQL(newTable));
+                this.append(ret, sql, true);
+            }
+        }
         if (!options.safe && this.platform.supportsNativeEnums()) {
             for (const removedNativeEnum of schemaDiff.removedNativeEnums) {
                 this.append(ret, this.helper.getDropNativeEnumSQL(removedNativeEnum.name, removedNativeEnum.schema));
@@ -409,6 +415,9 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
     }
     preAlterTable(diff, safe) {
         const ret = [];
+        // removed/changed policies must be dropped before any column type alter, including the pre-alter
+        // uuid-to-text cast on postgres — a policy expression blocks type changes on the columns it references
+        this.append(ret, this.helper.getRlsDropSQL(diff, safe));
         this.append(ret, this.helper.getPreAlterTable(diff, safe));
         for (const foreignKey of Object.values(diff.removedForeignKeys)) {
             ret.push(this.helper.dropForeignKey(diff.toTable.getShortestName(), foreignKey.constraintName));
@@ -439,18 +448,23 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
     }
     async execute(sql, options = {}) {
         options.wrap ??= false;
-        const lines = this.wrapSchema(sql, options).split('\n');
+        const lines = this.splitOutsideLiterals(this.wrapSchema(sql, options), '\n');
         const groups = [];
         let i = 0;
         for (const line of lines) {
-            if (line.trim() === '') {
+            const stmt = line.trim();
+            if (stmt === '') {
                 if (groups[i]?.length > 0) {
                     i++;
                 }
                 continue;
             }
+            // same boundary an empty line creates, for statements that have to start their own batch
+            if (groups[i]?.length > 0 && this.startsBatch(stmt)) {
+                i++;
+            }
             groups[i] ??= [];
-            groups[i].push(line.trim());
+            groups[i].push(stmt);
         }
         if (groups.length === 0) {
             return;
@@ -463,14 +477,37 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
             return;
         }
         const statements = groups.flatMap(group => {
-            return group
-                .join('\n')
-                .split(';\n')
+            return this.splitOutsideLiterals(group.join('\n'), ';\n')
                 .map(s => s.trim())
                 .filter(s => s);
         });
         await Utils.runSerial(statements, stmt => this.driver.execute(stmt));
     }
+    /** Splits the SQL on the separator, keeping the separators that fall inside a string literal. */
+    splitOutsideLiterals(sql, separator) {
+        const [idOpen, idClose] = this.platform.quoteIdentifier('');
+        // mysql escapes quotes as `\'`, the other dialects double them, which pairs up on its own
+        const esc = this.platform.quoteValue(`'`).includes(`\\'`) ? '\\\\.|' : '';
+        // complete literals, quoted identifiers and `--` comments, so that an apostrophe inside an
+        // identifier or a comment is not mistaken for one opening a literal
+        const tokens = new RegExp(`'(?:${esc}[^'])*'|\\${idOpen}[^\\${idClose}]*\\${idClose}|--[^\n]*`, 'g');
+        const parts = [];
+        for (const chunk of sql.split(separator)) {
+            const prev = parts.at(-1);
+            // whatever quote is left once the complete tokens are gone opened a literal we are still inside of
+            if (prev?.replace(tokens, '').includes(`'`)) {
+                parts[parts.length - 1] = prev + separator + chunk;
+            }
+            else {
+                parts.push(chunk);
+            }
+        }
+        return parts;
+    }
+    /** Whether the statement has to be the first one in a query batch, e.g. `create trigger` on MSSQL. */
+    startsBatch(_statement) {
+        return false;
+    }
     async dropTableIfExists(name, schema) {
         const sql = this.helper.dropTableIfExists(name, schema);
         return this.execute(sql);

package/typings.d.ts

@@ -114,6 +114,15 @@ export interface CheckDef<T = unknown> {
     definition?: string;
     columnName?: string;
 }
+/** Resolved row level security policy for schema operations (all callbacks resolved to strings). */
+export interface SqlPolicyDef {
+    name: string;
+    command: 'select' | 'insert' | 'update' | 'delete' | 'all';
+    type: 'permissive' | 'restrictive';
+    roles: string[];
+    using?: string;
+    check?: string;
+}
 /** Resolved trigger definition for schema operations (all callbacks resolved to strings). */
 export interface SqlTriggerDef {
     name: string;
@@ -191,6 +200,13 @@ export interface TableDifference {
     addedTriggers: Dictionary<SqlTriggerDef>;
     changedTriggers: Dictionary<SqlTriggerDef>;
     removedTriggers: Dictionary<SqlTriggerDef>;
+    addedPolicies: Dictionary<SqlPolicyDef>;
+    /** Changed policies surface as `removedPolicies` + `addedPolicies` pairs (drop + recreate). */
+    removedPolicies: Dictionary<SqlPolicyDef>;
+    /** New RLS enable state, present only when it changed. */
+    changedRlsEnabled?: boolean;
+    /** New RLS force state, present only when it changed. */
+    changedRlsForced?: boolean;
     addedForeignKeys: Dictionary<ForeignKey>;
     changedForeignKeys: Dictionary<ForeignKey>;
     removedForeignKeys: Dictionary<ForeignKey>;
@@ -277,6 +293,8 @@ export interface IQueryBuilder<T> {
     with(name: string, query: AnyQueryBuilder | NativeQueryBuilder | RawQueryFragment, options?: CteOptions): this;
     withRecursive(name: string, query: AnyQueryBuilder | NativeQueryBuilder | RawQueryFragment, options?: CteOptions): this;
     scheduleFilterCheck(path: string): void;
+    /** @internal */
+    ensureTPTJoins(): void;
     withSchema(schema: string): this;
 }
 export interface ICriteriaNodeProcessOptions {
@@ -368,9 +386,9 @@ type MaybeGenerated<TValue, TOptions, TProcessOnCreate extends boolean> = TOptio
 } ? TValue | null : TOptions extends {
     autoincrement: true;
 } ? Generated<TValue> : TOptions extends {
-    default: true;
+    default: unknown;
 } ? Generated<TValue> : TOptions extends {
-    defaultRaw: true;
+    defaultRaw: unknown;
 } ? Generated<TValue> : TProcessOnCreate extends false ? TValue : TOptions extends {
     onCreate: Function;
 } ? Generated<TValue> : TValue;