prisma-guard 1.14.1 → 1.16.0

package/dist/runtime/index.cjs

@@ -24,7 +24,8 @@ __export(runtime_exports, {
   PolicyError: () => PolicyError,
   ShapeError: () => ShapeError,
   createGuard: () => createGuard,
-  force: () => force
+  force: () => force,
+  unsupported: () => unsupported
 });
 module.exports = __toCommonJS(runtime_exports);
 
@@ -114,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"
@@ -143,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");
@@ -203,7 +222,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"]),
@@ -212,10 +243,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];
@@ -250,7 +294,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();
@@ -268,7 +314,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];
@@ -276,7 +327,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") {
@@ -290,24 +343,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 ? 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
@@ -357,6 +415,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;
   }
@@ -389,9 +450,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) {
@@ -465,7 +530,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)
@@ -476,7 +543,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.`
+          );
         }
       }
     }
@@ -509,10 +578,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,
@@ -541,11 +614,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);
@@ -557,7 +636,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
@@ -603,6 +687,15 @@ function force(value) {
   wrapper[FORCED_MARKER] = true;
   return wrapper;
 }
+var UNSUPPORTED_MARKER = Symbol.for("prisma-guard.unsupported");
+function isUnsupportedMarker(v) {
+  return v !== null && typeof v === "object" && v[UNSUPPORTED_MARKER] === true;
+}
+function unsupported() {
+  const marker = {};
+  marker[UNSUPPORTED_MARKER] = true;
+  return marker;
+}
 
 // src/shared/match-caller.ts
 function matchCallerPattern(patterns, caller) {
@@ -3189,31 +3282,6 @@ function buildRelationWriteSchema(model, fieldName, relatedModelName, isList, co
       );
     }
   }
-  if (config.delete !== void 0) {
-    if (config.delete === true) {
-      if (isList) {
-        throw new ShapeError(
-          `delete on to-many relation "${model}.${fieldName}" requires field config, not true`
-        );
-      }
-      opSchemas["delete"] = import_zod8.z.literal(true).optional();
-    } else if (isPlainObject(config.delete)) {
-      const deleteSchema = buildWhereFieldsSchema(
-        relatedModelName,
-        config.delete,
-        typeMap,
-        schemaBuilder
-      );
-      opSchemas["delete"] = isList ? import_zod8.z.union([
-        deleteSchema,
-        import_zod8.z.preprocess(coerceToArray, import_zod8.z.array(deleteSchema))
-      ]).optional() : deleteSchema.optional();
-    } else {
-      throw new ShapeError(
-        `delete config on "${model}.${fieldName}" must be true (to-one) or an object of field names`
-      );
-    }
-  }
   if (config.set !== void 0) {
     if (!isList) {
       throw new ShapeError(
@@ -3420,8 +3488,13 @@ function buildDataSchema(model, dataConfig, mode, typeMap, schemaBuilder, zodDef
   const forced = {};
   for (const [fieldName, value] of Object.entries(dataConfig)) {
     const fieldMeta = modelFields[fieldName];
-    if (!fieldMeta)
+    if (!fieldMeta) {
+      if (isUnsupportedMarker(value)) {
+        schemaMap[fieldName] = import_zod8.z.unknown().optional();
+        continue;
+      }
       throw new ShapeError(`Unknown field "${fieldName}" on model "${model}"`);
+    }
     if (fieldMeta.isRelation) {
       if (!isPlainObject(value)) {
         throw new ShapeError(
@@ -4630,6 +4703,7 @@ function createGuard(config) {
   PolicyError,
   ShapeError,
   createGuard,
-  force
+  force,
+  unsupported
 });
 //# sourceMappingURL=index.cjs.map