turbine-orm 0.5.0 → 0.7.1

package/dist/cjs/schema-builder.js

@@ -1,6 +1,6 @@
 "use strict";
 /**
- * @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,
@@ -8,7 +8,7 @@
  *
  * @example
  * ```ts
- * import { defineSchema } from '@batadata/turbine';
+ * import { defineSchema } from 'turbine-orm';
  *
  * export default defineSchema({
  *   users: {
@@ -47,6 +47,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,
@@ -83,23 +86,74 @@ function isTableDef(v) {
  */
 function defineSchema(input) {
     const tables = {};
-    for (const [tableName, value] of Object.entries(input)) {
+    for (const [accessor, value] of Object.entries(input)) {
+        // The user-facing key is the camelCase JS accessor; the DDL-facing
+        // table name is its snake_case form (e.g. `postTags` → `post_tags`).
+        const dbName = camelToSnakeLocal(accessor);
         if (isTableDef(value)) {
             // Legacy format: defineSchema({ users: table({ ... }) })
-            value.name = tableName;
-            tables[tableName] = value;
+            // Stamp both the DDL name and the JS accessor.
+            value.name = dbName;
+            value.accessor = accessor;
+            tables[accessor] = value;
         }
         else {
             // Object format: defineSchema({ users: { id: { type: 'serial' }, ... } })
+            const raw = value;
             const columns = {};
-            for (const [fieldName, def] of Object.entries(value)) {
+            let pk;
+            for (const [fieldName, def] of Object.entries(raw)) {
+                if (fieldName === 'primaryKey') {
+                    // Top-level composite primary key declaration
+                    if (def !== undefined) {
+                        if (!Array.isArray(def)) {
+                            throw new Error(`Table "${accessor}": top-level "primaryKey" must be an array of column names (string[])`);
+                        }
+                        pk = def;
+                    }
+                    continue;
+                }
+                // Anything else is a ColumnDef
                 columns[fieldName] = resolveColumn(def);
             }
-            tables[tableName] = { name: tableName, columns };
+            // Validate composite PK references real columns and clear column-level PKs
+            // for those columns so we don't double-emit `PRIMARY KEY` clauses.
+            // Composite PK members are implicitly NOT NULL — preserve that even
+            // when the user clears the column-level `primaryKey: true` flag.
+            if (pk && pk.length > 0) {
+                for (const colName of pk) {
+                    if (!(colName in columns)) {
+                        throw new Error(`Table "${accessor}": composite primaryKey references unknown column "${colName}". ` +
+                            `Known columns: ${Object.keys(columns).join(', ') || '(none)'}`);
+                    }
+                    // A composite PK at the table level supersedes any column-level
+                    // `primaryKey: true` flag — silently clear it so DDL emission
+                    // produces a single, valid table-level PRIMARY KEY constraint.
+                    // Force NOT NULL since PK columns can never be nullable.
+                    const c = columns[colName];
+                    if (c) {
+                        c.isPrimaryKey = false;
+                        c.isNotNull = true;
+                    }
+                }
+            }
+            tables[accessor] = {
+                name: dbName,
+                accessor,
+                columns,
+                ...(pk && pk.length > 0 ? { primaryKey: pk } : {}),
+            };
         }
     }
     return { tables };
 }
+/**
+ * Local copy of camelToSnake to avoid a circular import dependency at the
+ * top of the file. Mirrors the implementation in `./schema.ts`.
+ */
+function camelToSnakeLocal(s) {
+    return s.replace(/[A-Z]/g, (c) => `_${c.toLowerCase()}`);
+}
 // ---------------------------------------------------------------------------
 // Legacy compat — ColumnBuilder still works for existing code
 // ---------------------------------------------------------------------------
@@ -117,28 +171,94 @@ 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 };
+    }
 }
 exports.ColumnBuilder = ColumnBuilder;
 /** @deprecated Use defineSchema() with plain objects instead */
@@ -160,7 +280,7 @@ function table(columns) {
     for (const [fieldName, builder] of Object.entries(columns)) {
         built[fieldName] = builder.build();
     }
-    return { name: '', columns: built };
+    return { name: '', accessor: '', columns: built };
 }
 // ---------------------------------------------------------------------------
 // Helpers

package/dist/cjs/schema-sql.js

@@ -1,6 +1,6 @@
 "use strict";
 /**
- * @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.
@@ -14,8 +14,8 @@ exports.schemaDiff = schemaDiff;
 exports.schemaPush = schemaPush;
 exports.schemaToSQLString = schemaToSQLString;
 const pg_1 = __importDefault(require("pg"));
-const schema_js_1 = require("./schema.js");
 const query_js_1 = require("./query.js");
+const schema_js_1 = require("./schema.js");
 // ---------------------------------------------------------------------------
 // SQL Generation — SchemaDef → CREATE TABLE statements
 // ---------------------------------------------------------------------------
@@ -29,10 +29,11 @@ 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) {
@@ -42,12 +43,51 @@ 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();
@@ -64,9 +104,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);
                     }
                 }
             }
@@ -82,12 +123,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) => (0, query_js_1.quoteIdent)((0, schema_js_1.camelToSnake)(c))).join(', ');
+        columnDefs.push(`PRIMARY KEY (${cols})`);
     }
     const body = columnDefs.map((d) => `    ${d}`).join(',\n');
     return `CREATE TABLE ${(0, query_js_1.quoteIdent)(tableName)} (\n${body}\n);`;
@@ -95,7 +152,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 = (0, schema_js_1.camelToSnake)(fieldName);
     const parts = [(0, query_js_1.quoteIdent)(snakeName)];
     // Type
@@ -129,11 +186,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 ${(0, query_js_1.quoteIdent)(refParts[0])}(${(0, query_js_1.quoteIdent)(refParts[1])})`);
+            const rawTable = refParts[0];
+            const refTable = resolveRef ? resolveRef(rawTable) : rawTable;
+            parts.push(`REFERENCES ${(0, query_js_1.quoteIdent)(refTable)}(${(0, query_js_1.quoteIdent)(refParts[1])})`);
         }
     }
     return parts.join(' ');
@@ -154,9 +214,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;
     }
@@ -164,8 +222,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.`);
@@ -216,66 +278,158 @@ 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 ${(0, query_js_1.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 = (0, schema_js_1.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 ${(0, query_js_1.quoteIdent)(tableName)} ADD COLUMN ${colDef};`;
-                    alterDef.columns.push({ column: snakeName, action: 'add', sql });
+                    const reverseSql = `ALTER TABLE ${(0, query_js_1.quoteIdent)(tableName)} DROP COLUMN ${(0, query_js_1.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 ${(0, query_js_1.quoteIdent)(tableName)} ALTER COLUMN ${(0, query_js_1.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 ${(0, query_js_1.quoteIdent)(tableName)} ALTER COLUMN ${(0, query_js_1.quoteIdent)(snakeName)} TYPE ${sqlType} USING ${(0, query_js_1.quoteIdent)(snakeName)}::${sqlType};`;
+                    const reverseSql = `ALTER TABLE ${(0, query_js_1.quoteIdent)(tableName)} ALTER COLUMN ${(0, query_js_1.quoteIdent)(snakeName)} TYPE ${oldSqlType} USING ${(0, query_js_1.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 ${(0, query_js_1.quoteIdent)(tableName)} ALTER COLUMN ${(0, query_js_1.quoteIdent)(snakeName)} SET NOT NULL;`;
-                    alterDef.columns.push({ column: snakeName, action: 'set_not_null', sql });
+                    const reverseSql = `ALTER TABLE ${(0, query_js_1.quoteIdent)(tableName)} ALTER COLUMN ${(0, query_js_1.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 ${(0, query_js_1.quoteIdent)(tableName)} ALTER COLUMN ${(0, query_js_1.quoteIdent)(snakeName)} DROP NOT NULL;`;
-                    alterDef.columns.push({ column: snakeName, action: 'drop_not_null', sql });
+                    const reverseSql = `ALTER TABLE ${(0, query_js_1.quoteIdent)(tableName)} ALTER COLUMN ${(0, query_js_1.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 ${(0, query_js_1.quoteIdent)(tableName)} ALTER COLUMN ${(0, query_js_1.quoteIdent)(snakeName)} SET DEFAULT ${schemaDefault};`;
+                        const reverseSql = `ALTER TABLE ${(0, query_js_1.quoteIdent)(tableName)} ALTER COLUMN ${(0, query_js_1.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 ${(0, query_js_1.quoteIdent)(tableName)} ALTER COLUMN ${(0, query_js_1.quoteIdent)(snakeName)} DROP DEFAULT;`;
+                        const reverseSql = `ALTER TABLE ${(0, query_js_1.quoteIdent)(tableName)} ALTER COLUMN ${(0, query_js_1.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 ${(0, query_js_1.quoteIdent)(tableName)} ALTER COLUMN ${(0, query_js_1.quoteIdent)(snakeName)} SET DEFAULT ${schemaDefault};`;
+                        const reverseSql = `ALTER TABLE ${(0, query_js_1.quoteIdent)(tableName)} ALTER COLUMN ${(0, query_js_1.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 ${(0, query_js_1.quoteIdent)(tableName)} ADD CONSTRAINT ${(0, query_js_1.quoteIdent)(constraintName)} UNIQUE (${(0, query_js_1.quoteIdent)(snakeName)});`;
+                        const reverseSql = `ALTER TABLE ${(0, query_js_1.quoteIdent)(tableName)} DROP CONSTRAINT ${(0, query_js_1.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 ${(0, query_js_1.quoteIdent)(tableName)} DROP CONSTRAINT ${(0, query_js_1.quoteIdent)(constraintName)};`;
+                        const reverseSql = `ALTER TABLE ${(0, query_js_1.quoteIdent)(tableName)} ADD CONSTRAINT ${(0, query_js_1.quoteIdent)(constraintName)} UNIQUE (${(0, query_js_1.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
@@ -283,7 +437,8 @@ async function schemaDiff(schema, connectionString) {
                 const hasField = Object.entries(tableDef.columns).some(([fieldName]) => (0, schema_js_1.camelToSnake)(fieldName) === dbColName);
                 if (!hasField) {
                     const sql = `ALTER TABLE ${(0, query_js_1.quoteIdent)(tableName)} DROP COLUMN ${(0, query_js_1.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
                 }
             }
@@ -320,6 +475,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.
  *
@@ -367,5 +571,5 @@ async function schemaPush(schema, connectionString, options = {}) {
  */
 function schemaToSQLString(schema) {
     const statements = schemaToSQL(schema);
-    return statements.join('\n\n') + '\n';
+    return `${statements.join('\n\n')}\n`;
 }