prisma-guard 1.15.0 → 1.17.0

package/dist/runtime/index.cjs

@@ -115,10 +115,7 @@ function isJsonSafe(value) {
   return true;
 }
 var DECIMAL_REGEX = /^-?(\d+\.?\d*|\.\d+)([eE]-?\d+)?$/;
-var decimalStringSchema = import_zod.z.string().refine(
-  (s) => DECIMAL_REGEX.test(s),
-  "Invalid decimal string"
-);
+var decimalStringSchema = import_zod.z.string().refine((s) => DECIMAL_REGEX.test(s), "Invalid decimal string");
 var decimalObjectSchema = import_zod.z.custom(
   (v) => v !== null && typeof v === "object" && typeof v.toFixed === "function" && typeof v.toNumber === "function",
   "Expected Decimal-compatible object"
@@ -144,18 +141,39 @@ function createScalarBase(strictDecimal) {
       import_zod.z.string().regex(/^-?\d+$/).transform((v) => BigInt(v))
     ]),
     Boolean: () => import_zod.z.boolean(),
-    DateTime: () => import_zod.z.union([
-      import_zod.z.date(),
-      import_zod.z.string().datetime({ offset: true })
-    ]).pipe(import_zod.z.coerce.date()),
-    Json: () => import_zod.z.unknown().refine(isJsonSafe, "Value must be JSON-serializable (no undefined, functions, symbols, class instances, NaN, Infinity, or circular references)"),
-    Bytes: () => import_zod.z.union([
-      import_zod.z.string(),
-      import_zod.z.custom((v) => v instanceof Uint8Array)
-    ])
+    DateTime: () => import_zod.z.union([import_zod.z.date(), import_zod.z.string().datetime({ offset: true })]).pipe(import_zod.z.coerce.date()),
+    Json: () => import_zod.z.unknown().refine(
+      isJsonSafe,
+      "Value must be JSON-serializable (no undefined, functions, symbols, class instances, NaN, Infinity, or circular references)"
+    ),
+    Bytes: () => import_zod.z.union([import_zod.z.string(), import_zod.z.custom((v) => v instanceof Uint8Array)])
   };
 }
 var SCALAR_BASE = createScalarBase(false);
+function wrapWithInputCoercion(fieldType, isList, schema) {
+  let itemCoercion = null;
+  switch (fieldType) {
+    case "String":
+      itemCoercion = import_zod.z.union([import_zod.z.string(), import_zod.z.number().transform(String)]);
+      break;
+    case "Int":
+      itemCoercion = import_zod.z.union([
+        import_zod.z.number().int(),
+        import_zod.z.string().regex(/^-?\d+$/).transform(Number)
+      ]);
+      break;
+    case "Float":
+      itemCoercion = import_zod.z.union([
+        import_zod.z.number(),
+        import_zod.z.string().regex(/^-?(\d+\.?\d*|\.\d+)([eE][+-]?\d+)?$/).transform(Number)
+      ]);
+      break;
+    default:
+      return schema;
+  }
+  const coercion = isList ? import_zod.z.array(itemCoercion) : itemCoercion;
+  return coercion.pipe(schema);
+}
 
 // src/runtime/schema-builder.ts
 var import_zod3 = require("zod");
@@ -204,19 +222,65 @@ 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"]),
   BigInt: /* @__PURE__ */ new Set(["equals", "not", "gt", "gte", "lt", "lte", "in", "notIn"]),
   Boolean: /* @__PURE__ */ new Set(["equals", "not"]),
   DateTime: /* @__PURE__ */ new Set(["equals", "not", "gt", "gte", "lt", "lte", "in", "notIn"]),
-  Bytes: /* @__PURE__ */ new Set([])
+  Bytes: /* @__PURE__ */ new Set([]),
+  Json: /* @__PURE__ */ new Set([
+    "equals",
+    "not",
+    "path",
+    "string_contains",
+    "string_starts_with",
+    "string_ends_with",
+    "array_contains",
+    "array_starts_with",
+    "array_ends_with"
+  ])
 };
-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"
+]);
+var JSON_STRING_OPERATORS = /* @__PURE__ */ new Set([
+  "string_contains",
+  "string_starts_with",
+  "string_ends_with"
+]);
+var JSON_ARRAY_OPERATORS = /* @__PURE__ */ new Set([
+  "array_contains",
+  "array_starts_with",
+  "array_ends_with"
+]);
 function getSupportedOperators(fieldMeta) {
   if (fieldMeta.isList)
     return [...SCALAR_LIST_OPERATORS];
@@ -251,7 +315,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 import_zod2.z.boolean();
@@ -267,9 +333,32 @@ function createScalarListOperatorSchema(fieldMeta, operator, enumMap, scalarBase
   }
   return import_zod2.z.preprocess(coerceToArray, import_zod2.z.array(itemBase));
 }
+function createJsonOperatorSchema(fieldMeta, operator) {
+  const jsonValue = import_zod2.z.unknown();
+  if (operator === "equals" || operator === "not") {
+    return !fieldMeta.isRequired ? import_zod2.z.union([jsonValue, import_zod2.z.null()]) : jsonValue;
+  }
+  if (operator === "path") {
+    return import_zod2.z.preprocess(coerceToArray, import_zod2.z.array(import_zod2.z.string()).min(1));
+  }
+  if (JSON_STRING_OPERATORS.has(operator)) {
+    return import_zod2.z.string();
+  }
+  if (JSON_ARRAY_OPERATORS.has(operator)) {
+    return jsonValue;
+  }
+  throw new ShapeError(
+    `Operator "${operator}" not supported for Json fields`
+  );
+}
 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];
@@ -277,7 +366,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 = import_zod2.z.enum(values);
     if (operator === "equals" || operator === "not") {
@@ -286,29 +377,43 @@ function createOperatorSchema(fieldMeta, operator, enumMap, scalarBase) {
     const itemSchema = !fieldMeta.isRequired ? import_zod2.z.union([enumSchema, import_zod2.z.null()]) : enumSchema;
     return import_zod2.z.preprocess(coerceToArray, import_zod2.z.array(itemSchema));
   }
+  if (fieldMeta.type === "Json") {
+    const supportedOps2 = SCALAR_OPERATORS["Json"];
+    if (!supportedOps2 || !supportedOps2.has(operator)) {
+      throw new ShapeError(
+        `Operator "${operator}" not supported for type "Json"`
+      );
+    }
+    return createJsonOperatorSchema(fieldMeta, operator);
+  }
   const supportedOps = SCALAR_OPERATORS[fieldMeta.type];
   if (!supportedOps) {
     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 ? import_zod2.z.union([scalar, import_zod2.z.null()]) : scalar;
+    return !fieldMeta.isRequired ? import_zod2.z.union([coerced, import_zod2.z.null()]) : coerced;
   }
   if (operator === "in" || operator === "notIn") {
-    const itemSchema = !fieldMeta.isRequired ? import_zod2.z.union([scalar, import_zod2.z.null()]) : scalar;
+    const itemSchema = !fieldMeta.isRequired ? import_zod2.z.union([coerced, import_zod2.z.null()]) : coerced;
     return import_zod2.z.preprocess(coerceToArray, import_zod2.z.array(itemSchema));
   }
-  return scalar;
+  return coerced;
 }
 
 // src/runtime/schema-builder.ts
@@ -358,6 +463,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;
   }
@@ -390,9 +498,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) {
@@ -466,7 +578,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)
@@ -477,7 +591,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.`
+          );
         }
       }
     }
@@ -510,10 +626,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,
@@ -542,11 +662,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] = import_zod3.z.number().int().min(0);
         }
         schemaMap["_count"] = import_zod3.z.object(countFields);
@@ -558,7 +684,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
@@ -1012,13 +1143,18 @@ function validateUniqueEquality(model, where, method, uniqueMap, typeMap) {
 }
 
 // src/runtime/query-builder-where.ts
-var UNSUPPORTED_WHERE_TYPES = /* @__PURE__ */ new Set(["Json", "Bytes"]);
+var UNSUPPORTED_WHERE_TYPES = /* @__PURE__ */ new Set(["Bytes"]);
 var STRING_MODE_OPS = /* @__PURE__ */ new Set([
   "contains",
   "startsWith",
   "endsWith",
   "equals"
 ]);
+var JSON_STRING_MODE_OPS = /* @__PURE__ */ new Set([
+  "string_contains",
+  "string_starts_with",
+  "string_ends_with"
+]);
 var MAX_WHERE_DEPTH = 10;
 function safeStringify(v) {
   if (typeof v === "bigint")
@@ -1114,6 +1250,13 @@ function mergeRelationForcedMaps(target, source) {
     }
   }
 }
+function isModeCompatibleOp(fieldType, op) {
+  if (fieldType === "String")
+    return STRING_MODE_OPS.has(op);
+  if (fieldType === "Json")
+    return JSON_STRING_MODE_OPS.has(op);
+  return false;
+}
 function createWhereBuilder(typeMap, enumMap, scalarBase) {
   function buildWhereSchema(model, whereConfig, depth) {
     const currentDepth = depth ?? 0;
@@ -1316,7 +1459,7 @@ function createWhereBuilder(typeMap, enumMap, scalarBase) {
     const opSchemas = {};
     const fieldForced = {};
     let hasClientOps = false;
-    let hasStringModeOp = false;
+    let hasModeCompatibleOp = false;
     const clientOpKeys = [];
     let modeConfigValue = void 0;
     let hasModeConfig = false;
@@ -1335,8 +1478,8 @@ function createWhereBuilder(typeMap, enumMap, scalarBase) {
         ).optional();
         hasClientOps = true;
         clientOpKeys.push(op);
-        if (fieldMeta.type === "String" && !fieldMeta.isList && STRING_MODE_OPS.has(op)) {
-          hasStringModeOp = true;
+        if (!fieldMeta.isList && isModeCompatibleOp(fieldMeta.type, op)) {
+          hasModeCompatibleOp = true;
         }
       } else {
         const actualOpValue = isForcedValue(opValue) ? opValue.value : opValue;
@@ -1355,15 +1498,15 @@ function createWhereBuilder(typeMap, enumMap, scalarBase) {
           );
         }
         fieldForced[op] = parsed;
-        if (fieldMeta.type === "String" && !fieldMeta.isList && STRING_MODE_OPS.has(op)) {
-          hasStringModeOp = true;
+        if (!fieldMeta.isList && isModeCompatibleOp(fieldMeta.type, op)) {
+          hasModeCompatibleOp = true;
         }
       }
     }
     if (!hasClientOps && Object.keys(fieldForced).length === 0) {
       if (hasModeConfig) {
         throw new ShapeError(
-          `Where field "${fieldName}" on model "${model}" has "mode" but no operators. Add at least one operator (contains, startsWith, endsWith, equals).`
+          `Where field "${fieldName}" on model "${model}" has "mode" but no operators. Add at least one compatible operator.`
         );
       }
       throw new ShapeError(
@@ -1371,9 +1514,9 @@ function createWhereBuilder(typeMap, enumMap, scalarBase) {
       );
     }
     if (hasModeConfig) {
-      if (!hasStringModeOp) {
+      if (!hasModeCompatibleOp) {
         throw new ShapeError(
-          `"mode" on where field "${fieldName}" on model "${model}" requires a compatible String operator (contains, startsWith, endsWith, equals)`
+          `"mode" on where field "${fieldName}" on model "${model}" requires a compatible operator (String: contains, startsWith, endsWith, equals; Json: string_contains, string_starts_with, string_ends_with)`
         );
       }
       if (modeConfigValue === true) {
@@ -1391,7 +1534,7 @@ function createWhereBuilder(typeMap, enumMap, scalarBase) {
         }
         fieldForced["mode"] = parsed;
       }
-    } else if (hasStringModeOp) {
+    } else if (hasModeCompatibleOp) {
       opSchemas["mode"] = import_zod4.z.enum(["default", "insensitive"]).optional();
     }
     if (hasClientOps) {
@@ -1404,7 +1547,7 @@ function createWhereBuilder(typeMap, enumMap, scalarBase) {
           message: `At least one operator required for where field "${fieldName}"`
         }
       );
-      if ("equals" in opSchemas) {
+      if ("equals" in opSchemas && fieldMeta.type !== "Json") {
         const equalsBase = createOperatorSchema(
           fieldMeta,
           "equals",