ts-prorm-orm 1.1.0 → 1.2.1

package/dist/schema/schema-differ.d.ts

@@ -0,0 +1,114 @@
+/**
+ * Schema Differ
+ * Compares model definitions against database schema to detect changes
+ */
+import type { ModelStatic } from '../types';
+import type { Dialect } from '../dialects/dialect';
+import type { SchemaDiff, ColumnChange, IndexChange, ConstraintChange, ForeignKeyChange, ColumnDefinition, DatabaseColumnInfo, DatabaseIndexInfo, DatabaseConstraintInfo, DatabaseForeignKeyInfo, SchemaDifferOptions } from './types';
+/**
+ * SchemaDiffer compares model definitions against database schema
+ */
+export declare class SchemaDiffer {
+    private dialect;
+    private options;
+    constructor(dialect: Dialect, options?: SchemaDifferOptions);
+    /**
+     * Compare a model against its database table
+     */
+    diffModel(model: ModelStatic<any>): Promise<SchemaDiff>;
+    /**
+     * Diff all models registered with Prorm
+     */
+    diffAll(): Promise<SchemaDiff[]>;
+    /**
+     * Get column changes between model and database
+     */
+    getColumnChanges(modelColumns: ColumnDefinition[], dbColumns: DatabaseColumnInfo[]): ColumnChange[];
+    /**
+     * Get index changes between model and database
+     */
+    getIndexChanges(modelIndexes: {
+        name: string;
+        unique: boolean;
+        fields: string[];
+    }[], dbIndexes: DatabaseIndexInfo[]): IndexChange[];
+    /**
+     * Get constraint changes between model and database
+     */
+    getConstraintChanges(modelConstraints: {
+        name: string;
+        type: string;
+        fields: string[];
+    }[], dbConstraints: DatabaseConstraintInfo[]): ConstraintChange[];
+    /**
+     * Get foreign key changes between model and database
+     */
+    getForeignKeyChanges(modelFKs: {
+        name: string;
+        fields: string[];
+        references: {
+            table: string;
+            fields: string[];
+        };
+    }[], dbFKs: DatabaseForeignKeyInfo[]): ForeignKeyChange[];
+    /**
+     * Extract column definitions from model
+     */
+    private extractColumnDefinitions;
+    /**
+     * Extract index definitions from model
+     */
+    private extractIndexDefinitions;
+    /**
+     * Extract constraint definitions from model
+     */
+    private extractConstraintDefinitions;
+    /**
+     * Extract foreign key definitions from model
+     */
+    private extractForeignKeyDefinitions;
+    /**
+     * Get database column information
+     */
+    private getDatabaseColumns;
+    /**
+     * Get database index information
+     */
+    private getDatabaseIndexes;
+    /**
+     * Get database constraint information
+     */
+    private getDatabaseConstraints;
+    /**
+     * Get database foreign key information
+     */
+    private getDatabaseForeignKeys;
+    /**
+     * Serialize DataType to string for comparison
+     */
+    private serializeDataType;
+    /**
+     * Compare column definitions and return list of changed properties
+     */
+    private compareColumnDefinitions;
+    /**
+     * Compare index definitions and return list of changed properties
+     */
+    private compareIndexDefinitions;
+    /**
+     * Compare constraint definitions and return list of changed properties
+     */
+    private compareConstraintDefinitions;
+    /**
+     * Compare foreign key definitions and return list of changed properties
+     */
+    private compareForeignKeyDefinitions;
+    /**
+     * Normalize type string for comparison
+     */
+    private normalizeType;
+}
+/**
+ * Create a SchemaDiffer instance
+ */
+export declare function createSchemaDiffer(dialect: Dialect, options?: SchemaDifferOptions): SchemaDiffer;

package/dist/schema/types.d.ts

@@ -0,0 +1,246 @@
+/**
+ * Schema Diff Types
+ * Type definitions for automated schema diffing and migration generation
+ */
+import type { DataType } from '../types';
+/**
+ * Type of change detected in schema diff
+ */
+export type ChangeType = 'create' | 'modify' | 'delete';
+/**
+ * Column change details
+ */
+export interface ColumnChange {
+    type: 'column';
+    changeType: ChangeType;
+    columnName: string;
+    /** Column definition from model (for create/modify) */
+    modelDefinition?: ColumnDefinition;
+    /** Column definition from database (for modify/delete) */
+    databaseDefinition?: DatabaseColumnInfo;
+    /** Specific properties that changed */
+    changedProperties?: string[];
+}
+/**
+ * Index change details
+ */
+export interface IndexChange {
+    type: 'index';
+    changeType: ChangeType;
+    indexName: string;
+    /** Index definition from model (for create/modify) */
+    modelDefinition?: IndexDefinition;
+    /** Index definition from database (for modify/delete) */
+    databaseDefinition?: DatabaseIndexInfo;
+    /** Specific properties that changed */
+    changedProperties?: string[];
+}
+/**
+ * Constraint change details
+ */
+export interface ConstraintChange {
+    type: 'constraint';
+    changeType: ChangeType;
+    constraintName: string;
+    constraintType: 'PRIMARY KEY' | 'UNIQUE' | 'CHECK';
+    /** Constraint definition from model (for create/modify) */
+    modelDefinition?: ConstraintDefinition;
+    /** Constraint definition from database (for modify/delete) */
+    databaseDefinition?: DatabaseConstraintInfo;
+    /** Specific properties that changed */
+    changedProperties?: string[];
+}
+/**
+ * Foreign key change details
+ */
+export interface ForeignKeyChange {
+    type: 'foreignKey';
+    changeType: ChangeType;
+    constraintName: string;
+    /** Foreign key definition from model (for create/modify) */
+    modelDefinition?: ForeignKeyDefinition;
+    /** Foreign key definition from database (for modify/delete) */
+    databaseDefinition?: DatabaseForeignKeyInfo;
+    /** Specific properties that changed */
+    changedProperties?: string[];
+}
+/**
+ * Table change details containing all changes for a single table
+ */
+export interface TableChange {
+    tableName: string;
+    schemaName?: string;
+    columnChanges: ColumnChange[];
+    indexChanges: IndexChange[];
+    constraintChanges: ConstraintChange[];
+    foreignKeyChanges: ForeignKeyChange[];
+    /** Whether the table is new (created) */
+    isNew: boolean;
+    /** Whether the table was deleted */
+    isDeleted: boolean;
+}
+/**
+ * Complete schema diff result
+ */
+export interface SchemaDiff {
+    /** Name of the model this diff is for */
+    modelName: string;
+    /** Database table name */
+    tableName: string;
+    /** Optional schema name */
+    schemaName?: string;
+    /** All detected changes */
+    changes: {
+        columns: ColumnChange[];
+        indexes: IndexChange[];
+        constraints: ConstraintChange[];
+        foreignKeys: ForeignKeyChange[];
+    };
+    /** Whether there are any changes */
+    hasChanges: boolean;
+    /** Timestamp when diff was generated */
+    generatedAt: Date;
+}
+/**
+ * Column definition extracted from model
+ */
+export interface ColumnDefinition {
+    name: string;
+    type: DataType;
+    typeString: string;
+    allowNull: boolean;
+    defaultValue: any;
+    primaryKey: boolean;
+    autoIncrement: boolean;
+    unique: boolean | string;
+    references?: {
+        model: string;
+        key: string;
+        deferrable?: string;
+        onDelete?: string;
+        onUpdate?: string;
+    };
+    comment?: string;
+    field?: string;
+}
+/**
+ * Index definition extracted from model
+ */
+export interface IndexDefinition {
+    name: string;
+    unique: boolean;
+    type?: string;
+    fields: string[];
+    where?: Record<string, any>;
+    using?: string;
+}
+/**
+ * Constraint definition extracted from model
+ */
+export interface ConstraintDefinition {
+    name: string;
+    type: 'PRIMARY KEY' | 'UNIQUE' | 'CHECK';
+    fields: string[];
+    check?: string;
+}
+/**
+ * Foreign key definition extracted from model
+ */
+export interface ForeignKeyDefinition {
+    name: string;
+    fields: string[];
+    references: {
+        table: string;
+        fields: string[];
+        onDelete?: string;
+        onUpdate?: string;
+    };
+}
+/**
+ * Column information from database (via describeTable)
+ */
+export interface DatabaseColumnInfo {
+    name: string;
+    type: string;
+    allowNull: boolean;
+    defaultValue: any;
+    primaryKey: boolean;
+    autoIncrement: boolean;
+}
+/**
+ * Index information from database (via showIndexes)
+ */
+export interface DatabaseIndexInfo {
+    name: string;
+    unique: boolean;
+    type?: string;
+    fields: string[];
+    primary: boolean;
+}
+/**
+ * Constraint information from database (via showConstraints)
+ */
+export interface DatabaseConstraintInfo {
+    name: string;
+    type: 'PRIMARY KEY' | 'UNIQUE' | 'CHECK';
+    fields?: string[];
+    check?: string;
+}
+/**
+ * Foreign key information from database
+ */
+export interface DatabaseForeignKeyInfo {
+    name: string;
+    fields: string[];
+    references: {
+        table: string;
+        fields: string[];
+    };
+    onDelete?: string;
+    onUpdate?: string;
+}
+/**
+ * Migration script generated from schema diff
+ */
+export interface MigrationScript {
+    /** Migration name */
+    name: string;
+    /** Up migration SQL statements */
+    up: string[];
+    /** Down migration SQL statements (for rollback) */
+    down: string[];
+    /** Model name this migration applies to */
+    modelName: string;
+    /** Table name */
+    tableName: string;
+    /** Timestamp when generated */
+    generatedAt: Date;
+}
+/**
+ * Options for migration generation
+ */
+export interface MigrationGeneratorOptions {
+    /** Custom migration name prefix */
+    namePrefix?: string;
+    /** Whether to generate rollback statements */
+    generateDown?: boolean;
+    /** Whether to include comments in generated SQL */
+    includeComments?: boolean;
+    /** Dialect-specific options */
+    dialectOptions?: Record<string, any>;
+}
+/**
+ * Options for schema differ
+ */
+export interface SchemaDifferOptions {
+    /** Whether to compare indexes */
+    compareIndexes?: boolean;
+    /** Whether to compare constraints */
+    compareConstraints?: boolean;
+    /** Whether to compare foreign keys */
+    compareForeignKeys?: boolean;
+    /** Custom column type serializer */
+    serializeColumnType?: (type: DataType) => string;
+    /** Skip certain column properties when comparing */
+    skipColumnProperties?: string[];
+}

package/dist/schema-objects.d.ts

@@ -0,0 +1,78 @@
+/**
+ * SQL generation for the schema objects that had no ORM-level API.
+ *
+ * Sequences, stored procedures, SQL functions, triggers, row-level security and
+ * full-text indexes previously had to be created by hand through
+ * `prorm.query()` with a template literal - the README's own per-dialect
+ * walkthroughs did exactly that, twelve times, in a library whose stated goal is
+ * that the user never writes SQL. These builders back the corresponding
+ * `QueryInterface` methods.
+ *
+ * Every builder is dialect-aware and throws a clear error when the target
+ * database has no equivalent, rather than emitting SQL that fails at the driver.
+ */
+export type SqlDialectName = 'mysql' | 'mariadb' | 'postgres' | 'cockroachdb' | 'redshift' | 'sqlite' | 'mssql' | 'oracle' | 'db2' | 'snowflake' | 'duckdb' | 'hana' | 'spanner' | string;
+/** Raised when a schema object has no equivalent on the target dialect. */
+export declare class UnsupportedSchemaObjectError extends Error {
+    constructor(object: string, dialect: string, hint?: string);
+}
+export interface SequenceOptions {
+    /** Value the sequence starts at (default 1) */
+    start?: number;
+    /** Amount added on each call (default 1) */
+    increment?: number;
+    /** Minimum value */
+    minValue?: number;
+    /** Maximum value */
+    maxValue?: number;
+    /** Wrap around when the max/min is reached */
+    cycle?: boolean;
+    /** Number of values to pre-allocate (Oracle/Postgres CACHE) */
+    cache?: number;
+    /** Emit IF NOT EXISTS where supported */
+    ifNotExists?: boolean;
+}
+export declare function buildCreateSequenceSQL(name: string, options: SequenceOptions, dialect: SqlDialectName, quoteId: (id: string) => string): string;
+export declare function buildDropSequenceSQL(name: string, dialect: SqlDialectName, quoteId: (id: string) => string, ifExists?: boolean): string;
+export interface PolicyOptions {
+    /** Table the policy applies to */
+    table: string;
+    /** Policy name */
+    name: string;
+    /** USING expression - rows visible to the command */
+    using?: string;
+    /** WITH CHECK expression - rows the command may write */
+    withCheck?: string;
+    /** Command the policy applies to */
+    for?: 'ALL' | 'SELECT' | 'INSERT' | 'UPDATE' | 'DELETE';
+    /** Roles the policy applies to */
+    to?: string[];
+}
+export declare function buildEnableRowLevelSecuritySQL(table: string, dialect: SqlDialectName, quoteTable: (t: string) => string, enable?: boolean): string;
+export declare function buildCreatePolicySQL(options: PolicyOptions, dialect: SqlDialectName, quoteId: (id: string) => string, quoteTable: (t: string) => string): string;
+export declare function buildDropPolicySQL(name: string, table: string, dialect: SqlDialectName, quoteId: (id: string) => string, quoteTable: (t: string) => string, ifExists?: boolean): string;
+export interface FullTextIndexOptions {
+    /** Index name */
+    name: string;
+    /** Table to index */
+    table: string;
+    /** Columns to include in the index */
+    columns: string[];
+    /** Text search configuration (PostgreSQL), e.g. 'english' */
+    language?: string;
+}
+export declare function buildCreateFullTextIndexSQL(options: FullTextIndexOptions, dialect: SqlDialectName, quoteId: (id: string) => string, quoteTable: (t: string) => string): string;
+export interface TriggerDefinition {
+    name: string;
+    table: string;
+    timing: 'BEFORE' | 'AFTER' | 'INSTEAD OF';
+    event: 'INSERT' | 'UPDATE' | 'DELETE';
+    /** Statement body (without BEGIN/END for simple single-statement triggers) */
+    body: string;
+    /** Row- vs statement-level (defaults to row) */
+    forEach?: 'ROW' | 'STATEMENT';
+    /** Condition guarding the trigger */
+    when?: string;
+}
+export declare function buildCreateTriggerStatements(trigger: TriggerDefinition, dialect: SqlDialectName, quoteId: (id: string) => string, quoteTable: (t: string) => string): string[];
+export declare function buildDropTriggerSQL(name: string, table: string, dialect: SqlDialectName, quoteId: (id: string) => string, quoteTable: (t: string) => string, ifExists?: boolean): string;

package/dist/schema-objects.js

@@ -0,0 +1,203 @@
+"use strict";
+/**
+ * SQL generation for the schema objects that had no ORM-level API.
+ *
+ * Sequences, stored procedures, SQL functions, triggers, row-level security and
+ * full-text indexes previously had to be created by hand through
+ * `prorm.query()` with a template literal - the README's own per-dialect
+ * walkthroughs did exactly that, twelve times, in a library whose stated goal is
+ * that the user never writes SQL. These builders back the corresponding
+ * `QueryInterface` methods.
+ *
+ * Every builder is dialect-aware and throws a clear error when the target
+ * database has no equivalent, rather than emitting SQL that fails at the driver.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnsupportedSchemaObjectError = void 0;
+exports.buildCreateSequenceSQL = buildCreateSequenceSQL;
+exports.buildDropSequenceSQL = buildDropSequenceSQL;
+exports.buildEnableRowLevelSecuritySQL = buildEnableRowLevelSecuritySQL;
+exports.buildCreatePolicySQL = buildCreatePolicySQL;
+exports.buildDropPolicySQL = buildDropPolicySQL;
+exports.buildCreateFullTextIndexSQL = buildCreateFullTextIndexSQL;
+exports.buildCreateTriggerStatements = buildCreateTriggerStatements;
+exports.buildDropTriggerSQL = buildDropTriggerSQL;
+// Derived dialects report their own `name` (TimescaleDBDialect extends
+// PostgresDialect but calls itself 'timescaledb'), so family membership has to
+// be listed explicitly rather than inferred from the class hierarchy.
+//
+// Membership here means "shares this family's DDL syntax for the objects in this
+// module", which is narrower than "extends that dialect class". Trino, CrateDB,
+// QuestDB, Exasol, Vertica, Firebird and Databricks all extend a Postgres or
+// MySQL dialect in this codebase but genuinely lack sequences and/or triggers,
+// so they are deliberately left out - an UnsupportedSchemaObjectError naming the
+// database is more useful than SQL the driver rejects.
+const POSTGRES_FAMILY = new Set(['postgres', 'cockroachdb', 'redshift', 'greenplum', 'timescaledb']);
+const MYSQL_FAMILY = new Set(['mysql', 'mariadb', 'tidb', 'singlestore']);
+// Turso/libSQL is SQLite over the wire - same FTS5, same trigger syntax, same
+// lack of sequences.
+const SQLITE_FAMILY = new Set(['sqlite', 'turso']);
+function isPostgresFamily(d) {
+    return POSTGRES_FAMILY.has(d);
+}
+function isMysqlFamily(d) {
+    return MYSQL_FAMILY.has(d);
+}
+function isSqliteFamily(d) {
+    return SQLITE_FAMILY.has(d);
+}
+/** Raised when a schema object has no equivalent on the target dialect. */
+class UnsupportedSchemaObjectError extends Error {
+    constructor(object, dialect, hint) {
+        super(`${object} is not supported on ${dialect}${hint ? `. ${hint}` : ''}`);
+        this.name = 'UnsupportedSchemaObjectError';
+    }
+}
+exports.UnsupportedSchemaObjectError = UnsupportedSchemaObjectError;
+function buildCreateSequenceSQL(name, options, dialect, quoteId) {
+    if (isSqliteFamily(dialect)) {
+        throw new UnsupportedSchemaObjectError('CREATE SEQUENCE', dialect, 'SQLite has no sequences - use an INTEGER PRIMARY KEY AUTOINCREMENT column instead.');
+    }
+    const parts = ['CREATE SEQUENCE'];
+    // MySQL/MariaDB: MariaDB 10.3+ supports sequences; MySQL does not.
+    if (dialect === 'mysql') {
+        throw new UnsupportedSchemaObjectError('CREATE SEQUENCE', dialect, 'MySQL has no sequences - use an AUTO_INCREMENT column instead.');
+    }
+    if (options.ifNotExists && (isPostgresFamily(dialect) || dialect === 'mariadb')) {
+        parts.push('IF NOT EXISTS');
+    }
+    parts.push(quoteId(name));
+    if (options.start !== undefined) {
+        parts.push(dialect === 'oracle' ? `START WITH ${options.start}` : `START WITH ${options.start}`);
+    }
+    if (options.increment !== undefined) {
+        parts.push(`INCREMENT BY ${options.increment}`);
+    }
+    if (options.minValue !== undefined)
+        parts.push(`MINVALUE ${options.minValue}`);
+    if (options.maxValue !== undefined)
+        parts.push(`MAXVALUE ${options.maxValue}`);
+    if (options.cache !== undefined && dialect !== 'mssql')
+        parts.push(`CACHE ${options.cache}`);
+    if (options.cycle)
+        parts.push('CYCLE');
+    return parts.join(' ');
+}
+function buildDropSequenceSQL(name, dialect, quoteId, ifExists = true) {
+    if (isSqliteFamily(dialect) || dialect === 'mysql') {
+        throw new UnsupportedSchemaObjectError('DROP SEQUENCE', dialect);
+    }
+    // Oracle has no IF EXISTS on DROP SEQUENCE.
+    const guard = ifExists && dialect !== 'oracle' ? 'IF EXISTS ' : '';
+    return `DROP SEQUENCE ${guard}${quoteId(name)}`;
+}
+function buildEnableRowLevelSecuritySQL(table, dialect, quoteTable, enable = true) {
+    if (!isPostgresFamily(dialect)) {
+        throw new UnsupportedSchemaObjectError('Row-level security', dialect, dialect === 'mssql'
+            ? 'SQL Server uses CREATE SECURITY POLICY with a predicate function instead.'
+            : undefined);
+    }
+    return `ALTER TABLE ${quoteTable(table)} ${enable ? 'ENABLE' : 'DISABLE'} ROW LEVEL SECURITY`;
+}
+function buildCreatePolicySQL(options, dialect, quoteId, quoteTable) {
+    if (!isPostgresFamily(dialect)) {
+        throw new UnsupportedSchemaObjectError('CREATE POLICY', dialect);
+    }
+    let sql = `CREATE POLICY ${quoteId(options.name)} ON ${quoteTable(options.table)}`;
+    if (options.for && options.for !== 'ALL')
+        sql += ` FOR ${options.for}`;
+    if (options.to?.length)
+        sql += ` TO ${options.to.map(quoteId).join(', ')}`;
+    if (options.using)
+        sql += ` USING (${options.using})`;
+    if (options.withCheck)
+        sql += ` WITH CHECK (${options.withCheck})`;
+    return sql;
+}
+function buildDropPolicySQL(name, table, dialect, quoteId, quoteTable, ifExists = true) {
+    if (!isPostgresFamily(dialect)) {
+        throw new UnsupportedSchemaObjectError('DROP POLICY', dialect);
+    }
+    return `DROP POLICY ${ifExists ? 'IF EXISTS ' : ''}${quoteId(name)} ON ${quoteTable(table)}`;
+}
+function buildCreateFullTextIndexSQL(options, dialect, quoteId, quoteTable) {
+    const { name, table, columns, language = 'english' } = options;
+    if (!columns.length) {
+        throw new Error('A full-text index requires at least one column');
+    }
+    if (isPostgresFamily(dialect)) {
+        // to_tsvector over the concatenated columns, coalesced so a NULL column
+        // doesn't null the whole expression.
+        const expr = columns.map((c) => `coalesce(${quoteId(c)}, '')`).join(" || ' ' || ");
+        return `CREATE INDEX ${quoteId(name)} ON ${quoteTable(table)} USING GIN (to_tsvector('${language}', ${expr}))`;
+    }
+    if (isMysqlFamily(dialect)) {
+        return `CREATE FULLTEXT INDEX ${quoteId(name)} ON ${quoteTable(table)} (${columns.map(quoteId).join(', ')})`;
+    }
+    if (isSqliteFamily(dialect)) {
+        // SQLite full-text search is a virtual table, not an index.
+        return `CREATE VIRTUAL TABLE IF NOT EXISTS ${quoteId(name)} USING fts5(${columns
+            .map(quoteId)
+            .join(', ')}, content=${quoteId(table)})`;
+    }
+    if (dialect === 'mssql') {
+        throw new UnsupportedSchemaObjectError('Full-text index', dialect, 'SQL Server requires a full-text catalog and a unique key index; create those first, then use CREATE FULLTEXT INDEX.');
+    }
+    throw new UnsupportedSchemaObjectError('Full-text index', dialect);
+}
+function buildCreateTriggerStatements(trigger, dialect, quoteId, quoteTable) {
+    const { name, table, timing, event, body, forEach = 'ROW', when } = trigger;
+    if (isPostgresFamily(dialect)) {
+        // PostgreSQL triggers call a function; emit both statements.
+        const fnName = `${name}_fn`;
+        const fn = `CREATE OR REPLACE FUNCTION ${quoteId(fnName)}() RETURNS TRIGGER AS $$\n` +
+            `BEGIN\n${body}\nEND;\n$$ LANGUAGE plpgsql`;
+        let trg = `CREATE TRIGGER ${quoteId(name)} ${timing} ${event} ON ${quoteTable(table)} FOR EACH ${forEach}`;
+        if (when)
+            trg += ` WHEN (${when})`;
+        trg += ` EXECUTE FUNCTION ${quoteId(fnName)}()`;
+        return [fn, trg];
+    }
+    if (isMysqlFamily(dialect)) {
+        let sql = `CREATE TRIGGER ${quoteId(name)} ${timing} ${event} ON ${quoteTable(table)} FOR EACH ROW`;
+        sql += `\nBEGIN\n${body}\nEND`;
+        return [sql];
+    }
+    if (isSqliteFamily(dialect)) {
+        // SQLite is always row-level and has no FOR EACH STATEMENT.
+        let sql = `CREATE TRIGGER IF NOT EXISTS ${quoteId(name)} ${timing} ${event} ON ${quoteTable(table)}`;
+        if (when)
+            sql += ` WHEN ${when}`;
+        sql += `\nBEGIN\n${body}\nEND`;
+        return [sql];
+    }
+    if (dialect === 'mssql') {
+        const msTiming = timing === 'BEFORE' ? 'INSTEAD OF' : timing;
+        return [
+            `CREATE TRIGGER ${quoteId(name)} ON ${quoteTable(table)} ${msTiming} ${event}\nAS\nBEGIN\n${body}\nEND`,
+        ];
+    }
+    if (dialect === 'oracle') {
+        let sql = `CREATE OR REPLACE TRIGGER ${quoteId(name)} ${timing} ${event} ON ${quoteTable(table)}`;
+        if (forEach === 'ROW')
+            sql += ' FOR EACH ROW';
+        if (when)
+            sql += ` WHEN (${when})`;
+        sql += `\nBEGIN\n${body}\nEND;`;
+        return [sql];
+    }
+    throw new UnsupportedSchemaObjectError('CREATE TRIGGER', dialect);
+}
+function buildDropTriggerSQL(name, table, dialect, quoteId, quoteTable, ifExists = true) {
+    const guard = ifExists ? 'IF EXISTS ' : '';
+    if (isMysqlFamily(dialect) || isSqliteFamily(dialect)) {
+        return `DROP TRIGGER ${guard}${quoteId(name)}`;
+    }
+    if (isPostgresFamily(dialect)) {
+        return `DROP TRIGGER ${guard}${quoteId(name)} ON ${quoteTable(table)}`;
+    }
+    if (dialect === 'mssql' || dialect === 'oracle') {
+        return `DROP TRIGGER ${quoteId(name)}`;
+    }
+    throw new UnsupportedSchemaObjectError('DROP TRIGGER', dialect);
+}