@payloadcms/db-postgres 0.1.0-beta.0

package/dist/queries/getTableColumnFromPath.js

@@ -0,0 +1,333 @@
+/* eslint-disable no-param-reassign */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getTableColumnFromPath", {
+    enumerable: true,
+    get: function() {
+        return getTableColumnFromPath;
+    }
+});
+const _drizzleorm = require("drizzle-orm");
+const _pgcore = require("drizzle-orm/pg-core");
+const _errors = require("payload/errors");
+const _types = require("payload/types");
+const _utilities = require("payload/utilities");
+const _tosnakecase = /*#__PURE__*/ _interop_require_default(require("to-snake-case"));
+const _uuid = require("uuid");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const getTableColumnFromPath = ({ adapter, aliasTable, collectionPath, columnPrefix = '', constraints = [], fields, joinAliases, joins, locale: incomingLocale, pathSegments: incomingSegments, selectFields, tableName })=>{
+    const fieldPath = incomingSegments[0];
+    let locale = incomingLocale;
+    const field = (0, _utilities.flattenTopLevelFields)(fields).find((fieldToFind)=>(0, _types.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: '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,
+                        constraints,
+                        fields: field.tabs.map((tab)=>({
+                                ...tab,
+                                type: 'tab'
+                            })),
+                        joinAliases,
+                        joins,
+                        locale,
+                        pathSegments: pathSegments.slice(1),
+                        selectFields,
+                        tableName: newTableName
+                    });
+                }
+            case 'tab':
+                {
+                    if ((0, _types.tabHasName)(field)) {
+                        return getTableColumnFromPath({
+                            adapter,
+                            aliasTable,
+                            collectionPath,
+                            columnPrefix: `${columnPrefix}${field.name}_`,
+                            constraints,
+                            fields: field.fields,
+                            joinAliases,
+                            joins,
+                            locale,
+                            pathSegments: pathSegments.slice(1),
+                            selectFields,
+                            tableName: newTableName
+                        });
+                    }
+                    return getTableColumnFromPath({
+                        adapter,
+                        aliasTable,
+                        collectionPath,
+                        columnPrefix,
+                        constraints,
+                        fields: field.fields,
+                        joinAliases,
+                        joins,
+                        locale,
+                        pathSegments: pathSegments.slice(1),
+                        selectFields,
+                        tableName: newTableName
+                    });
+                }
+            case 'group':
+                {
+                    if (locale && field.localized && adapter.payload.config.localization) {
+                        newTableName = `${tableName}_locales`;
+                        joins[tableName] = (0, _drizzleorm.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}_`,
+                        constraints,
+                        fields: field.fields,
+                        joinAliases,
+                        joins,
+                        locale,
+                        pathSegments: pathSegments.slice(1),
+                        selectFields,
+                        tableName: newTableName
+                    });
+                }
+            case 'array':
+                {
+                    newTableName = `${tableName}_${(0, _tosnakecase.default)(field.name)}`;
+                    if (locale && field.localized && adapter.payload.config.localization) {
+                        joins[newTableName] = (0, _drizzleorm.and)((0, _drizzleorm.eq)(adapter.tables[tableName].id, adapter.tables[newTableName]._parentID), (0, _drizzleorm.eq)(adapter.tables[newTableName]._locale, locale));
+                        if (locale !== 'all') {
+                            constraints.push({
+                                columnName: '_locale',
+                                table: adapter.tables[newTableName],
+                                value: locale
+                            });
+                        }
+                    } else {
+                        joins[newTableName] = (0, _drizzleorm.eq)(adapter.tables[tableName].id, adapter.tables[newTableName]._parentID);
+                    }
+                    return getTableColumnFromPath({
+                        adapter,
+                        collectionPath,
+                        constraints,
+                        fields: field.fields,
+                        joinAliases,
+                        joins,
+                        locale,
+                        pathSegments: pathSegments.slice(1),
+                        selectFields,
+                        tableName: newTableName
+                    });
+                }
+            case 'blocks':
+                {
+                    let blockTableColumn;
+                    let newTableName;
+                    const hasBlockField = field.blocks.some((block)=>{
+                        newTableName = `${tableName}_blocks_${(0, _tosnakecase.default)(block.slug)}`;
+                        let result;
+                        const blockConstraints = [];
+                        const blockSelectFields = {};
+                        try {
+                            result = getTableColumnFromPath({
+                                adapter,
+                                collectionPath,
+                                constraints: blockConstraints,
+                                fields: block.fields,
+                                joinAliases,
+                                joins,
+                                locale,
+                                pathSegments: pathSegments.slice(1),
+                                selectFields: blockSelectFields,
+                                tableName: newTableName
+                            });
+                        } 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] = (0, _drizzleorm.and)((0, _drizzleorm.eq)(adapter.tables[tableName].id, adapter.tables[newTableName]._parentID), (0, _drizzleorm.eq)(adapter.tables[newTableName]._locale, locale));
+                            if (locale) {
+                                constraints.push({
+                                    columnName: '_locale',
+                                    table: adapter.tables[newTableName],
+                                    value: locale
+                                });
+                            }
+                        } else {
+                            joins[newTableName] = (0, _drizzleorm.eq)(adapter.tables[tableName].id, adapter.tables[newTableName]._parentID);
+                        }
+                        return result;
+                    });
+                    if (hasBlockField) {
+                        return {
+                            columnName: blockTableColumn.columnName,
+                            constraints,
+                            field: blockTableColumn.field,
+                            pathSegments: pathSegments.slice(1),
+                            rawColumn: blockTableColumn.rawColumn,
+                            table: adapter.tables[newTableName]
+                        };
+                    }
+                    break;
+                }
+            case 'relationship':
+            case 'upload':
+                {
+                    let relationshipFields;
+                    const relationTableName = `${tableName}_relationships`;
+                    const newCollectionPath = pathSegments.slice(1).join('.');
+                    const aliasRelationshipTableName = (0, _uuid.v4)();
+                    const aliasRelationshipTable = (0, _pgcore.alias)(adapter.tables[relationTableName], aliasRelationshipTableName);
+                    // Join in the relationships table
+                    joinAliases.push({
+                        condition: (0, _drizzleorm.eq)((aliasTable || adapter.tables[tableName]).id, aliasRelationshipTable.parent),
+                        table: aliasRelationshipTable
+                    });
+                    selectFields[`${relationTableName}.path`] = aliasRelationshipTable.path;
+                    constraints.push({
+                        columnName: 'path',
+                        table: aliasRelationshipTable,
+                        value: field.name
+                    });
+                    let newAliasTable;
+                    if (typeof field.relationTo === 'string') {
+                        newTableName = `${(0, _tosnakecase.default)(field.relationTo)}`;
+                        // parent to relationship join table
+                        relationshipFields = adapter.payload.collections[field.relationTo].config.fields;
+                        newAliasTable = (0, _pgcore.alias)(adapter.tables[newTableName], (0, _tosnakecase.default)((0, _uuid.v4)()));
+                        joinAliases.push({
+                            condition: (0, _drizzleorm.eq)(newAliasTable.id, aliasRelationshipTable[`${field.relationTo}ID`]),
+                            table: newAliasTable
+                        });
+                        if (newCollectionPath === '') {
+                            return {
+                                columnName: `${field.relationTo}ID`,
+                                constraints,
+                                field,
+                                table: aliasRelationshipTable
+                            };
+                        }
+                    } else if (newCollectionPath === 'value') {
+                        const tableColumnsNames = field.relationTo.map((relationTo)=>`"${aliasRelationshipTableName}"."${(0, _tosnakecase.default)(relationTo)}_id"`);
+                        return {
+                            constraints,
+                            field,
+                            rawColumn: _drizzleorm.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 _errors.APIError('Not supported');
+                    }
+                    return getTableColumnFromPath({
+                        adapter,
+                        aliasTable: newAliasTable,
+                        collectionPath: newCollectionPath,
+                        constraints,
+                        fields: relationshipFields,
+                        joinAliases,
+                        joins,
+                        locale,
+                        pathSegments: pathSegments.slice(1),
+                        selectFields,
+                        tableName: newTableName
+                    });
+                }
+            default:
+                {
+                    if ((0, _types.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}_locales`;
+                            const parentTable = aliasTable || adapter.tables[tableName];
+                            joins[newTableName] = (0, _drizzleorm.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: pathSegments,
+                            table: targetTable
+                        };
+                    }
+                }
+        }
+    }
+    throw new _errors.APIError(`Cannot find field for path at ${fieldPath}`);
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/queries/getTableColumnFromPath.ts"],"sourcesContent":["/* eslint-disable no-param-reassign */\nimport type { SQL } from 'drizzle-orm'\nimport type { Field, FieldAffectingData, TabAsField } from 'payload/types'\n\nimport { and, eq, 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'\nimport type { BuildQueryJoinAliases, BuildQueryJoins } from './buildQuery'\n\ntype Constraint = {\n  columnName: string\n  table: GenericTable\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\n}\n\ntype Args = {\n  adapter: PostgresAdapter\n  aliasTable?: GenericTable\n  collectionPath: string\n  columnPrefix?: string\n  constraints?: Constraint[]\n  fields: (Field | TabAsField)[]\n  joinAliases: BuildQueryJoinAliases\n  joins: BuildQueryJoins\n  locale?: string\n  pathSegments: string[]\n  selectFields: Record<string, GenericColumn>\n  tableName: string\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  constraints = [],\n  fields,\n  joinAliases,\n  joins,\n  locale: incomingLocale,\n  pathSegments: incomingSegments,\n  selectFields,\n  tableName,\n}: Args): TableColumn => {\n  const fieldPath = incomingSegments[0]\n  let locale = incomingLocale\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: 'number',\n      },\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          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          selectFields,\n          tableName: newTableName,\n        })\n      }\n      case 'tab': {\n        if (tabHasName(field)) {\n          return getTableColumnFromPath({\n            adapter,\n            aliasTable,\n            collectionPath,\n            columnPrefix: `${columnPrefix}${field.name}_`,\n            constraints,\n            fields: field.fields,\n            joinAliases,\n            joins,\n            locale,\n            pathSegments: pathSegments.slice(1),\n            selectFields,\n            tableName: newTableName,\n          })\n        }\n        return getTableColumnFromPath({\n          adapter,\n          aliasTable,\n          collectionPath,\n          columnPrefix,\n          constraints,\n          fields: field.fields,\n          joinAliases,\n          joins,\n          locale,\n          pathSegments: pathSegments.slice(1),\n          selectFields,\n          tableName: newTableName,\n        })\n      }\n\n      case 'group': {\n        if (locale && field.localized && adapter.payload.config.localization) {\n          newTableName = `${tableName}_locales`\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          constraints,\n          fields: field.fields,\n          joinAliases,\n          joins,\n          locale,\n          pathSegments: pathSegments.slice(1),\n          selectFields,\n          tableName: newTableName,\n        })\n      }\n\n      case 'array': {\n        newTableName = `${tableName}_${toSnakeCase(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          constraints,\n          fields: field.fields,\n          joinAliases,\n          joins,\n          locale,\n          pathSegments: pathSegments.slice(1),\n          selectFields,\n          tableName: newTableName,\n        })\n      }\n\n      case 'blocks': {\n        let blockTableColumn: TableColumn\n        let newTableName: string\n        const hasBlockField = field.blocks.some((block) => {\n          newTableName = `${tableName}_blocks_${toSnakeCase(block.slug)}`\n          let result\n          const blockConstraints = []\n          const blockSelectFields = {}\n          try {\n            result = getTableColumnFromPath({\n              adapter,\n              collectionPath,\n              constraints: blockConstraints,\n              fields: block.fields,\n              joinAliases,\n              joins,\n              locale,\n              pathSegments: pathSegments.slice(1),\n              selectFields: blockSelectFields,\n              tableName: newTableName,\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 result\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: adapter.tables[newTableName],\n          }\n        }\n        break\n      }\n\n      case 'relationship':\n      case 'upload': {\n        let relationshipFields\n        const relationTableName = `${tableName}_relationships`\n        const newCollectionPath = pathSegments.slice(1).join('.')\n\n        const aliasRelationshipTableName = uuid()\n        const aliasRelationshipTable = alias(\n          adapter.tables[relationTableName],\n          aliasRelationshipTableName,\n        )\n\n        // Join in the relationships table\n        joinAliases.push({\n          condition: eq(\n            (aliasTable || adapter.tables[tableName]).id,\n            aliasRelationshipTable.parent,\n          ),\n          table: aliasRelationshipTable,\n        })\n\n        selectFields[`${relationTableName}.path`] = aliasRelationshipTable.path\n\n        constraints.push({\n          columnName: 'path',\n          table: aliasRelationshipTable,\n          value: field.name,\n        })\n\n        let newAliasTable\n\n        if (typeof field.relationTo === 'string') {\n          newTableName = `${toSnakeCase(field.relationTo)}`\n          // parent to relationship join table\n          relationshipFields = adapter.payload.collections[field.relationTo].config.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 === '') {\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) => `\"${aliasRelationshipTableName}\".\"${toSnakeCase(relationTo)}_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          selectFields,\n          tableName: newTableName,\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}_locales`\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: pathSegments,\n            table: targetTable,\n          }\n        }\n      }\n    }\n  }\n\n  throw new APIError(`Cannot find field for path at ${fieldPath}`)\n}\n"],"names":["getTableColumnFromPath","adapter","aliasTable","collectionPath","columnPrefix","constraints","fields","joinAliases","joins","locale","incomingLocale","pathSegments","incomingSegments","selectFields","tableName","fieldPath","field","flattenTopLevelFields","find","fieldToFind","fieldAffectsData","name","newTableName","id","tables","columnName","type","table","localized","payload","config","localization","matchedLocale","localeCodes","splice","tabs","map","tab","slice","tabHasName","eq","_parentID","push","value","toSnakeCase","and","_locale","blockTableColumn","hasBlockField","blocks","some","block","slug","result","blockConstraints","blockSelectFields","error","concat","rawColumn","relationshipFields","relationTableName","newCollectionPath","join","aliasRelationshipTableName","uuid","aliasRelationshipTable","alias","condition","parent","path","newAliasTable","relationTo","collections","tableColumnsNames","sql","raw","Array","isArray","getNotNullColumnByValue","val","matchedRelation","relation","undefined","APIError","parentTable","targetTable"],"mappings":"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"}

package/dist/queries/operatorMap.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "operatorMap", {
+    enumerable: true,
+    get: function() {
+        return operatorMap;
+    }
+});
+const _drizzleorm = require("drizzle-orm");
+const operatorMap = {
+    // intersects: intersects,
+    and: _drizzleorm.and,
+    contains: _drizzleorm.ilike,
+    equals: _drizzleorm.eq,
+    exists: _drizzleorm.isNotNull,
+    greater_than: _drizzleorm.gt,
+    greater_than_equal: _drizzleorm.gte,
+    in: _drizzleorm.inArray,
+    isNull: _drizzleorm.isNull,
+    less_than: _drizzleorm.lt,
+    less_than_equal: _drizzleorm.lte,
+    like: _drizzleorm.ilike,
+    not_equals: _drizzleorm.ne,
+    // TODO: geojson queries
+    // near: near,
+    // within: within,
+    // all: all,
+    not_in: _drizzleorm.notInArray,
+    or: _drizzleorm.or
+};
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9xdWVyaWVzL29wZXJhdG9yTWFwLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7XG4gIGFuZCxcbiAgZXEsXG4gIGd0LFxuICBndGUsXG4gIGlsaWtlLFxuICBpbkFycmF5LFxuICBpc05vdE51bGwsXG4gIGlzTnVsbCxcbiAgbHQsXG4gIGx0ZSxcbiAgbmUsXG4gIG5vdEluQXJyYXksXG4gIG9yLFxufSBmcm9tICdkcml6emxlLW9ybSdcblxuZXhwb3J0IGNvbnN0IG9wZXJhdG9yTWFwID0ge1xuICAvLyBpbnRlcnNlY3RzOiBpbnRlcnNlY3RzLFxuICBhbmQsXG4gIGNvbnRhaW5zOiBpbGlrZSxcbiAgZXF1YWxzOiBlcSxcbiAgZXhpc3RzOiBpc05vdE51bGwsXG4gIGdyZWF0ZXJfdGhhbjogZ3QsXG4gIGdyZWF0ZXJfdGhhbl9lcXVhbDogZ3RlLFxuICBpbjogaW5BcnJheSxcbiAgaXNOdWxsLCAvLyBoYW5kbGVzIGV4aXN0czogZmFsc2VcbiAgbGVzc190aGFuOiBsdCxcbiAgbGVzc190aGFuX2VxdWFsOiBsdGUsXG4gIGxpa2U6IGlsaWtlLFxuICBub3RfZXF1YWxzOiBuZSxcbiAgLy8gVE9ETzogZ2VvanNvbiBxdWVyaWVzXG4gIC8vIG5lYXI6IG5lYXIsXG4gIC8vIHdpdGhpbjogd2l0aGluLFxuICAvLyBhbGw6IGFsbCxcbiAgbm90X2luOiBub3RJbkFycmF5LFxuICBvcixcbn1cbiJdLCJuYW1lcyI6WyJvcGVyYXRvck1hcCIsImFuZCIsImNvbnRhaW5zIiwiaWxpa2UiLCJlcXVhbHMiLCJlcSIsImV4aXN0cyIsImlzTm90TnVsbCIsImdyZWF0ZXJfdGhhbiIsImd0IiwiZ3JlYXRlcl90aGFuX2VxdWFsIiwiZ3RlIiwiaW4iLCJpbkFycmF5IiwiaXNOdWxsIiwibGVzc190aGFuIiwibHQiLCJsZXNzX3RoYW5fZXF1YWwiLCJsdGUiLCJsaWtlIiwibm90X2VxdWFscyIsIm5lIiwibm90X2luIiwibm90SW5BcnJheSIsIm9yIl0sIm1hcHBpbmdzIjoiOzs7OytCQWdCYUE7OztlQUFBQTs7OzRCQUZOO0FBRUEsTUFBTUEsY0FBYztJQUN6QiwwQkFBMEI7SUFDMUJDLEtBQUFBLGVBQUc7SUFDSEMsVUFBVUMsaUJBQUs7SUFDZkMsUUFBUUMsY0FBRTtJQUNWQyxRQUFRQyxxQkFBUztJQUNqQkMsY0FBY0MsY0FBRTtJQUNoQkMsb0JBQW9CQyxlQUFHO0lBQ3ZCQyxJQUFJQyxtQkFBTztJQUNYQyxRQUFBQSxrQkFBTTtJQUNOQyxXQUFXQyxjQUFFO0lBQ2JDLGlCQUFpQkMsZUFBRztJQUNwQkMsTUFBTWhCLGlCQUFLO0lBQ1hpQixZQUFZQyxjQUFFO0lBQ2Qsd0JBQXdCO0lBQ3hCLGNBQWM7SUFDZCxrQkFBa0I7SUFDbEIsWUFBWTtJQUNaQyxRQUFRQyxzQkFBVTtJQUNsQkMsSUFBQUEsY0FBRTtBQUNKIn0=

package/dist/queries/parseParams.js

@@ -0,0 +1,146 @@
+/* eslint-disable no-await-in-loop */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "parseParams", {
+    enumerable: true,
+    get: function() {
+        return parseParams;
+    }
+});
+const _drizzleorm = require("drizzle-orm");
+const _errors = require("payload/errors");
+const _types = require("payload/types");
+const _buildAndOrConditions = require("./buildAndOrConditions");
+const _createJSONQuery = require("./createJSONQuery");
+const _convertPathToJSONTraversal = require("./createJSONQuery/convertPathToJSONTraversal");
+const _getTableColumnFromPath = require("./getTableColumnFromPath");
+const _operatorMap = require("./operatorMap");
+const _sanitizeQueryValue = require("./sanitizeQueryValue");
+async function parseParams({ adapter, fields, joinAliases, joins, locale, selectFields, tableName, where }) {
+    let result;
+    const constraints = [];
+    if (typeof where === 'object' && Object.keys(where).length > 0) {
+        // We need to determine if the whereKey is an AND, OR, or a schema path
+        for (const relationOrPath of Object.keys(where)){
+            if (relationOrPath) {
+                const condition = where[relationOrPath];
+                let conditionOperator;
+                if (relationOrPath.toLowerCase() === 'and') {
+                    conditionOperator = 'and';
+                } else if (relationOrPath.toLowerCase() === 'or') {
+                    conditionOperator = 'or';
+                }
+                if (Array.isArray(condition)) {
+                    const builtConditions = await (0, _buildAndOrConditions.buildAndOrConditions)({
+                        adapter,
+                        fields,
+                        joinAliases,
+                        joins,
+                        locale,
+                        selectFields,
+                        tableName,
+                        where: condition
+                    });
+                    if (builtConditions.length > 0) {
+                        if (result) {
+                            result = _operatorMap.operatorMap[conditionOperator](result, ...builtConditions);
+                        } else {
+                            result = _operatorMap.operatorMap[conditionOperator](...builtConditions);
+                        }
+                    }
+                } else {
+                    // It's a path - and there can be multiple comparisons on a single path.
+                    // For example - title like 'test' and title not equal to 'tester'
+                    // So we need to loop on keys again here to handle each operator independently
+                    const pathOperators = where[relationOrPath];
+                    if (typeof pathOperators === 'object') {
+                        for (const operator of Object.keys(pathOperators)){
+                            if (_types.validOperators.includes(operator)) {
+                                const { columnName, constraints: queryConstraints, field, getNotNullColumnByValue, pathSegments, rawColumn, table } = (0, _getTableColumnFromPath.getTableColumnFromPath)({
+                                    adapter,
+                                    collectionPath: relationOrPath,
+                                    fields,
+                                    joinAliases,
+                                    joins,
+                                    locale,
+                                    pathSegments: relationOrPath.replace(/__/g, '.').split('.'),
+                                    selectFields,
+                                    tableName
+                                });
+                                const val = where[relationOrPath][operator];
+                                queryConstraints.forEach(({ columnName: col, table: constraintTable, value })=>{
+                                    constraints.push(_operatorMap.operatorMap.equals(constraintTable[col], value));
+                                });
+                                if ([
+                                    'json',
+                                    'richText'
+                                ].includes(field.type) && Array.isArray(pathSegments)) {
+                                    const segments = pathSegments.slice(1);
+                                    segments.unshift(table[columnName].name);
+                                    if (field.type === 'richText') {
+                                        const jsonQuery = (0, _createJSONQuery.createJSONQuery)({
+                                            operator,
+                                            pathSegments: segments,
+                                            treatAsArray: [
+                                                'children'
+                                            ],
+                                            treatRootAsArray: true,
+                                            value: val
+                                        });
+                                        constraints.push(_drizzleorm.sql.raw(jsonQuery));
+                                    }
+                                    if (field.type === 'json') {
+                                        const jsonQuery = (0, _convertPathToJSONTraversal.convertPathToJSONTraversal)(pathSegments);
+                                        constraints.push(_drizzleorm.sql.raw(`${table[columnName].name}${jsonQuery} = '%${val}%'`));
+                                    }
+                                    break;
+                                }
+                                if (getNotNullColumnByValue) {
+                                    const columnName = getNotNullColumnByValue(val);
+                                    if (columnName) {
+                                        constraints.push((0, _drizzleorm.isNotNull)(table[columnName]));
+                                    } else {
+                                        throw new _errors.QueryError([
+                                            {
+                                                path: relationOrPath
+                                            }
+                                        ]);
+                                    }
+                                    break;
+                                }
+                                if (operator === 'like') {
+                                    constraints.push((0, _drizzleorm.and)(...val.split(' ').map((word)=>(0, _drizzleorm.ilike)(table[columnName], `%${word}%`))));
+                                    break;
+                                }
+                                const { operator: queryOperator, value: queryValue } = (0, _sanitizeQueryValue.sanitizeQueryValue)({
+                                    field,
+                                    operator,
+                                    val
+                                });
+                                if (queryOperator === 'not_equals' && queryValue !== null) {
+                                    constraints.push((0, _drizzleorm.or)((0, _drizzleorm.isNull)(rawColumn || table[columnName]), /* eslint-disable @typescript-eslint/no-explicit-any */ (0, _drizzleorm.ne)(rawColumn || table[columnName], queryValue)));
+                                } else {
+                                    constraints.push(_operatorMap.operatorMap[queryOperator](rawColumn || table[columnName], queryValue));
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    if (constraints.length > 0) {
+        if (result) {
+            result = (0, _drizzleorm.and)(result, ...constraints);
+        } else {
+            result = (0, _drizzleorm.and)(...constraints);
+        }
+    }
+    if (constraints.length === 1 && !result) {
+        [result] = constraints;
+    }
+    return result;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/queries/parseParams.ts"],"sourcesContent":["/* eslint-disable no-await-in-loop */\nimport type { SQL } from 'drizzle-orm'\nimport type { Field, Operator, Where } from 'payload/types'\n\nimport { and, ilike, isNotNull, isNull, ne, or, sql } from 'drizzle-orm'\nimport { QueryError } from 'payload/errors'\nimport { validOperators } from 'payload/types'\n\nimport type { GenericColumn, PostgresAdapter } from '../types'\nimport type { BuildQueryJoinAliases, BuildQueryJoins } from './buildQuery'\n\nimport { buildAndOrConditions } from './buildAndOrConditions'\nimport { createJSONQuery } from './createJSONQuery'\nimport { convertPathToJSONTraversal } from './createJSONQuery/convertPathToJSONTraversal'\nimport { getTableColumnFromPath } from './getTableColumnFromPath'\nimport { operatorMap } from './operatorMap'\nimport { sanitizeQueryValue } from './sanitizeQueryValue'\n\ntype Args = {\n  adapter: PostgresAdapter\n  fields: Field[]\n  joinAliases: BuildQueryJoinAliases\n  joins: BuildQueryJoins\n  locale: string\n  selectFields: Record<string, GenericColumn>\n  tableName: string\n  where: Where\n}\n\nexport async function parseParams ({\n  adapter,\n  fields,\n  joinAliases,\n  joins,\n  locale,\n  selectFields,\n  tableName,\n  where,\n}: Args): Promise<SQL> {\n  let result: SQL\n  const constraints: SQL[] = []\n\n  if (typeof where === 'object' && Object.keys(where).length > 0) {\n    // We need to determine if the whereKey is an AND, OR, or a schema path\n    for (const relationOrPath of Object.keys(where)) {\n      if (relationOrPath) {\n        const condition = where[relationOrPath]\n        let conditionOperator: 'and' | 'or'\n        if (relationOrPath.toLowerCase() === 'and') {\n          conditionOperator = 'and'\n        } else if (relationOrPath.toLowerCase() === 'or') {\n          conditionOperator = 'or'\n        }\n        if (Array.isArray(condition)) {\n          const builtConditions = await buildAndOrConditions({\n            adapter,\n            fields,\n            joinAliases,\n            joins,\n            locale,\n            selectFields,\n            tableName,\n            where: condition,\n          })\n          if (builtConditions.length > 0) {\n            if (result) {\n              result = operatorMap[conditionOperator](result, ...builtConditions)\n            } else {\n              result = operatorMap[conditionOperator](...builtConditions)\n            }\n          }\n        } else {\n          // It's a path - and there can be multiple comparisons on a single path.\n          // For example - title like 'test' and title not equal to 'tester'\n          // So we need to loop on keys again here to handle each operator independently\n          const pathOperators = where[relationOrPath]\n          if (typeof pathOperators === 'object') {\n            for (const operator of Object.keys(pathOperators)) {\n              if (validOperators.includes(operator as Operator)) {\n                const {\n                  columnName,\n                  constraints: queryConstraints,\n                  field,\n                  getNotNullColumnByValue,\n                  pathSegments,\n                  rawColumn,\n                  table,\n                } = getTableColumnFromPath({\n                  adapter,\n                  collectionPath: relationOrPath,\n                  fields,\n                  joinAliases,\n                  joins,\n                  locale,\n                  pathSegments: relationOrPath.replace(/__/g, '.').split('.'),\n                  selectFields,\n                  tableName,\n                })\n\n                const val = where[relationOrPath][operator]\n\n                queryConstraints.forEach(({ columnName: col, table: constraintTable, value }) => {\n                  constraints.push(operatorMap.equals(constraintTable[col], value))\n                })\n\n                if (['json', 'richText'].includes(field.type) && Array.isArray(pathSegments)) {\n                  const segments = pathSegments.slice(1)\n                  segments.unshift(table[columnName].name)\n\n                  if (field.type === 'richText') {\n                    const jsonQuery = createJSONQuery({\n                      operator,\n                      pathSegments: segments,\n                      treatAsArray: ['children'],\n                      treatRootAsArray: true,\n                      value: val,\n                    })\n\n                    constraints.push(sql.raw(jsonQuery))\n                  }\n\n                  if (field.type === 'json') {\n                    const jsonQuery = convertPathToJSONTraversal(pathSegments)\n                    constraints.push(sql.raw(`${table[columnName].name}${jsonQuery} = '%${val}%'`))\n                  }\n\n                  break\n                }\n\n                if (getNotNullColumnByValue) {\n                  const columnName = getNotNullColumnByValue(val)\n                  if (columnName) {\n                    constraints.push(isNotNull(table[columnName]))\n                  } else {\n                    throw new QueryError([{ path: relationOrPath }])\n                  }\n                  break\n                }\n\n                if (operator === 'like') {\n                  constraints.push(\n                    and(...val.split(' ').map((word) => ilike(table[columnName], `%${word}%`))),\n                  )\n                  break\n                }\n\n                const { operator: queryOperator, value: queryValue } = sanitizeQueryValue({\n                  field,\n                  operator,\n                  val,\n                })\n\n                if (queryOperator === 'not_equals' && queryValue !== null) {\n                  constraints.push(\n                    or(\n                      isNull(rawColumn || table[columnName]),\n                      /* eslint-disable @typescript-eslint/no-explicit-any */\n                      ne<any>(rawColumn || table[columnName], queryValue),\n                    )\n                  )\n                } else {\n                  constraints.push(\n                    operatorMap[queryOperator](rawColumn || table[columnName], queryValue),\n                  )\n                }\n              }\n            }\n          }\n        }\n      }\n    }\n  }\n  if (constraints.length > 0) {\n    if (result) {\n      result = and(result, ...constraints)\n    } else {\n      result = and(...constraints)\n    }\n  }\n  if (constraints.length === 1 && !result) {\n    ;[result] = constraints\n  }\n\n  return result\n}\n"],"names":["parseParams","adapter","fields","joinAliases","joins","locale","selectFields","tableName","where","result","constraints","Object","keys","length","relationOrPath","condition","conditionOperator","toLowerCase","Array","isArray","builtConditions","buildAndOrConditions","operatorMap","pathOperators","operator","validOperators","includes","columnName","queryConstraints","field","getNotNullColumnByValue","pathSegments","rawColumn","table","getTableColumnFromPath","collectionPath","replace","split","val","forEach","col","constraintTable","value","push","equals","type","segments","slice","unshift","name","jsonQuery","createJSONQuery","treatAsArray","treatRootAsArray","sql","raw","convertPathToJSONTraversal","isNotNull","QueryError","path","and","map","word","ilike","queryOperator","queryValue","sanitizeQueryValue","or","isNull","ne"],"mappings":"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"}