@depup/payload 3.79.1-depup.0

package/dist/utilities/parseDocumentID.js

@@ -0,0 +1,7 @@
+import { isNumber } from './isNumber.js';
+export function parseDocumentID({ id, collectionSlug, payload }) {
+    const idType = payload.collections[collectionSlug]?.customIDType ?? payload.db.defaultIDType;
+    return id ? idType === 'number' && isNumber(id) ? parseFloat(String(id)) : id : undefined;
+}
+
+//# sourceMappingURL=parseDocumentID.js.map

package/dist/utilities/parseDocumentID.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/parseDocumentID.ts"],"sourcesContent":["import type { CollectionSlug, Payload } from '../index.js'\n\nimport { isNumber } from './isNumber.js'\n\ntype ParseDocumentIDArgs = {\n  collectionSlug: CollectionSlug\n  id?: number | string\n  payload: Payload\n}\n\nexport function parseDocumentID({ id, collectionSlug, payload }: ParseDocumentIDArgs) {\n  const idType = payload.collections[collectionSlug]?.customIDType ?? payload.db.defaultIDType\n\n  return id ? (idType === 'number' && isNumber(id) ? parseFloat(String(id)) : id) : undefined\n}\n"],"names":["isNumber","parseDocumentID","id","collectionSlug","payload","idType","collections","customIDType","db","defaultIDType","parseFloat","String","undefined"],"mappings":"AAEA,SAASA,QAAQ,QAAQ,gBAAe;AAQxC,OAAO,SAASC,gBAAgB,EAAEC,EAAE,EAAEC,cAAc,EAAEC,OAAO,EAAuB;IAClF,MAAMC,SAASD,QAAQE,WAAW,CAACH,eAAe,EAAEI,gBAAgBH,QAAQI,EAAE,CAACC,aAAa;IAE5F,OAAOP,KAAMG,WAAW,YAAYL,SAASE,MAAMQ,WAAWC,OAAOT,OAAOA,KAAMU;AACpF"}

package/dist/utilities/parseParams/index.d.ts

@@ -0,0 +1,59 @@
+import type { JoinQuery, PopulateType, SelectType, Where } from '../../types/index.js';
+import type { JoinParams } from '../sanitizeJoinParams.js';
+type RawParams = {
+    [key: string]: unknown;
+    autosave?: string;
+    data?: string;
+    depth?: string;
+    draft?: string;
+    field?: string;
+    flattenLocales?: string;
+    joins?: JoinParams;
+    limit?: string;
+    overrideLock?: string;
+    page?: string;
+    pagination?: string;
+    populate?: unknown;
+    publishAllLocales?: string;
+    publishSpecificLocale?: string;
+    select?: unknown;
+    selectedLocales?: string;
+    sort?: string | string[];
+    trash?: string;
+    unpublishAllLocales?: string;
+    where?: Where;
+};
+type ParsedParams = {
+    autosave?: boolean;
+    data?: Record<string, unknown>;
+    depth?: number;
+    draft?: boolean;
+    field?: string;
+    flattenLocales?: boolean;
+    joins?: JoinQuery;
+    limit?: number;
+    overrideLock?: boolean;
+    page?: number;
+    pagination?: boolean;
+    populate?: PopulateType;
+    publishAllLocales?: boolean;
+    publishSpecificLocale?: string;
+    select?: SelectType;
+    selectedLocales?: string[];
+    sort?: string[];
+    trash?: boolean;
+    unpublishAllLocales?: boolean;
+    where?: Where;
+} & Record<string, unknown>;
+export declare const booleanParams: string[];
+export declare const numberParams: string[];
+/**
+ * Takes raw query parameters and parses them into the correct types that Payload expects.
+ * Examples:
+ *   a. `draft` provided as a string of "true" is converted to a boolean
+ *   b. `depth` provided as a string of "0" is converted to a number
+ *   c. `sort` provided as a comma-separated string or array is converted to an array of strings
+ */
+export declare const parseParams: (params: RawParams) => ParsedParams;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/utilities/parseParams/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/utilities/parseParams/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,YAAY,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAA;AACtF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAS1D,KAAK,SAAS,GAAG;IACf,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;IACtB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,KAAK,CAAC,EAAE,UAAU,CAAA;IAClB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAC1B,qBAAqB,CAAC,EAAE,MAAM,CAAA;IAC9B,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAA;IACxB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,mBAAmB,CAAC,EAAE,MAAM,CAAA;IAC5B,KAAK,CAAC,EAAE,KAAK,CAAA;CACd,CAAA;AAED,KAAK,YAAY,GAAG;IAClB,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC9B,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,cAAc,CAAC,EAAE,OAAO,CAAA;IACxB,KAAK,CAAC,EAAE,SAAS,CAAA;IACjB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,QAAQ,CAAC,EAAE,YAAY,CAAA;IACvB,iBAAiB,CAAC,EAAE,OAAO,CAAA;IAC3B,qBAAqB,CAAC,EAAE,MAAM,CAAA;IAC9B,MAAM,CAAC,EAAE,UAAU,CAAA;IACnB,eAAe,CAAC,EAAE,MAAM,EAAE,CAAA;IAC1B,IAAI,CAAC,EAAE,MAAM,EAAE,CAAA;IACf,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,mBAAmB,CAAC,EAAE,OAAO,CAAA;IAC7B,KAAK,CAAC,EAAE,KAAK,CAAA;CACd,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;AAE3B,eAAO,MAAM,aAAa,UAOzB,CAAA;AAED,eAAO,MAAM,YAAY,UAA6B,CAAA;AAEtD;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,WAAY,SAAS,KAAG,YAuC/C,CAAA"}

package/dist/utilities/parseParams/index.js

@@ -0,0 +1,59 @@
+import { isNumber } from '../isNumber.js';
+import { parseBooleanString } from '../parseBooleanString.js';
+import { sanitizeJoinParams } from '../sanitizeJoinParams.js';
+import { sanitizePopulateParam } from '../sanitizePopulateParam.js';
+import { sanitizeSelectParam } from '../sanitizeSelectParam.js';
+import { sanitizeSortParams } from '../sanitizeSortParams.js';
+export const booleanParams = [
+    'autosave',
+    'draft',
+    'trash',
+    'overrideLock',
+    'pagination',
+    'flattenLocales'
+];
+export const numberParams = [
+    'depth',
+    'limit',
+    'page'
+];
+/**
+ * Takes raw query parameters and parses them into the correct types that Payload expects.
+ * Examples:
+ *   a. `draft` provided as a string of "true" is converted to a boolean
+ *   b. `depth` provided as a string of "0" is converted to a number
+ *   c. `sort` provided as a comma-separated string or array is converted to an array of strings
+ */ export const parseParams = (params)=>{
+    const parsedParams = params || {};
+    // iterate through known params to make this very fast
+    for (const key of booleanParams){
+        if (key in params) {
+            parsedParams[key] = parseBooleanString(params[key]);
+        }
+    }
+    for (const key of numberParams){
+        if (key in params) {
+            if (isNumber(params[key])) {
+                parsedParams[key] = Number(params[key]);
+            }
+        }
+    }
+    if ('populate' in params) {
+        parsedParams.populate = sanitizePopulateParam(params.populate);
+    }
+    if ('select' in params) {
+        parsedParams.select = sanitizeSelectParam(params.select);
+    }
+    if ('joins' in params) {
+        parsedParams.joins = sanitizeJoinParams(params.joins);
+    }
+    if ('sort' in params) {
+        parsedParams.sort = sanitizeSortParams(params.sort);
+    }
+    if ('data' in params && typeof params.data === 'string' && params.data.length > 0) {
+        parsedParams.data = JSON.parse(params.data);
+    }
+    return parsedParams;
+};
+
+//# sourceMappingURL=index.js.map

package/dist/utilities/parseParams/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utilities/parseParams/index.ts"],"sourcesContent":["import type { JoinQuery, PopulateType, SelectType, Where } from '../../types/index.js'\nimport type { JoinParams } from '../sanitizeJoinParams.js'\n\nimport { isNumber } from '../isNumber.js'\nimport { parseBooleanString } from '../parseBooleanString.js'\nimport { sanitizeJoinParams } from '../sanitizeJoinParams.js'\nimport { sanitizePopulateParam } from '../sanitizePopulateParam.js'\nimport { sanitizeSelectParam } from '../sanitizeSelectParam.js'\nimport { sanitizeSortParams } from '../sanitizeSortParams.js'\n\ntype RawParams = {\n  [key: string]: unknown\n  autosave?: string\n  data?: string\n  depth?: string\n  draft?: string\n  field?: string\n  flattenLocales?: string\n  joins?: JoinParams\n  limit?: string\n  overrideLock?: string\n  page?: string\n  pagination?: string\n  populate?: unknown\n  publishAllLocales?: string\n  publishSpecificLocale?: string\n  select?: unknown\n  selectedLocales?: string\n  sort?: string | string[]\n  trash?: string\n  unpublishAllLocales?: string\n  where?: Where\n}\n\ntype ParsedParams = {\n  autosave?: boolean\n  data?: Record<string, unknown>\n  depth?: number\n  draft?: boolean\n  field?: string\n  flattenLocales?: boolean\n  joins?: JoinQuery\n  limit?: number\n  overrideLock?: boolean\n  page?: number\n  pagination?: boolean\n  populate?: PopulateType\n  publishAllLocales?: boolean\n  publishSpecificLocale?: string\n  select?: SelectType\n  selectedLocales?: string[]\n  sort?: string[]\n  trash?: boolean\n  unpublishAllLocales?: boolean\n  where?: Where\n} & Record<string, unknown>\n\nexport const booleanParams = [\n  'autosave',\n  'draft',\n  'trash',\n  'overrideLock',\n  'pagination',\n  'flattenLocales',\n]\n\nexport const numberParams = ['depth', 'limit', 'page']\n\n/**\n * Takes raw query parameters and parses them into the correct types that Payload expects.\n * Examples:\n *   a. `draft` provided as a string of \"true\" is converted to a boolean\n *   b. `depth` provided as a string of \"0\" is converted to a number\n *   c. `sort` provided as a comma-separated string or array is converted to an array of strings\n */\nexport const parseParams = (params: RawParams): ParsedParams => {\n  const parsedParams = (params || {}) as ParsedParams\n\n  // iterate through known params to make this very fast\n  for (const key of booleanParams) {\n    if (key in params) {\n      parsedParams[key] = parseBooleanString(params[key] as boolean | string)\n    }\n  }\n\n  for (const key of numberParams) {\n    if (key in params) {\n      if (isNumber(params[key])) {\n        parsedParams[key] = Number(params[key])\n      }\n    }\n  }\n\n  if ('populate' in params) {\n    parsedParams.populate = sanitizePopulateParam(params.populate)\n  }\n\n  if ('select' in params) {\n    parsedParams.select = sanitizeSelectParam(params.select)\n  }\n\n  if ('joins' in params) {\n    parsedParams.joins = sanitizeJoinParams(params.joins as JoinParams)\n  }\n\n  if ('sort' in params) {\n    parsedParams.sort = sanitizeSortParams(params.sort)\n  }\n\n  if ('data' in params && typeof params.data === 'string' && params.data.length > 0) {\n    parsedParams.data = JSON.parse(params.data)\n  }\n\n  return parsedParams\n}\n"],"names":["isNumber","parseBooleanString","sanitizeJoinParams","sanitizePopulateParam","sanitizeSelectParam","sanitizeSortParams","booleanParams","numberParams","parseParams","params","parsedParams","key","Number","populate","select","joins","sort","data","length","JSON","parse"],"mappings":"AAGA,SAASA,QAAQ,QAAQ,iBAAgB;AACzC,SAASC,kBAAkB,QAAQ,2BAA0B;AAC7D,SAASC,kBAAkB,QAAQ,2BAA0B;AAC7D,SAASC,qBAAqB,QAAQ,8BAA6B;AACnE,SAASC,mBAAmB,QAAQ,4BAA2B;AAC/D,SAASC,kBAAkB,QAAQ,2BAA0B;AAiD7D,OAAO,MAAMC,gBAAgB;IAC3B;IACA;IACA;IACA;IACA;IACA;CACD,CAAA;AAED,OAAO,MAAMC,eAAe;IAAC;IAAS;IAAS;CAAO,CAAA;AAEtD;;;;;;CAMC,GACD,OAAO,MAAMC,cAAc,CAACC;IAC1B,MAAMC,eAAgBD,UAAU,CAAC;IAEjC,sDAAsD;IACtD,KAAK,MAAME,OAAOL,cAAe;QAC/B,IAAIK,OAAOF,QAAQ;YACjBC,YAAY,CAACC,IAAI,GAAGV,mBAAmBQ,MAAM,CAACE,IAAI;QACpD;IACF;IAEA,KAAK,MAAMA,OAAOJ,aAAc;QAC9B,IAAII,OAAOF,QAAQ;YACjB,IAAIT,SAASS,MAAM,CAACE,IAAI,GAAG;gBACzBD,YAAY,CAACC,IAAI,GAAGC,OAAOH,MAAM,CAACE,IAAI;YACxC;QACF;IACF;IAEA,IAAI,cAAcF,QAAQ;QACxBC,aAAaG,QAAQ,GAAGV,sBAAsBM,OAAOI,QAAQ;IAC/D;IAEA,IAAI,YAAYJ,QAAQ;QACtBC,aAAaI,MAAM,GAAGV,oBAAoBK,OAAOK,MAAM;IACzD;IAEA,IAAI,WAAWL,QAAQ;QACrBC,aAAaK,KAAK,GAAGb,mBAAmBO,OAAOM,KAAK;IACtD;IAEA,IAAI,UAAUN,QAAQ;QACpBC,aAAaM,IAAI,GAAGX,mBAAmBI,OAAOO,IAAI;IACpD;IAEA,IAAI,UAAUP,UAAU,OAAOA,OAAOQ,IAAI,KAAK,YAAYR,OAAOQ,IAAI,CAACC,MAAM,GAAG,GAAG;QACjFR,aAAaO,IAAI,GAAGE,KAAKC,KAAK,CAACX,OAAOQ,IAAI;IAC5C;IAEA,OAAOP;AACT,EAAC"}

package/dist/utilities/parseParams/index.spec.js

@@ -0,0 +1,369 @@
+import * as qs from 'qs-esm';
+import { describe, it, expect } from 'vitest';
+import { parseParams, booleanParams, numberParams } from './index.js';
+describe('parseParams', ()=>{
+    describe('boolean parameters', ()=>{
+        booleanParams.forEach((param)=>{
+            describe(param, ()=>{
+                it('should parse string "true" to boolean true', ()=>{
+                    const result = parseParams({
+                        [param]: 'true'
+                    });
+                    expect(result[param]).toBe(true);
+                });
+                it('should parse string "false" to boolean false', ()=>{
+                    const result = parseParams({
+                        [param]: 'false'
+                    });
+                    expect(result[param]).toBe(false);
+                });
+                it('should parse boolean true to boolean true', ()=>{
+                    const result = parseParams({
+                        [param]: true
+                    });
+                    expect(result[param]).toBe(true);
+                });
+                it('should parse boolean false to boolean false', ()=>{
+                    const result = parseParams({
+                        [param]: false
+                    });
+                    expect(result[param]).toBe(false);
+                });
+                it('should return undefined for truthy strings (not exact "true")', ()=>{
+                    const result = parseParams({
+                        [param]: '1'
+                    });
+                    expect(result[param]).toBeUndefined();
+                });
+                it('should return undefined for falsy strings (not exact "false")', ()=>{
+                    const result = parseParams({
+                        [param]: '0'
+                    });
+                    expect(result[param]).toBeUndefined();
+                });
+                it('should return undefined for empty string', ()=>{
+                    const result = parseParams({
+                        [param]: ''
+                    });
+                    expect(result[param]).toBeUndefined();
+                });
+            });
+        });
+    });
+    describe('number parameters', ()=>{
+        numberParams.forEach((param)=>{
+            describe(param, ()=>{
+                it('should parse valid number string to number', ()=>{
+                    const result = parseParams({
+                        [param]: '42'
+                    });
+                    expect(result[param]).toBe(42);
+                });
+                it('should parse zero string to zero', ()=>{
+                    const result = parseParams({
+                        [param]: '0'
+                    });
+                    expect(result[param]).toBe(0);
+                });
+                it('should parse negative number string to negative number', ()=>{
+                    const result = parseParams({
+                        [param]: '-5'
+                    });
+                    expect(result[param]).toBe(-5);
+                });
+                it('should parse decimal number string to decimal number', ()=>{
+                    const result = parseParams({
+                        [param]: '3.14'
+                    });
+                    expect(result[param]).toBe(3.14);
+                });
+                it('should not parse invalid number strings', ()=>{
+                    const result = parseParams({
+                        [param]: 'not-a-number'
+                    });
+                    expect(result[param]).toBe('not-a-number'); // remains as string
+                });
+                it('should not parse empty string', ()=>{
+                    const result = parseParams({
+                        [param]: ''
+                    });
+                    expect(result[param]).toBe(''); // remains as string
+                });
+                it('should handle already numeric values', ()=>{
+                    const result = parseParams({
+                        [param]: 123
+                    });
+                    expect(result[param]).toBe(123);
+                });
+            });
+        });
+    });
+    describe('sort parameter', ()=>{
+        it('should parse comma-separated string to array', ()=>{
+            const result = parseParams({
+                sort: 'name,createdAt,-updatedAt'
+            });
+            expect(result.sort).toEqual([
+                'name',
+                'createdAt',
+                '-updatedAt'
+            ]);
+        });
+        it('should parse single value string to array with one element', ()=>{
+            const result = parseParams({
+                sort: 'name'
+            });
+            expect(result.sort).toEqual([
+                'name'
+            ]);
+        });
+        it('should handle empty string', ()=>{
+            const result = parseParams({
+                sort: ''
+            });
+            expect(result.sort).toEqual([
+                ''
+            ]);
+        });
+        it('should handle comma-separated string with spaces', ()=>{
+            const result = parseParams({
+                sort: 'name, createdAt , -updatedAt'
+            });
+            expect(result.sort).toEqual([
+                'name',
+                ' createdAt ',
+                ' -updatedAt'
+            ]);
+        });
+        it('should parse array of strings', ()=>{
+            const result = parseParams({
+                sort: [
+                    'name',
+                    '-createdAt'
+                ]
+            });
+            expect(result.sort).toEqual([
+                'name',
+                '-createdAt'
+            ]);
+        });
+        it('should return undefined for non-string sort values', ()=>{
+            const result = parseParams({
+                sort: 123
+            });
+            expect(result.sort).toBeUndefined();
+        });
+        it('should return undefined for array with non-string sort values', ()=>{
+            const result = parseParams({
+                sort: [
+                    'name',
+                    123
+                ]
+            });
+            expect(result.sort).toBeUndefined();
+        });
+        it('should handle qs-esm array sort parsing', ()=>{
+            const query = qs.stringify({
+                sort: [
+                    'title',
+                    '-createdAt'
+                ]
+            });
+            const parsed = qs.parse(query);
+            const result = parseParams(parsed);
+            expect(result.sort).toEqual([
+                'title',
+                '-createdAt'
+            ]);
+        });
+        it('should return undefined for null sort values', ()=>{
+            const result = parseParams({
+                sort: null
+            });
+            expect(result.sort).toBeUndefined();
+        });
+    });
+    describe('data parameter', ()=>{
+        it('should parse valid JSON string', ()=>{
+            const data = {
+                name: 'test',
+                value: 42
+            };
+            const result = parseParams({
+                data: JSON.stringify(data)
+            });
+            expect(result.data).toEqual(data);
+        });
+        it('should parse empty object JSON string', ()=>{
+            const result = parseParams({
+                data: '{}'
+            });
+            expect(result.data).toEqual({});
+        });
+        it('should parse array JSON string', ()=>{
+            const data = [
+                1,
+                2,
+                3
+            ];
+            const result = parseParams({
+                data: JSON.stringify(data)
+            });
+            expect(result.data).toEqual(data);
+        });
+        it('should not process empty string', ()=>{
+            const result = parseParams({
+                data: ''
+            });
+            expect(result.data).toBe(''); // empty string is not processed, remains as string
+        });
+        it('should throw error for invalid JSON', ()=>{
+            expect(()=>{
+                parseParams({
+                    data: 'invalid-json'
+                });
+            }).toThrow();
+        });
+        it('should not process non-string data values', ()=>{
+            const result = parseParams({
+                data: {
+                    already: 'parsed'
+                }
+            });
+            expect(result.data).toEqual({
+                already: 'parsed'
+            });
+        });
+    });
+    describe('special parameters', ()=>{
+        it('should handle populate parameter', ()=>{
+            const result = parseParams({
+                populate: 'field1,field2'
+            });
+            expect(result).toHaveProperty('populate');
+        // Note: actual sanitization logic is tested in sanitizePopulateParam tests
+        });
+        it('should handle select parameter', ()=>{
+            const result = parseParams({
+                select: 'field1,field2'
+            });
+            expect(result).toHaveProperty('select');
+        // Note: actual sanitization logic is tested in sanitizeSelectParam tests
+        });
+        it('should handle joins parameter', ()=>{
+            const joins = {
+                collection: 'posts'
+            };
+            const result = parseParams({
+                joins
+            });
+            expect(result).toHaveProperty('joins');
+        // Note: actual sanitization logic is tested in sanitizeJoinParams tests
+        });
+    });
+    describe('selectedLocales parameter', ()=>{
+        it('should pass through selectedLocales as-is', ()=>{
+            const selectedLocales = 'en,es,fr';
+            const result = parseParams({
+                selectedLocales
+            });
+            expect(result.selectedLocales).toBe(selectedLocales);
+        });
+    });
+    describe('publishSpecificLocale parameter', ()=>{
+        it('should pass through publishSpecificLocale as-is', ()=>{
+            const publishSpecificLocale = 'en';
+            const result = parseParams({
+                publishSpecificLocale
+            });
+            expect(result.publishSpecificLocale).toBe(publishSpecificLocale);
+        });
+    });
+    describe('field parameter', ()=>{
+        it('should pass through field as-is', ()=>{
+            const field = 'myField';
+            const result = parseParams({
+                field
+            });
+            expect(result.field).toBe(field);
+        });
+    });
+    describe('where parameter', ()=>{
+        it('should pass through where as-is', ()=>{
+            const where = {
+                name: {
+                    equals: 'test'
+                }
+            };
+            const result = parseParams({
+                where
+            });
+            expect(result.where).toBe(where);
+        });
+    });
+    describe('edge cases', ()=>{
+        it('should handle empty params object', ()=>{
+            const result = parseParams({});
+            expect(result).toEqual({});
+        });
+        it('should throw error for null params (current implementation bug)', ()=>{
+            expect(()=>{
+                parseParams(null);
+            }).toThrow(TypeError);
+        });
+        it('should throw error for undefined params (current implementation bug)', ()=>{
+            expect(()=>{
+                parseParams(undefined);
+            }).toThrow(TypeError);
+        });
+        it('should preserve unknown parameters', ()=>{
+            const result = parseParams({
+                customParam: 'customValue'
+            });
+            expect(result.customParam).toBe('customValue');
+        });
+        it('should handle mixed parameter types', ()=>{
+            const result = parseParams({
+                draft: 'true',
+                depth: '5',
+                sort: 'name,createdAt',
+                data: '{"test": true}',
+                customParam: 'custom'
+            });
+            expect(result.draft).toBe(true);
+            expect(result.depth).toBe(5);
+            expect(result.sort).toEqual([
+                'name',
+                'createdAt'
+            ]);
+            expect(result.data).toEqual({
+                test: true
+            });
+            expect(result.customParam).toBe('custom');
+        });
+    });
+    describe('parameter preservation', ()=>{
+        it('should not modify parameters that are not in known lists', ()=>{
+            const params = {
+                unknownBoolean: 'true',
+                unknownNumber: '42',
+                unknownString: 'test'
+            };
+            const result = parseParams(params);
+            expect(result.unknownBoolean).toBe('true'); // should remain string
+            expect(result.unknownNumber).toBe('42'); // should remain string
+            expect(result.unknownString).toBe('test');
+        });
+        it('should only process parameters that exist in the input', ()=>{
+            const result = parseParams({
+                draft: 'true'
+            });
+            expect(result.draft).toBe(true);
+            expect(result).not.toHaveProperty('autosave');
+            expect(result).not.toHaveProperty('depth');
+            expect(result).not.toHaveProperty('sort');
+        });
+    });
+});
+
+//# sourceMappingURL=index.spec.js.map

package/dist/utilities/parseParams/index.spec.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utilities/parseParams/index.spec.ts"],"sourcesContent":["import * as qs from 'qs-esm'\nimport { describe, it, expect } from 'vitest'\nimport { parseParams, booleanParams, numberParams } from './index.js'\n\ndescribe('parseParams', () => {\n  describe('boolean parameters', () => {\n    booleanParams.forEach((param) => {\n      describe(param, () => {\n        it('should parse string \"true\" to boolean true', () => {\n          const result = parseParams({ [param]: 'true' })\n          expect(result[param]).toBe(true)\n        })\n\n        it('should parse string \"false\" to boolean false', () => {\n          const result = parseParams({ [param]: 'false' })\n          expect(result[param]).toBe(false)\n        })\n\n        it('should parse boolean true to boolean true', () => {\n          const result = parseParams({ [param]: true })\n          expect(result[param]).toBe(true)\n        })\n\n        it('should parse boolean false to boolean false', () => {\n          const result = parseParams({ [param]: false })\n          expect(result[param]).toBe(false)\n        })\n\n        it('should return undefined for truthy strings (not exact \"true\")', () => {\n          const result = parseParams({ [param]: '1' })\n          expect(result[param]).toBeUndefined()\n        })\n\n        it('should return undefined for falsy strings (not exact \"false\")', () => {\n          const result = parseParams({ [param]: '0' })\n          expect(result[param]).toBeUndefined()\n        })\n\n        it('should return undefined for empty string', () => {\n          const result = parseParams({ [param]: '' })\n          expect(result[param]).toBeUndefined()\n        })\n      })\n    })\n  })\n\n  describe('number parameters', () => {\n    numberParams.forEach((param) => {\n      describe(param, () => {\n        it('should parse valid number string to number', () => {\n          const result = parseParams({ [param]: '42' })\n          expect(result[param]).toBe(42)\n        })\n\n        it('should parse zero string to zero', () => {\n          const result = parseParams({ [param]: '0' })\n          expect(result[param]).toBe(0)\n        })\n\n        it('should parse negative number string to negative number', () => {\n          const result = parseParams({ [param]: '-5' })\n          expect(result[param]).toBe(-5)\n        })\n\n        it('should parse decimal number string to decimal number', () => {\n          const result = parseParams({ [param]: '3.14' })\n          expect(result[param]).toBe(3.14)\n        })\n\n        it('should not parse invalid number strings', () => {\n          const result = parseParams({ [param]: 'not-a-number' })\n          expect(result[param]).toBe('not-a-number') // remains as string\n        })\n\n        it('should not parse empty string', () => {\n          const result = parseParams({ [param]: '' })\n          expect(result[param]).toBe('') // remains as string\n        })\n\n        it('should handle already numeric values', () => {\n          const result = parseParams({ [param]: 123 })\n          expect(result[param]).toBe(123)\n        })\n      })\n    })\n  })\n\n  describe('sort parameter', () => {\n    it('should parse comma-separated string to array', () => {\n      const result = parseParams({ sort: 'name,createdAt,-updatedAt' })\n      expect(result.sort).toEqual(['name', 'createdAt', '-updatedAt'])\n    })\n\n    it('should parse single value string to array with one element', () => {\n      const result = parseParams({ sort: 'name' })\n      expect(result.sort).toEqual(['name'])\n    })\n\n    it('should handle empty string', () => {\n      const result = parseParams({ sort: '' })\n      expect(result.sort).toEqual([''])\n    })\n\n    it('should handle comma-separated string with spaces', () => {\n      const result = parseParams({ sort: 'name, createdAt , -updatedAt' })\n      expect(result.sort).toEqual(['name', ' createdAt ', ' -updatedAt'])\n    })\n\n    it('should parse array of strings', () => {\n      const result = parseParams({ sort: ['name', '-createdAt'] })\n      expect(result.sort).toEqual(['name', '-createdAt'])\n    })\n\n    it('should return undefined for non-string sort values', () => {\n      const result = parseParams({ sort: 123 as any })\n      expect(result.sort).toBeUndefined()\n    })\n\n    it('should return undefined for array with non-string sort values', () => {\n      const result = parseParams({ sort: ['name', 123] as any })\n      expect(result.sort).toBeUndefined()\n    })\n\n    it('should handle qs-esm array sort parsing', () => {\n      const query = qs.stringify({ sort: ['title', '-createdAt'] })\n      const parsed = qs.parse(query)\n      const result = parseParams(parsed)\n      expect(result.sort).toEqual(['title', '-createdAt'])\n    })\n\n    it('should return undefined for null sort values', () => {\n      const result = parseParams({ sort: null as any })\n      expect(result.sort).toBeUndefined()\n    })\n  })\n\n  describe('data parameter', () => {\n    it('should parse valid JSON string', () => {\n      const data = { name: 'test', value: 42 }\n      const result = parseParams({ data: JSON.stringify(data) })\n      expect(result.data).toEqual(data)\n    })\n\n    it('should parse empty object JSON string', () => {\n      const result = parseParams({ data: '{}' })\n      expect(result.data).toEqual({})\n    })\n\n    it('should parse array JSON string', () => {\n      const data = [1, 2, 3]\n      const result = parseParams({ data: JSON.stringify(data) })\n      expect(result.data).toEqual(data)\n    })\n\n    it('should not process empty string', () => {\n      const result = parseParams({ data: '' })\n      expect(result.data).toBe('') // empty string is not processed, remains as string\n    })\n\n    it('should throw error for invalid JSON', () => {\n      expect(() => {\n        parseParams({ data: 'invalid-json' })\n      }).toThrow()\n    })\n\n    it('should not process non-string data values', () => {\n      const result = parseParams({ data: { already: 'parsed' } as any })\n      expect(result.data).toEqual({ already: 'parsed' })\n    })\n  })\n\n  describe('special parameters', () => {\n    it('should handle populate parameter', () => {\n      const result = parseParams({ populate: 'field1,field2' })\n      expect(result).toHaveProperty('populate')\n      // Note: actual sanitization logic is tested in sanitizePopulateParam tests\n    })\n\n    it('should handle select parameter', () => {\n      const result = parseParams({ select: 'field1,field2' })\n      expect(result).toHaveProperty('select')\n      // Note: actual sanitization logic is tested in sanitizeSelectParam tests\n    })\n\n    it('should handle joins parameter', () => {\n      const joins = { collection: 'posts' }\n      const result = parseParams({ joins })\n      expect(result).toHaveProperty('joins')\n      // Note: actual sanitization logic is tested in sanitizeJoinParams tests\n    })\n  })\n\n  describe('selectedLocales parameter', () => {\n    it('should pass through selectedLocales as-is', () => {\n      const selectedLocales = 'en,es,fr'\n      const result = parseParams({ selectedLocales })\n      expect(result.selectedLocales).toBe(selectedLocales)\n    })\n  })\n\n  describe('publishSpecificLocale parameter', () => {\n    it('should pass through publishSpecificLocale as-is', () => {\n      const publishSpecificLocale = 'en'\n      const result = parseParams({ publishSpecificLocale })\n      expect(result.publishSpecificLocale).toBe(publishSpecificLocale)\n    })\n  })\n\n  describe('field parameter', () => {\n    it('should pass through field as-is', () => {\n      const field = 'myField'\n      const result = parseParams({ field })\n      expect(result.field).toBe(field)\n    })\n  })\n\n  describe('where parameter', () => {\n    it('should pass through where as-is', () => {\n      const where = { name: { equals: 'test' } }\n      const result = parseParams({ where })\n      expect(result.where).toBe(where)\n    })\n  })\n\n  describe('edge cases', () => {\n    it('should handle empty params object', () => {\n      const result = parseParams({})\n      expect(result).toEqual({})\n    })\n\n    it('should throw error for null params (current implementation bug)', () => {\n      expect(() => {\n        parseParams(null as any)\n      }).toThrow(TypeError)\n    })\n\n    it('should throw error for undefined params (current implementation bug)', () => {\n      expect(() => {\n        parseParams(undefined as any)\n      }).toThrow(TypeError)\n    })\n\n    it('should preserve unknown parameters', () => {\n      const result = parseParams({ customParam: 'customValue' })\n      expect(result.customParam).toBe('customValue')\n    })\n\n    it('should handle mixed parameter types', () => {\n      const result = parseParams({\n        draft: 'true',\n        depth: '5',\n        sort: 'name,createdAt',\n        data: '{\"test\": true}',\n        customParam: 'custom',\n      })\n\n      expect(result.draft).toBe(true)\n      expect(result.depth).toBe(5)\n      expect(result.sort).toEqual(['name', 'createdAt'])\n      expect(result.data).toEqual({ test: true })\n      expect(result.customParam).toBe('custom')\n    })\n  })\n\n  describe('parameter preservation', () => {\n    it('should not modify parameters that are not in known lists', () => {\n      const params = {\n        unknownBoolean: 'true',\n        unknownNumber: '42',\n        unknownString: 'test',\n      }\n      const result = parseParams(params)\n\n      expect(result.unknownBoolean).toBe('true') // should remain string\n      expect(result.unknownNumber).toBe('42') // should remain string\n      expect(result.unknownString).toBe('test')\n    })\n\n    it('should only process parameters that exist in the input', () => {\n      const result = parseParams({ draft: 'true' })\n\n      expect(result.draft).toBe(true)\n      expect(result).not.toHaveProperty('autosave')\n      expect(result).not.toHaveProperty('depth')\n      expect(result).not.toHaveProperty('sort')\n    })\n  })\n})\n"],"names":["qs","describe","it","expect","parseParams","booleanParams","numberParams","forEach","param","result","toBe","toBeUndefined","sort","toEqual","query","stringify","parsed","parse","data","name","value","JSON","toThrow","already","populate","toHaveProperty","select","joins","collection","selectedLocales","publishSpecificLocale","field","where","equals","TypeError","undefined","customParam","draft","depth","test","params","unknownBoolean","unknownNumber","unknownString","not"],"mappings":"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"}

package/dist/utilities/reduceFieldsToValues.d.ts

@@ -0,0 +1,10 @@
+import type { Data, FormState } from '../admin/types.js';
+/**
+ * Reduce flattened form fields (Fields) to just map to the respective values instead of the full FormField object
+ *
+ * @param unflatten This also unflattens the data if `unflatten` is true. The unflattened data should match the original data structure
+ * @param ignoreDisableFormData - if true, will include fields that have `disableFormData` set to true, for example, blocks or arrays fields.
+ *
+ */
+export declare const reduceFieldsToValues: (fields: FormState, unflatten?: boolean, ignoreDisableFormData?: boolean) => Data;
+//# sourceMappingURL=reduceFieldsToValues.d.ts.map

package/dist/utilities/reduceFieldsToValues.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reduceFieldsToValues.d.ts","sourceRoot":"","sources":["../../src/utilities/reduceFieldsToValues.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAA;AAGxD;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB,WACvB,SAAS,cACL,OAAO,0BACK,OAAO,KAC9B,IAkBF,CAAA"}

package/dist/utilities/reduceFieldsToValues.js

@@ -0,0 +1,24 @@
+import { unflatten as flatleyUnflatten } from './unflatten.js';
+/**
+ * Reduce flattened form fields (Fields) to just map to the respective values instead of the full FormField object
+ *
+ * @param unflatten This also unflattens the data if `unflatten` is true. The unflattened data should match the original data structure
+ * @param ignoreDisableFormData - if true, will include fields that have `disableFormData` set to true, for example, blocks or arrays fields.
+ *
+ */ export const reduceFieldsToValues = (fields, unflatten, ignoreDisableFormData)=>{
+    let data = {};
+    if (!fields) {
+        return data;
+    }
+    Object.keys(fields).forEach((key)=>{
+        if (ignoreDisableFormData === true || !fields[key]?.disableFormData) {
+            data[key] = fields[key]?.value;
+        }
+    });
+    if (unflatten) {
+        data = flatleyUnflatten(data);
+    }
+    return data;
+};
+
+//# sourceMappingURL=reduceFieldsToValues.js.map

package/dist/utilities/reduceFieldsToValues.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/reduceFieldsToValues.ts"],"sourcesContent":["import type { Data, FormState } from '../admin/types.js'\n\nimport { unflatten as flatleyUnflatten } from './unflatten.js'\n/**\n * Reduce flattened form fields (Fields) to just map to the respective values instead of the full FormField object\n *\n * @param unflatten This also unflattens the data if `unflatten` is true. The unflattened data should match the original data structure\n * @param ignoreDisableFormData - if true, will include fields that have `disableFormData` set to true, for example, blocks or arrays fields.\n *\n */\nexport const reduceFieldsToValues = (\n  fields: FormState,\n  unflatten?: boolean,\n  ignoreDisableFormData?: boolean,\n): Data => {\n  let data: Record<string, any> = {}\n\n  if (!fields) {\n    return data\n  }\n\n  Object.keys(fields).forEach((key) => {\n    if (ignoreDisableFormData === true || !fields[key]?.disableFormData) {\n      data[key] = fields[key]?.value\n    }\n  })\n\n  if (unflatten) {\n    data = flatleyUnflatten(data)\n  }\n\n  return data\n}\n"],"names":["unflatten","flatleyUnflatten","reduceFieldsToValues","fields","ignoreDisableFormData","data","Object","keys","forEach","key","disableFormData","value"],"mappings":"AAEA,SAASA,aAAaC,gBAAgB,QAAQ,iBAAgB;AAC9D;;;;;;CAMC,GACD,OAAO,MAAMC,uBAAuB,CAClCC,QACAH,WACAI;IAEA,IAAIC,OAA4B,CAAC;IAEjC,IAAI,CAACF,QAAQ;QACX,OAAOE;IACT;IAEAC,OAAOC,IAAI,CAACJ,QAAQK,OAAO,CAAC,CAACC;QAC3B,IAAIL,0BAA0B,QAAQ,CAACD,MAAM,CAACM,IAAI,EAAEC,iBAAiB;YACnEL,IAAI,CAACI,IAAI,GAAGN,MAAM,CAACM,IAAI,EAAEE;QAC3B;IACF;IAEA,IAAIX,WAAW;QACbK,OAAOJ,iBAAiBI;IAC1B;IAEA,OAAOA;AACT,EAAC"}

package/dist/utilities/removeUndefined.d.ts

@@ -0,0 +1,2 @@
+export declare function removeUndefined<T extends object>(obj: T): T;
+//# sourceMappingURL=removeUndefined.d.ts.map

package/dist/utilities/removeUndefined.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"removeUndefined.d.ts","sourceRoot":"","sources":["../../src/utilities/removeUndefined.ts"],"names":[],"mappings":"AAAA,wBAAgB,eAAe,CAAC,CAAC,SAAS,MAAM,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,CAE3D"}

package/dist/utilities/removeUndefined.js

@@ -0,0 +1,5 @@
+export function removeUndefined(obj) {
+    return Object.fromEntries(Object.entries(obj).filter(([, value])=>value !== undefined));
+}
+
+//# sourceMappingURL=removeUndefined.js.map

package/dist/utilities/removeUndefined.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/removeUndefined.ts"],"sourcesContent":["export function removeUndefined<T extends object>(obj: T): T {\n  return Object.fromEntries(Object.entries(obj).filter(([, value]) => value !== undefined)) as T\n}\n"],"names":["removeUndefined","obj","Object","fromEntries","entries","filter","value","undefined"],"mappings":"AAAA,OAAO,SAASA,gBAAkCC,GAAM;IACtD,OAAOC,OAAOC,WAAW,CAACD,OAAOE,OAAO,CAACH,KAAKI,MAAM,CAAC,CAAC,GAAGC,MAAM,GAAKA,UAAUC;AAChF"}

package/dist/utilities/routeError.d.ts

@@ -0,0 +1,11 @@
+import type { Collection } from '../collections/config/types.js';
+import type { SanitizedConfig } from '../config/types.js';
+import type { PayloadRequest } from '../types/index.js';
+import { APIError } from '../errors/APIError.js';
+export declare const routeError: ({ collection, config: configArg, err, req: incomingReq, }: {
+    collection?: Collection;
+    config: Promise<SanitizedConfig> | SanitizedConfig;
+    err: APIError;
+    req: PayloadRequest | Request;
+}) => Promise<Response>;
+//# sourceMappingURL=routeError.d.ts.map

package/dist/utilities/routeError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routeError.d.ts","sourceRoot":"","sources":["../../src/utilities/routeError.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAA;AAChE,OAAO,KAAK,EAAe,eAAe,EAAE,MAAM,oBAAoB,CAAA;AACtE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AAEvD,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAA;AAQhD,eAAO,MAAM,UAAU,8DAKpB;IACD,UAAU,CAAC,EAAE,UAAU,CAAA;IACvB,MAAM,EAAE,OAAO,CAAC,eAAe,CAAC,GAAG,eAAe,CAAA;IAClD,GAAG,EAAE,QAAQ,CAAA;IACb,GAAG,EAAE,cAAc,GAAG,OAAO,CAAA;CAC9B,KAAG,OAAO,CAAC,QAAQ,CA+FnB,CAAA"}