turbine-orm 0.5.0 → 0.7.1

package/dist/schema-sql.js

@@ -1,12 +1,12 @@
 /**
- * @batadata/turbine — Schema SQL Generator
+ * turbine-orm — Schema SQL Generator
  *
  * Converts a SchemaDef (from defineSchema) into executable DDL statements.
  * Also provides diff and push commands for syncing schema to a live database.
  */
 import pg from 'pg';
-import { camelToSnake } from './schema.js';
 import { quoteIdent } from './query.js';
+import { camelToSnake } from './schema.js';
 // ---------------------------------------------------------------------------
 // SQL Generation — SchemaDef → CREATE TABLE statements
 // ---------------------------------------------------------------------------
@@ -20,10 +20,11 @@ export function schemaToSQL(schema) {
     const statements = [];
     // Topologically sort tables by their foreign key references
     const sorted = topologicalSort(schema);
+    const resolveRef = makeRefResolver(schema);
     // Generate CREATE TABLE statements
     for (const tableName of sorted) {
         const table = schema.tables[tableName];
-        statements.push(generateCreateTable(table));
+        statements.push(generateCreateTable(table, resolveRef));
     }
     // Generate CREATE INDEX for foreign key columns
     for (const tableName of sorted) {
@@ -33,12 +34,51 @@ export function schemaToSQL(schema) {
     }
     return statements;
 }
+/**
+ * Build a function that resolves a raw `references: 'foo.id'` target name
+ * to the snake_case DDL table name. Accepts both the JS-facing camelCase
+ * accessor name and the snake_case DDL name; passes through unknown names
+ * unchanged so existing call sites continue to work.
+ */
+function makeRefResolver(schema) {
+    const lookup = buildTableLookup(schema);
+    return (rawName) => {
+        const key = lookup[rawName];
+        if (key) {
+            const def = schema.tables[key];
+            if (def?.name)
+                return def.name;
+        }
+        return rawName;
+    };
+}
+/**
+ * Build a lookup index from both DDL names (snake_case) and JS accessor
+ * names (camelCase) to table keys, so `references: 'post_tags.id'` and
+ * `references: 'postTags.id'` both resolve to the same TableDef.
+ */
+function buildTableLookup(schema) {
+    const lookup = {};
+    for (const [key, def] of Object.entries(schema.tables)) {
+        lookup[key] = key;
+        if (def.name && def.name !== key)
+            lookup[def.name] = key;
+        if (def.accessor && def.accessor !== key)
+            lookup[def.accessor] = key;
+    }
+    return lookup;
+}
 /**
  * Topologically sort tables so that referenced tables come before referencing ones.
+ * Returns the table keys (the same keys used in `schema.tables`). The keys are
+ * the JS-facing accessor names; consumers should still call `table.name` to get
+ * the snake_case DDL name when emitting SQL.
+ *
  * Falls back to input order for tables with no dependency ordering.
  */
 function topologicalSort(schema) {
     const tableNames = Object.keys(schema.tables);
+    const lookup = buildTableLookup(schema);
     const resolved = new Set();
     const result = [];
     const visiting = new Set();
@@ -55,9 +95,10 @@ function topologicalSort(schema) {
             // Visit all tables this table references
             for (const col of Object.values(table.columns)) {
                 if (col.referencesTarget) {
-                    const refTable = col.referencesTarget.split('.')[0];
-                    if (refTable !== name && schema.tables[refTable]) {
-                        visit(refTable);
+                    const refRaw = col.referencesTarget.split('.')[0];
+                    const refKey = lookup[refRaw];
+                    if (refKey && refKey !== name) {
+                        visit(refKey);
                     }
                 }
             }
@@ -73,12 +114,28 @@ function topologicalSort(schema) {
 }
 /**
  * Generate a CREATE TABLE statement for a single table definition.
+ *
+ * If `table.primaryKey` is set (composite primary key), emits a table-level
+ * `PRIMARY KEY ("col1", "col2", ...)` constraint instead of column-level
+ * `PRIMARY KEY` clauses on each member column. The composite PK column
+ * names are camelCase JS field names; they are converted to snake_case
+ * here.
+ *
+ * `resolveRef` (when supplied) maps raw `references: 'foo.id'` table names
+ * to their snake_case DDL form, so users can write either camelCase JS
+ * accessor names or snake_case DDL names.
  */
-function generateCreateTable(table) {
+function generateCreateTable(table, resolveRef) {
     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));
+        columnDefs.push(generateColumnDef(fieldName, config, resolveRef));
+    }
+    // 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 body = columnDefs.map((d) => `    ${d}`).join(',\n');
     return `CREATE TABLE ${quoteIdent(tableName)} (\n${body}\n);`;
@@ -86,7 +143,7 @@ function generateCreateTable(table) {
 /**
  * Generate a single column definition line (e.g. "id BIGSERIAL PRIMARY KEY").
  */
-function generateColumnDef(fieldName, config) {
+function generateColumnDef(fieldName, config, resolveRef) {
     const snakeName = camelToSnake(fieldName);
     const parts = [quoteIdent(snakeName)];
     // Type
@@ -120,11 +177,14 @@ function generateColumnDef(fieldName, config) {
         const sqlDefault = normalizeDefault(config.defaultValue);
         parts.push(`DEFAULT ${sqlDefault}`);
     }
-    // REFERENCES
+    // REFERENCES — resolve the raw table name through the optional resolver so
+    // both camelCase accessor names and snake_case DDL names work.
     if (config.referencesTarget) {
         const refParts = config.referencesTarget.split('.');
         if (refParts.length === 2) {
-            parts.push(`REFERENCES ${quoteIdent(refParts[0])}(${quoteIdent(refParts[1])})`);
+            const rawTable = refParts[0];
+            const refTable = resolveRef ? resolveRef(rawTable) : rawTable;
+            parts.push(`REFERENCES ${quoteIdent(refTable)}(${quoteIdent(refParts[1])})`);
         }
     }
     return parts.join(' ');
@@ -145,9 +205,7 @@ function normalizeDefault(val) {
         return upper;
     }
     // Known SQL function calls: NOW(), CURRENT_TIMESTAMP, CURRENT_DATE, CURRENT_TIME, GEN_RANDOM_UUID()
-    const allowedFunctions = [
-        'NOW()', 'CURRENT_TIMESTAMP', 'CURRENT_DATE', 'CURRENT_TIME', 'GEN_RANDOM_UUID()',
-    ];
+    const allowedFunctions = ['NOW()', 'CURRENT_TIMESTAMP', 'CURRENT_DATE', 'CURRENT_TIME', 'GEN_RANDOM_UUID()'];
     if (allowedFunctions.includes(upper)) {
         return upper;
     }
@@ -155,8 +213,12 @@ function normalizeDefault(val) {
     if (/^-?\d+(\.\d+)?$/.test(val.trim())) {
         return val.trim();
     }
-    // Simple single-quoted string literals (no nested quotes)
+    // Simple single-quoted string literals (no semicolons, no SQL statement keywords)
     if (/^'[^']*'$/.test(val.trim())) {
+        const inner = val.trim().slice(1, -1);
+        if (/[;]/.test(inner) || /\b(DROP|ALTER|CREATE|INSERT|UPDATE|DELETE|GRANT|REVOKE|TRUNCATE)\b/i.test(inner)) {
+            throw new Error(`Suspicious default value: ${val}. String literals must not contain SQL statements.`);
+        }
         return val.trim();
     }
     throw new Error(`Unsupported default value: ${val}. Use a SQL function, numeric, string literal, or NULL.`);
@@ -207,66 +269,158 @@ export async function schemaDiff(schema, connectionString) {
                 maxLength: row.character_maximum_length,
             };
         }
-        const schemaTableNames = new Set(Object.keys(schema.tables));
-        const result = { create: [], alter: [], drop: [], statements: [] };
+        // Get single-column UNIQUE constraints (excluding PKs)
+        const uniqueResult = await client.query(`SELECT tc.table_name, tc.constraint_name, kcu.column_name
+       FROM information_schema.table_constraints tc
+       JOIN information_schema.key_column_usage kcu
+         ON tc.constraint_name = kcu.constraint_name
+         AND tc.table_schema = kcu.table_schema
+       WHERE tc.table_schema = 'public'
+         AND tc.constraint_type = 'UNIQUE'
+         AND tc.constraint_name IN (
+           SELECT constraint_name
+           FROM information_schema.key_column_usage
+           WHERE table_schema = 'public'
+           GROUP BY constraint_name
+           HAVING COUNT(*) = 1
+         )`);
+        // Map: table → column → constraint_name for single-col uniques
+        const dbUniques = {};
+        for (const row of uniqueResult.rows) {
+            if (!dbUniques[row.table_name])
+                dbUniques[row.table_name] = {};
+            dbUniques[row.table_name][row.column_name] = row.constraint_name;
+        }
+        // Build a set of DDL-facing snake_case table names that the schema defines.
+        const schemaDdlNames = new Set();
+        for (const def of Object.values(schema.tables))
+            schemaDdlNames.add(def.name);
+        const result = { create: [], alter: [], drop: [], statements: [], reverseStatements: [] };
+        const resolveRef = makeRefResolver(schema);
         // Tables to create (in schema but not in DB)
         const sorted = topologicalSort(schema);
-        for (const tableName of sorted) {
-            if (!existingTables.has(tableName)) {
-                const tableDef = schema.tables[tableName];
+        for (const tableKey of sorted) {
+            const tableDef = schema.tables[tableKey];
+            const ddlName = tableDef.name;
+            if (!existingTables.has(ddlName)) {
                 result.create.push(tableDef);
-                result.statements.push(generateCreateTable(tableDef));
-                // Also add FK indexes
-                result.statements.push(...generateForeignKeyIndexes(tableDef));
+                result.statements.push(generateCreateTable(tableDef, resolveRef));
+                const fkIndexes = generateForeignKeyIndexes(tableDef);
+                result.statements.push(...fkIndexes);
+                // Reverse: DROP TABLE (with indexes — they drop automatically)
+                result.reverseStatements.unshift(`DROP TABLE IF EXISTS ${quoteIdent(ddlName)} CASCADE;`);
             }
         }
         // Tables to drop (in DB but not in schema)
         for (const existingTable of existingTables) {
-            if (!schemaTableNames.has(existingTable)) {
+            if (!schemaDdlNames.has(existingTable)) {
                 result.drop.push(existingTable);
                 // We don't auto-generate DROP statements for safety
             }
         }
         // Tables to alter (exist in both)
-        for (const tableName of sorted) {
+        for (const tableKey of sorted) {
+            const tableDef = schema.tables[tableKey];
+            const tableName = tableDef.name;
             if (!existingTables.has(tableName))
                 continue;
-            const tableDef = schema.tables[tableName];
             const dbCols = dbColumns[tableName] ?? {};
+            const tableUniques = dbUniques[tableName] ?? {};
             const alterDef = { table: tableName, columns: [] };
             for (const [fieldName, config] of Object.entries(tableDef.columns)) {
                 const snakeName = camelToSnake(fieldName);
                 const dbCol = dbCols[snakeName];
                 if (!dbCol) {
                     // Column exists in schema but not in DB — ADD COLUMN
-                    const colDef = generateColumnDef(fieldName, config);
+                    const colDef = generateColumnDef(fieldName, config, resolveRef);
                     const sql = `ALTER TABLE ${quoteIdent(tableName)} ADD COLUMN ${colDef};`;
-                    alterDef.columns.push({ column: snakeName, action: 'add', sql });
+                    const reverseSql = `ALTER TABLE ${quoteIdent(tableName)} DROP COLUMN ${quoteIdent(snakeName)};`;
+                    alterDef.columns.push({ column: snakeName, action: 'add', sql, reverseSql });
                     result.statements.push(sql);
+                    result.reverseStatements.unshift(reverseSql);
                     continue;
                 }
                 // Check type mismatch
                 const expectedUdt = schemaTypeToUdt(config);
                 if (expectedUdt && dbCol.udtName !== expectedUdt) {
-                    const sqlType = config.type === 'VARCHAR' && config.maxLength
-                        ? `VARCHAR(${config.maxLength})`
-                        : config.type;
-                    const sql = `ALTER TABLE ${quoteIdent(tableName)} ALTER COLUMN ${quoteIdent(snakeName)} TYPE ${sqlType};`;
-                    alterDef.columns.push({ column: snakeName, action: 'alter_type', sql });
+                    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};`;
+                    alterDef.columns.push({ column: snakeName, action: 'alter_type', sql, reverseSql });
                     result.statements.push(sql);
+                    result.reverseStatements.unshift(reverseSql);
                 }
                 // Check NOT NULL mismatch
                 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;`;
-                    alterDef.columns.push({ column: snakeName, action: 'set_not_null', sql });
+                    const reverseSql = `ALTER TABLE ${quoteIdent(tableName)} ALTER COLUMN ${quoteIdent(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;`;
-                    alterDef.columns.push({ column: snakeName, action: 'drop_not_null', sql });
+                    const reverseSql = `ALTER TABLE ${quoteIdent(tableName)} ALTER COLUMN ${quoteIdent(snakeName)} SET NOT NULL;`;
+                    alterDef.columns.push({ column: snakeName, action: 'drop_not_null', sql, reverseSql });
                     result.statements.push(sql);
+                    result.reverseStatements.unshift(reverseSql);
+                }
+                // Check DEFAULT value mismatch
+                const isSerial = config.type === 'BIGSERIAL';
+                if (!isSerial) {
+                    const schemaDefault = config.defaultValue ? normalizeDefault(config.defaultValue) : null;
+                    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;`;
+                        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};`;
+                        alterDef.columns.push({ column: snakeName, action: 'drop_default', sql, reverseSql });
+                        result.statements.push(sql);
+                        result.reverseStatements.unshift(reverseSql);
+                    }
+                    else if (schemaDefault &&
+                        dbDefault &&
+                        !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};`;
+                        alterDef.columns.push({ column: snakeName, action: 'set_default', sql, reverseSql });
+                        result.statements.push(sql);
+                        result.reverseStatements.unshift(reverseSql);
+                    }
+                }
+                // Check UNIQUE constraint mismatch (skip PKs — they're implicitly unique)
+                if (!config.isPrimaryKey) {
+                    const hasDbUnique = snakeName in tableUniques;
+                    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)};`;
+                        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)});`;
+                        alterDef.columns.push({ column: snakeName, action: 'drop_unique', sql, reverseSql });
+                        result.statements.push(sql);
+                        result.reverseStatements.unshift(reverseSql);
+                    }
                 }
             }
             // Check for columns in DB that are not in schema
@@ -274,7 +428,8 @@ export async function schemaDiff(schema, connectionString) {
                 const hasField = Object.entries(tableDef.columns).some(([fieldName]) => camelToSnake(fieldName) === dbColName);
                 if (!hasField) {
                     const sql = `ALTER TABLE ${quoteIdent(tableName)} DROP COLUMN ${quoteIdent(dbColName)};`;
-                    alterDef.columns.push({ column: dbColName, action: 'drop', sql });
+                    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
                 }
             }
@@ -311,6 +466,55 @@ function schemaTypeToUdt(config) {
     };
     return map[config.type] ?? null;
 }
+/**
+ * Reverse map: PostgreSQL UDT name → SQL type (for generating reverse ALTER TYPE).
+ */
+function udtToSqlType(udtName, maxLength) {
+    const map = {
+        int8: 'BIGINT',
+        int4: 'INTEGER',
+        int2: 'SMALLINT',
+        text: 'TEXT',
+        varchar: maxLength ? `VARCHAR(${maxLength})` : 'VARCHAR',
+        bool: 'BOOLEAN',
+        timestamptz: 'TIMESTAMPTZ',
+        date: 'DATE',
+        jsonb: 'JSONB',
+        uuid: 'UUID',
+        float4: 'REAL',
+        float8: 'DOUBLE PRECISION',
+        numeric: 'NUMERIC',
+        bytea: 'BYTEA',
+    };
+    return map[udtName] ?? udtName.toUpperCase();
+}
+/**
+ * Normalize a database default value for comparison.
+ * Strips PostgreSQL type casts (e.g. 'free'::text → 'free') and wrapping parens.
+ */
+function normalizeDbDefault(dbDefault) {
+    let val = dbDefault;
+    // Strip type casts: 'free'::text → 'free', 0::integer → 0
+    val = val.replace(/::[\w\s"]+(\[\])?$/g, '').trim();
+    // Unwrap parens added by PostgreSQL: ('free') → 'free'
+    while (val.startsWith('(') && val.endsWith(')')) {
+        val = val.slice(1, -1).trim();
+    }
+    return val;
+}
+/** Check if a DB default is a sequence default (auto-generated for serial columns). */
+function isSequenceDefault(dbDefault) {
+    return dbDefault.includes('nextval(');
+}
+/**
+ * Compare a schema default against a database default, accounting for
+ * PostgreSQL's normalization of default values.
+ */
+function defaultsMatch(schemaDefault, dbDefault) {
+    const a = schemaDefault.toLowerCase().trim();
+    const b = normalizeDbDefault(dbDefault).toLowerCase().trim();
+    return a === b;
+}
 /**
  * Push a schema definition to a live database.
  *
@@ -358,6 +562,6 @@ export async function schemaPush(schema, connectionString, options = {}) {
  */
 export function schemaToSQLString(schema) {
     const statements = schemaToSQL(schema);
-    return statements.join('\n\n') + '\n';
+    return `${statements.join('\n\n')}\n`;
 }
 //# sourceMappingURL=schema-sql.js.map

package/dist/schema.d.ts

@@ -1,5 +1,5 @@
 /**
- * @batadata/turbine — Schema metadata types
+ * turbine-orm — Schema metadata types
  *
  * These types represent the introspected database schema at runtime.
  * They're used by the query builder, code generator, and CLI.

package/dist/schema.js

@@ -1,5 +1,5 @@
 /**
- * @batadata/turbine — Schema metadata types
+ * turbine-orm — Schema metadata types
  *
  * These types represent the introspected database schema at runtime.
  * They're used by the query builder, code generator, and CLI.
@@ -11,6 +11,9 @@ const PG_TO_TS = {
     // Integers
     int2: 'number',
     int4: 'number',
+    // int8 maps to `number` for DX (auto-increment IDs, counts, etc.).
+    // Values exceeding Number.MAX_SAFE_INTEGER (2^53 - 1) are returned as
+    // `string` at runtime to avoid precision loss. See client.ts int8 parser.
     int8: 'number',
     float4: 'number',
     float8: 'number',
@@ -119,7 +122,7 @@ export function snakeToPascal(s) {
 /** Naive singularize: "posts" → "post", "categories" → "category" */
 export function singularize(s) {
     if (s.endsWith('ies'))
-        return s.slice(0, -3) + 'y';
+        return `${s.slice(0, -3)}y`;
     if (s.endsWith('ses') || s.endsWith('xes') || s.endsWith('zes'))
         return s.slice(0, -2);
     if (s.endsWith('s') && !s.endsWith('ss'))