zodipus 0.1.0

package/dist/index.cjs

@@ -0,0 +1,696 @@
+'use strict';
+
+var generatorHelper = require('@prisma/generator-helper');
+var fs = require('fs');
+var path = require('path');
+
+// src/index.ts
+function parseConfig(options) {
+  const config = options.generator.config;
+  const getConfigValue = (key, defaultValue) => {
+    const value = config[key];
+    if (Array.isArray(value)) return value[0] ?? defaultValue;
+    return value ?? defaultValue;
+  };
+  return {
+    dateFormat: getConfigValue("dateFormat", "coerce"),
+    passthroughEnabled: getConfigValue("passthroughEnabled", "false") === "true",
+    relationDepth: Number.parseInt(getConfigValue("relationDepth", "5")),
+    debug: getConfigValue("debug", "false") === "true",
+    zodImport: getConfigValue("zodImport", "zod"),
+    dryRun: process.env.ZODIPUS_DRY_RUN === "true"
+  };
+}
+async function generate(options) {
+  if (process.env.ZODIPUS_CMD === "inspect") {
+    await inspectSchema(options.dmmf);
+    return;
+  }
+  const outputDir = options.generator.output?.value;
+  if (!outputDir) {
+    throw new Error("No output directory specified");
+  }
+  const config = parseConfig(options);
+  const log = (...args) => {
+    if (config.debug) {
+      console.log(...args);
+    }
+  };
+  const resolvedOutputDir = path.resolve(path.dirname(options.schemaPath), outputDir);
+  log("\u{1F527} Zodipus generator");
+  log(`\u{1F4C1} Output directory: ${resolvedOutputDir}`);
+  log(
+    `\u2699\uFE0F  Config: dateFormat=${config.dateFormat}, passthroughEnabled=${config.passthroughEnabled}, relationDepth=${config.relationDepth}`
+  );
+  log("\u{1F4E6} Generating clean Zod model schemas...");
+  await generateCleanModelSchemas(options, resolvedOutputDir, log, config);
+  log("\u{1F517} Extracting relations from DMMF...");
+  log(`   Total models in schema: ${options.dmmf.datamodel.models.length}`);
+  const relations = extractRelationsFromDMMF(options.dmmf, config.relationDepth);
+  log(`   Found ${Object.keys(relations).length} models with relations`);
+  const relationsCode = formatRelationsAsTypeScript(relations, config.relationDepth);
+  const relationsPath = path.resolve(resolvedOutputDir, "generated-relations.ts");
+  if (!config.dryRun) {
+    fs.mkdirSync(path.dirname(relationsPath), { recursive: true });
+    fs.writeFileSync(relationsPath, relationsCode, "utf-8");
+  } else {
+    log(`   [DRY RUN] Would write to ${relationsPath}`);
+  }
+  log(`   \u2705 Relations written to ${relationsPath}`);
+  log("\u{1F4DD} Generating index file...");
+  const indexCode = generateIndexFile(options.dmmf);
+  const indexPath = path.resolve(resolvedOutputDir, "generated-index.ts");
+  if (!config.dryRun) {
+    fs.writeFileSync(indexPath, indexCode, "utf-8");
+  } else {
+    log(`   [DRY RUN] Would write to ${indexPath}`);
+  }
+  log("\u2705 Query Engine generation complete!");
+}
+async function generateCleanModelSchemas(options, outputDir, log, config) {
+  const models = options.dmmf.datamodel.models;
+  const enums = options.dmmf.datamodel.enums;
+  const enumNames = new Set(enums.map((e) => e.name));
+  log(`   Found ${models.length} models and ${enums.length} enums`);
+  const customSchemas = /* @__PURE__ */ new Set();
+  for (const model of models) {
+    const scalarFields = model.fields.filter((field) => field.kind !== "object");
+    for (const field of scalarFields) {
+      const customSchema = extractCustomSchema(field.documentation);
+      if (customSchema) {
+        customSchemas.add(customSchema);
+      }
+    }
+  }
+  const enumSchemas = [];
+  for (const enumDef of enums) {
+    const enumCode = generateEnumSchema(enumDef, config);
+    enumSchemas.push(enumCode);
+  }
+  const usedEnums = /* @__PURE__ */ new Set();
+  for (const model of models) {
+    const scalarFields = model.fields.filter((field) => field.kind !== "object");
+    for (const field of scalarFields) {
+      if (enumNames.has(field.type)) {
+        usedEnums.add(field.type);
+      }
+    }
+  }
+  const modelSchemas = [];
+  for (const model of models) {
+    const modelCode = generateModelSchema(model, enums, config);
+    modelSchemas.push(modelCode);
+  }
+  const enumsCode = `import { z } from '${config.zodImport}';
+
+${enumSchemas.map((s) => s.replace(/import \{ z \} from '[^']+';\n\n/g, "")).join("\n\n")}`;
+  const enumsPath = path.resolve(outputDir, "enums.ts");
+  if (!config.dryRun) {
+    fs.writeFileSync(enumsPath, enumsCode, "utf-8");
+  } else {
+    log(`   [DRY RUN] Would write to ${enumsPath}`);
+  }
+  const enumImportList = Array.from(usedEnums).sort().map((name) => `${name}Schema`).join(", ");
+  const customSchemaImportList = Array.from(customSchemas).sort().join(", ");
+  const modelImports = [`import { z } from '${config.zodImport}';`];
+  if (usedEnums.size > 0) {
+    modelImports.push(`import { ${enumImportList} } from './enums';`);
+  }
+  if (customSchemas.size > 0) {
+    modelImports.push(`import { ${customSchemaImportList} } from './custom-schemas';`);
+  }
+  const modelsCodeWithoutImports = modelSchemas.map(
+    (s) => s.replace(/import \{ z \} from '[^']+';\n/g, "").replace(/import \{ [^}]+ \} from '\.\/enums';\n/g, "").replace(/import \{ [^}]+ \} from '\.\/custom-schemas';\n/g, "").trim()
+  ).join("\n\n");
+  const modelsCode = `${modelImports.join("\n")}
+
+${modelsCodeWithoutImports}`;
+  const modelsPath = path.resolve(outputDir, "models.ts");
+  if (!config.dryRun) {
+    fs.writeFileSync(modelsPath, modelsCode, "utf-8");
+  } else {
+    log(`   [DRY RUN] Would write to ${modelsPath}`);
+  }
+  if (customSchemas.size > 0) {
+    generateCustomSchemasTemplate(outputDir, customSchemas, log, config);
+  }
+  log(`   \u2705 Generated ${enums.length} enums and ${models.length} model schemas`);
+  if (customSchemas.size > 0) {
+    log(`   \u{1F4DD} Found ${customSchemas.size} custom schema references - update custom-schemas.ts`);
+  }
+}
+function generateCustomSchemasTemplate(outputDir, customSchemas, log, config) {
+  const customSchemasPath = path.resolve(outputDir, "custom-schemas.ts");
+  if (fs.existsSync(customSchemasPath)) {
+    log("   \u26A0\uFE0F  custom-schemas.ts already exists, skipping template generation");
+    return;
+  }
+  const schemaTemplates = Array.from(customSchemas).map((schemaName) => {
+    return `/**
+ * ${schemaName} schema
+ */
+export const ${schemaName} = z.any(); // Replace with your schema`;
+  }).join("\n\n");
+  const template = `import { z } from '${config.zodImport}';
+
+/**
+ * Custom Zod schemas for JSON fields
+ * 
+ * This file contains custom schemas referenced via @zodSchema annotations
+ * in your Prisma schema. Update these with your actual schema definitions.
+ */
+
+${schemaTemplates}
+`;
+  if (!config.dryRun) {
+    fs.writeFileSync(customSchemasPath, template, "utf-8");
+    log(`   \u2728 Created custom-schemas.ts template at ${customSchemasPath}`);
+  } else {
+    log(`   [DRY RUN] Would create template at ${customSchemasPath}`);
+  }
+}
+async function inspectSchema(dmmf) {
+  const flags = process.env.ZODIPUS_INSPECT_FLAGS || "";
+  const showModels = flags.includes("models");
+  const showEnums = flags.includes("enums");
+  const showRelations = flags.includes("relations");
+  const showAll = !showModels && !showEnums && !showRelations;
+  const asJson = process.env.ZODIPUS_INSPECT_JSON === "true";
+  if (asJson) {
+    const output = {};
+    if (showAll || showModels) {
+      output.models = dmmf.datamodel.models.map((m) => ({
+        name: m.name,
+        fields: m.fields.map((f) => ({
+          name: f.name,
+          type: f.type,
+          isRequired: f.isRequired,
+          isList: f.isList,
+          isId: f.isId,
+          isUnique: f.isUnique
+        }))
+      }));
+    }
+    if (showAll || showEnums) {
+      output.enums = dmmf.datamodel.enums.map((e) => ({
+        name: e.name,
+        values: e.values.map((v) => v.name)
+      }));
+    }
+    console.log(JSON.stringify(output, null, 2));
+    return;
+  }
+  if (showAll || showModels) {
+    console.log("\u{1F4E6} Models:");
+    console.log("\u2500".repeat(50));
+    for (const model of dmmf.datamodel.models) {
+      const fieldCount = model.fields.length;
+      const scalarCount = model.fields.filter((f) => f.kind !== "object").length;
+      const relationCount = fieldCount - scalarCount;
+      console.log(`  ${model.name} (${scalarCount} fields, ${relationCount} relations)`);
+      for (const field of model.fields) {
+        const markers = [];
+        if (field.isId) markers.push("@id");
+        if (field.isUnique) markers.push("@unique");
+        if (!field.isRequired) markers.push("optional");
+        if (field.isList) markers.push("[]");
+        const markerStr = markers.length > 0 ? ` [${markers.join(", ")}]` : "";
+        const typeStr = field.kind === "object" ? `\u2192 ${field.type}` : field.type;
+        console.log(`    \u2022 ${field.name}: ${typeStr}${markerStr}`);
+      }
+      console.log();
+    }
+  }
+  if (showAll || showEnums) {
+    console.log("\n\u{1F3F7}\uFE0F  Enums:");
+    console.log("\u2500".repeat(50));
+    for (const enumDef of dmmf.datamodel.enums) {
+      const values = enumDef.values.map((v) => v.name).join(", ");
+      console.log(`  ${enumDef.name}: ${values}`);
+    }
+    console.log();
+  }
+  if (showAll || showRelations) {
+    console.log("\n\u{1F517} Relations:");
+    console.log("\u2500".repeat(50));
+    for (const model of dmmf.datamodel.models) {
+      const relations = model.fields.filter((f) => f.kind === "object");
+      if (relations.length > 0) {
+        console.log(`  ${model.name}:`);
+        for (const rel of relations) {
+          const arrow = rel.isList ? "\u2500\u252C\u25B6" : "\u2500\u2500\u25B6";
+          console.log(`    ${arrow} ${rel.type} (via ${rel.name})`);
+        }
+      }
+    }
+    console.log();
+  }
+  console.log("\u2705 Inspection complete\n");
+}
+function generateEnumSchema(enumDef, config) {
+  const values = enumDef.values.map((v) => `  '${v.name}'`).join(",\n");
+  const jsDocLines = ["/**"];
+  jsDocLines.push(` * ${enumDef.name} enum schema`);
+  if (enumDef.documentation) {
+    jsDocLines.push(` * @description ${enumDef.documentation}`);
+  }
+  jsDocLines.push(` * @values ${enumDef.values.map((v) => v.name).join(", ")}`);
+  jsDocLines.push(" */");
+  const jsDoc = jsDocLines.join("\n");
+  return `import { z } from '${config.zodImport}';
+
+${jsDoc}
+export const ${enumDef.name}Schema = z.enum([
+${values}
+]);
+
+export type ${enumDef.name} = z.infer<typeof ${enumDef.name}Schema>;`;
+}
+function generateModelSchema(model, enums, config) {
+  const enumNames = new Set(enums.map((e) => e.name));
+  const scalarFields = model.fields.filter((field) => field.kind !== "object");
+  const imports = [`import { z } from '${config.zodImport}';`];
+  const enumImports = /* @__PURE__ */ new Set();
+  const customSchemaImports = /* @__PURE__ */ new Set();
+  const fieldDefinitions = [];
+  for (const field of scalarFields) {
+    const customSchema = extractCustomSchema(field.documentation);
+    let zodType;
+    if (customSchema) {
+      zodType = customSchema;
+      customSchemaImports.add(customSchema);
+    } else {
+      zodType = mapPrismaTypeToZod(field, enumNames, config);
+      if (enumNames.has(field.type)) {
+        enumImports.add(field.type);
+      }
+    }
+    const optional = field.isRequired ? "" : ".optional()";
+    const nullable = field.isRequired ? "" : ".nullable()";
+    const array = field.isList ? ".array()" : "";
+    let fieldDef = `  ${field.name}: ${zodType}${array}${optional}${nullable}`;
+    const fieldDocLines = [];
+    if (field.documentation) {
+      const cleanDoc = field.documentation.replace(/@zodSchema\s+\w+/g, "").trim();
+      if (cleanDoc) {
+        fieldDocLines.push(cleanDoc);
+      }
+    }
+    const constraints = [];
+    if (field.isId) constraints.push("@id");
+    if (field.isUnique) constraints.push("@unique");
+    if (field.hasDefaultValue) {
+      const defaultVal = formatDefaultValue(field.default);
+      constraints.push(`@default(${defaultVal})`);
+    }
+    if (field.isUpdatedAt) constraints.push("@updatedAt");
+    if (!field.isRequired) constraints.push("optional");
+    if (constraints.length > 0) {
+      fieldDocLines.push(`Prisma: ${constraints.join(", ")}`);
+    }
+    if (fieldDocLines.length > 0) {
+      fieldDef = `  /** ${fieldDocLines.join(" | ")} */
+${fieldDef}`;
+    }
+    fieldDefinitions.push(fieldDef);
+  }
+  if (enumImports.size > 0) {
+    const enumImportList = Array.from(enumImports).map((name) => `${name}Schema`).sort().join(", ");
+    imports.push(`import { ${enumImportList} } from './enums';`);
+  }
+  if (customSchemaImports.size > 0) {
+    const customImportList = Array.from(customSchemaImports).sort().join(", ");
+    imports.push(`import { ${customImportList} } from './custom-schemas';`);
+  }
+  const schemaModifier = config.passthroughEnabled ? ".passthrough()" : "";
+  return `${imports.join("\n")}
+
+/**
+ * ${model.name} model (clean schema without relations)
+ */
+export const ${model.name}Schema = z.object({
+${fieldDefinitions.join(",\n")}
+})${schemaModifier};
+
+export type ${model.name} = z.infer<typeof ${model.name}Schema>;`;
+}
+function extractCustomSchema(documentation) {
+  if (!documentation) return null;
+  const match = documentation.match(/@zodSchema\s+(\w+)/);
+  return match ? match[1] : null;
+}
+function formatDefaultValue(value) {
+  if (typeof value === "object" && value !== null && "name" in value && "args" in value) {
+    const { name, args } = value;
+    if (name.includes("(")) return name;
+    if (Array.isArray(args) && args.length > 0) {
+      return `${name}(${args.join(", ")})`;
+    }
+    return `${name}()`;
+  }
+  if (typeof value === "object" && value !== null) {
+    return JSON.stringify(value);
+  }
+  return String(value);
+}
+function mapPrismaTypeToZod(field, enumNames, config) {
+  if (enumNames.has(field.type)) {
+    return `${field.type}Schema`;
+  }
+  switch (field.type) {
+    case "String":
+      return "z.string()";
+    case "Int":
+      return "z.number().int()";
+    case "BigInt":
+      return "z.bigint()";
+    case "Float":
+      return "z.number()";
+    case "Decimal":
+      return 'z.union([z.number(), z.string(), z.custom<{ toString(): string }>((val) => typeof val === "object" && val !== null && "toString" in val)]).transform(String)';
+    case "Boolean":
+      return "z.boolean()";
+    case "DateTime":
+      return config.dateFormat === "string" ? "z.string().datetime()" : "z.coerce.date()";
+    case "Json":
+      return "z.union([z.record(z.string(), z.unknown()), z.array(z.unknown())])";
+    case "Bytes":
+      return "z.instanceof(Buffer)";
+    default:
+      return "z.unknown()";
+  }
+}
+function extractRelationsFromDMMF(dmmf, maxDepth) {
+  const relations = {};
+  const modelMap = new Map(dmmf.datamodel.models.map((m) => [m.name, m]));
+  function extractForModel(modelName, depth, visited) {
+    if (depth > maxDepth || visited.has(modelName)) {
+      return {};
+    }
+    const model = modelMap.get(modelName);
+    if (!model) return {};
+    const newVisited = new Set(visited);
+    newVisited.add(modelName);
+    const result = {};
+    for (const field of model.fields) {
+      if (field.kind === "object") {
+        const nestedRelations = extractForModel(field.type, depth + 1, newVisited);
+        result[field.name] = {
+          type: toCamelCase(field.type),
+          isArray: field.isList,
+          ...Object.keys(nestedRelations).length > 0 && {
+            relations: nestedRelations
+          }
+        };
+      }
+    }
+    return result;
+  }
+  for (const model of dmmf.datamodel.models) {
+    const modelRelations = extractForModel(model.name, 0, /* @__PURE__ */ new Set());
+    if (Object.keys(modelRelations).length > 0) {
+      relations[toCamelCase(model.name)] = modelRelations;
+    }
+  }
+  return relations;
+}
+function formatRelationsAsTypeScript(relations, maxDepth) {
+  const formatValue = (value, indent) => {
+    const spaces = "  ".repeat(indent);
+    if (typeof value === "string") {
+      return `"${value}" as const`;
+    }
+    if (typeof value === "boolean") {
+      return String(value);
+    }
+    if (typeof value === "object" && value !== null) {
+      const entries2 = Object.entries(value);
+      if (entries2.length === 0) return "{}";
+      const formattedEntries = entries2.map(([key, val]) => {
+        const formattedVal = formatValue(val, indent + 1);
+        return `${spaces}  ${key}: ${formattedVal},`;
+      });
+      return `{
+${formattedEntries.join("\n")}
+${spaces}}`;
+    }
+    return String(value);
+  };
+  const lines = [];
+  lines.push("/**");
+  lines.push(" * Auto-generated relation metadata from Prisma schema");
+  lines.push(` * Generated on: ${(/* @__PURE__ */ new Date()).toISOString()}`);
+  lines.push(` * Max nesting depth: ${maxDepth}`);
+  lines.push(" *");
+  lines.push(" * Generated by zodipus");
+  lines.push(" * To regenerate: prisma generate");
+  lines.push(" */");
+  lines.push("");
+  lines.push("const modelRelations = {");
+  const entries = Object.entries(relations);
+  for (let i = 0; i < entries.length; i++) {
+    const [modelName, modelRelations] = entries[i];
+    const formattedRelations = formatValue(modelRelations, 1);
+    const comma = i < entries.length - 1 ? "," : "";
+    lines.push(`  ${modelName}: ${formattedRelations}${comma}`);
+  }
+  lines.push("} as const;");
+  lines.push("");
+  lines.push("export default modelRelations;");
+  lines.push("");
+  return lines.join("\n");
+}
+function generateIndexFile(dmmf) {
+  const modelNames = dmmf.datamodel.models.map((m) => m.name);
+  const enumNames = dmmf.datamodel.enums.map((e) => e.name);
+  const modelTypeExports = modelNames.map((name) => `  ${name},`).join("\n");
+  const enumTypeExports = enumNames.map((name) => `  ${name},`).join("\n");
+  return `/**
+ * Generated export from zodipus
+ *
+ * This file exports:
+ * - Clean Zod model schemas (without relations)
+ * - Enum schemas
+ * - Relation metadata
+ */
+
+// Export enum schemas
+export * from './enums';
+
+// Export model schemas
+export * as models from './models';
+
+// Export relation metadata
+export { default as modelRelations } from './generated-relations';
+
+// Re-export types for convenience
+export type {
+${modelTypeExports}
+} from './models';
+
+export type {
+${enumTypeExports}
+} from './enums';
+`;
+}
+function toCamelCase(str) {
+  return str.charAt(0).toLowerCase() + str.slice(1);
+}
+
+// src/errors.ts
+var ZodipusError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ZodipusError";
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+};
+var ZodipusValidationError = class extends ZodipusError {
+  context;
+  constructor(message, context) {
+    const contextInfo = [
+      `Model: ${context.model}`,
+      context.field ? `Field: ${context.field}` : null,
+      context.expected ? `Expected: ${context.expected}` : null,
+      context.received ? `Received: ${context.received}` : null,
+      context.path?.length ? `Path: ${context.path.join(".")}` : null
+    ].filter(Boolean).join(", ");
+    super(`${message} (${contextInfo})`);
+    this.name = "ZodipusValidationError";
+    this.context = context;
+  }
+};
+var ZodipusGeneratorError = class extends ZodipusError {
+  schemaPath;
+  modelName;
+  constructor(message, options) {
+    const contextParts = [
+      options?.schemaPath ? `Schema: ${options.schemaPath}` : null,
+      options?.modelName ? `Model: ${options.modelName}` : null
+    ].filter(Boolean);
+    const fullMessage = contextParts.length ? `${message} (${contextParts.join(", ")})` : message;
+    super(fullMessage);
+    this.name = "ZodipusGeneratorError";
+    this.schemaPath = options?.schemaPath;
+    this.modelName = options?.modelName;
+  }
+};
+
+// src/queryEngine.ts
+function createRegistry(config) {
+  return {
+    createQuery: (model) => {
+      return (query) => {
+        const createParser = (isArray) => {
+          return (data) => {
+            const parseRelations = (item) => {
+              if (typeof item !== "object" || item === null) {
+                throw new ZodipusValidationError(`Invalid data for model "${String(model)}"`, {
+                  model: String(model),
+                  expected: "object",
+                  received: item === null ? "null" : typeof item
+                });
+              }
+              let result;
+              if (hasSelect) {
+                result = item;
+              } else {
+                const modelSchema = config.models[model];
+                if (!modelSchema) {
+                  throw new ZodipusValidationError("Model schema not found", {
+                    model: String(model)
+                  });
+                }
+                const parsed = modelSchema.parse(item);
+                result = parsed;
+              }
+              for (const [key, value] of Object.entries(query)) {
+                if (key === "select") continue;
+                if (typeof item === "object" && item !== null && key in item) {
+                  const modelRelations = config.relations[model];
+                  if (!modelRelations) continue;
+                  const relationType = modelRelations[key]?.type;
+                  if (!relationType) continue;
+                  const relationHasSelectOrInclude = typeof value === "object" && value !== null && ("select" in value || "include" in value);
+                  if (Array.isArray(item[key])) {
+                    result[key] = item[key].map(
+                      (rel) => {
+                        if (relationHasSelectOrInclude) {
+                          return rel;
+                        }
+                        const relationSchema = config.models[relationType];
+                        if (!relationSchema) {
+                          throw new ZodipusValidationError("Model schema not found for relation", {
+                            model: relationType,
+                            field: key,
+                            path: [String(model), key]
+                          });
+                        }
+                        return relationSchema.parse(rel);
+                      }
+                    );
+                  } else {
+                    const relData = item[key];
+                    if (relData === null) {
+                      result[key] = null;
+                    } else if (relationHasSelectOrInclude) {
+                      result[key] = relData;
+                    } else {
+                      const relationSchema = config.models[relationType];
+                      if (!relationSchema) {
+                        throw new ZodipusValidationError("Model schema not found for relation", {
+                          model: relationType,
+                          field: key,
+                          path: [String(model), key]
+                        });
+                      }
+                      result[key] = relationSchema.parse(relData);
+                    }
+                  }
+                }
+              }
+              return result;
+            };
+            if (isArray) {
+              const arrayData = data;
+              return arrayData.map(parseRelations);
+            }
+            return parseRelations(data);
+          };
+        };
+        const relationEntries = Object.fromEntries(
+          Object.entries(query).filter(([key]) => key !== "select")
+        );
+        const hasSelect = "select" in query && query.select;
+        const hasRelations = Object.keys(relationEntries).length > 0;
+        let selectQuery;
+        let includeQuery;
+        if (hasSelect && hasRelations) {
+          selectQuery = {
+            ...query.select ?? {},
+            ...relationEntries
+          };
+          includeQuery = {};
+        } else if (hasSelect && !hasRelations) {
+          selectQuery = query.select ?? {};
+          includeQuery = {};
+        } else if (!hasSelect && hasRelations) {
+          selectQuery = {};
+          includeQuery = relationEntries;
+        } else {
+          selectQuery = {};
+          includeQuery = {};
+        }
+        return {
+          query: hasSelect ? { select: selectQuery } : { include: includeQuery },
+          parse: createParser(false),
+          safeParse: ((data) => {
+            try {
+              return { success: true, data: createParser(false)(data) };
+            } catch (error) {
+              return {
+                success: false,
+                error: error instanceof Error ? error : new Error(String(error))
+              };
+            }
+          }),
+          array: () => ({
+            parse: createParser(true),
+            safeParse: ((data) => {
+              try {
+                return { success: true, data: createParser(true)(data) };
+              } catch (error) {
+                return {
+                  success: false,
+                  error: error instanceof Error ? error : new Error(String(error))
+                };
+              }
+            })
+          })
+        };
+      };
+    }
+  };
+}
+
+// src/index.ts
+generatorHelper.generatorHandler({
+  onManifest() {
+    return {
+      prettyName: "Zodipus - Prisma Zod Schema Generator",
+      defaultOutput: "../generated"
+    };
+  },
+  async onGenerate(options) {
+    await generate(options);
+  }
+});
+
+exports.ZodipusError = ZodipusError;
+exports.ZodipusGeneratorError = ZodipusGeneratorError;
+exports.ZodipusValidationError = ZodipusValidationError;
+exports.createRegistry = createRegistry;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map