fix(drizzle): polymorphic querying of different ID types (#8191)

This PR fixes querying by a relationship field that has custom IDs in
`relationTo` with different types.
Now, in this case, we do cast the ID value in the database.

Example of the config / int test that reproduced the issue:

```ts
{
  slug: 'posts-a',
  fields: [],
},
{
  slug: 'posts-b',
  fields: [],
},
{
  slug: 'posts-custom-id',
  fields: [{ name: 'id', type: 'text' }],
},
{
  slug: 'roots',
  fields: [
    {
      name: 'rel',
      relationTo: ['posts-a', 'posts-b', 'posts-custom-id'],
      type: 'relationship',
    },
  ],
},
```

```ts
const postA = await payload.create({ collection: 'posts-a', data: {} })
const postB = await payload.create({ collection: 'posts-b', data: {} })
const postC = await payload.create({
  collection: 'posts-custom-id',
  data: { id: crypto.randomUUID() },
})

const root_1 = await payload.create({
  collection: 'roots',
  data: {
    rel: {
      value: postC.id,
      relationTo: 'posts-custom-id',
    },
  },
})

const res_1 = await payload.find({
  collection: 'roots',
  where: {
    'rel.value': { equals: postC.id },
  },
})

// COALESCE types integer and character varying cannot be matched

expect(res_1.totalDocs).toBe(1)
```

<!--

For external contributors, please include:

- A summary of the pull request and any related issues it fixes.
- Reasoning for the changes made or any additional context that may be
useful.

Ensure you have read and understand the
[CONTRIBUTING.md](https://github.com/payloadcms/payload/blob/main/CONTRIBUTING.md)
document in this repository.

 -->

Author: r1tsuu

packages/drizzle/src/queries/getTableColumnFromPath.ts

@@ -1,12 +1,13 @@
 import type { SQL } from 'drizzle-orm'
-import type { PgTableWithColumns } from 'drizzle-orm/pg-core'
 import type { SQLiteTableWithColumns } from 'drizzle-orm/sqlite-core'
 import type { Field, FieldAffectingData, NumberField, TabAsField, TextField } from 'payload'
 
 import { and, eq, like, sql } from 'drizzle-orm'
+import { type PgTableWithColumns } from 'drizzle-orm/pg-core'
 import { APIError, flattenTopLevelFields } from 'payload'
 import { fieldAffectsData, tabHasName } from 'payload/shared'
 import toSnakeCase from 'to-snake-case'
+import { validate as uuidValidate } from 'uuid'
 
 import type { DrizzleAdapter, GenericColumn } from '../types.js'
 import type { BuildQueryJoinAliases } from './buildQuery.js'
@@ -21,6 +22,10 @@ type Constraint = {
 
 type TableColumn = {
   columnName?: string
+  columns?: {
+    idType: 'number' | 'text'
+    rawColumn: SQL<unknown>
+  }[]
   constraints: Constraint[]
   field: FieldAffectingData
   getNotNullColumnByValue?: (val: unknown) => string
@@ -53,7 +58,7 @@ type Args = {
   value: unknown
 }
 /**
- * Transforms path to table and column name
+ * Transforms path to table and column name or to a list of OR columns
  * Adds tables to `join`
  * @returns TableColumn
  */
@@ -510,25 +515,55 @@ export const getTableColumnFromPath = ({
               }
             }
           } else if (newCollectionPath === 'value') {
-            const tableColumnsNames = field.relationTo.map((relationTo) => {
-              const relationTableName = adapter.tableNameMap.get(
-                toSnakeCase(adapter.payload.collections[relationTo].config.slug),
-              )
+            const hasCustomCollectionWithCustomID = field.relationTo.some(
+              (relationTo) => !!adapter.payload.collections[relationTo].customIDType,
+            )
 
-              return `"${aliasRelationshipTableName}"."${relationTableName}_id"`
-            })
+            const columns: TableColumn['columns'] = field.relationTo
+              .map((relationTo) => {
+                let idType: 'number' | 'text' = adapter.idType === 'uuid' ? 'text' : 'number'
 
-            let column: string
-            if (tableColumnsNames.length === 1) {
-              column = tableColumnsNames[0]
-            } else {
-              column = `COALESCE(${tableColumnsNames.join(', ')})`
-            }
+                const { customIDType } = adapter.payload.collections[relationTo]
+
+                if (customIDType) {
+                  idType = customIDType
+                }
+
+                // Do not add the column to OR if we know that it can't match by the type
+                // We can't do the same with idType: 'number' because `value` can be from the REST search query params
+                if (typeof value === 'number' && idType === 'text') {
+                  return null
+                }
+
+                // Do not add the UUID type column if incoming query value doesn't match UUID. If there aren't any collections with
+                // a custom ID type, we skip this check
+                // We need this because Postgres throws an error if querying by UUID column with a value that isn't a valid UUID.
+                if (
+                  value &&
+                  !customIDType &&
+                  adapter.idType === 'uuid' &&
+                  hasCustomCollectionWithCustomID
+                ) {
+                  if (!uuidValidate(value)) {
+                    return null
+                  }
+                }
+
+                const relationTableName = adapter.tableNameMap.get(
+                  toSnakeCase(adapter.payload.collections[relationTo].config.slug),
+                )
+
+                return {
+                  idType,
+                  rawColumn: sql.raw(`"${aliasRelationshipTableName}"."${relationTableName}_id"`),
+                }
+              })
+              .filter(Boolean)
 
             return {
+              columns,
               constraints,
               field,
-              rawColumn: sql.raw(`${column}`),
               table: aliasRelationshipTable,
             }
           } else if (newCollectionPath === 'relationTo') {

packages/drizzle/src/queries/parseParams.ts

@@ -67,8 +67,10 @@ export async function parseParams({
             for (let operator of Object.keys(pathOperators)) {
               if (validOperators.includes(operator as Operator)) {
                 const val = where[relationOrPath][operator]
+
                 const {
                   columnName,
+                  columns,
                   constraints: queryConstraints,
                   field,
                   getNotNullColumnByValue,
@@ -190,6 +192,7 @@ export async function parseParams({
 
                 const sanitizedQueryValue = sanitizeQueryValue({
                   adapter,
+                  columns,
                   field,
                   operator,
                   relationOrPath,
@@ -200,7 +203,49 @@ export async function parseParams({
                   break
                 }
 
-                const { operator: queryOperator, value: queryValue } = sanitizedQueryValue
+                const {
+                  columns: queryColumns,
+                  operator: queryOperator,
+                  value: queryValue,
+                } = sanitizedQueryValue
+
+                // Handle polymorphic relationships by value
+                if (queryColumns) {
+                  if (!queryColumns.length) {
+                    break
+                  }
+
+                  let wrapOperator = or
+
+                  if (queryValue === null && ['equals', 'not_equals'].includes(operator)) {
+                    if (operator === 'equals') {
+                      wrapOperator = and
+                    }
+
+                    constraints.push(
+                      wrapOperator(
+                        ...queryColumns.map(({ rawColumn }) =>
+                          operator === 'equals' ? isNull(rawColumn) : isNotNull(rawColumn),
+                        ),
+                      ),
+                    )
+                    break
+                  }
+
+                  if (['not_equals', 'not_in'].includes(operator)) {
+                    wrapOperator = and
+                  }
+
+                  constraints.push(
+                    wrapOperator(
+                      ...queryColumns.map(({ rawColumn, value }) =>
+                        adapter.operators[queryOperator](rawColumn, value),
+                      ),
+                    ),
+                  )
+
+                  break
+                }
 
                 if (queryOperator === 'not_equals' && queryValue !== null) {
                   constraints.push(

packages/drizzle/src/queries/sanitizeQueryValue.ts

@@ -1,25 +1,42 @@
+import type { SQL } from 'drizzle-orm'
+
 import { APIError, createArrayFromCommaDelineated, type Field, type TabAsField } from 'payload'
 import { fieldAffectsData } from 'payload/shared'
 
 import type { DrizzleAdapter } from '../types.js'
 
 type SanitizeQueryValueArgs = {
   adapter: DrizzleAdapter
+  columns?: {
+    idType: 'number' | 'text'
+    rawColumn: SQL<unknown>
+  }[]
   field: Field | TabAsField
   operator: string
   relationOrPath: string
   val: any
 }
 
+type SanitizedColumn = {
+  rawColumn: SQL<unknown>
+  value: unknown
+}
+
 export const sanitizeQueryValue = ({
   adapter,
+  columns,
   field,
   operator: operatorArg,
   relationOrPath,
   val,
-}: SanitizeQueryValueArgs): { operator: string; value: unknown } => {
+}: SanitizeQueryValueArgs): {
+  columns?: SanitizedColumn[]
+  operator: string
+  value: unknown
+} => {
   let operator = operatorArg
   let formattedValue = val
+  let formattedColumns: SanitizedColumn[]
 
   if (!fieldAffectsData(field)) {
     return { operator, value: formattedValue }
@@ -100,10 +117,26 @@ export const sanitizeQueryValue = ({
         }
         idType = typeMap[mixedType]
       } else {
-        // LIMITATION: Only cast to the first relationTo id type,
-        // otherwise we need to make the db cast which is inefficient
-        const collection = adapter.payload.collections[field.relationTo[0]]
-        idType = collection.customIDType || adapter.idType === 'uuid' ? 'text' : 'number'
+        formattedColumns = columns
+          .map(({ idType, rawColumn }) => {
+            let formattedValue: number | string
+            if (idType === 'number') {
+              formattedValue = Number(val)
+
+              if (Number.isNaN(formattedValue)) {
+                return null
+              }
+            }
+            if (idType === 'text') {
+              formattedValue = String(val)
+            }
+
+            return {
+              rawColumn,
+              value: formattedValue,
+            }
+          })
+          .filter(Boolean)
       }
       if (Array.isArray(formattedValue)) {
         formattedValue = formattedValue.map((value) => {
@@ -147,5 +180,9 @@ export const sanitizeQueryValue = ({
     }
   }
 
-  return { operator, value: formattedValue }
+  return {
+    columns: formattedColumns,
+    operator,
+    value: formattedValue,
+  }
 }

test/collections-rest/int.spec.ts

@@ -33,7 +33,9 @@ describe('collections-rest', () => {
     if (payload.db.name === 'mongoose') {
       await new Promise((resolve, reject) => {
         payload.db.collections[pointSlug].ensureIndexes(function (err) {
-          if (err) reject(err)
+          if (err) {
+            reject(err)
+          }
           resolve(true)
         })
       })

test/databaseAdapter.ts

@@ -1,16 +1,13 @@
+// DO NOT MODIFY. This file is automatically generated in initDevAndTest.ts
 
-  // DO NOT MODIFY. This file is automatically generated in initDevAndTest.ts
+import { mongooseAdapter } from '@payloadcms/db-mongodb'
 
-  
-  import { mongooseAdapter } from '@payloadcms/db-mongodb'
-
-  export const databaseAdapter = mongooseAdapter({
-    url:
-      process.env.MONGODB_MEMORY_SERVER_URI ||
-      process.env.DATABASE_URI ||
-      'mongodb://127.0.0.1/payloadtests',
-    collation: {
-      strength: 1,
-    },
-  })
-  
+export const databaseAdapter = mongooseAdapter({
+  url:
+    process.env.MONGODB_MEMORY_SERVER_URI ||
+    process.env.DATABASE_URI ||
+    'mongodb://127.0.0.1/payloadtests',
+  collation: {
+    strength: 1,
+  },
+})

test/relationships/config.ts

@@ -315,6 +315,16 @@ export default buildConfigWithDefaults({
         },
       ],
     },
+    {
+      slug: 'rels-to-pages-and-custom-text-ids',
+      fields: [
+        {
+          name: 'rel',
+          type: 'relationship',
+          relationTo: ['pages', 'custom-id', 'custom-id-number'],
+        },
+      ],
+    },
   ],
   onInit: async (payload) => {
     await payload.create({