fix: where querying by a join field with relationship nested to an array (#16101)

Fixes #16095

---
- To see the specific tasks where the Asana app for GitHub is being
used, see below:
  - https://app.asana.com/0/0/1213862751667806

Author: r1tsuu

packages/db-mongodb/src/queries/buildSearchParams.ts

@@ -193,8 +193,16 @@ export async function buildSearchParam({
               let ref = doc
 
               for (const segment of joinPath.split('.')) {
-                if (typeof ref === 'object' && ref) {
+                if (Array.isArray(ref)) {
+                  ref = ref
+                    .map((item) => (typeof item === 'object' && item ? item[segment] : undefined))
+                    .flat()
+                    .filter((item) => item != null)
+                } else if (typeof ref === 'object' && ref) {
                   ref = ref[segment]
+                } else {
+                  ref = undefined
+                  break
                 }
               }
 

packages/drizzle/src/queries/getTableColumnFromPath.ts

@@ -476,14 +476,53 @@ export const getTableColumnFromPath = ({
           existingTable || getTableAlias({ adapter, tableName: newTableName }).newAliasTable
 
         if (!existingTable) {
-          joins.push({
-            condition: eq(
-              newAliasTable[field.on.replaceAll('.', '_')],
-              aliasTable ? aliasTable.id : adapter.tables[tableName].id,
-            ),
-            queryPath: `${constraintPath}${field.name}`,
-            table: newAliasTable,
-          })
+          const onSegments = field.on.split('.')
+          const collectionFlattenedFields =
+            adapter.payload.collections[field.collection].config.flattenedFields
+          const firstSegField =
+            onSegments.length > 1
+              ? collectionFlattenedFields.find((f) => f.name === onSegments[0])
+              : null
+
+          const arrayTableName =
+            firstSegField?.type === 'array'
+              ? adapter.tableNameMap.get(`${newTableName}_${toSnakeCase(onSegments[0])}`)
+              : undefined
+
+          if (arrayTableName) {
+            // join from main table to array table
+            const { newAliasTable: arrayAliasTable } = getTableAlias({
+              adapter,
+              tableName: arrayTableName,
+            })
+
+            joins.push({
+              condition: eq(
+                arrayAliasTable[onSegments.slice(1).join('_')],
+                aliasTable ? aliasTable.id : adapter.tables[tableName].id,
+              ),
+              queryPath: `${constraintPath}${field.name}._array`,
+              table: arrayAliasTable,
+            })
+
+            joins.push({
+              condition: eq(
+                (newAliasTable as PgTableWithColumns<any>).id,
+                arrayAliasTable._parentID,
+              ),
+              queryPath: `${constraintPath}${field.name}`,
+              table: newAliasTable,
+            })
+          } else {
+            joins.push({
+              condition: eq(
+                newAliasTable[field.on.replaceAll('.', '_')],
+                aliasTable ? aliasTable.id : adapter.tables[tableName].id,
+              ),
+              queryPath: `${constraintPath}${field.name}`,
+              table: newAliasTable,
+            })
+          }
         }
 
         if (newCollectionPath === 'id') {

test/joins/int.spec.ts

@@ -1865,6 +1865,24 @@ describe('Joins Field', () => {
     expect(found.docs[0].id).toBe(category.id)
   })
 
+  it('should support where querying by a join field with relationship nested to an array', async () => {
+    const category = await payload.create({ collection: 'categories', data: {} })
+    const post = await payload.create({
+      collection: 'posts',
+      data: { array: [{ category: category.id }], title: 'array-join-where-test' },
+    })
+    const found = await payload.find({
+      collection: 'categories',
+      where: { 'arrayPosts.title': { equals: 'array-join-where-test' } },
+    })
+
+    expect(found.docs).toHaveLength(1)
+    expect(found.docs[0].id).toBe(category.id)
+
+    await payload.delete({ collection: 'posts', id: post.id })
+    await payload.delete({ collection: 'categories', id: category.id })
+  })
+
   it('should support where querying by a join field multiple times', async () => {
     const category = await payload.create({ collection: 'categories', data: {} })
     await payload.create({