packages/prisma/extensions/disallow-undefined-where-clause.ts (2)

19-38: Deep validation misses nested undefineds (OR/AND/NOT), only checks top-level fields and top-level 'in'

Cases like { OR: [{ id: undefined }] } or nested relation filters can slip through. If the intent is to “disallow undefined fields anywhere in where,” you need recursive validation over objects and arrays.

Sketch:

function hasUndefinedDeep(value: unknown): boolean {
  if (value === undefined) return true;
  if (value === null) return false;
  if (Array.isArray(value)) return value.some(hasUndefinedDeep);
  if (typeof value === "object") {
    return Object.values(value as Record<string, unknown>).some(hasUndefinedDeep);
  }
  return false;
}

// Then inside validateWhereClause after top-level checks:
if (typeof where === "object" || Array.isArray(where)) {
  if (hasUndefinedDeep(where)) {
    throw new Error('The "where" clause contains undefined values.');
  }
}

Optionally, keep the specific "in" error message if you want a more descriptive error for that path, but a deep scan will broadly prevent undefineds anywhere.

---

34-37: Use safe hasOwnProperty check and guard non-objects

whereInput can be primitives (e.g., id: "x", teamId: null), so directly accessing hasOwnProperty may be surprising. Also, use Object.prototype.hasOwnProperty.call to avoid prototype overrides.

-      if (whereInput.hasOwnProperty("in") && typeof whereInput.in === "undefined") {
+      if (
+        whereInput &&
+        typeof whereInput === "object" &&
+        Object.prototype.hasOwnProperty.call(whereInput, "in") &&
+        typeof (whereInput as any).in === "undefined"
+      ) {
         message = `The "in" value for the field "${key}" cannot be undefined.`;
         throw new Error(message);
       }

packages/prisma/extensions/disallow-undefined-where-clause.ts (1)

3-16: Strengthen typing and null handling in validateWhereClause; avoid any and clarify null-case

• Replace any with unknown and add precise type guards.
• Avoid Object.keys(where || {}) and explicitly check for null to produce clearer error messages.

-export const validateWhereClause = (where: any) => {
+export const validateWhereClause = (where: unknown) => {
   // Check if where is undefined
   if (where === undefined) {
     throw new Error('The "where" clause cannot be undefined.');
   }

-  // Check if where is an empty object
-  if (typeof where === "object" && !Array.isArray(where) && Object.keys(where || {}).length === 0) {
+  // Disallow null explicitly to avoid misreporting it as {}
+  if (where === null) {
+    throw new Error('The "where" clause cannot be null.');
+  }
+
+  // Check if where is an empty object
+  if (typeof where === "object" && !Array.isArray(where) && Object.keys(where as Record<string, unknown>).length === 0) {
     throw new Error('The "where" clause cannot be an empty object {}.');
   }

   // Check if where is an empty array
   if (Array.isArray(where) && where.length === 0) {
     throw new Error('The "where" clause cannot be an empty array [].');
   }

Pros:

• Better type-safety and clearer error for null.
• Avoids reliance on falsy coalescing which can hide intent.

Cons:

• Introduces a new error message for null; add a matching test if you adopt this.

packages/prisma/extensions/disallow-undefined-where-clause.test.ts (3)

39-39: Typos: “contain” → “contains”

Minor grammar cleanup in test names.

-it("validateWhereClause should not throw exception when the where object contain null values", async () => {
+it("validateWhereClause should not throw exception when the where object contains null values", () => {

-it("validateWhereClause should throw exception when the where object contain null values and 'in' field is undefined", async () => {
+it("validateWhereClause should throw exception when the where object contains null values and 'in' field is undefined", () => {

Also applies to: 48-48

---

36-37: Make “does not throw” assertions explicit

Prefer an explicit not.toThrow() to make intent clear and to ensure any unexpected throw is caught by the assertion rather than the test runner.

-    validateWhereClause(where);
+    expect(() => validateWhereClause(where)).not.toThrow();

Also applies to: 45-46

---

62-67: Consider adding a test for where = null (if you adopt null-specific error)

Your current code treats null like empty {} due to coalescing. If you adopt explicit null handling, add a test to assert the null message.

Example:

it('validateWhereClause should throw exception when the where object is null', () => {
  const where = null as unknown as object;
  expect(() => validateWhereClause(where)).toThrowError('The "where" clause cannot be null.');
});

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro