@payloadcms/db-postgres 3.0.0-beta.5 → 3.0.0-beta.50

package/dist/queries/getTableColumnFromPath.js

@@ -1,16 +1,14 @@
 /* eslint-disable no-param-reassign */ import { and, eq, like, sql } from 'drizzle-orm';
 import { alias } from 'drizzle-orm/pg-core';
-import { APIError } from 'payload/errors';
-import { fieldAffectsData, tabHasName } from 'payload/types';
-import { flattenTopLevelFields } from 'payload/utilities';
+import { APIError, flattenTopLevelFields } from 'payload';
+import { fieldAffectsData, tabHasName } from 'payload/shared';
 import toSnakeCase from 'to-snake-case';
 import { v4 as uuid } from 'uuid';
-import { getTableName } from '../schema/getTableName.js';
 /**
  * Transforms path to table and column name
  * Adds tables to `join`
  * @returns TableColumn
- */ export const getTableColumnFromPath = ({ adapter, aliasTable, collectionPath, columnPrefix = '', constraintPath: incomingConstraintPath, constraints = [], fields, joinAliases, joins, locale: incomingLocale, pathSegments: incomingSegments, rootTableName: incomingRootTableName, selectFields, tableName, tableNameSuffix = '', value })=>{
+ */ export const getTableColumnFromPath = ({ adapter, aliasTable, collectionPath, columnPrefix = '', constraintPath: incomingConstraintPath, constraints = [], fields, joins, locale: incomingLocale, pathSegments: incomingSegments, rootTableName: incomingRootTableName, selectFields, tableName, tableNameSuffix = '', value })=>{
     const fieldPath = incomingSegments[0];
     let locale = incomingLocale;
     const rootTableName = incomingRootTableName || tableName;
@@ -56,7 +54,6 @@ import { getTableName } from '../schema/getTableName.js';
                                 ...tab,
                                 type: 'tab'
                             })),
-                        joinAliases,
                         joins,
                         locale,
                         pathSegments: pathSegments.slice(1),
@@ -78,7 +75,6 @@ import { getTableName } from '../schema/getTableName.js';
                             constraintPath: `${constraintPath}${field.name}.`,
                             constraints,
                             fields: field.fields,
-                            joinAliases,
                             joins,
                             locale,
                             pathSegments: pathSegments.slice(1),
@@ -97,7 +93,6 @@ import { getTableName } from '../schema/getTableName.js';
                         constraintPath,
                         constraints,
                         fields: field.fields,
-                        joinAliases,
                         joins,
                         locale,
                         pathSegments: pathSegments.slice(1),
@@ -111,14 +106,11 @@ import { getTableName } from '../schema/getTableName.js';
             case 'group':
                 {
                     if (locale && field.localized && adapter.payload.config.localization) {
-                        newTableName = getTableName({
-                            adapter,
-                            config: field,
-                            locales: true,
-                            parentTableName: tableName,
-                            prefix: `${tableName}_`
+                        newTableName = `${tableName}${adapter.localesSuffix}`;
+                        joins.push({
+                            condition: eq(adapter.tables[tableName].id, adapter.tables[newTableName]._parentID),
+                            table: adapter.tables[newTableName]
                         });
-                        joins[tableName] = eq(adapter.tables[tableName].id, adapter.tables[newTableName]._parentID);
                         if (locale !== 'all') {
                             constraints.push({
                                 columnName: '_locale',
@@ -135,7 +127,6 @@ import { getTableName } from '../schema/getTableName.js';
                         constraintPath: `${constraintPath}${field.name}.`,
                         constraints,
                         fields: field.fields,
-                        joinAliases,
                         joins,
                         locale,
                         pathSegments: pathSegments.slice(1),
@@ -146,17 +137,88 @@ import { getTableName } from '../schema/getTableName.js';
                         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 = getTableName({
-                        adapter,
-                        config: field,
-                        parentTableName: `${tableName}_${tableNameSuffix}`,
-                        prefix: `${tableName}_${tableNameSuffix}`
-                    });
+                    newTableName = adapter.tableNameMap.get(`${tableName}_${tableNameSuffix}${toSnakeCase(field.name)}`);
                     constraintPath = `${constraintPath}${field.name}.%.`;
                     if (locale && field.localized && adapter.payload.config.localization) {
-                        joins[newTableName] = and(eq(adapter.tables[tableName].id, adapter.tables[newTableName]._parentID), eq(adapter.tables[newTableName]._locale, locale));
+                        joins.push({
+                            condition: and(eq(adapter.tables[tableName].id, adapter.tables[newTableName]._parentID), eq(adapter.tables[newTableName]._locale, locale)),
+                            table: adapter.tables[newTableName]
+                        });
                         if (locale !== 'all') {
                             constraints.push({
                                 columnName: '_locale',
@@ -165,7 +227,10 @@ import { getTableName } from '../schema/getTableName.js';
                             });
                         }
                     } else {
-                        joins[newTableName] = eq(adapter.tables[tableName].id, adapter.tables[newTableName]._parentID);
+                        joins.push({
+                            condition: eq(adapter.tables[tableName].id, adapter.tables[newTableName]._parentID),
+                            table: adapter.tables[newTableName]
+                        });
                     }
                     return getTableColumnFromPath({
                         adapter,
@@ -173,7 +238,6 @@ import { getTableName } from '../schema/getTableName.js';
                         constraintPath,
                         constraints,
                         fields: field.fields,
-                        joinAliases,
                         joins,
                         locale,
                         pathSegments: pathSegments.slice(1),
@@ -195,16 +259,16 @@ import { getTableName } from '../schema/getTableName.js';
                         ];
                         blockTypes.forEach((blockType)=>{
                             const block = field.blocks.find((block)=>block.slug === blockType);
-                            newTableName = getTableName({
-                                adapter,
-                                config: block,
-                                parentTableName: tableName,
-                                prefix: `${tableName}_blocks_`
+                            newTableName = adapter.tableNameMap.get(`${tableName}_blocks_${toSnakeCase(block.slug)}`);
+                            const newAliasTableName = toSnakeCase(uuid());
+                            const newAliasTable = alias(adapter.tables[newTableName], newAliasTableName);
+                            joins.push({
+                                condition: eq(adapter.tables[tableName].id, newAliasTable._parentID),
+                                table: newAliasTable
                             });
-                            joins[newTableName] = eq(adapter.tables[tableName].id, adapter.tables[newTableName]._parentID);
                             constraints.push({
                                 columnName: '_path',
-                                table: adapter.tables[newTableName],
+                                table: newAliasTable,
                                 value: pathSegments[0]
                             });
                         });
@@ -216,12 +280,7 @@ import { getTableName } from '../schema/getTableName.js';
                         };
                     }
                     const hasBlockField = field.blocks.some((block)=>{
-                        newTableName = getTableName({
-                            adapter,
-                            config: block,
-                            parentTableName: tableName,
-                            prefix: `${tableName}_blocks_`
-                        });
+                        newTableName = adapter.tableNameMap.get(`${tableName}_blocks_${toSnakeCase(block.slug)}`);
                         constraintPath = `${constraintPath}${field.name}.%.`;
                         let result;
                         const blockConstraints = [];
@@ -233,7 +292,6 @@ import { getTableName } from '../schema/getTableName.js';
                                 constraintPath,
                                 constraints: blockConstraints,
                                 fields: block.fields,
-                                joinAliases,
                                 joins,
                                 locale,
                                 pathSegments: pathSegments.slice(1),
@@ -255,7 +313,10 @@ import { getTableName } from '../schema/getTableName.js';
                             ...blockSelectFields
                         };
                         if (field.localized && adapter.payload.config.localization) {
-                            joins[newTableName] = and(eq(adapter.tables[tableName].id, adapter.tables[newTableName]._parentID), 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)),
+                                table: adapter.tables[newTableName]
+                            });
                             if (locale) {
                                 constraints.push({
                                     columnName: '_locale',
@@ -264,7 +325,10 @@ import { getTableName } from '../schema/getTableName.js';
                                 });
                             }
                         } else {
-                            joins[newTableName] = eq(adapter.tables[tableName].id, adapter.tables[newTableName]._parentID);
+                            joins.push({
+                                condition: eq((aliasTable || adapter.tables[tableName]).id, adapter.tables[newTableName]._parentID),
+                                table: adapter.tables[newTableName]
+                            });
                         }
                         return true;
                     });
@@ -283,128 +347,168 @@ import { getTableName } from '../schema/getTableName.js';
             case 'relationship':
             case 'upload':
                 {
-                    let relationshipFields;
-                    const relationTableName = `${rootTableName}${adapter.relationshipsSuffix}`;
                     const newCollectionPath = pathSegments.slice(1).join('.');
-                    const aliasRelationshipTableName = uuid();
-                    const aliasRelationshipTable = alias(adapter.tables[relationTableName], aliasRelationshipTableName);
-                    // Join in the relationships table
-                    if (locale && field.localized && adapter.payload.config.localization) {
-                        joinAliases.push({
-                            condition: and(eq((aliasTable || adapter.tables[rootTableName]).id, aliasRelationshipTable.parent), eq(aliasRelationshipTable.locale, locale), like(aliasRelationshipTable.path, `${constraintPath}${field.name}`)),
-                            table: aliasRelationshipTable
-                        });
-                        if (locale !== 'all') {
-                            constraints.push({
-                                columnName: 'locale',
-                                table: aliasRelationshipTable,
-                                value: locale
+                    if (Array.isArray(field.relationTo) || field.type === 'relationship' && field.hasMany) {
+                        let relationshipFields;
+                        const relationTableName = `${rootTableName}${adapter.relationshipsSuffix}`;
+                        const aliasRelationshipTableName = uuid();
+                        const aliasRelationshipTable = alias(adapter.tables[relationTableName], aliasRelationshipTableName);
+                        // Join in the relationships table
+                        if (locale && field.localized && adapter.payload.config.localization) {
+                            joins.push({
+                                condition: and(eq((aliasTable || adapter.tables[rootTableName]).id, aliasRelationshipTable.parent), eq(aliasRelationshipTable.locale, locale), like(aliasRelationshipTable.path, `${constraintPath}${field.name}`)),
+                                table: aliasRelationshipTable
+                            });
+                            if (locale !== 'all') {
+                                constraints.push({
+                                    columnName: 'locale',
+                                    table: aliasRelationshipTable,
+                                    value: locale
+                                });
+                            }
+                        } else {
+                            // Join in the relationships table
+                            joins.push({
+                                condition: and(eq((aliasTable || adapter.tables[rootTableName]).id, aliasRelationshipTable.parent), like(aliasRelationshipTable.path, `${constraintPath}${field.name}`)),
+                                table: aliasRelationshipTable
                             });
                         }
-                    } else {
-                        // Join in the relationships table
-                        joinAliases.push({
-                            condition: and(eq((aliasTable || adapter.tables[rootTableName]).id, aliasRelationshipTable.parent), like(aliasRelationshipTable.path, `${constraintPath}${field.name}`)),
-                            table: aliasRelationshipTable
-                        });
-                    }
-                    selectFields[`${relationTableName}.path`] = aliasRelationshipTable.path;
-                    let newAliasTable;
-                    if (typeof field.relationTo === 'string') {
-                        const relationshipConfig = adapter.payload.collections[field.relationTo].config;
-                        newTableName = getTableName({
-                            adapter,
-                            config: relationshipConfig
-                        });
-                        // parent to relationship join table
-                        relationshipFields = relationshipConfig.fields;
-                        newAliasTable = alias(adapter.tables[newTableName], toSnakeCase(uuid()));
-                        joinAliases.push({
-                            condition: eq(newAliasTable.id, aliasRelationshipTable[`${field.relationTo}ID`]),
-                            table: newAliasTable
-                        });
-                        if (newCollectionPath === '' || newCollectionPath === 'id') {
+                        selectFields[`${relationTableName}.path`] = aliasRelationshipTable.path;
+                        let newAliasTable;
+                        if (typeof field.relationTo === 'string') {
+                            const relationshipConfig = adapter.payload.collections[field.relationTo].config;
+                            newTableName = adapter.tableNameMap.get(toSnakeCase(relationshipConfig.slug));
+                            // parent to relationship join table
+                            relationshipFields = relationshipConfig.fields;
+                            newAliasTable = alias(adapter.tables[newTableName], toSnakeCase(uuid()));
+                            joins.push({
+                                condition: eq(newAliasTable.id, aliasRelationshipTable[`${field.relationTo}ID`]),
+                                table: newAliasTable
+                            });
+                            if (newCollectionPath === '' || newCollectionPath === 'id') {
+                                return {
+                                    columnName: `${field.relationTo}ID`,
+                                    constraints,
+                                    field,
+                                    table: aliasRelationshipTable
+                                };
+                            }
+                        } else if (newCollectionPath === 'value') {
+                            const tableColumnsNames = field.relationTo.map((relationTo)=>{
+                                const relationTableName = adapter.tableNameMap.get(toSnakeCase(adapter.payload.collections[relationTo].config.slug));
+                                return `"${aliasRelationshipTableName}"."${relationTableName}_id"`;
+                            });
                             return {
-                                columnName: `${field.relationTo}ID`,
                                 constraints,
                                 field,
+                                rawColumn: sql.raw(`COALESCE(${tableColumnsNames.join(', ')})`),
                                 table: aliasRelationshipTable
                             };
+                        } else if (newCollectionPath === 'relationTo') {
+                            const relationTo = Array.isArray(field.relationTo) ? field.relationTo : [
+                                field.relationTo
+                            ];
+                            return {
+                                constraints,
+                                field,
+                                getNotNullColumnByValue: (val)=>{
+                                    const matchedRelation = relationTo.find((relation)=>relation === val);
+                                    if (matchedRelation) return `${matchedRelation}ID`;
+                                    return undefined;
+                                },
+                                table: aliasRelationshipTable
+                            };
+                        } else {
+                            throw new APIError('Not supported');
                         }
-                    } else if (newCollectionPath === 'value') {
-                        const tableColumnsNames = field.relationTo.map((relationTo)=>`"${aliasRelationshipTableName}"."${getTableName({
-                                adapter,
-                                config: adapter.payload.collections[relationTo].config
-                            })}_id"`);
-                        return {
+                        return getTableColumnFromPath({
+                            adapter,
+                            aliasTable: newAliasTable,
+                            collectionPath: newCollectionPath,
                             constraints,
-                            field,
-                            rawColumn: sql.raw(`COALESCE(${tableColumnsNames.join(', ')})`),
-                            table: aliasRelationshipTable
-                        };
-                    } else if (newCollectionPath === 'relationTo') {
-                        const relationTo = Array.isArray(field.relationTo) ? field.relationTo : [
-                            field.relationTo
-                        ];
-                        return {
+                            fields: relationshipFields,
+                            joins,
+                            locale,
+                            pathSegments: pathSegments.slice(1),
+                            rootTableName: newTableName,
+                            selectFields,
+                            tableName: newTableName,
+                            value
+                        });
+                    } else if (pathSegments.length > 1 && !(pathSegments.length === 2 && pathSegments[1] === 'id')) {
+                        // simple relationships
+                        const columnName = `${columnPrefix}${field.name}`;
+                        const newTableName = adapter.tableNameMap.get(toSnakeCase(adapter.payload.collections[field.relationTo].config.slug));
+                        const aliasTableName = uuid();
+                        const newAliasTable = alias(adapter.tables[newTableName], aliasTableName);
+                        if (field.localized && adapter.payload.config.localization) {
+                            const aliasLocaleTableName = uuid();
+                            const aliasLocaleTable = alias(adapter.tables[`${rootTableName}${adapter.localesSuffix}`], aliasLocaleTableName);
+                            joins.push({
+                                condition: and(eq(aliasLocaleTable._parentID, adapter.tables[rootTableName].id), eq(aliasLocaleTable._locale, locale)),
+                                table: aliasLocaleTable
+                            });
+                            joins.push({
+                                condition: eq(aliasLocaleTable[columnName], newAliasTable.id),
+                                table: newAliasTable
+                            });
+                        } else {
+                            joins.push({
+                                condition: eq(newAliasTable.id, aliasTable ? aliasTable[columnName] : adapter.tables[tableName][columnName]),
+                                table: newAliasTable
+                            });
+                        }
+                        return getTableColumnFromPath({
+                            adapter,
+                            aliasTable: newAliasTable,
+                            collectionPath: newCollectionPath,
+                            constraintPath: '',
                             constraints,
-                            field,
-                            getNotNullColumnByValue: (val)=>{
-                                const matchedRelation = relationTo.find((relation)=>relation === val);
-                                if (matchedRelation) return `${matchedRelation}ID`;
-                                return undefined;
-                            },
-                            table: aliasRelationshipTable
-                        };
-                    } else {
-                        throw new APIError('Not supported');
+                            fields: adapter.payload.collections[field.relationTo].config.fields,
+                            joins,
+                            locale,
+                            pathSegments: pathSegments.slice(1),
+                            selectFields,
+                            tableName: newTableName,
+                            value
+                        });
                     }
-                    return getTableColumnFromPath({
-                        adapter,
-                        aliasTable: newAliasTable,
-                        collectionPath: newCollectionPath,
-                        constraints,
-                        fields: relationshipFields,
-                        joinAliases,
-                        joins,
-                        locale,
-                        pathSegments: pathSegments.slice(1),
-                        rootTableName: newTableName,
-                        selectFields,
-                        tableName: newTableName,
-                        value
-                    });
+                    break;
                 }
             default:
                 {
-                    if (fieldAffectsData(field)) {
-                        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
-                            newTableName = `${tableName}${adapter.localesSuffix}`;
-                            const parentTable = aliasTable || adapter.tables[tableName];
-                            joins[newTableName] = eq(parentTable.id, adapter.tables[newTableName]._parentID);
-                            aliasTable = undefined;
-                            if (locale !== 'all') {
-                                constraints.push({
-                                    columnName: '_locale',
-                                    table: adapter.tables[newTableName],
-                                    value: locale
-                                });
-                            }
-                        }
-                        const targetTable = aliasTable || adapter.tables[newTableName];
-                        selectFields[`${newTableName}.${columnPrefix}${field.name}`] = targetTable[`${columnPrefix}${field.name}`];
-                        return {
-                            columnName: `${columnPrefix}${field.name}`,
-                            constraints,
-                            field,
-                            pathSegments,
-                            table: targetTable
-                        };
-                    }
+                    break;
                 }
         }
+        if (fieldAffectsData(field)) {
+            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;
+                if (locale !== 'all') {
+                    constraints.push({
+                        columnName: '_locale',
+                        table: adapter.tables[newTableName],
+                        value: locale
+                    });
+                }
+            }
+            const targetTable = aliasTable || adapter.tables[newTableName];
+            selectFields[`${newTableName}.${columnPrefix}${field.name}`] = targetTable[`${columnPrefix}${field.name}`];
+            return {
+                columnName: `${columnPrefix}${field.name}`,
+                constraints,
+                field,
+                pathSegments,
+                table: targetTable
+            };
+        }
     }
     throw new APIError(`Cannot find field for path at ${fieldPath}`);
 };