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

package/dist/index.cjs

@@ -2003,13 +2003,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 +5284,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 +5303,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 +5312,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 +6048,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 +6110,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("."),