payload 1.0.9 → 1.0.10

package/dist/mongoose/buildQuery.js

@@ -1,288 +1,288 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-/* eslint-disable no-await-in-loop */
-/* eslint-disable no-restricted-syntax */
-const deepmerge_1 = __importDefault(require("deepmerge"));
-const mongoose_1 = __importDefault(require("mongoose"));
-const combineMerge_1 = require("../utilities/combineMerge");
-const getSchemaTypeOptions_1 = require("./getSchemaTypeOptions");
-const operatorMap_1 = require("./operatorMap");
-const sanitizeFormattedValue_1 = require("./sanitizeFormattedValue");
-const validOperators = ['like', 'contains', 'in', 'all', 'not_in', 'greater_than_equal', 'greater_than', 'less_than_equal', 'less_than', 'not_equals', 'equals', 'exists', 'near'];
-const subQueryOptions = {
-    limit: 50,
-    lean: true,
-};
-class ParamParser {
-    constructor(model, rawParams, locale) {
-        this.parse = this.parse.bind(this);
-        this.model = model;
-        this.rawParams = rawParams;
-        this.locale = locale;
-        this.query = {
-            searchParams: {},
-            sort: false,
-        };
-    }
-    // Entry point to the ParamParser class
-    async parse() {
-        if (typeof this.rawParams === 'object') {
-            for (const key of Object.keys(this.rawParams)) {
-                if (key === 'where') {
-                    this.query.searchParams = await this.parsePathOrRelation(this.rawParams.where);
-                }
-                else if (key === 'sort') {
-                    this.query.sort = this.rawParams[key];
-                }
-            }
-            return this.query;
-        }
-        return {};
-    }
-    async parsePathOrRelation(object) {
-        let result = {};
-        // We need to determine if the whereKey is an AND, OR, or a schema path
-        for (const relationOrPath of Object.keys(object)) {
-            if (relationOrPath.toLowerCase() === 'and') {
-                const andConditions = object[relationOrPath];
-                const builtAndConditions = await this.buildAndOrConditions(andConditions);
-                if (builtAndConditions.length > 0)
-                    result.$and = builtAndConditions;
-            }
-            else if (relationOrPath.toLowerCase() === 'or' && Array.isArray(object[relationOrPath])) {
-                const orConditions = object[relationOrPath];
-                const builtOrConditions = await this.buildAndOrConditions(orConditions);
-                if (builtOrConditions.length > 0)
-                    result.$or = builtOrConditions;
-            }
-            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 = object[relationOrPath];
-                if (typeof pathOperators === 'object') {
-                    for (const operator of Object.keys(pathOperators)) {
-                        if (validOperators.includes(operator)) {
-                            const searchParam = await this.buildSearchParam(this.model.schema, relationOrPath, pathOperators[operator], operator);
-                            if ((searchParam === null || searchParam === void 0 ? void 0 : searchParam.value) && (searchParam === null || searchParam === void 0 ? void 0 : searchParam.path)) {
-                                result = {
-                                    ...result,
-                                    [searchParam.path]: searchParam.value,
-                                };
-                            }
-                            else if (typeof (searchParam === null || searchParam === void 0 ? void 0 : searchParam.value) === 'object') {
-                                result = (0, deepmerge_1.default)(result, searchParam.value, { arrayMerge: combineMerge_1.combineMerge });
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        return result;
-    }
-    async buildAndOrConditions(conditions) {
-        const completedConditions = [];
-        // Loop over all AND / OR operations and add them to the AND / OR query param
-        // Operations should come through as an array
-        for (const condition of conditions) {
-            // If the operation is properly formatted as an object
-            if (typeof condition === 'object') {
-                const result = await this.parsePathOrRelation(condition);
-                completedConditions.push(result);
-            }
-        }
-        return completedConditions;
-    }
-    // Build up an array of auto-localized paths to search on
-    // Multiple paths may be possible if searching on properties of relationship fields
-    getLocalizedPaths(Model, incomingPath, operator) {
-        const { schema } = Model;
-        const pathSegments = incomingPath.split('.');
-        let paths = [
-            {
-                path: '',
-                complete: false,
-                Model,
-            },
-        ];
-        pathSegments.forEach((segment, i) => {
-            const lastIncompletePath = paths.find(({ complete }) => !complete);
-            const { path } = lastIncompletePath;
-            const currentPath = path ? `${path}.${segment}` : segment;
-            const currentSchemaType = schema.path(currentPath);
-            const currentSchemaPathType = schema.pathType(currentPath);
-            if (currentSchemaPathType === 'nested') {
-                lastIncompletePath.path = currentPath;
-                return;
-            }
-            const upcomingSegment = pathSegments[i + 1];
-            if (currentSchemaType && currentSchemaPathType !== 'adhocOrUndefined') {
-                const currentSchemaTypeOptions = (0, getSchemaTypeOptions_1.getSchemaTypeOptions)(currentSchemaType);
-                if (currentSchemaTypeOptions.localized) {
-                    const localePath = `${currentPath}.${this.locale}`;
-                    const localizedSchemaType = schema.path(localePath);
-                    if (localizedSchemaType || operator === 'near') {
-                        lastIncompletePath.path = localePath;
-                        return;
-                    }
-                    const upcomingPathWithLocale = `${currentPath}.${this.locale}.${upcomingSegment}`;
-                    const upcomingSchemaTypeWithLocale = schema.path(upcomingPathWithLocale);
-                    if (upcomingSchemaTypeWithLocale) {
-                        lastIncompletePath.path = upcomingPathWithLocale;
-                        return;
-                    }
-                }
-                lastIncompletePath.path = currentPath;
-                return;
-            }
-            const priorSchemaType = schema.path(path);
-            if (priorSchemaType) {
-                const priorSchemaTypeOptions = (0, getSchemaTypeOptions_1.getSchemaTypeOptions)(priorSchemaType);
-                if (typeof priorSchemaTypeOptions.ref === 'string') {
-                    const RefModel = mongoose_1.default.model(priorSchemaTypeOptions.ref);
-                    lastIncompletePath.complete = true;
-                    const remainingPath = pathSegments.slice(i).join('.');
-                    paths = [
-                        ...paths,
-                        ...this.getLocalizedPaths(RefModel, remainingPath, operator),
-                    ];
-                    return;
-                }
-            }
-            if (operator === 'near') {
-                lastIncompletePath.path = currentPath;
-            }
-        });
-        return paths;
-    }
-    // Convert the Payload key / value / operator into a MongoDB query
-    async buildSearchParam(schema, incomingPath, val, operator) {
-        // Replace GraphQL nested field double underscore formatting
-        let sanitizedPath = incomingPath.replace(/__/gi, '.');
-        if (sanitizedPath === 'id')
-            sanitizedPath = '_id';
-        const collectionPaths = this.getLocalizedPaths(this.model, sanitizedPath, operator);
-        const [{ path }] = collectionPaths;
-        if (path) {
-            const schemaType = schema.path(path);
-            const schemaOptions = (0, getSchemaTypeOptions_1.getSchemaTypeOptions)(schemaType);
-            const formattedValue = (0, sanitizeFormattedValue_1.sanitizeQueryValue)(schemaType, path, operator, val);
-            // If there are multiple collections to search through,
-            // Recursively build up a list of query constraints
-            if (collectionPaths.length > 1) {
-                // Remove top collection and reverse array
-                // to work backwards from top
-                const collectionPathsToSearch = collectionPaths.slice(1).reverse();
-                const initialRelationshipQuery = {
-                    value: {},
-                };
-                const relationshipQuery = await collectionPathsToSearch.reduce(async (priorQuery, { Model: SubModel, path: subPath }, i) => {
-                    const priorQueryResult = await priorQuery;
-                    // On the "deepest" collection,
-                    // Search on the value passed through the query
-                    if (i === 0) {
-                        const subQuery = await SubModel.buildQuery({
-                            where: {
-                                [subPath]: {
-                                    [operator]: val,
-                                },
-                            },
-                        }, this.locale);
-                        const result = await SubModel.find(subQuery, subQueryOptions);
-                        const $in = result.map((doc) => doc._id.toString());
-                        if (collectionPathsToSearch.length === 1)
-                            return { path, value: { $in } };
-                        return {
-                            value: { _id: { $in } },
-                        };
-                    }
-                    const subQuery = priorQueryResult.value;
-                    const result = await SubModel.find(subQuery, subQueryOptions);
-                    const $in = result.map((doc) => doc._id.toString());
-                    // If it is the last recursion
-                    // then pass through the search param
-                    if (i + 1 === collectionPathsToSearch.length) {
-                        return { path, value: { $in } };
-                    }
-                    return {
-                        value: {
-                            _id: { $in },
-                        },
-                    };
-                }, Promise.resolve(initialRelationshipQuery));
-                return relationshipQuery;
-            }
-            if (operator && validOperators.includes(operator)) {
-                const operatorKey = operatorMap_1.operatorMap[operator];
-                let overrideQuery = false;
-                let query;
-                // If there is a ref, this is a relationship or upload field
-                // IDs can be either string, number, or ObjectID
-                // So we need to build an `or` query for all these types
-                if (schemaOptions && (schemaOptions.ref || schemaOptions.refPath)) {
-                    overrideQuery = true;
-                    query = {
-                        $or: [
-                            {
-                                [path]: {
-                                    [operatorKey]: formattedValue,
-                                },
-                            },
-                        ],
-                    };
-                    if (typeof formattedValue === 'number' || (typeof formattedValue === 'string' && mongoose_1.default.Types.ObjectId.isValid(formattedValue))) {
-                        query.$or.push({
-                            [path]: {
-                                [operatorKey]: formattedValue.toString(),
-                            },
-                        });
-                    }
-                    if (typeof formattedValue === 'string') {
-                        if (!Number.isNaN(formattedValue)) {
-                            query.$or.push({
-                                [path]: {
-                                    [operatorKey]: parseFloat(formattedValue),
-                                },
-                            });
-                        }
-                    }
-                }
-                // If forced query
-                if (overrideQuery) {
-                    return {
-                        value: query,
-                    };
-                }
-                // Some operators like 'near' need to define a full query
-                // so if there is no operator key, just return the value
-                if (!operatorKey) {
-                    return {
-                        path,
-                        value: formattedValue,
-                    };
-                }
-                return {
-                    path,
-                    value: { [operatorKey]: formattedValue },
-                };
-            }
-        }
-        return undefined;
-    }
-}
-// This plugin asynchronously builds a list of Mongoose query constraints
-// which can then be used in subsequent Mongoose queries.
-function buildQueryPlugin(schema) {
-    const modifiedSchema = schema;
-    async function buildQuery(rawParams, locale) {
-        const paramParser = new ParamParser(this, rawParams, locale);
-        const params = await paramParser.parse();
-        return params.searchParams;
-    }
-    modifiedSchema.statics.buildQuery = buildQuery;
-}
-exports.default = buildQueryPlugin;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable no-await-in-loop */
+/* eslint-disable no-restricted-syntax */
+const deepmerge_1 = __importDefault(require("deepmerge"));
+const mongoose_1 = __importDefault(require("mongoose"));
+const combineMerge_1 = require("../utilities/combineMerge");
+const getSchemaTypeOptions_1 = require("./getSchemaTypeOptions");
+const operatorMap_1 = require("./operatorMap");
+const sanitizeFormattedValue_1 = require("./sanitizeFormattedValue");
+const validOperators = ['like', 'contains', 'in', 'all', 'not_in', 'greater_than_equal', 'greater_than', 'less_than_equal', 'less_than', 'not_equals', 'equals', 'exists', 'near'];
+const subQueryOptions = {
+    limit: 50,
+    lean: true,
+};
+class ParamParser {
+    constructor(model, rawParams, locale) {
+        this.parse = this.parse.bind(this);
+        this.model = model;
+        this.rawParams = rawParams;
+        this.locale = locale;
+        this.query = {
+            searchParams: {},
+            sort: false,
+        };
+    }
+    // Entry point to the ParamParser class
+    async parse() {
+        if (typeof this.rawParams === 'object') {
+            for (const key of Object.keys(this.rawParams)) {
+                if (key === 'where') {
+                    this.query.searchParams = await this.parsePathOrRelation(this.rawParams.where);
+                }
+                else if (key === 'sort') {
+                    this.query.sort = this.rawParams[key];
+                }
+            }
+            return this.query;
+        }
+        return {};
+    }
+    async parsePathOrRelation(object) {
+        let result = {};
+        // We need to determine if the whereKey is an AND, OR, or a schema path
+        for (const relationOrPath of Object.keys(object)) {
+            if (relationOrPath.toLowerCase() === 'and') {
+                const andConditions = object[relationOrPath];
+                const builtAndConditions = await this.buildAndOrConditions(andConditions);
+                if (builtAndConditions.length > 0)
+                    result.$and = builtAndConditions;
+            }
+            else if (relationOrPath.toLowerCase() === 'or' && Array.isArray(object[relationOrPath])) {
+                const orConditions = object[relationOrPath];
+                const builtOrConditions = await this.buildAndOrConditions(orConditions);
+                if (builtOrConditions.length > 0)
+                    result.$or = builtOrConditions;
+            }
+            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 = object[relationOrPath];
+                if (typeof pathOperators === 'object') {
+                    for (const operator of Object.keys(pathOperators)) {
+                        if (validOperators.includes(operator)) {
+                            const searchParam = await this.buildSearchParam(this.model.schema, relationOrPath, pathOperators[operator], operator);
+                            if ((searchParam === null || searchParam === void 0 ? void 0 : searchParam.value) && (searchParam === null || searchParam === void 0 ? void 0 : searchParam.path)) {
+                                result = {
+                                    ...result,
+                                    [searchParam.path]: searchParam.value,
+                                };
+                            }
+                            else if (typeof (searchParam === null || searchParam === void 0 ? void 0 : searchParam.value) === 'object') {
+                                result = (0, deepmerge_1.default)(result, searchParam.value, { arrayMerge: combineMerge_1.combineMerge });
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return result;
+    }
+    async buildAndOrConditions(conditions) {
+        const completedConditions = [];
+        // Loop over all AND / OR operations and add them to the AND / OR query param
+        // Operations should come through as an array
+        for (const condition of conditions) {
+            // If the operation is properly formatted as an object
+            if (typeof condition === 'object') {
+                const result = await this.parsePathOrRelation(condition);
+                completedConditions.push(result);
+            }
+        }
+        return completedConditions;
+    }
+    // Build up an array of auto-localized paths to search on
+    // Multiple paths may be possible if searching on properties of relationship fields
+    getLocalizedPaths(Model, incomingPath, operator) {
+        const { schema } = Model;
+        const pathSegments = incomingPath.split('.');
+        let paths = [
+            {
+                path: '',
+                complete: false,
+                Model,
+            },
+        ];
+        pathSegments.forEach((segment, i) => {
+            const lastIncompletePath = paths.find(({ complete }) => !complete);
+            const { path } = lastIncompletePath;
+            const currentPath = path ? `${path}.${segment}` : segment;
+            const currentSchemaType = schema.path(currentPath);
+            const currentSchemaPathType = schema.pathType(currentPath);
+            if (currentSchemaPathType === 'nested') {
+                lastIncompletePath.path = currentPath;
+                return;
+            }
+            const upcomingSegment = pathSegments[i + 1];
+            if (currentSchemaType && currentSchemaPathType !== 'adhocOrUndefined') {
+                const currentSchemaTypeOptions = (0, getSchemaTypeOptions_1.getSchemaTypeOptions)(currentSchemaType);
+                if (currentSchemaTypeOptions.localized) {
+                    const localePath = `${currentPath}.${this.locale}`;
+                    const localizedSchemaType = schema.path(localePath);
+                    if (localizedSchemaType || operator === 'near') {
+                        lastIncompletePath.path = localePath;
+                        return;
+                    }
+                    const upcomingPathWithLocale = `${currentPath}.${this.locale}.${upcomingSegment}`;
+                    const upcomingSchemaTypeWithLocale = schema.path(upcomingPathWithLocale);
+                    if (upcomingSchemaTypeWithLocale) {
+                        lastIncompletePath.path = upcomingPathWithLocale;
+                        return;
+                    }
+                }
+                lastIncompletePath.path = currentPath;
+                return;
+            }
+            const priorSchemaType = schema.path(path);
+            if (priorSchemaType) {
+                const priorSchemaTypeOptions = (0, getSchemaTypeOptions_1.getSchemaTypeOptions)(priorSchemaType);
+                if (typeof priorSchemaTypeOptions.ref === 'string') {
+                    const RefModel = mongoose_1.default.model(priorSchemaTypeOptions.ref);
+                    lastIncompletePath.complete = true;
+                    const remainingPath = pathSegments.slice(i).join('.');
+                    paths = [
+                        ...paths,
+                        ...this.getLocalizedPaths(RefModel, remainingPath, operator),
+                    ];
+                    return;
+                }
+            }
+            if (operator === 'near') {
+                lastIncompletePath.path = currentPath;
+            }
+        });
+        return paths;
+    }
+    // Convert the Payload key / value / operator into a MongoDB query
+    async buildSearchParam(schema, incomingPath, val, operator) {
+        // Replace GraphQL nested field double underscore formatting
+        let sanitizedPath = incomingPath.replace(/__/gi, '.');
+        if (sanitizedPath === 'id')
+            sanitizedPath = '_id';
+        const collectionPaths = this.getLocalizedPaths(this.model, sanitizedPath, operator);
+        const [{ path }] = collectionPaths;
+        if (path) {
+            const schemaType = schema.path(path);
+            const schemaOptions = (0, getSchemaTypeOptions_1.getSchemaTypeOptions)(schemaType);
+            const formattedValue = (0, sanitizeFormattedValue_1.sanitizeQueryValue)(schemaType, path, operator, val);
+            // If there are multiple collections to search through,
+            // Recursively build up a list of query constraints
+            if (collectionPaths.length > 1) {
+                // Remove top collection and reverse array
+                // to work backwards from top
+                const collectionPathsToSearch = collectionPaths.slice(1).reverse();
+                const initialRelationshipQuery = {
+                    value: {},
+                };
+                const relationshipQuery = await collectionPathsToSearch.reduce(async (priorQuery, { Model: SubModel, path: subPath }, i) => {
+                    const priorQueryResult = await priorQuery;
+                    // On the "deepest" collection,
+                    // Search on the value passed through the query
+                    if (i === 0) {
+                        const subQuery = await SubModel.buildQuery({
+                            where: {
+                                [subPath]: {
+                                    [operator]: val,
+                                },
+                            },
+                        }, this.locale);
+                        const result = await SubModel.find(subQuery, subQueryOptions);
+                        const $in = result.map((doc) => doc._id.toString());
+                        if (collectionPathsToSearch.length === 1)
+                            return { path, value: { $in } };
+                        return {
+                            value: { _id: { $in } },
+                        };
+                    }
+                    const subQuery = priorQueryResult.value;
+                    const result = await SubModel.find(subQuery, subQueryOptions);
+                    const $in = result.map((doc) => doc._id.toString());
+                    // If it is the last recursion
+                    // then pass through the search param
+                    if (i + 1 === collectionPathsToSearch.length) {
+                        return { path, value: { $in } };
+                    }
+                    return {
+                        value: {
+                            _id: { $in },
+                        },
+                    };
+                }, Promise.resolve(initialRelationshipQuery));
+                return relationshipQuery;
+            }
+            if (operator && validOperators.includes(operator)) {
+                const operatorKey = operatorMap_1.operatorMap[operator];
+                let overrideQuery = false;
+                let query;
+                // If there is a ref, this is a relationship or upload field
+                // IDs can be either string, number, or ObjectID
+                // So we need to build an `or` query for all these types
+                if (schemaOptions && (schemaOptions.ref || schemaOptions.refPath)) {
+                    overrideQuery = true;
+                    query = {
+                        $or: [
+                            {
+                                [path]: {
+                                    [operatorKey]: formattedValue,
+                                },
+                            },
+                        ],
+                    };
+                    if (typeof formattedValue === 'number' || (typeof formattedValue === 'string' && mongoose_1.default.Types.ObjectId.isValid(formattedValue))) {
+                        query.$or.push({
+                            [path]: {
+                                [operatorKey]: formattedValue.toString(),
+                            },
+                        });
+                    }
+                    if (typeof formattedValue === 'string') {
+                        if (!Number.isNaN(formattedValue)) {
+                            query.$or.push({
+                                [path]: {
+                                    [operatorKey]: parseFloat(formattedValue),
+                                },
+                            });
+                        }
+                    }
+                }
+                // If forced query
+                if (overrideQuery) {
+                    return {
+                        value: query,
+                    };
+                }
+                // Some operators like 'near' need to define a full query
+                // so if there is no operator key, just return the value
+                if (!operatorKey) {
+                    return {
+                        path,
+                        value: formattedValue,
+                    };
+                }
+                return {
+                    path,
+                    value: { [operatorKey]: formattedValue },
+                };
+            }
+        }
+        return undefined;
+    }
+}
+// This plugin asynchronously builds a list of Mongoose query constraints
+// which can then be used in subsequent Mongoose queries.
+function buildQueryPlugin(schema) {
+    const modifiedSchema = schema;
+    async function buildQuery(rawParams, locale) {
+        const paramParser = new ParamParser(this, rawParams, locale);
+        const params = await paramParser.parse();
+        return params.searchParams;
+    }
+    modifiedSchema.statics.buildQuery = buildQuery;
+}
+exports.default = buildQueryPlugin;
 //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"buildQuery.js","sourceRoot":"","sources":["../../src/mongoose/buildQuery.ts"],"names":[],"mappings":"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"}

package/dist/mongoose/buildSchema.d.ts

@@ -1,11 +1,11 @@
-import { Schema, SchemaOptions } from 'mongoose';
-import { SanitizedConfig } from '../config/types';
-import { Field } from '../fields/config/types';
-export declare type BuildSchemaOptions = {
-    options?: SchemaOptions;
-    allowIDField?: boolean;
-    disableUnique?: boolean;
-    global?: boolean;
-};
-declare const buildSchema: (config: SanitizedConfig, configFields: Field[], buildSchemaOptions?: BuildSchemaOptions) => Schema;
-export default buildSchema;
+import { Schema, SchemaOptions } from 'mongoose';
+import { SanitizedConfig } from '../config/types';
+import { Field } from '../fields/config/types';
+export declare type BuildSchemaOptions = {
+    options?: SchemaOptions;
+    allowIDField?: boolean;
+    disableUnique?: boolean;
+    global?: boolean;
+};
+declare const buildSchema: (config: SanitizedConfig, configFields: Field[], buildSchemaOptions?: BuildSchemaOptions) => Schema;
+export default buildSchema;