zod4-prisma 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Carter Grimmeisen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,304 @@
+<!-- PROJECT SHIELDS -->
+<!--
+*** I'm using markdown "reference style" links for readability.
+*** Reference links are enclosed in brackets [ ] instead of parentheses ( ).
+*** See the bottom of this document for the declaration of the reference variables
+*** for contributors-url, forks-url, etc. This is an optional, concise syntax you may use.
+*** https://www.markdownguide.org/basic-syntax/#reference-style-links
+-->
+
+[![NPM][npm-shield]][npm-url]
+[![Contributors][contributors-shield]][contributors-url]
+[![Forks][forks-shield]][forks-url]
+[![Stargazers][stars-shield]][stars-url]
+[![Issues][issues-shield]][issues-url]
+[![MIT License][license-shield]][license-url]
+
+<!-- PROJECT LOGO -->
+<br />
+<p align="center">
+  <a href="https://github.com/nestifine/zod4-prisma">
+    <img src="https://raw.githubusercontent.com/nestifine/zod4-prisma/main/images/zod-prisma.svg" alt="Logo" width="120" height="120">
+  </a>
+  <h3 align="center">zod4-prisma</h3>
+  <p align="center">
+    A Prisma generator that creates Zod v4 schemas for all of your models.
+    <br />
+    <a href="https://github.com/nestifine/zod4-prisma"><strong>Explore the docs »</strong></a>
+    <br />
+    <br />
+    <a href="https://github.com/nestifine/zod4-prisma/blob/main/src/test/functional">View Demo</a>
+    ·
+    <a href="https://github.com/nestifine/zod4-prisma/issues">Report Bug</a>
+    ·
+    <a href="https://github.com/nestifine/zod4-prisma/issues">Request Feature</a>
+  </p>
+</p>
+
+<!-- TABLE OF CONTENTS -->
+<details open="open">
+  <summary><h2 style="display: inline-block">Table of Contents</h2></summary>
+  <ol>
+    <li>
+      <a href="#about-the-project">About The Project</a>
+      <ul>
+        <li><a href="#built-with">Built With</a></li>
+      </ul>
+    </li>
+    <li>
+      <a href="#getting-started">Getting Started</a>
+      <ul>
+        <li><a href="#prerequisites">Prerequisites</a></li>
+        <li><a href="#installation">Installation</a></li>
+      </ul>
+    </li>
+    <li><a href="#usage">Usage</a>
+      <ul>
+      <li><a href="#jsdoc-generation">JSDoc Generation</a></li>
+      <li><a href="#extending-zod-fields">Extending Zod Fields</a></li>
+      <li>
+        <a href="#importing-helpers">Importing Helpers</a>
+        <ul>
+        <li><a href="#custom-zod-schema">Custom Zod Schemas</a></li>
+        </ul>
+      </li>
+      <li><a href="#json-fields">JSON Fields</a></li>
+      </ul>
+    </li>
+    <li><a href="#examples">Examples</a></li>
+    <li><a href="#roadmap">Roadmap</a></li>
+    <li><a href="#contributing">Contributing</a></li>
+    <li><a href="#license">License</a></li>
+    <li><a href="#contact">Contact</a></li>
+  </ol>
+</details>
+
+<!-- ABOUT THE PROJECT -->
+
+## About The Project
+
+I got tired of having to manually create Zod schemas for my Prisma models and of updating them everytime I made schema changes.
+This provides a way of automatically generating them with your prisma
+
+<!-- [![Product Name Screen Shot][product-screenshot]](https://example.com) -->
+
+### Built With
+
+-   [tsup](https://github.com/egoist/tsup)
+-   [Zod](https://github.com/colinhacks/zod)
+-   [ts-morph](https://github.com/dsherret/ts-morph)
+-   [Based on this gist](https://gist.github.com/deckchairlabs/8a11c33311c01273deec7e739417dbc9)
+
+<!-- GETTING STARTED -->
+
+## Getting Started
+
+To get a local copy up and running follow these simple steps.
+
+### Prerequisites
+
+This project uses npm.
+
+### Installation
+
+0.  **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**
+
+1.  Add zod4-prisma as a dev dependency
+
+    ```sh
+    npm install --save-dev zod4-prisma
+    ```
+
+2.  Add the zod4-prisma generator to your schema.prisma
+
+    ```prisma
+    generator zod {
+      provider                 = "zod4-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
+    }
+    ```
+
+3.  Run `npx prisma generate` to generate your zod schemas
+4.  Import the generated schemas from your selected output location
+
+<!-- USAGE EXAMPLES -->
+
+## Usage
+
+### JSDoc Generation
+
+[Rich-comments](https://www.prisma.io/docs/concepts/components/prisma-schema#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._
+
+```prisma
+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:
+
+```ts
+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(),
+})
+```
+
+### Extending Zod Fields
+
+You can also use the `@zod` keyword in rich-comments in the Prisma schema
+to extend your Zod schema fields:
+
+```prisma
+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:
+
+```ts
+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),
+})
+```
+
+### Importing Helpers
+
+Sometimes its useful to define a custom Zod preprocessor or transformer for your data.
+zod4-prisma enables you to reuse these by importing them via a config options. For example:
+
+```prisma
+generator zod {
+  provider      = "zod4-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.
+
+```typescript
+import * as imports from '../../src/zod-schemas'
+```
+
+#### Custom Zod Schema
+
+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
+
+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 zod4-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.
+
+## Examples
+
+<!-- Use this space to show useful examples of how a project can be used. Additional screenshots, code examples and demos work well in this space. You may also link to more resources. -->
+
+_For examples, please refer to the [Examples Directory](https://github.com/nestifine/zod4-prisma/blob/main/examples) or the [Functional Tests](https://github.com/nestifine/zod4-prisma/blob/main/src/test/functional)_
+
+<!-- ROADMAP -->
+
+## Roadmap
+
+See the [open issues](https://github.com/nestifine/zod4-prisma/issues) for a list of proposed features (and known issues).
+
+<!-- CONTRIBUTING -->
+
+## Contributing
+
+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
+
+<!-- LICENSE -->
+
+## License
+
+Distributed under the MIT License. See `LICENSE` for more information.
+
+<!-- CONTACT -->
+
+## Contact
+
+Project Link: [https://github.com/nestifine/zod4-prisma](https://github.com/nestifine/zod4-prisma)
+
+<!-- MARKDOWN LINKS & IMAGES -->
+<!-- https://www.markdownguide.org/basic-syntax/#reference-style-links -->
+
+[npm-shield]: https://img.shields.io/npm/v/zod4-prisma?style=for-the-badge
+[npm-url]: https://www.npmjs.com/package/zod4-prisma
+[contributors-shield]: https://img.shields.io/github/contributors/nestifine/zod4-prisma.svg?style=for-the-badge
+[contributors-url]: https://github.com/nestifine/zod4-prisma/graphs/contributors
+[forks-shield]: https://img.shields.io/github/forks/nestifine/zod4-prisma.svg?style=for-the-badge
+[forks-url]: https://github.com/nestifine/zod4-prisma/network/members
+[stars-shield]: https://img.shields.io/github/stars/nestifine/zod4-prisma.svg?style=for-the-badge
+[stars-url]: https://github.com/nestifine/zod4-prisma/stargazers
+[issues-shield]: https://img.shields.io/github/issues/nestifine/zod4-prisma.svg?style=for-the-badge
+[issues-url]: https://github.com/nestifine/zod4-prisma/issues
+[license-shield]: https://img.shields.io/github/license/nestifine/zod4-prisma.svg?style=for-the-badge
+[license-url]: https://github.com/nestifine/zod4-prisma/blob/main/LICENSE

package/bin/cli.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+require('../dist/index')

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/index.js

@@ -0,0 +1,390 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// package.json
+var version = "1.0.0";
+
+// src/index.ts
+var import_generator_helper = require("@prisma/generator-helper");
+var import_typescript = require("typescript");
+
+// src/config.ts
+var import_zod = require("zod");
+var stringBoolean = import_zod.z.enum(["true", "false"]);
+var configBoolean = stringBoolean.default("true").transform((arg) => arg === "true");
+var configSchema = import_zod.z.object({
+  relationModel: import_zod.z.union([import_zod.z.literal("default"), configBoolean]),
+  modelSuffix: import_zod.z.string().default("Model"),
+  modelCase: import_zod.z.enum(["PascalCase", "camelCase"]).default("PascalCase"),
+  useDecimalJs: configBoolean,
+  imports: import_zod.z.string().optional(),
+  prismaJsonNullability: configBoolean
+});
+
+// src/generator.ts
+var import_path = __toESM(require("path"));
+var import_ts_morph = require("ts-morph");
+
+// src/util.ts
+var writeArray = (writer, array, newLine = true) => array.forEach((line) => {
+  writer.write(line).conditionalNewLine(newLine);
+});
+var useModelNames = ({ modelCase, modelSuffix, relationModel }) => {
+  const formatModelName = (name, prefix = "") => {
+    if (modelCase === "camelCase") {
+      name = name.slice(0, 1).toLowerCase() + name.slice(1);
+    }
+    return `${prefix}${name}${modelSuffix}`;
+  };
+  return {
+    modelName: (name) => formatModelName(name, relationModel === "default" ? "_" : ""),
+    relatedModelName: (name) => formatModelName(
+      relationModel === "default" ? name.toString() : `Related${name.toString()}`
+    )
+  };
+};
+var needsRelatedModel = (model, config) => model.fields.some((field) => field.kind === "object") && config.relationModel !== false;
+var chunk = (input, size) => {
+  return input.reduce((arr, item, idx) => {
+    return idx % size === 0 ? [...arr, [item]] : [...arr.slice(0, -1), [...arr.slice(-1)[0], item]];
+  }, []);
+};
+var dotSlash = (input) => {
+  const converted = input.replace(/^\\\\\?\\/, "").replace(/\\/g, "/").replace(/\/\/+/g, "/");
+  if (converted.includes(`/node_modules/`)) {
+    const p = converted.split(`/node_modules/`).slice(-1)[0];
+    return p.startsWith(".prisma/") ? "@prisma/client" : p;
+  }
+  if (converted.startsWith(`../`)) return converted;
+  return "./" + converted;
+};
+
+// src/docs.ts
+var import_parenthesis = require("parenthesis");
+var getJSDocs = (docString) => {
+  const lines = [];
+  if (docString) {
+    const docLines = docString.split("\n").filter((dL) => !dL.trimStart().startsWith("@zod"));
+    if (docLines.length) {
+      lines.push("/**");
+      docLines.forEach((dL) => {
+        lines.push(` * ${dL}`);
+      });
+      lines.push(" */");
+    }
+  }
+  return lines;
+};
+var getZodDocElements = (docString) => docString.split("\n").filter((line) => line.trimStart().startsWith("@zod")).map((line) => line.trimStart().slice(4)).flatMap(
+  (line) => (
+    // Array.from(line.matchAll(/\.([^().]+\(.*?\))/g), (m) => m.slice(1)).flat()
+    chunk((0, import_parenthesis.parse)(line), 2).slice(0, -1).map(
+      ([each, contents]) => each.replace(/\)?\./, "") + `${(0, import_parenthesis.stringify)(contents)})`
+    )
+  )
+);
+var computeCustomSchema = (docString) => {
+  return getZodDocElements(docString).find((modifier) => modifier.startsWith("custom("))?.slice(7).slice(0, -1);
+};
+var computeModifiers = (docString) => {
+  return getZodDocElements(docString).filter((each) => !each.startsWith("custom("));
+};
+
+// src/types.ts
+var getZodConstructor = (field, getRelatedModelName = (name) => name.toString()) => {
+  let zodType = "z.unknown()";
+  let extraModifiers = [""];
+  if (field.kind === "scalar") {
+    switch (field.type) {
+      case "String":
+        zodType = "z.string()";
+        break;
+      case "Int":
+        zodType = "z.number()";
+        extraModifiers.push("int()");
+        break;
+      case "BigInt":
+        zodType = "z.bigint()";
+        break;
+      case "DateTime":
+        zodType = "z.date()";
+        break;
+      case "Float":
+        zodType = "z.number()";
+        break;
+      case "Decimal":
+        zodType = "z.number()";
+        break;
+      case "Json":
+        zodType = "jsonSchema";
+        break;
+      case "Boolean":
+        zodType = "z.boolean()";
+        break;
+      // TODO: Proper type for bytes fields
+      case "Bytes":
+        zodType = "z.unknown()";
+        break;
+    }
+  } else if (field.kind === "enum") {
+    zodType = `z.nativeEnum(${field.type})`;
+  } else if (field.kind === "object") {
+    zodType = getRelatedModelName(field.type);
+  }
+  if (field.isList) extraModifiers.push("array()");
+  if (field.documentation) {
+    zodType = computeCustomSchema(field.documentation) ?? zodType;
+    extraModifiers.push(...computeModifiers(field.documentation));
+  }
+  if (!field.isRequired && field.type !== "Json") extraModifiers.push("nullish()");
+  return `${zodType}${extraModifiers.join(".")}`;
+};
+
+// src/generator.ts
+var writeImportsForModel = (model, sourceFile, config, { schemaPath, outputPath, clientPath }) => {
+  const { relatedModelName } = useModelNames(config);
+  const importList = [
+    {
+      kind: import_ts_morph.StructureKind.ImportDeclaration,
+      namespaceImport: "z",
+      moduleSpecifier: "zod"
+    }
+  ];
+  if (config.imports) {
+    importList.push({
+      kind: import_ts_morph.StructureKind.ImportDeclaration,
+      namespaceImport: "imports",
+      moduleSpecifier: dotSlash(
+        import_path.default.relative(outputPath, import_path.default.resolve(import_path.default.dirname(schemaPath), config.imports))
+      )
+    });
+  }
+  const hasNonCustomDecimalFieldForImports = model.fields.some(
+    (f) => f.type === "Decimal" && (!f.documentation || !computeCustomSchema(f.documentation))
+  );
+  if (config.useDecimalJs && hasNonCustomDecimalFieldForImports) {
+    importList.push({
+      kind: import_ts_morph.StructureKind.ImportDeclaration,
+      namedImports: ["Decimal"],
+      moduleSpecifier: "decimal.js"
+    });
+  }
+  const enumFields = model.fields.filter((f) => f.kind === "enum");
+  const relationFields = model.fields.filter((f) => f.kind === "object");
+  const relativePath = import_path.default.relative(outputPath, clientPath);
+  if (enumFields.length > 0) {
+    importList.push({
+      kind: import_ts_morph.StructureKind.ImportDeclaration,
+      isTypeOnly: enumFields.length === 0,
+      moduleSpecifier: dotSlash(relativePath),
+      namedImports: enumFields.map((f) => f.type)
+    });
+  }
+  if (config.relationModel !== false && relationFields.length > 0) {
+    const filteredFields = relationFields.filter((f) => f.type !== model.name);
+    if (filteredFields.length > 0) {
+      importList.push({
+        kind: import_ts_morph.StructureKind.ImportDeclaration,
+        moduleSpecifier: "./index",
+        namedImports: Array.from(
+          new Set(filteredFields.flatMap((f) => [`Complete${f.type}`, relatedModelName(f.type)]))
+        )
+      });
+    }
+  }
+  sourceFile.addImportDeclarations(importList);
+};
+var writeTypeSpecificSchemas = (model, sourceFile, config, _prismaOptions) => {
+  if (model.fields.some((f) => f.type === "Json")) {
+    sourceFile.addStatements((writer) => {
+      writer.newLine();
+      writeArray(writer, [
+        "// Helper schema for JSON fields",
+        `type Literal = boolean | number | string${config.prismaJsonNullability ? "" : "| null"}`,
+        "type Json = Literal | { [key: string]: Json } | Json[]",
+        `const literalSchema = z.union([z.string(), z.number(), z.boolean()${config.prismaJsonNullability ? "" : ", z.null()"}])`,
+        "const jsonSchema: z.ZodSchema<Json> = z.lazy(() => z.union([literalSchema, z.array(jsonSchema), z.record(z.string(), jsonSchema)]))"
+      ]);
+    });
+  }
+  const hasNonCustomDecimalField = model.fields.some(
+    (f) => f.type === "Decimal" && (!f.documentation || !computeCustomSchema(f.documentation))
+  );
+  if (config.useDecimalJs && hasNonCustomDecimalField) {
+    sourceFile.addStatements((writer) => {
+      writer.newLine();
+      writeArray(writer, [
+        "// Helper schema for Decimal fields",
+        "z",
+        ".instanceof(Decimal)",
+        ".or(z.string())",
+        ".or(z.number())",
+        ".refine((value) => {",
+        "  try {",
+        "    return new Decimal(value);",
+        "  } catch (error) {",
+        "    return false;",
+        "  }",
+        "})",
+        ".transform((value) => new Decimal(value));"
+      ]);
+    });
+  }
+};
+var generateSchemaForModel = (model, sourceFile, config, _prismaOptions) => {
+  const { modelName } = useModelNames(config);
+  sourceFile.addVariableStatement({
+    declarationKind: import_ts_morph.VariableDeclarationKind.Const,
+    isExported: true,
+    leadingTrivia: (writer) => writer.blankLineIfLastNot(),
+    declarations: [
+      {
+        name: modelName(model.name),
+        initializer(writer) {
+          writer.write("z.object(").inlineBlock(() => {
+            model.fields.filter((f) => f.kind !== "object").forEach((field) => {
+              writeArray(writer, getJSDocs(field.documentation));
+              writer.write(`${field.name}: ${getZodConstructor(field)}`).write(",").newLine();
+            });
+          }).write(")");
+        }
+      }
+    ]
+  });
+};
+var generateRelatedSchemaForModel = (model, sourceFile, config, _prismaOptions) => {
+  const { modelName, relatedModelName } = useModelNames(config);
+  const relationFields = model.fields.filter((f) => f.kind === "object");
+  sourceFile.addInterface({
+    name: `Complete${model.name}`,
+    isExported: true,
+    extends: [`z.infer<typeof ${modelName(model.name)}>`],
+    properties: relationFields.map((f) => ({
+      hasQuestionToken: !f.isRequired,
+      name: f.name,
+      type: `Complete${f.type}${f.isList ? "[]" : ""}${!f.isRequired ? " | null" : ""}`
+    }))
+  });
+  sourceFile.addStatements(
+    (writer) => writeArray(writer, [
+      "",
+      "/**",
+      ` * ${relatedModelName(
+        model.name
+      )} contains all relations on your model in addition to the scalars`,
+      " *",
+      " * NOTE: Lazy required in case of potential circular dependencies within schema",
+      " */"
+    ])
+  );
+  sourceFile.addVariableStatement({
+    declarationKind: import_ts_morph.VariableDeclarationKind.Const,
+    isExported: true,
+    declarations: [
+      {
+        name: relatedModelName(model.name),
+        type: `z.ZodSchema<Complete${model.name}>`,
+        initializer(writer) {
+          writer.write(`z.lazy(() => ${modelName(model.name)}.extend(`).inlineBlock(() => {
+            relationFields.forEach((field) => {
+              writeArray(writer, getJSDocs(field.documentation));
+              writer.write(`${field.name}: ${getZodConstructor(field, relatedModelName)}`).write(",").newLine();
+            });
+          }).write("))");
+        }
+      }
+    ]
+  });
+};
+var populateModelFile = (model, sourceFile, config, prismaOptions) => {
+  writeImportsForModel(model, sourceFile, config, prismaOptions);
+  writeTypeSpecificSchemas(model, sourceFile, config, prismaOptions);
+  generateSchemaForModel(model, sourceFile, config, prismaOptions);
+  if (needsRelatedModel(model, config))
+    generateRelatedSchemaForModel(model, sourceFile, config, prismaOptions);
+};
+var generateBarrelFile = (models, indexFile) => {
+  models.forEach((model) => {
+    indexFile.addExportDeclaration({
+      moduleSpecifier: `./${model.name.toLowerCase()}`
+    });
+  });
+};
+
+// src/index.ts
+var import_ts_morph2 = require("ts-morph");
+(0, import_generator_helper.generatorHandler)({
+  onManifest() {
+    return {
+      version,
+      prettyName: "Zod Schemas",
+      defaultOutput: "zod"
+    };
+  },
+  onGenerate(options) {
+    const project = new import_ts_morph2.Project();
+    const models = options.dmmf.datamodel.models;
+    const { schemaPath } = options;
+    const outputPath = options.generator.output.value;
+    const clientPath = options.otherGenerators.find(
+      (each) => each.provider.value === "prisma-client" || each.provider.value === "prisma-client-js"
+    ).output.value;
+    const results = configSchema.safeParse(options.generator.config);
+    if (!results.success)
+      throw new Error(
+        "Incorrect config provided. Please check the values you provided and try again."
+      );
+    const config = results.data;
+    const prismaOptions = {
+      clientPath,
+      outputPath,
+      schemaPath
+    };
+    const indexFile = project.createSourceFile(
+      `${outputPath}/index.ts`,
+      {},
+      { overwrite: true }
+    );
+    generateBarrelFile(models, indexFile);
+    indexFile.formatText({
+      indentSize: 2,
+      convertTabsToSpaces: true,
+      semicolons: import_typescript.SemicolonPreference.Remove
+    });
+    models.forEach((model) => {
+      const sourceFile = project.createSourceFile(
+        `${outputPath}/${model.name.toLowerCase()}.ts`,
+        {},
+        { overwrite: true }
+      );
+      populateModelFile(model, sourceFile, config, prismaOptions);
+      sourceFile.formatText({
+        indentSize: 2,
+        convertTabsToSpaces: true,
+        semicolons: import_typescript.SemicolonPreference.Remove
+      });
+    });
+    return project.save();
+  }
+});

package/package.json

@@ -0,0 +1,110 @@
+{
+  "name": "zod4-prisma",
+  "version": "1.0.0",
+  "description": "A Prisma generator that creates Zod schemas for all of your models",
+  "license": "MIT",
+  "author": "Carter Grimmeisen",
+  "homepage": "https://github.com/nestifine/zod4-prisma#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nestifine/zod4-prisma.git"
+  },
+  "bugs": {
+    "url": "https://github.com/nestifine/zod4-prisma/issues"
+  },
+  "main": "dist/index.js",
+  "typings": "dist/index.d.ts",
+  "bin": "bin/cli.js",
+  "keywords": [
+    "zod",
+    "prisma",
+    "generator"
+  ],
+  "files": [
+    "bin",
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs --dts --clean --out-dir dist --target node18 --external @prisma/generator-helper --external ts-morph --external parenthesis --external typescript",
+    "lint": "tsc --noEmit",
+    "prepublishOnly": "tsup src/index.ts --format cjs --dts --clean --out-dir dist --target node18 --external @prisma/generator-helper --external ts-morph --external parenthesis --external typescript",
+    "test": "npx jest --forceExit",
+    "prepare": "test -d .git && lefthook install || true"
+  },
+  "prettier": {
+    "printWidth": 100,
+    "semi": false,
+    "singleQuote": true,
+    "tabWidth": 4,
+    "trailingComma": "es5",
+    "useTabs": true
+  },
+  "eslintConfig": {
+    "rules": {
+      "react-hooks/rules-of-hooks": "off"
+    }
+  },
+  "jest": {
+    "testEnvironment": "node",
+    "transform": {
+      "^.+\\.tsx?$": [
+        "ts-jest",
+        {
+          "tsconfig": "tsconfig.json"
+        }
+      ]
+    },
+    "testRegex": "(/__tests__/.*|(\\.|/)(test|spec))\\.(jsx?|tsx?)$",
+    "moduleFileExtensions": [
+      "ts",
+      "tsx",
+      "js",
+      "jsx",
+      "json",
+      "node"
+    ]
+  },
+  "dependencies": {
+    "@prisma/generator-helper": "^7.6.0",
+    "parenthesis": "^3.1.8",
+    "ts-morph": "^27.0.2"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.4.10",
+    "@prisma/client": "^7.6.0",
+    "@prisma/internals": "^7.6.0",
+    "@tsconfig/recommended": "^1.0.1",
+    "@types/fs-extra": "^11.0.4",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^25.5.2",
+    "decimal.js": "^10.6.0",
+    "fast-glob": "^3.3.3",
+    "fs-extra": "^11.3.4",
+    "jest-mock-extended": "^4.0.0",
+    "lefthook": "^2.1.4",
+    "prisma": "^7.6.0",
+    "resolve-from": "^5.0.0",
+    "ts-jest": "^29.4.9",
+    "tslib": "^2.8.1",
+    "tsup": "^8.5.1",
+    "typescript": "^5.6.3",
+    "zod": "^4.3.6"
+  },
+  "peerDependencies": {
+    "decimal.js": "^10.0.0",
+    "prisma": "^7.0.0",
+    "typescript": ">=4.5.0",
+    "zod": "^4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "decimal.js": {
+      "optional": true
+    },
+    "typescript": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}