prisma-guard 1.15.0 → 1.16.0

package/dist/runtime/index.js

@@ -84,10 +84,7 @@ function isJsonSafe(value) {
   return true;
 }
 var DECIMAL_REGEX = /^-?(\d+\.?\d*|\.\d+)([eE]-?\d+)?$/;
-var decimalStringSchema = z.string().refine(
-  (s) => DECIMAL_REGEX.test(s),
-  "Invalid decimal string"
-);
+var decimalStringSchema = z.string().refine((s) => DECIMAL_REGEX.test(s), "Invalid decimal string");
 var decimalObjectSchema = z.custom(
   (v) => v !== null && typeof v === "object" && typeof v.toFixed === "function" && typeof v.toNumber === "function",
   "Expected Decimal-compatible object"
@@ -113,18 +110,39 @@ function createScalarBase(strictDecimal) {
       z.string().regex(/^-?\d+$/).transform((v) => BigInt(v))
     ]),
     Boolean: () => z.boolean(),
-    DateTime: () => z.union([
-      z.date(),
-      z.string().datetime({ offset: true })
-    ]).pipe(z.coerce.date()),
-    Json: () => z.unknown().refine(isJsonSafe, "Value must be JSON-serializable (no undefined, functions, symbols, class instances, NaN, Infinity, or circular references)"),
-    Bytes: () => z.union([
-      z.string(),
-      z.custom((v) => v instanceof Uint8Array)
-    ])
+    DateTime: () => z.union([z.date(), z.string().datetime({ offset: true })]).pipe(z.coerce.date()),
+    Json: () => z.unknown().refine(
+      isJsonSafe,
+      "Value must be JSON-serializable (no undefined, functions, symbols, class instances, NaN, Infinity, or circular references)"
+    ),
+    Bytes: () => z.union([z.string(), z.custom((v) => v instanceof Uint8Array)])
   };
 }
 var SCALAR_BASE = createScalarBase(false);
+function wrapWithInputCoercion(fieldType, isList, schema) {
+  let itemCoercion = null;
+  switch (fieldType) {
+    case "String":
+      itemCoercion = z.union([z.string(), z.number().transform(String)]);
+      break;
+    case "Int":
+      itemCoercion = z.union([
+        z.number().int(),
+        z.string().regex(/^-?\d+$/).transform(Number)
+      ]);
+      break;
+    case "Float":
+      itemCoercion = z.union([
+        z.number(),
+        z.string().regex(/^-?(\d+\.?\d*|\.\d+)([eE][+-]?\d+)?$/).transform(Number)
+      ]);
+      break;
+    default:
+      return schema;
+  }
+  const coercion = isList ? z.array(itemCoercion) : itemCoercion;
+  return coercion.pipe(schema);
+}
 
 // src/runtime/schema-builder.ts
 import { z as z3 } from "zod";
@@ -173,7 +191,19 @@ function coerceToArray(value) {
 
 // src/runtime/zod-type-map.ts
 var SCALAR_OPERATORS = {
-  String: /* @__PURE__ */ new Set(["equals", "not", "contains", "startsWith", "endsWith", "in", "notIn", "gt", "gte", "lt", "lte"]),
+  String: /* @__PURE__ */ new Set([
+    "equals",
+    "not",
+    "contains",
+    "startsWith",
+    "endsWith",
+    "in",
+    "notIn",
+    "gt",
+    "gte",
+    "lt",
+    "lte"
+  ]),
   Int: /* @__PURE__ */ new Set(["equals", "not", "gt", "gte", "lt", "lte", "in", "notIn"]),
   Float: /* @__PURE__ */ new Set(["equals", "not", "gt", "gte", "lt", "lte", "in", "notIn"]),
   Decimal: /* @__PURE__ */ new Set(["equals", "not", "gt", "gte", "lt", "lte", "in", "notIn"]),
@@ -182,10 +212,23 @@ var SCALAR_OPERATORS = {
   DateTime: /* @__PURE__ */ new Set(["equals", "not", "gt", "gte", "lt", "lte", "in", "notIn"]),
   Bytes: /* @__PURE__ */ new Set([])
 };
-var SCALAR_LIST_OPERATORS = /* @__PURE__ */ new Set(["has", "hasEvery", "hasSome", "isEmpty", "equals"]);
+var SCALAR_LIST_OPERATORS = /* @__PURE__ */ new Set([
+  "has",
+  "hasEvery",
+  "hasSome",
+  "isEmpty",
+  "equals"
+]);
 var ENUM_OPERATORS = /* @__PURE__ */ new Set(["equals", "not", "in", "notIn"]);
 var NUMERIC_TYPES = /* @__PURE__ */ new Set(["Int", "Float", "Decimal", "BigInt"]);
-var COMPARABLE_TYPES = /* @__PURE__ */ new Set(["Int", "Float", "Decimal", "BigInt", "String", "DateTime"]);
+var COMPARABLE_TYPES = /* @__PURE__ */ new Set([
+  "Int",
+  "Float",
+  "Decimal",
+  "BigInt",
+  "String",
+  "DateTime"
+]);
 function getSupportedOperators(fieldMeta) {
   if (fieldMeta.isList)
     return [...SCALAR_LIST_OPERATORS];
@@ -220,7 +263,9 @@ function createBaseType(fieldMeta, enumMap, scalarBase) {
 }
 function createScalarListOperatorSchema(fieldMeta, operator, enumMap, scalarBase) {
   if (!SCALAR_LIST_OPERATORS.has(operator)) {
-    throw new ShapeError(`Operator "${operator}" not supported for scalar list fields`);
+    throw new ShapeError(
+      `Operator "${operator}" not supported for scalar list fields`
+    );
   }
   if (operator === "isEmpty") {
     return z2.boolean();
@@ -238,7 +283,12 @@ function createScalarListOperatorSchema(fieldMeta, operator, enumMap, scalarBase
 }
 function createOperatorSchema(fieldMeta, operator, enumMap, scalarBase) {
   if (fieldMeta.isList) {
-    return createScalarListOperatorSchema(fieldMeta, operator, enumMap, scalarBase);
+    return createScalarListOperatorSchema(
+      fieldMeta,
+      operator,
+      enumMap,
+      scalarBase
+    );
   }
   if (fieldMeta.isEnum) {
     const values = enumMap[fieldMeta.type];
@@ -246,7 +296,9 @@ function createOperatorSchema(fieldMeta, operator, enumMap, scalarBase) {
       throw new ShapeError(`Unknown enum: ${fieldMeta.type}`);
     }
     if (!ENUM_OPERATORS.has(operator)) {
-      throw new ShapeError(`Operator "${operator}" not supported for enum fields`);
+      throw new ShapeError(
+        `Operator "${operator}" not supported for enum fields`
+      );
     }
     const enumSchema = z2.enum(values);
     if (operator === "equals" || operator === "not") {
@@ -260,24 +312,29 @@ function createOperatorSchema(fieldMeta, operator, enumMap, scalarBase) {
     throw new ShapeError(`Unknown scalar type for operator: ${fieldMeta.type}`);
   }
   if (supportedOps.size === 0) {
-    throw new ShapeError(`Type "${fieldMeta.type}" does not support filter operators`);
+    throw new ShapeError(
+      `Type "${fieldMeta.type}" does not support filter operators`
+    );
   }
   if (!supportedOps.has(operator)) {
-    throw new ShapeError(`Operator "${operator}" not supported for type "${fieldMeta.type}"`);
+    throw new ShapeError(
+      `Operator "${operator}" not supported for type "${fieldMeta.type}"`
+    );
   }
   const factory = scalarBase[fieldMeta.type];
   if (!factory) {
     throw new ShapeError(`Unknown scalar type: ${fieldMeta.type}`);
   }
   const scalar = factory();
+  const coerced = wrapWithInputCoercion(fieldMeta.type, false, scalar);
   if (operator === "equals" || operator === "not") {
-    return !fieldMeta.isRequired ? z2.union([scalar, z2.null()]) : scalar;
+    return !fieldMeta.isRequired ? z2.union([coerced, z2.null()]) : coerced;
   }
   if (operator === "in" || operator === "notIn") {
-    const itemSchema = !fieldMeta.isRequired ? z2.union([scalar, z2.null()]) : scalar;
+    const itemSchema = !fieldMeta.isRequired ? z2.union([coerced, z2.null()]) : coerced;
     return z2.preprocess(coerceToArray, z2.array(itemSchema));
   }
-  return scalar;
+  return coerced;
 }
 
 // src/runtime/schema-builder.ts
@@ -327,6 +384,9 @@ function createSchemaBuilder(typeMap, zodChains, enumMap, scalarBase, zodDefault
         );
       }
     }
+    if (!fieldMeta.isEnum && !fieldMeta.isRelation && !fieldMeta.isUnsupported) {
+      result = wrapWithInputCoercion(fieldMeta.type, fieldMeta.isList, result);
+    }
     lruSet(chainCache, cacheKey, result, DEFAULT_MAX_CACHE);
     return result;
   }
@@ -359,9 +419,13 @@ function createSchemaBuilder(typeMap, zodChains, enumMap, scalarBase, zodDefault
         if (!modelFields[name])
           throw new ShapeError(`Unknown field "${name}" on model "${model}"`);
         if (modelFields[name].isRelation)
-          throw new ShapeError(`Field "${name}" cannot be used in input schema (relation field)`);
+          throw new ShapeError(
+            `Field "${name}" cannot be used in input schema (relation field)`
+          );
         if (modelFields[name].isUpdatedAt)
-          throw new ShapeError(`Field "${name}" cannot be used in input schema (updatedAt field)`);
+          throw new ShapeError(
+            `Field "${name}" cannot be used in input schema (updatedAt field)`
+          );
       }
       fieldNames = fieldNames.filter((n) => opts.pick.includes(n));
     } else if (opts.omit) {
@@ -435,7 +499,9 @@ function createSchemaBuilder(typeMap, zodChains, enumMap, scalarBase, zodDefault
     }
     const effectiveMaxDepth = maxDepth ?? opts.maxDepth ?? DEFAULT_MAX_DEPTH;
     if (depth > effectiveMaxDepth) {
-      throw new ShapeError(`Maximum include depth (${effectiveMaxDepth}) exceeded`);
+      throw new ShapeError(
+        `Maximum include depth (${effectiveMaxDepth}) exceeded`
+      );
     }
     const modelFields = typeMap[model];
     if (!modelFields)
@@ -446,7 +512,9 @@ function createSchemaBuilder(typeMap, zodChains, enumMap, scalarBase, zodDefault
         if (!modelFields[name])
           throw new ShapeError(`Unknown field "${name}" on model "${model}"`);
         if (modelFields[name].isRelation && !includeKeys.has(name)) {
-          throw new ShapeError(`Field "${name}" is a relation on model "${model}". Use include: { ${name}: ... } instead of pick.`);
+          throw new ShapeError(
+            `Field "${name}" is a relation on model "${model}". Use include: { ${name}: ... } instead of pick.`
+          );
         }
       }
     }
@@ -479,10 +547,14 @@ function createSchemaBuilder(typeMap, zodChains, enumMap, scalarBase, zodDefault
       if (!fieldMeta)
         throw new ShapeError(`Unknown field "${relName}" on model "${model}"`);
       if (!fieldMeta.isRelation)
-        throw new ShapeError(`Field "${relName}" is not a relation on model "${model}"`);
+        throw new ShapeError(
+          `Field "${relName}" is not a relation on model "${model}"`
+        );
       const relatedModel = fieldMeta.type;
       if (!typeMap[relatedModel]) {
-        throw new ShapeError(`Related model "${relatedModel}" not found in type map`);
+        throw new ShapeError(
+          `Related model "${relatedModel}" not found in type map`
+        );
       }
       let relSchema = buildModelSchema(
         relatedModel,
@@ -511,11 +583,17 @@ function createSchemaBuilder(typeMap, zodChains, enumMap, scalarBase, zodDefault
         const countFields = {};
         for (const relName of Object.keys(opts._count)) {
           if (!modelFields[relName])
-            throw new ShapeError(`Unknown field "${relName}" on model "${model}" in _count`);
+            throw new ShapeError(
+              `Unknown field "${relName}" on model "${model}" in _count`
+            );
           if (!modelFields[relName].isRelation)
-            throw new ShapeError(`Field "${relName}" is not a relation on model "${model}" in _count`);
+            throw new ShapeError(
+              `Field "${relName}" is not a relation on model "${model}" in _count`
+            );
           if (!modelFields[relName].isList)
-            throw new ShapeError(`Field "${relName}" is a to-one relation on model "${model}" in _count. Only to-many relations support _count.`);
+            throw new ShapeError(
+              `Field "${relName}" is a to-one relation on model "${model}" in _count. Only to-many relations support _count.`
+            );
           countFields[relName] = z3.number().int().min(0);
         }
         schemaMap["_count"] = z3.object(countFields);
@@ -527,7 +605,12 @@ function createSchemaBuilder(typeMap, zodChains, enumMap, scalarBase, zodDefault
     }
     return schema;
   }
-  return { buildFieldSchema, buildBaseFieldSchema, buildInputSchema, buildModelSchema };
+  return {
+    buildFieldSchema,
+    buildBaseFieldSchema,
+    buildInputSchema,
+    buildModelSchema
+  };
 }
 
 // src/runtime/query-builder.ts