fix(drizzle): convert equals/not_equals to in/not_in for hasMany relationship array values (#15766)

### What?

When the value is an array, converts `equals` → `in` and `not_equals` →
`not_in` for relationship/upload fields in `sanitizeQueryValue`.

### Why?

When filtering relationship fields with `equals` or `not_equals` using
array values (e.g., `{ relatedPost: { equals: [1] } }`), SQL adapters
(Postgres, SQLite) throw because the `=` operator doesn't accept arrays.

### How?

Added an `Array.isArray(formattedValue)` guard at the end of
`sanitizeQueryValue` that swaps the operator when the value is an array.
It runs after all type conversions (UUID validation, date formatting, ID
casting) so it works with already-sanitized values. Same pattern as the
existing `contains` → `equals` swap for hasMany relationships on line
248.

Also added integration tests covering `equals` and `not_equals` with
array values for both hasMany and non-hasMany relationship fields.

---------

Co-authored-by: Patrik Kozak <35232443+PatrikKozak@users.noreply.github.com>

Author: maximseshuk

packages/drizzle/src/queries/parseParams.ts

@@ -316,7 +316,7 @@ export function parseParams({
                 if (
                   (field.type === 'relationship' || field.type === 'upload') &&
                   Array.isArray(queryValue) &&
-                  operator === 'not_in'
+                  queryOperator === 'not_in'
                 ) {
                   constraints.push(
                     sql`(${notInArray(table[columnName], queryValue)} OR

packages/drizzle/src/queries/sanitizeQueryValue.ts

@@ -281,6 +281,22 @@ export const sanitizeQueryValue = ({
     }
   }
 
+  if ((field.type === 'relationship' || field.type === 'upload') && Array.isArray(formattedValue)) {
+    if (operator === 'equals') {
+      return {
+        columns: formattedColumns,
+        operator: 'in',
+        value: formattedValue,
+      }
+    } else if (operator === 'not_equals') {
+      return {
+        columns: formattedColumns,
+        operator: 'not_in',
+        value: formattedValue,
+      }
+    }
+  }
+
   return {
     columns: formattedColumns,
     operator,

test/fields/int.spec.ts

@@ -4272,6 +4272,94 @@ describe('Fields', () => {
         expect(noMatchDocIDs).toContain(relDoc1.id)
         expect(noMatchDocIDs).not.toContain(relDoc2.id)
       })
+
+      it('should not throw when querying hasMany relationship with equals array', async () => {
+        const text1 = await payload.create({
+          collection: 'text-fields',
+          data: { text: 'Text 1' },
+        })
+
+        const relDoc = await payload.create({
+          collection: 'relationship-fields',
+          data: {
+            relationshipHasMany: [text1.id],
+            relationship: { relationTo: 'text-fields', value: text1.id },
+          },
+        })
+        createdIDs.push(relDoc.id)
+
+        try {
+          const equalsResult = await payload.find({
+            collection: 'relationship-fields',
+            where: {
+              relationshipHasMany: {
+                equals: [text1.id],
+              },
+            },
+          })
+
+          expect(equalsResult.docs.some((doc) => doc.id === relDoc.id)).toBe(true)
+
+          const notEqualsResult = await payload.find({
+            collection: 'relationship-fields',
+            where: {
+              relationshipHasMany: {
+                not_equals: [text1.id],
+              },
+            },
+          })
+
+          expect(notEqualsResult.docs.some((doc) => doc.id === relDoc.id)).toBe(false)
+        } finally {
+          await payload.delete({ collection: 'text-fields', id: text1.id })
+        }
+      })
+
+      it('should include docs with null relationship when using not_equals with array on non-hasMany field', async () => {
+        // Only SQL adapters are affected - MongoDB handles NOT IN / NULL differently
+        if (payload.db.name === 'mongoose') {
+          return
+        }
+
+        const text1 = await payload.create({
+          collection: 'text-fields',
+          data: { text: 'Text 1' },
+        })
+
+        const text2 = await payload.create({
+          collection: 'text-fields',
+          data: { text: 'Text 2' },
+        })
+
+        // relDocWithNull has no relationshipDrawer set (null)
+        const relDocWithNull = await payload.create({
+          collection: 'relationship-fields',
+          data: {
+            relationship: { relationTo: 'text-fields', value: text1.id },
+          },
+        })
+        createdIDs.push(relDocWithNull.id)
+
+        try {
+          // Querying not_equals: [text2.id] should include relDocWithNull because
+          // its relationshipDrawer is null, which is "not equal to text2.id".
+          // Without OR IS NULL in the SQL, NULL NOT IN (text2.id) evaluates to NULL
+          // (not TRUE), so the document is incorrectly excluded.
+          const result = await payload.find({
+            collection: 'relationship-fields',
+            where: {
+              relationshipDrawer: {
+                not_equals: [text2.id],
+              },
+            },
+          })
+
+          expect(result.docs.some((doc) => doc.id === relDocWithNull.id)).toBe(true)
+        } finally {
+          await payload.delete({ collection: 'text-fields', id: text1.id })
+          await payload.delete({ collection: 'text-fields', id: text2.id })
+        }
+      })
     })
   })