@stryke/prisma-trpc-generator 0.10.6 → 0.11.0

package/dist/index.js

@@ -2485,20 +2485,20 @@ var exists = /* @__PURE__ */ __name(async (filePath) => {
 
 // ../fs/src/helpers.ts
 import { mkdir, readFile, rm } from "node:fs/promises";
-async function createDirectory(path5) {
-  if (await exists(path5)) {
+async function createDirectory(path6) {
+  if (await exists(path6)) {
     return;
   }
-  return mkdir(path5, {
+  return mkdir(path6, {
     recursive: true
   });
 }
 __name(createDirectory, "createDirectory");
-async function removeDirectory(path5) {
-  if (!existsSync(path5)) {
+async function removeDirectory(path6) {
+  if (!existsSync(path6)) {
     return;
   }
-  return rm(path5, {
+  return rm(path6, {
     recursive: true
   });
 }
@@ -2520,65 +2520,65 @@ var _DRIVE_LETTER_RE = /^[A-Z]:$/i;
 var isAbsolute = /* @__PURE__ */ __name(function(p) {
   return _IS_ABSOLUTE_RE.test(p);
 }, "isAbsolute");
-var correctPaths = /* @__PURE__ */ __name(function(path5) {
-  if (!path5 || path5.length === 0) {
+var correctPaths = /* @__PURE__ */ __name(function(path6) {
+  if (!path6 || path6.length === 0) {
     return ".";
   }
-  path5 = normalizeWindowsPath(path5);
-  const isUNCPath = path5.match(_UNC_REGEX);
-  const isPathAbsolute = isAbsolute(path5);
-  const trailingSeparator = path5[path5.length - 1] === "/";
-  path5 = normalizeString(path5, !isPathAbsolute);
-  if (path5.length === 0) {
+  path6 = normalizeWindowsPath(path6);
+  const isUNCPath = path6.match(_UNC_REGEX);
+  const isPathAbsolute = isAbsolute(path6);
+  const trailingSeparator = path6[path6.length - 1] === "/";
+  path6 = normalizeString(path6, !isPathAbsolute);
+  if (path6.length === 0) {
     if (isPathAbsolute) {
       return "/";
     }
     return trailingSeparator ? "./" : ".";
   }
   if (trailingSeparator) {
-    path5 += "/";
+    path6 += "/";
   }
-  if (_DRIVE_LETTER_RE.test(path5)) {
-    path5 += "/";
+  if (_DRIVE_LETTER_RE.test(path6)) {
+    path6 += "/";
   }
   if (isUNCPath) {
     if (!isPathAbsolute) {
-      return `//./${path5}`;
+      return `//./${path6}`;
     }
-    return `//${path5}`;
+    return `//${path6}`;
   }
-  return isPathAbsolute && !isAbsolute(path5) ? `/${path5}` : path5;
+  return isPathAbsolute && !isAbsolute(path6) ? `/${path6}` : path6;
 }, "correctPaths");
 var joinPaths = /* @__PURE__ */ __name(function(...segments) {
-  let path5 = "";
+  let path6 = "";
   for (const seg of segments) {
     if (!seg) {
       continue;
     }
-    if (path5.length > 0) {
-      const pathTrailing = path5[path5.length - 1] === "/";
+    if (path6.length > 0) {
+      const pathTrailing = path6[path6.length - 1] === "/";
       const segLeading = seg[0] === "/";
       const both = pathTrailing && segLeading;
       if (both) {
-        path5 += seg.slice(1);
+        path6 += seg.slice(1);
       } else {
-        path5 += pathTrailing || segLeading ? seg : `/${seg}`;
+        path6 += pathTrailing || segLeading ? seg : `/${seg}`;
       }
     } else {
-      path5 += seg;
+      path6 += seg;
     }
   }
-  return correctPaths(path5);
+  return correctPaths(path6);
 }, "joinPaths");
-function normalizeString(path5, allowAboveRoot) {
+function normalizeString(path6, allowAboveRoot) {
   let res = "";
   let lastSegmentLength = 0;
   let lastSlash = -1;
   let dots = 0;
   let char = null;
-  for (let index = 0; index <= path5.length; ++index) {
-    if (index < path5.length) {
-      char = path5[index];
+  for (let index = 0; index <= path6.length; ++index) {
+    if (index < path6.length) {
+      char = path6[index];
     } else if (char === "/") {
       break;
     } else {
@@ -2614,9 +2614,9 @@ function normalizeString(path5, allowAboveRoot) {
         }
       } else {
         if (res.length > 0) {
-          res += `/${path5.slice(lastSlash + 1, index)}`;
+          res += `/${path6.slice(lastSlash + 1, index)}`;
         } else {
-          res = path5.slice(lastSlash + 1, index);
+          res = path6.slice(lastSlash + 1, index);
         }
         lastSegmentLength = index - lastSlash - 1;
       }
@@ -2640,7 +2640,7 @@ var lowerCaseFirst = /* @__PURE__ */ __name((input) => {
 
 // src/prisma-generator.ts
 var import_pluralize = __toESM(require_pluralize(), 1);
-import path4 from "node:path";
+import path5 from "node:path";
 
 // src/config.ts
 init_esm_shims();
@@ -3007,8 +3007,8 @@ function getErrorMap() {
 }
 __name(getErrorMap, "getErrorMap");
 var makeIssue = /* @__PURE__ */ __name((params) => {
-  const { data, path: path5, errorMaps, issueData } = params;
-  const fullPath = [...path5, ...issueData.path || []];
+  const { data, path: path6, errorMaps, issueData } = params;
+  const fullPath = [...path6, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -3142,11 +3142,11 @@ var ParseInputLazyPath = class {
   static {
     __name(this, "ParseInputLazyPath");
   }
-  constructor(parent, value, path5, key) {
+  constructor(parent, value, path6, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path5;
+    this._path = path6;
     this._key = key;
   }
   get path() {
@@ -6878,7 +6878,6 @@ var modelActionEnum = z.nativeEnum(ModelAction);
 var configBoolean = z.string().trim().transform((value) => !value || value.toLowerCase() === "false" || value.toLowerCase() === "n" || value.toLowerCase() === "no" || value === "0" ? false : value.toLowerCase() === "true" || value.toLowerCase() === "y" || value.toLowerCase() === "yes" || value === "1" ? true : value);
 var configSchema = z.object({
   debug: configBoolean.default("false"),
-  withZod: configBoolean.default("true"),
   withNext: configBoolean.default("true"),
   withMiddleware: configBoolean.default("false"),
   withShield: configBoolean.default("false"),
@@ -6887,7 +6886,18 @@ var configSchema = z.object({
   showModelNameInProcedure: configBoolean.default("false"),
   generateModelActions: z.string().default(Object.values(ModelAction).join(",")).transform((arg) => {
     return arg.split(",").map((action) => modelActionEnum.parse(action.trim()));
-  })
+  }),
+  // Zod configuration
+  withZod: configBoolean.default("true"),
+  relationModel: configBoolean.default("true").or(z.literal("default")),
+  modelSuffix: z.string().default("Model"),
+  modelCase: z.enum([
+    "PascalCase",
+    "camelCase"
+  ]).default("PascalCase"),
+  useDecimalJs: configBoolean.default("false"),
+  imports: z.string().optional(),
+  prismaJsonNullability: configBoolean.default("true")
 });
 
 // src/helpers.ts
@@ -6907,20 +6917,20 @@ init_esm_shims();
 // ../path/src/is-file.ts
 init_esm_shims();
 import { lstatSync, statSync } from "node:fs";
-function isFile(path5, additionalPath) {
-  return Boolean(statSync(additionalPath ? joinPaths(additionalPath, path5) : path5, {
+function isFile(path6, additionalPath) {
+  return Boolean(statSync(additionalPath ? joinPaths(additionalPath, path6) : path6, {
     throwIfNoEntry: false
   })?.isFile());
 }
 __name(isFile, "isFile");
-function isDirectory(path5, additionalPath) {
-  return Boolean(statSync(additionalPath ? joinPaths(additionalPath, path5) : path5, {
+function isDirectory(path6, additionalPath) {
+  return Boolean(statSync(additionalPath ? joinPaths(additionalPath, path6) : path6, {
     throwIfNoEntry: false
   })?.isDirectory());
 }
 __name(isDirectory, "isDirectory");
-function isAbsolutePath(path5) {
-  return !/^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Z]:[/\\]/i.test(path5);
+function isAbsolutePath(path6) {
+  return !/^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Z]:[/\\]/i.test(path6);
 }
 __name(isAbsolutePath, "isAbsolutePath");
 
@@ -6935,45 +6945,45 @@ function normalizeWindowsPath2(input = "") {
 __name(normalizeWindowsPath2, "normalizeWindowsPath");
 var _UNC_REGEX2 = /^[/\\]{2}/;
 var _DRIVE_LETTER_RE2 = /^[A-Z]:$/i;
-function correctPath(path5) {
-  if (!path5 || path5.length === 0) {
+function correctPath(path6) {
+  if (!path6 || path6.length === 0) {
     return ".";
   }
-  path5 = normalizeWindowsPath2(path5);
-  const isUNCPath = path5.match(_UNC_REGEX2);
-  const isPathAbsolute = isAbsolutePath(path5);
-  const trailingSeparator = path5[path5.length - 1] === "/";
-  path5 = normalizeString2(path5, !isPathAbsolute);
-  if (path5.length === 0) {
+  path6 = normalizeWindowsPath2(path6);
+  const isUNCPath = path6.match(_UNC_REGEX2);
+  const isPathAbsolute = isAbsolutePath(path6);
+  const trailingSeparator = path6[path6.length - 1] === "/";
+  path6 = normalizeString2(path6, !isPathAbsolute);
+  if (path6.length === 0) {
     if (isPathAbsolute) {
       return "/";
     }
     return trailingSeparator ? "./" : ".";
   }
   if (trailingSeparator) {
-    path5 += "/";
+    path6 += "/";
   }
-  if (_DRIVE_LETTER_RE2.test(path5)) {
-    path5 += "/";
+  if (_DRIVE_LETTER_RE2.test(path6)) {
+    path6 += "/";
   }
   if (isUNCPath) {
     if (!isPathAbsolute) {
-      return `//./${path5}`;
+      return `//./${path6}`;
     }
-    return `//${path5}`;
+    return `//${path6}`;
   }
-  return isPathAbsolute && !isAbsolutePath(path5) ? `/${path5}` : path5;
+  return isPathAbsolute && !isAbsolutePath(path6) ? `/${path6}` : path6;
 }
 __name(correctPath, "correctPath");
-function normalizeString2(path5, allowAboveRoot) {
+function normalizeString2(path6, allowAboveRoot) {
   let res = "";
   let lastSegmentLength = 0;
   let lastSlash = -1;
   let dots = 0;
   let char = null;
-  for (let index = 0; index <= path5.length; ++index) {
-    if (index < path5.length) {
-      char = path5[index];
+  for (let index = 0; index <= path6.length; ++index) {
+    if (index < path6.length) {
+      char = path6[index];
     } else if (char === "/") {
       break;
     } else {
@@ -7009,9 +7019,9 @@ function normalizeString2(path5, allowAboveRoot) {
         }
       } else {
         if (res.length > 0) {
-          res += `/${path5.slice(lastSlash + 1, index)}`;
+          res += `/${path6.slice(lastSlash + 1, index)}`;
         } else {
-          res = path5.slice(lastSlash + 1, index);
+          res = path6.slice(lastSlash + 1, index);
         }
         lastSegmentLength = index - lastSlash - 1;
       }
@@ -7083,34 +7093,34 @@ __name2(normalizeWindowsPath3, "normalizeWindowsPath");
 var _UNC_REGEX3 = /^[/\\]{2}/;
 var _IS_ABSOLUTE_RE2 = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
 var _DRIVE_LETTER_RE3 = /^[A-Za-z]:$/;
-var correctPaths2 = /* @__PURE__ */ __name2(function(path5) {
-  if (!path5 || path5.length === 0) {
+var correctPaths2 = /* @__PURE__ */ __name2(function(path6) {
+  if (!path6 || path6.length === 0) {
     return ".";
   }
-  path5 = normalizeWindowsPath3(path5);
-  const isUNCPath = path5.match(_UNC_REGEX3);
-  const isPathAbsolute = isAbsolute2(path5);
-  const trailingSeparator = path5[path5.length - 1] === "/";
-  path5 = normalizeString3(path5, !isPathAbsolute);
-  if (path5.length === 0) {
+  path6 = normalizeWindowsPath3(path6);
+  const isUNCPath = path6.match(_UNC_REGEX3);
+  const isPathAbsolute = isAbsolute2(path6);
+  const trailingSeparator = path6[path6.length - 1] === "/";
+  path6 = normalizeString3(path6, !isPathAbsolute);
+  if (path6.length === 0) {
     if (isPathAbsolute) {
       return "/";
     }
     return trailingSeparator ? "./" : ".";
   }
   if (trailingSeparator) {
-    path5 += "/";
+    path6 += "/";
   }
-  if (_DRIVE_LETTER_RE3.test(path5)) {
-    path5 += "/";
+  if (_DRIVE_LETTER_RE3.test(path6)) {
+    path6 += "/";
   }
   if (isUNCPath) {
     if (!isPathAbsolute) {
-      return `//./${path5}`;
+      return `//./${path6}`;
     }
-    return `//${path5}`;
+    return `//${path6}`;
   }
-  return isPathAbsolute && !isAbsolute2(path5) ? `/${path5}` : path5;
+  return isPathAbsolute && !isAbsolute2(path6) ? `/${path6}` : path6;
 }, "correctPaths");
 function cwd() {
   if (typeof process !== "undefined" && typeof process.cwd === "function") {
@@ -7120,15 +7130,15 @@ function cwd() {
 }
 __name(cwd, "cwd");
 __name2(cwd, "cwd");
-function normalizeString3(path5, allowAboveRoot) {
+function normalizeString3(path6, allowAboveRoot) {
   let res = "";
   let lastSegmentLength = 0;
   let lastSlash = -1;
   let dots = 0;
   let char = null;
-  for (let index = 0; index <= path5.length; ++index) {
-    if (index < path5.length) {
-      char = path5[index];
+  for (let index = 0; index <= path6.length; ++index) {
+    if (index < path6.length) {
+      char = path6[index];
     } else if (char === "/") {
       break;
     } else {
@@ -7164,9 +7174,9 @@ function normalizeString3(path5, allowAboveRoot) {
         }
       } else {
         if (res.length > 0) {
-          res += `/${path5.slice(lastSlash + 1, index)}`;
+          res += `/${path6.slice(lastSlash + 1, index)}`;
         } else {
-          res = path5.slice(lastSlash + 1, index);
+          res = path6.slice(lastSlash + 1, index);
         }
         lastSegmentLength = index - lastSlash - 1;
       }
@@ -7251,8 +7261,8 @@ __name2(findWorkspaceRoot, "findWorkspaceRoot");
 
 // ../path/src/get-parent-path.ts
 init_esm_shims();
-var resolveParentPath = /* @__PURE__ */ __name((path5) => {
-  return resolvePaths(path5, "..");
+var resolveParentPath = /* @__PURE__ */ __name((path6) => {
+  return resolvePaths(path6, "..");
 }, "resolveParentPath");
 var getParentPath = /* @__PURE__ */ __name((name, cwd2, options) => {
   const ignoreCase = options?.ignoreCase ?? true;
@@ -7357,17 +7367,17 @@ function findFilePath(filePath) {
   }), "");
 }
 __name(findFilePath, "findFilePath");
-function resolvePath(path5, cwd2 = getWorkspaceRoot()) {
-  const paths = normalizeWindowsPath2(path5).split("/");
+function resolvePath(path6, cwd2 = getWorkspaceRoot()) {
+  const paths = normalizeWindowsPath2(path6).split("/");
   let resolvedPath = "";
   let resolvedAbsolute = false;
   for (let index = paths.length - 1; index >= -1 && !resolvedAbsolute; index--) {
-    const path6 = index >= 0 ? paths[index] : cwd2;
-    if (!path6 || path6.length === 0) {
+    const path7 = index >= 0 ? paths[index] : cwd2;
+    if (!path7 || path7.length === 0) {
       continue;
     }
-    resolvedPath = joinPaths(path6, resolvedPath);
-    resolvedAbsolute = isAbsolutePath(path6);
+    resolvedPath = joinPaths(path7, resolvedPath);
+    resolvedAbsolute = isAbsolutePath(path7);
   }
   resolvedPath = normalizeString2(resolvedPath, !resolvedAbsolute);
   if (resolvedAbsolute && !isAbsolutePath(resolvedPath)) {
@@ -7377,7 +7387,7 @@ function resolvePath(path5, cwd2 = getWorkspaceRoot()) {
 }
 __name(resolvePath, "resolvePath");
 function resolvePaths(...paths) {
-  return resolvePath(joinPaths(...paths.map((path5) => normalizeWindowsPath2(path5))));
+  return resolvePath(joinPaths(...paths.map((path6) => normalizeWindowsPath2(path6))));
 }
 __name(resolvePaths, "resolvePaths");
 function relativePath(from, to) {
@@ -7403,6 +7413,22 @@ function relativePath(from, to) {
 }
 __name(relativePath, "relativePath");
 
+// src/project.ts
+init_esm_shims();
+import { ModuleKind, Project, ScriptTarget } from "ts-morph";
+var compilerOptions = {
+  target: ScriptTarget.ESNext,
+  module: ModuleKind.ESNext,
+  emitDecoratorMetadata: true,
+  experimentalDecorators: true,
+  esModuleInterop: true
+};
+var project = new Project({
+  compilerOptions: {
+    ...compilerOptions
+  }
+});
+
 // src/utils/get-prisma-internals.ts
 init_esm_shims();
 
@@ -7594,6 +7620,322 @@ async function getPrismaGeneratorHelper() {
 }
 __name(getPrismaGeneratorHelper, "getPrismaGeneratorHelper");
 
+// src/zod/model-helpers.ts
+init_esm_shims();
+import path2 from "node:path";
+import { StructureKind, VariableDeclarationKind } from "ts-morph";
+
+// src/zod/docs-helpers.ts
+init_esm_shims();
+import { parse, stringify } from "parenthesis";
+var getJSDocs = /* @__PURE__ */ __name((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;
+}, "getJSDocs");
+var getZodDocElements = /* @__PURE__ */ __name((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(parse(line), 2).slice(0, -1).map(([each, contents]) => `${each.replace(/\)?\./, "")}${stringify(contents)})`)
+)), "getZodDocElements");
+
+// src/zod/model-helpers.ts
+function checkModelHasModelRelation(model) {
+  const { fields: modelFields } = model;
+  for (const modelField of modelFields) {
+    const isRelationField = checkIsModelRelationField(modelField);
+    if (isRelationField) {
+      return true;
+    }
+  }
+  return false;
+}
+__name(checkModelHasModelRelation, "checkModelHasModelRelation");
+function checkModelHasManyModelRelation(model) {
+  const { fields: modelFields } = model;
+  for (const modelField of modelFields) {
+    const isManyRelationField = checkIsManyModelRelationField(modelField);
+    if (isManyRelationField) {
+      return true;
+    }
+  }
+  return false;
+}
+__name(checkModelHasManyModelRelation, "checkModelHasManyModelRelation");
+function checkIsModelRelationField(modelField) {
+  const { kind, relationName } = modelField;
+  return kind === "object" && !!relationName;
+}
+__name(checkIsModelRelationField, "checkIsModelRelationField");
+function checkIsManyModelRelationField(modelField) {
+  return checkIsModelRelationField(modelField) && modelField.isList;
+}
+__name(checkIsManyModelRelationField, "checkIsManyModelRelationField");
+function findModelByName(models, modelName) {
+  return models.find(({ name }) => name === modelName);
+}
+__name(findModelByName, "findModelByName");
+var writeArray = /* @__PURE__ */ __name((writer, array, newLine = true) => array.forEach((line) => writer.write(line).conditionalNewLine(newLine)), "writeArray");
+var useModelNames = /* @__PURE__ */ __name(({ modelCase, modelSuffix, relationModel }) => {
+  const formatModelName = /* @__PURE__ */ __name((name, prefix = "") => {
+    if (modelCase === "camelCase") {
+      name = name.slice(0, 1).toLowerCase() + name.slice(1);
+    }
+    return `${prefix}${name}${modelSuffix}`;
+  }, "formatModelName");
+  return {
+    modelName: /* @__PURE__ */ __name((name) => formatModelName(name, relationModel === "default" ? "_" : ""), "modelName"),
+    relatedModelName: /* @__PURE__ */ __name((name) => formatModelName(relationModel === "default" ? name.toString() : `Related${name.toString()}`), "relatedModelName")
+  };
+}, "useModelNames");
+var dotSlash = /* @__PURE__ */ __name((input) => {
+  const converted = input.replace(/^\\\\\?\\/, "").replace(/\\/g, "/").replace(/\/{2,}/g, "/");
+  if (converted.includes(`/node_modules/`)) return converted.split(`/node_modules/`).slice(-1)[0];
+  if (converted.startsWith(`../`)) return converted;
+  return `./${converted}`;
+}, "dotSlash");
+var chunk = /* @__PURE__ */ __name((input, size) => {
+  return input.reduce((arr, item, idx) => {
+    return idx % size === 0 ? [
+      ...arr,
+      [
+        item
+      ]
+    ] : [
+      ...arr.slice(0, -1),
+      [
+        ...arr.slice(-1)[0],
+        item
+      ]
+    ];
+  }, []);
+}, "chunk");
+var needsRelatedModel = /* @__PURE__ */ __name((model, config) => model.fields.some((field) => field.kind === "object") && config.relationModel !== false, "needsRelatedModel");
+var writeImportsForModel = /* @__PURE__ */ __name(async (model, sourceFile, config, options) => {
+  const internals = await getPrismaInternals();
+  const outputPath = internals.parseEnvValue(options.generator.output);
+  const { relatedModelName } = useModelNames(config);
+  const importList = [
+    {
+      kind: StructureKind.ImportDeclaration,
+      namespaceImport: "z",
+      moduleSpecifier: "zod"
+    }
+  ];
+  if (config.imports) {
+    importList.push({
+      kind: StructureKind.ImportDeclaration,
+      namespaceImport: "imports",
+      moduleSpecifier: dotSlash(path2.relative(outputPath, path2.resolve(path2.dirname(options.schemaPath), config.imports)))
+    });
+  }
+  if (config.useDecimalJs && model.fields.some((f) => f.type === "Decimal")) {
+    importList.push({
+      kind: 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 clientPath = options.otherGenerators.find((each) => each.provider.value === "prisma-client-js").output.value;
+  const relativePath2 = path2.relative(outputPath, clientPath);
+  if (enumFields.length > 0) {
+    importList.push({
+      kind: StructureKind.ImportDeclaration,
+      isTypeOnly: enumFields.length === 0,
+      moduleSpecifier: dotSlash(relativePath2),
+      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: StructureKind.ImportDeclaration,
+        moduleSpecifier: "./index",
+        namedImports: Array.from(new Set(filteredFields.flatMap((f) => [
+          `${f.type}`,
+          relatedModelName(f.type)
+        ])))
+      });
+    }
+  }
+  sourceFile.addImportDeclarations(importList);
+}, "writeImportsForModel");
+var computeCustomSchema = /* @__PURE__ */ __name((docString) => {
+  return getZodDocElements(docString).find((modifier) => modifier.startsWith("custom("))?.slice(7).slice(0, -1);
+}, "computeCustomSchema");
+var computeModifiers = /* @__PURE__ */ __name((docString) => {
+  return getZodDocElements(docString).filter((each) => !each.startsWith("custom("));
+}, "computeModifiers");
+var getZodConstructor = /* @__PURE__ */ __name((field, getRelatedModelName = (name) => name.toString()) => {
+  let zodType = "z.unknown()";
+  const 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(".")}`;
+}, "getZodConstructor");
+var writeTypeSpecificSchemas = /* @__PURE__ */ __name((model, sourceFile, config) => {
+  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(jsonSchema)]))"
+      ]);
+    });
+  }
+  if (config.useDecimalJs && model.fields.some((f) => f.type === "Decimal")) {
+    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));"
+      ]);
+    });
+  }
+}, "writeTypeSpecificSchemas");
+var generateSchemaForModel = /* @__PURE__ */ __name((model, sourceFile, config) => {
+  const { modelName } = useModelNames(config);
+  sourceFile.addVariableStatement({
+    declarationKind: VariableDeclarationKind.Const,
+    isExported: true,
+    leadingTrivia: /* @__PURE__ */ __name((writer) => writer.blankLineIfLastNot(), "leadingTrivia"),
+    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(")");
+        }
+      }
+    ]
+  });
+}, "generateSchemaForModel");
+var generateRelatedSchemaForModel = /* @__PURE__ */ __name((model, sourceFile, config) => {
+  const { modelName, relatedModelName } = useModelNames(config);
+  const relationFields = model.fields.filter((f) => f.kind === "object");
+  sourceFile.addInterface({
+    name: `${model.name}`,
+    isExported: true,
+    extends: [
+      `z.infer<typeof ${modelName(model.name)}>`
+    ],
+    properties: relationFields.map((f) => ({
+      hasQuestionToken: !f.isRequired,
+      name: f.name,
+      type: `${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: VariableDeclarationKind.Const,
+    isExported: true,
+    declarations: [
+      {
+        name: relatedModelName(model.name),
+        type: `z.ZodSchema<${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("))");
+        }
+      }
+    ]
+  });
+}, "generateRelatedSchemaForModel");
+var populateModelFile = /* @__PURE__ */ __name(async (model, sourceFile, config, options) => {
+  await writeImportsForModel(model, sourceFile, config, options);
+  writeTypeSpecificSchemas(model, sourceFile, config);
+  generateSchemaForModel(model, sourceFile, config);
+  if (needsRelatedModel(model, config)) generateRelatedSchemaForModel(model, sourceFile, config);
+}, "populateModelFile");
+var generateBarrelFile = /* @__PURE__ */ __name((models, indexFile) => {
+  models.forEach((model) => indexFile.addExportDeclaration({
+    moduleSpecifier: `./${lowerCaseFirst(model.name)}`
+  }));
+}, "generateBarrelFile");
+
 // src/helpers.ts
 var getProcedureName = /* @__PURE__ */ __name((config) => {
   return config.withShield ? "shieldedProcedure" : config.withMiddleware ? "protectedProcedure" : "publicProcedure";
@@ -8011,22 +8353,24 @@ const options: RuntimeConfigOptions<Context> = {${config.withNext ? "\n transfor
 export default options;
 `;
 }, "constructDefaultOptions");
-
-// src/project.ts
-init_esm_shims();
-import { ModuleKind, Project, ScriptTarget } from "ts-morph";
-var compilerOptions = {
-  target: ScriptTarget.ESNext,
-  module: ModuleKind.ESNext,
-  emitDecoratorMetadata: true,
-  experimentalDecorators: true,
-  esModuleInterop: true
-};
-var project = new Project({
-  compilerOptions: {
-    ...compilerOptions
-  }
-});
+var constructZodModels = /* @__PURE__ */ __name(async (models, outputPath, config, options) => {
+  const indexFile = project.createSourceFile(`${outputPath}/index.ts`, {}, {
+    overwrite: true
+  });
+  generateBarrelFile(models, indexFile);
+  indexFile.formatText({
+    indentSize: 2
+  });
+  await Promise.all(models.map(async (model) => {
+    const sourceFile = project.createSourceFile(`${outputPath}/${lowerCaseFirst(model.name)}.schema.ts`, {}, {
+      overwrite: true
+    });
+    await populateModelFile(model, sourceFile, config, options);
+    sourceFile.formatText({
+      indentSize: 2
+    });
+  }));
+}, "constructZodModels");
 
 // src/utils/write-file-safely.ts
 init_esm_shims();
@@ -8563,7 +8907,7 @@ var ParseOptions;
     allowTrailingComma: false
   };
 })(ParseOptions || (ParseOptions = {}));
-function parse(text, errors = [], options = ParseOptions.DEFAULT) {
+function parse2(text, errors = [], options = ParseOptions.DEFAULT) {
   let currentProperty = null;
   let currentParent = [];
   const previousParents = [];
@@ -8611,7 +8955,7 @@ function parse(text, errors = [], options = ParseOptions.DEFAULT) {
   visit(text, visitor, options);
   return currentParent[0];
 }
-__name(parse, "parse");
+__name(parse2, "parse");
 function visit(text, visitor, options = ParseOptions.DEFAULT) {
   const _scanner = createScanner(text, false);
   const _jsonPath = [];
@@ -8963,7 +9307,7 @@ var SyntaxKind;
   SyntaxKind2[SyntaxKind2["Unknown"] = 16] = "Unknown";
   SyntaxKind2[SyntaxKind2["EOF"] = 17] = "EOF";
 })(SyntaxKind || (SyntaxKind = {}));
-var parse2 = parse;
+var parse3 = parse2;
 var ParseErrorCode;
 (function(ParseErrorCode2) {
   ParseErrorCode2[ParseErrorCode2["InvalidSymbol"] = 1] = "InvalidSymbol";
@@ -9216,7 +9560,7 @@ var isURL = /* @__PURE__ */ __name((payload) => payload instanceof URL, "isURL")
 // ../../node_modules/.pnpm/superjson@2.2.2/node_modules/superjson/dist/pathstringifier.js
 init_esm_shims();
 var escapeKey = /* @__PURE__ */ __name((key) => key.replace(/\./g, "\\."), "escapeKey");
-var stringifyPath = /* @__PURE__ */ __name((path5) => path5.map(String).map(escapeKey).join("."), "stringifyPath");
+var stringifyPath = /* @__PURE__ */ __name((path6) => path6.map(String).map(escapeKey).join("."), "stringifyPath");
 var parsePath = /* @__PURE__ */ __name((string) => {
   const result = [];
   let segment = "";
@@ -9479,27 +9823,27 @@ var getNthKey = /* @__PURE__ */ __name((value, n) => {
   }
   return keys.next().value;
 }, "getNthKey");
-function validatePath(path5) {
-  if (includes(path5, "__proto__")) {
+function validatePath(path6) {
+  if (includes(path6, "__proto__")) {
     throw new Error("__proto__ is not allowed as a property");
   }
-  if (includes(path5, "prototype")) {
+  if (includes(path6, "prototype")) {
     throw new Error("prototype is not allowed as a property");
   }
-  if (includes(path5, "constructor")) {
+  if (includes(path6, "constructor")) {
     throw new Error("constructor is not allowed as a property");
   }
 }
 __name(validatePath, "validatePath");
-var getDeep = /* @__PURE__ */ __name((object, path5) => {
-  validatePath(path5);
-  for (let i = 0; i < path5.length; i++) {
-    const key = path5[i];
+var getDeep = /* @__PURE__ */ __name((object, path6) => {
+  validatePath(path6);
+  for (let i = 0; i < path6.length; i++) {
+    const key = path6[i];
     if (isSet(object)) {
       object = getNthKey(object, +key);
     } else if (isMap(object)) {
       const row = +key;
-      const type = +path5[++i] === 0 ? "key" : "value";
+      const type = +path6[++i] === 0 ? "key" : "value";
       const keyOfRow = getNthKey(object, row);
       switch (type) {
         case "key":
@@ -9515,14 +9859,14 @@ var getDeep = /* @__PURE__ */ __name((object, path5) => {
   }
   return object;
 }, "getDeep");
-var setDeep = /* @__PURE__ */ __name((object, path5, mapper) => {
-  validatePath(path5);
-  if (path5.length === 0) {
+var setDeep = /* @__PURE__ */ __name((object, path6, mapper) => {
+  validatePath(path6);
+  if (path6.length === 0) {
     return mapper(object);
   }
   let parent = object;
-  for (let i = 0; i < path5.length - 1; i++) {
-    const key = path5[i];
+  for (let i = 0; i < path6.length - 1; i++) {
+    const key = path6[i];
     if (isArray(parent)) {
       const index = +key;
       parent = parent[index];
@@ -9532,12 +9876,12 @@ var setDeep = /* @__PURE__ */ __name((object, path5, mapper) => {
       const row = +key;
       parent = getNthKey(parent, row);
     } else if (isMap(parent)) {
-      const isEnd = i === path5.length - 2;
+      const isEnd = i === path6.length - 2;
       if (isEnd) {
         break;
       }
       const row = +key;
-      const type = +path5[++i] === 0 ? "key" : "value";
+      const type = +path6[++i] === 0 ? "key" : "value";
       const keyOfRow = getNthKey(parent, row);
       switch (type) {
         case "key":
@@ -9549,7 +9893,7 @@ var setDeep = /* @__PURE__ */ __name((object, path5, mapper) => {
       }
     }
   }
-  const lastKey = path5[path5.length - 1];
+  const lastKey = path6[path6.length - 1];
   if (isArray(parent)) {
     parent[+lastKey] = mapper(parent[+lastKey]);
   } else if (isPlainObject2(parent)) {
@@ -9564,7 +9908,7 @@ var setDeep = /* @__PURE__ */ __name((object, path5, mapper) => {
     }
   }
   if (isMap(parent)) {
-    const row = +path5[path5.length - 2];
+    const row = +path6[path6.length - 2];
     const keyToRow = getNthKey(parent, row);
     const type = +lastKey === 0 ? "key" : "value";
     switch (type) {
@@ -9610,15 +9954,15 @@ function traverse(tree, walker2, origin = []) {
 }
 __name(traverse, "traverse");
 function applyValueAnnotations(plain, annotations, superJson) {
-  traverse(annotations, (type, path5) => {
-    plain = setDeep(plain, path5, (v) => untransformValue(v, type, superJson));
+  traverse(annotations, (type, path6) => {
+    plain = setDeep(plain, path6, (v) => untransformValue(v, type, superJson));
   });
   return plain;
 }
 __name(applyValueAnnotations, "applyValueAnnotations");
 function applyReferentialEqualityAnnotations(plain, annotations) {
-  function apply(identicalPaths, path5) {
-    const object = getDeep(plain, parsePath(path5));
+  function apply(identicalPaths, path6) {
+    const object = getDeep(plain, parsePath(path6));
     identicalPaths.map(parsePath).forEach((identicalObjectPath) => {
       plain = setDeep(plain, identicalObjectPath, () => object);
     });
@@ -9639,13 +9983,13 @@ function applyReferentialEqualityAnnotations(plain, annotations) {
 }
 __name(applyReferentialEqualityAnnotations, "applyReferentialEqualityAnnotations");
 var isDeep = /* @__PURE__ */ __name((object, superJson) => isPlainObject2(object) || isArray(object) || isMap(object) || isSet(object) || isInstanceOfRegisteredClass(object, superJson), "isDeep");
-function addIdentity(object, path5, identities) {
+function addIdentity(object, path6, identities) {
   const existingSet = identities.get(object);
   if (existingSet) {
-    existingSet.push(path5);
+    existingSet.push(path6);
   } else {
     identities.set(object, [
-      path5
+      path6
     ]);
   }
 }
@@ -9658,7 +10002,7 @@ function generateReferentialEqualityAnnotations(identitites, dedupe) {
       return;
     }
     if (!dedupe) {
-      paths = paths.map((path5) => path5.map(String)).sort((a, b) => a.length - b.length);
+      paths = paths.map((path6) => path6.map(String)).sort((a, b) => a.length - b.length);
     }
     const [representativePath, ...identicalPaths] = paths;
     if (representativePath.length === 0) {
@@ -9683,10 +10027,10 @@ function generateReferentialEqualityAnnotations(identitites, dedupe) {
   }
 }
 __name(generateReferentialEqualityAnnotations, "generateReferentialEqualityAnnotations");
-var walker = /* @__PURE__ */ __name((object, identities, superJson, dedupe, path5 = [], objectsInThisPath = [], seenObjects = /* @__PURE__ */ new Map()) => {
+var walker = /* @__PURE__ */ __name((object, identities, superJson, dedupe, path6 = [], objectsInThisPath = [], seenObjects = /* @__PURE__ */ new Map()) => {
   const primitive = isPrimitive(object);
   if (!primitive) {
-    addIdentity(object, path5, identities);
+    addIdentity(object, path6, identities);
     const seen = seenObjects.get(object);
     if (seen) {
       return dedupe ? {
@@ -9723,7 +10067,7 @@ var walker = /* @__PURE__ */ __name((object, identities, superJson, dedupe, path
       throw new Error(`Detected property ${index}. This is a prototype pollution risk, please remove it from your object.`);
     }
     const recursiveResult = walker(value, identities, superJson, dedupe, [
-      ...path5,
+      ...path6,
       index
     ], [
       ...objectsInThisPath,
@@ -9907,8 +10251,8 @@ SuperJSON.registerCustom = SuperJSON.defaultInstance.registerCustom.bind(SuperJS
 SuperJSON.allowErrorProps = SuperJSON.defaultInstance.allowErrorProps.bind(SuperJSON.defaultInstance);
 var serialize = SuperJSON.serialize;
 var deserialize = SuperJSON.deserialize;
-var stringify = SuperJSON.stringify;
-var parse3 = SuperJSON.parse;
+var stringify2 = SuperJSON.stringify;
+var parse4 = SuperJSON.parse;
 var registerClass = SuperJSON.registerClass;
 var registerCustom = SuperJSON.registerCustom;
 var registerSymbol = SuperJSON.registerSymbol;
@@ -10121,7 +10465,7 @@ var isNumber2 = /* @__PURE__ */ __name((value) => {
 }, "isNumber");
 
 // ../json/src/utils/stringify.ts
-var stringify2 = /* @__PURE__ */ __name((value, spacing = 2) => {
+var stringify3 = /* @__PURE__ */ __name((value, spacing = 2) => {
   const space = isNumber2(spacing) ? " ".repeat(spacing) : spacing;
   switch (value) {
     case null: {
@@ -10138,7 +10482,7 @@ var stringify2 = /* @__PURE__ */ __name((value, spacing = 2) => {
     }
   }
   if (Array.isArray(value)) {
-    return `[${space}${value.map((v) => stringify2(v, space)).join(`,${space}`)}${space}]`;
+    return `[${space}${value.map((v) => stringify3(v, space)).join(`,${space}`)}${space}]`;
   }
   if (value instanceof Uint8Array) {
     return value.toString();
@@ -10152,7 +10496,7 @@ var stringify2 = /* @__PURE__ */ __name((value, spacing = 2) => {
     }
     case "object": {
       const keys = Object.keys(value);
-      return `{${space}${keys.map((k) => `${k}: ${space}${stringify2(value[k], space)}`).join(`,${space}`)}${space}}`;
+      return `{${space}${keys.map((k) => `${k}: ${space}${stringify3(value[k], space)}`).join(`,${space}`)}${space}}`;
     }
     default:
       return "null";
@@ -10208,7 +10552,7 @@ var StormJSON = class _StormJSON extends SuperJSON {
     if (customTransformer) {
       result = customTransformer.serialize(result);
     }
-    return stringify2(result?.json ? result?.json : result, options?.spaces);
+    return stringify3(result?.json ? result?.json : result, options?.spaces);
   }
   /**
   * Stringify the given value with superjson
@@ -10239,7 +10583,7 @@ var StormJSON = class _StormJSON extends SuperJSON {
       allowTrailingComma: true,
       ...options
     };
-    const result = parse2(strData, errors, opts);
+    const result = parse3(strData, errors, opts);
     if (errors.length > 0 && errors[0]) {
       throw new Error(formatParseError(strData, errors[0]));
     }
@@ -10303,7 +10647,7 @@ var writeFile = /* @__PURE__ */ __name(async (filePath, content, options) => {
 }, "writeFile");
 
 // src/utils/write-file-safely.ts
-import path2 from "node:path";
+import path3 from "node:path";
 
 // src/utils/format-file.ts
 init_esm_shims();
@@ -10347,13 +10691,14 @@ var writeFileSafely = /* @__PURE__ */ __name(async (writeLocation, content, addT
 }, "writeFileSafely");
 var writeIndexFile = /* @__PURE__ */ __name(async (indexPath) => {
   const rows = Array.from(indexExports).map((filePath) => {
-    let relativePath2 = path2.relative(path2.dirname(indexPath), filePath);
+    let relativePath2 = path3.relative(path3.dirname(indexPath), filePath);
     if (relativePath2.endsWith(".ts")) {
       relativePath2 = relativePath2.slice(0, relativePath2.lastIndexOf(".ts"));
     }
     const normalized = correctPath(relativePath2);
-    return `export * from './${normalized}'`;
+    return `export * from './${normalized}';`;
   });
+  rows.push("export * from './models';");
   await writeFileSafely(indexPath, rows.join("\n"), false);
 }, "writeIndexFile");
 
@@ -10524,45 +10869,7 @@ init_esm_shims();
 
 // src/zod/transformer.ts
 init_esm_shims();
-import path3 from "node:path";
-
-// src/zod/model-helpers.ts
-init_esm_shims();
-function checkModelHasModelRelation(model) {
-  const { fields: modelFields } = model;
-  for (const modelField of modelFields) {
-    const isRelationField = checkIsModelRelationField(modelField);
-    if (isRelationField) {
-      return true;
-    }
-  }
-  return false;
-}
-__name(checkModelHasModelRelation, "checkModelHasModelRelation");
-function checkModelHasManyModelRelation(model) {
-  const { fields: modelFields } = model;
-  for (const modelField of modelFields) {
-    const isManyRelationField = checkIsManyModelRelationField(modelField);
-    if (isManyRelationField) {
-      return true;
-    }
-  }
-  return false;
-}
-__name(checkModelHasManyModelRelation, "checkModelHasManyModelRelation");
-function checkIsModelRelationField(modelField) {
-  const { kind, relationName } = modelField;
-  return kind === "object" && !!relationName;
-}
-__name(checkIsModelRelationField, "checkIsModelRelationField");
-function checkIsManyModelRelationField(modelField) {
-  return checkIsModelRelationField(modelField) && modelField.isList;
-}
-__name(checkIsManyModelRelationField, "checkIsManyModelRelationField");
-function findModelByName(models, modelName) {
-  return models.find(({ name }) => name === modelName);
-}
-__name(findModelByName, "findModelByName");
+import path4 from "node:path";
 
 // src/zod/mongodb-helpers.ts
 init_esm_shims();
@@ -10672,13 +10979,13 @@ var Transformer = class _Transformer {
     this.isCustomPrismaClientOutputPath = prismaClientCustomPath !== "@prisma/client";
   }
   static async generateIndex() {
-    const indexPath = path3.join(_Transformer.outputPath, "schemas/index.ts");
+    const indexPath = path4.join(_Transformer.outputPath, "schemas/index.ts");
     await writeIndexFile(indexPath);
   }
   async generateEnumSchemas() {
     for (const enumType2 of this.enumTypes) {
       const { name, values } = enumType2;
-      await writeFileSafely(path3.join(_Transformer.outputPath, `schemas/enums/${lowerCaseFirst(name)}.schema.ts`), `${this.generateImportZodStatement()}
+      await writeFileSafely(path4.join(_Transformer.outputPath, `schemas/enums/${lowerCaseFirst(name)}.schema.ts`), `${this.generateImportZodStatement()}
 ${this.generateExportSchemaStatement(`${lowerCaseFirst(name)}`, `z.enum(${JSON.stringify(values)})`)}`);
     }
   }
@@ -10692,7 +10999,7 @@ ${this.generateExportSchemaStatement(`${lowerCaseFirst(name)}`, `z.enum(${JSON.s
     const zodObjectSchemaFields = this.generateObjectSchemaFields();
     const objectSchema = this.prepareObjectSchema(zodObjectSchemaFields);
     const objectSchemaName = this.resolveObjectSchemaName();
-    await writeFileSafely(path3.join(_Transformer.outputPath, `schemas/objects/${lowerCaseFirst(objectSchemaName)}.schema.ts`), objectSchema);
+    await writeFileSafely(path4.join(_Transformer.outputPath, `schemas/objects/${lowerCaseFirst(objectSchemaName)}.schema.ts`), objectSchema);
   }
   generateObjectSchemaFields() {
     const zodObjectSchemaFields = this.fields.map((field) => this.generateObjectSchemaField(field)).flatMap((item) => item).map((item) => {
@@ -10827,9 +11134,9 @@ ${this.generateExportSchemaStatement(`${lowerCaseFirst(name)}`, `z.enum(${JSON.s
   generateImportPrismaStatement() {
     let prismaClientImportPath;
     if (_Transformer.isCustomPrismaClientOutputPath) {
-      const fromPath = path3.join(_Transformer.outputPath, "schemas", "objects");
+      const fromPath = path4.join(_Transformer.outputPath, "schemas", "objects");
       const toPath = _Transformer.prismaClientOutputPath;
-      const relativePathFromOutputToPrismaClient = path3.relative(fromPath, toPath).split(path3.sep).join(path3.posix.sep);
+      const relativePathFromOutputToPrismaClient = path4.relative(fromPath, toPath).split(path4.sep).join(path4.posix.sep);
       prismaClientImportPath = relativePathFromOutputToPrismaClient;
     } else {
       prismaClientImportPath = _Transformer.prismaClientOutputPath;
@@ -10959,7 +11266,7 @@ ${this.generateExportSchemaStatement(`${lowerCaseFirst(name)}`, `z.enum(${JSON.s
           includeImport,
           `import { ${modelName}WhereUniqueInputObjectSchema } from './objects/${modelName}WhereUniqueInput.schema'`
         ];
-        await writeFileSafely(path3.join(_Transformer.outputPath, `schemas/${findUnique}.schema.ts`), `${this.generateImportStatements(imports)}${this.generateExportSchemaStatement(`${modelName}FindUnique`, `z.object({ ${selectZodSchemaLine} ${includeZodSchemaLine} where: ${modelName}WhereUniqueInputObjectSchema })`)}`);
+        await writeFileSafely(path4.join(_Transformer.outputPath, `schemas/${findUnique}.schema.ts`), `${this.generateImportStatements(imports)}${this.generateExportSchemaStatement(`${modelName}FindUnique`, `z.object({ ${selectZodSchemaLine} ${includeZodSchemaLine} where: ${modelName}WhereUniqueInputObjectSchema })`)}`);
       }
       if (findFirst) {
         const imports = [
@@ -10970,7 +11277,7 @@ ${this.generateExportSchemaStatement(`${lowerCaseFirst(name)}`, `z.enum(${JSON.s
           `import { ${modelName}WhereUniqueInputObjectSchema } from './objects/${modelName}WhereUniqueInput.schema'`,
           `import { ${modelName}ScalarFieldEnumSchema } from './enums/${modelName}ScalarFieldEnum.schema'`
         ];
-        await writeFileSafely(path3.join(_Transformer.outputPath, `schemas/${findFirst}.schema.ts`), `${this.generateImportStatements(imports)}${this.generateExportSchemaStatement(`${modelName}FindFirst`, `z.object({ ${selectZodSchemaLine} ${includeZodSchemaLine} ${orderByZodSchemaLine} where: ${modelName}WhereInputObjectSchema.optional(), cursor: ${modelName}WhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), distinct: z.array(${modelName}ScalarFieldEnumSchema).optional() })`)}`);
+        await writeFileSafely(path4.join(_Transformer.outputPath, `schemas/${findFirst}.schema.ts`), `${this.generateImportStatements(imports)}${this.generateExportSchemaStatement(`${modelName}FindFirst`, `z.object({ ${selectZodSchemaLine} ${includeZodSchemaLine} ${orderByZodSchemaLine} where: ${modelName}WhereInputObjectSchema.optional(), cursor: ${modelName}WhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), distinct: z.array(${modelName}ScalarFieldEnumSchema).optional() })`)}`);
       }
       if (findMany) {
         const imports = [
@@ -10981,7 +11288,7 @@ ${this.generateExportSchemaStatement(`${lowerCaseFirst(name)}`, `z.enum(${JSON.s
           `import { ${modelName}WhereUniqueInputObjectSchema } from './objects/${modelName}WhereUniqueInput.schema'`,
           `import { ${modelName}ScalarFieldEnumSchema } from './enums/${modelName}ScalarFieldEnum.schema'`
         ];
-        await writeFileSafely(path3.join(_Transformer.outputPath, `schemas/${findMany}.schema.ts`), `${this.generateImportStatements(imports)}${this.generateExportSchemaStatement(`${modelName}FindMany`, `z.object({ ${selectZodSchemaLineLazy} ${includeZodSchemaLineLazy} ${orderByZodSchemaLine} where: ${modelName}WhereInputObjectSchema.optional(), cursor: ${modelName}WhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), distinct: z.array(${modelName}ScalarFieldEnumSchema).optional()  })`)}`);
+        await writeFileSafely(path4.join(_Transformer.outputPath, `schemas/${findMany}.schema.ts`), `${this.generateImportStatements(imports)}${this.generateExportSchemaStatement(`${modelName}FindMany`, `z.object({ ${selectZodSchemaLineLazy} ${includeZodSchemaLineLazy} ${orderByZodSchemaLine} where: ${modelName}WhereInputObjectSchema.optional(), cursor: ${modelName}WhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), distinct: z.array(${modelName}ScalarFieldEnumSchema).optional()  })`)}`);
       }
       if (createOne) {
         const imports = [
@@ -10990,19 +11297,19 @@ ${this.generateExportSchemaStatement(`${lowerCaseFirst(name)}`, `z.enum(${JSON.s
           `import { ${modelName}CreateInputObjectSchema } from './objects/${modelName}CreateInput.schema'`,
           `import { ${modelName}UncheckedCreateInputObjectSchema } from './objects/${modelName}UncheckedCreateInput.schema'`
         ];
-        await writeFileSafely(path3.join(_Transformer.outputPath, `schemas/${createOne}.schema.ts`), `${this.generateImportStatements(imports)}${this.generateExportSchemaStatement(`${modelName}CreateOne`, `z.object({ ${selectZodSchemaLine} ${includeZodSchemaLine} data: z.union([${modelName}CreateInputObjectSchema, ${modelName}UncheckedCreateInputObjectSchema])  })`)}`);
+        await writeFileSafely(path4.join(_Transformer.outputPath, `schemas/${createOne}.schema.ts`), `${this.generateImportStatements(imports)}${this.generateExportSchemaStatement(`${modelName}CreateOne`, `z.object({ ${selectZodSchemaLine} ${includeZodSchemaLine} data: z.union([${modelName}CreateInputObjectSchema, ${modelName}UncheckedCreateInputObjectSchema])  })`)}`);
       }
       if (createMany) {
         const imports = [
           `import { ${modelName}CreateManyInputObjectSchema } from './objects/${modelName}CreateManyInput.schema'`
         ];
-        await writeFileSafely(path3.join(_Transformer.outputPath, `schemas/${createMany}.schema.ts`), `${this.generateImportStatements(imports)}${this.generateExportSchemaStatement(`${modelName}CreateMany`, `z.object({ data: z.union([ ${modelName}CreateManyInputObjectSchema, z.array(${modelName}CreateManyInputObjectSchema) ]), ${_Transformer.provider === "mongodb" || _Transformer.provider === "sqlserver" ? "" : "skipDuplicates: z.boolean().optional()"} })`)}`);
+        await writeFileSafely(path4.join(_Transformer.outputPath, `schemas/${createMany}.schema.ts`), `${this.generateImportStatements(imports)}${this.generateExportSchemaStatement(`${modelName}CreateMany`, `z.object({ data: z.union([ ${modelName}CreateManyInputObjectSchema, z.array(${modelName}CreateManyInputObjectSchema) ]), ${_Transformer.provider === "mongodb" || _Transformer.provider === "sqlserver" ? "" : "skipDuplicates: z.boolean().optional()"} })`)}`);
       }
       if (createManyAndReturn) {
         const imports = [
           `import { ${modelName}CreateManyAndReturnInputObjectSchema } from './objects/${modelName}CreateManyAndReturnInput.schema'`
         ];
-        await writeFileSafely(path3.join(_Transformer.outputPath, `schemas/${createManyAndReturn}.schema.ts`), `${this.generateImportStatements(imports)}${this.generateExportSchemaStatement(`${modelName}CreateManyAndReturn`, `z.object({ data: z.union([ ${modelName}CreateManyAndReturnInputObjectSchema, z.array(${modelName}CreateManyAndReturnInputObjectSchema) ]), ${_Transformer.provider === "mongodb" || _Transformer.provider === "sqlserver" ? "" : "skipDuplicates: z.boolean().optional()"} })`)}`);
+        await writeFileSafely(path4.join(_Transformer.outputPath, `schemas/${createManyAndReturn}.schema.ts`), `${this.generateImportStatements(imports)}${this.generateExportSchemaStatement(`${modelName}CreateManyAndReturn`, `z.object({ data: z.union([ ${modelName}CreateManyAndReturnInputObjectSchema, z.array(${modelName}CreateManyAndReturnInputObjectSchema) ]), ${_Transformer.provider === "mongodb" || _Transformer.provider === "sqlserver" ? "" : "skipDuplicates: z.boolean().optional()"} })`)}`);
       }
       if (deleteOne) {
         const imports = [
@@ -11010,13 +11317,13 @@ ${this.generateExportSchemaStatement(`${lowerCaseFirst(name)}`, `z.enum(${JSON.s
           includeImport,
           `import { ${modelName}WhereUniqueInputObjectSchema } from './objects/${modelName}WhereUniqueInput.schema'`
         ];
-        await writeFileSafely(path3.join(_Transformer.outputPath, `schemas/${deleteOne}.schema.ts`), `${this.generateImportStatements(imports)}${this.generateExportSchemaStatement(`${modelName}DeleteOne`, `z.object({ ${selectZodSchemaLine} ${includeZodSchemaLine} where: ${modelName}WhereUniqueInputObjectSchema  })`)}`);
+        await writeFileSafely(path4.join(_Transformer.outputPath, `schemas/${deleteOne}.schema.ts`), `${this.generateImportStatements(imports)}${this.generateExportSchemaStatement(`${modelName}DeleteOne`, `z.object({ ${selectZodSchemaLine} ${includeZodSchemaLine} where: ${modelName}WhereUniqueInputObjectSchema  })`)}`);
       }
       if (deleteMany) {
         const imports = [
           `import { ${modelName}WhereInputObjectSchema } from './objects/${modelName}WhereInput.schema'`
         ];
-        await writeFileSafely(path3.join(_Transformer.outputPath, `schemas/${deleteMany}.schema.ts`), `${this.generateImportStatements(imports)}${this.generateExportSchemaStatement(`${modelName}DeleteMany`, `z.object({ where: ${modelName}WhereInputObjectSchema.optional()  })`)}`);
+        await writeFileSafely(path4.join(_Transformer.outputPath, `schemas/${deleteMany}.schema.ts`), `${this.generateImportStatements(imports)}${this.generateExportSchemaStatement(`${modelName}DeleteMany`, `z.object({ where: ${modelName}WhereInputObjectSchema.optional()  })`)}`);
       }
       if (updateOne) {
         const imports = [
@@ -11026,20 +11333,20 @@ ${this.generateExportSchemaStatement(`${lowerCaseFirst(name)}`, `z.enum(${JSON.s
           `import { ${modelName}UncheckedUpdateInputObjectSchema } from './objects/${modelName}UncheckedUpdateInput.schema'`,
           `import { ${modelName}WhereUniqueInputObjectSchema } from './objects/${modelName}WhereUniqueInput.schema'`
         ];
-        await writeFileSafely(path3.join(_Transformer.outputPath, `schemas/${updateOne}.schema.ts`), `${this.generateImportStatements(imports)}${this.generateExportSchemaStatement(`${modelName}UpdateOne`, `z.object({ ${selectZodSchemaLine} ${includeZodSchemaLine} data: z.union([${modelName}UpdateInputObjectSchema, ${modelName}UncheckedUpdateInputObjectSchema]), where: ${modelName}WhereUniqueInputObjectSchema  })`)}`);
+        await writeFileSafely(path4.join(_Transformer.outputPath, `schemas/${updateOne}.schema.ts`), `${this.generateImportStatements(imports)}${this.generateExportSchemaStatement(`${modelName}UpdateOne`, `z.object({ ${selectZodSchemaLine} ${includeZodSchemaLine} data: z.union([${modelName}UpdateInputObjectSchema, ${modelName}UncheckedUpdateInputObjectSchema]), where: ${modelName}WhereUniqueInputObjectSchema  })`)}`);
       }
       if (updateMany) {
         const imports = [
           `import { ${modelName}UpdateManyMutationInputObjectSchema } from './objects/${modelName}UpdateManyMutationInput.schema'`,
           `import { ${modelName}WhereInputObjectSchema } from './objects/${modelName}WhereInput.schema'`
         ];
-        await writeFileSafely(path3.join(_Transformer.outputPath, `schemas/${updateMany}.schema.ts`), `${this.generateImportStatements(imports)}${this.generateExportSchemaStatement(`${modelName}UpdateMany`, `z.object({ data: ${modelName}UpdateManyMutationInputObjectSchema, where: ${modelName}WhereInputObjectSchema.optional()  })`)}`);
+        await writeFileSafely(path4.join(_Transformer.outputPath, `schemas/${updateMany}.schema.ts`), `${this.generateImportStatements(imports)}${this.generateExportSchemaStatement(`${modelName}UpdateMany`, `z.object({ data: ${modelName}UpdateManyMutationInputObjectSchema, where: ${modelName}WhereInputObjectSchema.optional()  })`)}`);
       }
       if (updateManyAndReturn) {
         const imports = [
           `import { ${modelName}UpdateManyAndReturnInputObjectSchema } from './objects/${modelName}UpdateManyAndReturnInput.schema'`
         ];
-        await writeFileSafely(path3.join(_Transformer.outputPath, `schemas/${updateManyAndReturn}.schema.ts`), `${this.generateImportStatements(imports)}${this.generateExportSchemaStatement(`${modelName}UpdateManyAndReturn`, `z.object({ data: z.union([ ${modelName}UpdateManyAndReturnInputObjectSchema, z.array(${modelName}UpdateManyAndReturnInputObjectSchema) ]), ${_Transformer.provider === "mongodb" || _Transformer.provider === "sqlserver" ? "" : "skipDuplicates: z.boolean().optional()"} })`)}`);
+        await writeFileSafely(path4.join(_Transformer.outputPath, `schemas/${updateManyAndReturn}.schema.ts`), `${this.generateImportStatements(imports)}${this.generateExportSchemaStatement(`${modelName}UpdateManyAndReturn`, `z.object({ data: z.union([ ${modelName}UpdateManyAndReturnInputObjectSchema, z.array(${modelName}UpdateManyAndReturnInputObjectSchema) ]), ${_Transformer.provider === "mongodb" || _Transformer.provider === "sqlserver" ? "" : "skipDuplicates: z.boolean().optional()"} })`)}`);
       }
       if (upsertOne) {
         const imports = [
@@ -11051,7 +11358,7 @@ ${this.generateExportSchemaStatement(`${lowerCaseFirst(name)}`, `z.enum(${JSON.s
           `import { ${modelName}UpdateInputObjectSchema } from './objects/${modelName}UpdateInput.schema'`,
           `import { ${modelName}UncheckedUpdateInputObjectSchema } from './objects/${modelName}UncheckedUpdateInput.schema'`
         ];
-        await writeFileSafely(path3.join(_Transformer.outputPath, `schemas/${upsertOne}.schema.ts`), `${this.generateImportStatements(imports)}${this.generateExportSchemaStatement(`${modelName}Upsert`, `z.object({ ${selectZodSchemaLine} ${includeZodSchemaLine} where: ${modelName}WhereUniqueInputObjectSchema, create: z.union([ ${modelName}CreateInputObjectSchema, ${modelName}UncheckedCreateInputObjectSchema ]), update: z.union([ ${modelName}UpdateInputObjectSchema, ${modelName}UncheckedUpdateInputObjectSchema ])  })`)}`);
+        await writeFileSafely(path4.join(_Transformer.outputPath, `schemas/${upsertOne}.schema.ts`), `${this.generateImportStatements(imports)}${this.generateExportSchemaStatement(`${modelName}Upsert`, `z.object({ ${selectZodSchemaLine} ${includeZodSchemaLine} where: ${modelName}WhereUniqueInputObjectSchema, create: z.union([ ${modelName}CreateInputObjectSchema, ${modelName}UncheckedCreateInputObjectSchema ]), update: z.union([ ${modelName}UpdateInputObjectSchema, ${modelName}UncheckedUpdateInputObjectSchema ])  })`)}`);
       }
       if (aggregate) {
         const imports = [
@@ -11082,7 +11389,7 @@ ${this.generateExportSchemaStatement(`${lowerCaseFirst(name)}`, `z.enum(${JSON.s
             aggregateOperations.push(`_sum: ${modelName}SumAggregateInputObjectSchema.optional()`);
           }
         }
-        await writeFileSafely(path3.join(_Transformer.outputPath, `schemas/${aggregate}.schema.ts`), `${this.generateImportStatements(imports)}${this.generateExportSchemaStatement(`${modelName}Aggregate`, `z.object({ ${orderByZodSchemaLine} where: ${modelName}WhereInputObjectSchema.optional(), cursor: ${modelName}WhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), ${aggregateOperations.join(", ")} })`)}`);
+        await writeFileSafely(path4.join(_Transformer.outputPath, `schemas/${aggregate}.schema.ts`), `${this.generateImportStatements(imports)}${this.generateExportSchemaStatement(`${modelName}Aggregate`, `z.object({ ${orderByZodSchemaLine} where: ${modelName}WhereInputObjectSchema.optional(), cursor: ${modelName}WhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), ${aggregateOperations.join(", ")} })`)}`);
       }
       if (groupBy) {
         const imports = [
@@ -11091,7 +11398,7 @@ ${this.generateExportSchemaStatement(`${lowerCaseFirst(name)}`, `z.enum(${JSON.s
           `import { ${modelName}ScalarWhereWithAggregatesInputObjectSchema } from './objects/${modelName}ScalarWhereWithAggregatesInput.schema'`,
           `import { ${modelName}ScalarFieldEnumSchema } from './enums/${modelName}ScalarFieldEnum.schema'`
         ];
-        await writeFileSafely(path3.join(_Transformer.outputPath, `schemas/${groupBy}.schema.ts`), `${this.generateImportStatements(imports)}${this.generateExportSchemaStatement(`${modelName}GroupBy`, `z.object({ where: ${modelName}WhereInputObjectSchema.optional(), orderBy: z.union([${modelName}OrderByWithAggregationInputObjectSchema, ${modelName}OrderByWithAggregationInputObjectSchema.array()]).optional(), having: ${modelName}ScalarWhereWithAggregatesInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), by: z.array(${modelName}ScalarFieldEnumSchema)  })`)}`);
+        await writeFileSafely(path4.join(_Transformer.outputPath, `schemas/${groupBy}.schema.ts`), `${this.generateImportStatements(imports)}${this.generateExportSchemaStatement(`${modelName}GroupBy`, `z.object({ where: ${modelName}WhereInputObjectSchema.optional(), orderBy: z.union([${modelName}OrderByWithAggregationInputObjectSchema, ${modelName}OrderByWithAggregationInputObjectSchema.array()]).optional(), having: ${modelName}ScalarWhereWithAggregatesInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), by: z.array(${modelName}ScalarFieldEnumSchema)  })`)}`);
       }
     }
   }
@@ -11572,6 +11879,7 @@ ${JSON.stringify(config)}`);
     if (prismaClientProvider?.isCustomOutput) {
       Transformer.setPrismaClientOutputPath(prismaClientProvider.output?.value);
     }
+    await constructZodModels(models, joinPaths(zodOutputPath, "models"), config, options);
     resolveZodModelsComments(models, modelOperations, enumTypes, hiddenModels, hiddenFields);
     await generateZodEnumSchemas(enumTypes.prisma, enumTypes.model);
     const dataSource = options.datasources?.[0];
@@ -11648,12 +11956,12 @@ ${JSON.stringify(config)}`);
   }
   resolveModelsComments(models, hiddenModels);
   consoleLog("Generating tRPC export file");
-  const trpcExports = project.createSourceFile(path4.resolve(outputDir, "trpc.ts"), void 0, {
+  const trpcExports = project.createSourceFile(path5.resolve(outputDir, "trpc.ts"), void 0, {
     overwrite: true
   });
   await generateTRPCExports(trpcExports, config, options, outputDir);
   consoleLog("Generating tRPC app router");
-  const appRouter = project.createSourceFile(path4.resolve(outputDir, "routers", `index.ts`), void 0, {
+  const appRouter = project.createSourceFile(path5.resolve(outputDir, "routers", `index.ts`), void 0, {
     overwrite: true
   });
   consoleLog("Generating tRPC router imports");
@@ -11682,7 +11990,7 @@ ${JSON.stringify(config)}`);
     const plural = (0, import_pluralize.default)(lowerCaseFirst(model));
     consoleLog(`Generating tRPC router for model ${model}`);
     generateRouterImport(appRouter, plural, model);
-    const modelRouter = project.createSourceFile(path4.resolve(outputDir, "routers", `${lowerCaseFirst(model)}.router.ts`), void 0, {
+    const modelRouter = project.createSourceFile(path5.resolve(outputDir, "routers", `${lowerCaseFirst(model)}.router.ts`), void 0, {
       overwrite: true
     });
     generateCreateRouterImport({