@payloadcms/db-postgres 3.0.0-canary.220bb7c → 3.0.0-canary.28c161d

package/dist/queries/operatorMap.d.ts

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

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

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

package/dist/queries/operatorMap.js

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

package/dist/queries/operatorMap.js.map

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

package/dist/queries/parseParams.d.ts

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

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

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

package/dist/queries/parseParams.js

@@ -1,183 +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, 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,
-                        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 (let 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,
-                                    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' && (field.type === 'number' || table[columnName].columnType === 'PgUUID')) {
-                                    operator = 'equals';
-                                }
-                                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 } 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  joins: BuildQueryJoinAliases\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  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            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 (let 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                  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 (\n                  operator === 'like' &&\n                  (field.type === 'number' || table[columnName].columnType === 'PgUUID')\n                ) {\n                  operator = 'equals'\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","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","columnType","map","word","sanitizedQueryValue","queryOperator","queryValue"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

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,22 +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 } from './buildQuery.js';
-import { type GenericColumn } from '../types.js';
-type Args = {
-    adapter: PostgresAdapter;
-    chainedMethods?: ChainedMethods;
-    db: DrizzleDB;
-    joins: BuildQueryJoinAliases;
-    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, 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,MAAM,iBAAiB,CAAA;AAG5D,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,KAAK,EAAE,qBAAqB,CAAA;IAC5B,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,4EAQxB,IAAI,KAAG,aAAa,OAAO,MAAM,EAAE,aAAa,CAAC,GAAG;IAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,EAAE,CAkB/E,CAAA"}

package/dist/queries/selectDistinct.js

@@ -1,30 +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, joins, selectFields, tableName, where })=>{
-    if (Object.keys(joins).length > 0) {
-        if (where) {
-            chainedMethods.push({
-                args: [
-                    where
-                ],
-                method: 'where'
-            });
-        }
-        joins.forEach(({ condition, table })=>{
-            chainedMethods.push({
-                args: [
-                    table,
-                    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 } 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  joins: BuildQueryJoinAliases\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  joins,\n  selectFields,\n  tableName,\n  where,\n}: Args): QueryPromise<Record<string, GenericColumn> & { id: number | string }[]> => {\n  if (Object.keys(joins).length > 0) {\n    if (where) {\n      chainedMethods.push({ args: [where], method: 'where' })\n    }\n\n    joins.forEach(({ condition, table }) => {\n      chainedMethods.push({\n        args: [table, condition],\n        method: 'leftJoin',\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","joins","selectFields","tableName","where","Object","keys","length","push","args","method","forEach","condition","table","methods","query","from","tables"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAMA,SAASA,YAAY,QAAQ,0BAAyB;AAatD;;CAEC,GACD,OAAO,MAAMC,iBAAiB,CAAC,EAC7BC,OAAO,EACPC,iBAAiB,EAAE,EACnBC,EAAE,EACFC,KAAK,EACLC,YAAY,EACZC,SAAS,EACTC,KAAK,EACA;IACL,IAAIC,OAAOC,IAAI,CAACL,OAAOM,MAAM,GAAG,GAAG;QACjC,IAAIH,OAAO;YACTL,eAAeS,IAAI,CAAC;gBAAEC,MAAM;oBAACL;iBAAM;gBAAEM,QAAQ;YAAQ;QACvD;QAEAT,MAAMU,OAAO,CAAC,CAAC,EAAEC,SAAS,EAAEC,KAAK,EAAE;YACjCd,eAAeS,IAAI,CAAC;gBAClBC,MAAM;oBAACI;oBAAOD;iBAAU;gBACxBF,QAAQ;YACV;QACF;QAEA,OAAOd,aAAa;YAClBkB,SAASf;YACTgB,OAAOf,GAAGH,cAAc,CAACK,cAAcc,IAAI,CAAClB,QAAQmB,MAAM,CAACd,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;AAQnE,eAAO,MAAM,WAAW,EAAE,WAgDzB,CAAA"}

package/dist/queryDrafts.js

@@ -1,41 +0,0 @@
-import { combineQueries } from 'payload/database';
-import { buildVersionCollectionFields } from 'payload/versions';
-import toSnakeCase from 'to-snake-case';
-import { findMany } from './find/findMany.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 = this.tableNameMap.get(`_${toSnakeCase(collectionConfig.slug)}${this.versionsSuffix}`);
-    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 { PayloadRequestWithData, SanitizedCollectionConfig } from 'payload/types'\n\nimport { type QueryDrafts, combineQueries } from 'payload/database'\nimport { buildVersionCollectionFields } from 'payload/versions'\nimport toSnakeCase from 'to-snake-case'\n\nimport type { PostgresAdapter } from './types.js'\n\nimport { findMany } from './find/findMany.js'\n\nexport const queryDrafts: QueryDrafts = async function queryDrafts(\n  this: PostgresAdapter,\n  {\n    collection,\n    limit,\n    locale,\n    page = 1,\n    pagination,\n    req = {} as PayloadRequestWithData,\n    sort,\n    where,\n  },\n) {\n  const collectionConfig: SanitizedCollectionConfig = this.payload.collections[collection].config\n  const tableName = this.tableNameMap.get(\n    `_${toSnakeCase(collectionConfig.slug)}${this.versionsSuffix}`,\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","toSnakeCase","findMany","queryDrafts","collection","limit","locale","page","pagination","req","sort","where","collectionConfig","payload","collections","config","tableName","tableNameMap","get","slug","versionsSuffix","fields","combinedWhere","latest","equals","result","adapter","docs","map","doc","id","parent","version","createdAt","updatedAt"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAEA,SAA2BA,cAAc,QAAQ,mBAAkB;AACnE,SAASC,4BAA4B,QAAQ,mBAAkB;AAC/D,OAAOC,iBAAiB,gBAAe;AAIvC,SAASC,QAAQ,QAAQ,qBAAoB;AAE7C,OAAO,MAAMC,cAA2B,eAAeA,YAErD,EACEC,UAAU,EACVC,KAAK,EACLC,MAAM,EACNC,OAAO,CAAC,EACRC,UAAU,EACVC,MAAM,CAAC,CAA2B,EAClCC,IAAI,EACJC,KAAK,EACN;IAED,MAAMC,mBAA8C,IAAI,CAACC,OAAO,CAACC,WAAW,CAACV,WAAW,CAACW,MAAM;IAC/F,MAAMC,YAAY,IAAI,CAACC,YAAY,CAACC,GAAG,CACrC,CAAC,CAAC,EAAEjB,YAAYW,iBAAiBO,IAAI,EAAE,EAAE,IAAI,CAACC,cAAc,CAAC,CAAC;IAEhE,MAAMC,SAASrB,6BAA6BY;IAE5C,MAAMU,gBAAgBvB,eAAe;QAAEwB,QAAQ;YAAEC,QAAQ;QAAK;IAAE,GAAGb;IAEnE,MAAMc,SAAS,MAAMvB,SAAS;QAC5BwB,SAAS,IAAI;QACbL;QACAhB;QACAC;QACAC;QACAC;QACAC;QACAC;QACAM;QACAL,OAAOW;IACT;IAEA,OAAO;QACL,GAAGG,MAAM;QACTE,MAAMF,OAAOE,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,34 +0,0 @@
-import type { ForeignKeyBuilder, IndexBuilder, PgColumnBuilder, UniqueConstraintBuilder } from 'drizzle-orm/pg-core';
-import type { Field } from 'payload/types';
-import type { GenericColumns, PostgresAdapter } from '../types.js';
-export type BaseExtraConfig = Record<string, (cols: GenericColumns) => ForeignKeyBuilder | IndexBuilder | UniqueConstraintBuilder>;
-export type RelationMap = Map<string, {
-    localized: boolean;
-    target: string;
-    type: 'many' | 'one';
-}>;
-type Args = {
-    adapter: PostgresAdapter;
-    baseColumns?: Record<string, PgColumnBuilder>;
-    baseExtraConfig?: BaseExtraConfig;
-    buildNumbers?: boolean;
-    buildRelationships?: boolean;
-    disableNotNull: boolean;
-    disableUnique: boolean;
-    fields: Field[];
-    rootRelationsToBuild?: RelationMap;
-    rootRelationships?: Set<string>;
-    rootTableIDColType?: string;
-    rootTableName?: string;
-    tableName: string;
-    timestamps?: boolean;
-    versions: boolean;
-};
-type Result = {
-    hasManyNumberField: 'index' | boolean;
-    hasManyTextField: 'index' | boolean;
-    relationsToBuild: RelationMap;
-};
-export declare const buildTable: ({ adapter, baseColumns, baseExtraConfig, 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,iBAAiB,EACjB,YAAY,EACZ,eAAe,EAEf,uBAAuB,EACxB,MAAM,qBAAqB,CAAA;AAC5B,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,eAAe,CAAA;AAe1C,OAAO,KAAK,EAAE,cAAc,EAAwB,eAAe,EAAE,MAAM,aAAa,CAAA;AAOxF,MAAM,MAAM,eAAe,GAAG,MAAM,CAClC,MAAM,EACN,CAAC,IAAI,EAAE,cAAc,KAAK,iBAAiB,GAAG,YAAY,GAAG,uBAAuB,CACrF,CAAA;AAED,MAAM,MAAM,WAAW,GAAG,GAAG,CAAC,MAAM,EAAE;IAAE,SAAS,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,GAAG,KAAK,CAAA;CAAE,CAAC,CAAA;AAEnG,KAAK,IAAI,GAAG;IACV,OAAO,EAAE,eAAe,CAAA;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAA;IAC7C,eAAe,CAAC,EAAE,eAAe,CAAA;IACjC,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,kBAAkB,CAAC,EAAE,OAAO,CAAA;IAC5B,cAAc,EAAE,OAAO,CAAA;IACvB,aAAa,EAAE,OAAO,CAAA;IACtB,MAAM,EAAE,KAAK,EAAE,CAAA;IACf,oBAAoB,CAAC,EAAE,WAAW,CAAA;IAClC,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,WAAW,CAAA;CAC9B,CAAA;AAED,eAAO,MAAM,UAAU,0NAcpB,IAAI,KAAG,MAqYT,CAAA"}