turbine-orm 0.11.0 → 0.13.0

package/dist/cjs/cli/migrate.js

@@ -33,27 +33,21 @@ const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const pg_1 = __importDefault(require("pg"));
 const index_js_1 = require("../adapters/index.js");
+const dialect_js_1 = require("../dialect.js");
 const errors_js_1 = require("../errors.js");
-const index_js_2 = require("../query/index.js");
 // ---------------------------------------------------------------------------
 // Tracking table management
 // ---------------------------------------------------------------------------
 const TRACKING_TABLE = '_turbine_migrations';
-const QUOTED_TRACKING_TABLE = (0, index_js_2.quoteIdent)(TRACKING_TABLE);
-const CREATE_TRACKING_TABLE = `
-  CREATE TABLE IF NOT EXISTS ${QUOTED_TRACKING_TABLE} (
-    id SERIAL PRIMARY KEY,
-    name TEXT NOT NULL UNIQUE,
-    checksum TEXT NOT NULL,
-    applied_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
-  );
-`;
-async function ensureTrackingTable(client) {
-    await client.query(CREATE_TRACKING_TABLE);
+function quotedTrackingTable(dialect) {
+    return dialect.quoteIdentifier(TRACKING_TABLE);
+}
+async function ensureTrackingTable(client, dialect = dialect_js_1.postgresDialect) {
+    await client.query(dialect.buildMigrationTrackingTable(quotedTrackingTable(dialect)));
 }
-async function getAppliedMigrations(client) {
-    await ensureTrackingTable(client);
-    const result = await client.query(`SELECT id, name, applied_at, checksum FROM ${QUOTED_TRACKING_TABLE} ORDER BY id ASC`);
+async function getAppliedMigrations(client, dialect = dialect_js_1.postgresDialect) {
+    await ensureTrackingTable(client, dialect);
+    const result = await client.query(dialect.buildMigrationSelectApplied(quotedTrackingTable(dialect)));
     return result.rows;
 }
 // ---------------------------------------------------------------------------
@@ -265,8 +259,8 @@ async function releaseLock(client, lockId, adapter) {
  * Validate that applied migration files have not been modified or deleted since they were run.
  * Returns an array of mismatched migrations (empty if all are clean).
  */
-async function validateChecksums(client, migrationsDir) {
-    const applied = await getAppliedMigrations(client);
+async function validateChecksums(client, migrationsDir, dialect = dialect_js_1.postgresDialect) {
+    const applied = await getAppliedMigrations(client, dialect);
     const allFiles = listMigrationFiles(migrationsDir);
     const fileMap = new Map(allFiles.map((f) => [f.name, f]));
     const mismatches = [];
@@ -286,7 +280,7 @@ async function validateChecksums(client, migrationsDir) {
         if (currentHash !== migration.checksum) {
             // Auto-upgrade legacy djb2 checksums to SHA-256 without flagging as modified
             if (isLegacyChecksum(migration.checksum)) {
-                await client.query(`UPDATE ${QUOTED_TRACKING_TABLE} SET checksum = $1 WHERE name = $2`, [
+                await client.query(dialect.buildMigrationUpdateChecksum(quotedTrackingTable(dialect)), [
                     currentHash,
                     migration.name,
                 ]);
@@ -321,6 +315,7 @@ async function migrateUp(connectionString, migrationsDir, options) {
     await client.connect();
     // Treat `force` as an alias for `allowDrift` for backwards compatibility.
     const allowDrift = options?.allowDrift === true || options?.force === true;
+    const dialect = options?.dialect ?? dialect_js_1.postgresDialect;
     try {
         // Derive an advisory lock ID per-database so concurrent migrations in
         // sibling databases on the same Postgres cluster do not contend.
@@ -334,7 +329,7 @@ async function migrateUp(connectionString, migrationsDir, options) {
             throw new errors_js_1.MigrationError('[turbine] Could not acquire migration lock — another migration is already running');
         }
         try {
-            await ensureTrackingTable(client);
+            await ensureTrackingTable(client, dialect);
             // Validate checksums of already-applied migrations.
             // Drift = an APPLIED migration's on-disk file has changed (or been deleted)
             // since it was run. Either situation means the database state and the
@@ -342,7 +337,7 @@ async function migrateUp(connectionString, migrationsDir, options) {
             // Users can pass `allowDrift: true` (CLI: `--allow-drift`) to force past
             // the block when they are intentionally rewriting history.
             if (!allowDrift) {
-                const mismatches = await validateChecksums(client, migrationsDir);
+                const mismatches = await validateChecksums(client, migrationsDir, dialect);
                 if (mismatches.length > 0) {
                     const modified = mismatches.filter((m) => m.type === 'modified');
                     const missing = mismatches.filter((m) => m.type === 'missing');
@@ -366,7 +361,7 @@ async function migrateUp(connectionString, migrationsDir, options) {
                     throw new errors_js_1.MigrationError(lines.join('\n'));
                 }
             }
-            const applied = await getAppliedMigrations(client);
+            const applied = await getAppliedMigrations(client, dialect);
             const appliedNames = new Set(applied.map((m) => m.name));
             const allFiles = listMigrationFiles(migrationsDir);
             let pending = allFiles.filter((f) => !appliedNames.has(f.name));
@@ -386,7 +381,7 @@ async function migrateUp(connectionString, migrationsDir, options) {
                 try {
                     await client.query('BEGIN');
                     await client.query(up);
-                    await client.query(`INSERT INTO ${QUOTED_TRACKING_TABLE} (name, checksum) VALUES ($1, $2) ON CONFLICT (name) DO NOTHING`, [file.name, hash]);
+                    await client.query(dialect.buildMigrationInsertApplied(quotedTrackingTable(dialect)), [file.name, hash]);
                     await client.query('COMMIT');
                     results.push(file);
                 }
@@ -419,6 +414,7 @@ async function migrateUp(connectionString, migrationsDir, options) {
 async function migrateDown(connectionString, migrationsDir, options) {
     const client = new pg_1.default.Client({ connectionString });
     await client.connect();
+    const dialect = options?.dialect ?? dialect_js_1.postgresDialect;
     try {
         // Derive a per-database advisory lock ID so concurrent migrations in
         // sibling databases on the same cluster do not contend.
@@ -430,8 +426,8 @@ async function migrateDown(connectionString, migrationsDir, options) {
             throw new errors_js_1.MigrationError('[turbine] Could not acquire migration lock — another migration is already running');
         }
         try {
-            await ensureTrackingTable(client);
-            const applied = await getAppliedMigrations(client);
+            await ensureTrackingTable(client, dialect);
+            const applied = await getAppliedMigrations(client, dialect);
             if (applied.length === 0) {
                 return { rolledBack: [], errors: [] };
             }
@@ -458,7 +454,7 @@ async function migrateDown(connectionString, migrationsDir, options) {
                 try {
                     await client.query('BEGIN');
                     await client.query(down);
-                    await client.query(`DELETE FROM ${QUOTED_TRACKING_TABLE} WHERE name = $1`, [migration.name]);
+                    await client.query(dialect.buildMigrationDeleteApplied(quotedTrackingTable(dialect)), [migration.name]);
                     await client.query('COMMIT');
                     results.push(file);
                 }
@@ -483,12 +479,13 @@ async function migrateDown(connectionString, migrationsDir, options) {
  * Get the status of all migrations (applied vs pending).
  * Includes checksum validation for applied migrations.
  */
-async function migrateStatus(connectionString, migrationsDir) {
+async function migrateStatus(connectionString, migrationsDir, options) {
     const client = new pg_1.default.Client({ connectionString });
     await client.connect();
+    const dialect = options?.dialect ?? dialect_js_1.postgresDialect;
     try {
-        await ensureTrackingTable(client);
-        const applied = await getAppliedMigrations(client);
+        await ensureTrackingTable(client, dialect);
+        const applied = await getAppliedMigrations(client, dialect);
         const appliedMap = new Map(applied.map((m) => [m.name, m]));
         const allFiles = listMigrationFiles(migrationsDir);
         return allFiles.map((file) => {

package/dist/cjs/dialect.js

@@ -33,6 +33,28 @@ exports.postgresDialect = {
         const suffix = orderBy ? ` ${orderBy}` : '';
         return `COALESCE(json_agg(${jsonObjectExpr}${suffix}), ${this.emptyJsonArrayLiteral})`;
     },
+    buildReturningClause(selection = '*') {
+        return ` RETURNING ${selection}`;
+    },
+    buildInsertStatement(input) {
+        return `INSERT INTO ${input.table} (${input.columns.join(', ')}) VALUES (${input.valuePlaceholders.join(', ')})${this.buildReturningClause(input.returning)}`;
+    },
+    buildBulkInsertStatement(input) {
+        if (!input.columnArrayTypes || input.columnArrayTypes.length !== input.columns.length) {
+            throw new Error('PostgreSQL bulk insert requires one array type per column');
+        }
+        const columnArrays = input.columns.map((_, columnIndex) => input.rowValues.map((row) => row[columnIndex]));
+        const unnestArgs = input.columns.map((_, i) => `${this.paramPlaceholder(i + 1)}::${input.columnArrayTypes[i]}`);
+        let sql = `INSERT INTO ${input.table} (${input.columns.join(', ')}) SELECT * FROM UNNEST(${unnestArgs.join(', ')})`;
+        if (input.skipDuplicates)
+            sql += ' ON CONFLICT DO NOTHING';
+        return { sql: `${sql}${this.buildReturningClause(input.returning)}`, params: columnArrays };
+    },
+    buildUpsertStatement(input) {
+        return (`INSERT INTO ${input.table} (${input.insertColumns.join(', ')}) VALUES (${input.valuePlaceholders.join(', ')})` +
+            ` ON CONFLICT (${input.conflictColumns.join(', ')}) DO UPDATE SET ${input.updateSetClauses.join(', ')}` +
+            this.buildReturningClause(input.returning));
+    },
     buildInsensitiveLike(column, paramRef) {
         return `${column} ILIKE ${paramRef}`;
     },
@@ -54,4 +76,56 @@ exports.postgresDialect = {
         // This hook is the package boundary MySQL/SQLite implementations will fill.
         return 'unknown';
     },
+    buildColumnType(input) {
+        if (input.type === 'VARCHAR' && input.maxLength != null) {
+            return `VARCHAR(${input.maxLength})`;
+        }
+        return input.type;
+    },
+    buildColumnDefinition(input) {
+        const parts = [input.name, this.buildColumnType(input)];
+        if (input.primaryKey)
+            parts.push('PRIMARY KEY');
+        if (input.unique && !input.primaryKey)
+            parts.push('UNIQUE');
+        if (input.notNull)
+            parts.push('NOT NULL');
+        if (input.defaultValue != null)
+            parts.push(`DEFAULT ${input.defaultValue}`);
+        if (input.references)
+            parts.push(`REFERENCES ${input.references.table}(${input.references.column})`);
+        return parts.join(' ');
+    },
+    buildPrimaryKeyConstraint(columns) {
+        return `PRIMARY KEY (${columns.join(', ')})`;
+    },
+    buildCreateTableStatement(input) {
+        const body = input.definitions.map((d) => `    ${d}`).join(',\n');
+        return `CREATE TABLE ${input.table} (\n${body}\n);`;
+    },
+    buildCreateIndexStatement(input) {
+        return `CREATE INDEX ${input.name} ON ${input.table}(${input.columns.join(', ')});`;
+    },
+    buildMigrationTrackingTable(table) {
+        return `
+  CREATE TABLE IF NOT EXISTS ${table} (
+    id SERIAL PRIMARY KEY,
+    name TEXT NOT NULL UNIQUE,
+    checksum TEXT NOT NULL,
+    applied_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+  );
+`;
+    },
+    buildMigrationSelectApplied(table) {
+        return `SELECT id, name, applied_at, checksum FROM ${table} ORDER BY id ASC`;
+    },
+    buildMigrationUpdateChecksum(table) {
+        return `UPDATE ${table} SET checksum = ${this.paramPlaceholder(1)} WHERE name = ${this.paramPlaceholder(2)}`;
+    },
+    buildMigrationInsertApplied(table) {
+        return `INSERT INTO ${table} (name, checksum) VALUES (${this.paramPlaceholder(1)}, ${this.paramPlaceholder(2)}) ON CONFLICT (name) DO NOTHING`;
+    },
+    buildMigrationDeleteApplied(table) {
+        return `DELETE FROM ${table} WHERE name = ${this.paramPlaceholder(1)}`;
+    },
 };

package/dist/cjs/query/builder.js

@@ -736,7 +736,12 @@ class QueryInterface {
         const columns = entries.map(([k]) => this.toSqlColumn(k));
         const params = entries.map(([, v]) => v);
         const placeholders = entries.map((_, i) => `${this.p(i + 1)}`);
-        const sql = `INSERT INTO ${this.q(this.table)} (${columns.join(', ')}) VALUES (${placeholders.join(', ')}) RETURNING *`;
+        const sql = this.dialect.buildInsertStatement({
+            table: this.q(this.table),
+            columns,
+            valuePlaceholders: placeholders,
+            returning: '*',
+        });
         return {
             sql,
             params,
@@ -776,27 +781,24 @@ class QueryInterface {
         }
         const keys = Object.keys(args.data[0]).filter((k) => args.data[0][k] !== undefined);
         const columns = keys.map((k) => this.toColumn(k));
-        // Build column arrays for UNNEST
-        const columnArrays = keys.map(() => []);
-        for (const row of args.data) {
+        const rowValues = args.data.map((row) => {
             const record = row;
-            keys.forEach((key, i) => {
-                columnArrays[i].push(record[key]);
-            });
-        }
-        // Use actual Postgres types for array casts
+            return keys.map((key) => record[key]);
+        });
+        // Use actual Postgres types for array casts in the default PostgreSQL dialect.
         const typeCasts = columns.map((col) => this.getColumnArrayType(col));
-        const unnestArgs = columnArrays.map((_, i) => `${this.p(i + 1)}::${typeCasts[i]}`);
         const quotedColumns = columns.map((c) => this.q(c));
-        let sql = `INSERT INTO ${qt} (${quotedColumns.join(', ')}) SELECT * FROM UNNEST(${unnestArgs.join(', ')})`;
-        // skipDuplicates: add ON CONFLICT DO NOTHING
-        if (args.skipDuplicates) {
-            sql += ` ON CONFLICT DO NOTHING`;
-        }
-        sql += ` RETURNING *`;
+        const built = this.dialect.buildBulkInsertStatement({
+            table: qt,
+            columns: quotedColumns,
+            rowValues,
+            columnArrayTypes: typeCasts,
+            skipDuplicates: args.skipDuplicates,
+            returning: '*',
+        });
         return {
-            sql,
-            params: columnArrays,
+            sql: built.sql,
+            params: built.params,
             transform: (result) => result.rows.map((row) => this.parseRow(row, this.table)),
             tag: `${this.table}.createMany`,
         };
@@ -825,7 +827,7 @@ class QueryInterface {
             const whereClause = this.buildWhereClause(whereObj, freshParams);
             const whereSql = whereClause ? ` WHERE ${whereClause}` : '';
             this.assertMutationHasPredicate('update', whereSql, args.allowFullTableScan);
-            return `UPDATE ${this.q(this.table)} SET ${setClauses.join(', ')}${whereSql} RETURNING *`;
+            return `UPDATE ${this.q(this.table)} SET ${setClauses.join(', ')}${whereSql}${this.dialect.buildReturningClause('*')}`;
         });
         // On cache hit, validate predicate
         if (whereFp === '') {
@@ -874,7 +876,7 @@ class QueryInterface {
             const clause = this.buildWhereClause(whereObj, freshParams);
             const whereSql = clause ? ` WHERE ${clause}` : '';
             this.assertMutationHasPredicate('delete', whereSql, args.allowFullTableScan);
-            return `DELETE FROM ${this.q(this.table)}${whereSql} RETURNING *`;
+            return `DELETE FROM ${this.q(this.table)}${whereSql}${this.dialect.buildReturningClause('*')}`;
         });
         // On cache hit, still validate the predicate
         if (whereFp === '') {
@@ -928,9 +930,14 @@ class QueryInterface {
         });
         const updateParams = updateEntries.map(([, v]) => v);
         const params = [...createParams, ...updateParams];
-        const sql = `INSERT INTO ${this.q(this.table)} (${columns.join(', ')}) VALUES (${placeholders.join(', ')})` +
-            ` ON CONFLICT (${conflictColumns.join(', ')}) DO UPDATE SET ${setClauses.join(', ')}` +
-            ` RETURNING *`;
+        const sql = this.dialect.buildUpsertStatement({
+            table: this.q(this.table),
+            insertColumns: columns,
+            valuePlaceholders: placeholders,
+            conflictColumns,
+            updateSetClauses: setClauses,
+            returning: '*',
+        });
         return {
             sql,
             params,

package/dist/cjs/schema-sql.js

@@ -14,7 +14,7 @@ exports.schemaDiff = schemaDiff;
 exports.schemaPush = schemaPush;
 exports.schemaToSQLString = schemaToSQLString;
 const pg_1 = __importDefault(require("pg"));
-const index_js_1 = require("./query/index.js");
+const dialect_js_1 = require("./dialect.js");
 const schema_js_1 = require("./schema.js");
 // ---------------------------------------------------------------------------
 // SQL Generation — SchemaDef → CREATE TABLE statements
@@ -25,7 +25,8 @@ const schema_js_1 = require("./schema.js");
  * Returns CREATE TABLE statements (in dependency order based on references)
  * followed by CREATE INDEX statements for foreign key columns.
  */
-function schemaToSQL(schema) {
+function schemaToSQL(schema, options) {
+    const dialect = options?.dialect ?? dialect_js_1.postgresDialect;
     const statements = [];
     // Topologically sort tables by their foreign key references
     const sorted = topologicalSort(schema);
@@ -33,12 +34,12 @@ function schemaToSQL(schema) {
     // Generate CREATE TABLE statements
     for (const tableName of sorted) {
         const table = schema.tables[tableName];
-        statements.push(generateCreateTable(table, resolveRef));
+        statements.push(generateCreateTable(table, resolveRef, dialect));
     }
     // Generate CREATE INDEX for foreign key columns
     for (const tableName of sorted) {
         const table = schema.tables[tableName];
-        const indexes = generateForeignKeyIndexes(table);
+        const indexes = generateForeignKeyIndexes(table, dialect);
         statements.push(...indexes);
     }
     return statements;
@@ -134,42 +135,28 @@ function topologicalSort(schema) {
  * to their snake_case DDL form, so users can write either camelCase JS
  * accessor names or snake_case DDL names.
  */
-function generateCreateTable(table, resolveRef) {
+function generateCreateTable(table, resolveRef, dialect = dialect_js_1.postgresDialect) {
     const tableName = table.name;
     const columnDefs = [];
     const compositePk = table.primaryKey && table.primaryKey.length > 0 ? table.primaryKey : null;
     for (const [fieldName, config] of Object.entries(table.columns)) {
-        columnDefs.push(generateColumnDef(fieldName, config, resolveRef));
+        columnDefs.push(generateColumnDef(fieldName, config, resolveRef, dialect));
     }
     // Append a table-level PRIMARY KEY constraint when a composite PK is set.
     if (compositePk) {
-        const cols = compositePk.map((c) => (0, index_js_1.quoteIdent)((0, schema_js_1.camelToSnake)(c))).join(', ');
-        columnDefs.push(`PRIMARY KEY (${cols})`);
+        const cols = compositePk.map((c) => dialect.quoteIdentifier((0, schema_js_1.camelToSnake)(c)));
+        columnDefs.push(dialect.buildPrimaryKeyConstraint(cols));
     }
-    const body = columnDefs.map((d) => `    ${d}`).join(',\n');
-    return `CREATE TABLE ${(0, index_js_1.quoteIdent)(tableName)} (\n${body}\n);`;
+    return dialect.buildCreateTableStatement({
+        table: dialect.quoteIdentifier(tableName),
+        definitions: columnDefs,
+    });
 }
 /**
  * Generate a single column definition line (e.g. "id BIGSERIAL PRIMARY KEY").
  */
-function generateColumnDef(fieldName, config, resolveRef) {
+function generateColumnDef(fieldName, config, resolveRef, dialect = dialect_js_1.postgresDialect) {
     const snakeName = (0, schema_js_1.camelToSnake)(fieldName);
-    const parts = [(0, index_js_1.quoteIdent)(snakeName)];
-    // Type
-    if (config.type === 'VARCHAR' && config.maxLength != null) {
-        parts.push(`VARCHAR(${config.maxLength})`);
-    }
-    else {
-        parts.push(config.type);
-    }
-    // PRIMARY KEY
-    if (config.isPrimaryKey) {
-        parts.push('PRIMARY KEY');
-    }
-    // UNIQUE (only if not primary key — PK is implicitly unique)
-    if (config.isUnique && !config.isPrimaryKey) {
-        parts.push('UNIQUE');
-    }
     // NOT NULL — serial types are implicitly NOT NULL, but explicit is fine.
     // A column is NOT NULL if:
     //   1. Explicitly marked .notNull(), OR
@@ -178,25 +165,36 @@ function generateColumnDef(fieldName, config, resolveRef) {
     // A column is left nullable if .nullable() was called.
     const isSerial = config.type === 'BIGSERIAL';
     const implicitNotNull = isSerial || config.isPrimaryKey;
-    if (config.isNotNull && !implicitNotNull) {
-        parts.push('NOT NULL');
-    }
+    const notNull = config.isNotNull && !implicitNotNull;
     // DEFAULT
+    let defaultValue;
     if (config.defaultValue != null) {
-        const sqlDefault = normalizeDefault(config.defaultValue);
-        parts.push(`DEFAULT ${sqlDefault}`);
+        defaultValue = normalizeDefault(config.defaultValue);
     }
     // REFERENCES — resolve the raw table name through the optional resolver so
     // both camelCase accessor names and snake_case DDL names work.
+    let references;
     if (config.referencesTarget) {
         const refParts = config.referencesTarget.split('.');
         if (refParts.length === 2) {
             const rawTable = refParts[0];
             const refTable = resolveRef ? resolveRef(rawTable) : rawTable;
-            parts.push(`REFERENCES ${(0, index_js_1.quoteIdent)(refTable)}(${(0, index_js_1.quoteIdent)(refParts[1])})`);
+            references = {
+                table: dialect.quoteIdentifier(refTable),
+                column: dialect.quoteIdentifier(refParts[1]),
+            };
         }
     }
-    return parts.join(' ');
+    return dialect.buildColumnDefinition({
+        name: dialect.quoteIdentifier(snakeName),
+        type: config.type,
+        maxLength: config.maxLength,
+        primaryKey: config.isPrimaryKey,
+        unique: config.isUnique,
+        notNull,
+        defaultValue,
+        references,
+    });
 }
 /**
  * Normalize a default value from the user's schema definition to valid SQL.
@@ -236,13 +234,17 @@ function normalizeDefault(val) {
  * Generate CREATE INDEX statements for foreign key columns.
  * Only generates indexes for columns that have a REFERENCES clause.
  */
-function generateForeignKeyIndexes(table) {
+function generateForeignKeyIndexes(table, dialect = dialect_js_1.postgresDialect) {
     const indexes = [];
     for (const [fieldName, config] of Object.entries(table.columns)) {
         if (config.referencesTarget) {
             const snakeName = (0, schema_js_1.camelToSnake)(fieldName);
             const indexName = `idx_${table.name}_${snakeName}`;
-            indexes.push(`CREATE INDEX ${(0, index_js_1.quoteIdent)(indexName)} ON ${(0, index_js_1.quoteIdent)(table.name)}(${(0, index_js_1.quoteIdent)(snakeName)});`);
+            indexes.push(dialect.buildCreateIndexStatement({
+                name: dialect.quoteIdentifier(indexName),
+                table: dialect.quoteIdentifier(table.name),
+                columns: [dialect.quoteIdentifier(snakeName)],
+            }));
         }
     }
     return indexes;
@@ -254,6 +256,7 @@ function generateForeignKeyIndexes(table) {
  * DDL is needed to make the database match the schema definition.
  */
 async function schemaDiff(schema, connectionString) {
+    const dialect = dialect_js_1.postgresDialect;
     const client = new pg_1.default.Client({ connectionString });
     await client.connect();
     try {
@@ -313,11 +316,11 @@ async function schemaDiff(schema, connectionString) {
             const ddlName = tableDef.name;
             if (!existingTables.has(ddlName)) {
                 result.create.push(tableDef);
-                result.statements.push(generateCreateTable(tableDef, resolveRef));
-                const fkIndexes = generateForeignKeyIndexes(tableDef);
+                result.statements.push(generateCreateTable(tableDef, resolveRef, dialect));
+                const fkIndexes = generateForeignKeyIndexes(tableDef, dialect);
                 result.statements.push(...fkIndexes);
                 // Reverse: DROP TABLE (with indexes — they drop automatically)
-                result.reverseStatements.unshift(`DROP TABLE IF EXISTS ${(0, index_js_1.quoteIdent)(ddlName)} CASCADE;`);
+                result.reverseStatements.unshift(`DROP TABLE IF EXISTS ${dialect.quoteIdentifier(ddlName)} CASCADE;`);
             }
         }
         // Tables to drop (in DB but not in schema)
@@ -341,9 +344,9 @@ async function schemaDiff(schema, connectionString) {
                 const dbCol = dbCols[snakeName];
                 if (!dbCol) {
                     // Column exists in schema but not in DB — ADD COLUMN
-                    const colDef = generateColumnDef(fieldName, config, resolveRef);
-                    const sql = `ALTER TABLE ${(0, index_js_1.quoteIdent)(tableName)} ADD COLUMN ${colDef};`;
-                    const reverseSql = `ALTER TABLE ${(0, index_js_1.quoteIdent)(tableName)} DROP COLUMN ${(0, index_js_1.quoteIdent)(snakeName)};`;
+                    const colDef = generateColumnDef(fieldName, config, resolveRef, dialect);
+                    const sql = `ALTER TABLE ${dialect.quoteIdentifier(tableName)} ADD COLUMN ${colDef};`;
+                    const reverseSql = `ALTER TABLE ${dialect.quoteIdentifier(tableName)} DROP COLUMN ${dialect.quoteIdentifier(snakeName)};`;
                     alterDef.columns.push({ column: snakeName, action: 'add', sql, reverseSql });
                     result.statements.push(sql);
                     result.reverseStatements.unshift(reverseSql);
@@ -354,8 +357,8 @@ async function schemaDiff(schema, connectionString) {
                 if (expectedUdt && dbCol.udtName !== expectedUdt) {
                     const sqlType = config.type === 'VARCHAR' && config.maxLength ? `VARCHAR(${config.maxLength})` : config.type;
                     const oldSqlType = udtToSqlType(dbCol.udtName, dbCol.maxLength);
-                    const sql = `ALTER TABLE ${(0, index_js_1.quoteIdent)(tableName)} ALTER COLUMN ${(0, index_js_1.quoteIdent)(snakeName)} TYPE ${sqlType} USING ${(0, index_js_1.quoteIdent)(snakeName)}::${sqlType};`;
-                    const reverseSql = `ALTER TABLE ${(0, index_js_1.quoteIdent)(tableName)} ALTER COLUMN ${(0, index_js_1.quoteIdent)(snakeName)} TYPE ${oldSqlType} USING ${(0, index_js_1.quoteIdent)(snakeName)}::${oldSqlType};`;
+                    const sql = `ALTER TABLE ${dialect.quoteIdentifier(tableName)} ALTER COLUMN ${dialect.quoteIdentifier(snakeName)} TYPE ${sqlType} USING ${dialect.quoteIdentifier(snakeName)}::${sqlType};`;
+                    const reverseSql = `ALTER TABLE ${dialect.quoteIdentifier(tableName)} ALTER COLUMN ${dialect.quoteIdentifier(snakeName)} TYPE ${oldSqlType} USING ${dialect.quoteIdentifier(snakeName)}::${oldSqlType};`;
                     alterDef.columns.push({ column: snakeName, action: 'alter_type', sql, reverseSql });
                     result.statements.push(sql);
                     result.reverseStatements.unshift(reverseSql);
@@ -364,15 +367,15 @@ async function schemaDiff(schema, connectionString) {
                 const shouldBeNotNull = config.isNotNull || config.isPrimaryKey || config.type === 'BIGSERIAL';
                 const isCurrentlyNullable = dbCol.isNullable;
                 if (shouldBeNotNull && isCurrentlyNullable && !config.isNullable) {
-                    const sql = `ALTER TABLE ${(0, index_js_1.quoteIdent)(tableName)} ALTER COLUMN ${(0, index_js_1.quoteIdent)(snakeName)} SET NOT NULL;`;
-                    const reverseSql = `ALTER TABLE ${(0, index_js_1.quoteIdent)(tableName)} ALTER COLUMN ${(0, index_js_1.quoteIdent)(snakeName)} DROP NOT NULL;`;
+                    const sql = `ALTER TABLE ${dialect.quoteIdentifier(tableName)} ALTER COLUMN ${dialect.quoteIdentifier(snakeName)} SET NOT NULL;`;
+                    const reverseSql = `ALTER TABLE ${dialect.quoteIdentifier(tableName)} ALTER COLUMN ${dialect.quoteIdentifier(snakeName)} DROP NOT NULL;`;
                     alterDef.columns.push({ column: snakeName, action: 'set_not_null', sql, reverseSql });
                     result.statements.push(sql);
                     result.reverseStatements.unshift(reverseSql);
                 }
                 else if (!shouldBeNotNull && !isCurrentlyNullable && config.isNullable) {
-                    const sql = `ALTER TABLE ${(0, index_js_1.quoteIdent)(tableName)} ALTER COLUMN ${(0, index_js_1.quoteIdent)(snakeName)} DROP NOT NULL;`;
-                    const reverseSql = `ALTER TABLE ${(0, index_js_1.quoteIdent)(tableName)} ALTER COLUMN ${(0, index_js_1.quoteIdent)(snakeName)} SET NOT NULL;`;
+                    const sql = `ALTER TABLE ${dialect.quoteIdentifier(tableName)} ALTER COLUMN ${dialect.quoteIdentifier(snakeName)} DROP NOT NULL;`;
+                    const reverseSql = `ALTER TABLE ${dialect.quoteIdentifier(tableName)} ALTER COLUMN ${dialect.quoteIdentifier(snakeName)} SET NOT NULL;`;
                     alterDef.columns.push({ column: snakeName, action: 'drop_not_null', sql, reverseSql });
                     result.statements.push(sql);
                     result.reverseStatements.unshift(reverseSql);
@@ -384,16 +387,16 @@ async function schemaDiff(schema, connectionString) {
                     const dbDefault = dbCol.columnDefault;
                     if (schemaDefault && !dbDefault) {
                         // Schema has default, DB doesn't
-                        const sql = `ALTER TABLE ${(0, index_js_1.quoteIdent)(tableName)} ALTER COLUMN ${(0, index_js_1.quoteIdent)(snakeName)} SET DEFAULT ${schemaDefault};`;
-                        const reverseSql = `ALTER TABLE ${(0, index_js_1.quoteIdent)(tableName)} ALTER COLUMN ${(0, index_js_1.quoteIdent)(snakeName)} DROP DEFAULT;`;
+                        const sql = `ALTER TABLE ${dialect.quoteIdentifier(tableName)} ALTER COLUMN ${dialect.quoteIdentifier(snakeName)} SET DEFAULT ${schemaDefault};`;
+                        const reverseSql = `ALTER TABLE ${dialect.quoteIdentifier(tableName)} ALTER COLUMN ${dialect.quoteIdentifier(snakeName)} DROP DEFAULT;`;
                         alterDef.columns.push({ column: snakeName, action: 'set_default', sql, reverseSql });
                         result.statements.push(sql);
                         result.reverseStatements.unshift(reverseSql);
                     }
                     else if (!schemaDefault && dbDefault && !isSequenceDefault(dbDefault)) {
                         // DB has a non-sequence default, schema doesn't
-                        const sql = `ALTER TABLE ${(0, index_js_1.quoteIdent)(tableName)} ALTER COLUMN ${(0, index_js_1.quoteIdent)(snakeName)} DROP DEFAULT;`;
-                        const reverseSql = `ALTER TABLE ${(0, index_js_1.quoteIdent)(tableName)} ALTER COLUMN ${(0, index_js_1.quoteIdent)(snakeName)} SET DEFAULT ${dbDefault};`;
+                        const sql = `ALTER TABLE ${dialect.quoteIdentifier(tableName)} ALTER COLUMN ${dialect.quoteIdentifier(snakeName)} DROP DEFAULT;`;
+                        const reverseSql = `ALTER TABLE ${dialect.quoteIdentifier(tableName)} ALTER COLUMN ${dialect.quoteIdentifier(snakeName)} SET DEFAULT ${dbDefault};`;
                         alterDef.columns.push({ column: snakeName, action: 'drop_default', sql, reverseSql });
                         result.statements.push(sql);
                         result.reverseStatements.unshift(reverseSql);
@@ -403,8 +406,8 @@ async function schemaDiff(schema, connectionString) {
                         !isSequenceDefault(dbDefault) &&
                         !defaultsMatch(schemaDefault, dbDefault)) {
                         // Both have defaults but they differ
-                        const sql = `ALTER TABLE ${(0, index_js_1.quoteIdent)(tableName)} ALTER COLUMN ${(0, index_js_1.quoteIdent)(snakeName)} SET DEFAULT ${schemaDefault};`;
-                        const reverseSql = `ALTER TABLE ${(0, index_js_1.quoteIdent)(tableName)} ALTER COLUMN ${(0, index_js_1.quoteIdent)(snakeName)} SET DEFAULT ${dbDefault};`;
+                        const sql = `ALTER TABLE ${dialect.quoteIdentifier(tableName)} ALTER COLUMN ${dialect.quoteIdentifier(snakeName)} SET DEFAULT ${schemaDefault};`;
+                        const reverseSql = `ALTER TABLE ${dialect.quoteIdentifier(tableName)} ALTER COLUMN ${dialect.quoteIdentifier(snakeName)} SET DEFAULT ${dbDefault};`;
                         alterDef.columns.push({ column: snakeName, action: 'set_default', sql, reverseSql });
                         result.statements.push(sql);
                         result.reverseStatements.unshift(reverseSql);
@@ -416,16 +419,16 @@ async function schemaDiff(schema, connectionString) {
                     const wantsUnique = config.isUnique === true;
                     if (wantsUnique && !hasDbUnique) {
                         const constraintName = `${tableName}_${snakeName}_key`;
-                        const sql = `ALTER TABLE ${(0, index_js_1.quoteIdent)(tableName)} ADD CONSTRAINT ${(0, index_js_1.quoteIdent)(constraintName)} UNIQUE (${(0, index_js_1.quoteIdent)(snakeName)});`;
-                        const reverseSql = `ALTER TABLE ${(0, index_js_1.quoteIdent)(tableName)} DROP CONSTRAINT ${(0, index_js_1.quoteIdent)(constraintName)};`;
+                        const sql = `ALTER TABLE ${dialect.quoteIdentifier(tableName)} ADD CONSTRAINT ${dialect.quoteIdentifier(constraintName)} UNIQUE (${dialect.quoteIdentifier(snakeName)});`;
+                        const reverseSql = `ALTER TABLE ${dialect.quoteIdentifier(tableName)} DROP CONSTRAINT ${dialect.quoteIdentifier(constraintName)};`;
                         alterDef.columns.push({ column: snakeName, action: 'add_unique', sql, reverseSql });
                         result.statements.push(sql);
                         result.reverseStatements.unshift(reverseSql);
                     }
                     else if (!wantsUnique && hasDbUnique) {
                         const constraintName = tableUniques[snakeName];
-                        const sql = `ALTER TABLE ${(0, index_js_1.quoteIdent)(tableName)} DROP CONSTRAINT ${(0, index_js_1.quoteIdent)(constraintName)};`;
-                        const reverseSql = `ALTER TABLE ${(0, index_js_1.quoteIdent)(tableName)} ADD CONSTRAINT ${(0, index_js_1.quoteIdent)(constraintName)} UNIQUE (${(0, index_js_1.quoteIdent)(snakeName)});`;
+                        const sql = `ALTER TABLE ${dialect.quoteIdentifier(tableName)} DROP CONSTRAINT ${dialect.quoteIdentifier(constraintName)};`;
+                        const reverseSql = `ALTER TABLE ${dialect.quoteIdentifier(tableName)} ADD CONSTRAINT ${dialect.quoteIdentifier(constraintName)} UNIQUE (${dialect.quoteIdentifier(snakeName)});`;
                         alterDef.columns.push({ column: snakeName, action: 'drop_unique', sql, reverseSql });
                         result.statements.push(sql);
                         result.reverseStatements.unshift(reverseSql);
@@ -436,7 +439,7 @@ async function schemaDiff(schema, connectionString) {
             for (const dbColName of Object.keys(dbCols)) {
                 const hasField = Object.entries(tableDef.columns).some(([fieldName]) => (0, schema_js_1.camelToSnake)(fieldName) === dbColName);
                 if (!hasField) {
-                    const sql = `ALTER TABLE ${(0, index_js_1.quoteIdent)(tableName)} DROP COLUMN ${(0, index_js_1.quoteIdent)(dbColName)};`;
+                    const sql = `ALTER TABLE ${dialect.quoteIdentifier(tableName)} DROP COLUMN ${dialect.quoteIdentifier(dbColName)};`;
                     const reverseSql = `-- Cannot auto-reverse DROP COLUMN for "${dbColName}" — add it back manually`;
                     alterDef.columns.push({ column: dbColName, action: 'drop', sql, reverseSql });
                     // Don't auto-add drops to statements for safety — user must opt in
@@ -569,7 +572,7 @@ async function schemaPush(schema, connectionString, options = {}) {
  * Generate the full DDL as a single formatted string.
  * Useful for printing or saving to a .sql file.
  */
-function schemaToSQLString(schema) {
-    const statements = schemaToSQL(schema);
+function schemaToSQLString(schema, options) {
+    const statements = schemaToSQL(schema, options);
     return `${statements.join('\n\n')}\n`;
 }

package/dist/cli/migrate.d.ts

@@ -12,6 +12,7 @@
  *   DROP TABLE users;
  */
 import type { DatabaseAdapter } from '../adapters/index.js';
+import { type Dialect } from '../dialect.js';
 export interface MigrationFile {
     /** Full filename (e.g. "20260325120000_create_users.sql") */
     filename: string;
@@ -115,6 +116,7 @@ export declare function migrateUp(connectionString: string, migrationsDir: strin
     allowDrift?: boolean /** @deprecated use allowDrift */;
     force?: boolean;
     adapter?: DatabaseAdapter;
+    dialect?: Dialect;
 }): Promise<{
     applied: MigrationFile[];
     errors: Array<{
@@ -133,6 +135,7 @@ export declare function migrateUp(connectionString: string, migrationsDir: strin
 export declare function migrateDown(connectionString: string, migrationsDir: string, options?: {
     step?: number;
     adapter?: DatabaseAdapter;
+    dialect?: Dialect;
 }): Promise<{
     rolledBack: MigrationFile[];
     errors: Array<{
@@ -144,5 +147,7 @@ export declare function migrateDown(connectionString: string, migrationsDir: str
  * Get the status of all migrations (applied vs pending).
  * Includes checksum validation for applied migrations.
  */
-export declare function migrateStatus(connectionString: string, migrationsDir: string): Promise<MigrationStatus[]>;
+export declare function migrateStatus(connectionString: string, migrationsDir: string, options?: {
+    dialect?: Dialect;
+}): Promise<MigrationStatus[]>;
 //# sourceMappingURL=migrate.d.ts.map