prisma-guard 1.4.1 → 1.5.1

package/dist/runtime/index.js

@@ -705,18 +705,23 @@ function mergeUniqueWhereForced(where, forced) {
 }
 function applyBuiltShape(built, body, isUniqueMethod) {
   let parseable = body;
-  if (built.forcedOnlyWhereKeys.size > 0 && isPlainObject(body)) {
+  if (isPlainObject(body)) {
     const bodyObj = body;
     if (isPlainObject(bodyObj.where)) {
       const where = { ...bodyObj.where };
-      let stripped = false;
-      for (const key of built.forcedOnlyWhereKeys) {
-        if (key in where) {
-          delete where[key];
-          stripped = true;
+      let modified = false;
+      if (built.forcedOnlyWhereKeys.size > 0) {
+        for (const key of built.forcedOnlyWhereKeys) {
+          if (key in where) {
+            delete where[key];
+            modified = true;
+          }
         }
       }
-      if (stripped) {
+      if (Object.keys(where).length === 0 && hasWhereForced(built.forcedWhere)) {
+        const { where: _, ...rest } = bodyObj;
+        parseable = rest;
+      } else if (modified) {
         parseable = { ...bodyObj, where };
       }
     }
@@ -1247,7 +1252,14 @@ function createWhereBuilder(typeMap, enumMap, scalarBase) {
     let hasClientOps = false;
     let hasStringModeOp = false;
     const clientOpKeys = [];
+    let modeConfigValue = void 0;
+    let hasModeConfig = false;
     for (const [op, opValue] of Object.entries(operators)) {
+      if (op === "mode") {
+        hasModeConfig = true;
+        modeConfigValue = opValue;
+        continue;
+      }
       if (opValue === true) {
         opSchemas[op] = createOperatorSchema(
           fieldMeta,
@@ -1277,14 +1289,43 @@ function createWhereBuilder(typeMap, enumMap, scalarBase) {
           );
         }
         fieldForced[op] = parsed;
+        if (fieldMeta.type === "String" && !fieldMeta.isList && STRING_MODE_OPS.has(op)) {
+          hasStringModeOp = 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).`
+        );
+      }
       throw new ShapeError(
         `Empty operator config for where field "${fieldName}" on model "${model}". Define at least one operator.`
       );
     }
-    if (hasStringModeOp) {
+    if (hasModeConfig) {
+      if (!hasStringModeOp) {
+        throw new ShapeError(
+          `"mode" on where field "${fieldName}" on model "${model}" requires a compatible String operator (contains, startsWith, endsWith, equals)`
+        );
+      }
+      if (modeConfigValue === true) {
+        opSchemas["mode"] = z4.enum(["default", "insensitive"]).optional();
+      } else {
+        const actualModeValue = isForcedValue(modeConfigValue) ? modeConfigValue.value : modeConfigValue;
+        const modeSchema = z4.enum(["default", "insensitive"]);
+        let parsed;
+        try {
+          parsed = modeSchema.parse(actualModeValue);
+        } catch (err) {
+          throw new ShapeError(
+            `Invalid forced value for "${model}.${fieldName}.mode": ${err.message}`
+          );
+        }
+        fieldForced["mode"] = parsed;
+      }
+    } else if (hasStringModeOp) {
       opSchemas["mode"] = z4.enum(["default", "insensitive"]).optional();
     }
     if (hasClientOps) {
@@ -2070,9 +2111,11 @@ function createQueryBuilder(typeMap, enumMap, uniqueMap, scalarBase) {
     }
     if (method === "count" && shape.include)
       throw new ShapeError('count does not support "include"');
-    if (method === "groupBy" && shape.orderBy) {
+    if (method === "groupBy" && shape.orderBy && shape.orderBy !== true) {
       const bySet = new Set(shape.by);
       for (const fieldName of Object.keys(shape.orderBy)) {
+        if (fieldName === "_count")
+          continue;
         if (!bySet.has(fieldName)) {
           throw new ShapeError(
             `orderBy field "${fieldName}" must be included in "by" for groupBy`
@@ -2150,11 +2193,29 @@ function createQueryBuilder(typeMap, enumMap, uniqueMap, scalarBase) {
         forcedSelectCountWhere = result.forcedCountWhere;
       }
     }
-    if (shape.orderBy)
-      schemaFields["orderBy"] = argsBuilder.buildOrderBySchema(
-        model,
-        shape.orderBy
-      );
+    if (shape.orderBy) {
+      if (method === "groupBy" && shape.orderBy === true && shape.by) {
+        const sortEnum = z7.enum(["asc", "desc"]);
+        const groupByOrderFields = {};
+        for (const field of shape.by) {
+          groupByOrderFields[field] = sortEnum.optional();
+        }
+        groupByOrderFields["_count"] = sortEnum.optional();
+        const fieldKeys = Object.keys(groupByOrderFields);
+        const singleSchema = z7.object(groupByOrderFields).strict().refine(
+          (v) => fieldKeys.some(
+            (k) => v[k] !== void 0
+          ),
+          { message: "orderBy must specify at least one field" }
+        );
+        schemaFields["orderBy"] = z7.union([singleSchema, z7.array(singleSchema).min(1)]).optional();
+      } else {
+        schemaFields["orderBy"] = argsBuilder.buildOrderBySchema(
+          model,
+          shape.orderBy
+        );
+      }
+    }
     if (shape.cursor)
       schemaFields["cursor"] = argsBuilder.buildCursorSchema(
         model,