@payloadcms/drizzle 3.0.0-canary.2c2c95f

package/dist/queries/operatorMap.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/queries/operatorMap.ts"],"sourcesContent":["import {\n  type Column,\n  type SQL,\n  type SQLWrapper,\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\ntype OperatorKeys =\n  | 'and'\n  | 'contains'\n  | 'equals'\n  | 'exists'\n  | 'greater_than'\n  | 'greater_than_equal'\n  | 'in'\n  | 'isNull'\n  | 'less_than'\n  | 'less_than_equal'\n  | 'like'\n  | 'not_equals'\n  | 'not_in'\n  | 'or'\n\nexport type Operators = Record<OperatorKeys, (column: Column, value: SQLWrapper | unknown) => SQL>\n\nexport const operatorMap: Operators = {\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  // intersects: intersects,\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"],"mappings":"AAAA,SAIEA,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;AAoBpB,OAAO,MAAMC,cAAyB;IACpCb;IACAc,UAAUV;IACVW,QAAQd;IACRe,QAAQV;IACRW,cAAcf;IACdgB,oBAAoBf;IACpBgB,IAAId;IACJE;IACAa,WAAWZ;IACXa,iBAAiBZ;IACjBa,MAAMlB;IACNmB,YAAYb;IACZ,wBAAwB;IACxB,0BAA0B;IAC1B,cAAc;IACd,kBAAkB;IAClB,YAAY;IACZc,QAAQb;IACRC;AACF,EAAC"}

package/dist/queries/parseParams.d.ts

@@ -0,0 +1,16 @@
+import type { SQL } from 'drizzle-orm';
+import type { Field, Where } from 'payload';
+import type { DrizzleAdapter, GenericColumn } from '../types.js';
+import type { BuildQueryJoinAliases } from './buildQuery.js';
+type Args = {
+    adapter: DrizzleAdapter;
+    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

@@ -0,0 +1 @@
+{"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,SAAS,CAAA;AAMrD,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAChE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAA;AAM5D,KAAK,IAAI,GAAG;IACV,OAAO,EAAE,cAAc,CAAA;IACvB,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,CA8NrB"}

package/dist/queries/parseParams.js

@@ -0,0 +1,188 @@
+/* eslint-disable no-await-in-loop */ import { and, isNotNull, isNull, ne, notInArray, or, sql } from 'drizzle-orm';
+import { QueryError } from 'payload';
+import { validOperators } from 'payload/shared';
+import { buildAndOrConditions } from './buildAndOrConditions.js';
+import { getTableColumnFromPath } from './getTableColumnFromPath.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 = 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(adapter.operators.like(constraintTable[col], value));
+                                    } else {
+                                        constraints.push(adapter.operators.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') {
+                                        // use the table name from the nearest join to handle blocks, arrays, etc. or use the tableName arg
+                                        const jsonTable = joins.length === 0 ? tableName : joins[joins.length - 1].table[Object.getOwnPropertySymbols(joins[joins.length - 1].table)[0]];
+                                        const jsonQuery = adapter.createJSONQuery({
+                                            operator,
+                                            pathSegments: segments,
+                                            table: jsonTable,
+                                            treatAsArray: [
+                                                'children'
+                                            ],
+                                            treatRootAsArray: true,
+                                            value: val
+                                        });
+                                        constraints.push(sql.raw(jsonQuery));
+                                        break;
+                                    }
+                                    const jsonQuery = adapter.convertPathToJSONTraversal(pathSegments);
+                                    const operatorKeys = {
+                                        contains: {
+                                            operator: 'like',
+                                            wildcard: '%'
+                                        },
+                                        equals: {
+                                            operator: '=',
+                                            wildcard: ''
+                                        },
+                                        exists: {
+                                            operator: val === true ? 'is not null' : 'is null'
+                                        },
+                                        like: {
+                                            operator: 'like',
+                                            wildcard: '%'
+                                        },
+                                        not_equals: {
+                                            operator: '<>',
+                                            wildcard: ''
+                                        }
+                                    };
+                                    let formattedValue = val;
+                                    if (adapter.name === 'sqlite' && operator === 'equals' && !isNaN(val)) {
+                                        formattedValue = val;
+                                    } else {
+                                        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)=>adapter.operators.like(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(adapter.operators[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

@@ -0,0 +1 @@
+{"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'\n\nimport { and, isNotNull, isNull, ne, notInArray, or, sql } from 'drizzle-orm'\nimport { QueryError } from 'payload'\nimport { validOperators } from 'payload/shared'\n\nimport type { DrizzleAdapter, GenericColumn } from '../types.js'\nimport type { BuildQueryJoinAliases } from './buildQuery.js'\n\nimport { buildAndOrConditions } from './buildAndOrConditions.js'\nimport { getTableColumnFromPath } from './getTableColumnFromPath.js'\nimport { sanitizeQueryValue } from './sanitizeQueryValue.js'\n\ntype Args = {\n  adapter: DrizzleAdapter\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: typeof and | typeof 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 = 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(adapter.operators.like(constraintTable[col], value))\n                  } else {\n                    constraints.push(adapter.operators.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                    // use the table name from the nearest join to handle blocks, arrays, etc. or use the tableName arg\n                    const jsonTable =\n                      joins.length === 0\n                        ? tableName\n                        : joins[joins.length - 1].table[\n                            Object.getOwnPropertySymbols(joins[joins.length - 1].table)[0]\n                          ]\n                    const jsonQuery = adapter.createJSONQuery({\n                      operator,\n                      pathSegments: segments,\n                      table: jsonTable,\n                      treatAsArray: ['children'],\n                      treatRootAsArray: true,\n                      value: val,\n                    })\n\n                    constraints.push(sql.raw(jsonQuery))\n                    break\n                  }\n\n                  const jsonQuery = adapter.convertPathToJSONTraversal(pathSegments)\n                  const operatorKeys = {\n                    contains: { operator: 'like', 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\n                  let formattedValue = val\n                  if (adapter.name === 'sqlite' && operator === 'equals' && !isNaN(val)) {\n                    formattedValue = val\n                  } else {\n                    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(\n                      ...val\n                        .split(' ')\n                        .map((word) => adapter.operators.like(table[columnName], `%${word}%`)),\n                    ),\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                  adapter.operators[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","isNotNull","isNull","ne","notInArray","or","sql","QueryError","validOperators","buildAndOrConditions","getTableColumnFromPath","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","operators","like","equals","type","segments","slice","unshift","name","jsonTable","getOwnPropertySymbols","jsonQuery","createJSONQuery","treatAsArray","treatRootAsArray","raw","convertPathToJSONTraversal","operatorKeys","contains","wildcard","exists","not_equals","formattedValue","isNaN","path","columnType","map","word","sanitizedQueryValue","queryOperator","queryValue"],"mappings":"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"}

package/dist/queries/sanitizeQueryValue.d.ts

@@ -0,0 +1,15 @@
+import { type Field, type TabAsField } from 'payload';
+import type { DrizzleAdapter } from '../types.js';
+type SanitizeQueryValueArgs = {
+    adapter: DrizzleAdapter;
+    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

@@ -0,0 +1 @@
+{"version":3,"file":"sanitizeQueryValue.d.ts","sourceRoot":"","sources":["../../src/queries/sanitizeQueryValue.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,KAAK,KAAK,EAAE,KAAK,UAAU,EAAkC,MAAM,SAAS,CAAA;AAG/F,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AAEjD,KAAK,sBAAsB,GAAG;IAC5B,OAAO,EAAE,cAAc,CAAA;IACvB,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;CA2H7D,CAAA"}

package/dist/queries/sanitizeQueryValue.js

@@ -0,0 +1,120 @@
+import { APIError, createArrayFromCommaDelineated } from 'payload';
+import { fieldAffectsData } from 'payload/shared';
+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).toISOString();
+            if (Number.isNaN(Date.parse(formattedValue))) {
+                return {
+                    operator,
+                    value: undefined
+                };
+            }
+        } else if (typeof val === 'number') formattedValue = new Date(val).toISOString();
+    }
+    if (field.type === 'relationship' || field.type === 'upload') {
+        if (val === 'null') {
+            formattedValue = null;
+        } else if (!(formattedValue === null || typeof formattedValue === 'boolean')) {
+            // convert the value to the idType of the relationship
+            let idType;
+            if (typeof field.relationTo === 'string') {
+                const collection = adapter.payload.collections[field.relationTo];
+                const mixedType = collection.customIDType || adapter.idType;
+                const typeMap = {
+                    number: 'number',
+                    serial: 'number',
+                    text: 'text',
+                    uuid: 'text'
+                };
+                idType = typeMap[mixedType];
+            } else {
+                // LIMITATION: Only cast to the first relationTo id type,
+                // otherwise we need to make the db cast which is inefficient
+                const collection = adapter.payload.collections[field.relationTo[0]];
+                idType = collection.customIDType || adapter.idType === 'uuid' ? 'text' : 'number';
+            }
+            if (Array.isArray(formattedValue)) {
+                formattedValue = formattedValue.map((value)=>{
+                    if (idType === 'number') {
+                        return Number(value);
+                    }
+                    if (idType === 'text') {
+                        return String(value);
+                    }
+                    return value;
+                });
+            } else {
+                if (idType === 'number') {
+                    formattedValue = Number(val);
+                }
+                if (idType === 'text') {
+                    formattedValue = String(val);
+                }
+            }
+        }
+    }
+    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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/queries/sanitizeQueryValue.ts"],"sourcesContent":["import { APIError, type Field, type TabAsField, createArrayFromCommaDelineated } from 'payload'\nimport { fieldAffectsData } from 'payload/shared'\n\nimport type { DrizzleAdapter } from '../types.js'\n\ntype SanitizeQueryValueArgs = {\n  adapter: DrizzleAdapter\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).toISOString()\n      if (Number.isNaN(Date.parse(formattedValue))) {\n        return { operator, value: undefined }\n      }\n    } else if (typeof val === 'number') formattedValue = new Date(val).toISOString()\n  }\n\n  if (field.type === 'relationship' || field.type === 'upload') {\n    if (val === 'null') {\n      formattedValue = null\n    } else if (!(formattedValue === null || typeof formattedValue === 'boolean')) {\n      // convert the value to the idType of the relationship\n      let idType: 'number' | 'text'\n      if (typeof field.relationTo === 'string') {\n        const collection = adapter.payload.collections[field.relationTo]\n        const mixedType: 'number' | 'serial' | 'text' | 'uuid' =\n          collection.customIDType || adapter.idType\n        const typeMap: Record<string, 'number' | 'text'> = {\n          number: 'number',\n          serial: 'number',\n          text: 'text',\n          uuid: 'text',\n        }\n        idType = typeMap[mixedType]\n      } else {\n        // LIMITATION: Only cast to the first relationTo id type,\n        // otherwise we need to make the db cast which is inefficient\n        const collection = adapter.payload.collections[field.relationTo[0]]\n        idType = collection.customIDType || adapter.idType === 'uuid' ? 'text' : 'number'\n      }\n      if (Array.isArray(formattedValue)) {\n        formattedValue = formattedValue.map((value) => {\n          if (idType === 'number') {\n            return Number(value)\n          }\n          if (idType === 'text') {\n            return String(value)\n          }\n          return value\n        })\n      } else {\n        if (idType === 'number') {\n          formattedValue = Number(val)\n        }\n        if (idType === 'text') {\n          formattedValue = String(val)\n        }\n      }\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","createArrayFromCommaDelineated","fieldAffectsData","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","toISOString","isNaN","parse","undefined","relationTo","collection","payload","collections","mixedType","customIDType","typeMap","number","serial","text","uuid","hasMany"],"mappings":"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"}

package/dist/queries/selectDistinct.d.ts

@@ -0,0 +1,22 @@
+import type { QueryPromise, SQL } from 'drizzle-orm';
+import type { ChainedMethods } from '../find/chainMethods.js';
+import type { DrizzleAdapter, DrizzleTransaction } from '../types.js';
+import type { BuildQueryJoinAliases } from './buildQuery.js';
+import { type GenericColumn } from '../types.js';
+type Args = {
+    adapter: DrizzleAdapter;
+    chainedMethods?: ChainedMethods;
+    db: DrizzleAdapter['drizzle'] | DrizzleTransaction;
+    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

@@ -0,0 +1 @@
+{"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;AAGpD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAA;AAC7D,OAAO,KAAK,EACV,cAAc,EACd,kBAAkB,EAInB,MAAM,aAAa,CAAA;AACpB,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAA;AAG5D,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,aAAa,CAAA;AAEhD,KAAK,IAAI,GAAG;IACV,OAAO,EAAE,cAAc,CAAA;IACvB,cAAc,CAAC,EAAE,cAAc,CAAA;IAC/B,EAAE,EAAE,cAAc,CAAC,SAAS,CAAC,GAAG,kBAAkB,CAAA;IAClD,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,YAAY,CAAC,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,GAAG;IAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,EAAE,CAgC/E,CAAA"}

package/dist/queries/selectDistinct.js

@@ -0,0 +1,38 @@
+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'
+            });
+        });
+        let query;
+        const table = adapter.tables[tableName];
+        if (adapter.name === 'postgres') {
+            query = db.selectDistinct(selectFields).from(table);
+        }
+        if (adapter.name === 'sqlite') {
+            query = db.selectDistinct(selectFields).from(table);
+        }
+        return chainMethods({
+            methods: chainedMethods,
+            query
+        });
+    }
+};
+
+//# sourceMappingURL=selectDistinct.js.map

package/dist/queries/selectDistinct.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/queries/selectDistinct.ts"],"sourcesContent":["import type { QueryPromise, SQL } from 'drizzle-orm'\nimport type { SQLiteColumn } from 'drizzle-orm/sqlite-core'\n\nimport type { ChainedMethods } from '../find/chainMethods.js'\nimport type {\n  DrizzleAdapter,\n  DrizzleTransaction,\n  GenericPgColumn,\n  TransactionPg,\n  TransactionSQLite,\n} 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: DrizzleAdapter\n  chainedMethods?: ChainedMethods\n  db: DrizzleAdapter['drizzle'] | DrizzleTransaction\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    let query\n    const table = adapter.tables[tableName]\n\n    if (adapter.name === 'postgres') {\n      query = (db as TransactionPg)\n        .selectDistinct(selectFields as Record<string, GenericPgColumn>)\n        .from(table)\n    }\n    if (adapter.name === 'sqlite') {\n      query = (db as TransactionSQLite)\n        .selectDistinct(selectFields as Record<string, SQLiteColumn>)\n        .from(table)\n    }\n\n    return chainMethods({\n      methods: chainedMethods,\n      query,\n    })\n  }\n}\n"],"names":["chainMethods","selectDistinct","adapter","chainedMethods","db","joins","selectFields","tableName","where","Object","keys","length","push","args","method","forEach","condition","table","query","tables","name","from","methods"],"mappings":"AAaA,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,IAAII;QACJ,MAAMD,QAAQf,QAAQiB,MAAM,CAACZ,UAAU;QAEvC,IAAIL,QAAQkB,IAAI,KAAK,YAAY;YAC/BF,QAAQ,AAACd,GACNH,cAAc,CAACK,cACfe,IAAI,CAACJ;QACV;QACA,IAAIf,QAAQkB,IAAI,KAAK,UAAU;YAC7BF,QAAQ,AAACd,GACNH,cAAc,CAACK,cACfe,IAAI,CAACJ;QACV;QAEA,OAAOjB,aAAa;YAClBsB,SAASnB;YACTe;QACF;IACF;AACF,EAAC"}

package/dist/queryDrafts.d.ts

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

package/dist/queryDrafts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queryDrafts.d.ts","sourceRoot":"","sources":["../src/queryDrafts.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAkB,WAAW,EAA6B,MAAM,SAAS,CAAA;AASrF,eAAO,MAAM,WAAW,EAAE,WAuCzB,CAAA"}

package/dist/queryDrafts.js

@@ -0,0 +1,40 @@
+import { buildVersionCollectionFields, combineQueries } from 'payload';
+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

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/queryDrafts.ts"],"sourcesContent":["import type { PayloadRequest, QueryDrafts, SanitizedCollectionConfig } from 'payload'\n\nimport { buildVersionCollectionFields, combineQueries } from 'payload'\nimport toSnakeCase from 'to-snake-case'\n\nimport type { DrizzleAdapter } from './types.js'\n\nimport { findMany } from './find/findMany.js'\n\nexport const queryDrafts: QueryDrafts = async function queryDrafts(\n  this: DrizzleAdapter,\n  { collection, limit, locale, page = 1, pagination, req = {} as PayloadRequest, sort, where },\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":["buildVersionCollectionFields","combineQueries","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"],"mappings":"AAEA,SAASA,4BAA4B,EAAEC,cAAc,QAAQ,UAAS;AACtE,OAAOC,iBAAiB,gBAAe;AAIvC,SAASC,QAAQ,QAAQ,qBAAoB;AAE7C,OAAO,MAAMC,cAA2B,eAAeA,YAErD,EAAEC,UAAU,EAAEC,KAAK,EAAEC,MAAM,EAAEC,OAAO,CAAC,EAAEC,UAAU,EAAEC,MAAM,CAAC,CAAmB,EAAEC,IAAI,EAAEC,KAAK,EAAE;IAE5F,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,SAAStB,6BAA6Ba;IAE5C,MAAMU,gBAAgBtB,eAAe;QAAEuB,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/transactions/beginTransaction.d.ts

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

package/dist/transactions/beginTransaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"beginTransaction.d.ts","sourceRoot":"","sources":["../../src/transactions/beginTransaction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAA;AAM/C,eAAO,MAAM,gBAAgB,EAAE,gBA2D9B,CAAA"}

package/dist/transactions/beginTransaction.js

@@ -0,0 +1,51 @@
+import { v4 as uuid } from 'uuid';
+export const beginTransaction = async function beginTransaction() {
+    let id;
+    try {
+        id = uuid();
+        let reject;
+        let resolve;
+        let transaction;
+        let transactionReady;
+        // Await initialization here
+        // Prevent race conditions where the adapter may be
+        // re-initializing, and `this.drizzle` is potentially undefined
+        await this.initializing;
+        // Drizzle only exposes a transactions API that is sufficient if you
+        // can directly pass around the `tx` argument. But our operations are spread
+        // over many files and we don't want to pass the `tx` around like that,
+        // so instead, we "lift" up the `resolve` and `reject` methods
+        // and will call them in our respective transaction methods
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
+        const done = this.drizzle.transaction(async (tx)=>{
+            transaction = tx;
+            await new Promise((res, rej)=>{
+                resolve = ()=>{
+                    res();
+                    return done;
+                };
+                reject = ()=>{
+                    rej();
+                    return done;
+                };
+                transactionReady();
+            });
+        }).catch(()=>{
+        // swallow
+        });
+        // Need to wait until the transaction is ready
+        // before binding its `resolve` and `reject` methods below
+        await new Promise((resolve)=>transactionReady = resolve);
+        this.sessions[id] = {
+            db: transaction,
+            reject,
+            resolve
+        };
+    } catch (err) {
+        this.payload.logger.error(`Error: cannot begin transaction: ${err.message}`, err);
+        process.exit(1);
+    }
+    return id;
+};
+
+//# sourceMappingURL=beginTransaction.js.map

package/dist/transactions/beginTransaction.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/transactions/beginTransaction.ts"],"sourcesContent":["import type { BeginTransaction } from 'payload'\n\nimport { v4 as uuid } from 'uuid'\n\nimport type { DrizzleAdapter, DrizzleTransaction } from '../types.js'\n\nexport const beginTransaction: BeginTransaction = async function beginTransaction(\n  this: DrizzleAdapter,\n) {\n  let id\n  try {\n    id = uuid()\n\n    let reject: () => Promise<void>\n    let resolve: () => Promise<void>\n    let transaction: DrizzleTransaction\n\n    let transactionReady: () => void\n\n    // Await initialization here\n    // Prevent race conditions where the adapter may be\n    // re-initializing, and `this.drizzle` is potentially undefined\n    await this.initializing\n\n    // Drizzle only exposes a transactions API that is sufficient if you\n    // can directly pass around the `tx` argument. But our operations are spread\n    // over many files and we don't want to pass the `tx` around like that,\n    // so instead, we \"lift\" up the `resolve` and `reject` methods\n    // and will call them in our respective transaction methods\n\n    // eslint-disable-next-line @typescript-eslint/no-floating-promises\n    const done = this.drizzle\n      .transaction(async (tx) => {\n        transaction = tx\n        await new Promise<void>((res, rej) => {\n          resolve = () => {\n            res()\n            return done\n          }\n          reject = () => {\n            rej()\n            return done\n          }\n          transactionReady()\n        })\n      })\n      .catch(() => {\n        // swallow\n      })\n\n    // Need to wait until the transaction is ready\n    // before binding its `resolve` and `reject` methods below\n    await new Promise<void>((resolve) => (transactionReady = resolve))\n\n    this.sessions[id] = {\n      db: transaction,\n      reject,\n      resolve,\n    }\n  } catch (err) {\n    this.payload.logger.error(`Error: cannot begin transaction: ${err.message}`, err)\n    process.exit(1)\n  }\n\n  return id\n}\n"],"names":["v4","uuid","beginTransaction","id","reject","resolve","transaction","transactionReady","initializing","done","drizzle","tx","Promise","res","rej","catch","sessions","db","err","payload","logger","error","message","process","exit"],"mappings":"AAEA,SAASA,MAAMC,IAAI,QAAQ,OAAM;AAIjC,OAAO,MAAMC,mBAAqC,eAAeA;IAG/D,IAAIC;IACJ,IAAI;QACFA,KAAKF;QAEL,IAAIG;QACJ,IAAIC;QACJ,IAAIC;QAEJ,IAAIC;QAEJ,4BAA4B;QAC5B,mDAAmD;QACnD,+DAA+D;QAC/D,MAAM,IAAI,CAACC,YAAY;QAEvB,oEAAoE;QACpE,4EAA4E;QAC5E,uEAAuE;QACvE,8DAA8D;QAC9D,2DAA2D;QAE3D,mEAAmE;QACnE,MAAMC,OAAO,IAAI,CAACC,OAAO,CACtBJ,WAAW,CAAC,OAAOK;YAClBL,cAAcK;YACd,MAAM,IAAIC,QAAc,CAACC,KAAKC;gBAC5BT,UAAU;oBACRQ;oBACA,OAAOJ;gBACT;gBACAL,SAAS;oBACPU;oBACA,OAAOL;gBACT;gBACAF;YACF;QACF,GACCQ,KAAK,CAAC;QACL,UAAU;QACZ;QAEF,8CAA8C;QAC9C,0DAA0D;QAC1D,MAAM,IAAIH,QAAc,CAACP,UAAaE,mBAAmBF;QAEzD,IAAI,CAACW,QAAQ,CAACb,GAAG,GAAG;YAClBc,IAAIX;YACJF;YACAC;QACF;IACF,EAAE,OAAOa,KAAK;QACZ,IAAI,CAACC,OAAO,CAACC,MAAM,CAACC,KAAK,CAAC,CAAC,iCAAiC,EAAEH,IAAII,OAAO,CAAC,CAAC,EAAEJ;QAC7EK,QAAQC,IAAI,CAAC;IACf;IAEA,OAAOrB;AACT,EAAC"}

package/dist/transactions/commitTransaction.d.ts

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

package/dist/transactions/commitTransaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commitTransaction.d.ts","sourceRoot":"","sources":["../../src/transactions/commitTransaction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAEhD,eAAO,MAAM,iBAAiB,EAAE,iBAe/B,CAAA"}