gem-hunter

Generate Zod schemas from your Sequelize models. This library is inspired by drizzle-zod: you define attributes with a column builder, optionally register a Sequelize model, and get select, insert, and update Zod schemas with correct TypeScript inference.

pnpm add @xcvzmoon/sequelize-zod sequelize zod

Peer dependencies: sequelize (^6.37.7) and zod (^4.3.6).

• Column factory: Define table columns with a chainable API (integer(), string(), date(), etc.) that maps to Sequelize data types.
• defineModel: Build a Sequelize model from those attributes so one definition drives both the database schema and validation.
• Schema helpers: createSelectSchema, createInsertSchema, and createUpdateSchema produce Zod schemas from either your attribute object or from an existing Sequelize model.
• Refinements: Override or refine any field in the generated schemas (e.g. add .min(), .max(), or custom validation).

You can use the column builder and schema helpers without a database; only defineModel requires a Sequelize instance.

import {
  integer,
  string,
  boolean,
  date,
  enumType,
  defineModel,
  createSelectSchema,
  createInsertSchema,
  createUpdateSchema,
} from '@xcvzmoon/sequelize-zod';
import type { InferModelFromAttributes } from '@xcvzmoon/sequelize-zod';
import { Sequelize } from 'sequelize';
import { z } from 'zod';

const userAttributes = {
  id: integer().primaryKey().autoIncrement(),
  name: string(100).notNull(),
  active: boolean().defaultValue(true),
  role: enumType('admin', 'user', 'guest').notNull().defaultValue('user'),
  createdAt: date().defaultValue(() => new Date()),
};

type UserModel = InferModelFromAttributes<typeof userAttributes>;

const selectSchema = createSelectSchema(userAttributes);
const insertSchema = createInsertSchema(userAttributes);
const updateSchema = createUpdateSchema(userAttributes);

type UserSelect = z.infer<typeof selectSchema>;
type UserInsert = z.infer<typeof insertSchema>;
type UserUpdate = z.infer<typeof updateSchema>;

const result = insertSchema.safeParse({ name: 'Alice', role: 'user' });

const sequelize = new Sequelize({ dialect: 'sqlite', storage: ':memory:', logging: false });
const User = defineModel(sequelize, 'User', userAttributes);

const selectFromModel = createSelectSchema(User);
const insertFromModel = createInsertSchema(User);
const updateFromModel = createUpdateSchema(User);

Columns are defined with builder functions. Each returns a chainable builder with methods such as .primaryKey(), .autoIncrement(), .notNull(), .allowNull(), .defaultValue(), .unique(), .references(), etc.

range(), geometry(), geography(), hstore(), cidr(), inet(), macaddr(), citext(), tsvector(). Virtual columns: virtual(returnType, dependencies?).

Builds a Zod object schema for the full row shape (e.g. query results). All columns are included; optionality follows allowNull and hasDefault.

• input: A record of column builders (e.g. userAttributes) or a Sequelize ModelStatic.
• refinements: Optional Record<string, z.ZodType | (schema => z.ZodType)> to override or refine fields.

Builds a Zod schema for insert payloads. Auto-generated (identity) columns are omitted. Fields are optional when allowNull or hasDefault is true.

• input: Same as createSelectSchema.
• refinements: Same as above.

Builds a Zod schema for partial updates. All fields are optional; generated columns are omitted.

• input: Same as createSelectSchema.
• refinements: Same as above.

const insertSchema = createInsertSchema(userAttributes, {
  name: z.string().min(2).max(100),
  role: (schema) => schema.refine((v) => ['admin', 'user', 'guest'].includes(v as string)),
});

Registers a Sequelize model with the given name and the attribute record built with the column factory. Returns a ModelStatic whose instance type matches InferModelFromAttributes<typeof attributes>.

Use the same attributes with createSelectSchema, createInsertSchema, and createUpdateSchema so types stay in sync.

This project is inspired by drizzle-zod, which provides Zod schema generation from Drizzle ORM schemas. Sequelize Zod aims to offer a similar workflow for Sequelize: define columns once, then derive select, insert, and update schemas with full type inference.

ISC