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

package/schema/DatabaseTable.js

@@ -10,10 +10,15 @@ export class DatabaseTable {
     #indexes = [];
     #checks = [];
     #triggers = [];
+    #policies = [];
     #foreignKeys = {};
     #platform;
     nativeEnums = {}; // for postgres
     comment;
+    /** Whether row level security is enabled on the table (postgres only). */
+    rlsEnabled = false;
+    /** Whether row level security is also enforced for the table owner (postgres `force`). */
+    rlsForced = false;
     partitioning;
     /**
      * Effective collation the column defaults to when no explicit `COLLATE` is set on a column.
@@ -55,6 +60,17 @@ export class DatabaseTable {
     getTriggers() {
         return this.#triggers;
     }
+    getPolicies() {
+        return this.#policies;
+    }
+    /** `[]` and `['public']` both mean PUBLIC — a single predicate so metadata, introspection and codegen agree. */
+    static isDefaultPolicyRoles(roles) {
+        return roles.length === 0 || (roles.length === 1 && roles[0] === 'public');
+    }
+    /** @internal */
+    setPolicies(policies) {
+        this.#policies = policies;
+    }
     /** @internal */
     setIndexes(indexes) {
         this.#indexes = indexes;
@@ -219,6 +235,8 @@ export class DatabaseTable {
                 skippedColumnNames.includes(index.columnNames[0]) || // Non-composite indexes for skipped columns are to be mapped as entity decorators.
                 index.deferMode ||
                 index.expression ||
+                index.where ||
+                this.hasAdvancedIndexOptions(index) ||
                 !(index.columnNames[0] in columnFks)) && // Trivial non-composite indexes for scalar props are to be mapped to the column.
             // ignore indexes that don't have all column names (this can happen in sqlite where there is no way to infer this for expressions)
             !(index.columnNames.some(col => !col) && !index.expression));
@@ -254,14 +272,7 @@ export class DatabaseTable {
                 }
             }
             // An index is trivial if it has no special options that require entity-level declaration
-            const hasAdvancedOptions = index.columns?.length ||
-                index.include?.length ||
-                index.fillFactor ||
-                index.type ||
-                index.invisible ||
-                index.disabled ||
-                index.clustered;
-            const isTrivial = !index.deferMode && !index.expression && !index.where && !hasAdvancedOptions;
+            const isTrivial = !index.deferMode && !index.expression && !index.where && !this.hasAdvancedIndexOptions(index);
             if (isTrivial) {
                 // Index is for FK. Map to the FK prop and move on.
                 const fkForIndex = fkIndexes.get(index);
@@ -299,6 +310,19 @@ export class DatabaseTable {
             }
             schema.addIndex(ret);
         }
+        for (const check of this.getChecks()) {
+            // skip checks that were consumed by enum conversion — the enum property recreates an
+            // equivalent check under the conventional name during discovery (only on platforms that
+            // emulate enums via check constraints; mysql/mariadb enums are native and recreate nothing)
+            const enumItems = check.columnName ? this.getColumn(check.columnName)?.enumItems : undefined;
+            if (this.#platform.usesEnumCheckConstraints() &&
+                enumItems?.length &&
+                (check.expression === this.#platform.getEnumCheckConstraintExpression(check.columnName, enumItems) ||
+                    check.name === this.#platform.getIndexName(this.name, [check.columnName], 'check'))) {
+                continue;
+            }
+            schema.meta.checks.push({ name: check.name, expression: check.expression });
+        }
         const addedStandaloneFkPropsBasedOnColumn = new Set();
         const nonSkippedColumns = this.getColumns().filter(column => !skippedColumnNames.includes(column.name));
         for (const column of nonSkippedColumns) {
@@ -507,7 +531,9 @@ export class DatabaseTable {
     findFkIndex(currentFk) {
         const fkColumnsLength = currentFk.columnNames.length;
         const possibleIndexes = this.#indexes.filter(index => {
-            return (index.columnNames.length === fkColumnsLength &&
+            return (!index.where &&
+                !this.hasAdvancedIndexOptions(index) &&
+                index.columnNames.length === fkColumnsLength &&
                 !currentFk.columnNames.some((columnName, i) => index.columnNames[i] !== columnName));
         });
         possibleIndexes.sort((a, b) => {
@@ -521,13 +547,31 @@ export class DatabaseTable {
         });
         return possibleIndexes.at(0);
     }
+    /** Advanced options require an entity-level declaration, as the property-level `index`/`unique` cannot carry them. */
+    hasAdvancedIndexOptions(index) {
+        return !!(index.columns?.length ||
+            index.include?.length ||
+            index.fillFactor ||
+            index.type ||
+            index.invisible ||
+            index.disabled ||
+            index.clustered);
+    }
     getIndexProperties(index, columnFks, fksOnColumnProps, fksOnStandaloneProps, namingStrategy) {
-        const propBaseNames = new Set();
+        const propBaseNames = new Map();
         const columnNames = index.columnNames;
         const l = columnNames.length;
         if (columnNames.some(col => !col)) {
             return;
         }
+        const addPropBaseName = (baseName, position) => {
+            const positions = propBaseNames.get(baseName);
+            if (positions) {
+                positions.last = position;
+                return;
+            }
+            propBaseNames.set(baseName, { first: position, last: position });
+        };
         for (let i = 0; i < l; ++i) {
             const columnName = columnNames[i];
             // The column is not involved with FKs.
@@ -538,14 +582,14 @@ export class DatabaseTable {
                 }
                 // It has a prop named after it.
                 // Add it and move on.
-                propBaseNames.add(columnName);
+                addPropBaseName(columnName, i);
                 continue;
             }
             // If the prop named after the column has a FK and the FK's columns are a subset of this index,
             // include this prop and move on.
             const columnPropFk = fksOnColumnProps.get(columnName);
             if (columnPropFk && !columnPropFk.columnNames.some(fkColumnName => !columnNames.includes(fkColumnName))) {
-                propBaseNames.add(columnName);
+                addPropBaseName(columnName, i);
                 continue;
             }
             // If there is at least one standalone FK featuring this column,
@@ -557,7 +601,7 @@ export class DatabaseTable {
                     continue;
                 }
                 if (!fk.columnNames.some(fkColumnName => !columnNames.includes(fkColumnName))) {
-                    propBaseNames.add(propName);
+                    addPropBaseName(propName, i);
                     propAdded = true;
                 }
             }
@@ -568,7 +612,10 @@ export class DatabaseTable {
             // Break the whole prop creation.
             return;
         }
-        return Array.from(propBaseNames).map(baseName => this.getPropertyName(namingStrategy, baseName, fksOnColumnProps.get(baseName)));
+        // Props sharing their first column would otherwise follow FK discovery order, so break ties on the last one.
+        return Array.from(propBaseNames)
+            .sort(([, a], [, b]) => a.first - b.first || a.last - b.last)
+            .map(([baseName]) => this.getPropertyName(namingStrategy, baseName, fksOnColumnProps.get(baseName)));
     }
     getSafeBaseNameForFkProp(namingStrategy, currentFk, fks, columnName) {
         if (columnName &&
@@ -639,6 +686,12 @@ export class DatabaseTable {
     hasTrigger(triggerName) {
         return !!this.getTrigger(triggerName);
     }
+    getPolicy(policyName) {
+        return this.#policies.find(p => p.name === policyName);
+    }
+    hasPolicy(policyName) {
+        return !!this.getPolicy(policyName);
+    }
     getPrimaryKey() {
         return this.#indexes.find(i => i.primary);
     }
@@ -694,9 +747,19 @@ export class DatabaseTable {
         const prop = this.getPropertyName(namingStrategy, column.name, fk);
         const persist = !(column.name in columnFks && typeof fk === 'undefined');
         const index = compositeFkIndexes[prop] ||
-            this.#indexes.find(idx => idx.columnNames[0] === column.name && !idx.composite && !idx.unique && !idx.primary);
+            this.#indexes.find(idx => idx.columnNames[0] === column.name &&
+                !idx.composite &&
+                !idx.unique &&
+                !idx.primary &&
+                !idx.where &&
+                !this.hasAdvancedIndexOptions(idx));
         const unique = compositeFkUniques[prop] ||
-            this.#indexes.find(idx => idx.columnNames[0] === column.name && !idx.composite && idx.unique && !idx.primary);
+            this.#indexes.find(idx => idx.columnNames[0] === column.name &&
+                !idx.composite &&
+                idx.unique &&
+                !idx.primary &&
+                !idx.where &&
+                !this.hasAdvancedIndexOptions(idx));
         const kind = this.getReferenceKind(fk, unique);
         const runtimeType = this.getPropertyTypeForColumn(namingStrategy, column, fk);
         const type = fk
@@ -949,6 +1012,9 @@ export class DatabaseTable {
     addTrigger(trigger) {
         this.#triggers.push(trigger);
     }
+    addPolicy(policy) {
+        this.#policies.push(policy);
+    }
     toJSON() {
         const columns = this.#columns;
         // locale-independent comparison so the snapshot is stable across machines
@@ -989,8 +1055,12 @@ export class DatabaseTable {
             // mysql stores decimal defaults padded to scale (`0` → `0.00`); collapse to canonical numeric form
             // so the metadata-side (`0`) and introspection-side (`0.00`) snapshots agree
             let defaultValue = c.default ?? null;
-            if (defaultValue != null && c.mappedType instanceof DecimalType && Number.isFinite(+defaultValue)) {
-                defaultValue = this.#platform.formatDecimal(defaultValue, c.scale).toString();
+            if (defaultValue != null && c.mappedType instanceof DecimalType) {
+                // string defaults like `default: '0.00'` are quoted in metadata, so strip the quotes first
+                const unquoted = defaultValue.replace(/^'(.*)'$/, '$1');
+                if (Number.isFinite(+unquoted)) {
+                    defaultValue = this.#platform.formatDecimal(unquoted, c.scale).toString();
+                }
             }
             const normalized = {
                 name: c.name,
@@ -1078,13 +1148,26 @@ export class DatabaseTable {
             }
             return out;
         };
+        const normalizePolicy = (policy) => {
+            const out = { name: policy.name, command: policy.command, type: policy.type };
+            if (!DatabaseTable.isDefaultPolicyRoles(policy.roles)) {
+                out.roles = [...policy.roles].sort(byString);
+            }
+            for (const field of ['using', 'check']) {
+                if (policy[field]) {
+                    out[field] = policy[field];
+                }
+            }
+            return out;
+        };
         const sortedIndexes = [...this.#indexes].sort((a, b) => byString(a.keyName, b.keyName)).map(normalizeIndex);
         const sortedChecks = [...this.#checks].sort((a, b) => byString(a.name, b.name)).map(normalizeCheck);
         const sortedTriggers = [...this.#triggers].sort((a, b) => byString(a.name, b.name));
+        const sortedPolicies = [...this.#policies].sort((a, b) => byString(a.name, b.name)).map(normalizePolicy);
         const sortedForeignKeys = Object.fromEntries(Object.entries(this.#foreignKeys)
             .sort(([a], [b]) => byString(a, b))
             .map(([k, v]) => [k, normalizeFk(v)]));
-        return {
+        const ret = {
             name: this.name,
             schema: this.schema,
             columns: columnsMapped,
@@ -1097,5 +1180,16 @@ export class DatabaseTable {
             // platforms that can't read comments back (sqlite), where keeping it would flip the snapshot
             comment: supportsComments ? this.comment || null : null,
         };
+        // emit RLS state only when set, so snapshots of non-RLS tables stay byte-for-byte unchanged
+        if (sortedPolicies.length > 0) {
+            ret.policies = sortedPolicies;
+        }
+        if (this.rlsEnabled) {
+            ret.rlsEnabled = true;
+        }
+        if (this.rlsForced) {
+            ret.rlsForced = true;
+        }
+        return ret;
     }
 }

package/schema/SchemaComparator.d.ts

@@ -88,7 +88,10 @@ export declare class SchemaComparator {
      */
     private diffViewExpression;
     private diffTrigger;
+    private diffPolicies;
+    private diffPolicy;
     parseJsonDefault(defaultValue?: string | null): Dictionary | string | null;
+    private parseDecimalDefault;
     hasSameDefaultValue(from: Column, to: Column): boolean;
     private mapColumnToProperty;
     private log;

package/schema/SchemaComparator.js

@@ -328,6 +328,7 @@ export class SchemaComparator {
             addedIndexes: {},
             addedChecks: {},
             addedTriggers: {},
+            addedPolicies: {},
             changedColumns: {},
             changedForeignKeys: {},
             changedIndexes: {},
@@ -338,6 +339,7 @@ export class SchemaComparator {
             removedIndexes: {},
             removedChecks: {},
             removedTriggers: {},
+            removedPolicies: {},
             renamedColumns: {},
             renamedIndexes: {},
             fromTable,
@@ -517,6 +519,9 @@ export class SchemaComparator {
                 }
             }
         }
+        if (this.#platform.supportsRowLevelSecurity()) {
+            changes += this.diffPolicies(fromTable, toTable, tableDifferences);
+        }
         const fromForeignKeys = { ...fromTable.getForeignKeys() };
         const toForeignKeys = { ...toTable.getForeignKeys() };
         for (const fromConstraint of Object.values(fromForeignKeys)) {
@@ -820,6 +825,10 @@ export class SchemaComparator {
         if (!!index1.clustered !== !!index2.clustered) {
             return false;
         }
+        // Compare the index access method (e.g. `using gin` on PostgreSQL); unset means the platform default
+        if (this.#helper.getIndexAccessMethod(index1) !== this.#helper.getIndexAccessMethod(index2)) {
+            return false;
+        }
         // Compare WHERE predicate of partial indexes structurally (whitespace/quoting/casing
         // are normalized via the same helper used for check constraints).
         if (this.diffExpression(index1.where ?? '', index2.where ?? '')) {
@@ -897,9 +906,17 @@ export class SchemaComparator {
                 // lookbehind: only strip a real charset introducer, never an underscore inside a literal like 'a_b'
                 ?.replace(/(?<![\w'])_\w+'(.*?)'/g, '$1')
                 .replace(/!=/g, '<>')
-                .replace(/in\s*\((.*?)\)/gi, '= any (array[$1])')
+                // `\b` keeps this from firing inside identifiers like `min(...)`
+                .replace(/\bin\s*\((.*?)\)/gi, '= any (array[$1])')
                 // MySQL normalizes count(*) to count(0)
                 .replace(/\bcount\s*\(\s*0\s*\)/gi, 'count(*)')
+                // multi word type names in casts, the generic `::\w+` below only covers single word ones
+                // the precision is kept, so `timestamptz(3)` and `timestamp(3) with time zone` leave the same residue
+                .replace(/::\s*(?:character\s+varying|bit\s+varying|double\s+precision|(?:timestamp|time)\b(\s*\(\d+\))?(?:\s+with(?:out)?\s+time\s+zone)?)/gi, '$1')
+                // Protect dots inside string literals before the quote strip below, or the alias-prefix normalization
+                // would mangle literal contents — `current_setting('app.tenant')` and `current_setting('req.tenant')`
+                // must not both collapse to `current_settingtenant`
+                .replace(/'([^']*)'/g, (_, inner) => `'${inner.replaceAll('.', '\u0000')}'`)
                 // Remove quotes first so we can process identifiers
                 .replace(/['"`]/g, '')
                 // MySQL adds table/alias prefixes to columns (e.g., a.name or table_name.column vs just column)
@@ -907,12 +924,18 @@ export class SchemaComparator {
                 .replace(/\b\w+\.(\w+)/g, '$1')
                 // Normalize JOIN syntax: inner join -> join (equivalent in SQL)
                 .replace(/\binner\s+join\b/gi, 'join')
+                // PostgreSQL names an unaliased bare function call after the function itself,
+                // so `max(created_at)` comes back as `max(created_at) AS max`
+                // the lookahead skips table function column alias lists like `unnest(a) AS unnest(c)`, which are meaningful
+                .replace(/\b(\w+)\s*\(((?:[^()]|\([^()]*\))*)\)\s+as\s+\1\b(?!\s*\()/gi, '$1($2)')
                 // Remove redundant column aliases like `title AS title` -> `title`
                 .replace(/\b(\w+)\s+as\s+\1\b/gi, '$1')
                 // Remove AS keyword (optional in SQL, MySQL may add/remove it)
                 .replace(/\bas\b/gi, '')
                 // Remove remaining special chars, parentheses, type casts, asterisks, and normalize whitespace
-                .replace(/[()\n[\]*]|::\w+| +/g, '')
+                // tabs and CRs included — the schema generator trims every line before executing the DDL,
+                // so indentation and CRLF endings can never come back from introspection
+                .replace(/[()\n\r\t[\]*]|::\w+| +/g, '')
                 .replace(/anyarray\[(.*)]/gi, '$1')
                 .toLowerCase()
                 // PostgreSQL adds default aliases to aggregate functions (e.g., count(*) AS count)
@@ -949,13 +972,13 @@ export class SchemaComparator {
     }
     diffTrigger(from, to) {
         // Raw DDL expression cannot be meaningfully compared to introspected
-        // trigger metadata, so skip diffing when the metadata side uses it.
-        if (to.expression) {
+        // trigger metadata, so it needs special handling when either side uses it.
+        if (from.expression || to.expression) {
             // Both sides have expression — compare the raw DDL directly
-            if (from.expression) {
+            if (from.expression && to.expression) {
                 return this.diffExpression(from.expression, to.expression);
             }
-            // Only metadata side has expression — the raw DDL cannot be compared to
+            // Only one side has expression — the raw DDL cannot be compared to
             // introspected metadata. Changes to the expression value won't be detected;
             // drop and recreate the trigger manually to apply expression changes.
             return false;
@@ -971,6 +994,87 @@ export class SchemaComparator {
         }
         return this.diffExpression(from.body, to.body);
     }
+    diffPolicies(fromTable, toTable, diff) {
+        let changes = 0;
+        // `ignorePolicies` makes RLS create-only: declared policies are still added and RLS is still enabled/forced,
+        // but existing policies are never diffed for drop/alter and RLS is never disabled or unforced — this protects
+        // hand-written policies on databases that adopted RLS before the ORM managed it
+        const ignorePolicies = this.#platform.getConfig().get('schemaGenerator').ignorePolicies;
+        // postgres rejects `alter column ... type` on a column referenced by any policy, so a type change forces us to
+        // drop every still-present policy around the alter (dropped before via `getRlsDropSQL`, recreated after via
+        // `getRlsAlterSQL`) even when the policy itself is otherwise unchanged; a `generated`-only change is emitted
+        // as a drop + re-add of the same column, which a policy's column dependency blocks the same way
+        const hasColumnTypeChange = Object.values(diff.changedColumns).some(c => c.changedProperties.has('type')) ||
+            Object.keys(diff.removedColumns).some(name => name in diff.addedColumns);
+        for (const policy of toTable.getPolicies()) {
+            if (!fromTable.hasPolicy(policy.name)) {
+                diff.addedPolicies[policy.name] = policy;
+                this.log(`policy ${policy.name} added to table ${diff.name}`, { policy });
+                changes++;
+            }
+        }
+        if (fromTable.rlsEnabled !== toTable.rlsEnabled && (!ignorePolicies || toTable.rlsEnabled)) {
+            diff.changedRlsEnabled = toTable.rlsEnabled;
+            changes++;
+        }
+        if (fromTable.rlsForced !== toTable.rlsForced && (!ignorePolicies || toTable.rlsForced)) {
+            diff.changedRlsForced = toTable.rlsForced;
+            changes++;
+        }
+        if (ignorePolicies) {
+            // existing policies are unmanaged here, but a type change still needs them dropped and recreated for the
+            // alter to succeed — recreate each verbatim from introspection so the hand-written definition is preserved
+            if (hasColumnTypeChange) {
+                for (const policy of fromTable.getPolicies()) {
+                    diff.removedPolicies[policy.name] = policy;
+                    diff.addedPolicies[policy.name] = policy;
+                    changes += 2;
+                }
+            }
+            return changes;
+        }
+        for (const policy of fromTable.getPolicies()) {
+            const toPolicy = toTable.getPolicy(policy.name);
+            if (!toPolicy) {
+                diff.removedPolicies[policy.name] = policy;
+                this.log(`policy ${policy.name} removed from table ${diff.name}`);
+                changes++;
+                continue;
+            }
+            // changed policies are always dropped (before column drops, which the old expression can block via its
+            // column dependencies) and recreated (after column adds) — postgres could alter some of the changes in
+            // place, but not a policy's command or type, nor unset an expression
+            if (this.diffPolicy(policy, toPolicy)) {
+                diff.removedPolicies[policy.name] = policy;
+                diff.addedPolicies[policy.name] = toPolicy;
+                this.log(`policy ${policy.name} recreated in table ${diff.name}`, { from: policy, to: toPolicy });
+                changes += 2;
+                continue;
+            }
+            // an unchanged policy still blocks a type change on any column, so drop + recreate it around the alter
+            if (hasColumnTypeChange) {
+                diff.removedPolicies[policy.name] = policy;
+                diff.addedPolicies[policy.name] = toPolicy;
+                this.log(`policy ${policy.name} recreated around a column type change in table ${diff.name}`);
+                changes += 2;
+            }
+        }
+        return changes;
+    }
+    diffPolicy(from, to) {
+        // normalize so an omitted `roles` matches introspected `{public}`
+        const normalizeRoles = (roles) => DatabaseTable.isDefaultPolicyRoles(roles) ? '' : [...roles].sort().join(',');
+        if (from.command !== to.command || from.type !== to.type) {
+            return true;
+        }
+        if (normalizeRoles(from.roles) !== normalizeRoles(to.roles)) {
+            return true;
+        }
+        if (this.diffExpression(from.using ?? '', to.using ?? '')) {
+            return true;
+        }
+        return this.diffExpression(from.check ?? '', to.check ?? '');
+    }
     parseJsonDefault(defaultValue) {
         /* v8 ignore next */
         if (!defaultValue) {
@@ -979,6 +1083,10 @@ export class SchemaComparator {
         const val = defaultValue.replace(/^(_\w+\\)?'(.*?)\\?'$/, '$2').replace(/^\(?'(.*?)'\)?$/, '$1');
         return parseJsonSafe(val);
     }
+    parseDecimalDefault(defaultValue) {
+        const value = +('' + defaultValue).replace(/^'(.+)'$/, '$1');
+        return Number.isFinite(value) ? value : null;
+    }
     hasSameDefaultValue(from, to) {
         if (from.default == null ||
             from.default.toString().toLowerCase() === 'null' ||
@@ -1004,10 +1112,15 @@ export class SchemaComparator {
             const defaultValueTo = to.default.toLowerCase().replace('current_timestamp', 'now').replace(/\(\)$/, '');
             return defaultValueFrom === defaultValueTo;
         }
-        // mysql stores decimal defaults padded to scale (`0` → `0.00`); compare numerically so the
-        // entity-side raw literal and the introspected padded form don't churn the no-op migration
-        if (to.mappedType instanceof DecimalType && Number.isFinite(+from.default) && Number.isFinite(+to.default)) {
-            return (this.#platform.formatDecimal(from.default, to.scale) === this.#platform.formatDecimal(to.default, to.scale));
+        // mysql pads decimal defaults to scale (`0` → `0.00`) and postgres reports them unquoted
+        // while metadata keeps them quoted; compare numerically so neither churns a no-op migration
+        if (to.mappedType instanceof DecimalType) {
+            const defaultValueFrom = this.parseDecimalDefault(from.default);
+            const defaultValueTo = this.parseDecimalDefault(to.default);
+            if (defaultValueFrom != null && defaultValueTo != null) {
+                return (this.#platform.formatDecimal(defaultValueFrom, to.scale) ===
+                    this.#platform.formatDecimal(defaultValueTo, to.scale));
+            }
         }
         if (from.default && to.default) {
             return from.default.toString().toLowerCase() === to.default.toString().toLowerCase();

package/schema/SchemaHelper.d.ts

@@ -4,7 +4,13 @@ import type { AbstractSqlPlatform } from '../AbstractSqlPlatform.js';
 import type { CheckDef, Column, ForeignKey, IndexDef, Table, TableDifference, SqlTriggerDef, SqlRoutineDef } from '../typings.js';
 import type { DatabaseSchema } from './DatabaseSchema.js';
 import type { DatabaseTable } from './DatabaseTable.js';
-/** 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 declare function stripStatementNewlines(body: string): string;
 /**
  * Strips SQL line comments and blank lines from a view definition. Comments are dropped by the
@@ -64,6 +70,13 @@ export declare abstract class SchemaHelper {
      * Hook for adding driver-specific index options (e.g., fill factor for PostgreSQL).
      */
     protected getCreateIndexSuffix(_index: IndexDef): string;
+    /**
+     * 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: IndexDef): string;
+    /** Emits the access method between the table name and the column list (e.g. ` using gin`). */
+    protected getIndexAccessMethodClause(index: IndexDef): string;
     /**
      * 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
@@ -118,6 +131,8 @@ export declare abstract class SchemaHelper {
     getAddColumnsSQL(table: DatabaseTable, columns: Column[]): string[];
     getDropColumnsSQL(tableName: string, columns: Column[], schemaName?: string): string;
     hasNonDefaultPrimaryKeyName(table: DatabaseTable): boolean;
+    /** Returns the `constraint <name> ` prefix for a primary key definition, empty when the server assigns the default name on its own. */
+    protected getPrimaryKeyConstraintPrefix(table: DatabaseTable, index: IndexDef): string;
     castColumn(name: string, type: string): string;
     alterTableColumn(column: Column, table: DatabaseTable, changedProperties: Set<string>): string[];
     /** Returns the bare `collate <name>` clause for column DDL. Overridden by PostgreSQL to quote the identifier. */
@@ -137,6 +152,14 @@ export declare abstract class SchemaHelper {
         }[];
     }[], safe: boolean): string[];
     getChangeColumnCommentSQL(tableName: string, to: Column, schemaName?: string): string;
+    /** Whether the column comment is part of the column declaration, as opposed to a separate statement. */
+    protected hasInlineColumnComment(): boolean;
+    /** Row level security DDL for a freshly created table (enable/force + create policies). Postgres only. */
+    getRlsCreateSQL(table: DatabaseTable): string[];
+    /** 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: TableDifference, safe?: boolean): string[];
+    /** Row level security DDL for a table difference (enable/disable/force transitions + policy creation). Postgres only. */
+    getRlsAlterSQL(diff: TableDifference, safe?: boolean): string[];
     getNamespaces(connection: AbstractSqlConnection, ctx?: Transaction): Promise<string[]>;
     protected mapIndexes(indexes: IndexDef[]): Promise<IndexDef[]>;
     mapForeignKeys(fks: any[], tableName: string, schemaName?: string): Dictionary;
@@ -176,6 +199,8 @@ export declare abstract class SchemaHelper {
     createRoutine(_routine: SqlRoutineDef): string;
     dropRoutine(_routine: SqlRoutineDef): string;
     getAllRoutines(_connection: AbstractSqlConnection, _schemas?: string[]): Promise<SqlRoutineDef[]>;
+    /** Flattens internal `;\n` so the statement splitter doesn't tear the DDL, and ensures exactly one trailing `;` for the enclosing `begin ... end` block. */
+    protected normalizeTriggerBody(body: string): string;
     /** 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. */
     protected wrapRoutineBody(body: string): string;
     protected stripRoutineBody(body: string): string;