prisma-guard 1.16.0 → 1.18.0

package/dist/runtime/index.cjs

@@ -241,7 +241,18 @@ var SCALAR_OPERATORS = {
   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",
@@ -260,6 +271,16 @@ var COMPARABLE_TYPES = /* @__PURE__ */ new Set([
   "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];
@@ -312,6 +333,24 @@ 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(
@@ -338,6 +377,15 @@ 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}`);
@@ -1095,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")
@@ -1197,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;
@@ -1399,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;
@@ -1418,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;
@@ -1438,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(
@@ -1454,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) {
@@ -1474,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) {
@@ -1487,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",
@@ -3734,6 +3794,17 @@ var PROJECTION_MUTATION_METHODS = /* @__PURE__ */ new Set([
   "updateManyAndReturn"
 ]);
 var BATCH_CREATE_METHODS = /* @__PURE__ */ new Set(["createMany", "createManyAndReturn"]);
+function normalizeUniqueWhere(where) {
+  const result = {};
+  for (const [key, value] of Object.entries(where)) {
+    if (key !== "AND" && key !== "OR" && key !== "NOT" && isPlainObject(value) && "equals" in value && Object.keys(value).length === 1) {
+      result[key] = value.equals;
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
 function buildDefaultSelectInput(config) {
   const result = {};
   for (const [key, value] of Object.entries(config)) {
@@ -4343,7 +4414,7 @@ function createModelGuardExtension(config) {
           dataSchema,
           method
         );
-        const where = isUniqueWhere ? requireWhere(
+        let where = isUniqueWhere ? requireWhere(
           resolved.shape,
           resolved.body.where,
           method,
@@ -4364,6 +4435,7 @@ function createModelGuardExtension(config) {
         }
         if (isUniqueWhere) {
           validateResolvedUniqueWhere(modelName, where, method, uniqueMap);
+          where = normalizeUniqueWhere(where);
         }
         const args = { data, where };
         if (supportsProjection) {
@@ -4402,7 +4474,7 @@ function createModelGuardExtension(config) {
           );
         }
         maybeValidateUniqueWhere(modelName, resolved.shape, method);
-        const where = isUniqueWhere ? requireWhere(
+        let where = isUniqueWhere ? requireWhere(
           resolved.shape,
           resolved.body.where,
           method,
@@ -4423,6 +4495,7 @@ function createModelGuardExtension(config) {
         }
         if (isUniqueWhere) {
           validateResolvedUniqueWhere(modelName, where, method, uniqueMap);
+          where = normalizeUniqueWhere(where);
         }
         const args = { where };
         if (supportsProjection) {
@@ -4507,7 +4580,7 @@ function createModelGuardExtension(config) {
         );
         validateResolvedUniqueWhere(modelName, where, "upsert", uniqueMap);
         const args = {
-          where,
+          where: normalizeUniqueWhere(where),
           create: createData,
           update: updateData
         };