prisma-extension-autozod 1.0.3 → 1.0.5

package/README.md

@@ -7,14 +7,26 @@
 > 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.
 
 ---
 
+## Why prisma-extension-autozod?
+
+| Feature | Manual Controller Validation | Schema Generators (zod-prisma) | prisma-extension-autozod |
+| :--- | :--- | :--- | :--- |
+| **Zero Controller Boilerplate** | No (Manual `.parse()`) | No (Manual `.parse()`) | Yes (Auto-intercepted) |
+| **Prisma 8 Native Architecture** | No | No | Yes (`beforeCompile` / Contract) |
+| **Compile-Time Typo Linter** | No | No | Yes (Immediate IDE feedback) |
+| **Casing Normalization** | No | No | Yes (`first_name` <-> `firstName`) |
+
+---
+
 ## Requirements
 
-- **Node.js**: `>= 24.0.0`
+- **Node.js**: `>= 22.0.0`
 - **Prisma ORM**: `@prisma/orm-postgres >= 8.0.0`
 - **Zod**: `^4.0.0`
 
@@ -64,18 +76,30 @@ 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(),
-  })
+    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
-> }));
+> defineModel(
+>   "User",
+>   z.object({
+>     nonExistentColumn: z.string(), // Error: Field 'nonExistentColumn' does not exist in table contract
+>   }),
+> );
 > ```
 
 ---
@@ -128,11 +152,43 @@ 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
-  });
+await db.orm.public.User.where({ email: "alice@prisma.io" }).update({
+  name: "Alice Wonder", // Valid; other fields are not required on updates
+});
+```
+
+---
+
+### 4. Column Normalization in Action
+
+Incoming payloads from frontend forms or REST APIs often use `snake_case`. The middleware automatically remaps them to match your contract columns:
+
+```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",
+});
+```
+
+---
+
+### 5. Error Handling DX
+
+Because validation throws standard `ZodError` instances, you can easily catch and format errors for HTTP responses in Express, NestJS, Fastify, or Hono:
+
+```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;
+}
 ```
 
 ---
@@ -140,28 +196,36 @@ await db.orm.public.User
 ## 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.
 
 ---
@@ -184,6 +248,17 @@ pnpm run build
 
 ---
 
+## Contributing
+
+Contributions, bug reports, and feature requests are welcome!  
+Feel free to check the [issues page](https://github.com/abzr0o/prisma-extension-autozod/issues).
+
+## Support
+
+If this library saves you time or prevents schema bugs in production, consider giving it a star on [GitHub](https://github.com/abzr0o/prisma-extension-autozod)!
+
+---
+
 ## License
 
 [MIT](LICENSE) (c) [Mohammed Thamer](https://github.com/abzr0o)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prisma-extension-autozod",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "Contract-aware compile-time linting and runtime Zod validation for Prisma ORM 8 (@prisma/orm-postgres)",
   "type": "module",
   "main": "./dist/index.cjs",