@payloadcms/drizzle 3.0.0-canary.f1f97ff → 3.0.0-canary.fb04843

package/dist/queries/getTableColumnFromPath.js

@@ -2,9 +2,12 @@ import { and, eq, like, sql } from 'drizzle-orm';
 import { APIError, flattenTopLevelFields } from 'payload';
 import { fieldAffectsData, tabHasName } from 'payload/shared';
 import toSnakeCase from 'to-snake-case';
+import { validate as uuidValidate } from 'uuid';
+import { isPolymorphicRelationship } from '../utilities/isPolymorphicRelationship.js';
+import { addJoinTable } from './addJoinTable.js';
 import { getTableAlias } from './getTableAlias.js';
 /**
- * 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
  */ export const getTableColumnFromPath = ({ adapter, aliasTable, collectionPath, columnPrefix = '', constraintPath: incomingConstraintPath, constraints = [], fields, joins, locale: incomingLocale, pathSegments: incomingSegments, rootTableName: incomingRootTableName, selectFields, tableName, tableNameSuffix = '', value })=>{
@@ -40,194 +43,27 @@ import { getTableAlias } from './getTableAlias.js';
             }
         }
         switch(field.type){
-            case 'tabs':
-                {
-                    return getTableColumnFromPath({
-                        adapter,
-                        aliasTable,
-                        collectionPath,
-                        columnPrefix,
-                        constraintPath,
-                        constraints,
-                        fields: field.tabs.map((tab)=>({
-                                ...tab,
-                                type: 'tab'
-                            })),
-                        joins,
-                        locale,
-                        pathSegments: pathSegments.slice(1),
-                        rootTableName,
-                        selectFields,
-                        tableName: newTableName,
-                        tableNameSuffix,
-                        value
-                    });
-                }
-            case 'tab':
-                {
-                    if (tabHasName(field)) {
-                        return getTableColumnFromPath({
-                            adapter,
-                            aliasTable,
-                            collectionPath,
-                            columnPrefix: `${columnPrefix}${field.name}_`,
-                            constraintPath: `${constraintPath}${field.name}.`,
-                            constraints,
-                            fields: field.fields,
-                            joins,
-                            locale,
-                            pathSegments: pathSegments.slice(1),
-                            rootTableName,
-                            selectFields,
-                            tableName: newTableName,
-                            tableNameSuffix: `${tableNameSuffix}${toSnakeCase(field.name)}_`,
-                            value
-                        });
-                    }
-                    return getTableColumnFromPath({
-                        adapter,
-                        aliasTable,
-                        collectionPath,
-                        columnPrefix,
-                        constraintPath,
-                        constraints,
-                        fields: field.fields,
-                        joins,
-                        locale,
-                        pathSegments: pathSegments.slice(1),
-                        rootTableName,
-                        selectFields,
-                        tableName: newTableName,
-                        tableNameSuffix,
-                        value
-                    });
-                }
-            case 'group':
-                {
-                    if (locale && field.localized && adapter.payload.config.localization) {
-                        newTableName = `${tableName}${adapter.localesSuffix}`;
-                        joins.push({
-                            condition: eq(adapter.tables[tableName].id, adapter.tables[newTableName]._parentID),
-                            table: adapter.tables[newTableName]
-                        });
-                        if (locale !== 'all') {
-                            constraints.push({
-                                columnName: '_locale',
-                                table: adapter.tables[newTableName],
-                                value: locale
-                            });
-                        }
-                    }
-                    return getTableColumnFromPath({
-                        adapter,
-                        aliasTable,
-                        collectionPath,
-                        columnPrefix: `${columnPrefix}${field.name}_`,
-                        constraintPath: `${constraintPath}${field.name}.`,
-                        constraints,
-                        fields: field.fields,
-                        joins,
-                        locale,
-                        pathSegments: pathSegments.slice(1),
-                        rootTableName,
-                        selectFields,
-                        tableName: newTableName,
-                        tableNameSuffix: `${tableNameSuffix}${toSnakeCase(field.name)}_`,
-                        value
-                    });
-                }
-            case 'select':
-                {
-                    if (field.hasMany) {
-                        const newTableName = adapter.tableNameMap.get(`${tableName}_${tableNameSuffix}${toSnakeCase(field.name)}`);
-                        if (locale && field.localized && adapter.payload.config.localization) {
-                            joins.push({
-                                condition: and(eq(adapter.tables[tableName].id, adapter.tables[newTableName].parent), eq(adapter.tables[newTableName]._locale, locale)),
-                                table: adapter.tables[newTableName]
-                            });
-                            if (locale !== 'all') {
-                                constraints.push({
-                                    columnName: '_locale',
-                                    table: adapter.tables[newTableName],
-                                    value: locale
-                                });
-                            }
-                        } else {
-                            joins.push({
-                                condition: eq(adapter.tables[tableName].id, adapter.tables[newTableName].parent),
-                                table: adapter.tables[newTableName]
-                            });
-                        }
-                        return {
-                            columnName: 'value',
-                            constraints,
-                            field,
-                            table: adapter.tables[newTableName]
-                        };
-                    }
-                    break;
-                }
-            case 'text':
-            case 'number':
-                {
-                    if (field.hasMany) {
-                        let tableType = 'texts';
-                        let columnName = 'text';
-                        if (field.type === 'number') {
-                            tableType = 'numbers';
-                            columnName = 'number';
-                        }
-                        newTableName = `${tableName}_${tableType}`;
-                        const joinConstraints = [
-                            eq(adapter.tables[tableName].id, adapter.tables[newTableName].parent),
-                            eq(adapter.tables[newTableName].path, `${constraintPath}${field.name}`)
-                        ];
-                        if (locale && field.localized && adapter.payload.config.localization) {
-                            joins.push({
-                                condition: and(...joinConstraints, eq(adapter.tables[newTableName]._locale, locale)),
-                                table: adapter.tables[newTableName]
-                            });
-                            if (locale !== 'all') {
-                                constraints.push({
-                                    columnName: 'locale',
-                                    table: adapter.tables[newTableName],
-                                    value: locale
-                                });
-                            }
-                        } else {
-                            joins.push({
-                                condition: and(...joinConstraints),
-                                table: adapter.tables[newTableName]
-                            });
-                        }
-                        return {
-                            columnName,
-                            constraints,
-                            field,
-                            table: adapter.tables[newTableName]
-                        };
-                    }
-                    break;
-                }
             case 'array':
                 {
                     newTableName = adapter.tableNameMap.get(`${tableName}_${tableNameSuffix}${toSnakeCase(field.name)}`);
+                    const arrayParentTable = aliasTable || adapter.tables[tableName];
                     constraintPath = `${constraintPath}${field.name}.%.`;
                     if (locale && field.localized && adapter.payload.config.localization) {
-                        joins.push({
-                            condition: and(eq(adapter.tables[tableName].id, adapter.tables[newTableName]._parentID), eq(adapter.tables[newTableName]._locale, locale)),
-                            table: adapter.tables[newTableName]
-                        });
+                        const conditions = [
+                            eq(arrayParentTable.id, adapter.tables[newTableName]._parentID)
+                        ];
                         if (locale !== 'all') {
-                            constraints.push({
-                                columnName: '_locale',
-                                table: adapter.tables[newTableName],
-                                value: locale
-                            });
+                            conditions.push(eq(adapter.tables[newTableName]._locale, locale));
                         }
+                        addJoinTable({
+                            condition: and(...conditions),
+                            joins,
+                            table: adapter.tables[newTableName]
+                        });
                     } else {
-                        joins.push({
-                            condition: eq(adapter.tables[tableName].id, adapter.tables[newTableName]._parentID),
+                        addJoinTable({
+                            condition: eq(arrayParentTable.id, adapter.tables[newTableName]._parentID),
+                            joins,
                             table: adapter.tables[newTableName]
                         });
                     }
@@ -314,17 +150,16 @@ import { getTableAlias } from './getTableAlias.js';
                             ...blockSelectFields
                         };
                         if (field.localized && adapter.payload.config.localization) {
+                            const conditions = [
+                                eq((aliasTable || adapter.tables[tableName]).id, adapter.tables[newTableName]._parentID)
+                            ];
+                            if (locale !== 'all') {
+                                conditions.push(eq(adapter.tables[newTableName]._locale, locale));
+                            }
                             joins.push({
-                                condition: and(eq((aliasTable || adapter.tables[tableName]).id, adapter.tables[newTableName]._parentID), eq(adapter.tables[newTableName]._locale, locale)),
+                                condition: and(...conditions),
                                 table: adapter.tables[newTableName]
                             });
-                            if (locale) {
-                                constraints.push({
-                                    columnName: '_locale',
-                                    table: adapter.tables[newTableName],
-                                    value: locale
-                                });
-                            }
                         } else {
                             joins.push({
                                 condition: eq((aliasTable || adapter.tables[tableName]).id, adapter.tables[newTableName]._parentID),
@@ -345,11 +180,86 @@ import { getTableAlias } from './getTableAlias.js';
                     }
                     break;
                 }
+            case 'group':
+                {
+                    if (locale && field.localized && adapter.payload.config.localization) {
+                        newTableName = `${tableName}${adapter.localesSuffix}`;
+                        let condition = eq(adapter.tables[tableName].id, adapter.tables[newTableName]._parentID);
+                        if (locale !== 'all') {
+                            condition = and(condition, eq(adapter.tables[newTableName]._locale, locale));
+                        }
+                        addJoinTable({
+                            condition,
+                            joins,
+                            table: adapter.tables[newTableName]
+                        });
+                    }
+                    return getTableColumnFromPath({
+                        adapter,
+                        aliasTable,
+                        collectionPath,
+                        columnPrefix: `${columnPrefix}${field.name}_`,
+                        constraintPath: `${constraintPath}${field.name}.`,
+                        constraints,
+                        fields: field.fields,
+                        joins,
+                        locale,
+                        pathSegments: pathSegments.slice(1),
+                        rootTableName,
+                        selectFields,
+                        tableName: newTableName,
+                        tableNameSuffix: `${tableNameSuffix}${toSnakeCase(field.name)}_`,
+                        value
+                    });
+                }
+            case 'number':
+            case 'text':
+                {
+                    if (field.hasMany) {
+                        let tableType = 'texts';
+                        let columnName = 'text';
+                        if (field.type === 'number') {
+                            tableType = 'numbers';
+                            columnName = 'number';
+                        }
+                        newTableName = `${rootTableName}_${tableType}`;
+                        const joinConstraints = [
+                            eq(adapter.tables[rootTableName].id, adapter.tables[newTableName].parent),
+                            like(adapter.tables[newTableName].path, `${constraintPath}${field.name}`)
+                        ];
+                        if (locale && field.localized && adapter.payload.config.localization) {
+                            const conditions = [
+                                ...joinConstraints
+                            ];
+                            if (locale !== 'all') {
+                                conditions.push(eq(adapter.tables[newTableName]._locale, locale));
+                            }
+                            addJoinTable({
+                                condition: and(...conditions),
+                                joins,
+                                table: adapter.tables[newTableName]
+                            });
+                        } else {
+                            addJoinTable({
+                                condition: and(...joinConstraints),
+                                joins,
+                                table: adapter.tables[newTableName]
+                            });
+                        }
+                        return {
+                            columnName,
+                            constraints,
+                            field,
+                            table: adapter.tables[newTableName]
+                        };
+                    }
+                    break;
+                }
             case 'relationship':
             case 'upload':
                 {
                     const newCollectionPath = pathSegments.slice(1).join('.');
-                    if (Array.isArray(field.relationTo) || field.type === 'relationship' && field.hasMany) {
+                    if (Array.isArray(field.relationTo) || field.hasMany) {
                         let relationshipFields;
                         const relationTableName = `${rootTableName}${adapter.relationshipsSuffix}`;
                         const { newAliasTable: aliasRelationshipTable, newAliasTableName: aliasRelationshipTableName } = getTableAlias({
@@ -358,17 +268,17 @@ import { getTableAlias } from './getTableAlias.js';
                         });
                         // Join in the relationships table
                         if (locale && field.localized && adapter.payload.config.localization) {
+                            const conditions = [
+                                eq((aliasTable || adapter.tables[rootTableName]).id, aliasRelationshipTable.parent),
+                                like(aliasRelationshipTable.path, `${constraintPath}${field.name}`)
+                            ];
+                            if (locale !== 'all') {
+                                conditions.push(eq(aliasRelationshipTable.locale, locale));
+                            }
                             joins.push({
-                                condition: and(eq((aliasTable || adapter.tables[rootTableName]).id, aliasRelationshipTable.parent), eq(aliasRelationshipTable.locale, locale), like(aliasRelationshipTable.path, `${constraintPath}${field.name}`)),
+                                condition: and(...conditions),
                                 table: aliasRelationshipTable
                             });
-                            if (locale !== 'all') {
-                                constraints.push({
-                                    columnName: 'locale',
-                                    table: aliasRelationshipTable,
-                                    value: locale
-                                });
-                            }
                         } else {
                             // Join in the relationships table
                             joins.push({
@@ -400,20 +310,43 @@ import { getTableAlias } from './getTableAlias.js';
                                 };
                             }
                         } else if (newCollectionPath === 'value') {
-                            const tableColumnsNames = field.relationTo.map((relationTo)=>{
+                            const hasCustomCollectionWithCustomID = field.relationTo.some((relationTo)=>!!adapter.payload.collections[relationTo].customIDType);
+                            const columns = field.relationTo.map((relationTo)=>{
+                                let idType = adapter.idType === 'uuid' ? 'uuid' : 'number';
+                                const { customIDType } = adapter.payload.collections[relationTo];
+                                if (customIDType) {
+                                    idType = customIDType;
+                                }
+                                const idTypeTextOrUuid = idType === 'text' || idType === 'uuid';
+                                // 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' && idTypeTextOrUuid) {
+                                    return null;
+                                }
+                                if (Array.isArray(value) && value.every((val)=>typeof val === 'number') && idTypeTextOrUuid) {
+                                    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 && !Array.isArray(value) && idType === 'uuid' && hasCustomCollectionWithCustomID) {
+                                    if (!uuidValidate(value)) {
+                                        return null;
+                                    }
+                                }
+                                if (Array.isArray(value) && idType === 'uuid' && hasCustomCollectionWithCustomID && !value.some((val)=>uuidValidate(val))) {
+                                    return null;
+                                }
                                 const relationTableName = adapter.tableNameMap.get(toSnakeCase(adapter.payload.collections[relationTo].config.slug));
-                                return `"${aliasRelationshipTableName}"."${relationTableName}_id"`;
-                            });
-                            let column;
-                            if (tableColumnsNames.length === 1) {
-                                column = tableColumnsNames[0];
-                            } else {
-                                column = `COALESCE(${tableColumnsNames.join(', ')})`;
-                            }
+                                return {
+                                    idType,
+                                    rawColumn: sql.raw(`"${aliasRelationshipTableName}"."${relationTableName}_id"`)
+                                };
+                            }).filter(Boolean);
                             return {
+                                columns,
                                 constraints,
                                 field,
-                                rawColumn: sql.raw(`${column}`),
                                 table: aliasRelationshipTable
                             };
                         } else if (newCollectionPath === 'relationTo') {
@@ -425,11 +358,22 @@ import { getTableAlias } from './getTableAlias.js';
                                 field,
                                 getNotNullColumnByValue: (val)=>{
                                     const matchedRelation = relationTo.find((relation)=>relation === val);
-                                    if (matchedRelation) return `${matchedRelation}ID`;
+                                    if (matchedRelation) {
+                                        return `${matchedRelation}ID`;
+                                    }
                                     return undefined;
                                 },
                                 table: aliasRelationshipTable
                             };
+                        } else if (isPolymorphicRelationship(value)) {
+                            const { relationTo } = value;
+                            const relationTableName = adapter.tableNameMap.get(toSnakeCase(adapter.payload.collections[relationTo].config.slug));
+                            return {
+                                constraints,
+                                field,
+                                rawColumn: sql.raw(`"${aliasRelationshipTableName}"."${relationTableName}_id"`),
+                                table: aliasRelationshipTable
+                            };
                         } else {
                             throw new APIError('Not supported');
                         }
@@ -460,12 +404,20 @@ import { getTableAlias } from './getTableAlias.js';
                                 adapter,
                                 tableName: `${rootTableName}${adapter.localesSuffix}`
                             });
-                            joins.push({
-                                condition: and(eq(aliasLocaleTable._parentID, adapter.tables[rootTableName].id), eq(aliasLocaleTable._locale, locale)),
-                                table: aliasLocaleTable
+                            const condtions = [
+                                eq(aliasLocaleTable._parentID, adapter.tables[rootTableName].id)
+                            ];
+                            if (locale !== 'all') {
+                                condtions.push(eq(aliasLocaleTable._locale, locale));
+                            }
+                            const localesTable = adapter.tables[`${rootTableName}${adapter.localesSuffix}`];
+                            addJoinTable({
+                                condition: and(...condtions),
+                                joins,
+                                table: localesTable
                             });
                             joins.push({
-                                condition: eq(aliasLocaleTable[columnName], newAliasTable.id),
+                                condition: eq(localesTable[columnName], newAliasTable.id),
                                 table: newAliasTable
                             });
                         } else {
@@ -491,31 +443,126 @@ import { getTableAlias } from './getTableAlias.js';
                     }
                     break;
                 }
+            case 'select':
+                {
+                    if (field.hasMany) {
+                        const newTableName = adapter.tableNameMap.get(`${tableName}_${tableNameSuffix}${toSnakeCase(field.name)}`);
+                        if (locale && field.localized && adapter.payload.config.localization) {
+                            const conditions = [
+                                eq(adapter.tables[tableName].id, adapter.tables[newTableName].parent),
+                                eq(adapter.tables[newTableName]._locale, locale)
+                            ];
+                            if (locale !== 'all') {
+                                conditions.push(eq(adapter.tables[newTableName]._locale, locale));
+                            }
+                            addJoinTable({
+                                condition: and(...conditions),
+                                joins,
+                                table: adapter.tables[newTableName]
+                            });
+                        } else {
+                            addJoinTable({
+                                condition: eq(adapter.tables[tableName].id, adapter.tables[newTableName].parent),
+                                joins,
+                                table: adapter.tables[newTableName]
+                            });
+                        }
+                        return {
+                            columnName: 'value',
+                            constraints,
+                            field,
+                            table: adapter.tables[newTableName]
+                        };
+                    }
+                    break;
+                }
+            case 'tab':
+                {
+                    if (tabHasName(field)) {
+                        return getTableColumnFromPath({
+                            adapter,
+                            aliasTable,
+                            collectionPath,
+                            columnPrefix: `${columnPrefix}${field.name}_`,
+                            constraintPath: `${constraintPath}${field.name}.`,
+                            constraints,
+                            fields: field.fields,
+                            joins,
+                            locale,
+                            pathSegments: pathSegments.slice(1),
+                            rootTableName,
+                            selectFields,
+                            tableName: newTableName,
+                            tableNameSuffix: `${tableNameSuffix}${toSnakeCase(field.name)}_`,
+                            value
+                        });
+                    }
+                    return getTableColumnFromPath({
+                        adapter,
+                        aliasTable,
+                        collectionPath,
+                        columnPrefix,
+                        constraintPath,
+                        constraints,
+                        fields: field.fields,
+                        joins,
+                        locale,
+                        pathSegments: pathSegments.slice(1),
+                        rootTableName,
+                        selectFields,
+                        tableName: newTableName,
+                        tableNameSuffix,
+                        value
+                    });
+                }
+            case 'tabs':
+                {
+                    return getTableColumnFromPath({
+                        adapter,
+                        aliasTable,
+                        collectionPath,
+                        columnPrefix,
+                        constraintPath,
+                        constraints,
+                        fields: field.tabs.map((tab)=>({
+                                ...tab,
+                                type: 'tab'
+                            })),
+                        joins,
+                        locale,
+                        pathSegments: pathSegments.slice(1),
+                        rootTableName,
+                        selectFields,
+                        tableName: newTableName,
+                        tableNameSuffix,
+                        value
+                    });
+                }
             default:
                 {
                     break;
                 }
         }
         if (fieldAffectsData(field)) {
+            let newTable = adapter.tables[newTableName];
             if (field.localized && adapter.payload.config.localization) {
                 // If localized, we go to localized table and set aliasTable to undefined
                 // so it is not picked up below to be used as targetTable
                 const parentTable = aliasTable || adapter.tables[tableName];
                 newTableName = `${tableName}${adapter.localesSuffix}`;
-                joins.push({
-                    condition: eq(parentTable.id, adapter.tables[newTableName]._parentID),
-                    table: adapter.tables[newTableName]
-                });
-                aliasTable = undefined;
+                newTable = adapter.tables[newTableName];
+                let condition = eq(parentTable.id, newTable._parentID);
                 if (locale !== 'all') {
-                    constraints.push({
-                        columnName: '_locale',
-                        table: adapter.tables[newTableName],
-                        value: locale
-                    });
+                    condition = and(condition, eq(newTable._locale, locale));
                 }
+                addJoinTable({
+                    condition,
+                    joins,
+                    table: newTable
+                });
+                aliasTable = undefined;
             }
-            const targetTable = aliasTable || adapter.tables[newTableName];
+            const targetTable = aliasTable || newTable;
             selectFields[`${newTableName}.${columnPrefix}${field.name}`] = targetTable[`${columnPrefix}${field.name}`];
             return {
                 columnName: `${columnPrefix}${field.name}`,