prisma-guard 1.9.0 → 1.10.0

package/dist/runtime/index.cjs

@@ -161,8 +161,49 @@ 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"]),
+  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,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;
@@ -738,6 +756,9 @@ function applyBuiltShape(built, body, isUniqueMethod) {
   const hasWhereInSchema = "where" in built.zodSchema.shape;
   if (isPlainObject(body)) {
     const bodyObj = body;
+    if ("select" in bodyObj && "include" in bodyObj) {
+      throw new ShapeError('Request cannot define both "include" and "select"');
+    }
     if ("where" in bodyObj) {
       if (!hasWhereInSchema) {
         const { where: _, ...rest } = bodyObj;
@@ -1176,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)) {
@@ -1360,14 +1384,26 @@ 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
+        );
+        const shorthand = equalsBase.transform((v) => ({ equals: v }));
+        fieldSchemas[fieldName] = import_zod4.z.union([refined, shorthand]).optional();
+      } else {
+        fieldSchemas[fieldName] = refined.optional();
+      }
     }
     if (Object.keys(fieldForced).length > 0) {
       scalarConditions[fieldName] = fieldForced;
@@ -1469,7 +1505,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)) {
@@ -1540,7 +1576,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) {
@@ -1562,7 +1598,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];
@@ -2140,11 +2176,6 @@ function createQueryBuilder(typeMap, enumMap, uniqueMap, scalarBase) {
     if (UNIQUE_WHERE_METHODS.has(method) && !shape.where) {
       throw new ShapeError(`${method} shape must define "where"`);
     }
-    if (shape.include && shape.select) {
-      throw new ShapeError(
-        'Shape config cannot define both "include" and "select".'
-      );
-    }
     if (method === "groupBy" && !shape.by)
       throw new ShapeError('groupBy shape must define "by"');
     if (method === "groupBy" && (shape.include || shape.select)) {
@@ -2254,7 +2285,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)) {
@@ -2297,7 +2328,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(
@@ -3394,9 +3425,6 @@ function createModelGuardExtension(config) {
       return queryBuilder.buildWhereSchema(modelName, whereConfig);
     }
     function buildProjectionSchema(shape) {
-      if (shape.select && shape.include) {
-        throw new ShapeError('Shape cannot define both "select" and "include"');
-      }
       const schemaFields = {};
       let forcedIncludeTree = {};
       let forcedSelectTree = {};
@@ -3448,6 +3476,11 @@ function createModelGuardExtension(config) {
           `Guard shape does not define "select" or "include" for ${method} return projection`
         );
       }
+      if ("select" in parsed && "include" in parsed) {
+        throw new ShapeError(
+          'Request body cannot define both "select" and "include"'
+        );
+      }
       if (!hasShapeProjection)
         return {};
       if (!hasBodyProjection && !enforceProjection)
@@ -3946,7 +3979,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 +3995,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 +4040,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 +4048,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 +4078,7 @@ function createGuard(config) {
         uniqueMap: config.uniqueMap ?? {},
         scopeMap: config.scopeMap,
         guardConfig: config.guardConfig,
-        contextFn,
+        contextFn: effectiveContextFn,
         wrapZodErrors
       });
       return {