feat: mockAll coverage mode and zodmint/storybook adapter (v2.5.0)

- mockAll(schema, options?) — returns full boundary set for any schema.
  Numbers: min/min+1/max-1/max. Enums: all values. Booleans: [true, false].
  Optional/nullable: includes undefined/null. Union: one per branch.
  Every returned value passes safeParse. Duplicates removed.

- zodmint/storybook — new sub-entry with zodArgTypes() and mockArgs().
  Maps Zod types to Storybook controls (text/number/range/boolean/select/date/object).
  Zero @storybook/* dependencies.

- 55 new tests (37 coverage + 18 storybook), 534 total passing
- README, CHANGELOG, ROADMAP updated

Author: gonll

CHANGELOG.md

@@ -4,6 +4,27 @@ All notable changes to zodmint are documented here. This project follows [Keep a
 
 ---
 
+## [2.5.0] - 2026-06-03
+
+### Added
+- **`mockAll(schema, options?)`** — returns the full boundary set for a schema. For numbers, generates min, min+1, max-1, max (plus 0 if in range). For enums, returns every value. For booleans, always `[true, false]`. For optionals/nullables, includes `undefined`/`null` alongside the inner type's boundary values. For unions, one value per branch. For arrays, empty/1/2-item variants plus length-constrained boundaries. Duplicates are removed. Every returned value passes `schema.safeParse(v).success === true`. Accepts the same options as `mock()` (`seed`, `session`, `generators`); the `mode` option is ignored.
+- **`zodmint/storybook`** — new sub-entry with `zodArgTypes(schema)` and `mockArgs(schema, options?)`. `zodArgTypes` maps a Zod object schema to a Storybook `ArgTypes` record — string→text, number→number (range when both min and max are present), boolean→boolean, enum→select, date→date, object/array→object. `z.optional()` and `z.nullable()` are transparently unwrapped. `z.describe()` populates the `description` field. `mockArgs` is a typed wrapper around `mock()` for generating story `args`. Zero runtime dependencies — no `@storybook/*` import required.
+
+---
+
+## [2.4.0] - 2026-05-29
+
+### Added
+- **`zodmint/seed`** — new sub-entry for schema-driven database seeding. `seed(inserter, schema, options?)` generates `count` valid fixtures and inserts them via any async function. Returns the full array of generated items for chaining.
+- **`prismaInserter(model)`** — wraps a Prisma model delegate (`createMany`) into a `SeedInserter`. Zero runtime dependency: uses duck typing, so no `@prisma/client` import is required in `zodmint/seed` itself.
+- **`drizzleInserter(db, table)`** — wraps a Drizzle `db.insert(table).values()` call into a `SeedInserter`. Same approach: duck typed, no drizzle-orm import.
+- **`SeedOptions`** — extends `MockOptions` with `count` (default 10), `batchSize` (default: single batch), and `async` (uses `mockAsync()` when true, for schemas with async refinements).
+- **Batched inserts** — when `batchSize < count`, records are split into chunks and inserted sequentially, respecting ORM and DB row limits per statement.
+- **Seeded determinism** — when a `seed` value is provided, each item receives an offset seed (`seed + i`) so items are distinct but the full result set is reproducible.
+- `@prisma/client >= 5.0.0` and `drizzle-orm >= 0.29.0` added as optional peer dependencies.
+
+---
+
 ## [2.3.0] - 2026-05-29
 
 ### Added

README.md

@@ -892,12 +892,48 @@ Known gaps:
 
 **ORM/OpenAPI ingestion** — Only makes sense after relational generation matures.
 
+**Relational dataset DSL** — `dataset()` + `model().belongsTo()` for generating fully coherent multi-schema datasets with referential integrity. Planned for v3.
+
 ---
 
 Zod v4 uses `new Function()` internally to compile schema validators. If your environment disables `unsafe-eval` (e.g. via CSP), stick with Zod v3.
 
 ---
 
+## Coverage Mode — `mockAll`
+
+`mockAll(schema, options?)` returns the full boundary set for a schema — every interesting edge case — instead of a single value. Use it to systematically exercise constraint boundaries without writing the boundary values yourself.
+
+```typescript
+import { mockAll } from "zodmint";
+
+// Numbers: min, min+1, max-1, max (plus 0 if in range)
+mockAll(z.number().int().min(18).max(100));
+// → [0, 18, 19, 99, 100]
+
+// Enums: every value
+mockAll(z.enum(["admin", "user", "guest"]));
+// → ["admin", "user", "guest"]
+
+// Booleans: both values
+mockAll(z.boolean());
+// → [true, false]
+
+// Optional: includes undefined
+mockAll(z.string().optional());
+// → [undefined, "", "a", "abc"]
+
+// Union: one value per branch
+mockAll(z.union([z.string().uuid(), z.number().int().positive()]));
+// → ["3f2e1d4c-...", 1]
+```
+
+Every value in the returned array is guaranteed to pass `schema.safeParse(v).success === true`. Duplicates are automatically removed.
+
+`mockAll` accepts the same options as `mock()` — `seed`, `session`, `generators` — and forwards them to any internal generation calls. The `mode` option is ignored: `mockAll` always uses boundary-aware generation.
+
+---
+
 ## Integrations
 
 ### fast-check
@@ -1014,6 +1050,103 @@ Or add a script to `package.json`:
 
 ---
 
+### Database Seeding — `zodmint/seed`
+
+zodmint ships a `zodmint/seed` sub-entry for generating and inserting bulk fixtures directly into your database. It works with any ORM via a plain async inserter function, and ships first-class adapters for Prisma and Drizzle.
+
+```bash
+# No extra install needed — seed works with whatever ORM you already have
+```
+
+```typescript
+import { seed, prismaInserter, drizzleInserter } from "zodmint/seed";
+```
+
+**Prisma:**
+
+```typescript
+import { PrismaClient } from "@prisma/client";
+import { seed, prismaInserter } from "zodmint/seed";
+
+const prisma = new PrismaClient();
+
+const users = await seed(prismaInserter(prisma.user), UserSchema, { count: 50 });
+// users.length === 50, each passes UserSchema.safeParse  ✓
+// prisma.user.createMany was called with all 50 records
+```
+
+**Drizzle:**
+
+```typescript
+import { drizzle } from "drizzle-orm/node-postgres";
+import { seed, drizzleInserter } from "zodmint/seed";
+import { users } from "./schema";
+
+const db = drizzle(pool);
+
+await seed(drizzleInserter(db, users), UserSchema, { count: 50 });
+```
+
+**Plain function — works with any ORM or custom writer:**
+
+```typescript
+await seed(
+  (data) => prisma.user.createMany({ data }),
+  UserSchema,
+  { count: 50 },
+);
+```
+
+`seed()` returns the full array of generated items, so you can chain it with `mockRelated()` or assert against results in tests:
+
+```typescript
+const seededUsers = await seed(prismaInserter(prisma.user), UserSchema, { count: 10 });
+// seed related posts after
+const seededPosts = await seed(
+  prismaInserter(prisma.post),
+  PostSchema,
+  { count: 10, overrides: { userId: seededUsers[0].id } },
+);
+```
+
+All `MockOptions` are supported — `seed`, `mode`, `overrides`, `generators`, `session`:
+
+```typescript
+// Deterministic — same data every time
+await seed(prismaInserter(prisma.user), UserSchema, { count: 50, seed: 1 });
+
+// Unique emails via seq() + session
+const session = createSession();
+await seed(prismaInserter(prisma.user), UserSchema, {
+  count: 50,
+  session,
+  generators: { email: () => `user-${seq("email", session)}@example.com` },
+});
+
+// Edge-mode values to stress-test DB constraints
+await seed(prismaInserter(prisma.user), UserSchema, { count: 10, mode: "edge" });
+```
+
+**Batched inserts** — for large counts or ORMs with row limits per statement:
+
+```typescript
+await seed(prismaInserter(prisma.product), ProductSchema, {
+  count: 10_000,
+  batchSize: 500, // inserts in chunks of 500
+});
+```
+
+**Async schemas** — when the schema contains async `z.superRefine()` predicates, pass `async: true`:
+
+```typescript
+await seed(prismaInserter(prisma.user), UniqueEmailSchema, {
+  count: 20,
+  async: true,
+});
+```
+
+---
+
 ### Snapshot Pinning — `mockPin`
 
 `mockPin` generates a value and writes it to a JSON fixture file the first time it runs. Subsequent calls read from the file, giving you a stable snapshot that is always valid and always typed.
@@ -1100,6 +1233,65 @@ const [user, product, order] = mockRelatedThree(
 
 ---
 
+### Storybook — `zodmint/storybook`
+
+zodmint ships a `zodmint/storybook` sub-entry with two utilities for wiring Zod schemas into Storybook stories. No Storybook runtime dependency required — the package is a zero-dependency utility that produces plain objects Storybook understands.
+
+```typescript
+import { zodArgTypes, mockArgs } from "zodmint/storybook";
+```
+
+**`zodArgTypes(schema)`** maps a Zod object schema to a Storybook `ArgTypes` map. Each field becomes an argType with an appropriate control based on its Zod type:
+
+```typescript
+const ButtonPropsSchema = z.object({
+  label:    z.string().describe("Button text"),
+  disabled: z.boolean().optional(),
+  size:     z.enum(["sm", "md", "lg"]),
+  priority: z.number().min(1).max(10),
+});
+
+export default {
+  title: "Components/Button",
+  argTypes: zodArgTypes(ButtonPropsSchema),
+};
+// label    → { control: "text", description: "Button text" }
+// disabled → { control: "boolean" }
+// size     → { control: "select", options: ["sm", "md", "lg"] }
+// priority → { control: { type: "range", min: 1, max: 10 } }
+```
+
+**`mockArgs(schema, options?)`** generates a single valid mock value to use as story `args`:
+
+```typescript
+export const Default = {
+  args: mockArgs(ButtonPropsSchema),
+  // { label: "Submit", disabled: false, size: "md", priority: 7 }
+};
+
+export const SeededStory = {
+  args: mockArgs(ButtonPropsSchema, { seed: 42 }),
+  // same args every time — stable for snapshot tests
+};
+```
+
+Control mapping:
+
+| Zod type | Storybook control |
+|---|---|
+| `z.string()` | `"text"` |
+| `z.number()` | `"number"` |
+| `z.number().min(x).max(y)` | `{ type: "range", min: x, max: y }` |
+| `z.boolean()` | `"boolean"` |
+| `z.enum([...])` / `z.nativeEnum(E)` | `"select"` with `options` |
+| `z.date()` | `"date"` |
+| `z.object({...})` / `z.array(...)` | `"object"` |
+| everything else | `"text"` (fallback) |
+
+`z.optional()` and `z.nullable()` are transparently unwrapped — the inner type determines the control. `z.describe("...")` populates the `description` field on the argType.
+
+---
+
 ## Prior art
 
 zodmint was built with an eye on the existing ecosystem. Three libraries were studied for orientation:

examples/14-seed.ts

@@ -0,0 +1,133 @@
+/**
+ * Database seeding — zodmint/seed
+ *
+ * Generates batches of valid fixtures and inserts them via any async inserter.
+ * First-class adapters for Prisma and Drizzle are included.
+ *
+ * Run: npx tsx examples/14-seed.ts
+ */
+import { z } from "zod";
+import { createSession, seq } from "zodmint";
+import { seed, prismaInserter, drizzleInserter } from "zodmint/seed";
+
+const UserSchema = z.object({
+  id: z.string().uuid(),
+  email: z.string().email(),
+  name: z.string(),
+  role: z.enum(["admin", "user", "guest"]),
+  active: z.boolean(),
+});
+
+// ─── Plain function inserter — works with anything ────────────────────────────
+
+const db: unknown[] = [];
+
+const users = await seed(
+  async (items) => { db.push(...items); },
+  UserSchema,
+  { count: 5, seed: 1 },
+);
+
+console.log("Inserted via plain fn:", users.length, "users");
+console.log("All valid:", users.every((u) => UserSchema.safeParse(u).success));
+
+// ─── Prisma adapter ───────────────────────────────────────────────────────────
+
+// In a real project: import { PrismaClient } from '@prisma/client'
+// const prisma = new PrismaClient()
+
+// Simulated Prisma model delegate (same shape as the real thing)
+const prismaUserModel = {
+  createMany: async (args: { data: unknown[] }) => {
+    console.log("\nprisma.user.createMany called with", args.data.length, "records");
+    return { count: args.data.length };
+  },
+};
+
+const prismaUsers = await seed(
+  prismaInserter(prismaUserModel),
+  UserSchema,
+  { count: 10, seed: 42 },
+);
+
+console.log("Prisma seed:", prismaUsers.length, "users");
+
+// ─── Drizzle adapter ──────────────────────────────────────────────────────────
+
+// In a real project:
+// import { drizzle } from 'drizzle-orm/node-postgres'
+// import { users } from './schema'
+// const db = drizzle(pool)
+
+// Simulated Drizzle db (same shape as the real thing)
+const drizzleDb = {
+  insert: (table: unknown) => ({
+    values: async (data: unknown[]) => {
+      console.log("\ndrizzle insert into", table, "with", data.length, "rows");
+      return data;
+    },
+  }),
+};
+
+const drizzleUsers = await seed(
+  drizzleInserter(drizzleDb, "users"),
+  UserSchema,
+  { count: 8, seed: 7 },
+);
+
+console.log("Drizzle seed:", drizzleUsers.length, "users");
+
+// ─── Batched insert ───────────────────────────────────────────────────────────
+
+let batchCount = 0;
+await seed(
+  async (batch) => {
+    batchCount++;
+    console.log(`\nBatch ${batchCount}: ${batch.length} records`);
+  },
+  UserSchema,
+  { count: 25, batchSize: 10, seed: 100 },
+);
+// Batches: [10, 10, 5]
+
+// ─── Unique fields via seq() ──────────────────────────────────────────────────
+
+const session = createSession();
+
+const ContactSchema = z.object({
+  email: z.string().email(),
+  name: z.string(),
+});
+
+const contacts = await seed(
+  async () => {},
+  ContactSchema,
+  {
+    count: 5,
+    session,
+    generators: {
+      email: () => `user-${seq("email", session)}@example.com`,
+    },
+  },
+);
+
+console.log("\nUnique emails:");
+contacts.forEach((c) => console.log(" ", c.email));
+// user-1@example.com, user-2@example.com, ...
+
+// ─── Async schema refinements ─────────────────────────────────────────────────
+
+const EvenAgeSchema = z.object({
+  name: z.string(),
+  age: z.number().int().min(18).max(98).superRefine(async (n, ctx) => {
+    if (n % 2 !== 0) ctx.addIssue({ code: "custom", message: "must be even" });
+  }),
+});
+
+const evenUsers = await seed(async () => {}, EvenAgeSchema, {
+  count: 3,
+  async: true, // use mockAsync() internally
+});
+
+console.log("\nEven ages:", evenUsers.map((u) => u.age));
+// all even numbers

examples/15-coverage.ts

@@ -0,0 +1,17 @@
+// 15-coverage.ts — mockAll: boundary-set generation
+import { z } from "zod";
+import { mockAll } from "zodmint";
+
+const AgeSchema = z.number().int().min(18).max(100);
+console.log("ages:", mockAll(AgeSchema));
+
+const RoleSchema = z.enum(["admin", "user", "guest"]);
+console.log("roles:", mockAll(RoleSchema));
+
+console.log("booleans:", mockAll(z.boolean()));
+
+const MaybeStr = z.string().optional();
+console.log("optional:", mockAll(MaybeStr));
+
+const IdSchema = z.union([z.string().uuid(), z.number().int().positive()]);
+console.log("ids:", mockAll(IdSchema));