Generate schema-valid MSW handlers directly from your Zod schemas

[gonll]

zodmint/msw

generate schema-valid MSW handlers directly from your Zod schemas

Hey folks 👋

I built [zodmint](https://github.com/gonll/zodmint), a fixture generator that derives mock data from Zod schemas, guaranteeing schema.safeParse(output).success === true on every value. It ships a first-class zodmint/msw sub-entry that wires a Zod schema directly to an MSW v2 handler.

The problem it solves

When you hand-write MSW handlers, the response body is decoupled from your schema. faker.internet.email() doesn't know about .max(10). faker.number.int() doesn't know about .positive(). Your handlers pass in tests but the shape drifts silently from what your app actually validates.

How it works

import { mockHandler, mockHandlers } from 'zodmint/msw'

export const handlers = [
  mockHandler(UserSchema, 'GET /api/users/:id'),
  mockHandler(PostSchema, 'POST /api/posts', { status: 201 }),
  mockHandler(ErrorSchema, 'GET /api/broken', { status: 500 }),
]

Every response is generated from the schema itself, so it always satisfies the same validation your app runs on real API responses.

It supports all the options you'd expect:

// Deterministic fixture, same data on every test run
mockHandler(UserSchema, 'GET /api/users/:id', { seed: 42 })

// Simulate a slow endpoint
mockHandler(UserSchema, 'GET /api/users/:id', { delay: 300 })

// Permanently hanging request (spinner tests)
mockHandler(UserSchema, 'GET /api/data', { delay: 'infinite' })

// Pin specific fields, let zodmint fill the rest
mockHandler(UserSchema, 'GET /api/users/:id', {
  overrides: { role: 'admin' }
})

Or batch with mockHandlers():

export const handlers = mockHandlers([
  { schema: UserSchema, route: 'GET /api/users/:id' },
  { schema: PostSchema, route: 'POST /api/posts', status: 201 },
])

Install

npm install zodmint

MSW and Zod are peer dependencies you likely already have.

Full docs: [github.com/gonll/zodmint](https://github.com/gonll/zodmint)

---

Would love feedback, especially from folks with complex union/discriminated union schemas, those are the interesting edge cases. 🙏

[kettanaito]

Hi @gonll. Thanks for building Zodmint.

I wonder did you compare it to Data? I haven't ported back the handler generation, but that's on the roadmap. I went for full Standard Schema support instead of just Zod so devs could bring their own schema libraries for modeling. Would like to hear your thoughts on it.

[gonll]

Hey @kettanaito thank you for reaching out!

Yes, I looked at it closely. The way I see it, Data is a test data store: you bring values, it manages them, queries them, models relations. Zodmint is a generator: you bring a schema, it produces values. They sit at different layers, so I think they compose well rather than compete.
On Standard Schema, that's the right call for your use case since Data only needs to validate records on write. Zodmint can't go that route. Generating values from a schema requires deep introspection of the schema's internal structure (types, constraints, transforms), not just calling parse(). Zod exposes ._def for that. Standard Schema standardizes the validation interface but not reflection, so there's no schema-library-agnostic way to walk a schema tree and generate from it as far as I know.

Handler generation is the interesting overlap. Right now the two pair nicely (mock(schema) feeds collection.createMany()), and once you ship handler generation I'd be curious whether zodmint could be an optional generation backend for seeding collections, rather than requiring users to bring faker or write their own factories.

Happy to chat more if you want to explore any of that!

[kettanaito]

Oh I see! Thanks for elaborating.