xcvzmoon/sequelize-zod

README

Sequelize Zod

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.

Installation

pnpm add @xcvzmoon/sequelize-zod sequelize zod

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

Overview

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.

Quick start

1. Define attributes with the column factory

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>;

2. Create Zod schemas from attributes (no DB required)

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' });

3. Optional: define a Sequelize model and derive schemas from it

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);

Column factory

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

Numeric

Function	Sequelize type	Notes
`integer()`	INTEGER
`bigint()`	BIGINT	TypeScript: `bigint`
`float(l?, d?)`	FLOAT	Optional length/decimals
`real(l?, d?)`	REAL
`double(l?, d?)`	DOUBLE
`decimal(p?, s?)`	DECIMAL	Optional precision/scale

String and text

Function	Sequelize type	Notes
`string(n?)`	STRING	Optional length
`char(n?)`	CHAR
`text(t?)`	TEXT	`'tiny' \| 'medium' \| 'long'`

Boolean and dates

Function	Sequelize type	Notes
`boolean()`	BOOLEAN
`date(n?)`	DATE	JavaScript `Date`
`dateonly()`	DATEONLY
`time()`	TIME

UUIDs

Function	Sequelize type
`uuid()`	UUID
`uuidv1()`	UUIDV1
`uuidv4()`	UUIDV4

JSON and blob

Function	Sequelize type	Notes
`json<T>()`	JSON	Generic for shape
`jsonb<T>()`	JSONB
`blob(t?)`	BLOB	`'tiny' \| 'medium' \| 'long'`

Enum and array

Function	Sequelize type	Notes
`enumType(...vals)`	ENUM	Literal union
`array(type)`	ARRAY	Pass Sequelize `DataTypes`

PostgreSQL-specific (when using Postgres)

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

Schema helpers

createSelectSchema(input, refinements?)

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.

createInsertSchema(input, refinements?)

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.

createUpdateSchema(input, refinements?)

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

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

Refinements example

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

defineModel(sequelize, modelName, attributes)

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.

Exported types

Type	Description
`InferModelFromAttributes<T>`	Sequelize model instance type from an attribute record `T`.
`InferSelectFromAttributes<T>`	Select/row shape from attributes. Use with `z.infer<typeof createSelectSchema(attrs)>`.
`InferSelectFromModel<M>`	Select shape from a Sequelize model.
`InferInsertFromAttributes<T>`	Insert payload type from attributes.
`InferInsertFromModel<M>`	Insert payload type from a model.
`InferUpdateFromAttributes<T>`	Partial update type from attributes.
`InferUpdateFromModel<M>`	Partial update type from a model.
`ColumnSchemaDescriptor`	Internal descriptor (category, allowNull, hasDefault, isGenerated, enumValues).
`DataTypeCategory`	Category string used for Zod mapping (`'integer'`, `'string'`, etc.).

Inspiration

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.

License

ISC