prisma-extension-autozod 1.0.5 → 1.1.0

package/README.md

@@ -4,12 +4,13 @@
 [![CI](https://github.com/abzr0o/prisma-extension-autozod/actions/workflows/ci.yml/badge.svg)](https://github.com/abzr0o/prisma-extension-autozod/actions)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
-> Contract-aware compile-time linting and runtime Zod validation for the new Prisma ORM (@prisma/orm-postgres).
+> Contract-aware compile-time linting, automatic schema generation, and runtime Zod validation for the new Prisma ORM (@prisma/orm-postgres).
 
-`prisma-extension-autozod` connects **Zod 4** and **Prisma ORM 8**. It provides two layers of safety:
+`prisma-extension-autozod` connects **Zod 4** and **Prisma ORM 8**. It provides three layers of safety:
 
-1. **Compile-time Linting**: TypeScript flags any field in your Zod schema that does not exist in your Prisma data contract.
-2. **Runtime Middleware**: Automatically intercepts write operations (`create`, `update`, `insert`) via Prisma 8's `beforeCompile` hook, validates payloads, normalizes column naming conventions, and blocks invalid mutations before SQL reaches your database.
+1. **Automatic Schema Inference**: Generate complete insert and update Zod schemas directly from `contract.json` without drifting field definitions.
+2. **Compile-time Linting**: TypeScript flags any field in your Zod schema that does not exist in your Prisma data contract.
+3. **Runtime Middleware**: Automatically intercepts write operations (`create`, `update`, `insert`) via Prisma 8's `beforeCompile` AST hook, maps domain fields to storage columns, sanitizes payloads, and writes back validated transforms, coercions, and defaults directly into database query parameters.
 
 ---
 
@@ -19,8 +20,10 @@
 | :--- | :--- | :--- | :--- |
 | **Zero Controller Boilerplate** | No (Manual `.parse()`) | No (Manual `.parse()`) | Yes (Auto-intercepted) |
 | **Prisma 8 Native Architecture** | No | No | Yes (`beforeCompile` / Contract) |
+| **Direct Schema Inference** | No | Yes (Build step) | Yes (`createInsertSchema(contract, "User")`) |
 | **Compile-Time Typo Linter** | No | No | Yes (Immediate IDE feedback) |
-| **Casing Normalization** | No | No | Yes (`first_name` <-> `firstName`) |
+| **Casing & Column Mapping** | No | No | Yes (`first_name` <-> `firstName`) |
+| **AST Value Write-Back** | No | No | Yes (Transforms and defaults reach DB) |
 
 ---
 
@@ -34,11 +37,11 @@
 
 ## Features
 
+- **Direct Contract Schema Inference**: Infer base Zod schemas straight from your Prisma 8 `contract.json` via `createInsertSchema` and `createUpdateSchema`, with database defaults automatically made optional.
+- **AST Transform & Default Write-Back**: Transformed and coerced values (e.g. `.trim().toLowerCase()`, `z.coerce.date()`, `.default()`) are updated in-place on AST parameter references so they actually persist to PostgreSQL.
+- **Multi-Row Insert Protection**: Transparently handles ORM-generated `DefaultValueExpr` nodes in multi-row inserts without triggering false validation rejections.
+- **Bidirectional Column & Model Mapping**: Seamlessly resolves domain model names to physical storage tables (e.g. `User` -> `users`) and model field names to storage columns (e.g. `firstName` -> `first_name`).
 - **Compile-Time Contract Linting**: Catches schema mismatches and invalid fields at build-time with clear TypeScript diagnostics.
-- **Native Prisma ORM 8 Lifecycle Hook**: Hooks directly into the `beforeCompile` AST pipeline without monkey-patching.
-- **Automatic Column Normalization**: Remaps input casing (e.g., `first_name` to `firstName`) based on your contract's column catalog.
-- **Context-Aware Validation**: Full validation for `create`/`insert`, and automatic `.partial()` validation for `update` operations so omitted fields do not fail.
-- **Flexible Strictness**: Choose between `createZodRegistry` (allows omitting auto-generated/default fields like `id` or `createdAt`) and `createStrictZodRegistry` (enforces full table column coverage).
 - **Dual ESM & CJS**: Full TypeScript `.d.ts` declarations included out-of-the-box.
 
 ---
@@ -60,51 +63,58 @@ yarn add prisma-extension-autozod zod @prisma/orm-postgres
 
 ## Quickstart
 
-### 1. Define Validated Schemas with Contract Linting
+### 1. Infer Schemas Directly from contract.json (Recommended)
 
-Bind your Zod schemas to your generated Prisma 8 `models` using `createZodRegistry`:
+Generate complete Zod schemas with zero manual field maintenance and customize individual fields with refinements:
+
+```typescript
+import { createInsertSchema, createUpdateSchema } from "prisma-extension-autozod";
+import contractJson from "./contract.json" with { type: "json" };
+
+// Inferred from contract.json with defaults (e.g. id, createdAt) marked optional:
+export const userCreateSchema = createInsertSchema(contractJson, "User", {
+  email: (s) => s.email("Must be a valid email").toLowerCase().trim(),
+  name: (s) => s.min(2),
+});
+
+// Update schema with all fields partial:
+export const userUpdateSchema = createUpdateSchema(contractJson, "User");
+```
+
+---
+
+### 2. Or Define Custom Schemas with Contract Linting
+
+If you prefer authoring your schemas manually, bind them to your contract types using `createZodRegistry`:
 
 ```typescript
 import { z } from "zod";
 import { createZodRegistry } from "prisma-extension-autozod";
 import type { models } from "./contract.d.ts";
 
-// Create a registry bound to your Prisma 8 contract models
 const defineModel = createZodRegistry<typeof models.public>();
 
 export const userValidator = defineModel(
   "User",
   z.object({
-    email: z.string().email("Invalid email address"),
-    username: z
-      .string()
-      .min(2, "Username must be at least 2 characters")
-      .nullable()
-      .optional(),
-    name: z
-      .string()
-      .min(2, "Name must be at least 2 characters")
-      .nullable()
-      .optional(),
+    email: z.string().email(),
+    username: z.string().min(2).nullable().optional(),
+    name: z.string().min(2).nullable().optional(),
   }),
 );
 ```
 
-> **Compile-Time Safety in Action:**
+> **Compile-Time Typo Protection:**
 > If you add a field that does not exist in the contract:
->
 > ```typescript
-> defineModel(
->   "User",
->   z.object({
->     nonExistentColumn: z.string(), // Error: Field 'nonExistentColumn' does not exist in table contract
->   }),
-> );
+> defineModel("User", z.object({
+>   nonExistentColumn: z.string(), // Error: Field 'nonExistentColumn' does not exist in table contract
+> }));
 > ```
 
 ---
 
-### 2. Register Middleware in Your Prisma 8 Client
+### 3. Register Middleware in Your Prisma 8 Client
 
 Pass the middleware to your `@prisma/orm-postgres` client setup:
 
@@ -114,7 +124,7 @@ import { contractFromJson } from "@prisma/orm-postgres/static";
 import { autoZodPrisma8 } from "prisma-extension-autozod";
 
 import contractJson from "./contract.json" with { type: "json" };
-import { userValidator } from "./schemas.ts";
+import { userCreateSchema } from "./schemas.ts";
 
 export const contract = contractFromJson(contractJson);
 
@@ -124,7 +134,7 @@ export const db = postgres({
   middleware: [
     autoZodPrisma8({
       contract: contractJson,
-      validators: [userValidator],
+      validators: [userCreateSchema],
     }),
   ],
 });
@@ -132,19 +142,19 @@ export const db = postgres({
 
 ---
 
-### 3. Automatic Validation & Sanitization
+### 4. Automatic Validation & Transform Write-Back
 
 In the new Prisma ORM, models are accessed via `db.orm.<namespace>.<ModelName>`:
 
 ```typescript
-// Valid: Passes validation and executes
+// Valid: Passes validation, applies transforms, and executes
 await db.orm.public.User.create({
-  email: "alice@prisma.io",
+  email: "  Alice@Prisma.IO  ", // Written back as "alice@prisma.io" in database
   username: "alice",
   name: "Alice Smith",
 });
 
-// Invalid: Throws standard ZodError before hitting the database
+// Invalid: Throws standard ZodError before hitting PostgreSQL
 await db.orm.public.User.create({
   email: "not-an-email",
   username: "a", // too short (< 2 characters)
@@ -153,52 +163,79 @@ await db.orm.public.User.create({
 
 // Update: Only supplied fields are validated
 await db.orm.public.User.where({ email: "alice@prisma.io" }).update({
-  name: "Alice Wonder", // Valid; other fields are not required on updates
+  name: "Alice Wonder", // Valid; omitted fields are ignored on updates
 });
 ```
 
 ---
 
-### 4. Column Normalization in Action
+### 5. Safe Route Validation (Mass Assignment Protection)
+
+Never pass raw client input (`req.body`) directly to database writes. In web applications, unvalidated payloads allow clients to inject unauthorized columns (such as `role: 'admin'`, `emailVerified: true`, or `ownerId`).
 
-Incoming payloads from frontend forms or REST APIs often use `snake_case`. The middleware automatically remaps them to match your contract columns:
+The recommended, secure pattern is to parse `req.body` at your route handler, which strips unauthorized fields, while `autoZodPrisma8` provides an automatic database-layer guard rail:
 
 ```typescript
-// Incoming frontend payload uses snake_case:
-await db.orm.public.User.create({
-  first_name: "Alice", // Automatically remapped to `firstName` in Postgres
-  email: "alice@prisma.io",
+import { ZodError } from "zod";
+import { userCreateSchema } from "./schemas.ts";
+
+// Express / NestJS / Fastify / Hono route handler:
+app.post("/users", async (req, res) => {
+  try {
+    // 1. Safe route validation: strips unknown fields & prevents mass assignment
+    const validatedData = userCreateSchema.parse(req.body);
+
+    // 2. Database mutation: intercepted & verified by AutoZod middleware
+    const user = await db.orm.public.User.create(validatedData);
+    return res.status(201).json(user);
+  } catch (error) {
+    if (error instanceof ZodError) {
+      // Return clean, flattened validation errors directly to the client
+      return res.status(400).json({ errors: error.flatten().fieldErrors });
+    }
+    return res.status(500).json({ error: "Internal server error" });
+  }
 });
 ```
 
 ---
 
-### 5. Error Handling DX
+### 6. Storage Column & Casing Normalization
 
-Because validation throws standard `ZodError` instances, you can easily catch and format errors for HTTP responses in Express, NestJS, Fastify, or Hono:
+If your Prisma contract maps camelCase model fields to snake_case storage columns (e.g. `@map("first_name")`), or if incoming payloads use alternative casing, `autoZodPrisma8` transparently reconciles them:
 
 ```typescript
-import { ZodError } from "zod";
-
-try {
-  await db.orm.public.User.create(req.body);
-} catch (error) {
-  if (error instanceof ZodError) {
-    // Clean flattened validation errors directly back to the client
-    return res.status(400).json({ errors: error.flatten().fieldErrors });
-  }
-  throw error;
-}
+// Model has firstName with @map("first_name"):
+// Middleware automatically resolves `first_name` in AST rows to the `firstName` schema
+await db.orm.public.User.create({
+  first_name: "Alice",
+  email: "alice@prisma.io",
+});
 ```
 
 ---
 
 ## API Reference
 
+### `createInsertSchema(contract, modelName, refinements?)`
+
+Infers a complete Zod insert schema from `contract.json`. Fields with database defaults (`autoincrement()`, `now()`) are marked optional.
+```typescript
+const userCreateSchema = createInsertSchema(contractJson, "User", {
+  email: (s) => s.email(),
+});
+```
+
+### `createUpdateSchema(contract, modelName, refinements?)`
+
+Infers a partial Zod update schema from `contract.json`.
+```typescript
+const userUpdateSchema = createUpdateSchema(contractJson, "User");
+```
+
 ### `createZodRegistry<TModels>()`
 
 Creates a model validator factory bound to your contract models. Validates that all fields in the schema exist in the contract table, allowing omission of auto-generated or optional fields.
-
 ```typescript
 const defineModel = createZodRegistry<typeof models.public>();
 const userValidator = defineModel("User", zodSchema);
@@ -207,7 +244,6 @@ const userValidator = defineModel("User", zodSchema);
 ### `createStrictZodRegistry<TModels>()`
 
 Creates a strict validator factory that requires all columns in the contract table to be declared in the schema, while also rejecting unknown fields.
-
 ```typescript
 const defineStrict = createStrictZodRegistry<typeof models.public>();
 const userValidator = defineStrict("User", zodSchema);
@@ -216,17 +252,8 @@ const userValidator = defineStrict("User", zodSchema);
 ### `autoZodPrisma8(options)` (alias: `autoZod`)
 
 Prisma ORM 8 middleware factory:
-
-- `options.contract`: The raw `contract.json` object.
-- `options.validators`: Array of validator entries returned by `createZodRegistry` or `createStrictZodRegistry`.
-
-### `extractColumns(contractJson)`
-
-Helper function that inspects storage namespaces inside `contract.json` and returns a normalized dictionary of table column names.
-
-### `normalizeKey(key: string)`
-
-Normalizes strings to lowercase alphanumeric format for reliable case- and separator-insensitive mapping.
+- `options.contract`: The parsed `contract.json` object.
+- `options.validators`: Array of validator entries returned by `createInsertSchema`, `createZodRegistry`, or `createStrictZodRegistry`.
 
 ---
 

package/dist/index.cjs

@@ -22,9 +22,15 @@ var index_exports = {};
 __export(index_exports, {
   autoZod: () => autoZod,
   autoZodPrisma8: () => autoZodPrisma8,
+  codecToZodSchema: () => codecToZodSchema,
+  createInsertSchema: () => createInsertSchema,
   createStrictZodRegistry: () => createStrictZodRegistry,
+  createUpdateSchema: () => createUpdateSchema,
   createZodRegistry: () => createZodRegistry,
   extractColumns: () => extractColumns,
+  extractContractMetadata: () => extractContractMetadata,
+  extractValue: () => extractValue,
+  isDefaultValueExpr: () => isDefaultValueExpr,
   normalizeKey: () => normalizeKey
 });
 module.exports = __toCommonJS(index_exports);
@@ -33,68 +39,200 @@ module.exports = __toCommonJS(index_exports);
 function normalizeKey(key) {
   return key.toLowerCase().replace(/[^a-z0-9]/g, "");
 }
+function isDefaultValueExpr(val) {
+  if (!val || typeof val !== "object") return false;
+  return val.kind === "default-value" || val.constructor?.name === "DefaultValueExpr";
+}
 function extractValue(val) {
+  if (isDefaultValueExpr(val)) {
+    return void 0;
+  }
   if (val && typeof val === "object" && "value" in val) {
     return val.value;
   }
   return val;
 }
-function extractColumns(contractJson) {
-  const tableCols = {};
-  const namespaces = contractJson?.storage?.namespaces || {};
-  for (const ns of Object.values(namespaces)) {
+function extractContractMetadata(contractJson) {
+  const modelsByName = /* @__PURE__ */ new Map();
+  const modelsByTable = /* @__PURE__ */ new Map();
+  const columnsByTable = {};
+  const domainNamespaces = contractJson?.domain?.namespaces || {};
+  const storageNamespaces = contractJson?.storage?.namespaces || {};
+  const storageDefaults = {};
+  for (const [, ns] of Object.entries(storageNamespaces)) {
     const tables = ns?.entries?.table || ns?.tables || {};
-    for (const [table, def] of Object.entries(tables)) {
-      tableCols[normalizeKey(table)] = Object.keys(def?.columns || {});
+    for (const [tableName, tableDef] of Object.entries(tables)) {
+      const cleanTable = normalizeKey(tableName);
+      const cols = Object.keys(tableDef?.columns || {});
+      columnsByTable[cleanTable] = cols;
+      storageDefaults[cleanTable] = {};
+      for (const [colName, colDef] of Object.entries(
+        tableDef?.columns || {}
+      )) {
+        storageDefaults[cleanTable][normalizeKey(colName)] = colDef?.default !== void 0;
+      }
     }
   }
-  return tableCols;
+  for (const [nsName, ns] of Object.entries(domainNamespaces)) {
+    const models = ns?.models || {};
+    for (const [modelName, modelDef] of Object.entries(models)) {
+      const storageTable = modelDef?.storage?.table || modelName;
+      const storageNs = modelDef?.storage?.namespaceId || nsName;
+      const cleanModelName = normalizeKey(modelName);
+      const cleanStorageTable = normalizeKey(storageTable);
+      const modelFieldToColumn = /* @__PURE__ */ new Map();
+      const columnToModelField = /* @__PURE__ */ new Map();
+      const fields = {};
+      const domainFields = modelDef?.fields || {};
+      const storageFields = modelDef?.storage?.fields || {};
+      for (const [fieldName, fieldDef] of Object.entries(domainFields)) {
+        const storageCol = storageFields[fieldName]?.column || fieldName;
+        const cleanFieldName = normalizeKey(fieldName);
+        const cleanColName = normalizeKey(storageCol);
+        modelFieldToColumn.set(cleanFieldName, storageCol);
+        modelFieldToColumn.set(cleanColName, storageCol);
+        columnToModelField.set(cleanColName, fieldName);
+        columnToModelField.set(cleanFieldName, fieldName);
+        const hasDefault = Boolean(
+          storageDefaults[cleanStorageTable]?.[cleanColName]
+        );
+        fields[fieldName] = {
+          modelFieldName: fieldName,
+          storageColumn: storageCol,
+          nullable: Boolean(fieldDef?.nullable),
+          codecId: fieldDef?.type?.codecId,
+          hasDefault
+        };
+      }
+      const meta = {
+        modelName,
+        storageTable,
+        storageNamespace: storageNs,
+        modelFieldToColumn,
+        columnToModelField,
+        fields
+      };
+      modelsByName.set(cleanModelName, meta);
+      modelsByTable.set(cleanStorageTable, meta);
+    }
+  }
+  return { modelsByName, modelsByTable, columnsByTable };
+}
+function extractColumns(contractJson) {
+  const metadata = extractContractMetadata(contractJson);
+  return metadata.columnsByTable;
 }
 function autoZodPrisma8(options) {
-  const columnCatalog = extractColumns(options.contract);
+  const contractMeta = extractContractMetadata(options.contract);
   const validatorMap = /* @__PURE__ */ new Map();
   for (const entry of options.validators) {
-    validatorMap.set(normalizeKey(entry.tableName), entry.schema);
+    const rawName = entry.tableName || entry._tableName || entry.name;
+    const schema = entry.schema || entry;
+    if (rawName && schema) {
+      const cleanName = normalizeKey(rawName);
+      validatorMap.set(cleanName, schema);
+      const meta = contractMeta.modelsByName.get(cleanName) || contractMeta.modelsByTable.get(cleanName);
+      if (meta) {
+        validatorMap.set(normalizeKey(meta.modelName), schema);
+        validatorMap.set(normalizeKey(meta.storageTable), schema);
+      }
+    }
   }
   return {
     name: "autozod-validator",
     familyId: "sql",
     async beforeCompile(draft, ctx) {
       const ast = draft?.ast;
-      if (!ast || ast.kind !== "insert" && ast.kind !== "update") return void 0;
-      const target = ast.table?.name;
-      if (!target) return void 0;
-      const cleanTarget = normalizeKey(target);
-      const schema = validatorMap.get(cleanTarget);
-      if (!schema) return void 0;
-      const targetCols = columnCatalog[cleanTarget] || [];
-      const colLookup = /* @__PURE__ */ new Map();
-      for (const col of targetCols) {
-        colLookup.set(normalizeKey(col), col);
+      if (!ast || ast.kind !== "insert" && ast.kind !== "update") {
+        return void 0;
       }
-      const validateFields = (rawRecord, isUpdate) => {
-        const extracted = {};
+      const rawTable = ast.table?.name;
+      if (!rawTable) return void 0;
+      const cleanTable = normalizeKey(rawTable);
+      const meta = contractMeta.modelsByTable.get(cleanTable) || contractMeta.modelsByName.get(cleanTable);
+      const schema = validatorMap.get(cleanTable) || (meta ? validatorMap.get(normalizeKey(meta.modelName)) : void 0);
+      if (!schema) return void 0;
+      const schemaShape = schema.shape || {};
+      const schemaKeys = Object.keys(schemaShape);
+      const validateAndWriteBack = (rawRecord, isUpdate) => {
+        const toValidate = {};
+        const defaultExprFields = /* @__PURE__ */ new Set();
+        for (const expectedKey of schemaKeys) {
+          if (expectedKey in rawRecord) {
+            const raw = rawRecord[expectedKey];
+            if (isDefaultValueExpr(raw)) {
+              defaultExprFields.add(expectedKey);
+            } else {
+              toValidate[expectedKey] = extractValue(raw);
+            }
+            continue;
+          }
+          const storageCol = meta?.modelFieldToColumn.get(normalizeKey(expectedKey));
+          if (storageCol && storageCol in rawRecord) {
+            const raw = rawRecord[storageCol];
+            if (isDefaultValueExpr(raw)) {
+              defaultExprFields.add(expectedKey);
+            } else {
+              toValidate[expectedKey] = extractValue(raw);
+            }
+            continue;
+          }
+        }
         for (const [col, val] of Object.entries(rawRecord)) {
-          const actualCol = colLookup.get(normalizeKey(col)) || col;
-          extracted[actualCol] = extractValue(val);
+          const mappedModelField = meta?.columnToModelField.get(
+            normalizeKey(col)
+          );
+          if (mappedModelField && mappedModelField in schemaShape) {
+            if (isDefaultValueExpr(val)) {
+              defaultExprFields.add(mappedModelField);
+            } else if (!(mappedModelField in toValidate)) {
+              toValidate[mappedModelField] = extractValue(val);
+            }
+          }
         }
-        const schemaShape = schema.shape || {};
-        const schemaKeys = new Set(Object.keys(schemaShape));
-        const toValidate = {};
-        for (const [k, v] of Object.entries(extracted)) {
-          if (schemaKeys.has(k)) {
-            toValidate[k] = v;
+        let activeSchema = isUpdate ? schema.partial() : schema;
+        if (!isUpdate && defaultExprFields.size > 0 && typeof schema.partial === "function") {
+          const mask = {};
+          for (const f of defaultExprFields) {
+            mask[f] = true;
+          }
+          try {
+            activeSchema = schema.partial(mask);
+          } catch {
+          }
+        }
+        const parsed = activeSchema.parse(toValidate);
+        if (parsed && typeof parsed === "object") {
+          for (const [parsedKey, parsedVal] of Object.entries(parsed)) {
+            let storageCol = meta?.modelFieldToColumn.get(
+              normalizeKey(parsedKey)
+            );
+            if (!storageCol || !(storageCol in rawRecord)) {
+              if (parsedKey in rawRecord) {
+                storageCol = parsedKey;
+              }
+            }
+            if (storageCol && storageCol in rawRecord) {
+              const current = rawRecord[storageCol];
+              if (current && typeof current === "object" && "value" in current) {
+                current.value = parsedVal;
+              } else if (isDefaultValueExpr(current)) {
+                rawRecord[storageCol] = { value: parsedVal };
+              } else {
+                rawRecord[storageCol] = parsedVal;
+              }
+            } else if (storageCol && !isUpdate) {
+              rawRecord[storageCol] = { value: parsedVal };
+            }
           }
         }
-        const activeSchema = isUpdate ? schema.partial() : schema;
-        activeSchema.parse(toValidate);
       };
       if (ast.kind === "insert" && Array.isArray(ast.rows)) {
         for (const row of ast.rows) {
-          validateFields(row, false);
+          validateAndWriteBack(row, false);
         }
       } else if (ast.kind === "update" && ast.set) {
-        validateFields(ast.set, true);
+        validateAndWriteBack(ast.set, true);
       }
       return void 0;
     }
@@ -119,12 +257,87 @@ function createStrictZodRegistry() {
     };
   };
 }
+
+// src/schema-generator.ts
+var import_zod = require("zod");
+function codecToZodSchema(codecId) {
+  if (!codecId) return import_zod.z.any();
+  const id = codecId.toLowerCase();
+  if (id.includes("uuid")) {
+    return import_zod.z.string().uuid();
+  }
+  if (id.includes("/text") || id.includes("/varchar") || id.includes("/char") || id.includes("/citext")) {
+    return import_zod.z.string();
+  }
+  if (id.includes("/int2") || id.includes("/int4")) {
+    return import_zod.z.number().int();
+  }
+  if (id.includes("/float") || id.includes("/numeric")) {
+    return import_zod.z.number();
+  }
+  if (id.includes("/int8")) {
+    return import_zod.z.union([import_zod.z.bigint(), import_zod.z.number()]);
+  }
+  if (id.includes("/bool")) {
+    return import_zod.z.boolean();
+  }
+  if (id.includes("/time") || id.includes("/date")) {
+    return import_zod.z.union([import_zod.z.date(), import_zod.z.string()]);
+  }
+  if (id.includes("/json")) {
+    return import_zod.z.any();
+  }
+  if (id.includes("/bytea")) {
+    return import_zod.z.union([import_zod.z.instanceof(Uint8Array), import_zod.z.string()]);
+  }
+  return import_zod.z.any();
+}
+function createInsertSchema(contract, modelName, refinements) {
+  const metadata = extractContractMetadata(contract);
+  const modelMeta = metadata.modelsByName.get(normalizeKey(modelName)) || metadata.modelsByTable.get(normalizeKey(modelName));
+  if (!modelMeta) {
+    const available = Array.from(metadata.modelsByName.values()).map((m) => m.modelName).join(", ");
+    throw new Error(
+      `[prisma-extension-autozod]: Model '${modelName}' not found in contract. Available models: ${available || "none"}`
+    );
+  }
+  const shape = {};
+  for (const [fieldName, fieldMeta] of Object.entries(modelMeta.fields)) {
+    let fieldSchema = codecToZodSchema(fieldMeta.codecId);
+    if (fieldMeta.nullable) {
+      fieldSchema = fieldSchema.nullable();
+    }
+    if (fieldMeta.hasDefault) {
+      fieldSchema = fieldSchema.optional();
+    }
+    const custom = refinements?.[fieldName] || refinements?.[fieldMeta.storageColumn];
+    if (custom) {
+      fieldSchema = typeof custom === "function" ? custom(fieldSchema) : custom;
+    }
+    shape[fieldName] = fieldSchema;
+  }
+  const schema = import_zod.z.object(shape);
+  schema.tableName = modelName;
+  return schema;
+}
+function createUpdateSchema(contract, modelName, refinements) {
+  const insertSchema = createInsertSchema(contract, modelName, refinements);
+  const updateSchema = insertSchema.partial();
+  updateSchema.tableName = modelName;
+  return updateSchema;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   autoZod,
   autoZodPrisma8,
+  codecToZodSchema,
+  createInsertSchema,
   createStrictZodRegistry,
+  createUpdateSchema,
   createZodRegistry,
   extractColumns,
+  extractContractMetadata,
+  extractValue,
+  isDefaultValueExpr,
   normalizeKey
 });

package/dist/index.d.cts

@@ -122,7 +122,7 @@ interface AutoZodMiddleware {
     familyId: "sql";
     /**
      * Lifecycle hook invoked prior to SQL plan compilation.
-     * Intercepts and validates AST mutation rows and values.
+     * Intercepts, validates, and writes back AST mutation rows and values.
      */
     beforeCompile(draft: any, ctx: any): Promise<undefined>;
 }
@@ -140,31 +140,71 @@ interface AutoZodMiddleware {
  * ```
  */
 declare function normalizeKey(key: string): string;
+/**
+ * Checks whether an AST node is a Prisma 8 DefaultValueExpr placeholder
+ * inserted during multi-row inserts with asymmetric keys.
+ */
+declare function isDefaultValueExpr(val: unknown): boolean;
+/**
+ * Extracts the raw JavaScript value from Prisma 8 AST parameter references.
+ * Automatically returns undefined for DefaultValueExpr nodes so Zod does not fail on them.
+ */
+declare function extractValue(val: unknown): unknown;
+/**
+ * Metadata for a model field extracted from contract.json.
+ */
+interface ModelFieldMeta {
+    modelFieldName: string;
+    storageColumn: string;
+    nullable: boolean;
+    codecId?: string;
+    hasDefault: boolean;
+}
+/**
+ * Metadata for a domain model extracted from contract.json.
+ */
+interface ModelContractMeta {
+    modelName: string;
+    storageTable: string;
+    storageNamespace: string;
+    modelFieldToColumn: Map<string, string>;
+    columnToModelField: Map<string, string>;
+    fields: Record<string, ModelFieldMeta>;
+}
+/**
+ * Comprehensive metadata extracted from contract.json across all namespaces.
+ */
+interface ContractMetadata {
+    modelsByName: Map<string, ModelContractMeta>;
+    modelsByTable: Map<string, ModelContractMeta>;
+    columnsByTable: Record<string, string[]>;
+}
+/**
+ * Inspects a compiled Prisma ORM 8 `contract.json` object and extracts
+ * bidirectional mappings between domain models, storage tables, field names, and column names.
+ *
+ * @param contractJson The parsed Prisma 8 contract JSON object.
+ * @returns A ContractMetadata object with indexed model and column lookups.
+ */
+declare function extractContractMetadata(contractJson: any): ContractMetadata;
 /**
  * Inspects a compiled Prisma ORM 8 `contract.json` object and extracts a
  * dictionary of normalized table names mapped to their column list.
  *
  * @param contractJson The parsed Prisma 8 contract JSON object.
  * @returns A mapping from normalized table names to array of column names.
- *
- * @example
- * ```typescript
- * import contractJson from "./contract.json" with { type: "json" };
- *
- * const columns = extractColumns(contractJson);
- * console.log(columns["user"]); // ["id", "email", "name", ...]
- * ```
  */
 declare function extractColumns(contractJson: any): Record<string, string[]>;
 /**
  * Factory creating Prisma ORM 8 SQL middleware for automatic runtime Zod validation.
  *
  * Hooks into the query compiler via `beforeCompile` and intercepts `insert` and `update`
- * operations. Maps columns according to the contract, validates payload values against
- * registered Zod schemas, and throws `ZodError` before SQL execution if invalid.
+ * operations. Resolves domain model names to physical storage tables, maps model field
+ * names to database columns, validates values, and writes back coerced, transformed,
+ * and defaulted values into the AST parameter references.
  *
  * @param options.contract The parsed Prisma 8 `contract.json` object.
- * @param options.validators An array of validator entries produced by `createZodRegistry`.
+ * @param options.validators An array of validator entries or schemas created by createZodRegistry / createInsertSchema.
  * @returns An `AutoZodMiddleware` instance ready to be passed to `postgres({ middleware: [...] })`.
  *
  * @example
@@ -192,12 +232,69 @@ declare function extractColumns(contractJson: any): Record<string, string[]>;
  */
 declare function autoZodPrisma8(options: {
     contract: any;
-    validators: ModelValidatorEntry[];
+    validators: (ModelValidatorEntry | (z.ZodObject<any> & {
+        tableName?: string;
+    }))[];
 }): AutoZodMiddleware;
 /**
  * Convenient alias for `autoZodPrisma8`.
  */
 declare const autoZod: typeof autoZodPrisma8;
 
-export { autoZod, autoZodPrisma8, createStrictZodRegistry, createZodRegistry, extractColumns, normalizeKey };
-export type { AutoZodMiddleware, CleanKey, InvalidContractKeys, MissingContractKeys, ModelValidatorEntry, ResolveColumn, ValidateZodAgainstContract };
+/**
+ * Refinement mapping allowing custom Zod schemas or mutator functions per field.
+ */
+type SchemaRefinements = Record<string, z.ZodTypeAny | ((base: z.ZodTypeAny) => z.ZodTypeAny)>;
+/**
+ * Map Prisma 8 SQL codec IDs to their corresponding base Zod types.
+ */
+declare function codecToZodSchema(codecId?: string): z.ZodTypeAny;
+/**
+ * Automatically infers a complete Zod insert schema from a Prisma ORM 8 `contract.json`.
+ *
+ * Fields with database defaults (e.g. autoincrement ID, now() timestamps) are automatically
+ * marked optional. Nullable columns are marked nullable. You can refine or override individual
+ * fields with custom validation rules.
+ *
+ * @param contract The parsed Prisma 8 `contract.json` object.
+ * @param modelName The model name in your contract (e.g., "User" or "Post").
+ * @param refinements Optional mapping to customize or extend specific field schemas.
+ * @returns A ZodObject schema with a `.tableName` property ready for route validation or AutoZod middleware.
+ *
+ * @example
+ * ```typescript
+ * import contractJson from "./contract.json" with { type: "json" };
+ * import { createInsertSchema } from "prisma-extension-autozod";
+ *
+ * export const userCreateSchema = createInsertSchema(contractJson, "User", {
+ *   email: (s) => s.email("Must be a valid email"),
+ *   name: (s) => s.min(2),
+ * });
+ * ```
+ */
+declare function createInsertSchema<TContract extends Record<string, any> = any, TModel extends string = string>(contract: TContract, modelName: TModel, refinements?: SchemaRefinements): z.ZodObject<any> & {
+    tableName: TModel;
+};
+/**
+ * Automatically infers a Zod update schema from a Prisma ORM 8 `contract.json`.
+ *
+ * Equivalent to `createInsertSchema(...).partial()`.
+ *
+ * @param contract The parsed Prisma 8 `contract.json` object.
+ * @param modelName The model name in your contract.
+ * @param refinements Optional mapping to customize or extend specific field schemas.
+ * @returns A partial ZodObject schema with a `.tableName` property.
+ *
+ * @example
+ * ```typescript
+ * export const userUpdateSchema = createUpdateSchema(contractJson, "User", {
+ *   email: (s) => s.email(),
+ * });
+ * ```
+ */
+declare function createUpdateSchema<TContract extends Record<string, any> = any, TModel extends string = string>(contract: TContract, modelName: TModel, refinements?: SchemaRefinements): z.ZodObject<any> & {
+    tableName: TModel;
+};
+
+export { autoZod, autoZodPrisma8, codecToZodSchema, createInsertSchema, createStrictZodRegistry, createUpdateSchema, createZodRegistry, extractColumns, extractContractMetadata, extractValue, isDefaultValueExpr, normalizeKey };
+export type { AutoZodMiddleware, CleanKey, ContractMetadata, InvalidContractKeys, MissingContractKeys, ModelContractMeta, ModelFieldMeta, ModelValidatorEntry, ResolveColumn, SchemaRefinements, ValidateZodAgainstContract };

package/dist/index.d.ts

@@ -122,7 +122,7 @@ interface AutoZodMiddleware {
     familyId: "sql";
     /**
      * Lifecycle hook invoked prior to SQL plan compilation.
-     * Intercepts and validates AST mutation rows and values.
+     * Intercepts, validates, and writes back AST mutation rows and values.
      */
     beforeCompile(draft: any, ctx: any): Promise<undefined>;
 }
@@ -140,31 +140,71 @@ interface AutoZodMiddleware {
  * ```
  */
 declare function normalizeKey(key: string): string;
+/**
+ * Checks whether an AST node is a Prisma 8 DefaultValueExpr placeholder
+ * inserted during multi-row inserts with asymmetric keys.
+ */
+declare function isDefaultValueExpr(val: unknown): boolean;
+/**
+ * Extracts the raw JavaScript value from Prisma 8 AST parameter references.
+ * Automatically returns undefined for DefaultValueExpr nodes so Zod does not fail on them.
+ */
+declare function extractValue(val: unknown): unknown;
+/**
+ * Metadata for a model field extracted from contract.json.
+ */
+interface ModelFieldMeta {
+    modelFieldName: string;
+    storageColumn: string;
+    nullable: boolean;
+    codecId?: string;
+    hasDefault: boolean;
+}
+/**
+ * Metadata for a domain model extracted from contract.json.
+ */
+interface ModelContractMeta {
+    modelName: string;
+    storageTable: string;
+    storageNamespace: string;
+    modelFieldToColumn: Map<string, string>;
+    columnToModelField: Map<string, string>;
+    fields: Record<string, ModelFieldMeta>;
+}
+/**
+ * Comprehensive metadata extracted from contract.json across all namespaces.
+ */
+interface ContractMetadata {
+    modelsByName: Map<string, ModelContractMeta>;
+    modelsByTable: Map<string, ModelContractMeta>;
+    columnsByTable: Record<string, string[]>;
+}
+/**
+ * Inspects a compiled Prisma ORM 8 `contract.json` object and extracts
+ * bidirectional mappings between domain models, storage tables, field names, and column names.
+ *
+ * @param contractJson The parsed Prisma 8 contract JSON object.
+ * @returns A ContractMetadata object with indexed model and column lookups.
+ */
+declare function extractContractMetadata(contractJson: any): ContractMetadata;
 /**
  * Inspects a compiled Prisma ORM 8 `contract.json` object and extracts a
  * dictionary of normalized table names mapped to their column list.
  *
  * @param contractJson The parsed Prisma 8 contract JSON object.
  * @returns A mapping from normalized table names to array of column names.
- *
- * @example
- * ```typescript
- * import contractJson from "./contract.json" with { type: "json" };
- *
- * const columns = extractColumns(contractJson);
- * console.log(columns["user"]); // ["id", "email", "name", ...]
- * ```
  */
 declare function extractColumns(contractJson: any): Record<string, string[]>;
 /**
  * Factory creating Prisma ORM 8 SQL middleware for automatic runtime Zod validation.
  *
  * Hooks into the query compiler via `beforeCompile` and intercepts `insert` and `update`
- * operations. Maps columns according to the contract, validates payload values against
- * registered Zod schemas, and throws `ZodError` before SQL execution if invalid.
+ * operations. Resolves domain model names to physical storage tables, maps model field
+ * names to database columns, validates values, and writes back coerced, transformed,
+ * and defaulted values into the AST parameter references.
  *
  * @param options.contract The parsed Prisma 8 `contract.json` object.
- * @param options.validators An array of validator entries produced by `createZodRegistry`.
+ * @param options.validators An array of validator entries or schemas created by createZodRegistry / createInsertSchema.
  * @returns An `AutoZodMiddleware` instance ready to be passed to `postgres({ middleware: [...] })`.
  *
  * @example
@@ -192,12 +232,69 @@ declare function extractColumns(contractJson: any): Record<string, string[]>;
  */
 declare function autoZodPrisma8(options: {
     contract: any;
-    validators: ModelValidatorEntry[];
+    validators: (ModelValidatorEntry | (z.ZodObject<any> & {
+        tableName?: string;
+    }))[];
 }): AutoZodMiddleware;
 /**
  * Convenient alias for `autoZodPrisma8`.
  */
 declare const autoZod: typeof autoZodPrisma8;
 
-export { autoZod, autoZodPrisma8, createStrictZodRegistry, createZodRegistry, extractColumns, normalizeKey };
-export type { AutoZodMiddleware, CleanKey, InvalidContractKeys, MissingContractKeys, ModelValidatorEntry, ResolveColumn, ValidateZodAgainstContract };
+/**
+ * Refinement mapping allowing custom Zod schemas or mutator functions per field.
+ */
+type SchemaRefinements = Record<string, z.ZodTypeAny | ((base: z.ZodTypeAny) => z.ZodTypeAny)>;
+/**
+ * Map Prisma 8 SQL codec IDs to their corresponding base Zod types.
+ */
+declare function codecToZodSchema(codecId?: string): z.ZodTypeAny;
+/**
+ * Automatically infers a complete Zod insert schema from a Prisma ORM 8 `contract.json`.
+ *
+ * Fields with database defaults (e.g. autoincrement ID, now() timestamps) are automatically
+ * marked optional. Nullable columns are marked nullable. You can refine or override individual
+ * fields with custom validation rules.
+ *
+ * @param contract The parsed Prisma 8 `contract.json` object.
+ * @param modelName The model name in your contract (e.g., "User" or "Post").
+ * @param refinements Optional mapping to customize or extend specific field schemas.
+ * @returns A ZodObject schema with a `.tableName` property ready for route validation or AutoZod middleware.
+ *
+ * @example
+ * ```typescript
+ * import contractJson from "./contract.json" with { type: "json" };
+ * import { createInsertSchema } from "prisma-extension-autozod";
+ *
+ * export const userCreateSchema = createInsertSchema(contractJson, "User", {
+ *   email: (s) => s.email("Must be a valid email"),
+ *   name: (s) => s.min(2),
+ * });
+ * ```
+ */
+declare function createInsertSchema<TContract extends Record<string, any> = any, TModel extends string = string>(contract: TContract, modelName: TModel, refinements?: SchemaRefinements): z.ZodObject<any> & {
+    tableName: TModel;
+};
+/**
+ * Automatically infers a Zod update schema from a Prisma ORM 8 `contract.json`.
+ *
+ * Equivalent to `createInsertSchema(...).partial()`.
+ *
+ * @param contract The parsed Prisma 8 `contract.json` object.
+ * @param modelName The model name in your contract.
+ * @param refinements Optional mapping to customize or extend specific field schemas.
+ * @returns A partial ZodObject schema with a `.tableName` property.
+ *
+ * @example
+ * ```typescript
+ * export const userUpdateSchema = createUpdateSchema(contractJson, "User", {
+ *   email: (s) => s.email(),
+ * });
+ * ```
+ */
+declare function createUpdateSchema<TContract extends Record<string, any> = any, TModel extends string = string>(contract: TContract, modelName: TModel, refinements?: SchemaRefinements): z.ZodObject<any> & {
+    tableName: TModel;
+};
+
+export { autoZod, autoZodPrisma8, codecToZodSchema, createInsertSchema, createStrictZodRegistry, createUpdateSchema, createZodRegistry, extractColumns, extractContractMetadata, extractValue, isDefaultValueExpr, normalizeKey };
+export type { AutoZodMiddleware, CleanKey, ContractMetadata, InvalidContractKeys, MissingContractKeys, ModelContractMeta, ModelFieldMeta, ModelValidatorEntry, ResolveColumn, SchemaRefinements, ValidateZodAgainstContract };

package/dist/index.js

@@ -2,68 +2,200 @@
 function normalizeKey(key) {
   return key.toLowerCase().replace(/[^a-z0-9]/g, "");
 }
+function isDefaultValueExpr(val) {
+  if (!val || typeof val !== "object") return false;
+  return val.kind === "default-value" || val.constructor?.name === "DefaultValueExpr";
+}
 function extractValue(val) {
+  if (isDefaultValueExpr(val)) {
+    return void 0;
+  }
   if (val && typeof val === "object" && "value" in val) {
     return val.value;
   }
   return val;
 }
-function extractColumns(contractJson) {
-  const tableCols = {};
-  const namespaces = contractJson?.storage?.namespaces || {};
-  for (const ns of Object.values(namespaces)) {
+function extractContractMetadata(contractJson) {
+  const modelsByName = /* @__PURE__ */ new Map();
+  const modelsByTable = /* @__PURE__ */ new Map();
+  const columnsByTable = {};
+  const domainNamespaces = contractJson?.domain?.namespaces || {};
+  const storageNamespaces = contractJson?.storage?.namespaces || {};
+  const storageDefaults = {};
+  for (const [, ns] of Object.entries(storageNamespaces)) {
     const tables = ns?.entries?.table || ns?.tables || {};
-    for (const [table, def] of Object.entries(tables)) {
-      tableCols[normalizeKey(table)] = Object.keys(def?.columns || {});
+    for (const [tableName, tableDef] of Object.entries(tables)) {
+      const cleanTable = normalizeKey(tableName);
+      const cols = Object.keys(tableDef?.columns || {});
+      columnsByTable[cleanTable] = cols;
+      storageDefaults[cleanTable] = {};
+      for (const [colName, colDef] of Object.entries(
+        tableDef?.columns || {}
+      )) {
+        storageDefaults[cleanTable][normalizeKey(colName)] = colDef?.default !== void 0;
+      }
     }
   }
-  return tableCols;
+  for (const [nsName, ns] of Object.entries(domainNamespaces)) {
+    const models = ns?.models || {};
+    for (const [modelName, modelDef] of Object.entries(models)) {
+      const storageTable = modelDef?.storage?.table || modelName;
+      const storageNs = modelDef?.storage?.namespaceId || nsName;
+      const cleanModelName = normalizeKey(modelName);
+      const cleanStorageTable = normalizeKey(storageTable);
+      const modelFieldToColumn = /* @__PURE__ */ new Map();
+      const columnToModelField = /* @__PURE__ */ new Map();
+      const fields = {};
+      const domainFields = modelDef?.fields || {};
+      const storageFields = modelDef?.storage?.fields || {};
+      for (const [fieldName, fieldDef] of Object.entries(domainFields)) {
+        const storageCol = storageFields[fieldName]?.column || fieldName;
+        const cleanFieldName = normalizeKey(fieldName);
+        const cleanColName = normalizeKey(storageCol);
+        modelFieldToColumn.set(cleanFieldName, storageCol);
+        modelFieldToColumn.set(cleanColName, storageCol);
+        columnToModelField.set(cleanColName, fieldName);
+        columnToModelField.set(cleanFieldName, fieldName);
+        const hasDefault = Boolean(
+          storageDefaults[cleanStorageTable]?.[cleanColName]
+        );
+        fields[fieldName] = {
+          modelFieldName: fieldName,
+          storageColumn: storageCol,
+          nullable: Boolean(fieldDef?.nullable),
+          codecId: fieldDef?.type?.codecId,
+          hasDefault
+        };
+      }
+      const meta = {
+        modelName,
+        storageTable,
+        storageNamespace: storageNs,
+        modelFieldToColumn,
+        columnToModelField,
+        fields
+      };
+      modelsByName.set(cleanModelName, meta);
+      modelsByTable.set(cleanStorageTable, meta);
+    }
+  }
+  return { modelsByName, modelsByTable, columnsByTable };
+}
+function extractColumns(contractJson) {
+  const metadata = extractContractMetadata(contractJson);
+  return metadata.columnsByTable;
 }
 function autoZodPrisma8(options) {
-  const columnCatalog = extractColumns(options.contract);
+  const contractMeta = extractContractMetadata(options.contract);
   const validatorMap = /* @__PURE__ */ new Map();
   for (const entry of options.validators) {
-    validatorMap.set(normalizeKey(entry.tableName), entry.schema);
+    const rawName = entry.tableName || entry._tableName || entry.name;
+    const schema = entry.schema || entry;
+    if (rawName && schema) {
+      const cleanName = normalizeKey(rawName);
+      validatorMap.set(cleanName, schema);
+      const meta = contractMeta.modelsByName.get(cleanName) || contractMeta.modelsByTable.get(cleanName);
+      if (meta) {
+        validatorMap.set(normalizeKey(meta.modelName), schema);
+        validatorMap.set(normalizeKey(meta.storageTable), schema);
+      }
+    }
   }
   return {
     name: "autozod-validator",
     familyId: "sql",
     async beforeCompile(draft, ctx) {
       const ast = draft?.ast;
-      if (!ast || ast.kind !== "insert" && ast.kind !== "update") return void 0;
-      const target = ast.table?.name;
-      if (!target) return void 0;
-      const cleanTarget = normalizeKey(target);
-      const schema = validatorMap.get(cleanTarget);
-      if (!schema) return void 0;
-      const targetCols = columnCatalog[cleanTarget] || [];
-      const colLookup = /* @__PURE__ */ new Map();
-      for (const col of targetCols) {
-        colLookup.set(normalizeKey(col), col);
+      if (!ast || ast.kind !== "insert" && ast.kind !== "update") {
+        return void 0;
       }
-      const validateFields = (rawRecord, isUpdate) => {
-        const extracted = {};
+      const rawTable = ast.table?.name;
+      if (!rawTable) return void 0;
+      const cleanTable = normalizeKey(rawTable);
+      const meta = contractMeta.modelsByTable.get(cleanTable) || contractMeta.modelsByName.get(cleanTable);
+      const schema = validatorMap.get(cleanTable) || (meta ? validatorMap.get(normalizeKey(meta.modelName)) : void 0);
+      if (!schema) return void 0;
+      const schemaShape = schema.shape || {};
+      const schemaKeys = Object.keys(schemaShape);
+      const validateAndWriteBack = (rawRecord, isUpdate) => {
+        const toValidate = {};
+        const defaultExprFields = /* @__PURE__ */ new Set();
+        for (const expectedKey of schemaKeys) {
+          if (expectedKey in rawRecord) {
+            const raw = rawRecord[expectedKey];
+            if (isDefaultValueExpr(raw)) {
+              defaultExprFields.add(expectedKey);
+            } else {
+              toValidate[expectedKey] = extractValue(raw);
+            }
+            continue;
+          }
+          const storageCol = meta?.modelFieldToColumn.get(normalizeKey(expectedKey));
+          if (storageCol && storageCol in rawRecord) {
+            const raw = rawRecord[storageCol];
+            if (isDefaultValueExpr(raw)) {
+              defaultExprFields.add(expectedKey);
+            } else {
+              toValidate[expectedKey] = extractValue(raw);
+            }
+            continue;
+          }
+        }
         for (const [col, val] of Object.entries(rawRecord)) {
-          const actualCol = colLookup.get(normalizeKey(col)) || col;
-          extracted[actualCol] = extractValue(val);
+          const mappedModelField = meta?.columnToModelField.get(
+            normalizeKey(col)
+          );
+          if (mappedModelField && mappedModelField in schemaShape) {
+            if (isDefaultValueExpr(val)) {
+              defaultExprFields.add(mappedModelField);
+            } else if (!(mappedModelField in toValidate)) {
+              toValidate[mappedModelField] = extractValue(val);
+            }
+          }
         }
-        const schemaShape = schema.shape || {};
-        const schemaKeys = new Set(Object.keys(schemaShape));
-        const toValidate = {};
-        for (const [k, v] of Object.entries(extracted)) {
-          if (schemaKeys.has(k)) {
-            toValidate[k] = v;
+        let activeSchema = isUpdate ? schema.partial() : schema;
+        if (!isUpdate && defaultExprFields.size > 0 && typeof schema.partial === "function") {
+          const mask = {};
+          for (const f of defaultExprFields) {
+            mask[f] = true;
+          }
+          try {
+            activeSchema = schema.partial(mask);
+          } catch {
+          }
+        }
+        const parsed = activeSchema.parse(toValidate);
+        if (parsed && typeof parsed === "object") {
+          for (const [parsedKey, parsedVal] of Object.entries(parsed)) {
+            let storageCol = meta?.modelFieldToColumn.get(
+              normalizeKey(parsedKey)
+            );
+            if (!storageCol || !(storageCol in rawRecord)) {
+              if (parsedKey in rawRecord) {
+                storageCol = parsedKey;
+              }
+            }
+            if (storageCol && storageCol in rawRecord) {
+              const current = rawRecord[storageCol];
+              if (current && typeof current === "object" && "value" in current) {
+                current.value = parsedVal;
+              } else if (isDefaultValueExpr(current)) {
+                rawRecord[storageCol] = { value: parsedVal };
+              } else {
+                rawRecord[storageCol] = parsedVal;
+              }
+            } else if (storageCol && !isUpdate) {
+              rawRecord[storageCol] = { value: parsedVal };
+            }
           }
         }
-        const activeSchema = isUpdate ? schema.partial() : schema;
-        activeSchema.parse(toValidate);
       };
       if (ast.kind === "insert" && Array.isArray(ast.rows)) {
         for (const row of ast.rows) {
-          validateFields(row, false);
+          validateAndWriteBack(row, false);
         }
       } else if (ast.kind === "update" && ast.set) {
-        validateFields(ast.set, true);
+        validateAndWriteBack(ast.set, true);
       }
       return void 0;
     }
@@ -88,11 +220,86 @@ function createStrictZodRegistry() {
     };
   };
 }
+
+// src/schema-generator.ts
+import { z } from "zod";
+function codecToZodSchema(codecId) {
+  if (!codecId) return z.any();
+  const id = codecId.toLowerCase();
+  if (id.includes("uuid")) {
+    return z.string().uuid();
+  }
+  if (id.includes("/text") || id.includes("/varchar") || id.includes("/char") || id.includes("/citext")) {
+    return z.string();
+  }
+  if (id.includes("/int2") || id.includes("/int4")) {
+    return z.number().int();
+  }
+  if (id.includes("/float") || id.includes("/numeric")) {
+    return z.number();
+  }
+  if (id.includes("/int8")) {
+    return z.union([z.bigint(), z.number()]);
+  }
+  if (id.includes("/bool")) {
+    return z.boolean();
+  }
+  if (id.includes("/time") || id.includes("/date")) {
+    return z.union([z.date(), z.string()]);
+  }
+  if (id.includes("/json")) {
+    return z.any();
+  }
+  if (id.includes("/bytea")) {
+    return z.union([z.instanceof(Uint8Array), z.string()]);
+  }
+  return z.any();
+}
+function createInsertSchema(contract, modelName, refinements) {
+  const metadata = extractContractMetadata(contract);
+  const modelMeta = metadata.modelsByName.get(normalizeKey(modelName)) || metadata.modelsByTable.get(normalizeKey(modelName));
+  if (!modelMeta) {
+    const available = Array.from(metadata.modelsByName.values()).map((m) => m.modelName).join(", ");
+    throw new Error(
+      `[prisma-extension-autozod]: Model '${modelName}' not found in contract. Available models: ${available || "none"}`
+    );
+  }
+  const shape = {};
+  for (const [fieldName, fieldMeta] of Object.entries(modelMeta.fields)) {
+    let fieldSchema = codecToZodSchema(fieldMeta.codecId);
+    if (fieldMeta.nullable) {
+      fieldSchema = fieldSchema.nullable();
+    }
+    if (fieldMeta.hasDefault) {
+      fieldSchema = fieldSchema.optional();
+    }
+    const custom = refinements?.[fieldName] || refinements?.[fieldMeta.storageColumn];
+    if (custom) {
+      fieldSchema = typeof custom === "function" ? custom(fieldSchema) : custom;
+    }
+    shape[fieldName] = fieldSchema;
+  }
+  const schema = z.object(shape);
+  schema.tableName = modelName;
+  return schema;
+}
+function createUpdateSchema(contract, modelName, refinements) {
+  const insertSchema = createInsertSchema(contract, modelName, refinements);
+  const updateSchema = insertSchema.partial();
+  updateSchema.tableName = modelName;
+  return updateSchema;
+}
 export {
   autoZod,
   autoZodPrisma8,
+  codecToZodSchema,
+  createInsertSchema,
   createStrictZodRegistry,
+  createUpdateSchema,
   createZodRegistry,
   extractColumns,
+  extractContractMetadata,
+  extractValue,
+  isDefaultValueExpr,
   normalizeKey
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prisma-extension-autozod",
-  "version": "1.0.5",
+  "version": "1.1.0",
   "description": "Contract-aware compile-time linting and runtime Zod validation for Prisma ORM 8 (@prisma/orm-postgres)",
   "type": "module",
   "main": "./dist/index.cjs",
@@ -63,8 +63,5 @@
     "typescript": "5.8.2",
     "vitest": "^5.1.0",
     "zod": "^4.6.7"
-  },
-  "dependencies": {
-    "@prisma/orm-family-sql": "8.0.0-rc.22"
   }
 }