prisma-guard 1.9.1 → 1.11.0

package/dist/runtime/index.cjs

@@ -161,6 +161,47 @@ var import_zod3 = require("zod");
 
 // src/runtime/zod-type-map.ts
 var import_zod2 = require("zod");
+
+// src/shared/utils.ts
+function isPlainObject(v) {
+  if (typeof v !== "object" || v === null || Array.isArray(v))
+    return false;
+  const proto = Object.getPrototypeOf(v);
+  return proto === Object.prototype || proto === null;
+}
+function schemaProducesValueForUndefined(schema) {
+  const result = schema.safeParse(void 0);
+  return result.success && result.data !== void 0;
+}
+function isZodSchema(value) {
+  if (value == null || typeof value !== "object")
+    return false;
+  const v = value;
+  return typeof v.parse === "function" && typeof v.optional === "function";
+}
+function coerceToArray(value) {
+  if (Array.isArray(value))
+    return value;
+  if (value === null || value === void 0)
+    return value;
+  if (typeof value !== "object")
+    return value;
+  const keys = Object.keys(value);
+  if (keys.length === 0)
+    return [];
+  const allNumeric = keys.every((k) => /^\d+$/.test(k));
+  if (!allNumeric)
+    return value;
+  const sorted = keys.map(Number).sort((a, b) => a - b);
+  const obj = value;
+  const result = [];
+  for (const idx of sorted) {
+    result.push(obj[String(idx)]);
+  }
+  return result;
+}
+
+// src/runtime/zod-type-map.ts
 var SCALAR_OPERATORS = {
   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"]),
@@ -212,17 +253,16 @@ function createScalarListOperatorSchema(fieldMeta, operator, enumMap, scalarBase
   if (operator === "isEmpty") {
     return import_zod2.z.boolean();
   }
-  if (operator === "equals") {
-    const itemMeta2 = { ...fieldMeta, isList: false };
-    const itemBase2 = createBaseType(itemMeta2, enumMap, scalarBase);
-    return fieldMeta.isRequired ? import_zod2.z.array(itemBase2) : import_zod2.z.union([import_zod2.z.array(itemBase2), import_zod2.z.null()]);
-  }
   const itemMeta = { ...fieldMeta, isList: false };
   const itemBase = createBaseType(itemMeta, enumMap, scalarBase);
   if (operator === "has") {
     return !fieldMeta.isRequired ? import_zod2.z.union([itemBase, import_zod2.z.null()]) : itemBase;
   }
-  return import_zod2.z.array(itemBase);
+  if (operator === "equals") {
+    const arrSchema = import_zod2.z.array(itemBase);
+    return fieldMeta.isRequired ? import_zod2.z.preprocess(coerceToArray, arrSchema) : import_zod2.z.union([import_zod2.z.preprocess(coerceToArray, arrSchema), import_zod2.z.null()]);
+  }
+  return import_zod2.z.preprocess(coerceToArray, import_zod2.z.array(itemBase));
 }
 function createOperatorSchema(fieldMeta, operator, enumMap, scalarBase) {
   if (fieldMeta.isList) {
@@ -240,10 +280,8 @@ function createOperatorSchema(fieldMeta, operator, enumMap, scalarBase) {
     if (operator === "equals" || operator === "not") {
       return !fieldMeta.isRequired ? import_zod2.z.union([enumSchema, import_zod2.z.null()]) : enumSchema;
     }
-    if (!fieldMeta.isRequired) {
-      return import_zod2.z.array(import_zod2.z.union([enumSchema, import_zod2.z.null()]));
-    }
-    return import_zod2.z.array(enumSchema);
+    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));
   }
   const supportedOps = SCALAR_OPERATORS[fieldMeta.type];
   if (!supportedOps) {
@@ -264,32 +302,12 @@ function createOperatorSchema(fieldMeta, operator, enumMap, scalarBase) {
     return !fieldMeta.isRequired ? import_zod2.z.union([scalar, import_zod2.z.null()]) : scalar;
   }
   if (operator === "in" || operator === "notIn") {
-    if (!fieldMeta.isRequired) {
-      return import_zod2.z.array(import_zod2.z.union([scalar, import_zod2.z.null()]));
-    }
-    return import_zod2.z.array(scalar);
+    const itemSchema = !fieldMeta.isRequired ? import_zod2.z.union([scalar, import_zod2.z.null()]) : scalar;
+    return import_zod2.z.preprocess(coerceToArray, import_zod2.z.array(itemSchema));
   }
   return scalar;
 }
 
-// src/shared/utils.ts
-function isPlainObject(v) {
-  if (typeof v !== "object" || v === null || Array.isArray(v))
-    return false;
-  const proto = Object.getPrototypeOf(v);
-  return proto === Object.prototype || proto === null;
-}
-function schemaProducesValueForUndefined(schema) {
-  const result = schema.safeParse(void 0);
-  return result.success && result.data !== void 0;
-}
-function isZodSchema(value) {
-  if (value == null || typeof value !== "object")
-    return false;
-  const v = value;
-  return typeof v.parse === "function" && typeof v.optional === "function";
-}
-
 // src/runtime/schema-builder.ts
 var DEFAULT_MAX_CACHE = 500;
 var DEFAULT_MAX_DEPTH = 5;
@@ -1179,9 +1197,12 @@ function createWhereBuilder(typeMap, enumMap, scalarBase) {
         );
       }
       if (key === "NOT") {
-        fieldSchemas[key] = import_zod4.z.union([elementSchema, import_zod4.z.array(elementSchema).min(1)]).optional();
+        fieldSchemas[key] = import_zod4.z.union([
+          elementSchema,
+          import_zod4.z.preprocess(coerceToArray, import_zod4.z.array(elementSchema).min(1))
+        ]).optional();
       } else {
-        fieldSchemas[key] = import_zod4.z.array(elementSchema).min(1).optional();
+        fieldSchemas[key] = import_zod4.z.preprocess(coerceToArray, import_zod4.z.array(elementSchema).min(1)).optional();
       }
     }
     if (hasWhereForced(result.forced)) {
@@ -1363,14 +1384,25 @@ function createWhereBuilder(typeMap, enumMap, scalarBase) {
     }
     if (hasClientOps) {
       const opObj = import_zod4.z.object(opSchemas).strict();
-      fieldSchemas[fieldName] = opObj.refine(
+      const refined = opObj.refine(
         (v) => clientOpKeys.some(
           (k) => v[k] !== void 0
         ),
         {
           message: `At least one operator required for where field "${fieldName}"`
         }
-      ).optional();
+      );
+      if ("equals" in opSchemas) {
+        const equalsBase = createOperatorSchema(
+          fieldMeta,
+          "equals",
+          enumMap,
+          scalarBase
+        );
+        fieldSchemas[fieldName] = import_zod4.z.union([refined, equalsBase]).optional();
+      } else {
+        fieldSchemas[fieldName] = refined.optional();
+      }
     }
     if (Object.keys(fieldForced).length > 0) {
       scalarConditions[fieldName] = fieldForced;
@@ -1472,7 +1504,7 @@ function createArgsBuilder(typeMap, enumMap, uniqueMap, scalarBase) {
       (v) => fieldKeys.some((k) => v[k] !== void 0),
       { message: "orderBy must specify at least one field" }
     );
-    return import_zod5.z.union([singleSchema, import_zod5.z.array(singleSchema).min(1)]).optional();
+    return import_zod5.z.union([singleSchema, import_zod5.z.preprocess(coerceToArray, import_zod5.z.array(singleSchema).min(1))]).optional();
   }
   function buildTakeSchema(config) {
     if (!Number.isFinite(config.max) || !Number.isInteger(config.max)) {
@@ -1543,7 +1575,7 @@ function createArgsBuilder(typeMap, enumMap, uniqueMap, scalarBase) {
         throw new ShapeError(`List field "${fieldName}" cannot be used in distinct`);
     }
     const enumSchema = import_zod5.z.enum(distinctConfig);
-    return import_zod5.z.union([enumSchema, import_zod5.z.array(enumSchema).min(1)]).optional();
+    return import_zod5.z.union([enumSchema, import_zod5.z.preprocess(coerceToArray, import_zod5.z.array(enumSchema).min(1))]).optional();
   }
   function buildBySchema(model, byConfig) {
     if (byConfig.length === 0) {
@@ -1565,7 +1597,7 @@ function createArgsBuilder(typeMap, enumMap, uniqueMap, scalarBase) {
         throw new ShapeError(`List field "${fieldName}" cannot be used in by`);
     }
     const enumSchema = import_zod5.z.enum(byConfig);
-    return import_zod5.z.union([enumSchema, import_zod5.z.array(enumSchema).min(1)]);
+    return import_zod5.z.union([enumSchema, import_zod5.z.preprocess(coerceToArray, import_zod5.z.array(enumSchema).min(1))]);
   }
   function buildHavingSchema(model, havingConfig) {
     const modelFields = typeMap[model];
@@ -2252,7 +2284,7 @@ function createQueryBuilder(typeMap, enumMap, uniqueMap, scalarBase) {
             ),
             { message: "orderBy must specify at least one field" }
           );
-          schemaFields["orderBy"] = import_zod7.z.union([singleSchema, import_zod7.z.array(singleSchema).min(1)]).optional();
+          schemaFields["orderBy"] = import_zod7.z.union([singleSchema, import_zod7.z.preprocess(coerceToArray, import_zod7.z.array(singleSchema).min(1))]).optional();
         } else {
           const groupByOrderFields = {};
           for (const [fieldName, config] of Object.entries(shape.orderBy)) {
@@ -2295,7 +2327,7 @@ function createQueryBuilder(typeMap, enumMap, uniqueMap, scalarBase) {
             ),
             { message: "orderBy must specify at least one field" }
           );
-          schemaFields["orderBy"] = import_zod7.z.union([singleSchema, import_zod7.z.array(singleSchema).min(1)]).optional();
+          schemaFields["orderBy"] = import_zod7.z.union([singleSchema, import_zod7.z.preprocess(coerceToArray, import_zod7.z.array(singleSchema).min(1))]).optional();
         }
       } else {
         schemaFields["orderBy"] = argsBuilder.buildOrderBySchema(
@@ -3946,7 +3978,9 @@ function createModelGuardExtension(config) {
 
 // src/runtime/guard.ts
 function createGuard(config) {
-  const scalarBase = createScalarBase(config.guardConfig.strictDecimal ?? false);
+  const scalarBase = createScalarBase(
+    config.guardConfig.strictDecimal ?? false
+  );
   const schemaBuilder = createSchemaBuilder(
     config.typeMap,
     config.zodChains,
@@ -3960,11 +3994,15 @@ function createGuard(config) {
     config.uniqueMap ?? {},
     scalarBase
   );
-  const log = config.logger ?? { warn: (msg) => console.warn(msg) };
+  const log = config.logger ?? {
+    warn: (msg) => console.warn(msg)
+  };
   const wrapZodErrors = config.wrapZodErrors ?? false;
   function rethrowZod(err) {
     if (err instanceof import_zod10.ZodError) {
-      throw new ShapeError(`Validation failed: ${formatZodError(err)}`, { cause: err });
+      throw new ShapeError(`Validation failed: ${formatZodError(err)}`, {
+        cause: err
+      });
     }
     throw err;
   }
@@ -4001,6 +4039,7 @@ function createGuard(config) {
       };
     },
     extension: (contextFn) => {
+      const effectiveContextFn = contextFn ?? (() => ({}));
       const scopeRoots = /* @__PURE__ */ new Set();
       for (const entries of Object.values(config.scopeMap)) {
         for (const entry of entries) {
@@ -4008,7 +4047,7 @@ function createGuard(config) {
         }
       }
       const scopeCtxFn = () => {
-        const ctx = validateContext(contextFn());
+        const ctx = validateContext(effectiveContextFn());
         const scopeCtx = {};
         for (const key of Object.keys(ctx)) {
           if (!scopeRoots.has(key))
@@ -4038,7 +4077,7 @@ function createGuard(config) {
         uniqueMap: config.uniqueMap ?? {},
         scopeMap: config.scopeMap,
         guardConfig: config.guardConfig,
-        contextFn,
+        contextFn: effectiveContextFn,
         wrapZodErrors
       });
       return {