turbine-orm 0.4.0 → 0.7.0

package/dist/schema-builder.js

@@ -22,7 +22,6 @@
  * });
  * ```
  */
-import { camelToSnake } from './schema.js';
 /** Maps shorthand names to actual Postgres type strings */
 const TYPE_MAP = {
     serial: 'BIGSERIAL',
@@ -43,6 +42,9 @@ const TYPE_MAP = {
 };
 /** Convert a user-facing ColumnDef to the internal ColumnConfig */
 function resolveColumn(def) {
+    if (!(def.type in TYPE_MAP)) {
+        throw new Error(`Invalid column type "${def.type}". Valid types: ${Object.keys(TYPE_MAP).join(', ')}`);
+    }
     return {
         type: TYPE_MAP[def.type],
         isPrimaryKey: def.primaryKey ?? false,
@@ -113,28 +115,94 @@ export class ColumnBuilder {
             maxLength: null,
         };
     }
-    serial() { this._config.type = 'BIGSERIAL'; return this; }
-    bigint() { this._config.type = 'BIGINT'; return this; }
-    integer() { this._config.type = 'INTEGER'; return this; }
-    smallint() { this._config.type = 'SMALLINT'; return this; }
-    text() { this._config.type = 'TEXT'; return this; }
-    varchar(length) { this._config.type = 'VARCHAR'; this._config.maxLength = length; return this; }
-    boolean() { this._config.type = 'BOOLEAN'; return this; }
-    timestamp() { this._config.type = 'TIMESTAMPTZ'; return this; }
-    date() { this._config.type = 'DATE'; return this; }
-    json() { this._config.type = 'JSONB'; return this; }
-    uuid() { this._config.type = 'UUID'; return this; }
-    real() { this._config.type = 'REAL'; return this; }
-    doublePrecision() { this._config.type = 'DOUBLE PRECISION'; return this; }
-    numeric() { this._config.type = 'NUMERIC'; return this; }
-    bytea() { this._config.type = 'BYTEA'; return this; }
-    primaryKey() { this._config.isPrimaryKey = true; return this; }
-    notNull() { this._config.isNotNull = true; return this; }
-    nullable() { this._config.isNullable = true; return this; }
-    unique() { this._config.isUnique = true; return this; }
-    default(val) { this._config.defaultValue = val; return this; }
-    references(target) { this._config.referencesTarget = target; return this; }
-    build() { return { ...this._config }; }
+    serial() {
+        this._config.type = 'BIGSERIAL';
+        return this;
+    }
+    bigint() {
+        this._config.type = 'BIGINT';
+        return this;
+    }
+    integer() {
+        this._config.type = 'INTEGER';
+        return this;
+    }
+    smallint() {
+        this._config.type = 'SMALLINT';
+        return this;
+    }
+    text() {
+        this._config.type = 'TEXT';
+        return this;
+    }
+    varchar(length) {
+        this._config.type = 'VARCHAR';
+        this._config.maxLength = length;
+        return this;
+    }
+    boolean() {
+        this._config.type = 'BOOLEAN';
+        return this;
+    }
+    timestamp() {
+        this._config.type = 'TIMESTAMPTZ';
+        return this;
+    }
+    date() {
+        this._config.type = 'DATE';
+        return this;
+    }
+    json() {
+        this._config.type = 'JSONB';
+        return this;
+    }
+    uuid() {
+        this._config.type = 'UUID';
+        return this;
+    }
+    real() {
+        this._config.type = 'REAL';
+        return this;
+    }
+    doublePrecision() {
+        this._config.type = 'DOUBLE PRECISION';
+        return this;
+    }
+    numeric() {
+        this._config.type = 'NUMERIC';
+        return this;
+    }
+    bytea() {
+        this._config.type = 'BYTEA';
+        return this;
+    }
+    primaryKey() {
+        this._config.isPrimaryKey = true;
+        return this;
+    }
+    notNull() {
+        this._config.isNotNull = true;
+        return this;
+    }
+    nullable() {
+        this._config.isNullable = true;
+        return this;
+    }
+    unique() {
+        this._config.isUnique = true;
+        return this;
+    }
+    default(val) {
+        this._config.defaultValue = val;
+        return this;
+    }
+    references(target) {
+        this._config.referencesTarget = target;
+        return this;
+    }
+    build() {
+        return { ...this._config };
+    }
 }
 /** @deprecated Use defineSchema() with plain objects instead */
 export const column = new Proxy({}, {

package/dist/schema-sql.d.ts

@@ -16,9 +16,11 @@ export interface AlterColumnDef {
     /** Column name in snake_case */
     column: string;
     /** What changed */
-    action: 'add' | 'drop' | 'alter_type' | 'set_not_null' | 'drop_not_null' | 'set_default' | 'drop_default';
+    action: 'add' | 'drop' | 'alter_type' | 'set_not_null' | 'drop_not_null' | 'set_default' | 'drop_default' | 'add_unique' | 'drop_unique';
     /** SQL fragment for the alteration */
     sql: string;
+    /** SQL to reverse this change (for DOWN migrations) */
+    reverseSql: string;
 }
 export interface AlterDef {
     /** Table name */
@@ -33,8 +35,10 @@ export interface DiffResult {
     alter: AlterDef[];
     /** Table names that exist in DB but not in schema — would need DROP TABLE */
     drop: string[];
-    /** SQL statements to execute the diff */
+    /** SQL statements to execute the diff (UP direction) */
     statements: string[];
+    /** SQL statements to reverse the diff (DOWN direction, for migrations) */
+    reverseStatements: string[];
 }
 /**
  * Compare a SchemaDef against a live Postgres database and return the diff.

package/dist/schema-sql.js

@@ -5,6 +5,7 @@
  * Also provides diff and push commands for syncing schema to a live database.
  */
 import pg from 'pg';
+import { quoteIdent } from './query.js';
 import { camelToSnake } from './schema.js';
 // ---------------------------------------------------------------------------
 // SQL Generation — SchemaDef → CREATE TABLE statements
@@ -17,7 +18,6 @@ import { camelToSnake } from './schema.js';
  */
 export function schemaToSQL(schema) {
     const statements = [];
-    const tableNames = Object.keys(schema.tables);
     // Topologically sort tables by their foreign key references
     const sorted = topologicalSort(schema);
     // Generate CREATE TABLE statements
@@ -81,14 +81,14 @@ function generateCreateTable(table) {
         columnDefs.push(generateColumnDef(fieldName, config));
     }
     const body = columnDefs.map((d) => `    ${d}`).join(',\n');
-    return `CREATE TABLE ${tableName} (\n${body}\n);`;
+    return `CREATE TABLE ${quoteIdent(tableName)} (\n${body}\n);`;
 }
 /**
  * Generate a single column definition line (e.g. "id BIGSERIAL PRIMARY KEY").
  */
 function generateColumnDef(fieldName, config) {
     const snakeName = camelToSnake(fieldName);
-    const parts = [snakeName];
+    const parts = [quoteIdent(snakeName)];
     // Type
     if (config.type === 'VARCHAR' && config.maxLength != null) {
         parts.push(`VARCHAR(${config.maxLength})`);
@@ -124,7 +124,7 @@ function generateColumnDef(fieldName, config) {
     if (config.referencesTarget) {
         const refParts = config.referencesTarget.split('.');
         if (refParts.length === 2) {
-            parts.push(`REFERENCES ${refParts[0]}(${refParts[1]})`);
+            parts.push(`REFERENCES ${quoteIdent(refParts[0])}(${quoteIdent(refParts[1])})`);
         }
     }
     return parts.join(' ');
@@ -139,11 +139,29 @@ function generateColumnDef(fieldName, config) {
  *   '0'      → 0
  */
 function normalizeDefault(val) {
-    // Recognize function calls like now(), gen_random_uuid(), etc.
-    if (/^[a-z_]+\(\)$/i.test(val)) {
-        return val.toUpperCase();
+    const upper = val.toUpperCase().trim();
+    // Known SQL constants
+    if (['TRUE', 'FALSE', 'NULL'].includes(upper)) {
+        return upper;
     }
-    return val;
+    // 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()'];
+    if (allowedFunctions.includes(upper)) {
+        return upper;
+    }
+    // Numeric literals (integer or decimal, optionally negative)
+    if (/^-?\d+(\.\d+)?$/.test(val.trim())) {
+        return val.trim();
+    }
+    // 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.`);
 }
 /**
  * Generate CREATE INDEX statements for foreign key columns.
@@ -155,7 +173,7 @@ function generateForeignKeyIndexes(table) {
         if (config.referencesTarget) {
             const snakeName = camelToSnake(fieldName);
             const indexName = `idx_${table.name}_${snakeName}`;
-            indexes.push(`CREATE INDEX ${indexName} ON ${table.name}(${snakeName});`);
+            indexes.push(`CREATE INDEX ${quoteIdent(indexName)} ON ${quoteIdent(table.name)}(${quoteIdent(snakeName)});`);
         }
     }
     return indexes;
@@ -191,8 +209,30 @@ export async function schemaDiff(schema, connectionString) {
                 maxLength: row.character_maximum_length,
             };
         }
+        // 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;
+        }
         const schemaTableNames = new Set(Object.keys(schema.tables));
-        const result = { create: [], alter: [], drop: [], statements: [] };
+        const result = { create: [], alter: [], drop: [], statements: [], reverseStatements: [] };
         // Tables to create (in schema but not in DB)
         const sorted = topologicalSort(schema);
         for (const tableName of sorted) {
@@ -200,8 +240,10 @@ export async function schemaDiff(schema, connectionString) {
                 const tableDef = schema.tables[tableName];
                 result.create.push(tableDef);
                 result.statements.push(generateCreateTable(tableDef));
-                // Also add FK indexes
-                result.statements.push(...generateForeignKeyIndexes(tableDef));
+                const fkIndexes = generateForeignKeyIndexes(tableDef);
+                result.statements.push(...fkIndexes);
+                // Reverse: DROP TABLE (with indexes — they drop automatically)
+                result.reverseStatements.unshift(`DROP TABLE IF EXISTS ${quoteIdent(tableName)} CASCADE;`);
             }
         }
         // Tables to drop (in DB but not in schema)
@@ -217,6 +259,7 @@ export async function schemaDiff(schema, connectionString) {
                 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);
@@ -224,41 +267,103 @@ export async function schemaDiff(schema, connectionString) {
                 if (!dbCol) {
                     // Column exists in schema but not in DB — ADD COLUMN
                     const colDef = generateColumnDef(fieldName, config);
-                    const sql = `ALTER TABLE ${tableName} ADD COLUMN ${colDef};`;
-                    alterDef.columns.push({ column: snakeName, action: 'add', sql });
+                    const sql = `ALTER TABLE ${quoteIdent(tableName)} ADD COLUMN ${colDef};`;
+                    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 ${tableName} ALTER COLUMN ${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 ${tableName} ALTER COLUMN ${snakeName} SET NOT NULL;`;
-                    alterDef.columns.push({ column: snakeName, action: 'set_not_null', sql });
+                    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;`;
+                    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 ${tableName} ALTER COLUMN ${snakeName} DROP NOT NULL;`;
-                    alterDef.columns.push({ column: snakeName, action: 'drop_not_null', sql });
+                    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;`;
+                    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
             for (const dbColName of Object.keys(dbCols)) {
                 const hasField = Object.entries(tableDef.columns).some(([fieldName]) => camelToSnake(fieldName) === dbColName);
                 if (!hasField) {
-                    const sql = `ALTER TABLE ${tableName} DROP COLUMN ${dbColName};`;
-                    alterDef.columns.push({ column: dbColName, action: 'drop', sql });
+                    const sql = `ALTER TABLE ${quoteIdent(tableName)} DROP COLUMN ${quoteIdent(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
                 }
             }
@@ -295,6 +400,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.
  *
@@ -342,6 +496,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.js

@@ -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'))