prisma-to-zod-v4 0.6.4 → 0.6.5

package/dist/index.js

@@ -213047,7 +213047,7 @@ Additional information: BADCLIENT: Bad error code, ${badCode} not found in range
 });
 
 // package.json
-var version = "0.6.4";
+var version = "0.6.5";
 
 // src/index.ts
 var import_generator_helper = require("@prisma/generator-helper");
@@ -213057,15 +213057,16 @@ var import_path2 = __toESM(require("path"));
 // 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 configBoolean = stringBoolean.transform((arg) => arg === "true");
 var configSchema = import_zod.z.object({
-  relationModel: import_zod.z.union([import_zod.z.literal("default"), configBoolean]),
+  imports: import_zod.z.string().optional(),
   modelSuffix: import_zod.z.string().default("Model"),
   modelCase: import_zod.z.enum(["PascalCase", "camelCase"]).default("PascalCase"),
-  useDecimalJs: configBoolean,
   useCoerce: configBoolean.default(false),
-  imports: import_zod.z.string().optional(),
-  prismaJsonNullability: configBoolean
+  useDecimalJs: configBoolean.default(true),
+  useStandaloneEnums: configBoolean.default(true),
+  relationModel: import_zod.z.union([import_zod.z.literal("default"), configBoolean.default(true)]),
+  prismaJsonNullability: configBoolean.default(true)
 });
 
 // src/generator.ts
@@ -213133,9 +213134,10 @@ var computeModifiers = (docString) => {
 };
 
 // src/types.ts
-var getZodConstructor = (field, getRelatedModelName = (name) => name.toString(), nativeType, useCoerce) => {
+var getZodConstructor = (field, getRelatedModelName = (name) => name.toString(), nativeType, config) => {
   var _a, _b, _c, _d;
   let zodType = "z.unknown()";
+  const useCoerce = (config == null ? void 0 : config.useCoerce) ?? false;
   const zodVar = useCoerce ? "z.coerce" : "z";
   const extraModifiers = [""];
   if (field.kind === "scalar") {
@@ -213232,7 +213234,12 @@ var getZodConstructor = (field, getRelatedModelName = (name) => name.toString(),
         break;
     }
   } else if (field.kind === "enum") {
-    zodType = `z.enum(${field.type})`;
+    if (config == null ? void 0 : config.useStandaloneEnums) {
+      const camelCase = field.type.charAt(0).toLowerCase() + field.type.slice(1);
+      zodType = `${camelCase}Schema`;
+    } else {
+      zodType = `z.enum(${field.type})`;
+    }
   } else if (field.kind === "object") {
     zodType = getRelatedModelName(field.type);
   }
@@ -213342,12 +213349,28 @@ var writeImportsForModel = (model, sourceFile, config, { schemaPath, outputPath,
   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.useStandaloneEnums) {
+      const uniqueEnumSchemas = Array.from(
+        new Set(
+          enumFields.map((f) => {
+            const camelCase = f.type.charAt(0).toLowerCase() + f.type.slice(1);
+            return `${camelCase}Schema`;
+          })
+        )
+      );
+      importList.push({
+        kind: import_ts_morph.StructureKind.ImportDeclaration,
+        moduleSpecifier: "./enums",
+        namedImports: uniqueEnumSchemas
+      });
+    } else {
+      importList.push({
+        kind: import_ts_morph.StructureKind.ImportDeclaration,
+        isTypeOnly: false,
+        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);
@@ -213417,12 +213440,7 @@ var generateSchemaForModel = (model, sourceFile, config, { schemaPath }) => {
               writeArray(writer, getJSDocs(field.documentation));
               const nativeType = modelNativeTypes.get(field.name);
               writer.write(
-                `${field.name}: ${getZodConstructor(
-                  field,
-                  void 0,
-                  nativeType,
-                  config.useCoerce
-                )}`
+                `${field.name}: ${getZodConstructor(field, void 0, nativeType, config)}`
               ).write(",").newLine();
             });
           }).write(")");
@@ -213473,7 +213491,7 @@ var generateRelatedSchemaForModel = (model, sourceFile, config, _prismaOptions)
                     field,
                     relatedModelName,
                     null,
-                    config.useCoerce
+                    config
                   )},`
                 ).newLine();
               });
@@ -213491,13 +213509,45 @@ var populateModelFile = (model, sourceFile, config, prismaOptions) => {
   if (needsRelatedModel(model, config))
     generateRelatedSchemaForModel(model, sourceFile, config, prismaOptions);
 };
-var generateBarrelFile = (models, indexFile) => {
+var generateBarrelFile = (models, indexFile, config, hasEnums) => {
+  if ((config == null ? void 0 : config.useStandaloneEnums) && hasEnums) {
+    indexFile.addExportDeclaration({
+      moduleSpecifier: "./enums"
+    });
+  }
   models.forEach((model) => {
     indexFile.addExportDeclaration({
       moduleSpecifier: `./${model.name.toLowerCase()}`
     });
   });
 };
+var generateEnumsFile = (enums, sourceFile) => {
+  sourceFile.addImportDeclaration({
+    kind: import_ts_morph.StructureKind.ImportDeclaration,
+    namespaceImport: "z",
+    moduleSpecifier: "zod"
+  });
+  enums.forEach((enumDef) => {
+    const values = enumDef.values.map((v) => v.name);
+    const enumInitializer = `z.enum([${values.map((v) => `'${v}'`).join(", ")}])`;
+    const camelCaseName = enumDef.name.charAt(0).toLowerCase() + enumDef.name.slice(1);
+    sourceFile.addVariableStatement({
+      isExported: true,
+      declarationKind: import_ts_morph.VariableDeclarationKind.Const,
+      declarations: [
+        {
+          name: `${camelCaseName}Schema`,
+          initializer: enumInitializer
+        }
+      ]
+    });
+    sourceFile.addTypeAlias({
+      isExported: true,
+      name: `${enumDef.name}Schema`,
+      type: `z.infer<typeof ${camelCaseName}Schema>`
+    });
+  });
+};
 
 // src/index.ts
 var import_ts_morph2 = require("ts-morph");
@@ -213516,6 +213566,7 @@ var import_ts_morph2 = require("ts-morph");
       }
     });
     const models = [...options.dmmf.datamodel.models];
+    const enums = [...options.dmmf.datamodel.enums];
     const schemaPath = options.schemaPath;
     const schemaDir = import_path2.default.dirname(schemaPath);
     const outputPath = options.generator.output.value;
@@ -213535,12 +213586,21 @@ var import_ts_morph2 = require("ts-morph");
       // Pass the directory, not the file
     };
     const indexFile = project.createSourceFile(`${outputPath}/index.ts`, {}, { overwrite: true });
-    generateBarrelFile(models, indexFile);
+    generateBarrelFile(models, indexFile, config, enums.length > 0);
     indexFile.formatText({
       indentSize: 2,
       convertTabsToSpaces: true,
       semicolons: import_typescript.SemicolonPreference.Remove
     });
+    if (config.useStandaloneEnums && enums.length > 0) {
+      const enumsFile = project.createSourceFile(`${outputPath}/enums.ts`, {}, { overwrite: true });
+      generateEnumsFile(enums, enumsFile);
+      enumsFile.formatText({
+        indentSize: 2,
+        convertTabsToSpaces: true,
+        semicolons: import_typescript.SemicolonPreference.Remove
+      });
+    }
     models.forEach((model) => {
       const sourceFile = project.createSourceFile(
         `${outputPath}/${model.name.toLowerCase()}.ts`,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "prisma-to-zod-v4",
-	"version": "0.6.4",
+	"version": "0.6.5",
 	"description": "A Prisma generator that creates Zod schemas for all of your models",
 	"license": "MIT",
 	"author": "yassinrais",
@@ -84,4 +84,4 @@
 	"engines": {
 		"node": ">=14"
 	}
-}
+}