@payloadcms/db-postgres 3.0.0-beta.11 → 3.0.0-beta.111

package/dist/queries/getTableColumnFromPath.js

@@ -1,412 +0,0 @@
-/* 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 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 })=>{
-    const fieldPath = incomingSegments[0];
-    let locale = incomingLocale;
-    const rootTableName = incomingRootTableName || tableName;
-    let constraintPath = incomingConstraintPath || '';
-    const field = flattenTopLevelFields(fields).find((fieldToFind)=>fieldAffectsData(fieldToFind) && fieldToFind.name === fieldPath);
-    let newTableName = tableName;
-    if (!field && fieldPath === 'id') {
-        selectFields.id = adapter.tables[newTableName].id;
-        return {
-            columnName: 'id',
-            constraints,
-            field: {
-                name: 'id',
-                type: adapter.idType === 'uuid' ? 'text' : 'number'
-            },
-            table: adapter.tables[newTableName]
-        };
-    }
-    if (field) {
-        const pathSegments = [
-            ...incomingSegments
-        ];
-        // If next segment is a locale,
-        // we need to take it out and use it as the locale from this point on
-        if ('localized' in field && field.localized && adapter.payload.config.localization) {
-            const matchedLocale = adapter.payload.config.localization.localeCodes.find((locale)=>locale === pathSegments[1]);
-            if (matchedLocale) {
-                locale = matchedLocale;
-                pathSegments.splice(1, 1);
-            }
-        }
-        switch(field.type){
-            case 'tabs':
-                {
-                    return getTableColumnFromPath({
-                        adapter,
-                        aliasTable,
-                        collectionPath,
-                        columnPrefix,
-                        constraintPath,
-                        constraints,
-                        fields: field.tabs.map((tab)=>({
-                                ...tab,
-                                type: 'tab'
-                            })),
-                        joinAliases,
-                        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,
-                            joinAliases,
-                            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,
-                        joinAliases,
-                        joins,
-                        locale,
-                        pathSegments: pathSegments.slice(1),
-                        rootTableName,
-                        selectFields,
-                        tableName: newTableName,
-                        tableNameSuffix,
-                        value
-                    });
-                }
-            case 'group':
-                {
-                    if (locale && field.localized && adapter.payload.config.localization) {
-                        newTableName = getTableName({
-                            adapter,
-                            config: field,
-                            locales: true,
-                            parentTableName: tableName,
-                            prefix: `${tableName}_`
-                        });
-                        joins[tableName] = eq(adapter.tables[tableName].id, adapter.tables[newTableName]._parentID);
-                        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,
-                        joinAliases,
-                        joins,
-                        locale,
-                        pathSegments: pathSegments.slice(1),
-                        rootTableName,
-                        selectFields,
-                        tableName: newTableName,
-                        tableNameSuffix: `${tableNameSuffix}${toSnakeCase(field.name)}_`,
-                        value
-                    });
-                }
-            case 'array':
-                {
-                    newTableName = getTableName({
-                        adapter,
-                        config: field,
-                        parentTableName: `${tableName}_${tableNameSuffix}`,
-                        prefix: `${tableName}_${tableNameSuffix}`
-                    });
-                    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));
-                        if (locale !== 'all') {
-                            constraints.push({
-                                columnName: '_locale',
-                                table: adapter.tables[newTableName],
-                                value: locale
-                            });
-                        }
-                    } else {
-                        joins[newTableName] = eq(adapter.tables[tableName].id, adapter.tables[newTableName]._parentID);
-                    }
-                    return getTableColumnFromPath({
-                        adapter,
-                        collectionPath,
-                        constraintPath,
-                        constraints,
-                        fields: field.fields,
-                        joinAliases,
-                        joins,
-                        locale,
-                        pathSegments: pathSegments.slice(1),
-                        rootTableName,
-                        selectFields,
-                        tableName: newTableName,
-                        value
-                    });
-                }
-            case 'blocks':
-                {
-                    let blockTableColumn;
-                    let newTableName;
-                    // handle blockType queries
-                    if (pathSegments[1] === 'blockType') {
-                        // find the block config using the value
-                        const blockTypes = Array.isArray(value) ? value : [
-                            value
-                        ];
-                        blockTypes.forEach((blockType)=>{
-                            const block = field.blocks.find((block)=>block.slug === blockType);
-                            newTableName = getTableName({
-                                adapter,
-                                config: block,
-                                parentTableName: tableName,
-                                prefix: `${tableName}_blocks_`
-                            });
-                            joins[newTableName] = eq(adapter.tables[tableName].id, adapter.tables[newTableName]._parentID);
-                            constraints.push({
-                                columnName: '_path',
-                                table: adapter.tables[newTableName],
-                                value: pathSegments[0]
-                            });
-                        });
-                        return {
-                            constraints,
-                            field,
-                            getNotNullColumnByValue: ()=>'id',
-                            table: adapter.tables[tableName]
-                        };
-                    }
-                    const hasBlockField = field.blocks.some((block)=>{
-                        newTableName = getTableName({
-                            adapter,
-                            config: block,
-                            parentTableName: tableName,
-                            prefix: `${tableName}_blocks_`
-                        });
-                        constraintPath = `${constraintPath}${field.name}.%.`;
-                        let result;
-                        const blockConstraints = [];
-                        const blockSelectFields = {};
-                        try {
-                            result = getTableColumnFromPath({
-                                adapter,
-                                collectionPath,
-                                constraintPath,
-                                constraints: blockConstraints,
-                                fields: block.fields,
-                                joinAliases,
-                                joins,
-                                locale,
-                                pathSegments: pathSegments.slice(1),
-                                rootTableName,
-                                selectFields: blockSelectFields,
-                                tableName: newTableName,
-                                value
-                            });
-                        } catch (error) {
-                        // this is fine, not every block will have the field
-                        }
-                        if (!result) {
-                            return;
-                        }
-                        blockTableColumn = result;
-                        constraints = constraints.concat(blockConstraints);
-                        selectFields = {
-                            ...selectFields,
-                            ...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));
-                            if (locale) {
-                                constraints.push({
-                                    columnName: '_locale',
-                                    table: adapter.tables[newTableName],
-                                    value: locale
-                                });
-                            }
-                        } else {
-                            joins[newTableName] = eq(adapter.tables[tableName].id, adapter.tables[newTableName]._parentID);
-                        }
-                        return true;
-                    });
-                    if (hasBlockField) {
-                        return {
-                            columnName: blockTableColumn.columnName,
-                            constraints,
-                            field: blockTableColumn.field,
-                            pathSegments: pathSegments.slice(1),
-                            rawColumn: blockTableColumn.rawColumn,
-                            table: blockTableColumn.table
-                        };
-                    }
-                    break;
-                }
-            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
-                            });
-                        }
-                    } 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') {
-                            return {
-                                columnName: `${field.relationTo}ID`,
-                                constraints,
-                                field,
-                                table: aliasRelationshipTable
-                            };
-                        }
-                    } else if (newCollectionPath === 'value') {
-                        const tableColumnsNames = field.relationTo.map((relationTo)=>`"${aliasRelationshipTableName}"."${getTableName({
-                                adapter,
-                                config: adapter.payload.collections[relationTo].config
-                            })}_id"`);
-                        return {
-                            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');
-                    }
-                    return getTableColumnFromPath({
-                        adapter,
-                        aliasTable: newAliasTable,
-                        collectionPath: newCollectionPath,
-                        constraints,
-                        fields: relationshipFields,
-                        joinAliases,
-                        joins,
-                        locale,
-                        pathSegments: pathSegments.slice(1),
-                        rootTableName: newTableName,
-                        selectFields,
-                        tableName: newTableName,
-                        value
-                    });
-                }
-            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
-                        };
-                    }
-                }
-        }
-    }
-    throw new APIError(`Cannot find field for path at ${fieldPath}`);
-};
-
-//# sourceMappingURL=getTableColumnFromPath.js.map

package/dist/queries/getTableColumnFromPath.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/queries/getTableColumnFromPath.ts"],"sourcesContent":["/* eslint-disable no-param-reassign */\nimport type { SQL } from 'drizzle-orm'\nimport type { PgTableWithColumns } from 'drizzle-orm/pg-core'\nimport type { Field, FieldAffectingData, NumberField, TabAsField, TextField } from 'payload/types'\n\nimport { and, eq, like, sql } from 'drizzle-orm'\nimport { alias } from 'drizzle-orm/pg-core'\nimport { APIError } from 'payload/errors'\nimport { fieldAffectsData, tabHasName } from 'payload/types'\nimport { flattenTopLevelFields } from 'payload/utilities'\nimport toSnakeCase from 'to-snake-case'\nimport { v4 as uuid } from 'uuid'\n\nimport type { GenericColumn, GenericTable, PostgresAdapter } from '../types.js'\nimport type { BuildQueryJoinAliases, BuildQueryJoins } from './buildQuery.js'\n\nimport { getTableName } from '../schema/getTableName.js'\n\ntype Constraint = {\n  columnName: string\n  table: GenericTable | PgTableWithColumns<any>\n  value: unknown\n}\n\ntype TableColumn = {\n  columnName?: string\n  constraints: Constraint[]\n  field: FieldAffectingData\n  getNotNullColumnByValue?: (val: unknown) => string\n  pathSegments?: string[]\n  rawColumn?: SQL\n  table: GenericTable | PgTableWithColumns<any>\n}\n\ntype Args = {\n  adapter: PostgresAdapter\n  aliasTable?: GenericTable | PgTableWithColumns<any>\n  collectionPath: string\n  columnPrefix?: string\n  constraintPath?: string\n  constraints?: Constraint[]\n  fields: (Field | TabAsField)[]\n  joinAliases: BuildQueryJoinAliases\n  joins: BuildQueryJoins\n  locale?: string\n  pathSegments: string[]\n  rootTableName?: string\n  selectFields: Record<string, GenericColumn>\n  tableName: string\n  /**\n   * If creating a new table name for arrays and blocks, this suffix should be appended to the table name\n   */\n  tableNameSuffix?: string\n  /**\n   * The raw value of the query before sanitization\n   */\n  value: unknown\n}\n/**\n * Transforms path to table and column name\n * Adds tables to `join`\n * @returns TableColumn\n */\nexport const getTableColumnFromPath = ({\n  adapter,\n  aliasTable,\n  collectionPath,\n  columnPrefix = '',\n  constraintPath: incomingConstraintPath,\n  constraints = [],\n  fields,\n  joinAliases,\n  joins,\n  locale: incomingLocale,\n  pathSegments: incomingSegments,\n  rootTableName: incomingRootTableName,\n  selectFields,\n  tableName,\n  tableNameSuffix = '',\n  value,\n}: Args): TableColumn => {\n  const fieldPath = incomingSegments[0]\n  let locale = incomingLocale\n  const rootTableName = incomingRootTableName || tableName\n  let constraintPath = incomingConstraintPath || ''\n\n  const field = flattenTopLevelFields(fields as Field[]).find(\n    (fieldToFind) => fieldAffectsData(fieldToFind) && fieldToFind.name === fieldPath,\n  ) as Field | TabAsField\n  let newTableName = tableName\n\n  if (!field && fieldPath === 'id') {\n    selectFields.id = adapter.tables[newTableName].id\n    return {\n      columnName: 'id',\n      constraints,\n      field: {\n        name: 'id',\n        type: adapter.idType === 'uuid' ? 'text' : 'number',\n      } as NumberField | TextField,\n      table: adapter.tables[newTableName],\n    }\n  }\n\n  if (field) {\n    const pathSegments = [...incomingSegments]\n\n    // If next segment is a locale,\n    // we need to take it out and use it as the locale from this point on\n    if ('localized' in field && field.localized && adapter.payload.config.localization) {\n      const matchedLocale = adapter.payload.config.localization.localeCodes.find(\n        (locale) => locale === pathSegments[1],\n      )\n\n      if (matchedLocale) {\n        locale = matchedLocale\n        pathSegments.splice(1, 1)\n      }\n    }\n\n    switch (field.type) {\n      case 'tabs': {\n        return getTableColumnFromPath({\n          adapter,\n          aliasTable,\n          collectionPath,\n          columnPrefix,\n          constraintPath,\n          constraints,\n          fields: field.tabs.map((tab) => ({\n            ...tab,\n            type: 'tab',\n          })),\n          joinAliases,\n          joins,\n          locale,\n          pathSegments: pathSegments.slice(1),\n          rootTableName,\n          selectFields,\n          tableName: newTableName,\n          tableNameSuffix,\n          value,\n        })\n      }\n      case 'tab': {\n        if (tabHasName(field)) {\n          return getTableColumnFromPath({\n            adapter,\n            aliasTable,\n            collectionPath,\n            columnPrefix: `${columnPrefix}${field.name}_`,\n            constraintPath: `${constraintPath}${field.name}.`,\n            constraints,\n            fields: field.fields,\n            joinAliases,\n            joins,\n            locale,\n            pathSegments: pathSegments.slice(1),\n            rootTableName,\n            selectFields,\n            tableName: newTableName,\n            tableNameSuffix: `${tableNameSuffix}${toSnakeCase(field.name)}_`,\n            value,\n          })\n        }\n        return getTableColumnFromPath({\n          adapter,\n          aliasTable,\n          collectionPath,\n          columnPrefix,\n          constraintPath,\n          constraints,\n          fields: field.fields,\n          joinAliases,\n          joins,\n          locale,\n          pathSegments: pathSegments.slice(1),\n          rootTableName,\n          selectFields,\n          tableName: newTableName,\n          tableNameSuffix,\n          value,\n        })\n      }\n\n      case 'group': {\n        if (locale && field.localized && adapter.payload.config.localization) {\n          newTableName = getTableName({\n            adapter,\n            config: field,\n            locales: true,\n            parentTableName: tableName,\n            prefix: `${tableName}_`,\n          })\n\n          joins[tableName] = eq(\n            adapter.tables[tableName].id,\n            adapter.tables[newTableName]._parentID,\n          )\n          if (locale !== 'all') {\n            constraints.push({\n              columnName: '_locale',\n              table: adapter.tables[newTableName],\n              value: locale,\n            })\n          }\n        }\n        return getTableColumnFromPath({\n          adapter,\n          aliasTable,\n          collectionPath,\n          columnPrefix: `${columnPrefix}${field.name}_`,\n          constraintPath: `${constraintPath}${field.name}.`,\n          constraints,\n          fields: field.fields,\n          joinAliases,\n          joins,\n          locale,\n          pathSegments: pathSegments.slice(1),\n          rootTableName,\n          selectFields,\n          tableName: newTableName,\n          tableNameSuffix: `${tableNameSuffix}${toSnakeCase(field.name)}_`,\n          value,\n        })\n      }\n\n      case 'array': {\n        newTableName = getTableName({\n          adapter,\n          config: field,\n          parentTableName: `${tableName}_${tableNameSuffix}`,\n          prefix: `${tableName}_${tableNameSuffix}`,\n        })\n        constraintPath = `${constraintPath}${field.name}.%.`\n        if (locale && field.localized && adapter.payload.config.localization) {\n          joins[newTableName] = and(\n            eq(adapter.tables[tableName].id, adapter.tables[newTableName]._parentID),\n            eq(adapter.tables[newTableName]._locale, locale),\n          )\n          if (locale !== 'all') {\n            constraints.push({\n              columnName: '_locale',\n              table: adapter.tables[newTableName],\n              value: locale,\n            })\n          }\n        } else {\n          joins[newTableName] = eq(\n            adapter.tables[tableName].id,\n            adapter.tables[newTableName]._parentID,\n          )\n        }\n        return getTableColumnFromPath({\n          adapter,\n          collectionPath,\n          constraintPath,\n          constraints,\n          fields: field.fields,\n          joinAliases,\n          joins,\n          locale,\n          pathSegments: pathSegments.slice(1),\n          rootTableName,\n          selectFields,\n          tableName: newTableName,\n          value,\n        })\n      }\n\n      case 'blocks': {\n        let blockTableColumn: TableColumn\n        let newTableName: string\n\n        // handle blockType queries\n        if (pathSegments[1] === 'blockType') {\n          // find the block config using the value\n          const blockTypes = Array.isArray(value) ? value : [value]\n          blockTypes.forEach((blockType) => {\n            const block = field.blocks.find((block) => block.slug === blockType)\n            newTableName = getTableName({\n              adapter,\n              config: block,\n              parentTableName: tableName,\n              prefix: `${tableName}_blocks_`,\n            })\n            joins[newTableName] = eq(\n              adapter.tables[tableName].id,\n              adapter.tables[newTableName]._parentID,\n            )\n            constraints.push({\n              columnName: '_path',\n              table: adapter.tables[newTableName],\n              value: pathSegments[0],\n            })\n          })\n          return {\n            constraints,\n            field,\n            getNotNullColumnByValue: () => 'id',\n            table: adapter.tables[tableName],\n          }\n        }\n\n        const hasBlockField = field.blocks.some((block) => {\n          newTableName = getTableName({\n            adapter,\n            config: block,\n            parentTableName: tableName,\n            prefix: `${tableName}_blocks_`,\n          })\n          constraintPath = `${constraintPath}${field.name}.%.`\n          let result\n          const blockConstraints = []\n          const blockSelectFields = {}\n          try {\n            result = getTableColumnFromPath({\n              adapter,\n              collectionPath,\n              constraintPath,\n              constraints: blockConstraints,\n              fields: block.fields,\n              joinAliases,\n              joins,\n              locale,\n              pathSegments: pathSegments.slice(1),\n              rootTableName,\n              selectFields: blockSelectFields,\n              tableName: newTableName,\n              value,\n            })\n          } catch (error) {\n            // this is fine, not every block will have the field\n          }\n          if (!result) {\n            return\n          }\n          blockTableColumn = result\n          constraints = constraints.concat(blockConstraints)\n          selectFields = { ...selectFields, ...blockSelectFields }\n          if (field.localized && adapter.payload.config.localization) {\n            joins[newTableName] = and(\n              eq(adapter.tables[tableName].id, adapter.tables[newTableName]._parentID),\n              eq(adapter.tables[newTableName]._locale, locale),\n            )\n            if (locale) {\n              constraints.push({\n                columnName: '_locale',\n                table: adapter.tables[newTableName],\n                value: locale,\n              })\n            }\n          } else {\n            joins[newTableName] = eq(\n              adapter.tables[tableName].id,\n              adapter.tables[newTableName]._parentID,\n            )\n          }\n          return true\n        })\n        if (hasBlockField) {\n          return {\n            columnName: blockTableColumn.columnName,\n            constraints,\n            field: blockTableColumn.field,\n            pathSegments: pathSegments.slice(1),\n            rawColumn: blockTableColumn.rawColumn,\n            table: blockTableColumn.table,\n          }\n        }\n        break\n      }\n\n      case 'relationship':\n      case 'upload': {\n        let relationshipFields\n        const relationTableName = `${rootTableName}${adapter.relationshipsSuffix}`\n        const newCollectionPath = pathSegments.slice(1).join('.')\n        const aliasRelationshipTableName = uuid()\n        const aliasRelationshipTable = alias(\n          adapter.tables[relationTableName],\n          aliasRelationshipTableName,\n        )\n\n        // Join in the relationships table\n        if (locale && field.localized && adapter.payload.config.localization) {\n          joinAliases.push({\n            condition: and(\n              eq((aliasTable || adapter.tables[rootTableName]).id, aliasRelationshipTable.parent),\n              eq(aliasRelationshipTable.locale, locale),\n              like(aliasRelationshipTable.path, `${constraintPath}${field.name}`),\n            ),\n            table: aliasRelationshipTable,\n          })\n          if (locale !== 'all') {\n            constraints.push({\n              columnName: 'locale',\n              table: aliasRelationshipTable,\n              value: locale,\n            })\n          }\n        } else {\n          // Join in the relationships table\n          joinAliases.push({\n            condition: and(\n              eq((aliasTable || adapter.tables[rootTableName]).id, aliasRelationshipTable.parent),\n              like(aliasRelationshipTable.path, `${constraintPath}${field.name}`),\n            ),\n            table: aliasRelationshipTable,\n          })\n        }\n\n        selectFields[`${relationTableName}.path`] = aliasRelationshipTable.path\n\n        let newAliasTable\n\n        if (typeof field.relationTo === 'string') {\n          const relationshipConfig = adapter.payload.collections[field.relationTo].config\n          newTableName = getTableName({\n            adapter,\n            config: relationshipConfig,\n          })\n          // parent to relationship join table\n          relationshipFields = relationshipConfig.fields\n\n          newAliasTable = alias(adapter.tables[newTableName], toSnakeCase(uuid()))\n\n          joinAliases.push({\n            condition: eq(newAliasTable.id, aliasRelationshipTable[`${field.relationTo}ID`]),\n            table: newAliasTable,\n          })\n\n          if (newCollectionPath === '' || newCollectionPath === 'id') {\n            return {\n              columnName: `${field.relationTo}ID`,\n              constraints,\n              field,\n              table: aliasRelationshipTable,\n            }\n          }\n        } else if (newCollectionPath === 'value') {\n          const tableColumnsNames = field.relationTo.map(\n            (relationTo) =>\n              `\"${aliasRelationshipTableName}\".\"${getTableName({\n                adapter,\n                config: adapter.payload.collections[relationTo].config,\n              })}_id\"`,\n          )\n          return {\n            constraints,\n            field,\n            rawColumn: sql.raw(`COALESCE(${tableColumnsNames.join(', ')})`),\n            table: aliasRelationshipTable,\n          }\n        } else if (newCollectionPath === 'relationTo') {\n          const relationTo = Array.isArray(field.relationTo) ? field.relationTo : [field.relationTo]\n\n          return {\n            constraints,\n            field,\n            getNotNullColumnByValue: (val) => {\n              const matchedRelation = relationTo.find((relation) => relation === val)\n              if (matchedRelation) return `${matchedRelation}ID`\n              return undefined\n            },\n            table: aliasRelationshipTable,\n          }\n        } else {\n          throw new APIError('Not supported')\n        }\n\n        return getTableColumnFromPath({\n          adapter,\n          aliasTable: newAliasTable,\n          collectionPath: newCollectionPath,\n          constraints,\n          fields: relationshipFields,\n          joinAliases,\n          joins,\n          locale,\n          pathSegments: pathSegments.slice(1),\n          rootTableName: newTableName,\n          selectFields,\n          tableName: newTableName,\n          value,\n        })\n      }\n\n      default: {\n        if (fieldAffectsData(field)) {\n          if (field.localized && adapter.payload.config.localization) {\n            // If localized, we go to localized table and set aliasTable to undefined\n            // so it is not picked up below to be used as targetTable\n            newTableName = `${tableName}${adapter.localesSuffix}`\n\n            const parentTable = aliasTable || adapter.tables[tableName]\n\n            joins[newTableName] = eq(parentTable.id, adapter.tables[newTableName]._parentID)\n\n            aliasTable = undefined\n\n            if (locale !== 'all') {\n              constraints.push({\n                columnName: '_locale',\n                table: adapter.tables[newTableName],\n                value: locale,\n              })\n            }\n          }\n\n          const targetTable = aliasTable || adapter.tables[newTableName]\n\n          selectFields[`${newTableName}.${columnPrefix}${field.name}`] =\n            targetTable[`${columnPrefix}${field.name}`]\n\n          return {\n            columnName: `${columnPrefix}${field.name}`,\n            constraints,\n            field,\n            pathSegments,\n            table: targetTable,\n          }\n        }\n      }\n    }\n  }\n\n  throw new APIError(`Cannot find field for path at ${fieldPath}`)\n}\n"],"names":["and","eq","like","sql","alias","APIError","fieldAffectsData","tabHasName","flattenTopLevelFields","toSnakeCase","v4","uuid","getTableName","getTableColumnFromPath","adapter","aliasTable","collectionPath","columnPrefix","constraintPath","incomingConstraintPath","constraints","fields","joinAliases","joins","locale","incomingLocale","pathSegments","incomingSegments","rootTableName","incomingRootTableName","selectFields","tableName","tableNameSuffix","value","fieldPath","field","find","fieldToFind","name","newTableName","id","tables","columnName","type","idType","table","localized","payload","config","localization","matchedLocale","localeCodes","splice","tabs","map","tab","slice","locales","parentTableName","prefix","_parentID","push","_locale","blockTableColumn","blockTypes","Array","isArray","forEach","blockType","block","blocks","slug","getNotNullColumnByValue","hasBlockField","some","result","blockConstraints","blockSelectFields","error","concat","rawColumn","relationshipFields","relationTableName","relationshipsSuffix","newCollectionPath","join","aliasRelationshipTableName","aliasRelationshipTable","condition","parent","path","newAliasTable","relationTo","relationshipConfig","collections","tableColumnsNames","raw","val","matchedRelation","relation","undefined","localesSuffix","parentTable","targetTable"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/dist/queries/operatorMap.d.ts

@@ -1,18 +0,0 @@
-import { and, ilike, inArray, isNotNull, isNull, notInArray, or } from 'drizzle-orm';
-export declare const operatorMap: {
-    and: typeof and;
-    contains: typeof ilike;
-    equals: import("drizzle-orm").BinaryOperator;
-    exists: typeof isNotNull;
-    greater_than: import("drizzle-orm").BinaryOperator;
-    greater_than_equal: import("drizzle-orm").BinaryOperator;
-    in: typeof inArray;
-    isNull: typeof isNull;
-    less_than: import("drizzle-orm").BinaryOperator;
-    less_than_equal: import("drizzle-orm").BinaryOperator;
-    like: typeof ilike;
-    not_equals: import("drizzle-orm").BinaryOperator;
-    not_in: typeof notInArray;
-    or: typeof or;
-};
-//# sourceMappingURL=operatorMap.d.ts.map

package/dist/queries/operatorMap.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"operatorMap.d.ts","sourceRoot":"","sources":["../../src/queries/operatorMap.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,GAAG,EAIH,KAAK,EACL,OAAO,EACP,SAAS,EACT,MAAM,EAIN,UAAU,EACV,EAAE,EACH,MAAM,aAAa,CAAA;AAEpB,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;CAoBvB,CAAA"}

package/dist/queries/operatorMap.js

@@ -1,24 +0,0 @@
-import { and, eq, gt, gte, ilike, inArray, isNotNull, isNull, lt, lte, ne, notInArray, or } from 'drizzle-orm';
-export const operatorMap = {
-    // intersects: intersects,
-    and,
-    contains: ilike,
-    equals: eq,
-    exists: isNotNull,
-    greater_than: gt,
-    greater_than_equal: gte,
-    in: inArray,
-    isNull,
-    less_than: lt,
-    less_than_equal: lte,
-    like: ilike,
-    not_equals: ne,
-    // TODO: geojson queries
-    // near: near,
-    // within: within,
-    // all: all,
-    not_in: notInArray,
-    or
-};
-
-//# sourceMappingURL=operatorMap.js.map

package/dist/queries/operatorMap.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/queries/operatorMap.ts"],"sourcesContent":["import {\n  and,\n  eq,\n  gt,\n  gte,\n  ilike,\n  inArray,\n  isNotNull,\n  isNull,\n  lt,\n  lte,\n  ne,\n  notInArray,\n  or,\n} from 'drizzle-orm'\n\nexport const operatorMap = {\n  // intersects: intersects,\n  and,\n  contains: ilike,\n  equals: eq,\n  exists: isNotNull,\n  greater_than: gt,\n  greater_than_equal: gte,\n  in: inArray,\n  isNull, // handles exists: false\n  less_than: lt,\n  less_than_equal: lte,\n  like: ilike,\n  not_equals: ne,\n  // TODO: geojson queries\n  // near: near,\n  // within: within,\n  // all: all,\n  not_in: notInArray,\n  or,\n}\n"],"names":["and","eq","gt","gte","ilike","inArray","isNotNull","isNull","lt","lte","ne","notInArray","or","operatorMap","contains","equals","exists","greater_than","greater_than_equal","in","less_than","less_than_equal","like","not_equals","not_in"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,SACEA,GAAG,EACHC,EAAE,EACFC,EAAE,EACFC,GAAG,EACHC,KAAK,EACLC,OAAO,EACPC,SAAS,EACTC,MAAM,EACNC,EAAE,EACFC,GAAG,EACHC,EAAE,EACFC,UAAU,EACVC,EAAE,QACG,cAAa;AAEpB,OAAO,MAAMC,cAAc;IACzB,0BAA0B;IAC1Bb;IACAc,UAAUV;IACVW,QAAQd;IACRe,QAAQV;IACRW,cAAcf;IACdgB,oBAAoBf;IACpBgB,IAAId;IACJE;IACAa,WAAWZ;IACXa,iBAAiBZ;IACjBa,MAAMlB;IACNmB,YAAYb;IACZ,wBAAwB;IACxB,cAAc;IACd,kBAAkB;IAClB,YAAY;IACZc,QAAQb;IACRC;AACF,EAAC"}

package/dist/queries/parseParams.d.ts

@@ -1,17 +0,0 @@
-import type { SQL } from 'drizzle-orm';
-import type { Field, Where } from 'payload/types';
-import type { GenericColumn, PostgresAdapter } from '../types.js';
-import type { BuildQueryJoinAliases, BuildQueryJoins } from './buildQuery.js';
-type Args = {
-    adapter: PostgresAdapter;
-    fields: Field[];
-    joinAliases: BuildQueryJoinAliases;
-    joins: BuildQueryJoins;
-    locale: string;
-    selectFields: Record<string, GenericColumn>;
-    tableName: string;
-    where: Where;
-};
-export declare function parseParams({ adapter, fields, joinAliases, joins, locale, selectFields, tableName, where, }: Args): Promise<SQL>;
-export {};
-//# sourceMappingURL=parseParams.d.ts.map

package/dist/queries/parseParams.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"parseParams.d.ts","sourceRoot":"","sources":["../../src/queries/parseParams.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,aAAa,CAAA;AACtC,OAAO,KAAK,EAAE,KAAK,EAAY,KAAK,EAAE,MAAM,eAAe,CAAA;AAM3D,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AACjE,OAAO,KAAK,EAAE,qBAAqB,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAA;AAS7E,KAAK,IAAI,GAAG;IACV,OAAO,EAAE,eAAe,CAAA;IACxB,MAAM,EAAE,KAAK,EAAE,CAAA;IACf,WAAW,EAAE,qBAAqB,CAAA;IAClC,KAAK,EAAE,eAAe,CAAA;IACtB,MAAM,EAAE,MAAM,CAAA;IACd,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA;IAC3C,SAAS,EAAE,MAAM,CAAA;IACjB,KAAK,EAAE,KAAK,CAAA;CACb,CAAA;AAED,wBAAsB,WAAW,CAAC,EAChC,OAAO,EACP,MAAM,EACN,WAAW,EACX,KAAK,EACL,MAAM,EACN,YAAY,EACZ,SAAS,EACT,KAAK,GACN,EAAE,IAAI,GAAG,OAAO,CAAC,GAAG,CAAC,CAwMrB"}