turbine-orm 0.11.0 → 0.13.0

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.11.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"