prisma-guard 1.14.1 → 1.16.0

package/dist/runtime/index.d.cts

@@ -187,5 +187,8 @@ declare class CallerError extends Error {
 declare function force<T>(value: T): {
     value: T;
 };
+declare function unsupported(): {
+    __brand: 'unsupported';
+};
 
-export { CallerError, type EnumMap, type FieldMeta, type GuardConfig, type GuardGeneratedConfig, type GuardInput, type GuardLogger, type GuardShape, type GuardShapeOrFn, type GuardedModel, type InputOpts, type InputSchema, type MissingScopeContextMode, type ModelOpts, type MutationMethod, type NestedIncludeArgs, type NestedSelectArgs, PolicyError, type QueryMethod, type QuerySchema, type ScopeEntry, type ScopeMap, type ShapeConfig, ShapeError, type ShapeOrFn, type TypeMap, type UniqueConstraint, type UniqueMap, type ZodChains, type ZodDefaults, createGuard, force };
+export { CallerError, type EnumMap, type FieldMeta, type GuardConfig, type GuardGeneratedConfig, type GuardInput, type GuardLogger, type GuardShape, type GuardShapeOrFn, type GuardedModel, type InputOpts, type InputSchema, type MissingScopeContextMode, type ModelOpts, type MutationMethod, type NestedIncludeArgs, type NestedSelectArgs, PolicyError, type QueryMethod, type QuerySchema, type ScopeEntry, type ScopeMap, type ShapeConfig, ShapeError, type ShapeOrFn, type TypeMap, type UniqueConstraint, type UniqueMap, type ZodChains, type ZodDefaults, createGuard, force, unsupported };

package/dist/runtime/index.d.ts

@@ -187,5 +187,8 @@ declare class CallerError extends Error {
 declare function force<T>(value: T): {
     value: T;
 };
+declare function unsupported(): {
+    __brand: 'unsupported';
+};
 
-export { CallerError, type EnumMap, type FieldMeta, type GuardConfig, type GuardGeneratedConfig, type GuardInput, type GuardLogger, type GuardShape, type GuardShapeOrFn, type GuardedModel, type InputOpts, type InputSchema, type MissingScopeContextMode, type ModelOpts, type MutationMethod, type NestedIncludeArgs, type NestedSelectArgs, PolicyError, type QueryMethod, type QuerySchema, type ScopeEntry, type ScopeMap, type ShapeConfig, ShapeError, type ShapeOrFn, type TypeMap, type UniqueConstraint, type UniqueMap, type ZodChains, type ZodDefaults, createGuard, force };
+export { CallerError, type EnumMap, type FieldMeta, type GuardConfig, type GuardGeneratedConfig, type GuardInput, type GuardLogger, type GuardShape, type GuardShapeOrFn, type GuardedModel, type InputOpts, type InputSchema, type MissingScopeContextMode, type ModelOpts, type MutationMethod, type NestedIncludeArgs, type NestedSelectArgs, PolicyError, type QueryMethod, type QuerySchema, type ScopeEntry, type ScopeMap, type ShapeConfig, ShapeError, type ShapeOrFn, type TypeMap, type UniqueConstraint, type UniqueMap, type ZodChains, type ZodDefaults, createGuard, force, unsupported };

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
@@ -573,6 +656,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) {
@@ -3159,31 +3251,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"] = z8.literal(true).optional();
-    } else if (isPlainObject(config.delete)) {
-      const deleteSchema = buildWhereFieldsSchema(
-        relatedModelName,
-        config.delete,
-        typeMap,
-        schemaBuilder
-      );
-      opSchemas["delete"] = isList ? z8.union([
-        deleteSchema,
-        z8.preprocess(coerceToArray, z8.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(
@@ -3390,8 +3457,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] = z8.unknown().optional();
+        continue;
+      }
       throw new ShapeError(`Unknown field "${fieldName}" on model "${model}"`);
+    }
     if (fieldMeta.isRelation) {
       if (!isPlainObject(value)) {
         throw new ShapeError(
@@ -4599,6 +4671,7 @@ export {
   PolicyError,
   ShapeError,
   createGuard,
-  force
+  force,
+  unsupported
 };
 //# sourceMappingURL=index.js.map