turbine-orm 0.12.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

@@ -76,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/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

package/dist/cli/migrate.js

@@ -16,27 +16,21 @@ import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from
 import { join } from 'node:path';
 import pg from 'pg';
 import { postgresql } from '../adapters/index.js';
+import { postgresDialect } from '../dialect.js';
 import { MigrationError } from '../errors.js';
-import { quoteIdent } from '../query/index.js';
 // ---------------------------------------------------------------------------
 // Tracking table management
 // ---------------------------------------------------------------------------
 const TRACKING_TABLE = '_turbine_migrations';
-const QUOTED_TRACKING_TABLE = 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 = 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 = postgresDialect) {
+    await ensureTrackingTable(client, dialect);
+    const result = await client.query(dialect.buildMigrationSelectApplied(quotedTrackingTable(dialect)));
     return result.rows;
 }
 // ---------------------------------------------------------------------------
@@ -248,8 +242,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 = postgresDialect) {
+    const applied = await getAppliedMigrations(client, dialect);
     const allFiles = listMigrationFiles(migrationsDir);
     const fileMap = new Map(allFiles.map((f) => [f.name, f]));
     const mismatches = [];
@@ -269,7 +263,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,
                 ]);
@@ -304,6 +298,7 @@ export 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 ?? postgresDialect;
     try {
         // Derive an advisory lock ID per-database so concurrent migrations in
         // sibling databases on the same Postgres cluster do not contend.
@@ -317,7 +312,7 @@ export async function migrateUp(connectionString, migrationsDir, options) {
             throw new 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
@@ -325,7 +320,7 @@ export 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');
@@ -349,7 +344,7 @@ export async function migrateUp(connectionString, migrationsDir, options) {
                     throw new 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));
@@ -369,7 +364,7 @@ export 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);
                 }
@@ -402,6 +397,7 @@ export async function migrateUp(connectionString, migrationsDir, options) {
 export async function migrateDown(connectionString, migrationsDir, options) {
     const client = new pg.Client({ connectionString });
     await client.connect();
+    const dialect = options?.dialect ?? postgresDialect;
     try {
         // Derive a per-database advisory lock ID so concurrent migrations in
         // sibling databases on the same cluster do not contend.
@@ -413,8 +409,8 @@ export async function migrateDown(connectionString, migrationsDir, options) {
             throw new 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: [] };
             }
@@ -441,7 +437,7 @@ export 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);
                 }
@@ -466,12 +462,13 @@ export async function migrateDown(connectionString, migrationsDir, options) {
  * Get the status of all migrations (applied vs pending).
  * Includes checksum validation for applied migrations.
  */
-export async function migrateStatus(connectionString, migrationsDir) {
+export async function migrateStatus(connectionString, migrationsDir, options) {
     const client = new pg.Client({ connectionString });
     await client.connect();
+    const dialect = options?.dialect ?? 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/dialect.d.ts

@@ -49,6 +49,43 @@ export interface UpsertStatementInput {
     /** Optional SQL-ready RETURNING selection. */
     returning?: string;
 }
+export interface ColumnTypeInput {
+    /** Schema-builder column type name (PostgreSQL-native in the root package). */
+    type: string;
+    /** Optional VARCHAR length. */
+    maxLength?: number | null;
+}
+export interface ColumnDefinitionInput extends ColumnTypeInput {
+    /** SQL-ready quoted column name. */
+    name: string;
+    /** Whether this column is a single-column primary key. */
+    primaryKey?: boolean;
+    /** Whether this column is unique. Ignored when primaryKey is true. */
+    unique?: boolean;
+    /** Whether this column is NOT NULL. */
+    notNull?: boolean;
+    /** SQL-ready default expression. */
+    defaultValue?: string;
+    /** SQL-ready REFERENCES clause without the leading REFERENCES keyword. */
+    references?: {
+        table: string;
+        column: string;
+    };
+}
+export interface CreateTableStatementInput {
+    /** SQL-ready quoted table name. */
+    table: string;
+    /** SQL-ready column and table constraints. */
+    definitions: string[];
+}
+export interface CreateIndexStatementInput {
+    /** SQL-ready quoted index name. */
+    name: string;
+    /** SQL-ready quoted table name. */
+    table: string;
+    /** SQL-ready quoted index columns. */
+    columns: string[];
+}
 export interface Dialect {
     /** Dialect identifier. */
     readonly name: DialectName;
@@ -92,6 +129,26 @@ export interface Dialect {
     typeToTypeScript(dialectType: string, nullable: boolean): string;
     /** Optional array-cast hook for bulk insert implementations. */
     arrayType?(baseType: string): string;
+    /** Map a schema-builder column type to dialect DDL. */
+    buildColumnType(input: ColumnTypeInput): string;
+    /** Build a column definition line for CREATE/ALTER TABLE. */
+    buildColumnDefinition(input: ColumnDefinitionInput): string;
+    /** Build a table-level PRIMARY KEY constraint. */
+    buildPrimaryKeyConstraint(columns: string[]): string;
+    /** Build a CREATE TABLE statement from SQL-ready definitions. */
+    buildCreateTableStatement(input: CreateTableStatementInput): string;
+    /** Build a CREATE INDEX statement. */
+    buildCreateIndexStatement(input: CreateIndexStatementInput): string;
+    /** Build the migration tracking table DDL. */
+    buildMigrationTrackingTable(table: string): string;
+    /** Build the query that reads applied migrations. */
+    buildMigrationSelectApplied(table: string): string;
+    /** Build the query that updates an applied migration checksum. */
+    buildMigrationUpdateChecksum(table: string): string;
+    /** Build the query that records an applied migration. */
+    buildMigrationInsertApplied(table: string): string;
+    /** Build the query that deletes a rolled-back migration record. */
+    buildMigrationDeleteApplied(table: string): string;
 }
 export interface DialectIntrospector {
     introspect(options: IntrospectOptions): Promise<SchemaMetadata>;

package/dist/dialect.js

@@ -73,5 +73,57 @@ export const 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)}`;
+    },
 };
 //# sourceMappingURL=dialect.js.map

package/dist/index.d.ts

@@ -35,7 +35,7 @@
 export type { DatabaseAdapter, IntrospectionOverrides } from './adapters/index.js';
 export { alloydb, cockroachdb, postgresql, timescale, yugabytedb } from './adapters/index.js';
 export { type Middleware, type MiddlewareNext, type MiddlewareParams, type PgCompatPool, type PgCompatPoolClient, type PgCompatQueryResult, TransactionClient, type TransactionOptions, TurbineClient, type TurbineConfig, } from './client.js';
-export type { BuiltStatement, BulkInsertStatementInput, Dialect, DialectIntrospector, DialectMigrator, DialectName, InsertStatementInput, IntrospectOptions as DialectIntrospectOptions, UpsertStatementInput, } from './dialect.js';
+export type { BuiltStatement, BulkInsertStatementInput, ColumnDefinitionInput, ColumnTypeInput, CreateIndexStatementInput, CreateTableStatementInput, Dialect, DialectIntrospector, DialectMigrator, DialectName, InsertStatementInput, IntrospectOptions as DialectIntrospectOptions, UpsertStatementInput, } from './dialect.js';
 export { postgresDialect } from './dialect.js';
 export { CheckConstraintError, CircularRelationError, ConnectionError, DeadlockError, type ErrorMessageMode, ForeignKeyError, getErrorMessageMode, MigrationError, NotFoundError, NotNullViolationError, PipelineError, type PipelineResultSlot, RelationError, SerializationFailureError, setErrorMessageMode, TimeoutError, TurbineError, TurbineErrorCode, UniqueConstraintError, ValidationError, wrapPgError, } from './errors.js';
 export { type GenerateOptions, generate } from './generate.js';
@@ -45,6 +45,6 @@ export { type AggregateArgs, type AggregateResult, type ArrayFilter, type CountA
 export type { ColumnMetadata, IndexMetadata, RelationDef, SchemaMetadata, TableMetadata, } from './schema.js';
 export { camelToSnake, isDateType, normalizeKeyColumns, pgArrayType, pgTypeToTs, singularize, snakeToCamel, snakeToPascal, } from './schema.js';
 export { ColumnBuilder, type ColumnConfig, type ColumnDef, type ColumnType, type ColumnTypeName, column, defineSchema, type SchemaDef, type TableDef, table, } from './schema-builder.js';
-export { type AlterColumnDef, type AlterDef, type DiffResult, type PushResult, schemaDiff, schemaPush, schemaToSQL, schemaToSQLString, } from './schema-sql.js';
+export { type AlterColumnDef, type AlterDef, type DiffResult, type PushResult, type SchemaSqlOptions, schemaDiff, schemaPush, schemaToSQL, schemaToSQLString, } from './schema-sql.js';
 export { type TurbineHttpOptions, turbineHttp } from './serverless.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/query/index.d.ts

@@ -6,7 +6,7 @@
  * former monolithic `import { … } from './query.js'`.
  */
 export type { AggregateArgs, AggregateResult, ArrayFilter, CountArgs, CreateArgs, CreateManyArgs, DeleteArgs, DeleteManyArgs, FindManyArgs, FindManyStreamArgs, FindUniqueArgs, GroupByArgs, JsonFilter, OrderDirection, RelationDescriptor, RelationFilter, TypedWithClause, UpdateArgs, UpdateInput, UpdateManyArgs, UpdateOperatorInput, UpsertArgs, WhereClause, WhereOperator, WhereValue, WithClause, WithOptions, WithResult, } from './types.js';
-export type { BuiltStatement, BulkInsertStatementInput, Dialect, InsertStatementInput, UpsertStatementInput, } from '../dialect.js';
+export type { BuiltStatement, BulkInsertStatementInput, ColumnDefinitionInput, ColumnTypeInput, CreateIndexStatementInput, CreateTableStatementInput, Dialect, InsertStatementInput, UpsertStatementInput, } from '../dialect.js';
 export { postgresDialect } from '../dialect.js';
 export type { SqlCacheEntry } from './utils.js';
 export { buildCorrelation, escapeLike, escSingleQuote, fnv1a64Hex, LRUCache, OPERATOR_KEYS, quoteIdent, sqlToPreparedName, } from './utils.js';

package/dist/schema-sql.d.ts

@@ -4,14 +4,19 @@
  * Converts a SchemaDef (from defineSchema) into executable DDL statements.
  * Also provides diff and push commands for syncing schema to a live database.
  */
+import { type Dialect } from './dialect.js';
 import type { SchemaDef, TableDef } from './schema-builder.js';
+export interface SchemaSqlOptions {
+    /** SQL dialect used for DDL generation. Defaults to PostgreSQL. */
+    dialect?: Dialect;
+}
 /**
  * Convert a SchemaDef into an ordered array of SQL DDL statements.
  *
  * Returns CREATE TABLE statements (in dependency order based on references)
  * followed by CREATE INDEX statements for foreign key columns.
  */
-export declare function schemaToSQL(schema: SchemaDef): string[];
+export declare function schemaToSQL(schema: SchemaDef, options?: SchemaSqlOptions): string[];
 export interface AlterColumnDef {
     /** Column name in snake_case */
     column: string;
@@ -71,5 +76,5 @@ export declare function schemaPush(schema: SchemaDef, connectionString: string,
  * Generate the full DDL as a single formatted string.
  * Useful for printing or saving to a .sql file.
  */
-export declare function schemaToSQLString(schema: SchemaDef): string;
+export declare function schemaToSQLString(schema: SchemaDef, options?: SchemaSqlOptions): string;
 //# sourceMappingURL=schema-sql.d.ts.map

package/dist/schema-sql.js

@@ -5,7 +5,7 @@
  * Also provides diff and push commands for syncing schema to a live database.
  */
 import pg from 'pg';
-import { quoteIdent } from './query/index.js';
+import { postgresDialect } from './dialect.js';
 import { camelToSnake } from './schema.js';
 // ---------------------------------------------------------------------------
 // SQL Generation — SchemaDef → CREATE TABLE statements
@@ -16,7 +16,8 @@ import { camelToSnake } from './schema.js';
  * Returns CREATE TABLE statements (in dependency order based on references)
  * followed by CREATE INDEX statements for foreign key columns.
  */
-export function schemaToSQL(schema) {
+export function schemaToSQL(schema, options) {
+    const dialect = options?.dialect ?? postgresDialect;
     const statements = [];
     // Topologically sort tables by their foreign key references
     const sorted = topologicalSort(schema);
@@ -24,12 +25,12 @@ export 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;
@@ -125,42 +126,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 = 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) => quoteIdent(camelToSnake(c))).join(', ');
-        columnDefs.push(`PRIMARY KEY (${cols})`);
+        const cols = compositePk.map((c) => dialect.quoteIdentifier(camelToSnake(c)));
+        columnDefs.push(dialect.buildPrimaryKeyConstraint(cols));
     }
-    const body = columnDefs.map((d) => `    ${d}`).join(',\n');
-    return `CREATE TABLE ${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 = postgresDialect) {
     const snakeName = camelToSnake(fieldName);
-    const parts = [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
@@ -169,25 +156,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 ${quoteIdent(refTable)}(${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.
@@ -227,13 +225,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 = postgresDialect) {
     const indexes = [];
     for (const [fieldName, config] of Object.entries(table.columns)) {
         if (config.referencesTarget) {
             const snakeName = camelToSnake(fieldName);
             const indexName = `idx_${table.name}_${snakeName}`;
-            indexes.push(`CREATE INDEX ${quoteIdent(indexName)} ON ${quoteIdent(table.name)}(${quoteIdent(snakeName)});`);
+            indexes.push(dialect.buildCreateIndexStatement({
+                name: dialect.quoteIdentifier(indexName),
+                table: dialect.quoteIdentifier(table.name),
+                columns: [dialect.quoteIdentifier(snakeName)],
+            }));
         }
     }
     return indexes;
@@ -245,6 +247,7 @@ function generateForeignKeyIndexes(table) {
  * DDL is needed to make the database match the schema definition.
  */
 export async function schemaDiff(schema, connectionString) {
+    const dialect = postgresDialect;
     const client = new pg.Client({ connectionString });
     await client.connect();
     try {
@@ -304,11 +307,11 @@ export 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 ${quoteIdent(ddlName)} CASCADE;`);
+                result.reverseStatements.unshift(`DROP TABLE IF EXISTS ${dialect.quoteIdentifier(ddlName)} CASCADE;`);
             }
         }
         // Tables to drop (in DB but not in schema)
@@ -332,9 +335,9 @@ export 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 ${quoteIdent(tableName)} ADD COLUMN ${colDef};`;
-                    const reverseSql = `ALTER TABLE ${quoteIdent(tableName)} DROP COLUMN ${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);
@@ -345,8 +348,8 @@ export 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 ${quoteIdent(tableName)} ALTER COLUMN ${quoteIdent(snakeName)} TYPE ${sqlType} USING ${quoteIdent(snakeName)}::${sqlType};`;
-                    const reverseSql = `ALTER TABLE ${quoteIdent(tableName)} ALTER COLUMN ${quoteIdent(snakeName)} TYPE ${oldSqlType} USING ${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);
@@ -355,15 +358,15 @@ export 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 ${quoteIdent(tableName)} ALTER COLUMN ${quoteIdent(snakeName)} SET NOT NULL;`;
-                    const reverseSql = `ALTER TABLE ${quoteIdent(tableName)} ALTER COLUMN ${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 ${quoteIdent(tableName)} ALTER COLUMN ${quoteIdent(snakeName)} DROP NOT NULL;`;
-                    const reverseSql = `ALTER TABLE ${quoteIdent(tableName)} ALTER COLUMN ${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);
@@ -375,16 +378,16 @@ export async function schemaDiff(schema, connectionString) {
                     const dbDefault = dbCol.columnDefault;
                     if (schemaDefault && !dbDefault) {
                         // Schema has default, DB doesn't
-                        const sql = `ALTER TABLE ${quoteIdent(tableName)} ALTER COLUMN ${quoteIdent(snakeName)} SET DEFAULT ${schemaDefault};`;
-                        const reverseSql = `ALTER TABLE ${quoteIdent(tableName)} ALTER COLUMN ${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 ${quoteIdent(tableName)} ALTER COLUMN ${quoteIdent(snakeName)} DROP DEFAULT;`;
-                        const reverseSql = `ALTER TABLE ${quoteIdent(tableName)} ALTER COLUMN ${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);
@@ -394,8 +397,8 @@ export async function schemaDiff(schema, connectionString) {
                         !isSequenceDefault(dbDefault) &&
                         !defaultsMatch(schemaDefault, dbDefault)) {
                         // Both have defaults but they differ
-                        const sql = `ALTER TABLE ${quoteIdent(tableName)} ALTER COLUMN ${quoteIdent(snakeName)} SET DEFAULT ${schemaDefault};`;
-                        const reverseSql = `ALTER TABLE ${quoteIdent(tableName)} ALTER COLUMN ${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);
@@ -407,16 +410,16 @@ export async function schemaDiff(schema, connectionString) {
                     const wantsUnique = config.isUnique === true;
                     if (wantsUnique && !hasDbUnique) {
                         const constraintName = `${tableName}_${snakeName}_key`;
-                        const sql = `ALTER TABLE ${quoteIdent(tableName)} ADD CONSTRAINT ${quoteIdent(constraintName)} UNIQUE (${quoteIdent(snakeName)});`;
-                        const reverseSql = `ALTER TABLE ${quoteIdent(tableName)} DROP CONSTRAINT ${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 ${quoteIdent(tableName)} DROP CONSTRAINT ${quoteIdent(constraintName)};`;
-                        const reverseSql = `ALTER TABLE ${quoteIdent(tableName)} ADD CONSTRAINT ${quoteIdent(constraintName)} UNIQUE (${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);
@@ -427,7 +430,7 @@ export async function schemaDiff(schema, connectionString) {
             for (const dbColName of Object.keys(dbCols)) {
                 const hasField = Object.entries(tableDef.columns).some(([fieldName]) => camelToSnake(fieldName) === dbColName);
                 if (!hasField) {
-                    const sql = `ALTER TABLE ${quoteIdent(tableName)} DROP COLUMN ${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
@@ -560,8 +563,8 @@ export async function schemaPush(schema, connectionString, options = {}) {
  * Generate the full DDL as a single formatted string.
  * Useful for printing or saving to a .sql file.
  */
-export function schemaToSQLString(schema) {
-    const statements = schemaToSQL(schema);
+export function schemaToSQLString(schema, options) {
+    const statements = schemaToSQL(schema, options);
     return `${statements.join('\n\n')}\n`;
 }
 //# sourceMappingURL=schema-sql.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "turbine-orm",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "description": "Postgres-native TypeScript ORM — runs on Neon, Vercel Postgres, Cloudflare, Supabase. Streaming cursors, typed errors, single-query nested relations. 1 dependency, ~110KB",
   "type": "module",
   "exports": {
@@ -28,7 +28,7 @@
   "main": "./dist/cjs/index.js",
   "types": "./dist/index.d.ts",
   "bin": {
-    "turbine": "./dist/cli/index.js"
+    "turbine": "dist/cli/index.js"
   },
   "files": [
     "dist",
@@ -101,7 +101,7 @@
   "homepage": "https://turbineorm.dev",
   "repository": {
     "type": "git",
-    "url": "https://github.com/zvndev/turbine-orm.git"
+    "url": "git+https://github.com/zvndev/turbine-orm.git"
   },
   "bugs": {
     "url": "https://github.com/zvndev/turbine-orm/issues"