turbine-orm 0.27.0 → 0.28.0

package/dist/cjs/generate.js

@@ -12,6 +12,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generate = generate;
 exports.generateTypes = generateTypes;
+exports.generateZod = generateZod;
+exports.generateMetadata = generateMetadata;
+exports.generateIndex = generateIndex;
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const schema_js_1 = require("./schema.js");
@@ -19,6 +22,24 @@ const schema_js_1 = require("./schema.js");
 function entityName(tableName) {
     return (0, schema_js_1.snakeToPascal)((0, schema_js_1.singularize)(tableName));
 }
+/**
+ * Resolve the TypeScript type for a column, mapping enum-typed columns to their
+ * generated string-literal union (PascalCase enum name) instead of the
+ * `unknown` that {@link pgTypeToTs} yields for user-defined types. Falls back to
+ * the introspected `col.tsType` for every non-enum column.
+ */
+function columnTsType(col, enums) {
+    const dt = col.dialectType ?? col.pgType;
+    const isArray = col.isArray || dt.startsWith('_');
+    const base = isArray && dt.startsWith('_') ? dt.slice(1) : dt;
+    if (Object.hasOwn(enums, base)) {
+        let t = (0, schema_js_1.snakeToPascal)(base);
+        if (isArray)
+            t += '[]';
+        return col.nullable ? `${t} | null` : t;
+    }
+    return col.tsType;
+}
 /** Escape a value for embedding in a single-quoted TypeScript string literal */
 function escSQ(value) {
     return value.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
@@ -48,6 +69,12 @@ function generate(options) {
     const indexContent = generateIndex(options.schema);
     (0, node_fs_1.writeFileSync)((0, node_path_1.join)(outDir, 'index.ts'), indexContent, 'utf-8');
     files.push('index.ts');
+    // Generate zod.ts (optional — --zod flag)
+    if (options.zod) {
+        const zodContent = generateZod(options.schema);
+        (0, node_fs_1.writeFileSync)((0, node_path_1.join)(outDir, 'zod.ts'), zodContent, 'utf-8');
+        files.push('zod.ts');
+    }
     return { outDir, files };
 }
 // ---------------------------------------------------------------------------
@@ -108,7 +135,7 @@ function generateTypes(schema) {
             const pkNote = table.primaryKey.includes(col.name) ? ' (primary key)' : '';
             const nullNote = col.nullable ? ' (nullable)' : '';
             lines.push(`  /** Column: ${col.name} — ${col.pgType}${pkNote}${nullNote} */`);
-            lines.push(`  ${col.field}: ${col.tsType};`);
+            lines.push(`  ${col.field}: ${columnTsType(col, schema.enums)};`);
         }
         lines.push('}');
         lines.push('');
@@ -118,15 +145,18 @@ function generateTypes(schema) {
         lines.push(`/** Input type for creating a row in \`${table.name}\` */`);
         lines.push(`export type ${typeName}Create = {`);
         for (const col of table.columns) {
+            // STORED generated columns are computed by the database — never writable.
+            if (col.isGeneratedStored)
+                continue;
             const isPk = table.primaryKey.includes(col.name);
             const isOptional = col.hasDefault || col.nullable || isPk;
             if (isOptional) {
                 const reason = isPk ? 'auto-generated' : col.hasDefault ? 'has default' : 'nullable';
                 lines.push(`  /** Optional: ${reason} */`);
-                lines.push(`  ${col.field}?: ${col.tsType};`);
+                lines.push(`  ${col.field}?: ${columnTsType(col, schema.enums)};`);
             }
             else {
-                lines.push(`  ${col.field}: ${col.tsType};`);
+                lines.push(`  ${col.field}: ${columnTsType(col, schema.enums)};`);
             }
         }
         lines.push('};');
@@ -134,11 +164,11 @@ function generateTypes(schema) {
         // --- Update input type (all fields optional except PK) ---
         // Numeric columns additionally accept `UpdateOperatorInput<number>` so
         // users can write `{ viewCount: { increment: 1 } }` without an `as any`.
-        const nonPkCols = table.columns.filter((c) => !table.primaryKey.includes(c.name));
+        const nonPkCols = table.columns.filter((c) => !table.primaryKey.includes(c.name) && !c.isGeneratedStored);
         lines.push(`/** Input type for updating a row in \`${table.name}\` */`);
         lines.push(`export type ${typeName}Update = {`);
         for (const col of nonPkCols) {
-            lines.push(`  ${col.field}?: ${updateFieldType(col.tsType)};`);
+            lines.push(`  ${col.field}?: ${updateFieldType(columnTsType(col, schema.enums))};`);
         }
         lines.push('};');
         lines.push('');
@@ -271,6 +301,119 @@ function generateTypes(schema) {
     return lines.join('\n');
 }
 // ---------------------------------------------------------------------------
+// zod.ts generator (H1 — `turbine generate --zod`)
+// ---------------------------------------------------------------------------
+/**
+ * Map a TypeScript primitive (as produced by {@link pgTypeToTs}) to its Zod
+ * expression. `Date` uses `z.coerce.date()` — the generated schemas double as
+ * request-body validators where dates arrive as ISO strings, and coercion keeps
+ * both a `Date` and a valid date-string acceptable (documented decision).
+ */
+function zodScalar(ts) {
+    switch (ts) {
+        case 'number':
+            return 'z.number()';
+        case 'string':
+            return 'z.string()';
+        case 'boolean':
+            return 'z.boolean()';
+        case 'Date':
+            return 'z.coerce.date()';
+        case 'bigint':
+            return 'z.bigint()';
+        case 'Buffer':
+            return 'z.instanceof(Uint8Array)';
+        case 'number[]':
+            // pgvector — `pgTypeToTs('vector')` yields `number[]`.
+            return 'z.array(z.number())';
+        default:
+            // json/jsonb and any unmapped user-defined type.
+            return 'z.unknown()';
+    }
+}
+/**
+ * Base Zod expression for a column, resolving enums → `z.enum([...])`, arrays →
+ * `.array()`, and vectors → `z.array(z.number())`. Does NOT append
+ * `.nullable()` / `.optional()` — callers layer those on per-schema.
+ */
+function zodBaseType(col, enums) {
+    const dt = col.dialectType ?? col.pgType;
+    const isArray = col.isArray || dt.startsWith('_');
+    const base = isArray && dt.startsWith('_') ? dt.slice(1) : dt;
+    let expr;
+    if (Object.hasOwn(enums, base)) {
+        expr = `z.enum([${enums[base].map((l) => `'${escSQ(l)}'`).join(', ')}])`;
+    }
+    else {
+        expr = zodScalar((0, schema_js_1.pgTypeToTs)(base, false));
+    }
+    if (isArray)
+        expr += '.array()';
+    return expr;
+}
+/**
+ * Generate the contents of `zod.ts`. Emits, per table, `XSchema` (the full
+ * row), `XCreateSchema` (PK/defaulted/nullable columns optional, STORED
+ * generated columns omitted), and `XUpdateSchema` (PK + STORED generated
+ * columns omitted, every remaining column optional). Exported so tests can pin
+ * the output without writing files.
+ */
+function generateZod(schema) {
+    const lines = [...generatedFileHeader()];
+    // `zod` is a USER dependency — this generated file imports it, but the Turbine
+    // library runtime never does, so Zod stays out of the package's dep graph.
+    lines.push("import { z } from 'zod';");
+    lines.push('');
+    for (const table of Object.values(schema.tables)) {
+        const typeName = entityName(table.name);
+        // Full-row schema.
+        lines.push(`/** Zod schema for a \`${table.name}\` row */`);
+        lines.push(`export const ${typeName}Schema = z.object({`);
+        for (const col of table.columns) {
+            let expr = zodBaseType(col, schema.enums);
+            if (col.nullable)
+                expr += '.nullable()';
+            lines.push(`  ${col.field}: ${expr},`);
+        }
+        lines.push('});');
+        lines.push('');
+        // Create schema — STORED generated columns can never be written; PK,
+        // defaulted, and nullable columns are optional.
+        lines.push(`/** Zod schema for creating a \`${table.name}\` row */`);
+        lines.push(`export const ${typeName}CreateSchema = z.object({`);
+        for (const col of table.columns) {
+            if (col.isGeneratedStored)
+                continue;
+            const isPk = table.primaryKey.includes(col.name);
+            let expr = zodBaseType(col, schema.enums);
+            if (col.nullable)
+                expr += '.nullable()';
+            if (col.hasDefault || col.nullable || isPk)
+                expr += '.optional()';
+            lines.push(`  ${col.field}: ${expr},`);
+        }
+        lines.push('});');
+        lines.push('');
+        // Update schema — PK and STORED generated columns omitted; all else optional.
+        lines.push(`/** Zod schema for updating a \`${table.name}\` row */`);
+        lines.push(`export const ${typeName}UpdateSchema = z.object({`);
+        for (const col of table.columns) {
+            if (col.isGeneratedStored)
+                continue;
+            if (table.primaryKey.includes(col.name))
+                continue;
+            let expr = zodBaseType(col, schema.enums);
+            if (col.nullable)
+                expr += '.nullable()';
+            expr += '.optional()';
+            lines.push(`  ${col.field}: ${expr},`);
+        }
+        lines.push('});');
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+// ---------------------------------------------------------------------------
 // metadata.ts generator
 // ---------------------------------------------------------------------------
 function generateMetadata(schema) {
@@ -352,6 +495,9 @@ function generateMetadata(schema) {
             lines.push(`        { name: '${escSQ(idx.name)}', columns: [${idx.columns.map((c) => `'${escSQ(c)}'`).join(', ')}], unique: ${idx.unique}, definition: ${JSON.stringify(idx.definition)} },`);
         }
         lines.push('      ],');
+        // isView — read-only marker; the runtime write guard reads it.
+        if (table.isView)
+            lines.push('      isView: true,');
         lines.push('    },');
     }
     lines.push('  },');
@@ -409,7 +555,7 @@ function generateIndex(schema) {
         const hasRelations = Object.keys(table.relations).length > 0;
         const genericArgs = hasRelations ? `${typeName}, ${typeName}Relations` : typeName;
         lines.push(`  /** Query interface for the \`${table.name}\` table (transaction-scoped) */`);
-        lines.push(`  declare readonly ${accessor}: QueryInterface<${genericArgs}>;`);
+        lines.push(`  declare readonly ${accessor}: ${accessorType(table, genericArgs)};`);
     }
     lines.push('}');
     lines.push('');
@@ -451,7 +597,7 @@ function generateIndex(schema) {
         const hasRelations = Object.keys(table.relations).length > 0;
         const genericArgs = hasRelations ? `${typeName}, ${typeName}Relations` : typeName;
         lines.push(`  /** Query interface for the \`${table.name}\` table */`);
-        lines.push(`  declare readonly ${accessor}: QueryInterface<${genericArgs}>;`);
+        lines.push(`  declare readonly ${accessor}: ${accessorType(table, genericArgs)};`);
     }
     lines.push('');
     lines.push('  constructor(config?: TurbineConfig) {');
@@ -495,6 +641,18 @@ function generateIndex(schema) {
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
+/**
+ * The generated table-accessor type. A view (`isView`) without a primary key
+ * cannot be looked up by unique key, so its `findUnique`-family methods are
+ * excluded via `Omit`. Everything else is a plain `QueryInterface<…>`.
+ */
+function accessorType(table, genericArgs) {
+    const base = `QueryInterface<${genericArgs}>`;
+    if (table.isView && table.primaryKey.length === 0) {
+        return `Omit<${base}, 'findUnique' | 'findUniqueOrThrow'>`;
+    }
+    return base;
+}
 function serializeColumn(col) {
     const parts = [
         `name: '${escSQ(col.name)}'`,
@@ -512,6 +670,12 @@ function serializeColumn(col) {
     // output stays byte-identical for the common client-default columns.
     if (col.isGenerated)
         parts.push(`isGenerated: true`);
+    // STORED generated columns — the runtime write guard reads isGeneratedStored.
+    if (col.isGeneratedStored)
+        parts.push(`isGeneratedStored: true`);
+    if (col.generationExpression !== undefined) {
+        parts.push(`generationExpression: '${escSQ(col.generationExpression)}'`);
+    }
     if (col.maxLength !== undefined)
         parts.push(`maxLength: ${col.maxLength}`);
     return `{ ${parts.join(', ')} }`;

package/dist/cjs/index.js

@@ -35,7 +35,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ColumnBuilder = exports.applyManyToManyRelations = exports.snakeToPascal = exports.snakeToCamel = exports.singularize = exports.pgTypeToTs = exports.pgArrayType = exports.normalizeKeyColumns = exports.isDateType = exports.camelToSnake = exports.validateChannel = exports.QueryInterface = exports.pipelineSupported = exports.executePipeline = exports.hasRelationFields = exports.executeNestedUpdate = exports.executeNestedCreate = exports.introspect = exports.generate = exports.wrapPgError = exports.ValidationError = exports.UnsupportedFeatureError = exports.UniqueConstraintError = exports.TurbineErrorCode = exports.TurbineError = exports.TimeoutError = exports.setErrorMessageMode = exports.SerializationFailureError = exports.RelationError = exports.PipelineError = exports.OptimisticLockError = exports.NotNullViolationError = exports.NotFoundError = exports.MigrationError = exports.getErrorMessageMode = exports.ForeignKeyError = exports.ExclusionConstraintError = exports.DeadlockError = exports.ConnectionError = exports.CircularRelationError = exports.CheckConstraintError = exports.postgresDialect = exports.withRetry = exports.TurbineClient = exports.TransactionClient = exports.yugabytedb = exports.timescale = exports.postgresql = exports.cockroachdb = exports.alloydb = void 0;
-exports.TypedSqlQuery = exports.buildTypedSql = exports.turbineHttp = exports.schemaToSQLString = exports.schemaToSQL = exports.schemaPush = exports.schemaDiff = exports.table = exports.defineSchema = exports.column = void 0;
+exports.TypedSqlQuery = exports.buildTypedSql = exports.turbineHttp = exports.defineSeed = exports.schemaToSQLString = exports.schemaToSQL = exports.schemaPush = exports.schemaDiff = exports.table = exports.defineSchema = exports.column = void 0;
 var index_js_1 = require("./adapters/index.js");
 Object.defineProperty(exports, "alloydb", { enumerable: true, get: function () { return index_js_1.alloydb; } });
 Object.defineProperty(exports, "cockroachdb", { enumerable: true, get: function () { return index_js_1.cockroachdb; } });
@@ -118,6 +118,9 @@ Object.defineProperty(exports, "schemaDiff", { enumerable: true, get: function (
 Object.defineProperty(exports, "schemaPush", { enumerable: true, get: function () { return schema_sql_js_1.schemaPush; } });
 Object.defineProperty(exports, "schemaToSQL", { enumerable: true, get: function () { return schema_sql_js_1.schemaToSQL; } });
 Object.defineProperty(exports, "schemaToSQLString", { enumerable: true, get: function () { return schema_sql_js_1.schemaToSQLString; } });
+// Seed helper
+var seed_js_1 = require("./seed.js");
+Object.defineProperty(exports, "defineSeed", { enumerable: true, get: function () { return seed_js_1.defineSeed; } });
 // Serverless / edge factory
 var serverless_js_1 = require("./serverless.js");
 Object.defineProperty(exports, "turbineHttp", { enumerable: true, get: function () { return serverless_js_1.turbineHttp; } });

package/dist/cjs/introspect.js

@@ -12,11 +12,32 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.pgConfActionToReferential = pgConfActionToReferential;
 exports.introspect = introspect;
 exports.introspectPostgresCatalog = introspectPostgresCatalog;
+exports.stripCheckWrapper = stripCheckWrapper;
 const pg_1 = __importDefault(require("pg"));
 const dialect_js_1 = require("./dialect.js");
 const schema_js_1 = require("./schema.js");
+/**
+ * Map a `pg_constraint.confdeltype` / `confupdtype` character to a
+ * {@link ReferentialAction}. Postgres encodes: `a` = NO ACTION, `r` = RESTRICT,
+ * `c` = CASCADE, `n` = SET NULL, `d` = SET DEFAULT.
+ */
+function pgConfActionToReferential(ch) {
+    switch (ch) {
+        case 'c':
+            return 'cascade';
+        case 'r':
+            return 'restrict';
+        case 'n':
+            return 'set null';
+        case 'd':
+            return 'set default';
+        default:
+            return 'no action';
+    }
+}
 // ---------------------------------------------------------------------------
 // SQL queries (all parameterized, no interpolation)
 // ---------------------------------------------------------------------------
@@ -36,6 +57,8 @@ const SQL_COLUMNS = `
     is_nullable,
     column_default,
     is_identity,
+    is_generated,
+    generation_expression,
     ordinal_position,
     character_maximum_length
   FROM information_schema.columns
@@ -91,6 +114,65 @@ const SQL_INDEXES = `
   FROM pg_indexes
   WHERE schemaname = $1
 `;
+// Foreign-key referential actions (ON DELETE / ON UPDATE) live in pg_catalog,
+// not information_schema. Keyed by constraint name for join with SQL_FOREIGN_KEYS.
+const SQL_FK_ACTIONS = `
+  SELECT con.conname, con.confdeltype, con.confupdtype
+  FROM pg_constraint con
+  JOIN pg_catalog.pg_namespace n ON n.oid = con.connamespace
+  WHERE con.contype = 'f'
+    AND n.nspname = $1
+`;
+// CHECK constraints (contype = 'c'). NOT NULL is stored as attnotnull, not a
+// check constraint, so it never appears here.
+const SQL_CHECKS = `
+  SELECT rel.relname AS table_name, con.conname, pg_get_constraintdef(con.oid) AS definition
+  FROM pg_constraint con
+  JOIN pg_catalog.pg_class rel ON rel.oid = con.conrelid
+  JOIN pg_catalog.pg_namespace n ON n.oid = con.connamespace
+  WHERE con.contype = 'c'
+    AND n.nspname = $1
+`;
+// Views (relkind 'v') — column metadata comes free from information_schema.columns.
+const SQL_VIEWS = `
+  SELECT table_name
+  FROM information_schema.views
+  WHERE table_schema = $1
+  ORDER BY table_name
+`;
+// Materialized views (relkind 'm') — NOT in information_schema; read from pg_catalog.
+const SQL_MATVIEWS = `
+  SELECT matviewname AS table_name
+  FROM pg_matviews
+  WHERE schemaname = $1
+  ORDER BY matviewname
+`;
+// Materialized-view columns — information_schema.columns omits matviews, so pull
+// them from pg_attribute. Aliased to mirror SQL_COLUMNS so the same row-mapping
+// applies (array types surface as data_type 'ARRAY' + a '_'-prefixed udt_name).
+const SQL_MATVIEW_COLUMNS = `
+  SELECT
+    c.relname AS table_name,
+    a.attname AS column_name,
+    t.typname AS udt_name,
+    CASE WHEN t.typcategory = 'A' THEN 'ARRAY' ELSE 'base' END AS data_type,
+    CASE WHEN a.attnotnull THEN 'NO' ELSE 'YES' END AS is_nullable,
+    NULL AS column_default,
+    'NO' AS is_identity,
+    'NEVER' AS is_generated,
+    NULL AS generation_expression,
+    a.attnum AS ordinal_position,
+    NULL::int AS character_maximum_length
+  FROM pg_catalog.pg_attribute a
+  JOIN pg_catalog.pg_class c ON c.oid = a.attrelid
+  JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+  JOIN pg_catalog.pg_type t ON t.oid = a.atttypid
+  WHERE n.nspname = $1
+    AND c.relkind = 'm'
+    AND a.attnum > 0
+    AND NOT a.attisdropped
+  ORDER BY c.relname, a.attnum
+`;
 const SQL_ENUMS = `
   SELECT t.typname, e.enumlabel
   FROM pg_type t
@@ -131,17 +213,45 @@ async function introspectPostgresCatalog(options) {
     });
     try {
         // Run all information_schema queries in parallel
-        const [tablesResult, columnsResult, pkResult, fkResult, uniqueResult, indexResult, enumResult] = await Promise.all([
+        const [tablesResult, columnsResult, pkResult, fkResult, fkActionsResult, uniqueResult, indexResult, checkResult, enumResult,] = await Promise.all([
             pool.query(SQL_TABLES, [schema]),
             pool.query(SQL_COLUMNS, [schema]),
             pool.query(SQL_PRIMARY_KEYS, [schema]),
             pool.query(SQL_FOREIGN_KEYS, [schema]),
+            pool.query(SQL_FK_ACTIONS, [schema]),
             pool.query(SQL_UNIQUE_CONSTRAINTS, [schema]),
             pool.query(SQL_INDEXES, [schema]),
+            pool.query(SQL_CHECKS, [schema]),
             pool.query(SQL_ENUMS, [schema]),
         ]);
-        // Filter tables by include/exclude
-        let tableNames = tablesResult.rows.map((r) => r.table_name);
+        // Views + materialized views (opt-in). Regular-view columns are already in
+        // columnsResult (information_schema.columns); matview columns need a separate
+        // pg_catalog read, which we splice into the column rows below.
+        const viewNameSet = new Set();
+        const matviewColumnRows = [];
+        if (options.includeViews) {
+            const [viewsResult, matviewsResult, matviewColsResult] = await Promise.all([
+                pool.query(SQL_VIEWS, [schema]),
+                pool.query(SQL_MATVIEWS, [schema]),
+                pool.query(SQL_MATVIEW_COLUMNS, [schema]),
+            ]);
+            for (const r of viewsResult.rows)
+                viewNameSet.add(r.table_name);
+            for (const r of matviewsResult.rows)
+                viewNameSet.add(r.table_name);
+            matviewColumnRows.push(...matviewColsResult.rows);
+        }
+        // constraint_name → { onDelete, onUpdate } referential actions.
+        const fkActions = new Map();
+        for (const row of fkActionsResult.rows) {
+            fkActions.set(row.conname, {
+                onDelete: pgConfActionToReferential(row.confdeltype),
+                onUpdate: pgConfActionToReferential(row.confupdtype),
+            });
+        }
+        // Filter tables by include/exclude. Views/matviews join the base tables as
+        // candidates so include/exclude apply uniformly.
+        let tableNames = [...tablesResult.rows.map((r) => r.table_name), ...viewNameSet];
         if (options.include?.length) {
             const includeSet = new Set(options.include);
             tableNames = tableNames.filter((t) => includeSet.has(t));
@@ -152,8 +262,10 @@ async function introspectPostgresCatalog(options) {
         }
         const tableSet = new Set(tableNames);
         // ----- Group columns by table -----
+        // Base-table + regular-view columns come from information_schema.columns;
+        // materialized-view columns are appended from the pg_catalog read.
         const columnsByTable = new Map();
-        for (const row of columnsResult.rows) {
+        for (const row of [...columnsResult.rows, ...matviewColumnRows]) {
             const tableName = row.table_name;
             if (!tableSet.has(tableName))
                 continue;
@@ -176,6 +288,11 @@ async function introspectPostgresCatalog(options) {
                 // (gen_random_uuid(), now()), which Turbine must still synthesize.
                 isGenerated: (typeof row.column_default === 'string' && row.column_default.includes('nextval(')) ||
                     row.is_identity === 'YES',
+                // GENERATED ALWAYS AS (expr) STORED — computed by the database, never
+                // writable. Distinct from isGenerated (serial/identity, which a client
+                // MAY override). is_generated is 'ALWAYS' for STORED columns, else 'NEVER'.
+                isGeneratedStored: row.is_generated === 'ALWAYS',
+                generationExpression: row.is_generated === 'ALWAYS' && row.generation_expression ? row.generation_expression : undefined,
                 isArray,
                 arrayType,
                 pgArrayType: arrayType,
@@ -230,6 +347,20 @@ async function introspectPostgresCatalog(options) {
                 definition: row.indexdef,
             });
         }
+        // ----- Group check constraints by table -----
+        // pg_get_constraintdef yields e.g. `CHECK ((price >= 0))`; strip the leading
+        // `CHECK ` and the outermost paren pair to recover the raw expression.
+        const checksByTable = new Map();
+        for (const row of checkResult.rows) {
+            if (!tableSet.has(row.table_name))
+                continue;
+            if (!checksByTable.has(row.table_name))
+                checksByTable.set(row.table_name, []);
+            checksByTable.get(row.table_name).push({
+                name: row.conname,
+                expression: stripCheckWrapper(row.definition),
+            });
+        }
         // ----- Collect enums -----
         const enums = {};
         for (const row of enumResult.rows) {
@@ -279,6 +410,13 @@ async function introspectPostgresCatalog(options) {
                     ? (0, schema_js_1.snakeToCamel)(fk.sourceColumns[0].replace(/_id$/, ''))
                     : (0, schema_js_1.snakeToCamel)(fk.constraintName.replace(/^fk_/, '').replace(/_fkey$/, ''))
                 : (0, schema_js_1.singularize)((0, schema_js_1.snakeToCamel)(fk.targetTable));
+            // Referential actions (omit the 'no action' default to keep metadata lean).
+            const actions = fkActions.get(fk.constraintName);
+            const actionFields = {};
+            if (actions?.onDelete && actions.onDelete !== 'no action')
+                actionFields.onDelete = actions.onDelete;
+            if (actions?.onUpdate && actions.onUpdate !== 'no action')
+                actionFields.onUpdate = actions.onUpdate;
             if (!relationsByTable.has(fk.sourceTable))
                 relationsByTable.set(fk.sourceTable, {});
             relationsByTable.get(fk.sourceTable)[belongsToName] = {
@@ -288,6 +426,7 @@ async function introspectPostgresCatalog(options) {
                 to: fk.targetTable,
                 foreignKey,
                 referenceKey,
+                ...actionFields,
             };
             // --- hasMany on the target (parent) table ---
             // e.g. posts.user_id → users.id creates users.posts (hasMany)
@@ -305,6 +444,7 @@ async function introspectPostgresCatalog(options) {
                 to: fk.sourceTable,
                 foreignKey,
                 referenceKey,
+                ...actionFields,
             };
         }
         // ----- Conservative many-to-many auto-detection (PURELY ADDITIVE) -----
@@ -422,6 +562,8 @@ async function introspectPostgresCatalog(options) {
                 uniqueColumns: uniqueByTable.get(tableName) ?? [],
                 relations: relationsByTable.get(tableName) ?? {},
                 indexes: indexesByTable.get(tableName) ?? [],
+                checks: checksByTable.get(tableName) ?? [],
+                ...(viewNameSet.has(tableName) ? { isView: true } : {}),
             };
         }
         return { tables, enums };
@@ -430,3 +572,34 @@ async function introspectPostgresCatalog(options) {
         await pool.end();
     }
 }
+/**
+ * Recover the raw check expression from `pg_get_constraintdef` output, which
+ * wraps it as `CHECK ((expr))`. Strips the leading `CHECK ` keyword and one
+ * balanced outer paren pair; leaves anything unexpected untouched.
+ */
+function stripCheckWrapper(def) {
+    let s = def.trim();
+    const m = /^CHECK\s*\((.*)\)$/is.exec(s);
+    if (m)
+        s = m[1].trim();
+    // pg double-wraps single expressions: `(price >= 0)` → unwrap one more pair
+    // only when the parens are balanced across the whole string.
+    if (s.startsWith('(') && s.endsWith(')')) {
+        let depth = 0;
+        let balanced = true;
+        for (let i = 0; i < s.length; i++) {
+            if (s[i] === '(')
+                depth++;
+            else if (s[i] === ')') {
+                depth--;
+                if (depth === 0 && i < s.length - 1) {
+                    balanced = false;
+                    break;
+                }
+            }
+        }
+        if (balanced)
+            s = s.slice(1, -1).trim();
+    }
+    return s;
+}