@payloadcms/db-mongodb 1.0.0-beta.0

package/dist/queries/getLocalizedSortProperty.spec.js

@@ -0,0 +1,195 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _config = require("payload/config");
+const _getLocalizedSortProperty = require("./getLocalizedSortProperty");
+const config = {
+    localization: {
+        locales: [
+            'en',
+            'es'
+        ]
+    }
+};
+describe('get localized sort property', ()=>{
+    it('passes through a non-localized sort property', ()=>{
+        const result = (0, _getLocalizedSortProperty.getLocalizedSortProperty)({
+            segments: [
+                'title'
+            ],
+            config: (0, _config.sanitizeConfig)(config),
+            fields: [
+                {
+                    name: 'title',
+                    type: 'text'
+                }
+            ],
+            locale: 'en'
+        });
+        expect(result).toStrictEqual('title');
+    });
+    it('properly localizes an un-localized sort property', ()=>{
+        const result = (0, _getLocalizedSortProperty.getLocalizedSortProperty)({
+            segments: [
+                'title'
+            ],
+            config: (0, _config.sanitizeConfig)(config),
+            fields: [
+                {
+                    name: 'title',
+                    type: 'text',
+                    localized: true
+                }
+            ],
+            locale: 'en'
+        });
+        expect(result).toStrictEqual('title.en');
+    });
+    it('keeps specifically asked-for localized sort properties', ()=>{
+        const result = (0, _getLocalizedSortProperty.getLocalizedSortProperty)({
+            segments: [
+                'title',
+                'es'
+            ],
+            config: (0, _config.sanitizeConfig)(config),
+            fields: [
+                {
+                    name: 'title',
+                    type: 'text',
+                    localized: true
+                }
+            ],
+            locale: 'en'
+        });
+        expect(result).toStrictEqual('title.es');
+    });
+    it('properly localizes nested sort properties', ()=>{
+        const result = (0, _getLocalizedSortProperty.getLocalizedSortProperty)({
+            segments: [
+                'group',
+                'title'
+            ],
+            config: (0, _config.sanitizeConfig)(config),
+            fields: [
+                {
+                    name: 'group',
+                    type: 'group',
+                    fields: [
+                        {
+                            name: 'title',
+                            type: 'text',
+                            localized: true
+                        }
+                    ]
+                }
+            ],
+            locale: 'en'
+        });
+        expect(result).toStrictEqual('group.title.en');
+    });
+    it('keeps requested locale with nested sort properties', ()=>{
+        const result = (0, _getLocalizedSortProperty.getLocalizedSortProperty)({
+            segments: [
+                'group',
+                'title',
+                'es'
+            ],
+            config: (0, _config.sanitizeConfig)(config),
+            fields: [
+                {
+                    name: 'group',
+                    type: 'group',
+                    fields: [
+                        {
+                            name: 'title',
+                            type: 'text',
+                            localized: true
+                        }
+                    ]
+                }
+            ],
+            locale: 'en'
+        });
+        expect(result).toStrictEqual('group.title.es');
+    });
+    it('properly localizes field within row', ()=>{
+        const result = (0, _getLocalizedSortProperty.getLocalizedSortProperty)({
+            segments: [
+                'title'
+            ],
+            config: (0, _config.sanitizeConfig)(config),
+            fields: [
+                {
+                    type: 'row',
+                    fields: [
+                        {
+                            name: 'title',
+                            type: 'text',
+                            localized: true
+                        }
+                    ]
+                }
+            ],
+            locale: 'en'
+        });
+        expect(result).toStrictEqual('title.en');
+    });
+    it('properly localizes field within named tab', ()=>{
+        const result = (0, _getLocalizedSortProperty.getLocalizedSortProperty)({
+            segments: [
+                'tab',
+                'title'
+            ],
+            config: (0, _config.sanitizeConfig)(config),
+            fields: [
+                {
+                    type: 'tabs',
+                    tabs: [
+                        {
+                            name: 'tab',
+                            fields: [
+                                {
+                                    name: 'title',
+                                    type: 'text',
+                                    localized: true
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ],
+            locale: 'en'
+        });
+        expect(result).toStrictEqual('tab.title.en');
+    });
+    it('properly localizes field within unnamed tab', ()=>{
+        const result = (0, _getLocalizedSortProperty.getLocalizedSortProperty)({
+            segments: [
+                'title'
+            ],
+            config: (0, _config.sanitizeConfig)(config),
+            fields: [
+                {
+                    type: 'tabs',
+                    tabs: [
+                        {
+                            label: 'Tab',
+                            fields: [
+                                {
+                                    name: 'title',
+                                    type: 'text',
+                                    localized: true
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ],
+            locale: 'en'
+        });
+        expect(result).toStrictEqual('title.en');
+    });
+});
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/queries/getLocalizedSortProperty.spec.ts"],"sourcesContent":["import { sanitizeConfig } from 'payload/config'\nimport { Config } from 'payload/config'\nimport { getLocalizedSortProperty } from './getLocalizedSortProperty'\n\nconst config = {\n  localization: {\n    locales: ['en', 'es'],\n  },\n} as Config\n\ndescribe('get localized sort property', () => {\n  it('passes through a non-localized sort property', () => {\n    const result = getLocalizedSortProperty({\n      segments: ['title'],\n      config: sanitizeConfig(config),\n      fields: [\n        {\n          name: 'title',\n          type: 'text',\n        },\n      ],\n      locale: 'en',\n    })\n\n    expect(result).toStrictEqual('title')\n  })\n\n  it('properly localizes an un-localized sort property', () => {\n    const result = getLocalizedSortProperty({\n      segments: ['title'],\n      config: sanitizeConfig(config),\n      fields: [\n        {\n          name: 'title',\n          type: 'text',\n          localized: true,\n        },\n      ],\n      locale: 'en',\n    })\n\n    expect(result).toStrictEqual('title.en')\n  })\n\n  it('keeps specifically asked-for localized sort properties', () => {\n    const result = getLocalizedSortProperty({\n      segments: ['title', 'es'],\n      config: sanitizeConfig(config),\n      fields: [\n        {\n          name: 'title',\n          type: 'text',\n          localized: true,\n        },\n      ],\n      locale: 'en',\n    })\n\n    expect(result).toStrictEqual('title.es')\n  })\n\n  it('properly localizes nested sort properties', () => {\n    const result = getLocalizedSortProperty({\n      segments: ['group', 'title'],\n      config: sanitizeConfig(config),\n      fields: [\n        {\n          name: 'group',\n          type: 'group',\n          fields: [\n            {\n              name: 'title',\n              type: 'text',\n              localized: true,\n            },\n          ],\n        },\n      ],\n      locale: 'en',\n    })\n\n    expect(result).toStrictEqual('group.title.en')\n  })\n\n  it('keeps requested locale with nested sort properties', () => {\n    const result = getLocalizedSortProperty({\n      segments: ['group', 'title', 'es'],\n      config: sanitizeConfig(config),\n      fields: [\n        {\n          name: 'group',\n          type: 'group',\n          fields: [\n            {\n              name: 'title',\n              type: 'text',\n              localized: true,\n            },\n          ],\n        },\n      ],\n      locale: 'en',\n    })\n\n    expect(result).toStrictEqual('group.title.es')\n  })\n\n  it('properly localizes field within row', () => {\n    const result = getLocalizedSortProperty({\n      segments: ['title'],\n      config: sanitizeConfig(config),\n      fields: [\n        {\n          type: 'row',\n          fields: [\n            {\n              name: 'title',\n              type: 'text',\n              localized: true,\n            },\n          ],\n        },\n      ],\n      locale: 'en',\n    })\n\n    expect(result).toStrictEqual('title.en')\n  })\n\n  it('properly localizes field within named tab', () => {\n    const result = getLocalizedSortProperty({\n      segments: ['tab', 'title'],\n      config: sanitizeConfig(config),\n      fields: [\n        {\n          type: 'tabs',\n          tabs: [\n            {\n              name: 'tab',\n              fields: [\n                {\n                  name: 'title',\n                  type: 'text',\n                  localized: true,\n                },\n              ],\n            },\n          ],\n        },\n      ],\n      locale: 'en',\n    })\n\n    expect(result).toStrictEqual('tab.title.en')\n  })\n\n  it('properly localizes field within unnamed tab', () => {\n    const result = getLocalizedSortProperty({\n      segments: ['title'],\n      config: sanitizeConfig(config),\n      fields: [\n        {\n          type: 'tabs',\n          tabs: [\n            {\n              label: 'Tab',\n              fields: [\n                {\n                  name: 'title',\n                  type: 'text',\n                  localized: true,\n                },\n              ],\n            },\n          ],\n        },\n      ],\n      locale: 'en',\n    })\n\n    expect(result).toStrictEqual('title.en')\n  })\n})\n"],"names":["config","localization","locales","describe","it","result","getLocalizedSortProperty","segments","sanitizeConfig","fields","name","type","locale","expect","toStrictEqual","localized","tabs","label"],"mappings":"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"}

package/dist/queries/mock.js

@@ -0,0 +1,3 @@
+"use strict";
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/dist/queries/operatorMap.d.ts

@@ -0,0 +1,16 @@
+export declare const operatorMap: {
+    all: string;
+    equals: string;
+    exists: string;
+    greater_than: string;
+    greater_than_equal: string;
+    in: string;
+    intersects: string;
+    less_than: string;
+    less_than_equal: string;
+    near: string;
+    not_equals: string;
+    not_in: string;
+    within: string;
+};
+//# sourceMappingURL=operatorMap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"operatorMap.d.ts","sourceRoot":"","sources":["../../src/queries/operatorMap.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,WAAW;;;;;;;;;;;;;;CAcvB,CAAA"}

package/dist/queries/operatorMap.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "operatorMap", {
+    enumerable: true,
+    get: function() {
+        return operatorMap;
+    }
+});
+const operatorMap = {
+    all: '$all',
+    equals: '$eq',
+    exists: '$exists',
+    greater_than: '$gt',
+    greater_than_equal: '$gte',
+    in: '$in',
+    intersects: '$geoIntersects',
+    less_than: '$lt',
+    less_than_equal: '$lte',
+    near: '$near',
+    not_equals: '$ne',
+    not_in: '$nin',
+    within: '$geoWithin'
+};
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9xdWVyaWVzL29wZXJhdG9yTWFwLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBjb25zdCBvcGVyYXRvck1hcCA9IHtcbiAgYWxsOiAnJGFsbCcsXG4gIGVxdWFsczogJyRlcScsXG4gIGV4aXN0czogJyRleGlzdHMnLFxuICBncmVhdGVyX3RoYW46ICckZ3QnLFxuICBncmVhdGVyX3RoYW5fZXF1YWw6ICckZ3RlJyxcbiAgaW46ICckaW4nLFxuICBpbnRlcnNlY3RzOiAnJGdlb0ludGVyc2VjdHMnLFxuICBsZXNzX3RoYW46ICckbHQnLFxuICBsZXNzX3RoYW5fZXF1YWw6ICckbHRlJyxcbiAgbmVhcjogJyRuZWFyJyxcbiAgbm90X2VxdWFsczogJyRuZScsXG4gIG5vdF9pbjogJyRuaW4nLFxuICB3aXRoaW46ICckZ2VvV2l0aGluJyxcbn1cbiJdLCJuYW1lcyI6WyJvcGVyYXRvck1hcCIsImFsbCIsImVxdWFscyIsImV4aXN0cyIsImdyZWF0ZXJfdGhhbiIsImdyZWF0ZXJfdGhhbl9lcXVhbCIsImluIiwiaW50ZXJzZWN0cyIsImxlc3NfdGhhbiIsImxlc3NfdGhhbl9lcXVhbCIsIm5lYXIiLCJub3RfZXF1YWxzIiwibm90X2luIiwid2l0aGluIl0sIm1hcHBpbmdzIjoiOzs7OytCQUFhQTs7O2VBQUFBOzs7QUFBTixNQUFNQSxjQUFjO0lBQ3pCQyxLQUFLO0lBQ0xDLFFBQVE7SUFDUkMsUUFBUTtJQUNSQyxjQUFjO0lBQ2RDLG9CQUFvQjtJQUNwQkMsSUFBSTtJQUNKQyxZQUFZO0lBQ1pDLFdBQVc7SUFDWEMsaUJBQWlCO0lBQ2pCQyxNQUFNO0lBQ05DLFlBQVk7SUFDWkMsUUFBUTtJQUNSQyxRQUFRO0FBQ1YifQ==

package/dist/queries/parseParams.d.ts

@@ -0,0 +1,12 @@
+import type { Payload } from 'payload';
+import type { Where } from 'payload/types';
+import type { Field } from 'payload/types';
+export declare function parseParams({ collectionSlug, fields, globalSlug, locale, payload, where, }: {
+    collectionSlug?: string;
+    fields: Field[];
+    globalSlug?: string;
+    locale: string;
+    payload: Payload;
+    where: Where;
+}): Promise<Record<string, unknown>>;
+//# 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":"AAGA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,SAAS,CAAA;AACtC,OAAO,KAAK,EAAY,KAAK,EAAE,MAAM,eAAe,CAAA;AACpD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,eAAe,CAAA;AAS1C,wBAAsB,WAAW,CAAC,EAChC,cAAc,EACd,MAAM,EACN,UAAU,EACV,MAAM,EACN,OAAO,EACP,KAAK,GACN,EAAE;IACD,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,MAAM,EAAE,KAAK,EAAE,CAAA;IACf,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,OAAO,CAAA;IAChB,KAAK,EAAE,KAAK,CAAA;CACb,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CA0DnC"}

package/dist/queries/parseParams.js

@@ -0,0 +1,80 @@
+/* eslint-disable no-restricted-syntax */ /* eslint-disable no-await-in-loop */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "parseParams", {
+    enumerable: true,
+    get: function() {
+        return parseParams;
+    }
+});
+const _deepmerge = /*#__PURE__*/ _interop_require_default(require("deepmerge"));
+const _types = require("payload/types");
+const _utilities = require("payload/utilities");
+const _buildAndOrConditions = require("./buildAndOrConditions");
+const _buildSearchParams = require("./buildSearchParams");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+async function parseParams({ collectionSlug, fields, globalSlug, locale, payload, where }) {
+    let result = {};
+    if (typeof where === 'object') {
+        // We need to determine if the whereKey is an AND, OR, or a schema path
+        for (const relationOrPath of Object.keys(where)){
+            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 (0, _buildAndOrConditions.buildAndOrConditions)({
+                    collectionSlug,
+                    fields,
+                    globalSlug,
+                    locale,
+                    payload,
+                    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 (const operator of Object.keys(pathOperators)){
+                        if (_types.validOperators.includes(operator)) {
+                            const searchParam = await (0, _buildSearchParams.buildSearchParam)({
+                                collectionSlug,
+                                fields,
+                                globalSlug,
+                                incomingPath: relationOrPath,
+                                locale,
+                                operator,
+                                payload,
+                                val: pathOperators[operator]
+                            });
+                            if (searchParam?.value && searchParam?.path) {
+                                result = {
+                                    ...result,
+                                    [searchParam.path]: searchParam.value
+                                };
+                            } else if (typeof searchParam?.value === 'object') {
+                                result = (0, _deepmerge.default)(result, searchParam.value, {
+                                    arrayMerge: _utilities.combineMerge
+                                });
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return result;
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/queries/sanitizeQueryValue.d.ts

@@ -0,0 +1,11 @@
+import type { Field, TabAsField } from 'payload/types';
+type SanitizeQueryValueArgs = {
+    field: Field | TabAsField;
+    hasCustomID: boolean;
+    operator: string;
+    path: string;
+    val: any;
+};
+export declare const sanitizeQueryValue: ({ field, hasCustomID, operator, path, val, }: SanitizeQueryValueArgs) => 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,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAA;AAKtD,KAAK,sBAAsB,GAAG;IAC5B,KAAK,EAAE,KAAK,GAAG,UAAU,CAAA;IACzB,WAAW,EAAE,OAAO,CAAA;IACpB,QAAQ,EAAE,MAAM,CAAA;IAChB,IAAI,EAAE,MAAM,CAAA;IACZ,GAAG,EAAE,GAAG,CAAA;CACT,CAAA;AAED,eAAO,MAAM,kBAAkB,iDAM5B,sBAAsB,KAAG,OA+G3B,CAAA"}

package/dist/queries/sanitizeQueryValue.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "sanitizeQueryValue", {
+    enumerable: true,
+    get: function() {
+        return sanitizeQueryValue;
+    }
+});
+const _mongoose = /*#__PURE__*/ _interop_require_default(require("mongoose"));
+const _utilities = require("payload/utilities");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const sanitizeQueryValue = ({ field, hasCustomID, operator, path, val })=>{
+    let formattedValue = val;
+    // Disregard invalid _ids
+    if (path === '_id' && typeof val === 'string' && val.split(',').length === 1) {
+        if (!hasCustomID) {
+            const isValid = _mongoose.default.Types.ObjectId.isValid(val);
+            if (!isValid) {
+                return undefined;
+            }
+        }
+        if (field.type === 'number') {
+            const parsedNumber = parseFloat(val);
+            if (Number.isNaN(parsedNumber)) {
+                return undefined;
+            }
+        }
+    }
+    // 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) && typeof formattedValue === 'string') {
+        formattedValue = (0, _utilities.createArrayFromCommaDelineated)(formattedValue);
+        if (field.type === 'number') {
+            formattedValue = formattedValue.map((arrayVal)=>parseFloat(arrayVal));
+        }
+    }
+    if (field.type === 'number' && typeof formattedValue === 'string') {
+        formattedValue = Number(val);
+    }
+    if (field.type === 'date' && typeof val === 'string') {
+        formattedValue = new Date(val);
+        if (Number.isNaN(Date.parse(formattedValue))) {
+            return undefined;
+        }
+    }
+    if ([
+        'relationship',
+        'upload'
+    ].includes(field.type)) {
+        if (val === 'null') {
+            formattedValue = null;
+        }
+        if (operator === 'in' && Array.isArray(formattedValue)) {
+            formattedValue = formattedValue.reduce((formattedValues, inVal)=>{
+                const newValues = [
+                    inVal
+                ];
+                if (_mongoose.default.Types.ObjectId.isValid(inVal)) newValues.push(new _mongoose.default.Types.ObjectId(inVal));
+                const parsedNumber = parseFloat(inVal);
+                if (!Number.isNaN(parsedNumber)) newValues.push(parsedNumber);
+                return [
+                    ...formattedValues,
+                    ...newValues
+                ];
+            }, []);
+        }
+    }
+    // Set up specific formatting necessary by operators
+    if (operator === 'near') {
+        let lng;
+        let lat;
+        let maxDistance;
+        let minDistance;
+        if (Array.isArray(formattedValue)) {
+            [lng, lat, maxDistance, minDistance] = formattedValue;
+        }
+        if (typeof formattedValue === 'string') {
+            [lng, lat, maxDistance, minDistance] = (0, _utilities.createArrayFromCommaDelineated)(formattedValue);
+        }
+        if (lng == null || lat == null || maxDistance == null && minDistance == null) {
+            formattedValue = undefined;
+        } else {
+            formattedValue = {
+                $geometry: {
+                    coordinates: [
+                        parseFloat(lng),
+                        parseFloat(lat)
+                    ],
+                    type: 'Point'
+                }
+            };
+            if (maxDistance) formattedValue.$maxDistance = parseFloat(maxDistance);
+            if (minDistance) formattedValue.$minDistance = parseFloat(minDistance);
+        }
+    }
+    if (operator === 'within' || operator === 'intersects') {
+        formattedValue = {
+            $geometry: formattedValue
+        };
+    }
+    if (path !== '_id' || path === '_id' && hasCustomID && field.type === 'text') {
+        if (operator === 'contains') {
+            formattedValue = {
+                $options: 'i',
+                $regex: formattedValue
+            };
+        }
+    }
+    if (operator === 'exists') {
+        formattedValue = formattedValue === 'true' || formattedValue === true;
+    }
+    return formattedValue;
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/queries/sanitizeQueryValue.ts"],"sourcesContent":["import type { Field, TabAsField } from 'payload/types'\n\nimport mongoose from 'mongoose'\nimport { createArrayFromCommaDelineated } from 'payload/utilities'\n\ntype SanitizeQueryValueArgs = {\n  field: Field | TabAsField\n  hasCustomID: boolean\n  operator: string\n  path: string\n  val: any\n}\n\nexport const sanitizeQueryValue = ({\n  field,\n  hasCustomID,\n  operator,\n  path,\n  val,\n}: SanitizeQueryValueArgs): unknown => {\n  let formattedValue = val\n\n  // Disregard invalid _ids\n  if (path === '_id' && typeof val === 'string' && val.split(',').length === 1) {\n    if (!hasCustomID) {\n      const isValid = mongoose.Types.ObjectId.isValid(val)\n\n      if (!isValid) {\n        return undefined\n      }\n    }\n\n    if (field.type === 'number') {\n      const parsedNumber = parseFloat(val)\n\n      if (Number.isNaN(parsedNumber)) {\n        return undefined\n      }\n    }\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) && 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 (field.type === 'number' && typeof formattedValue === 'string') {\n    formattedValue = Number(val)\n  }\n\n  if (field.type === 'date' && typeof val === 'string') {\n    formattedValue = new Date(val)\n    if (Number.isNaN(Date.parse(formattedValue))) {\n      return undefined\n    }\n  }\n\n  if (['relationship', 'upload'].includes(field.type)) {\n    if (val === 'null') {\n      formattedValue = null\n    }\n\n    if (operator === 'in' && Array.isArray(formattedValue)) {\n      formattedValue = formattedValue.reduce((formattedValues, inVal) => {\n        const newValues = [inVal]\n        if (mongoose.Types.ObjectId.isValid(inVal))\n          newValues.push(new mongoose.Types.ObjectId(inVal))\n\n        const parsedNumber = parseFloat(inVal)\n        if (!Number.isNaN(parsedNumber)) newValues.push(parsedNumber)\n\n        return [...formattedValues, ...newValues]\n      }, [])\n    }\n  }\n\n  // Set up specific formatting necessary by operators\n\n  if (operator === 'near') {\n    let lng\n    let lat\n    let maxDistance\n    let minDistance\n\n    if (Array.isArray(formattedValue)) {\n      ;[lng, lat, maxDistance, minDistance] = formattedValue\n    }\n\n    if (typeof formattedValue === 'string') {\n      ;[lng, lat, maxDistance, minDistance] = createArrayFromCommaDelineated(formattedValue)\n    }\n\n    if (lng == null || lat == null || (maxDistance == null && minDistance == null)) {\n      formattedValue = undefined\n    } else {\n      formattedValue = {\n        $geometry: { coordinates: [parseFloat(lng), parseFloat(lat)], type: 'Point' },\n      }\n\n      if (maxDistance) formattedValue.$maxDistance = parseFloat(maxDistance)\n      if (minDistance) formattedValue.$minDistance = parseFloat(minDistance)\n    }\n  }\n\n  if (operator === 'within' || operator === 'intersects') {\n    formattedValue = {\n      $geometry: formattedValue,\n    }\n  }\n\n  if (path !== '_id' || (path === '_id' && hasCustomID && field.type === 'text')) {\n    if (operator === 'contains') {\n      formattedValue = { $options: 'i', $regex: formattedValue }\n    }\n  }\n\n  if (operator === 'exists') {\n    formattedValue = formattedValue === 'true' || formattedValue === true\n  }\n\n  return formattedValue\n}\n"],"names":["sanitizeQueryValue","field","hasCustomID","operator","path","val","formattedValue","split","length","isValid","mongoose","Types","ObjectId","undefined","type","parsedNumber","parseFloat","Number","isNaN","toLowerCase","includes","createArrayFromCommaDelineated","map","arrayVal","Date","parse","Array","isArray","reduce","formattedValues","inVal","newValues","push","lng","lat","maxDistance","minDistance","$geometry","coordinates","$maxDistance","$minDistance","$options","$regex"],"mappings":"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"}

package/dist/queryDrafts.d.ts

@@ -0,0 +1,3 @@
+import type { QueryDrafts } from 'payload/database';
+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":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAWnD,eAAO,MAAM,WAAW,EAAE,WAqEzB,CAAA"}

package/dist/queryDrafts.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "queryDrafts", {
+    enumerable: true,
+    get: function() {
+        return queryDrafts;
+    }
+});
+const _database = require("payload/database");
+const _buildSortParam = require("./queries/buildSortParam");
+const _sanitizeInternalFields = /*#__PURE__*/ _interop_require_default(require("./utilities/sanitizeInternalFields"));
+const _withSession = require("./withSession");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const queryDrafts = async function queryDrafts({ collection, limit, locale, page, pagination, req = {}, sort: sortArg, where }) {
+    const VersionModel = this.versions[collection];
+    const collectionConfig = this.payload.collections[collection].config;
+    const options = (0, _withSession.withSession)(this, req.transactionID);
+    let hasNearConstraint;
+    let sort;
+    if (where) {
+        const constraints = (0, _database.flattenWhereToOperators)(where);
+        hasNearConstraint = constraints.some((prop)=>Object.keys(prop).some((key)=>key === 'near'));
+    }
+    if (!hasNearConstraint) {
+        sort = (0, _buildSortParam.buildSortParam)({
+            config: this.payload.config,
+            fields: collectionConfig.fields,
+            locale,
+            sort: sortArg || collectionConfig.defaultSort,
+            timestamps: true
+        });
+    }
+    const combinedWhere = (0, _database.combineQueries)({
+        latest: {
+            equals: true
+        }
+    }, where);
+    const versionQuery = await VersionModel.buildQuery({
+        locale,
+        payload: this.payload,
+        where: combinedWhere
+    });
+    const paginationOptions = {
+        forceCountFn: hasNearConstraint,
+        lean: true,
+        leanWithId: true,
+        options,
+        page,
+        pagination,
+        sort,
+        useEstimatedCount: hasNearConstraint
+    };
+    if (limit > 0) {
+        paginationOptions.limit = limit;
+        // limit must also be set here, it's ignored when pagination is false
+        paginationOptions.options.limit = limit;
+    }
+    const result = await VersionModel.paginate(versionQuery, paginationOptions);
+    const docs = JSON.parse(JSON.stringify(result.docs));
+    return {
+        ...result,
+        docs: docs.map((doc)=>{
+            // eslint-disable-next-line no-param-reassign
+            doc = {
+                _id: doc.parent,
+                id: doc.parent,
+                ...doc.version,
+                createdAt: doc.createdAt,
+                updatedAt: doc.updatedAt
+            };
+            return (0, _sanitizeInternalFields.default)(doc);
+        })
+    };
+};
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy9xdWVyeURyYWZ0cy50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IFBhZ2luYXRlT3B0aW9ucyB9IGZyb20gJ21vbmdvb3NlJ1xuaW1wb3J0IHR5cGUgeyBRdWVyeURyYWZ0cyB9IGZyb20gJ3BheWxvYWQvZGF0YWJhc2UnXG5pbXBvcnQgdHlwZSB7IFBheWxvYWRSZXF1ZXN0IH0gZnJvbSAncGF5bG9hZC90eXBlcydcblxuaW1wb3J0IHsgY29tYmluZVF1ZXJpZXMsIGZsYXR0ZW5XaGVyZVRvT3BlcmF0b3JzIH0gZnJvbSAncGF5bG9hZC9kYXRhYmFzZSdcblxuaW1wb3J0IHR5cGUgeyBNb25nb29zZUFkYXB0ZXIgfSBmcm9tICcuJ1xuXG5pbXBvcnQgeyBidWlsZFNvcnRQYXJhbSB9IGZyb20gJy4vcXVlcmllcy9idWlsZFNvcnRQYXJhbSdcbmltcG9ydCBzYW5pdGl6ZUludGVybmFsRmllbGRzIGZyb20gJy4vdXRpbGl0aWVzL3Nhbml0aXplSW50ZXJuYWxGaWVsZHMnXG5pbXBvcnQgeyB3aXRoU2Vzc2lvbiB9IGZyb20gJy4vd2l0aFNlc3Npb24nXG5cbmV4cG9ydCBjb25zdCBxdWVyeURyYWZ0czogUXVlcnlEcmFmdHMgPSBhc3luYyBmdW5jdGlvbiBxdWVyeURyYWZ0cyhcbiAgdGhpczogTW9uZ29vc2VBZGFwdGVyLFxuICB7IGNvbGxlY3Rpb24sIGxpbWl0LCBsb2NhbGUsIHBhZ2UsIHBhZ2luYXRpb24sIHJlcSA9IHt9IGFzIFBheWxvYWRSZXF1ZXN0LCBzb3J0OiBzb3J0QXJnLCB3aGVyZSB9LFxuKSB7XG4gIGNvbnN0IFZlcnNpb25Nb2RlbCA9IHRoaXMudmVyc2lvbnNbY29sbGVjdGlvbl1cbiAgY29uc3QgY29sbGVjdGlvbkNvbmZpZyA9IHRoaXMucGF5bG9hZC5jb2xsZWN0aW9uc1tjb2xsZWN0aW9uXS5jb25maWdcbiAgY29uc3Qgb3B0aW9ucyA9IHdpdGhTZXNzaW9uKHRoaXMsIHJlcS50cmFuc2FjdGlvbklEKVxuXG4gIGxldCBoYXNOZWFyQ29uc3RyYWludFxuICBsZXQgc29ydFxuXG4gIGlmICh3aGVyZSkge1xuICAgIGNvbnN0IGNvbnN0cmFpbnRzID0gZmxhdHRlbldoZXJlVG9PcGVyYXRvcnMod2hlcmUpXG4gICAgaGFzTmVhckNvbnN0cmFpbnQgPSBjb25zdHJhaW50cy5zb21lKChwcm9wKSA9PiBPYmplY3Qua2V5cyhwcm9wKS5zb21lKChrZXkpID0+IGtleSA9PT0gJ25lYXInKSlcbiAgfVxuXG4gIGlmICghaGFzTmVhckNvbnN0cmFpbnQpIHtcbiAgICBzb3J0ID0gYnVpbGRTb3J0UGFyYW0oe1xuICAgICAgY29uZmlnOiB0aGlzLnBheWxvYWQuY29uZmlnLFxuICAgICAgZmllbGRzOiBjb2xsZWN0aW9uQ29uZmlnLmZpZWxkcyxcbiAgICAgIGxvY2FsZSxcbiAgICAgIHNvcnQ6IHNvcnRBcmcgfHwgY29sbGVjdGlvbkNvbmZpZy5kZWZhdWx0U29ydCxcbiAgICAgIHRpbWVzdGFtcHM6IHRydWUsXG4gICAgfSlcbiAgfVxuXG4gIGNvbnN0IGNvbWJpbmVkV2hlcmUgPSBjb21iaW5lUXVlcmllcyh7IGxhdGVzdDogeyBlcXVhbHM6IHRydWUgfSB9LCB3aGVyZSlcblxuICBjb25zdCB2ZXJzaW9uUXVlcnkgPSBhd2FpdCBWZXJzaW9uTW9kZWwuYnVpbGRRdWVyeSh7XG4gICAgbG9jYWxlLFxuICAgIHBheWxvYWQ6IHRoaXMucGF5bG9hZCxcbiAgICB3aGVyZTogY29tYmluZWRXaGVyZSxcbiAgfSlcblxuICBjb25zdCBwYWdpbmF0aW9uT3B0aW9uczogUGFnaW5hdGVPcHRpb25zID0ge1xuICAgIGZvcmNlQ291bnRGbjogaGFzTmVhckNvbnN0cmFpbnQsXG4gICAgbGVhbjogdHJ1ZSxcbiAgICBsZWFuV2l0aElkOiB0cnVlLFxuICAgIG9wdGlvbnMsXG4gICAgcGFnZSxcbiAgICBwYWdpbmF0aW9uLFxuICAgIHNvcnQsXG4gICAgdXNlRXN0aW1hdGVkQ291bnQ6IGhhc05lYXJDb25zdHJhaW50LFxuICB9XG5cbiAgaWYgKGxpbWl0ID4gMCkge1xuICAgIHBhZ2luYXRpb25PcHRpb25zLmxpbWl0ID0gbGltaXRcbiAgICAvLyBsaW1pdCBtdXN0IGFsc28gYmUgc2V0IGhlcmUsIGl0J3MgaWdub3JlZCB3aGVuIHBhZ2luYXRpb24gaXMgZmFsc2VcbiAgICBwYWdpbmF0aW9uT3B0aW9ucy5vcHRpb25zLmxpbWl0ID0gbGltaXRcbiAgfVxuXG4gIGNvbnN0IHJlc3VsdCA9IGF3YWl0IFZlcnNpb25Nb2RlbC5wYWdpbmF0ZSh2ZXJzaW9uUXVlcnksIHBhZ2luYXRpb25PcHRpb25zKVxuICBjb25zdCBkb2NzID0gSlNPTi5wYXJzZShKU09OLnN0cmluZ2lmeShyZXN1bHQuZG9jcykpXG5cbiAgcmV0dXJuIHtcbiAgICAuLi5yZXN1bHQsXG4gICAgZG9jczogZG9jcy5tYXAoKGRvYykgPT4ge1xuICAgICAgLy8gZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIG5vLXBhcmFtLXJlYXNzaWduXG4gICAgICBkb2MgPSB7XG4gICAgICAgIF9pZDogZG9jLnBhcmVudCxcbiAgICAgICAgaWQ6IGRvYy5wYXJlbnQsXG4gICAgICAgIC4uLmRvYy52ZXJzaW9uLFxuICAgICAgICBjcmVhdGVkQXQ6IGRvYy5jcmVhdGVkQXQsXG4gICAgICAgIHVwZGF0ZWRBdDogZG9jLnVwZGF0ZWRBdCxcbiAgICAgIH1cblxuICAgICAgcmV0dXJuIHNhbml0aXplSW50ZXJuYWxGaWVsZHMoZG9jKVxuICAgIH0pLFxuICB9XG59XG4iXSwibmFtZXMiOlsicXVlcnlEcmFmdHMiLCJjb2xsZWN0aW9uIiwibGltaXQiLCJsb2NhbGUiLCJwYWdlIiwicGFnaW5hdGlvbiIsInJlcSIsInNvcnQiLCJzb3J0QXJnIiwid2hlcmUiLCJWZXJzaW9uTW9kZWwiLCJ2ZXJzaW9ucyIsImNvbGxlY3Rpb25Db25maWciLCJwYXlsb2FkIiwiY29sbGVjdGlvbnMiLCJjb25maWciLCJvcHRpb25zIiwid2l0aFNlc3Npb24iLCJ0cmFuc2FjdGlvbklEIiwiaGFzTmVhckNvbnN0cmFpbnQiLCJjb25zdHJhaW50cyIsImZsYXR0ZW5XaGVyZVRvT3BlcmF0b3JzIiwic29tZSIsInByb3AiLCJPYmplY3QiLCJrZXlzIiwia2V5IiwiYnVpbGRTb3J0UGFyYW0iLCJmaWVsZHMiLCJkZWZhdWx0U29ydCIsInRpbWVzdGFtcHMiLCJjb21iaW5lZFdoZXJlIiwiY29tYmluZVF1ZXJpZXMiLCJsYXRlc3QiLCJlcXVhbHMiLCJ2ZXJzaW9uUXVlcnkiLCJidWlsZFF1ZXJ5IiwicGFnaW5hdGlvbk9wdGlvbnMiLCJmb3JjZUNvdW50Rm4iLCJsZWFuIiwibGVhbldpdGhJZCIsInVzZUVzdGltYXRlZENvdW50IiwicmVzdWx0IiwicGFnaW5hdGUiLCJkb2NzIiwiSlNPTiIsInBhcnNlIiwic3RyaW5naWZ5IiwibWFwIiwiZG9jIiwiX2lkIiwicGFyZW50IiwiaWQiLCJ2ZXJzaW9uIiwiY3JlYXRlZEF0IiwidXBkYXRlZEF0Iiwic2FuaXRpemVJbnRlcm5hbEZpZWxkcyJdLCJtYXBwaW5ncyI6Ijs7OzsrQkFZYUE7OztlQUFBQTs7OzBCQVIyQztnQ0FJekI7K0VBQ0k7NkJBQ1A7Ozs7OztBQUVyQixNQUFNQSxjQUEyQixlQUFlQSxZQUVyRCxFQUFFQyxVQUFVLEVBQUVDLEtBQUssRUFBRUMsTUFBTSxFQUFFQyxJQUFJLEVBQUVDLFVBQVUsRUFBRUMsTUFBTSxDQUFDLENBQW1CLEVBQUVDLE1BQU1DLE9BQU8sRUFBRUMsS0FBSyxFQUFFO0lBRWpHLE1BQU1DLGVBQWUsSUFBSSxDQUFDQyxRQUFRLENBQUNWLFdBQVc7SUFDOUMsTUFBTVcsbUJBQW1CLElBQUksQ0FBQ0MsT0FBTyxDQUFDQyxXQUFXLENBQUNiLFdBQVcsQ0FBQ2MsTUFBTTtJQUNwRSxNQUFNQyxVQUFVQyxJQUFBQSx3QkFBVyxFQUFDLElBQUksRUFBRVgsSUFBSVksYUFBYTtJQUVuRCxJQUFJQztJQUNKLElBQUlaO0lBRUosSUFBSUUsT0FBTztRQUNULE1BQU1XLGNBQWNDLElBQUFBLGlDQUF1QixFQUFDWjtRQUM1Q1Usb0JBQW9CQyxZQUFZRSxJQUFJLENBQUMsQ0FBQ0MsT0FBU0MsT0FBT0MsSUFBSSxDQUFDRixNQUFNRCxJQUFJLENBQUMsQ0FBQ0ksTUFBUUEsUUFBUTtJQUN6RjtJQUVBLElBQUksQ0FBQ1AsbUJBQW1CO1FBQ3RCWixPQUFPb0IsSUFBQUEsOEJBQWMsRUFBQztZQUNwQlosUUFBUSxJQUFJLENBQUNGLE9BQU8sQ0FBQ0UsTUFBTTtZQUMzQmEsUUFBUWhCLGlCQUFpQmdCLE1BQU07WUFDL0J6QjtZQUNBSSxNQUFNQyxXQUFXSSxpQkFBaUJpQixXQUFXO1lBQzdDQyxZQUFZO1FBQ2Q7SUFDRjtJQUVBLE1BQU1DLGdCQUFnQkMsSUFBQUEsd0JBQWMsRUFBQztRQUFFQyxRQUFRO1lBQUVDLFFBQVE7UUFBSztJQUFFLEdBQUd6QjtJQUVuRSxNQUFNMEIsZUFBZSxNQUFNekIsYUFBYTBCLFVBQVUsQ0FBQztRQUNqRGpDO1FBQ0FVLFNBQVMsSUFBSSxDQUFDQSxPQUFPO1FBQ3JCSixPQUFPc0I7SUFDVDtJQUVBLE1BQU1NLG9CQUFxQztRQUN6Q0MsY0FBY25CO1FBQ2RvQixNQUFNO1FBQ05DLFlBQVk7UUFDWnhCO1FBQ0FaO1FBQ0FDO1FBQ0FFO1FBQ0FrQyxtQkFBbUJ0QjtJQUNyQjtJQUVBLElBQUlqQixRQUFRLEdBQUc7UUFDYm1DLGtCQUFrQm5DLEtBQUssR0FBR0E7UUFDMUIscUVBQXFFO1FBQ3JFbUMsa0JBQWtCckIsT0FBTyxDQUFDZCxLQUFLLEdBQUdBO0lBQ3BDO0lBRUEsTUFBTXdDLFNBQVMsTUFBTWhDLGFBQWFpQyxRQUFRLENBQUNSLGNBQWNFO0lBQ3pELE1BQU1PLE9BQU9DLEtBQUtDLEtBQUssQ0FBQ0QsS0FBS0UsU0FBUyxDQUFDTCxPQUFPRSxJQUFJO0lBRWxELE9BQU87UUFDTCxHQUFHRixNQUFNO1FBQ1RFLE1BQU1BLEtBQUtJLEdBQUcsQ0FBQyxDQUFDQztZQUNkLDZDQUE2QztZQUM3Q0EsTUFBTTtnQkFDSkMsS0FBS0QsSUFBSUUsTUFBTTtnQkFDZkMsSUFBSUgsSUFBSUUsTUFBTTtnQkFDZCxHQUFHRixJQUFJSSxPQUFPO2dCQUNkQyxXQUFXTCxJQUFJSyxTQUFTO2dCQUN4QkMsV0FBV04sSUFBSU0sU0FBUztZQUMxQjtZQUVBLE9BQU9DLElBQUFBLCtCQUFzQixFQUFDUDtRQUNoQztJQUNGO0FBQ0YifQ==

package/dist/testCredentials.d.ts

@@ -0,0 +1,8 @@
+export declare const email = "test@test.com";
+export declare const password = "test123";
+export declare const connection: {
+    name: string;
+    port: number;
+    url: string;
+};
+//# sourceMappingURL=testCredentials.d.ts.map

package/dist/testCredentials.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"testCredentials.d.ts","sourceRoot":"","sources":["../src/testCredentials.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,KAAK,kBAAkB,CAAA;AACpC,eAAO,MAAM,QAAQ,YAAY,CAAA;AACjC,eAAO,MAAM,UAAU;;;;CAItB,CAAA"}