@ghentcdh/crouton-api 0.0.1-alpha.56 → 0.0.1-alpha.58

package/dist/index.cjs

@@ -1993,7 +1993,9 @@ var import_zod21 = require("zod");
 var isInstanceOf = /* @__PURE__ */ __name((zodSchema, className) => {
   if (!(zodSchema instanceof import_zod21.z.ZodCustom)) return false;
   const result = zodSchema.safeParse(null);
-  return !result.success && result.error.issues[0]?.expected === className;
+  if (result.success) return false;
+  const issue = result.error.issues[0];
+  return issue?.expected === className || (issue?.message?.includes(className) ?? false);
 }, "isInstanceOf");
 var jsonSchemaOverride = /* @__PURE__ */ __name(({ zodSchema, jsonSchema }) => {
   if (zodSchema instanceof import_zod21.z.ZodDate) {
@@ -2003,13 +2005,26 @@ var jsonSchemaOverride = /* @__PURE__ */ __name(({ zodSchema, jsonSchema }) => {
   if (zodSchema instanceof import_zod21.z.ZodBigInt) {
     jsonSchema.type = "integer";
   }
-  if (isInstanceOf(zodSchema, "Decimal")) {
+  if (isInstanceOf(zodSchema, "Decimal") || isInstanceOf(zodSchema, "Decimal2")) {
     jsonSchema.type = "number";
   }
   if (isInstanceOf(zodSchema, "Buffer")) {
     jsonSchema.type = "string";
   }
 }, "jsonSchemaOverride");
+var unwrap = /* @__PURE__ */ __name((schema) => {
+  let s = schema;
+  let t = s._zod?.def?.type;
+  while (t === "optional" || t === "nullable" || t === "default" || t === "readonly") {
+    s = s._zod?.def?.innerType ?? s;
+    t = s._zod?.def?.type;
+  }
+  return s;
+}, "unwrap");
+var isDecimalField = /* @__PURE__ */ __name((zodType) => {
+  const inner = unwrap(zodType);
+  return isInstanceOf(inner, "Decimal") || isInstanceOf(inner, "Decimal2");
+}, "isDecimalField");
 var jsonSchemaOpts = {
   unrepresentable: "any",
   override: jsonSchemaOverride
@@ -5271,7 +5286,7 @@ function toJsonSchema2(schema) {
   return schema;
 }
 __name(toJsonSchema2, "toJsonSchema");
-var unwrap = /* @__PURE__ */ __name((schema) => {
+var unwrap2 = /* @__PURE__ */ __name((schema) => {
   let s = schema;
   let t = s?._zod?.def?.type;
   while (t === "optional" || t === "nullable" || t === "default" || t === "readonly") {
@@ -5290,7 +5305,7 @@ function toSelectFields(schema) {
   }
   const result = {};
   for (const [key, value] of Object.entries(schema.shape)) {
-    const inner = unwrap(value);
+    const inner = unwrap2(value);
     const t = typeOf(inner);
     if (t === "object") {
       result[key] = {
@@ -5299,7 +5314,7 @@ function toSelectFields(schema) {
       continue;
     }
     if (t === "array") {
-      const element = unwrap(inner._zod.def.element);
+      const element = unwrap2(inner._zod.def.element);
       if (typeOf(element) === "object") {
         result[key] = {
           select: toSelectFields(element)
@@ -6035,16 +6050,28 @@ var ZodValidationPipe = class {
   schema;
   /** Top-level field names that accept `null` (i.e. are nullable). */
   nullableKeys;
+  /** Top-level field names whose unwrapped type is a Prisma Decimal. */
+  decimalKeys;
+  /** Prisma Decimal constructor resolved once per pipe instance; null if unavailable. */
+  decimalCtor;
   /** Whether to coerce `undefined` → `null` on nullable fields (create/upsert only). */
   coerceUndefinedToNull;
   constructor(schema, options = {}) {
     this.schema = schema;
     this.nullableKeys = Object.entries(schema.shape).filter(([, field]) => field.safeParse(null).success).map(([key]) => key);
+    let decimalCtor = null;
+    try {
+      decimalCtor = require("@prisma/client/runtime/client").Decimal;
+    } catch {
+    }
+    this.decimalCtor = decimalCtor;
+    this.decimalKeys = decimalCtor ? Object.entries(schema.shape).filter(([, field]) => isDecimalField(field)).map(([key]) => key) : [];
     this.coerceUndefinedToNull = options.coerceNullableUndefinedToNull ?? false;
   }
   transform(value) {
     const stripped = this.stripEmptyStrings(value);
-    const input = this.coerceNullable(stripped);
+    const coerced = this.coerceNullable(stripped);
+    const input = this.coerceDecimals(coerced);
     const result = this.schema.safeParse(input);
     if (!result.success) {
       throw new CroutonValidationError(this.formatErrors(result.error));
@@ -6085,6 +6112,31 @@ var ZodValidationPipe = class {
     }
     return out;
   }
+  /**
+  * Coerce `number` / `string` values on Decimal fields to `Prisma.Decimal`.
+  * `null` / `undefined` / omitted keys are left untouched (PATCH-safe).
+  * An invalid numeric string is left as-is so Zod emits a proper validation error.
+  * Known limitation: only top-level fields are coerced (nested Decimals in relations/arrays
+  * are out of scope — matches how nullableKeys works today).
+  */
+  coerceDecimals(value) {
+    if (!this.decimalCtor || this.decimalKeys.length === 0 || value == null || typeof value !== "object" || Array.isArray(value)) {
+      return value;
+    }
+    const out = {
+      ...value
+    };
+    for (const key of this.decimalKeys) {
+      const v = out[key];
+      if (v == null) continue;
+      if (typeof v !== "number" && typeof v !== "string") continue;
+      try {
+        out[key] = new this.decimalCtor(v);
+      } catch {
+      }
+    }
+    return out;
+  }
   formatErrors(error) {
     return error.issues.map((e) => ({
       field: e.path.join("."),
@@ -7866,6 +7918,7 @@ var buildResourceDiffs = /* @__PURE__ */ __name(async (models, deps) => {
 var import_node_child_process = require("child_process");
 var import_node_fs7 = require("fs");
 var import_promises7 = require("fs/promises");
+var import_node_module2 = require("module");
 var import_node_path15 = require("path");
 var run = /* @__PURE__ */ __name((cmd, args, cwd) => new Promise((resolve7) => {
   const child = (0, import_node_child_process.spawn)(cmd, args, {
@@ -7917,11 +7970,28 @@ ${stderr}`.trim()
   };
 }, "prismaDbPull");
 var prismaCaseFormat = /* @__PURE__ */ __name(async (cwd, schemaPath) => {
-  const { code, stdout, stderr } = await run("npx", [
-    "prisma-case-format",
-    "--file",
-    schemaPath
-  ], cwd);
+  let binPath;
+  try {
+    const _require2 = (0, import_node_module2.createRequire)(importMetaUrl);
+    binPath = _require2.resolve("prisma-case-format/bin/cli.js");
+  } catch {
+  }
+  const [cmd, args] = binPath ? [
+    process.execPath,
+    [
+      binPath,
+      "--file",
+      schemaPath
+    ]
+  ] : [
+    "npx",
+    [
+      "prisma-case-format",
+      "--file",
+      schemaPath
+    ]
+  ];
+  const { code, stdout, stderr } = await run(cmd, args, cwd);
   return {
     ok: code === 0,
     output: `${stdout}