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

package/dist/queries/parseParams.js

@@ -1,182 +0,0 @@
-/* eslint-disable no-await-in-loop */ import { and, ilike, isNotNull, isNull, ne, notInArray, or, sql } from 'drizzle-orm';
-import { QueryError } from 'payload/errors';
-import { validOperators } from 'payload/types';
-import { buildAndOrConditions } from './buildAndOrConditions.js';
-import { convertPathToJSONTraversal } from './createJSONQuery/convertPathToJSONTraversal.js';
-import { createJSONQuery } from './createJSONQuery/index.js';
-import { getTableColumnFromPath } from './getTableColumnFromPath.js';
-import { operatorMap } from './operatorMap.js';
-import { sanitizeQueryValue } from './sanitizeQueryValue.js';
-export 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 buildAndOrConditions({
-                        adapter,
-                        fields,
-                        joinAliases,
-                        joins,
-                        locale,
-                        selectFields,
-                        tableName,
-                        where: condition
-                    });
-                    if (builtConditions.length > 0) {
-                        result = 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 (validOperators.includes(operator)) {
-                                const val = where[relationOrPath][operator];
-                                const { columnName, constraints: queryConstraints, field, getNotNullColumnByValue, pathSegments, rawColumn, table } = getTableColumnFromPath({
-                                    adapter,
-                                    collectionPath: relationOrPath,
-                                    fields,
-                                    joinAliases,
-                                    joins,
-                                    locale,
-                                    pathSegments: relationOrPath.replace(/__/g, '.').split('.'),
-                                    selectFields,
-                                    tableName,
-                                    value: val
-                                });
-                                queryConstraints.forEach(({ columnName: col, table: constraintTable, value })=>{
-                                    if (typeof value === 'string' && value.indexOf('%') > -1) {
-                                        constraints.push(operatorMap.like(constraintTable[col], value));
-                                    } else {
-                                        constraints.push(operatorMap.equals(constraintTable[col], value));
-                                    }
-                                });
-                                if ([
-                                    'json',
-                                    'richText'
-                                ].includes(field.type) && Array.isArray(pathSegments) && pathSegments.length > 1) {
-                                    const segments = pathSegments.slice(1);
-                                    segments.unshift(table[columnName].name);
-                                    if (field.type === 'richText') {
-                                        const jsonQuery = createJSONQuery({
-                                            operator,
-                                            pathSegments: segments,
-                                            treatAsArray: [
-                                                'children'
-                                            ],
-                                            treatRootAsArray: true,
-                                            value: val
-                                        });
-                                        constraints.push(sql.raw(jsonQuery));
-                                        break;
-                                    }
-                                    const jsonQuery = convertPathToJSONTraversal(pathSegments);
-                                    const operatorKeys = {
-                                        contains: {
-                                            operator: 'ilike',
-                                            wildcard: '%'
-                                        },
-                                        equals: {
-                                            operator: '=',
-                                            wildcard: ''
-                                        },
-                                        exists: {
-                                            operator: val === true ? 'is not null' : 'is null'
-                                        },
-                                        like: {
-                                            operator: 'like',
-                                            wildcard: '%'
-                                        },
-                                        not_equals: {
-                                            operator: '<>',
-                                            wildcard: ''
-                                        }
-                                    };
-                                    let formattedValue = `'${operatorKeys[operator].wildcard}${val}${operatorKeys[operator].wildcard}'`;
-                                    if (operator === 'exists') {
-                                        formattedValue = '';
-                                    }
-                                    constraints.push(sql.raw(`${table[columnName].name}${jsonQuery} ${operatorKeys[operator].operator} ${formattedValue}`));
-                                    break;
-                                }
-                                if (getNotNullColumnByValue) {
-                                    const columnName = getNotNullColumnByValue(val);
-                                    if (columnName) {
-                                        constraints.push(isNotNull(table[columnName]));
-                                    } else {
-                                        throw new QueryError([
-                                            {
-                                                path: relationOrPath
-                                            }
-                                        ]);
-                                    }
-                                    break;
-                                }
-                                if (operator === 'like') {
-                                    constraints.push(and(...val.split(' ').map((word)=>ilike(table[columnName], `%${word}%`))));
-                                    break;
-                                }
-                                const sanitizedQueryValue = sanitizeQueryValue({
-                                    adapter,
-                                    field,
-                                    operator,
-                                    relationOrPath,
-                                    val
-                                });
-                                if (sanitizedQueryValue === null) {
-                                    break;
-                                }
-                                const { operator: queryOperator, value: queryValue } = sanitizedQueryValue;
-                                if (queryOperator === 'not_equals' && queryValue !== null) {
-                                    constraints.push(or(isNull(rawColumn || table[columnName]), /* eslint-disable @typescript-eslint/no-explicit-any */ ne(rawColumn || table[columnName], queryValue)));
-                                    break;
-                                }
-                                if ((field.type === 'relationship' || field.type === 'upload') && Array.isArray(queryValue) && operator === 'not_in') {
-                                    constraints.push(sql`${notInArray(table[columnName], queryValue)} OR
-                    ${table[columnName]}
-                    IS
-                    NULL`);
-                                    break;
-                                }
-                                if (operator === 'equals' && queryValue === null) {
-                                    constraints.push(isNull(rawColumn || table[columnName]));
-                                    break;
-                                }
-                                if (operator === 'not_equals' && queryValue === null) {
-                                    constraints.push(isNotNull(rawColumn || table[columnName]));
-                                    break;
-                                }
-                                constraints.push(operatorMap[queryOperator](rawColumn || table[columnName], queryValue));
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-    if (constraints.length > 0) {
-        if (result) {
-            result = and(result, ...constraints);
-        } else {
-            result = and(...constraints);
-        }
-    }
-    if (constraints.length === 1 && !result) {
-        [result] = constraints;
-    }
-    return result;
-}
-
-//# sourceMappingURL=parseParams.js.map

package/dist/queries/parseParams.js.map

@@ -1 +0,0 @@
-{"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, notInArray, or, sql } from 'drizzle-orm'\nimport { QueryError } from 'payload/errors'\nimport { validOperators } from 'payload/types'\n\nimport type { GenericColumn, PostgresAdapter } from '../types.js'\nimport type { BuildQueryJoinAliases, BuildQueryJoins } from './buildQuery.js'\n\nimport { buildAndOrConditions } from './buildAndOrConditions.js'\nimport { convertPathToJSONTraversal } from './createJSONQuery/convertPathToJSONTraversal.js'\nimport { createJSONQuery } from './createJSONQuery/index.js'\nimport { getTableColumnFromPath } from './getTableColumnFromPath.js'\nimport { operatorMap } from './operatorMap.js'\nimport { sanitizeQueryValue } from './sanitizeQueryValue.js'\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            result = operatorMap[conditionOperator](...builtConditions)\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 val = where[relationOrPath][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                  value: val,\n                })\n\n                queryConstraints.forEach(({ columnName: col, table: constraintTable, value }) => {\n                  if (typeof value === 'string' && value.indexOf('%') > -1) {\n                    constraints.push(operatorMap.like(constraintTable[col], value))\n                  } else {\n                    constraints.push(operatorMap.equals(constraintTable[col], value))\n                  }\n                })\n\n                if (\n                  ['json', 'richText'].includes(field.type) &&\n                  Array.isArray(pathSegments) &&\n                  pathSegments.length > 1\n                ) {\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                    break\n                  }\n\n                  const jsonQuery = convertPathToJSONTraversal(pathSegments)\n                  const operatorKeys = {\n                    contains: { operator: 'ilike', wildcard: '%' },\n                    equals: { operator: '=', wildcard: '' },\n                    exists: { operator: val === true ? 'is not null' : 'is null' },\n                    like: { operator: 'like', wildcard: '%' },\n                    not_equals: { operator: '<>', wildcard: '' },\n                  }\n                  let formattedValue = `'${operatorKeys[operator].wildcard}${val}${operatorKeys[operator].wildcard}'`\n\n                  if (operator === 'exists') {\n                    formattedValue = ''\n                  }\n\n                  constraints.push(\n                    sql.raw(\n                      `${table[columnName].name}${jsonQuery} ${operatorKeys[operator].operator} ${formattedValue}`,\n                    ),\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 sanitizedQueryValue = sanitizeQueryValue({\n                  adapter,\n                  field,\n                  operator,\n                  relationOrPath,\n                  val,\n                })\n\n                if (sanitizedQueryValue === null) {\n                  break\n                }\n\n                const { operator: queryOperator, value: queryValue } = sanitizedQueryValue\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                  break\n                }\n\n                if (\n                  (field.type === 'relationship' || field.type === 'upload') &&\n                  Array.isArray(queryValue) &&\n                  operator === 'not_in'\n                ) {\n                  constraints.push(\n                    sql`${notInArray(table[columnName], queryValue)} OR\n                    ${table[columnName]}\n                    IS\n                    NULL`,\n                  )\n\n                  break\n                }\n\n                if (operator === 'equals' && queryValue === null) {\n                  constraints.push(isNull(rawColumn || table[columnName]))\n                  break\n                }\n\n                if (operator === 'not_equals' && queryValue === null) {\n                  constraints.push(isNotNull(rawColumn || table[columnName]))\n                  break\n                }\n\n                constraints.push(\n                  operatorMap[queryOperator](rawColumn || table[columnName], queryValue),\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":["and","ilike","isNotNull","isNull","ne","notInArray","or","sql","QueryError","validOperators","buildAndOrConditions","convertPathToJSONTraversal","createJSONQuery","getTableColumnFromPath","operatorMap","sanitizeQueryValue","parseParams","adapter","fields","joinAliases","joins","locale","selectFields","tableName","where","result","constraints","Object","keys","length","relationOrPath","condition","conditionOperator","toLowerCase","Array","isArray","builtConditions","pathOperators","operator","includes","val","columnName","queryConstraints","field","getNotNullColumnByValue","pathSegments","rawColumn","table","collectionPath","replace","split","value","forEach","col","constraintTable","indexOf","push","like","equals","type","segments","slice","unshift","name","jsonQuery","treatAsArray","treatRootAsArray","raw","operatorKeys","contains","wildcard","exists","not_equals","formattedValue","path","map","word","sanitizedQueryValue","queryOperator","queryValue"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,mCAAmC,GAInC,SAASA,GAAG,EAAEC,KAAK,EAAEC,SAAS,EAAEC,MAAM,EAAEC,EAAE,EAAEC,UAAU,EAAEC,EAAE,EAAEC,GAAG,QAAQ,cAAa;AACpF,SAASC,UAAU,QAAQ,iBAAgB;AAC3C,SAASC,cAAc,QAAQ,gBAAe;AAK9C,SAASC,oBAAoB,QAAQ,4BAA2B;AAChE,SAASC,0BAA0B,QAAQ,kDAAiD;AAC5F,SAASC,eAAe,QAAQ,6BAA4B;AAC5D,SAASC,sBAAsB,QAAQ,8BAA6B;AACpE,SAASC,WAAW,QAAQ,mBAAkB;AAC9C,SAASC,kBAAkB,QAAQ,0BAAyB;AAa5D,OAAO,eAAeC,YAAY,EAChCC,OAAO,EACPC,MAAM,EACNC,WAAW,EACXC,KAAK,EACLC,MAAM,EACNC,YAAY,EACZC,SAAS,EACTC,KAAK,EACA;IACL,IAAIC;IACJ,MAAMC,cAAqB,EAAE;IAE7B,IAAI,OAAOF,UAAU,YAAYG,OAAOC,IAAI,CAACJ,OAAOK,MAAM,GAAG,GAAG;QAC9D,uEAAuE;QACvE,KAAK,MAAMC,kBAAkBH,OAAOC,IAAI,CAACJ,OAAQ;YAC/C,IAAIM,gBAAgB;gBAClB,MAAMC,YAAYP,KAAK,CAACM,eAAe;gBACvC,IAAIE;gBACJ,IAAIF,eAAeG,WAAW,OAAO,OAAO;oBAC1CD,oBAAoB;gBACtB,OAAO,IAAIF,eAAeG,WAAW,OAAO,MAAM;oBAChDD,oBAAoB;gBACtB;gBACA,IAAIE,MAAMC,OAAO,CAACJ,YAAY;oBAC5B,MAAMK,kBAAkB,MAAM1B,qBAAqB;wBACjDO;wBACAC;wBACAC;wBACAC;wBACAC;wBACAC;wBACAC;wBACAC,OAAOO;oBACT;oBACA,IAAIK,gBAAgBP,MAAM,GAAG,GAAG;wBAC9BJ,SAASX,WAAW,CAACkB,kBAAkB,IAAII;oBAC7C;gBACF,OAAO;oBACL,wEAAwE;oBACxE,kEAAkE;oBAClE,8EAA8E;oBAC9E,MAAMC,gBAAgBb,KAAK,CAACM,eAAe;oBAC3C,IAAI,OAAOO,kBAAkB,UAAU;wBACrC,KAAK,MAAMC,YAAYX,OAAOC,IAAI,CAACS,eAAgB;4BACjD,IAAI5B,eAAe8B,QAAQ,CAACD,WAAuB;gCACjD,MAAME,MAAMhB,KAAK,CAACM,eAAe,CAACQ,SAAS;gCAC3C,MAAM,EACJG,UAAU,EACVf,aAAagB,gBAAgB,EAC7BC,KAAK,EACLC,uBAAuB,EACvBC,YAAY,EACZC,SAAS,EACTC,KAAK,EACN,GAAGlC,uBAAuB;oCACzBI;oCACA+B,gBAAgBlB;oCAChBZ;oCACAC;oCACAC;oCACAC;oCACAwB,cAAcf,eAAemB,OAAO,CAAC,OAAO,KAAKC,KAAK,CAAC;oCACvD5B;oCACAC;oCACA4B,OAAOX;gCACT;gCAEAE,iBAAiBU,OAAO,CAAC,CAAC,EAAEX,YAAYY,GAAG,EAAEN,OAAOO,eAAe,EAAEH,KAAK,EAAE;oCAC1E,IAAI,OAAOA,UAAU,YAAYA,MAAMI,OAAO,CAAC,OAAO,CAAC,GAAG;wCACxD7B,YAAY8B,IAAI,CAAC1C,YAAY2C,IAAI,CAACH,eAAe,CAACD,IAAI,EAAEF;oCAC1D,OAAO;wCACLzB,YAAY8B,IAAI,CAAC1C,YAAY4C,MAAM,CAACJ,eAAe,CAACD,IAAI,EAAEF;oCAC5D;gCACF;gCAEA,IACE;oCAAC;oCAAQ;iCAAW,CAACZ,QAAQ,CAACI,MAAMgB,IAAI,KACxCzB,MAAMC,OAAO,CAACU,iBACdA,aAAahB,MAAM,GAAG,GACtB;oCACA,MAAM+B,WAAWf,aAAagB,KAAK,CAAC;oCACpCD,SAASE,OAAO,CAACf,KAAK,CAACN,WAAW,CAACsB,IAAI;oCAEvC,IAAIpB,MAAMgB,IAAI,KAAK,YAAY;wCAC7B,MAAMK,YAAYpD,gBAAgB;4CAChC0B;4CACAO,cAAce;4CACdK,cAAc;gDAAC;6CAAW;4CAC1BC,kBAAkB;4CAClBf,OAAOX;wCACT;wCAEAd,YAAY8B,IAAI,CAACjD,IAAI4D,GAAG,CAACH;wCACzB;oCACF;oCAEA,MAAMA,YAAYrD,2BAA2BkC;oCAC7C,MAAMuB,eAAe;wCACnBC,UAAU;4CAAE/B,UAAU;4CAASgC,UAAU;wCAAI;wCAC7CZ,QAAQ;4CAAEpB,UAAU;4CAAKgC,UAAU;wCAAG;wCACtCC,QAAQ;4CAAEjC,UAAUE,QAAQ,OAAO,gBAAgB;wCAAU;wCAC7DiB,MAAM;4CAAEnB,UAAU;4CAAQgC,UAAU;wCAAI;wCACxCE,YAAY;4CAAElC,UAAU;4CAAMgC,UAAU;wCAAG;oCAC7C;oCACA,IAAIG,iBAAiB,CAAC,CAAC,EAAEL,YAAY,CAAC9B,SAAS,CAACgC,QAAQ,CAAC,EAAE9B,IAAI,EAAE4B,YAAY,CAAC9B,SAAS,CAACgC,QAAQ,CAAC,CAAC,CAAC;oCAEnG,IAAIhC,aAAa,UAAU;wCACzBmC,iBAAiB;oCACnB;oCAEA/C,YAAY8B,IAAI,CACdjD,IAAI4D,GAAG,CACL,CAAC,EAAEpB,KAAK,CAACN,WAAW,CAACsB,IAAI,CAAC,EAAEC,UAAU,CAAC,EAAEI,YAAY,CAAC9B,SAAS,CAACA,QAAQ,CAAC,CAAC,EAAEmC,eAAe,CAAC;oCAIhG;gCACF;gCAEA,IAAI7B,yBAAyB;oCAC3B,MAAMH,aAAaG,wBAAwBJ;oCAC3C,IAAIC,YAAY;wCACdf,YAAY8B,IAAI,CAACtD,UAAU6C,KAAK,CAACN,WAAW;oCAC9C,OAAO;wCACL,MAAM,IAAIjC,WAAW;4CAAC;gDAAEkE,MAAM5C;4CAAe;yCAAE;oCACjD;oCACA;gCACF;gCAEA,IAAIQ,aAAa,QAAQ;oCACvBZ,YAAY8B,IAAI,CACdxD,OAAOwC,IAAIU,KAAK,CAAC,KAAKyB,GAAG,CAAC,CAACC,OAAS3E,MAAM8C,KAAK,CAACN,WAAW,EAAE,CAAC,CAAC,EAAEmC,KAAK,CAAC,CAAC;oCAE1E;gCACF;gCAEA,MAAMC,sBAAsB9D,mBAAmB;oCAC7CE;oCACA0B;oCACAL;oCACAR;oCACAU;gCACF;gCAEA,IAAIqC,wBAAwB,MAAM;oCAChC;gCACF;gCAEA,MAAM,EAAEvC,UAAUwC,aAAa,EAAE3B,OAAO4B,UAAU,EAAE,GAAGF;gCAEvD,IAAIC,kBAAkB,gBAAgBC,eAAe,MAAM;oCACzDrD,YAAY8B,IAAI,CACdlD,GACEH,OAAO2C,aAAaC,KAAK,CAACN,WAAW,GACrC,qDAAqD,GACrDrC,GAAQ0C,aAAaC,KAAK,CAACN,WAAW,EAAEsC;oCAG5C;gCACF;gCAEA,IACE,AAACpC,CAAAA,MAAMgB,IAAI,KAAK,kBAAkBhB,MAAMgB,IAAI,KAAK,QAAO,KACxDzB,MAAMC,OAAO,CAAC4C,eACdzC,aAAa,UACb;oCACAZ,YAAY8B,IAAI,CACdjD,GAAG,CAAC,EAAEF,WAAW0C,KAAK,CAACN,WAAW,EAAEsC,YAAY;oBAChD,EAAEhC,KAAK,CAACN,WAAW,CAAC;;wBAEhB,CAAC;oCAGP;gCACF;gCAEA,IAAIH,aAAa,YAAYyC,eAAe,MAAM;oCAChDrD,YAAY8B,IAAI,CAACrD,OAAO2C,aAAaC,KAAK,CAACN,WAAW;oCACtD;gCACF;gCAEA,IAAIH,aAAa,gBAAgByC,eAAe,MAAM;oCACpDrD,YAAY8B,IAAI,CAACtD,UAAU4C,aAAaC,KAAK,CAACN,WAAW;oCACzD;gCACF;gCAEAf,YAAY8B,IAAI,CACd1C,WAAW,CAACgE,cAAc,CAAChC,aAAaC,KAAK,CAACN,WAAW,EAAEsC;4BAE/D;wBACF;oBACF;gBACF;YACF;QACF;IACF;IACA,IAAIrD,YAAYG,MAAM,GAAG,GAAG;QAC1B,IAAIJ,QAAQ;YACVA,SAASzB,IAAIyB,WAAWC;QAC1B,OAAO;YACLD,SAASzB,OAAO0B;QAClB;IACF;IACA,IAAIA,YAAYG,MAAM,KAAK,KAAK,CAACJ,QAAQ;QACtC,CAACA,OAAO,GAAGC;IACd;IAEA,OAAOD;AACT"}

package/dist/queries/sanitizeQueryValue.d.ts

@@ -1,15 +0,0 @@
-import { type Field, type TabAsField } from 'payload/types';
-import type { PostgresAdapter } from '../types.js';
-type SanitizeQueryValueArgs = {
-    adapter: PostgresAdapter;
-    field: Field | TabAsField;
-    operator: string;
-    relationOrPath: string;
-    val: any;
-};
-export declare const sanitizeQueryValue: ({ adapter, field, operator: operatorArg, relationOrPath, val, }: SanitizeQueryValueArgs) => {
-    operator: string;
-    value: unknown;
-};
-export {};
-//# sourceMappingURL=sanitizeQueryValue.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"sanitizeQueryValue.d.ts","sourceRoot":"","sources":["../../src/queries/sanitizeQueryValue.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,KAAK,EAAE,KAAK,UAAU,EAAoB,MAAM,eAAe,CAAA;AAG7E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAElD,KAAK,sBAAsB,GAAG;IAC5B,OAAO,EAAE,eAAe,CAAA;IACxB,KAAK,EAAE,KAAK,GAAG,UAAU,CAAA;IACzB,QAAQ,EAAE,MAAM,CAAA;IAChB,cAAc,EAAE,MAAM,CAAA;IACtB,GAAG,EAAE,GAAG,CAAA;CACT,CAAA;AAED,eAAO,MAAM,kBAAkB,oEAM5B,sBAAsB,KAAG;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAyF7D,CAAA"}

package/dist/queries/sanitizeQueryValue.js

@@ -1,90 +0,0 @@
-import { APIError } from 'payload/errors';
-import { fieldAffectsData } from 'payload/types';
-import { createArrayFromCommaDelineated } from 'payload/utilities';
-export const sanitizeQueryValue = ({ adapter, field, operator: operatorArg, relationOrPath, val })=>{
-    let operator = operatorArg;
-    let formattedValue = val;
-    if (!fieldAffectsData(field)) return {
-        operator,
-        value: formattedValue
-    };
-    if ((field.type === 'relationship' || field.type === 'upload') && !relationOrPath.endsWith('relationTo') && Array.isArray(formattedValue)) {
-        const allPossibleIDTypes = [];
-        formattedValue.forEach((val)=>{
-            if (adapter.idType !== 'uuid' && typeof val === 'string') {
-                allPossibleIDTypes.push(val, parseInt(val));
-            } else if (typeof val === 'string') {
-                allPossibleIDTypes.push(val);
-            } else {
-                allPossibleIDTypes.push(val, String(val));
-            }
-        });
-        formattedValue = allPossibleIDTypes;
-    }
-    // Cast incoming values as proper searchable types
-    if (field.type === 'checkbox' && typeof val === 'string') {
-        if (val.toLowerCase() === 'true') formattedValue = true;
-        if (val.toLowerCase() === 'false') formattedValue = false;
-    }
-    if ([
-        'all',
-        'in',
-        'not_in'
-    ].includes(operator)) {
-        if (typeof formattedValue === 'string') {
-            formattedValue = createArrayFromCommaDelineated(formattedValue);
-            if (field.type === 'number') {
-                formattedValue = formattedValue.map((arrayVal)=>parseFloat(arrayVal));
-            }
-        }
-        if (!Array.isArray(formattedValue) || formattedValue.length === 0) {
-            return null;
-        }
-    }
-    if (field.type === 'number' && typeof formattedValue === 'string') {
-        formattedValue = Number(val);
-    }
-    if (field.type === 'date' && operator !== 'exists') {
-        if (typeof val === 'string') {
-            formattedValue = new Date(val);
-            if (Number.isNaN(Date.parse(formattedValue))) {
-                return {
-                    operator,
-                    value: undefined
-                };
-            }
-        }
-        if (typeof val === 'number') {
-            formattedValue = new Date(val);
-        }
-    }
-    if ([
-        'relationship',
-        'upload'
-    ].includes(field.type)) {
-        if (val === 'null') {
-            formattedValue = null;
-        }
-    }
-    if ('hasMany' in field && field.hasMany && operator === 'contains') {
-        operator = 'equals';
-    }
-    if (operator === 'near' || operator === 'within' || operator === 'intersects') {
-        throw new APIError(`Querying with '${operator}' is not supported with the postgres database adapter.`);
-    }
-    if (operator === 'contains') {
-        formattedValue = `%${formattedValue}%`;
-    }
-    if (operator === 'exists') {
-        formattedValue = formattedValue === 'true' || formattedValue === true;
-        if (formattedValue === false) {
-            operator = 'isNull';
-        }
-    }
-    return {
-        operator,
-        value: formattedValue
-    };
-};
-
-//# sourceMappingURL=sanitizeQueryValue.js.map

package/dist/queries/sanitizeQueryValue.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/queries/sanitizeQueryValue.ts"],"sourcesContent":["import { APIError } from 'payload/errors'\nimport { type Field, type TabAsField, fieldAffectsData } from 'payload/types'\nimport { createArrayFromCommaDelineated } from 'payload/utilities'\n\nimport type { PostgresAdapter } from '../types.js'\n\ntype SanitizeQueryValueArgs = {\n  adapter: PostgresAdapter\n  field: Field | TabAsField\n  operator: string\n  relationOrPath: string\n  val: any\n}\n\nexport const sanitizeQueryValue = ({\n  adapter,\n  field,\n  operator: operatorArg,\n  relationOrPath,\n  val,\n}: SanitizeQueryValueArgs): { operator: string; value: unknown } => {\n  let operator = operatorArg\n  let formattedValue = val\n\n  if (!fieldAffectsData(field)) return { operator, value: formattedValue }\n\n  if (\n    (field.type === 'relationship' || field.type === 'upload') &&\n    !relationOrPath.endsWith('relationTo') &&\n    Array.isArray(formattedValue)\n  ) {\n    const allPossibleIDTypes: (number | string)[] = []\n    formattedValue.forEach((val) => {\n      if (adapter.idType !== 'uuid' && typeof val === 'string') {\n        allPossibleIDTypes.push(val, parseInt(val))\n      } else if (typeof val === 'string') {\n        allPossibleIDTypes.push(val)\n      } else {\n        allPossibleIDTypes.push(val, String(val))\n      }\n    })\n    formattedValue = allPossibleIDTypes\n  }\n\n  // Cast incoming values as proper searchable types\n  if (field.type === 'checkbox' && typeof val === 'string') {\n    if (val.toLowerCase() === 'true') formattedValue = true\n    if (val.toLowerCase() === 'false') formattedValue = false\n  }\n\n  if (['all', 'in', 'not_in'].includes(operator)) {\n    if (typeof formattedValue === 'string') {\n      formattedValue = createArrayFromCommaDelineated(formattedValue)\n\n      if (field.type === 'number') {\n        formattedValue = formattedValue.map((arrayVal) => parseFloat(arrayVal))\n      }\n    }\n\n    if (!Array.isArray(formattedValue) || formattedValue.length === 0) {\n      return null\n    }\n  }\n\n  if (field.type === 'number' && typeof formattedValue === 'string') {\n    formattedValue = Number(val)\n  }\n\n  if (field.type === 'date' && operator !== 'exists') {\n    if (typeof val === 'string') {\n      formattedValue = new Date(val)\n      if (Number.isNaN(Date.parse(formattedValue))) {\n        return { operator, value: undefined }\n      }\n    }\n\n    if (typeof val === 'number') {\n      formattedValue = new Date(val)\n    }\n  }\n\n  if (['relationship', 'upload'].includes(field.type)) {\n    if (val === 'null') {\n      formattedValue = null\n    }\n  }\n\n  if ('hasMany' in field && field.hasMany && operator === 'contains') {\n    operator = 'equals'\n  }\n\n  if (operator === 'near' || operator === 'within' || operator === 'intersects') {\n    throw new APIError(\n      `Querying with '${operator}' is not supported with the postgres database adapter.`,\n    )\n  }\n\n  if (operator === 'contains') {\n    formattedValue = `%${formattedValue}%`\n  }\n\n  if (operator === 'exists') {\n    formattedValue = formattedValue === 'true' || formattedValue === true\n    if (formattedValue === false) {\n      operator = 'isNull'\n    }\n  }\n\n  return { operator, value: formattedValue }\n}\n"],"names":["APIError","fieldAffectsData","createArrayFromCommaDelineated","sanitizeQueryValue","adapter","field","operator","operatorArg","relationOrPath","val","formattedValue","value","type","endsWith","Array","isArray","allPossibleIDTypes","forEach","idType","push","parseInt","String","toLowerCase","includes","map","arrayVal","parseFloat","length","Number","Date","isNaN","parse","undefined","hasMany"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,SAASA,QAAQ,QAAQ,iBAAgB;AACzC,SAAsCC,gBAAgB,QAAQ,gBAAe;AAC7E,SAASC,8BAA8B,QAAQ,oBAAmB;AAYlE,OAAO,MAAMC,qBAAqB,CAAC,EACjCC,OAAO,EACPC,KAAK,EACLC,UAAUC,WAAW,EACrBC,cAAc,EACdC,GAAG,EACoB;IACvB,IAAIH,WAAWC;IACf,IAAIG,iBAAiBD;IAErB,IAAI,CAACR,iBAAiBI,QAAQ,OAAO;QAAEC;QAAUK,OAAOD;IAAe;IAEvE,IACE,AAACL,CAAAA,MAAMO,IAAI,KAAK,kBAAkBP,MAAMO,IAAI,KAAK,QAAO,KACxD,CAACJ,eAAeK,QAAQ,CAAC,iBACzBC,MAAMC,OAAO,CAACL,iBACd;QACA,MAAMM,qBAA0C,EAAE;QAClDN,eAAeO,OAAO,CAAC,CAACR;YACtB,IAAIL,QAAQc,MAAM,KAAK,UAAU,OAAOT,QAAQ,UAAU;gBACxDO,mBAAmBG,IAAI,CAACV,KAAKW,SAASX;YACxC,OAAO,IAAI,OAAOA,QAAQ,UAAU;gBAClCO,mBAAmBG,IAAI,CAACV;YAC1B,OAAO;gBACLO,mBAAmBG,IAAI,CAACV,KAAKY,OAAOZ;YACtC;QACF;QACAC,iBAAiBM;IACnB;IAEA,kDAAkD;IAClD,IAAIX,MAAMO,IAAI,KAAK,cAAc,OAAOH,QAAQ,UAAU;QACxD,IAAIA,IAAIa,WAAW,OAAO,QAAQZ,iBAAiB;QACnD,IAAID,IAAIa,WAAW,OAAO,SAASZ,iBAAiB;IACtD;IAEA,IAAI;QAAC;QAAO;QAAM;KAAS,CAACa,QAAQ,CAACjB,WAAW;QAC9C,IAAI,OAAOI,mBAAmB,UAAU;YACtCA,iBAAiBR,+BAA+BQ;YAEhD,IAAIL,MAAMO,IAAI,KAAK,UAAU;gBAC3BF,iBAAiBA,eAAec,GAAG,CAAC,CAACC,WAAaC,WAAWD;YAC/D;QACF;QAEA,IAAI,CAACX,MAAMC,OAAO,CAACL,mBAAmBA,eAAeiB,MAAM,KAAK,GAAG;YACjE,OAAO;QACT;IACF;IAEA,IAAItB,MAAMO,IAAI,KAAK,YAAY,OAAOF,mBAAmB,UAAU;QACjEA,iBAAiBkB,OAAOnB;IAC1B;IAEA,IAAIJ,MAAMO,IAAI,KAAK,UAAUN,aAAa,UAAU;QAClD,IAAI,OAAOG,QAAQ,UAAU;YAC3BC,iBAAiB,IAAImB,KAAKpB;YAC1B,IAAImB,OAAOE,KAAK,CAACD,KAAKE,KAAK,CAACrB,kBAAkB;gBAC5C,OAAO;oBAAEJ;oBAAUK,OAAOqB;gBAAU;YACtC;QACF;QAEA,IAAI,OAAOvB,QAAQ,UAAU;YAC3BC,iBAAiB,IAAImB,KAAKpB;QAC5B;IACF;IAEA,IAAI;QAAC;QAAgB;KAAS,CAACc,QAAQ,CAAClB,MAAMO,IAAI,GAAG;QACnD,IAAIH,QAAQ,QAAQ;YAClBC,iBAAiB;QACnB;IACF;IAEA,IAAI,aAAaL,SAASA,MAAM4B,OAAO,IAAI3B,aAAa,YAAY;QAClEA,WAAW;IACb;IAEA,IAAIA,aAAa,UAAUA,aAAa,YAAYA,aAAa,cAAc;QAC7E,MAAM,IAAIN,SACR,CAAC,eAAe,EAAEM,SAAS,sDAAsD,CAAC;IAEtF;IAEA,IAAIA,aAAa,YAAY;QAC3BI,iBAAiB,CAAC,CAAC,EAAEA,eAAe,CAAC,CAAC;IACxC;IAEA,IAAIJ,aAAa,UAAU;QACzBI,iBAAiBA,mBAAmB,UAAUA,mBAAmB;QACjE,IAAIA,mBAAmB,OAAO;YAC5BJ,WAAW;QACb;IACF;IAEA,OAAO;QAAEA;QAAUK,OAAOD;IAAe;AAC3C,EAAC"}

package/dist/queries/selectDistinct.d.ts

@@ -1,23 +0,0 @@
-import type { QueryPromise, SQL } from 'drizzle-orm';
-import type { ChainedMethods } from '../find/chainMethods.js';
-import type { DrizzleDB, PostgresAdapter } from '../types.js';
-import type { BuildQueryJoinAliases, BuildQueryJoins } from './buildQuery.js';
-import { type GenericColumn } from '../types.js';
-type Args = {
-    adapter: PostgresAdapter;
-    chainedMethods?: ChainedMethods;
-    db: DrizzleDB;
-    joinAliases: BuildQueryJoinAliases;
-    joins: BuildQueryJoins;
-    selectFields: Record<string, GenericColumn>;
-    tableName: string;
-    where: SQL;
-};
-/**
- * Selects distinct records from a table only if there are joins that need to be used, otherwise return null
- */
-export declare const selectDistinct: ({ adapter, chainedMethods, db, joinAliases, joins, selectFields, tableName, where, }: Args) => QueryPromise<Record<string, GenericColumn> & {
-    id: number | string;
-}[]>;
-export {};
-//# sourceMappingURL=selectDistinct.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"selectDistinct.d.ts","sourceRoot":"","sources":["../../src/queries/selectDistinct.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,GAAG,EAAE,MAAM,aAAa,CAAA;AAEpD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAA;AAC7D,OAAO,KAAK,EAAE,SAAS,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAC7D,OAAO,KAAK,EAAE,qBAAqB,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAA;AAG7E,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,aAAa,CAAA;AAEhD,KAAK,IAAI,GAAG;IACV,OAAO,EAAE,eAAe,CAAA;IACxB,cAAc,CAAC,EAAE,cAAc,CAAA;IAC/B,EAAE,EAAE,SAAS,CAAA;IACb,WAAW,EAAE,qBAAqB,CAAA;IAClC,KAAK,EAAE,eAAe,CAAA;IACtB,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA;IAC3C,SAAS,EAAE,MAAM,CAAA;IACjB,KAAK,EAAE,GAAG,CAAA;CACX,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,cAAc,yFASxB,IAAI,KAAG,aAAa,OAAO,MAAM,EAAE,aAAa,CAAC,GAAG;IAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,EAAE,CA2B/E,CAAA"}

package/dist/queries/selectDistinct.js

@@ -1,41 +0,0 @@
-import { chainMethods } from '../find/chainMethods.js';
-/**
- * Selects distinct records from a table only if there are joins that need to be used, otherwise return null
- */ export const selectDistinct = ({ adapter, chainedMethods = [], db, joinAliases, joins, selectFields, tableName, where })=>{
-    if (Object.keys(joins).length > 0 || joinAliases.length > 0) {
-        if (where) {
-            chainedMethods.push({
-                args: [
-                    where
-                ],
-                method: 'where'
-            });
-        }
-        joinAliases.forEach(({ condition, table })=>{
-            chainedMethods.push({
-                args: [
-                    table,
-                    condition
-                ],
-                method: 'leftJoin'
-            });
-        });
-        Object.entries(joins).forEach(([joinTable, condition])=>{
-            if (joinTable) {
-                chainedMethods.push({
-                    args: [
-                        adapter.tables[joinTable],
-                        condition
-                    ],
-                    method: 'leftJoin'
-                });
-            }
-        });
-        return chainMethods({
-            methods: chainedMethods,
-            query: db.selectDistinct(selectFields).from(adapter.tables[tableName])
-        });
-    }
-};
-
-//# sourceMappingURL=selectDistinct.js.map

package/dist/queries/selectDistinct.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/queries/selectDistinct.ts"],"sourcesContent":["import type { QueryPromise, SQL } from 'drizzle-orm'\n\nimport type { ChainedMethods } from '../find/chainMethods.js'\nimport type { DrizzleDB, PostgresAdapter } from '../types.js'\nimport type { BuildQueryJoinAliases, BuildQueryJoins } from './buildQuery.js'\n\nimport { chainMethods } from '../find/chainMethods.js'\nimport { type GenericColumn } from '../types.js'\n\ntype Args = {\n  adapter: PostgresAdapter\n  chainedMethods?: ChainedMethods\n  db: DrizzleDB\n  joinAliases: BuildQueryJoinAliases\n  joins: BuildQueryJoins\n  selectFields: Record<string, GenericColumn>\n  tableName: string\n  where: SQL\n}\n\n/**\n * Selects distinct records from a table only if there are joins that need to be used, otherwise return null\n */\nexport const selectDistinct = ({\n  adapter,\n  chainedMethods = [],\n  db,\n  joinAliases,\n  joins,\n  selectFields,\n  tableName,\n  where,\n}: Args): QueryPromise<Record<string, GenericColumn> & { id: number | string }[]> => {\n  if (Object.keys(joins).length > 0 || joinAliases.length > 0) {\n    if (where) {\n      chainedMethods.push({ args: [where], method: 'where' })\n    }\n\n    joinAliases.forEach(({ condition, table }) => {\n      chainedMethods.push({\n        args: [table, condition],\n        method: 'leftJoin',\n      })\n    })\n\n    Object.entries(joins).forEach(([joinTable, condition]) => {\n      if (joinTable) {\n        chainedMethods.push({\n          args: [adapter.tables[joinTable], condition],\n          method: 'leftJoin',\n        })\n      }\n    })\n\n    return chainMethods({\n      methods: chainedMethods,\n      query: db.selectDistinct(selectFields).from(adapter.tables[tableName]),\n    })\n  }\n}\n"],"names":["chainMethods","selectDistinct","adapter","chainedMethods","db","joinAliases","joins","selectFields","tableName","where","Object","keys","length","push","args","method","forEach","condition","table","entries","joinTable","tables","methods","query","from"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAMA,SAASA,YAAY,QAAQ,0BAAyB;AActD;;CAEC,GACD,OAAO,MAAMC,iBAAiB,CAAC,EAC7BC,OAAO,EACPC,iBAAiB,EAAE,EACnBC,EAAE,EACFC,WAAW,EACXC,KAAK,EACLC,YAAY,EACZC,SAAS,EACTC,KAAK,EACA;IACL,IAAIC,OAAOC,IAAI,CAACL,OAAOM,MAAM,GAAG,KAAKP,YAAYO,MAAM,GAAG,GAAG;QAC3D,IAAIH,OAAO;YACTN,eAAeU,IAAI,CAAC;gBAAEC,MAAM;oBAACL;iBAAM;gBAAEM,QAAQ;YAAQ;QACvD;QAEAV,YAAYW,OAAO,CAAC,CAAC,EAAEC,SAAS,EAAEC,KAAK,EAAE;YACvCf,eAAeU,IAAI,CAAC;gBAClBC,MAAM;oBAACI;oBAAOD;iBAAU;gBACxBF,QAAQ;YACV;QACF;QAEAL,OAAOS,OAAO,CAACb,OAAOU,OAAO,CAAC,CAAC,CAACI,WAAWH,UAAU;YACnD,IAAIG,WAAW;gBACbjB,eAAeU,IAAI,CAAC;oBAClBC,MAAM;wBAACZ,QAAQmB,MAAM,CAACD,UAAU;wBAAEH;qBAAU;oBAC5CF,QAAQ;gBACV;YACF;QACF;QAEA,OAAOf,aAAa;YAClBsB,SAASnB;YACToB,OAAOnB,GAAGH,cAAc,CAACM,cAAciB,IAAI,CAACtB,QAAQmB,MAAM,CAACb,UAAU;QACvE;IACF;AACF,EAAC"}

package/dist/queryDrafts.d.ts

@@ -1,3 +0,0 @@
-import { type QueryDrafts } from 'payload/database';
-export declare const queryDrafts: QueryDrafts;
-//# sourceMappingURL=queryDrafts.d.ts.map

package/dist/queryDrafts.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"queryDrafts.d.ts","sourceRoot":"","sources":["../src/queryDrafts.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,WAAW,EAAkB,MAAM,kBAAkB,CAAA;AAMnE,eAAO,MAAM,WAAW,EAAE,WA+CzB,CAAA"}

package/dist/queryDrafts.js

@@ -1,45 +0,0 @@
-import { combineQueries } from 'payload/database';
-import { buildVersionCollectionFields } from 'payload/versions';
-import { findMany } from './find/findMany.js';
-import { getTableName } from './schema/getTableName.js';
-export const queryDrafts = async function queryDrafts({ collection, limit, locale, page = 1, pagination, req = {}, sort, where }) {
-    const collectionConfig = this.payload.collections[collection].config;
-    const tableName = getTableName({
-        adapter: this,
-        config: collectionConfig,
-        versions: true
-    });
-    const fields = buildVersionCollectionFields(collectionConfig);
-    const combinedWhere = combineQueries({
-        latest: {
-            equals: true
-        }
-    }, where);
-    const result = await findMany({
-        adapter: this,
-        fields,
-        limit,
-        locale,
-        page,
-        pagination,
-        req,
-        sort,
-        tableName,
-        where: combinedWhere
-    });
-    return {
-        ...result,
-        docs: result.docs.map((doc)=>{
-            // eslint-disable-next-line no-param-reassign
-            doc = {
-                id: doc.parent,
-                ...doc.version,
-                createdAt: doc.createdAt,
-                updatedAt: doc.updatedAt
-            };
-            return doc;
-        })
-    };
-};
-
-//# sourceMappingURL=queryDrafts.js.map

package/dist/queryDrafts.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/queryDrafts.ts"],"sourcesContent":["import type { PayloadRequest, SanitizedCollectionConfig } from 'payload/types'\n\nimport { type QueryDrafts, combineQueries } from 'payload/database'\nimport { buildVersionCollectionFields } from 'payload/versions'\n\nimport { findMany } from './find/findMany.js'\nimport { getTableName } from './schema/getTableName.js'\n\nexport const queryDrafts: QueryDrafts = async function queryDrafts({\n  collection,\n  limit,\n  locale,\n  page = 1,\n  pagination,\n  req = {} as PayloadRequest,\n  sort,\n  where,\n}) {\n  const collectionConfig: SanitizedCollectionConfig = this.payload.collections[collection].config\n  const tableName = getTableName({\n    adapter: this,\n    config: collectionConfig,\n    versions: true,\n  })\n  const fields = buildVersionCollectionFields(collectionConfig)\n\n  const combinedWhere = combineQueries({ latest: { equals: true } }, where)\n\n  const result = await findMany({\n    adapter: this,\n    fields,\n    limit,\n    locale,\n    page,\n    pagination,\n    req,\n    sort,\n    tableName,\n    where: combinedWhere,\n  })\n\n  return {\n    ...result,\n    docs: result.docs.map((doc) => {\n      // eslint-disable-next-line no-param-reassign\n      doc = {\n        id: doc.parent,\n        ...doc.version,\n        createdAt: doc.createdAt,\n        updatedAt: doc.updatedAt,\n      }\n\n      return doc\n    }),\n  }\n}\n"],"names":["combineQueries","buildVersionCollectionFields","findMany","getTableName","queryDrafts","collection","limit","locale","page","pagination","req","sort","where","collectionConfig","payload","collections","config","tableName","adapter","versions","fields","combinedWhere","latest","equals","result","docs","map","doc","id","parent","version","createdAt","updatedAt"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAEA,SAA2BA,cAAc,QAAQ,mBAAkB;AACnE,SAASC,4BAA4B,QAAQ,mBAAkB;AAE/D,SAASC,QAAQ,QAAQ,qBAAoB;AAC7C,SAASC,YAAY,QAAQ,2BAA0B;AAEvD,OAAO,MAAMC,cAA2B,eAAeA,YAAY,EACjEC,UAAU,EACVC,KAAK,EACLC,MAAM,EACNC,OAAO,CAAC,EACRC,UAAU,EACVC,MAAM,CAAC,CAAmB,EAC1BC,IAAI,EACJC,KAAK,EACN;IACC,MAAMC,mBAA8C,IAAI,CAACC,OAAO,CAACC,WAAW,CAACV,WAAW,CAACW,MAAM;IAC/F,MAAMC,YAAYd,aAAa;QAC7Be,SAAS,IAAI;QACbF,QAAQH;QACRM,UAAU;IACZ;IACA,MAAMC,SAASnB,6BAA6BY;IAE5C,MAAMQ,gBAAgBrB,eAAe;QAAEsB,QAAQ;YAAEC,QAAQ;QAAK;IAAE,GAAGX;IAEnE,MAAMY,SAAS,MAAMtB,SAAS;QAC5BgB,SAAS,IAAI;QACbE;QACAd;QACAC;QACAC;QACAC;QACAC;QACAC;QACAM;QACAL,OAAOS;IACT;IAEA,OAAO;QACL,GAAGG,MAAM;QACTC,MAAMD,OAAOC,IAAI,CAACC,GAAG,CAAC,CAACC;YACrB,6CAA6C;YAC7CA,MAAM;gBACJC,IAAID,IAAIE,MAAM;gBACd,GAAGF,IAAIG,OAAO;gBACdC,WAAWJ,IAAII,SAAS;gBACxBC,WAAWL,IAAIK,SAAS;YAC1B;YAEA,OAAOL;QACT;IACF;AACF,EAAC"}

package/dist/schema/build.d.ts

@@ -1,29 +0,0 @@
-import type { IndexBuilder, PgColumnBuilder, UniqueConstraintBuilder } from 'drizzle-orm/pg-core';
-import type { Field } from 'payload/types';
-import type { GenericColumns, PostgresAdapter } from '../types.js';
-type Args = {
-    adapter: PostgresAdapter;
-    baseColumns?: Record<string, PgColumnBuilder>;
-    baseExtraConfig?: Record<string, (cols: GenericColumns) => IndexBuilder | UniqueConstraintBuilder>;
-    buildNumbers?: boolean;
-    buildRelationships?: boolean;
-    buildTexts?: boolean;
-    disableNotNull: boolean;
-    disableUnique: boolean;
-    fields: Field[];
-    rootRelationsToBuild?: Map<string, string>;
-    rootRelationships?: Set<string>;
-    rootTableIDColType?: string;
-    rootTableName?: string;
-    tableName: string;
-    timestamps?: boolean;
-    versions: boolean;
-};
-type Result = {
-    hasManyNumberField: 'index' | boolean;
-    hasManyTextField: 'index' | boolean;
-    relationsToBuild: Map<string, string>;
-};
-export declare const buildTable: ({ adapter, baseColumns, baseExtraConfig, buildNumbers, buildRelationships, buildTexts, disableNotNull, disableUnique, fields, rootRelationsToBuild, rootRelationships, rootTableIDColType, rootTableName: incomingRootTableName, tableName, timestamps, versions, }: Args) => Result;
-export {};
-//# sourceMappingURL=build.d.ts.map

package/dist/schema/build.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../../src/schema/build.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,YAAY,EACZ,eAAe,EAEf,uBAAuB,EACxB,MAAM,qBAAqB,CAAA;AAC5B,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,eAAe,CAAA;AAM1C,OAAO,KAAK,EAAE,cAAc,EAAwB,eAAe,EAAE,MAAM,aAAa,CAAA;AAOxF,KAAK,IAAI,GAAG;IACV,OAAO,EAAE,eAAe,CAAA;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAA;IAC7C,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,cAAc,KAAK,YAAY,GAAG,uBAAuB,CAAC,CAAA;IAClG,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,kBAAkB,CAAC,EAAE,OAAO,CAAA;IAC5B,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,cAAc,EAAE,OAAO,CAAA;IACvB,aAAa,EAAE,OAAO,CAAA;IACtB,MAAM,EAAE,KAAK,EAAE,CAAA;IACf,oBAAoB,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC1C,iBAAiB,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;IAC/B,kBAAkB,CAAC,EAAE,MAAM,CAAA;IAC3B,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,SAAS,EAAE,MAAM,CAAA;IACjB,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,QAAQ,EAAE,OAAO,CAAA;CAClB,CAAA;AAED,KAAK,MAAM,GAAG;IACZ,kBAAkB,EAAE,OAAO,GAAG,OAAO,CAAA;IACrC,gBAAgB,EAAE,OAAO,GAAG,OAAO,CAAA;IACnC,gBAAgB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CACtC,CAAA;AAED,eAAO,MAAM,UAAU,wQAiBpB,IAAI,KAAG,MAmUT,CAAA"}