@payloadcms/db-postgres 3.0.0-canary.6041f49 → 3.0.0-canary.67aae47

package/dist/queries/buildQuery.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/queries/buildQuery.ts"],"sourcesContent":["import type { SQL } from 'drizzle-orm'\nimport type { PgTableWithColumns } from 'drizzle-orm/pg-core'\nimport type { Field, Where } from 'payload/types'\n\nimport { asc, desc } from 'drizzle-orm'\n\nimport type { GenericColumn, GenericTable, PostgresAdapter } from '../types.js'\n\nimport { getTableColumnFromPath } from './getTableColumnFromPath.js'\nimport { parseParams } from './parseParams.js'\n\nexport type BuildQueryJoins = Record<string, SQL>\n\nexport type BuildQueryJoinAliases = {\n  condition: SQL\n  table: GenericTable | PgTableWithColumns<any>\n}[]\n\ntype BuildQueryArgs = {\n  adapter: PostgresAdapter\n  fields: Field[]\n  locale?: string\n  sort?: string\n  tableName: string\n  where: Where\n}\n\ntype Result = {\n  joinAliases: BuildQueryJoinAliases\n  joins: BuildQueryJoins\n  orderBy: {\n    column: GenericColumn\n    order: typeof asc | typeof desc\n  }\n  selectFields: Record<string, GenericColumn>\n  where: SQL\n}\nconst buildQuery = async function buildQuery({\n  adapter,\n  fields,\n  locale,\n  sort,\n  tableName,\n  where: incomingWhere,\n}: BuildQueryArgs): Promise<Result> {\n  const selectFields: Record<string, GenericColumn> = {\n    id: adapter.tables[tableName].id,\n  }\n  const joins: BuildQueryJoins = {}\n  const joinAliases: BuildQueryJoinAliases = []\n\n  const orderBy: Result['orderBy'] = {\n    column: null,\n    order: null,\n  }\n\n  if (sort) {\n    let sortPath\n\n    if (sort[0] === '-') {\n      sortPath = sort.substring(1)\n      orderBy.order = desc\n    } else {\n      sortPath = sort\n      orderBy.order = asc\n    }\n\n    try {\n      const { columnName: sortTableColumnName, table: sortTable } = getTableColumnFromPath({\n        adapter,\n        collectionPath: sortPath,\n        fields,\n        joinAliases,\n        joins,\n        locale,\n        pathSegments: sortPath.replace(/__/g, '.').split('.'),\n        selectFields,\n        tableName,\n        value: sortPath,\n      })\n      orderBy.column = sortTable?.[sortTableColumnName]\n    } catch (err) {\n      // continue\n    }\n  }\n\n  if (!orderBy?.column) {\n    orderBy.order = desc\n    const createdAt = adapter.tables[tableName]?.createdAt\n\n    if (createdAt) {\n      orderBy.column = createdAt\n    } else {\n      orderBy.column = adapter.tables[tableName].id\n    }\n  }\n\n  if (orderBy.column) {\n    selectFields.sort = orderBy.column\n  }\n\n  let where: SQL\n\n  if (incomingWhere && Object.keys(incomingWhere).length > 0) {\n    where = await parseParams({\n      adapter,\n      fields,\n      joinAliases,\n      joins,\n      locale,\n      selectFields,\n      tableName,\n      where: incomingWhere,\n    })\n  }\n\n  return {\n    joinAliases,\n    joins,\n    orderBy,\n    selectFields,\n    where,\n  }\n}\n\nexport default buildQuery\n"],"names":["asc","desc","getTableColumnFromPath","parseParams","buildQuery","adapter","fields","locale","sort","tableName","where","incomingWhere","selectFields","id","tables","joins","joinAliases","orderBy","column","order","sortPath","substring","columnName","sortTableColumnName","table","sortTable","collectionPath","pathSegments","replace","split","value","err","createdAt","Object","keys","length"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAIA,SAASA,GAAG,EAAEC,IAAI,QAAQ,cAAa;AAIvC,SAASC,sBAAsB,QAAQ,8BAA6B;AACpE,SAASC,WAAW,QAAQ,mBAAkB;AA4B9C,MAAMC,aAAa,eAAeA,WAAW,EAC3CC,OAAO,EACPC,MAAM,EACNC,MAAM,EACNC,IAAI,EACJC,SAAS,EACTC,OAAOC,aAAa,EACL;IACf,MAAMC,eAA8C;QAClDC,IAAIR,QAAQS,MAAM,CAACL,UAAU,CAACI,EAAE;IAClC;IACA,MAAME,QAAyB,CAAC;IAChC,MAAMC,cAAqC,EAAE;IAE7C,MAAMC,UAA6B;QACjCC,QAAQ;QACRC,OAAO;IACT;IAEA,IAAIX,MAAM;QACR,IAAIY;QAEJ,IAAIZ,IAAI,CAAC,EAAE,KAAK,KAAK;YACnBY,WAAWZ,KAAKa,SAAS,CAAC;YAC1BJ,QAAQE,KAAK,GAAGlB;QAClB,OAAO;YACLmB,WAAWZ;YACXS,QAAQE,KAAK,GAAGnB;QAClB;QAEA,IAAI;YACF,MAAM,EAAEsB,YAAYC,mBAAmB,EAAEC,OAAOC,SAAS,EAAE,GAAGvB,uBAAuB;gBACnFG;gBACAqB,gBAAgBN;gBAChBd;gBACAU;gBACAD;gBACAR;gBACAoB,cAAcP,SAASQ,OAAO,CAAC,OAAO,KAAKC,KAAK,CAAC;gBACjDjB;gBACAH;gBACAqB,OAAOV;YACT;YACAH,QAAQC,MAAM,GAAGO,WAAW,CAACF,oBAAoB;QACnD,EAAE,OAAOQ,KAAK;QACZ,WAAW;QACb;IACF;IAEA,IAAI,CAACd,SAASC,QAAQ;QACpBD,QAAQE,KAAK,GAAGlB;QAChB,MAAM+B,YAAY3B,QAAQS,MAAM,CAACL,UAAU,EAAEuB;QAE7C,IAAIA,WAAW;YACbf,QAAQC,MAAM,GAAGc;QACnB,OAAO;YACLf,QAAQC,MAAM,GAAGb,QAAQS,MAAM,CAACL,UAAU,CAACI,EAAE;QAC/C;IACF;IAEA,IAAII,QAAQC,MAAM,EAAE;QAClBN,aAAaJ,IAAI,GAAGS,QAAQC,MAAM;IACpC;IAEA,IAAIR;IAEJ,IAAIC,iBAAiBsB,OAAOC,IAAI,CAACvB,eAAewB,MAAM,GAAG,GAAG;QAC1DzB,QAAQ,MAAMP,YAAY;YACxBE;YACAC;YACAU;YACAD;YACAR;YACAK;YACAH;YACAC,OAAOC;QACT;IACF;IAEA,OAAO;QACLK;QACAD;QACAE;QACAL;QACAF;IACF;AACF;AAEA,eAAeN,WAAU"}

package/dist/queries/createJSONQuery/convertPathToJSONTraversal.d.ts

@@ -1,2 +0,0 @@
-export declare const convertPathToJSONTraversal: (incomingSegments: string[]) => string;
-//# sourceMappingURL=convertPathToJSONTraversal.d.ts.map

package/dist/queries/createJSONQuery/convertPathToJSONTraversal.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"convertPathToJSONTraversal.d.ts","sourceRoot":"","sources":["../../../src/queries/createJSONQuery/convertPathToJSONTraversal.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,0BAA0B,qBAAsB,MAAM,EAAE,WAUpE,CAAA"}

package/dist/queries/createJSONQuery/convertPathToJSONTraversal.js

@@ -1,14 +0,0 @@
-import { formatJSONPathSegment } from './formatJSONPathSegment.js';
-export const convertPathToJSONTraversal = (incomingSegments)=>{
-    const segments = [
-        ...incomingSegments
-    ];
-    segments.shift();
-    return segments.reduce((res, segment, i)=>{
-        const formattedSegment = formatJSONPathSegment(segment);
-        if (i + 1 === segments.length) return `${res}->>${formattedSegment}`;
-        return `${res}->${formattedSegment}`;
-    }, '');
-};
-
-//# sourceMappingURL=convertPathToJSONTraversal.js.map

package/dist/queries/createJSONQuery/convertPathToJSONTraversal.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/queries/createJSONQuery/convertPathToJSONTraversal.ts"],"sourcesContent":["import { formatJSONPathSegment } from './formatJSONPathSegment.js'\n\nexport const convertPathToJSONTraversal = (incomingSegments: string[]) => {\n  const segments = [...incomingSegments]\n  segments.shift()\n\n  return segments.reduce((res, segment, i) => {\n    const formattedSegment = formatJSONPathSegment(segment)\n\n    if (i + 1 === segments.length) return `${res}->>${formattedSegment}`\n    return `${res}->${formattedSegment}`\n  }, '')\n}\n"],"names":["formatJSONPathSegment","convertPathToJSONTraversal","incomingSegments","segments","shift","reduce","res","segment","i","formattedSegment","length"],"rangeMappings":";;;;;;;;;;;","mappings":"AAAA,SAASA,qBAAqB,QAAQ,6BAA4B;AAElE,OAAO,MAAMC,6BAA6B,CAACC;IACzC,MAAMC,WAAW;WAAID;KAAiB;IACtCC,SAASC,KAAK;IAEd,OAAOD,SAASE,MAAM,CAAC,CAACC,KAAKC,SAASC;QACpC,MAAMC,mBAAmBT,sBAAsBO;QAE/C,IAAIC,IAAI,MAAML,SAASO,MAAM,EAAE,OAAO,CAAC,EAAEJ,IAAI,GAAG,EAAEG,iBAAiB,CAAC;QACpE,OAAO,CAAC,EAAEH,IAAI,EAAE,EAAEG,iBAAiB,CAAC;IACtC,GAAG;AACL,EAAC"}

package/dist/queries/createJSONQuery/formatJSONPathSegment.d.ts

@@ -1,2 +0,0 @@
-export declare const formatJSONPathSegment: (segment: string) => string;
-//# sourceMappingURL=formatJSONPathSegment.d.ts.map

package/dist/queries/createJSONQuery/formatJSONPathSegment.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"formatJSONPathSegment.d.ts","sourceRoot":"","sources":["../../../src/queries/createJSONQuery/formatJSONPathSegment.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,qBAAqB,YAAa,MAAM,WAEpD,CAAA"}

package/dist/queries/createJSONQuery/formatJSONPathSegment.js

@@ -1,5 +0,0 @@
-export const formatJSONPathSegment = (segment)=>{
-    return Number.isNaN(parseInt(segment)) ? `'${segment}'` : segment;
-};
-
-//# sourceMappingURL=formatJSONPathSegment.js.map

package/dist/queries/createJSONQuery/formatJSONPathSegment.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/queries/createJSONQuery/formatJSONPathSegment.ts"],"sourcesContent":["export const formatJSONPathSegment = (segment: string) => {\n  return Number.isNaN(parseInt(segment)) ? `'${segment}'` : segment\n}\n"],"names":["formatJSONPathSegment","segment","Number","isNaN","parseInt"],"rangeMappings":";;","mappings":"AAAA,OAAO,MAAMA,wBAAwB,CAACC;IACpC,OAAOC,OAAOC,KAAK,CAACC,SAASH,YAAY,CAAC,CAAC,EAAEA,QAAQ,CAAC,CAAC,GAAGA;AAC5D,EAAC"}

package/dist/queries/createJSONQuery/index.d.ts

@@ -1,10 +0,0 @@
-type Args = {
-    operator: string;
-    pathSegments: string[];
-    treatAsArray?: string[];
-    treatRootAsArray?: boolean;
-    value: unknown;
-};
-export declare const createJSONQuery: ({ operator, pathSegments, treatAsArray, treatRootAsArray, value, }: Args) => string;
-export {};
-//# sourceMappingURL=index.d.ts.map

package/dist/queries/createJSONQuery/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/queries/createJSONQuery/index.ts"],"names":[],"mappings":"AAmDA,KAAK,IAAI,GAAG;IACV,QAAQ,EAAE,MAAM,CAAA;IAChB,YAAY,EAAE,MAAM,EAAE,CAAA;IACtB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAA;IACvB,gBAAgB,CAAC,EAAE,OAAO,CAAA;IAC1B,KAAK,EAAE,OAAO,CAAA;CACf,CAAA;AAED,eAAO,MAAM,eAAe,uEAMzB,IAAI,KAAG,MAqBT,CAAA"}

package/dist/queries/createJSONQuery/index.js

@@ -1,54 +0,0 @@
-import { convertPathToJSONTraversal } from './convertPathToJSONTraversal.js';
-import { formatJSONPathSegment } from './formatJSONPathSegment.js';
-const operatorMap = {
-    contains: '~*',
-    equals: '=',
-    like: '~*'
-};
-const fromArray = ({ isRoot, operator, pathSegments, treatAsArray, value })=>{
-    const newPathSegments = pathSegments.slice(isRoot ? 1 : 2);
-    const alias = `${pathSegments[isRoot ? 0 : 1]}_alias_${newPathSegments.length}`;
-    newPathSegments.unshift(alias);
-    const arrayElements = isRoot ? pathSegments[0] : `${pathSegments[0]} -> ${formatJSONPathSegment(pathSegments[1])}`;
-    return `EXISTS (
-    SELECT 1
-    FROM jsonb_array_elements(${arrayElements}) AS ${alias}
-    WHERE ${createJSONQuery({
-        operator,
-        pathSegments: newPathSegments,
-        treatAsArray,
-        value
-    })}
-  )`;
-};
-const createConstraint = ({ operator, pathSegments, value })=>{
-    const jsonQuery = convertPathToJSONTraversal(pathSegments);
-    return `${pathSegments[0]}${jsonQuery} ${operatorMap[operator]} '${value}'`;
-};
-export const createJSONQuery = ({ operator, pathSegments, treatAsArray, treatRootAsArray, value })=>{
-    if (treatRootAsArray) {
-        return fromArray({
-            isRoot: true,
-            operator,
-            pathSegments,
-            treatAsArray,
-            value
-        });
-    }
-    if (treatAsArray.includes(pathSegments[1])) {
-        return fromArray({
-            operator,
-            pathSegments,
-            treatAsArray,
-            value
-        });
-    }
-    return createConstraint({
-        operator,
-        pathSegments,
-        treatAsArray,
-        value
-    });
-};
-
-//# sourceMappingURL=index.js.map

package/dist/queries/createJSONQuery/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/queries/createJSONQuery/index.ts"],"sourcesContent":["import { convertPathToJSONTraversal } from './convertPathToJSONTraversal.js'\nimport { formatJSONPathSegment } from './formatJSONPathSegment.js'\n\nconst operatorMap = {\n  contains: '~*',\n  equals: '=',\n  like: '~*',\n}\n\ntype FromArrayArgs = {\n  isRoot?: true\n  operator: string\n  pathSegments: string[]\n  treatAsArray?: string[]\n  value: unknown\n}\n\nconst fromArray = ({ isRoot, operator, pathSegments, treatAsArray, value }: FromArrayArgs) => {\n  const newPathSegments = pathSegments.slice(isRoot ? 1 : 2)\n  const alias = `${pathSegments[isRoot ? 0 : 1]}_alias_${newPathSegments.length}`\n\n  newPathSegments.unshift(alias)\n\n  const arrayElements = isRoot\n    ? pathSegments[0]\n    : `${pathSegments[0]} -> ${formatJSONPathSegment(pathSegments[1])}`\n\n  return `EXISTS (\n    SELECT 1\n    FROM jsonb_array_elements(${arrayElements}) AS ${alias}\n    WHERE ${createJSONQuery({\n      operator,\n      pathSegments: newPathSegments,\n      treatAsArray,\n      value,\n    })}\n  )`\n}\n\ntype CreateConstraintArgs = {\n  operator: string\n  pathSegments: string[]\n  treatAsArray?: string[]\n  value: unknown\n}\n\nconst createConstraint = ({ operator, pathSegments, value }: CreateConstraintArgs): string => {\n  const jsonQuery = convertPathToJSONTraversal(pathSegments)\n  return `${pathSegments[0]}${jsonQuery} ${operatorMap[operator]} '${value}'`\n}\n\ntype Args = {\n  operator: string\n  pathSegments: string[]\n  treatAsArray?: string[]\n  treatRootAsArray?: boolean\n  value: unknown\n}\n\nexport const createJSONQuery = ({\n  operator,\n  pathSegments,\n  treatAsArray,\n  treatRootAsArray,\n  value,\n}: Args): string => {\n  if (treatRootAsArray) {\n    return fromArray({\n      isRoot: true,\n      operator,\n      pathSegments,\n      treatAsArray,\n      value,\n    })\n  }\n\n  if (treatAsArray.includes(pathSegments[1])) {\n    return fromArray({\n      operator,\n      pathSegments,\n      treatAsArray,\n      value,\n    })\n  }\n\n  return createConstraint({ operator, pathSegments, treatAsArray, value })\n}\n"],"names":["convertPathToJSONTraversal","formatJSONPathSegment","operatorMap","contains","equals","like","fromArray","isRoot","operator","pathSegments","treatAsArray","value","newPathSegments","slice","alias","length","unshift","arrayElements","createJSONQuery","createConstraint","jsonQuery","treatRootAsArray","includes"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,SAASA,0BAA0B,QAAQ,kCAAiC;AAC5E,SAASC,qBAAqB,QAAQ,6BAA4B;AAElE,MAAMC,cAAc;IAClBC,UAAU;IACVC,QAAQ;IACRC,MAAM;AACR;AAUA,MAAMC,YAAY,CAAC,EAAEC,MAAM,EAAEC,QAAQ,EAAEC,YAAY,EAAEC,YAAY,EAAEC,KAAK,EAAiB;IACvF,MAAMC,kBAAkBH,aAAaI,KAAK,CAACN,SAAS,IAAI;IACxD,MAAMO,QAAQ,CAAC,EAAEL,YAAY,CAACF,SAAS,IAAI,EAAE,CAAC,OAAO,EAAEK,gBAAgBG,MAAM,CAAC,CAAC;IAE/EH,gBAAgBI,OAAO,CAACF;IAExB,MAAMG,gBAAgBV,SAClBE,YAAY,CAAC,EAAE,GACf,CAAC,EAAEA,YAAY,CAAC,EAAE,CAAC,IAAI,EAAER,sBAAsBQ,YAAY,CAAC,EAAE,EAAE,CAAC;IAErE,OAAO,CAAC;;8BAEoB,EAAEQ,cAAc,KAAK,EAAEH,MAAM;UACjD,EAAEI,gBAAgB;QACtBV;QACAC,cAAcG;QACdF;QACAC;IACF,GAAG;GACJ,CAAC;AACJ;AASA,MAAMQ,mBAAmB,CAAC,EAAEX,QAAQ,EAAEC,YAAY,EAAEE,KAAK,EAAwB;IAC/E,MAAMS,YAAYpB,2BAA2BS;IAC7C,OAAO,CAAC,EAAEA,YAAY,CAAC,EAAE,CAAC,EAAEW,UAAU,CAAC,EAAElB,WAAW,CAACM,SAAS,CAAC,EAAE,EAAEG,MAAM,CAAC,CAAC;AAC7E;AAUA,OAAO,MAAMO,kBAAkB,CAAC,EAC9BV,QAAQ,EACRC,YAAY,EACZC,YAAY,EACZW,gBAAgB,EAChBV,KAAK,EACA;IACL,IAAIU,kBAAkB;QACpB,OAAOf,UAAU;YACfC,QAAQ;YACRC;YACAC;YACAC;YACAC;QACF;IACF;IAEA,IAAID,aAAaY,QAAQ,CAACb,YAAY,CAAC,EAAE,GAAG;QAC1C,OAAOH,UAAU;YACfE;YACAC;YACAC;YACAC;QACF;IACF;IAEA,OAAOQ,iBAAiB;QAAEX;QAAUC;QAAcC;QAAcC;IAAM;AACxE,EAAC"}

package/dist/queries/getTableColumnFromPath.d.ts

@@ -1,51 +0,0 @@
-import type { SQL } from 'drizzle-orm';
-import type { PgTableWithColumns } from 'drizzle-orm/pg-core';
-import type { Field, FieldAffectingData, TabAsField } from 'payload/types';
-import type { GenericColumn, GenericTable, PostgresAdapter } from '../types.js';
-import type { BuildQueryJoinAliases, BuildQueryJoins } from './buildQuery.js';
-type Constraint = {
-    columnName: string;
-    table: GenericTable | PgTableWithColumns<any>;
-    value: unknown;
-};
-type TableColumn = {
-    columnName?: string;
-    constraints: Constraint[];
-    field: FieldAffectingData;
-    getNotNullColumnByValue?: (val: unknown) => string;
-    pathSegments?: string[];
-    rawColumn?: SQL;
-    table: GenericTable | PgTableWithColumns<any>;
-};
-type Args = {
-    adapter: PostgresAdapter;
-    aliasTable?: GenericTable | PgTableWithColumns<any>;
-    collectionPath: string;
-    columnPrefix?: string;
-    constraintPath?: string;
-    constraints?: Constraint[];
-    fields: (Field | TabAsField)[];
-    joinAliases: BuildQueryJoinAliases;
-    joins: BuildQueryJoins;
-    locale?: string;
-    pathSegments: string[];
-    rootTableName?: string;
-    selectFields: Record<string, GenericColumn>;
-    tableName: string;
-    /**
-     * If creating a new table name for arrays and blocks, this suffix should be appended to the table name
-     */
-    tableNameSuffix?: string;
-    /**
-     * The raw value of the query before sanitization
-     */
-    value: unknown;
-};
-/**
- * Transforms path to table and column name
- * Adds tables to `join`
- * @returns TableColumn
- */
-export declare const getTableColumnFromPath: ({ adapter, aliasTable, collectionPath, columnPrefix, constraintPath: incomingConstraintPath, constraints, fields, joinAliases, joins, locale: incomingLocale, pathSegments: incomingSegments, rootTableName: incomingRootTableName, selectFields, tableName, tableNameSuffix, value, }: Args) => TableColumn;
-export {};
-//# sourceMappingURL=getTableColumnFromPath.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"getTableColumnFromPath.d.ts","sourceRoot":"","sources":["../../src/queries/getTableColumnFromPath.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,aAAa,CAAA;AACtC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAA;AAC7D,OAAO,KAAK,EAAE,KAAK,EAAE,kBAAkB,EAAe,UAAU,EAAa,MAAM,eAAe,CAAA;AAUlG,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAC/E,OAAO,KAAK,EAAE,qBAAqB,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAA;AAE7E,KAAK,UAAU,GAAG;IAChB,UAAU,EAAE,MAAM,CAAA;IAClB,KAAK,EAAE,YAAY,GAAG,kBAAkB,CAAC,GAAG,CAAC,CAAA;IAC7C,KAAK,EAAE,OAAO,CAAA;CACf,CAAA;AAED,KAAK,WAAW,GAAG;IACjB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,WAAW,EAAE,UAAU,EAAE,CAAA;IACzB,KAAK,EAAE,kBAAkB,CAAA;IACzB,uBAAuB,CAAC,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,MAAM,CAAA;IAClD,YAAY,CAAC,EAAE,MAAM,EAAE,CAAA;IACvB,SAAS,CAAC,EAAE,GAAG,CAAA;IACf,KAAK,EAAE,YAAY,GAAG,kBAAkB,CAAC,GAAG,CAAC,CAAA;CAC9C,CAAA;AAED,KAAK,IAAI,GAAG;IACV,OAAO,EAAE,eAAe,CAAA;IACxB,UAAU,CAAC,EAAE,YAAY,GAAG,kBAAkB,CAAC,GAAG,CAAC,CAAA;IACnD,cAAc,EAAE,MAAM,CAAA;IACtB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,WAAW,CAAC,EAAE,UAAU,EAAE,CAAA;IAC1B,MAAM,EAAE,CAAC,KAAK,GAAG,UAAU,CAAC,EAAE,CAAA;IAC9B,WAAW,EAAE,qBAAqB,CAAA;IAClC,KAAK,EAAE,eAAe,CAAA;IACtB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,YAAY,EAAE,MAAM,EAAE,CAAA;IACtB,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA;IAC3C,SAAS,EAAE,MAAM,CAAA;IACjB;;OAEG;IACH,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB;;OAEG;IACH,KAAK,EAAE,OAAO,CAAA;CACf,CAAA;AACD;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,2RAiBhC,IAAI,KAAG,WA4fT,CAAA"}

package/dist/queries/getTableColumnFromPath.js

@@ -1,445 +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';
-/**
- * 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 = `${tableName}${adapter.localesSuffix}`;
-                        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 'select':
-                {
-                    if (field.hasMany) {
-                        const newTableName = adapter.tableNameMap.get(`${tableName}_${tableNameSuffix}${toSnakeCase(field.name)}`);
-                        if (locale && field.localized && adapter.payload.config.localization) {
-                            joins[newTableName] = and(eq(adapter.tables[tableName].id, adapter.tables[newTableName].parent), 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].parent);
-                        }
-                        return {
-                            columnName: 'value',
-                            constraints,
-                            field,
-                            table: adapter.tables[newTableName]
-                        };
-                    }
-                    break;
-                }
-            case 'text':
-            case 'number':
-                {
-                    if (field.hasMany) {
-                        let tableType = 'texts';
-                        let columnName = 'text';
-                        if (field.type === 'number') {
-                            tableType = 'numbers';
-                            columnName = 'number';
-                        }
-                        newTableName = `${tableName}_${tableType}`;
-                        const joinConstraints = [
-                            eq(adapter.tables[tableName].id, adapter.tables[newTableName].parent),
-                            eq(adapter.tables[newTableName].path, `${constraintPath}${field.name}`)
-                        ];
-                        if (locale && field.localized && adapter.payload.config.localization) {
-                            joins[newTableName] = and(...joinConstraints, eq(adapter.tables[newTableName]._locale, locale));
-                            if (locale !== 'all') {
-                                constraints.push({
-                                    columnName: 'locale',
-                                    table: adapter.tables[newTableName],
-                                    value: locale
-                                });
-                            }
-                        } else {
-                            joins[newTableName] = and(...joinConstraints);
-                        }
-                        return {
-                            columnName,
-                            constraints,
-                            field,
-                            table: adapter.tables[newTableName]
-                        };
-                    }
-                    break;
-                }
-            case 'array':
-                {
-                    newTableName = adapter.tableNameMap.get(`${tableName}_${tableNameSuffix}${toSnakeCase(field.name)}`);
-                    constraintPath = `${constraintPath}${field.name}.%.`;
-                    if (locale && field.localized && adapter.payload.config.localization) {
-                        joins[newTableName] = and(eq(adapter.tables[tableName].id, adapter.tables[newTableName]._parentID), eq(adapter.tables[newTableName]._locale, locale));
-                        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 = adapter.tableNameMap.get(`${tableName}_blocks_${toSnakeCase(block.slug)}`);
-                            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 = adapter.tableNameMap.get(`${tableName}_blocks_${toSnakeCase(block.slug)}`);
-                        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 = adapter.tableNameMap.get(toSnakeCase(relationshipConfig.slug));
-                        // 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)=>{
-                            const relationTableName = adapter.tableNameMap.get(toSnakeCase(adapter.payload.collections[relationTo].config.slug));
-                            return `"${aliasRelationshipTableName}"."${relationTableName}_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
-                    });
-                }
-        }
-        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