gem-hunter

A custom prisma generator that creates Zod schemas from your Prisma model.
Explore the docs »

View Demo · Report Bug · Request Feature

1. About The Project
   • Built With
2. Getting Started
   • Prerequisites
   • Installation
3. Usage
   • JSDoc Generation
   • Extending Zod Fields
   • Importing Helpers
     • Custom Zod Schemas
   • JSON Fields
4. Examples
5. Roadmap
6. Contributing
7. License
8. Contact

This is a fork of AcadArena/zod-prisma which is a fork of CarterGrimmeisen/zod-prisma

The difference to AcadArena's fork is that enums are generated as readonly objects rather than TS enums to allow literal strings and other overlapping enum values to be compatible with the zod inferred types. TypeScript enums suck.

Also, there is now the option to specify different zod schemas for the DateTime type. This is useful if you are converting to/from JSON where JS Date objects are serialized into ISO strings.

• dts-cli
• Zod
• Based on this gist

To get a local copy up and running follow these simple steps.

This project utilizes pnpm and if you plan on contributing, you should too.

npm install -g pnpm

1. Ensure your tsconfig.json enables the compiler's strict mode. Zod requires it and so do we, you will experience TS errors without strict mode enabled

2. Add zod-prisma as a dev dependency

   #npm
   npm install -D @gabrola/zod-prisma
   #yarn
   yarn add -D @gabrola/zod-prisma
   #pnpm
   pnpm add -D @gabrola/zod-prisma

3. Add the zod-prisma generator to your schema.prisma

   generator zod {
     provider                 = "zod-prisma"
     output                   = "./zod" // (default) the directory where generated zod schemas will be saved
   
     relationModel            = true // (default) Create and export both plain and related models.
     // relationModel         = "default" // Do not export model without relations.
     // relationModel         = false // Do not generate related model
   
     modelCase                = "PascalCase" // (default) Output models using pascal case (ex. UserModel, PostModel)
     // modelCase             = "camelCase" // Output models using camel case (ex. userModel, postModel)
   
     modelSuffix              = "Model" // (default) Suffix to apply to your prisma models when naming Zod schemas
   
     // useDecimalJs          = false // (default) represent the prisma Decimal type using as a JS number
     useDecimalJs             = true // represent the prisma Decimal type using Decimal.js (as Prisma does)
   
     imports                  = null // (default) will import the referenced file in generated schemas to be used via imports.someExportedVariable
   
     // https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-by-null-values
     prismaJsonNullability    = true // (default) uses prisma's scheme for JSON field nullability
     // prismaJsonNullability = false // allows null assignment to optional JSON fields
   
     enumFile                 = "enums" // will generate enum file instead of referencing generated ones from the prisma client
   
     // date      -  z.date()
     // union     -  z.union([z.date(), z.string().datetime()])
     // transform -  z.date().transform((v) => v.toISOString()).pipe(z.string().datetime())
     dateTimeSchema           = "date" // (default) the type to use for DateTime fields
   
     // data returned from prisma queries are (type | null), however passing data to a query is nullish as they are optional
     nullableType             = "nullish" // (default) use nullish (type | null | undefined) for optional fields
     // nullableType             = "nullable" // use nullable (type | null) for optional fields 
   }

4. Run npx prisma generate, yarn prisma generate, or pnpm prisma generate to generate your zod schemas

5. Import the generated schemas form your selected output location

Rich-comments in the Prisma schema will be transformed into JSDoc for the associated fields:

Note: make sure to use a triple-slash. Double-slash comments won't be processed.

model Post {
  /// The unique identifier for the post
  /// @default {Generated by database}
  id String @id @default(uuid())

  /// A brief title that describes the contents of the post
  title String

  /// The actual contents of the post.
  contents String
}

Generated code:

export const PostModel = z.object({
  /**
   * The unique identifier for the post
   * @default {Generated by database}
   */
  id: z.string().uuid(),
  /**
   * A brief title that describes the contents of the post
   */
  title: z.string(),
  /**
   * The actual contents of the post.
   */
  contents: z.string(),
});

You can also use the @zod keyword in rich-comments in the Prisma schema to extend your Zod schema fields:

model Post {
  id String @id @default(uuid()) /// @zod.uuid()

  /// @zod.max(255, { message: "The title must be shorter than 256 characters" })
  title String

  contents String /// @zod.max(10240)
}

Generated code:

export const PostModel = z.object({
  id: z.string().uuid(),
  title: z.string().max(255, { message: 'The title must be shorter than 256 characters' }),
  contents: z.string().max(10240),
});

Sometimes its useful to define a custom Zod preprocessor or transformer for your data. zod-prisma enables you to reuse these by importing them via a config options. For example:

generator zod {
  provider      = "zod-prisma"
  output        = "./zod"
  imports 		  = "../src/zod-schemas"
}

model User {
  username	String /// @zod.refine(imports.isValidUsername)
}

The referenced file can then be used by simply referring to exported members via imports.whateverExport. The generated zod schema files will now include a namespaced import like the following.

import * as imports from '../../src/zod-schemas';

In conjunction with this import option, you may want to utilize an entirely custom zod schema for a field. This can be accomplished by using the special comment directive @zod.custom(). By specifying the custom schema within the parentheses you can replace the autogenerated type that would normally be assigned to the field.

For instance if you wanted to use z.preprocess

JSON fields in Prisma disallow null values. This is to disambiguate between setting a field's value to NULL in the database and having a value of null stored in the JSON. In accordance with this zod-prisma will default to disallowing null values, even if your JSON field is optional.

If you would like to revert this behavior and allow null assignment to JSON fields, you can set prismaJsonNullability to false in the generator options.

For examples, please refer to the Examples Directory or the Functional Tests

See the open issues for a list of proposed features (and known issues).

Contributions are what make the open source community such an amazing place to be learn, inspire, and create. Any contributions you make are greatly appreciated.

1. Fork the Project
2. Create your Feature Branch (git checkout -b feature/AmazingFeature)
3. Commit your Changes (git commit -m 'Add some AmazingFeature')
4. Push to the Branch (git push origin feature/AmazingFeature)
5. Open a Pull Request

Distributed under the MIT License. See LICENSE for more information.