turbine-orm 0.5.0 → 0.7.0

package/dist/schema-builder.d.ts

@@ -1,5 +1,5 @@
 /**
- * @batadata/turbine — Schema Builder
+ * turbine-orm — Schema Builder
  *
  * TypeScript-first schema definition API. Define your database schema
  * as plain objects — no method chaining, no DSL. Fully type-checked,
@@ -7,7 +7,7 @@
  *
  * @example
  * ```ts
- * import { defineSchema } from '@batadata/turbine';
+ * import { defineSchema } from 'turbine-orm';
  *
  * export default defineSchema({
  *   users: {

package/dist/schema-builder.js

@@ -1,5 +1,5 @@
 /**
- * @batadata/turbine — Schema Builder
+ * turbine-orm — Schema Builder
  *
  * TypeScript-first schema definition API. Define your database schema
  * as plain objects — no method chaining, no DSL. Fully type-checked,
@@ -7,7 +7,7 @@
  *
  * @example
  * ```ts
- * import { defineSchema } from '@batadata/turbine';
+ * import { defineSchema } from 'turbine-orm';
  *
  * export default defineSchema({
  *   users: {
@@ -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

@@ -1,5 +1,5 @@
 /**
- * @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.
@@ -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

@@ -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
 // ---------------------------------------------------------------------------
@@ -145,9 +145,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 +153,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,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) {
@@ -216,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)
@@ -233,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);
@@ -241,32 +268,93 @@ export async function schemaDiff(schema, connectionString) {
                     // Column exists in schema but not in DB — ADD COLUMN
                     const colDef = generateColumnDef(fieldName, config);
                     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 +362,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 +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.
  *
@@ -358,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.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'))