fix(drizzle): folders with trash enabled don't display documents in polymorphic joins (#14223)

### What?

Fixes a bug where collections with both Folders and Trash features
enabled fail to display documents in folder views when using the
`Postgres` database adapter.

### Why?

When querying polymorphic joins (like the `documentsAndFolders` field on
folders), two issues occurred:

1. **SQL Type Mismatch**: Collections without trash would select `null`
(treated as TEXT type) for `deletedAt`, while collections with trash
would select the actual `deleted_at` column (TIMESTAMP type). This
caused Postgres UNION queries to fail with: `UNION types text and
timestamp with time zone cannot be matched`

2. **Incorrect Operator Mapping**: The `deletedAt: { exists: false }`
WHERE constraint was being translated to `IS NOT NULL` instead of `IS
NULL` in the simplified `buildSQLWhere` function used for polymorphic
joins. This caused non-trashed documents to be filtered out instead of
trashed ones.

### How?

1. Added type casting in `traverseFields.ts` to cast NULL values to
`timestamp with time zone` for the `deletedAt` field in polymorphic join
UNION queries, ensuring type consistency across all collections.

2. Added operator mapping logic in `buildSQLWhere` to convert `exists:
false` to the `isNull` operator, duplicating the logic from
`sanitizeQueryValue.ts`. This is necessary because `buildSQLWhere` is a
simplified WHERE builder for polymorphic joins that doesn't have access
to field definitions.

Fixes #14198

Author: PatrikKozak

packages/drizzle/src/find/traverseFields.ts

@@ -59,13 +59,22 @@ const buildSQLWhere = (where: Where, alias: string) => {
         return op(...accumulated)
       }
     } else {
-      const payloadOperator = Object.keys(where[k])[0]
+      let payloadOperator = Object.keys(where[k])[0]
 
       const value = where[k][payloadOperator]
       if (payloadOperator === '$raw') {
         return sql.raw(value)
       }
 
+      // Handle exists: false -> use isNull instead of isNotNull
+
+      // This logic is duplicated from sanitizeQueryValue.ts because buildSQLWhere
+      // is a simplified WHERE builder for polymorphic joins that doesn't have access
+      // to field definitions needed by sanitizeQueryValue
+      if (payloadOperator === 'exists' && value === false) {
+        payloadOperator = 'isNull'
+      }
+
       return operatorMap[payloadOperator](sql.raw(`"${alias}"."${k.split('.').join('_')}"`), value)
     }
   }
@@ -544,7 +553,13 @@ export const traverseFields = ({
                 selectFields[path] = sql`${adapter.tables[joinCollectionTableName][path]}`.as(path)
                 // Allow to filter by collectionSlug
               } else if (path !== 'relationTo') {
-                selectFields[path] = sql`null`.as(path)
+                // For timestamp fields like deletedAt, we need to cast to timestamp in Postgres
+                // SQLite doesn't require explicit type casting for UNION queries
+                if (path === 'deletedAt' && adapter.name === 'postgres') {
+                  selectFields[path] = sql`null::timestamp with time zone`.as(path)
+                } else {
+                  selectFields[path] = sql`null`.as(path)
+                }
               }
             }
 

test/folders/collections/Posts/index.ts

@@ -8,6 +8,7 @@ export const Posts: CollectionConfig = {
     useAsTitle: 'title',
   },
   folders: true,
+  trash: true,
   fields: [
     {
       name: 'title',

test/folders/int.spec.ts

@@ -87,7 +87,7 @@ describe('folders', () => {
       })
       const childDocument = await payload.create({
         collection: 'posts',
-        data: { title: 'Child Document', folder: parentFolder.id, folderType: ['posts'] },
+        data: { title: 'Child Document', folder: parentFolder.id },
       })
       const parentFolderQuery = await payload.findByID({
         collection: 'payload-folders',
@@ -152,6 +152,75 @@ describe('folders', () => {
 
       expect(parentFolderQuery.documentsAndFolders?.docs).toHaveLength(2)
     })
+
+    it('should populate non-trashed documents when collection has both folders and trash enabled', async () => {
+      const parentFolder = await payload.create({
+        collection: 'payload-folders',
+        data: {
+          folderType: ['posts'],
+          name: 'Posts Folder',
+        },
+      })
+
+      await payload.create({
+        collection: 'posts',
+        data: {
+          title: 'Post 1',
+          folder: parentFolder.id,
+        },
+      })
+
+      await payload.create({
+        collection: 'posts',
+        data: {
+          title: 'Post 2',
+          folder: parentFolder.id,
+        },
+      })
+
+      // Create a post that will be trashed
+      const post3 = await payload.create({
+        collection: 'posts',
+        data: {
+          title: 'Post 3 (to be trashed)',
+          folder: parentFolder.id,
+        },
+      })
+
+      // Trash post3
+      await payload.delete({
+        collection: 'posts',
+        id: post3.id,
+      })
+
+      const parentFolderQuery = await payload.findByID({
+        collection: 'payload-folders',
+        id: parentFolder.id,
+        joins: {
+          documentsAndFolders: {
+            where: {
+              or: [
+                {
+                  deletedAt: {
+                    exists: false,
+                  },
+                },
+              ],
+            },
+          },
+        },
+      })
+
+      // Should only see 2 non-trashed posts, not the trashed one
+      expect(parentFolderQuery.documentsAndFolders?.docs).toHaveLength(2)
+
+      // Verify the correct posts are returned
+      const returnedDocs = parentFolderQuery.documentsAndFolders?.docs
+      expect(returnedDocs).toHaveLength(2)
+
+      expect(returnedDocs?.some((doc) => (doc.value as any).title === 'Post 1')).toBe(true)
+      expect(returnedDocs?.some((doc) => (doc.value as any).title === 'Post 2')).toBe(true)
+    })
   })
 
   describe('hooks', () => {