prisma-extension-autozod 0.0.0-stage → 1.0.0

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 Mohammed Thamer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

package/README.md

@@ -1,3 +1,189 @@
-# Temporary Holding Version
+# prisma-extension-autozod
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+[![npm version](https://img.shields.io/npm/v/prisma-extension-autozod.svg)](https://www.npmjs.com/package/prisma-extension-autozod)
+[![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).
+
+`prisma-extension-autozod` connects **Zod 4** and **Prisma ORM 8**. It provides two 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.
+
+---
+
+## Requirements
+
+- **Node.js**: `>= 24.0.0`
+- **Prisma ORM**: `@prisma/orm-postgres >= 8.0.0`
+- **Zod**: `^4.0.0`
+
+---
+
+## Features
+
+- **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.
+
+---
+
+## Installation
+
+```bash
+# pnpm
+pnpm add prisma-extension-autozod zod @prisma/orm-postgres
+
+# npm
+npm install prisma-extension-autozod zod @prisma/orm-postgres
+
+# yarn
+yarn add prisma-extension-autozod zod @prisma/orm-postgres
+```
+
+---
+
+## Quickstart
+
+### 1. Define Validated Schemas with Contract Linting
+
+Bind your Zod schemas to your generated Prisma 8 `models` 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(),
+  })
+);
+```
+
+> **Compile-Time Safety in Action:**
+> 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
+> }));
+> ```
+
+---
+
+### 2. Register Middleware in Your Prisma 8 Client
+
+Pass the middleware to your `@prisma/orm-postgres` client setup:
+
+```typescript
+import postgres from "@prisma/orm-postgres/runtime";
+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";
+
+export const contract = contractFromJson(contractJson);
+
+export const db = postgres({
+  contract,
+  url: process.env.DATABASE_URL!,
+  middleware: [
+    autoZodPrisma8({
+      contract: contractJson,
+      validators: [userValidator],
+    }),
+  ],
+});
+```
+
+---
+
+### 3. Automatic Validation & Sanitization
+
+In the new Prisma ORM, models are accessed via `db.orm.<namespace>.<ModelName>`:
+
+```typescript
+// Valid: Passes validation and executes
+await db.orm.public.User.create({
+  email: "alice@prisma.io",
+  username: "alice",
+  name: "Alice Smith",
+});
+
+// Invalid: Throws standard ZodError before hitting the database
+await db.orm.public.User.create({
+  email: "not-an-email",
+  username: "a", // too short (< 2 characters)
+  name: "Alice",
+});
+
+// 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
+  });
+```
+
+---
+
+## API Reference
+
+### `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);
+```
+
+### `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);
+```
+
+### `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.
+
+---
+
+## Development & Testing
+
+```bash
+# Install dependencies
+pnpm install
+
+# Run tests
+pnpm test
+
+# Typecheck
+pnpm run typecheck
+
+# Build bundle (ESM + CJS + DTS)
+pnpm run build
+```
+
+---
+
+## License
+
+[MIT](LICENSE) (c) [Mohammed Thamer](https://github.com/abzr0o)

package/dist/index.cjs

@@ -0,0 +1,130 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  autoZod: () => autoZod,
+  autoZodPrisma8: () => autoZodPrisma8,
+  createStrictZodRegistry: () => createStrictZodRegistry,
+  createZodRegistry: () => createZodRegistry,
+  extractColumns: () => extractColumns,
+  normalizeKey: () => normalizeKey
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/middleware.ts
+function normalizeKey(key) {
+  return key.toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+function extractValue(val) {
+  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)) {
+    const tables = ns?.entries?.table || ns?.tables || {};
+    for (const [table, def] of Object.entries(tables)) {
+      tableCols[normalizeKey(table)] = Object.keys(def?.columns || {});
+    }
+  }
+  return tableCols;
+}
+function autoZodPrisma8(options) {
+  const columnCatalog = extractColumns(options.contract);
+  const validatorMap = /* @__PURE__ */ new Map();
+  for (const entry of options.validators) {
+    validatorMap.set(normalizeKey(entry.tableName), entry.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);
+      }
+      const validateFields = (rawRecord, isUpdate) => {
+        const extracted = {};
+        for (const [col, val] of Object.entries(rawRecord)) {
+          const actualCol = colLookup.get(normalizeKey(col)) || col;
+          extracted[actualCol] = 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;
+          }
+        }
+        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);
+        }
+      } else if (ast.kind === "update" && ast.set) {
+        validateFields(ast.set, true);
+      }
+      return void 0;
+    }
+  };
+}
+var autoZod = autoZodPrisma8;
+
+// src/registry.ts
+function createZodRegistry() {
+  return function(tableName, schema) {
+    return {
+      tableName,
+      schema
+    };
+  };
+}
+function createStrictZodRegistry() {
+  return function(tableName, schema) {
+    return {
+      tableName,
+      schema
+    };
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  autoZod,
+  autoZodPrisma8,
+  createStrictZodRegistry,
+  createZodRegistry,
+  extractColumns,
+  normalizeKey
+});

package/dist/index.d.cts

@@ -0,0 +1,203 @@
+import { z } from 'zod';
+
+/**
+ * Normalizes a string type by stripping underscores and hyphens and converting to lowercase.
+ */
+type CleanKey<S extends string> = Lowercase<S extends `${infer Head}_${infer Tail}` ? `${Head}${CleanKey<Tail>}` : S extends `${infer Head}-${infer Tail}` ? `${Head}${CleanKey<Tail>}` : S>;
+/**
+ * Resolves a Zod field key against the list of contract column fields using case-insensitive matching.
+ */
+type ResolveColumn<ZodKey extends string, ContractFields extends string> = {
+    [Field in ContractFields]: CleanKey<Field> extends CleanKey<ZodKey> ? Field : never;
+}[ContractFields];
+/**
+ * Returns any keys in `TShape` that do NOT correspond to a known column on the contract model.
+ */
+type InvalidContractKeys<TShape, ContractFields extends string> = {
+    [K in keyof TShape]: ResolveColumn<Extract<K, string>, ContractFields> extends never ? Extract<K, string> : never;
+}[keyof TShape];
+/**
+ * Returns any contract column names that are missing in `TShape`.
+ */
+type MissingContractKeys<TShape, ContractFields extends string> = {
+    [Field in ContractFields]: CleanKey<Field> extends CleanKey<Extract<keyof TShape, string>> ? never : Field;
+}[ContractFields];
+/**
+ * Compile-time linter type that verifies a Zod schema shape against Prisma 8 contract model fields.
+ *
+ * If all keys match, evaluates to `z.ZodObject<TShape>`.
+ * If any invalid key exists, evaluates to an error object mapping each invalid key
+ * to a descriptive compile error string.
+ */
+type ValidateZodAgainstContract<TShape, ContractFields extends string> = [InvalidContractKeys<TShape, ContractFields>] extends [never] ? z.ZodObject<TShape & z.ZodRawShape> : {
+    [K in keyof TShape]: ResolveColumn<Extract<K, string>, ContractFields> extends never ? `[Prisma8-Contract-Error]: Field '${Extract<K, string>}' does not exist in table contract` : any;
+};
+
+/**
+ * Represents a registered validator entry binding a table name to its Zod schema.
+ */
+interface ModelValidatorEntry {
+    /**
+     * The name of the database table or model to validate against.
+     */
+    tableName: string;
+    /**
+     * The Zod object schema used to validate mutation payloads.
+     */
+    schema: z.ZodObject<any>;
+}
+/**
+ * Creates a strongly typed validator registry factory bound to Prisma ORM 8 contract models.
+ *
+ * Provides compile-time checking ensuring that every field declared in your Zod schema
+ * corresponds to a valid column on the database model. Fields with default or auto-generated
+ * values (such as `id`, `createdAt`, `updatedAt`) can be omitted from the schema.
+ *
+ * @template TModels The generated Prisma 8 `Models` or `typeof models.public` type map.
+ * @returns A factory function `(tableName, schema)` producing a typed `ModelValidatorEntry`.
+ *
+ * @example
+ * ```typescript
+ * import { z } from "zod";
+ * import { createZodRegistry } from "prisma-extension-autozod";
+ * import type { models } from "./contract.d.ts";
+ *
+ * const defineModel = createZodRegistry<typeof models.public>();
+ *
+ * export const userValidator = defineModel(
+ *   "User",
+ *   z.object({
+ *     email: z.string().email(),
+ *     username: z.string().min(2),
+ *     name: z.string().nullable().optional(),
+ *   })
+ * );
+ * ```
+ */
+declare function createZodRegistry<TModels extends Record<string, any>>(): <TTable extends keyof TModels & string, TShape extends z.ZodRawShape>(tableName: TTable, schema: ValidateZodAgainstContract<TShape, Extract<keyof TModels[TTable], string>>) => ModelValidatorEntry;
+/**
+ * Creates a strict validator registry factory bound to Prisma ORM 8 contract models.
+ *
+ * In addition to rejecting unknown fields, this enforces that ALL columns defined on the
+ * contract table MUST be declared in the Zod schema.
+ *
+ * @template TModels The generated Prisma 8 `Models` or `typeof models.public` type map.
+ * @returns A factory function `(tableName, schema)` producing a typed `ModelValidatorEntry`.
+ *
+ * @example
+ * ```typescript
+ * import { z } from "zod";
+ * import { createStrictZodRegistry } from "prisma-extension-autozod";
+ * import type { models } from "./contract.d.ts";
+ *
+ * const defineStrict = createStrictZodRegistry<typeof models.public>();
+ *
+ * // Compile error if any column from the table contract is omitted:
+ * export const userValidator = defineStrict(
+ *   "User",
+ *   z.object({
+ *     id: z.number(),
+ *     email: z.string().email(),
+ *     username: z.string().nullable(),
+ *     name: z.string().nullable(),
+ *     createdAt: z.date(),
+ *     updatedAt: z.date(),
+ *   })
+ * );
+ * ```
+ */
+declare function createStrictZodRegistry<TModels extends Record<string, any>>(): <TTable extends keyof TModels & string, TShape extends z.ZodRawShape>(tableName: TTable, schema: [InvalidContractKeys<TShape, Extract<keyof TModels[TTable], string>>] extends [never] ? [MissingContractKeys<TShape, Extract<keyof TModels[TTable], string>>] extends [never] ? z.ZodObject<TShape> : { [K in MissingContractKeys<TShape, Extract<keyof TModels[TTable], string>>]: `[Prisma8-Contract-Error]: Missing required table column '${K}' in schema`; } : { [K in keyof TShape]: ResolveColumn<Extract<K, string>, Extract<keyof TModels[TTable], string>> extends never ? `[Prisma8-Contract-Error]: Field '${Extract<K, string>}' does not exist in table contract` : any; }) => ModelValidatorEntry;
+
+/**
+ * Shape of the AutoZod SQL middleware compatible with Prisma ORM 8 clients.
+ */
+interface AutoZodMiddleware {
+    /**
+     * Unique identifier name for the middleware.
+     */
+    name: string;
+    /**
+     * Target storage engine family. Always 'sql' for PostgreSQL.
+     */
+    familyId: "sql";
+    /**
+     * Lifecycle hook invoked prior to SQL plan compilation.
+     * Intercepts and validates AST mutation rows and values.
+     */
+    beforeCompile(draft: any, ctx: any): Promise<undefined>;
+}
+/**
+ * Normalizes a key by stripping hyphens, underscores, and special characters,
+ * and converting to lowercase.
+ *
+ * @param key The column or table string to normalize.
+ * @returns A sanitized lowercase alphanumeric string.
+ *
+ * @example
+ * ```typescript
+ * normalizeKey("first_name"); // "firstname"
+ * normalizeKey("User-Profile"); // "userprofile"
+ * ```
+ */
+declare function normalizeKey(key: string): string;
+/**
+ * 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.
+ *
+ * @param options.contract The parsed Prisma 8 `contract.json` object.
+ * @param options.validators An array of validator entries produced by `createZodRegistry`.
+ * @returns An `AutoZodMiddleware` instance ready to be passed to `postgres({ middleware: [...] })`.
+ *
+ * @example
+ * ```typescript
+ * import postgres from "@prisma/orm-postgres/runtime";
+ * 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";
+ *
+ * export const contract = contractFromJson(contractJson);
+ *
+ * export const db = postgres({
+ *   contract,
+ *   url: process.env.DATABASE_URL!,
+ *   middleware: [
+ *     autoZodPrisma8({
+ *       contract: contractJson,
+ *       validators: [userValidator],
+ *     }),
+ *   ],
+ * });
+ * ```
+ */
+declare function autoZodPrisma8(options: {
+    contract: any;
+    validators: ModelValidatorEntry[];
+}): 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 };

package/dist/index.d.ts

@@ -0,0 +1,203 @@
+import { z } from 'zod';
+
+/**
+ * Normalizes a string type by stripping underscores and hyphens and converting to lowercase.
+ */
+type CleanKey<S extends string> = Lowercase<S extends `${infer Head}_${infer Tail}` ? `${Head}${CleanKey<Tail>}` : S extends `${infer Head}-${infer Tail}` ? `${Head}${CleanKey<Tail>}` : S>;
+/**
+ * Resolves a Zod field key against the list of contract column fields using case-insensitive matching.
+ */
+type ResolveColumn<ZodKey extends string, ContractFields extends string> = {
+    [Field in ContractFields]: CleanKey<Field> extends CleanKey<ZodKey> ? Field : never;
+}[ContractFields];
+/**
+ * Returns any keys in `TShape` that do NOT correspond to a known column on the contract model.
+ */
+type InvalidContractKeys<TShape, ContractFields extends string> = {
+    [K in keyof TShape]: ResolveColumn<Extract<K, string>, ContractFields> extends never ? Extract<K, string> : never;
+}[keyof TShape];
+/**
+ * Returns any contract column names that are missing in `TShape`.
+ */
+type MissingContractKeys<TShape, ContractFields extends string> = {
+    [Field in ContractFields]: CleanKey<Field> extends CleanKey<Extract<keyof TShape, string>> ? never : Field;
+}[ContractFields];
+/**
+ * Compile-time linter type that verifies a Zod schema shape against Prisma 8 contract model fields.
+ *
+ * If all keys match, evaluates to `z.ZodObject<TShape>`.
+ * If any invalid key exists, evaluates to an error object mapping each invalid key
+ * to a descriptive compile error string.
+ */
+type ValidateZodAgainstContract<TShape, ContractFields extends string> = [InvalidContractKeys<TShape, ContractFields>] extends [never] ? z.ZodObject<TShape & z.ZodRawShape> : {
+    [K in keyof TShape]: ResolveColumn<Extract<K, string>, ContractFields> extends never ? `[Prisma8-Contract-Error]: Field '${Extract<K, string>}' does not exist in table contract` : any;
+};
+
+/**
+ * Represents a registered validator entry binding a table name to its Zod schema.
+ */
+interface ModelValidatorEntry {
+    /**
+     * The name of the database table or model to validate against.
+     */
+    tableName: string;
+    /**
+     * The Zod object schema used to validate mutation payloads.
+     */
+    schema: z.ZodObject<any>;
+}
+/**
+ * Creates a strongly typed validator registry factory bound to Prisma ORM 8 contract models.
+ *
+ * Provides compile-time checking ensuring that every field declared in your Zod schema
+ * corresponds to a valid column on the database model. Fields with default or auto-generated
+ * values (such as `id`, `createdAt`, `updatedAt`) can be omitted from the schema.
+ *
+ * @template TModels The generated Prisma 8 `Models` or `typeof models.public` type map.
+ * @returns A factory function `(tableName, schema)` producing a typed `ModelValidatorEntry`.
+ *
+ * @example
+ * ```typescript
+ * import { z } from "zod";
+ * import { createZodRegistry } from "prisma-extension-autozod";
+ * import type { models } from "./contract.d.ts";
+ *
+ * const defineModel = createZodRegistry<typeof models.public>();
+ *
+ * export const userValidator = defineModel(
+ *   "User",
+ *   z.object({
+ *     email: z.string().email(),
+ *     username: z.string().min(2),
+ *     name: z.string().nullable().optional(),
+ *   })
+ * );
+ * ```
+ */
+declare function createZodRegistry<TModels extends Record<string, any>>(): <TTable extends keyof TModels & string, TShape extends z.ZodRawShape>(tableName: TTable, schema: ValidateZodAgainstContract<TShape, Extract<keyof TModels[TTable], string>>) => ModelValidatorEntry;
+/**
+ * Creates a strict validator registry factory bound to Prisma ORM 8 contract models.
+ *
+ * In addition to rejecting unknown fields, this enforces that ALL columns defined on the
+ * contract table MUST be declared in the Zod schema.
+ *
+ * @template TModels The generated Prisma 8 `Models` or `typeof models.public` type map.
+ * @returns A factory function `(tableName, schema)` producing a typed `ModelValidatorEntry`.
+ *
+ * @example
+ * ```typescript
+ * import { z } from "zod";
+ * import { createStrictZodRegistry } from "prisma-extension-autozod";
+ * import type { models } from "./contract.d.ts";
+ *
+ * const defineStrict = createStrictZodRegistry<typeof models.public>();
+ *
+ * // Compile error if any column from the table contract is omitted:
+ * export const userValidator = defineStrict(
+ *   "User",
+ *   z.object({
+ *     id: z.number(),
+ *     email: z.string().email(),
+ *     username: z.string().nullable(),
+ *     name: z.string().nullable(),
+ *     createdAt: z.date(),
+ *     updatedAt: z.date(),
+ *   })
+ * );
+ * ```
+ */
+declare function createStrictZodRegistry<TModels extends Record<string, any>>(): <TTable extends keyof TModels & string, TShape extends z.ZodRawShape>(tableName: TTable, schema: [InvalidContractKeys<TShape, Extract<keyof TModels[TTable], string>>] extends [never] ? [MissingContractKeys<TShape, Extract<keyof TModels[TTable], string>>] extends [never] ? z.ZodObject<TShape> : { [K in MissingContractKeys<TShape, Extract<keyof TModels[TTable], string>>]: `[Prisma8-Contract-Error]: Missing required table column '${K}' in schema`; } : { [K in keyof TShape]: ResolveColumn<Extract<K, string>, Extract<keyof TModels[TTable], string>> extends never ? `[Prisma8-Contract-Error]: Field '${Extract<K, string>}' does not exist in table contract` : any; }) => ModelValidatorEntry;
+
+/**
+ * Shape of the AutoZod SQL middleware compatible with Prisma ORM 8 clients.
+ */
+interface AutoZodMiddleware {
+    /**
+     * Unique identifier name for the middleware.
+     */
+    name: string;
+    /**
+     * Target storage engine family. Always 'sql' for PostgreSQL.
+     */
+    familyId: "sql";
+    /**
+     * Lifecycle hook invoked prior to SQL plan compilation.
+     * Intercepts and validates AST mutation rows and values.
+     */
+    beforeCompile(draft: any, ctx: any): Promise<undefined>;
+}
+/**
+ * Normalizes a key by stripping hyphens, underscores, and special characters,
+ * and converting to lowercase.
+ *
+ * @param key The column or table string to normalize.
+ * @returns A sanitized lowercase alphanumeric string.
+ *
+ * @example
+ * ```typescript
+ * normalizeKey("first_name"); // "firstname"
+ * normalizeKey("User-Profile"); // "userprofile"
+ * ```
+ */
+declare function normalizeKey(key: string): string;
+/**
+ * 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.
+ *
+ * @param options.contract The parsed Prisma 8 `contract.json` object.
+ * @param options.validators An array of validator entries produced by `createZodRegistry`.
+ * @returns An `AutoZodMiddleware` instance ready to be passed to `postgres({ middleware: [...] })`.
+ *
+ * @example
+ * ```typescript
+ * import postgres from "@prisma/orm-postgres/runtime";
+ * 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";
+ *
+ * export const contract = contractFromJson(contractJson);
+ *
+ * export const db = postgres({
+ *   contract,
+ *   url: process.env.DATABASE_URL!,
+ *   middleware: [
+ *     autoZodPrisma8({
+ *       contract: contractJson,
+ *       validators: [userValidator],
+ *     }),
+ *   ],
+ * });
+ * ```
+ */
+declare function autoZodPrisma8(options: {
+    contract: any;
+    validators: ModelValidatorEntry[];
+}): 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 };

package/dist/index.js

@@ -0,0 +1,98 @@
+// src/middleware.ts
+function normalizeKey(key) {
+  return key.toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+function extractValue(val) {
+  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)) {
+    const tables = ns?.entries?.table || ns?.tables || {};
+    for (const [table, def] of Object.entries(tables)) {
+      tableCols[normalizeKey(table)] = Object.keys(def?.columns || {});
+    }
+  }
+  return tableCols;
+}
+function autoZodPrisma8(options) {
+  const columnCatalog = extractColumns(options.contract);
+  const validatorMap = /* @__PURE__ */ new Map();
+  for (const entry of options.validators) {
+    validatorMap.set(normalizeKey(entry.tableName), entry.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);
+      }
+      const validateFields = (rawRecord, isUpdate) => {
+        const extracted = {};
+        for (const [col, val] of Object.entries(rawRecord)) {
+          const actualCol = colLookup.get(normalizeKey(col)) || col;
+          extracted[actualCol] = 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;
+          }
+        }
+        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);
+        }
+      } else if (ast.kind === "update" && ast.set) {
+        validateFields(ast.set, true);
+      }
+      return void 0;
+    }
+  };
+}
+var autoZod = autoZodPrisma8;
+
+// src/registry.ts
+function createZodRegistry() {
+  return function(tableName, schema) {
+    return {
+      tableName,
+      schema
+    };
+  };
+}
+function createStrictZodRegistry() {
+  return function(tableName, schema) {
+    return {
+      tableName,
+      schema
+    };
+  };
+}
+export {
+  autoZod,
+  autoZodPrisma8,
+  createStrictZodRegistry,
+  createZodRegistry,
+  extractColumns,
+  normalizeKey
+};

package/package.json

@@ -1,6 +1,69 @@
 {
   "name": "prisma-extension-autozod",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.0",
+  "description": "Contract-aware compile-time linting and runtime Zod validation for Prisma ORM 8 (@prisma/orm-postgres)",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=24.0.0"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts --clean",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run typecheck && npm run test && npm run build"
+  },
+  "keywords": [
+    "prisma",
+    "prisma8",
+    "orm-postgres",
+    "zod",
+    "validation",
+    "middleware",
+    "autozod",
+    "orm",
+    "contract-linting",
+    "prisma-orm-extension"
+  ],
+  "license": "MIT",
+  "author": {
+    "name": "Mohammed Thamer",
+    "email": "mt20021911@gmail.com",
+    "url": "https://github.com/abzr0o"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/abzr0o/prisma-extension-autozod.git"
+  },
+  "bugs": {
+    "url": "https://github.com/abzr0o/prisma-extension-autozod/issues"
+  },
+  "homepage": "https://github.com/abzr0o/prisma-extension-autozod#readme",
+  "peerDependencies": {
+    "@prisma/orm-postgres": "^8.0.0",
+    "zod": "^4.0.0"
+  },
+  "devDependencies": {
+    "@prisma/orm-postgres": "8.0.0-rc.22",
+    "tsup": "^9.0.0",
+    "typescript": "5.8.2",
+    "vitest": "^5.1.0"
+  },
+  "dependencies": {
+    "@prisma/orm-family-sql": "8.0.0-rc.22",
+    "zod": "^4.6.7"
+  }
+}