@payloadcms/db-mongodb 1.0.0-beta.0

package/dist/models/buildGlobalModel.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "buildGlobalModel", {
+    enumerable: true,
+    get: function() {
+        return buildGlobalModel;
+    }
+});
+const _mongoose = /*#__PURE__*/ _interop_require_default(require("mongoose"));
+const _buildQuery = /*#__PURE__*/ _interop_require_default(require("../queries/buildQuery"));
+const _buildSchema = /*#__PURE__*/ _interop_require_default(require("./buildSchema"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const buildGlobalModel = (config)=>{
+    if (config.globals && config.globals.length > 0) {
+        const globalsSchema = new _mongoose.default.Schema({}, {
+            discriminatorKey: 'globalType',
+            minimize: false,
+            timestamps: true
+        });
+        globalsSchema.plugin((0, _buildQuery.default)());
+        const Globals = _mongoose.default.model('globals', globalsSchema, 'globals');
+        Object.values(config.globals).forEach((globalConfig)=>{
+            const globalSchema = (0, _buildSchema.default)(config, globalConfig.fields, {
+                options: {
+                    minimize: false
+                }
+            });
+            Globals.discriminator(globalConfig.slug, globalSchema);
+        });
+        return Globals;
+    }
+    return null;
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/models/buildSchema.d.ts

@@ -0,0 +1,14 @@
+import type { SchemaOptions } from 'mongoose';
+import type { SanitizedConfig } from 'payload/config';
+import type { Field } from 'payload/types';
+import { Schema } from 'mongoose';
+export type BuildSchemaOptions = {
+    allowIDField?: boolean;
+    disableUnique?: boolean;
+    draftsEnabled?: boolean;
+    indexSortableFields?: boolean;
+    options?: SchemaOptions;
+};
+declare const buildSchema: (config: SanitizedConfig, configFields: Field[], buildSchemaOptions?: BuildSchemaOptions) => Schema;
+export default buildSchema;
+//# sourceMappingURL=buildSchema.d.ts.map

package/dist/models/buildSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildSchema.d.ts","sourceRoot":"","sources":["../../src/models/buildSchema.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAgB,aAAa,EAAqB,MAAM,UAAU,CAAA;AAC9E,OAAO,KAAK,EAAE,eAAe,EAA+B,MAAM,gBAAgB,CAAA;AAClF,OAAO,KAAK,EASV,KAAK,EAcN,MAAM,eAAe,CAAA;AAGtB,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AAQjC,MAAM,MAAM,kBAAkB,GAAG;IAC/B,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,mBAAmB,CAAC,EAAE,OAAO,CAAA;IAC7B,OAAO,CAAC,EAAE,aAAa,CAAA;CACxB,CAAA;AAkDD,QAAA,MAAM,WAAW,WACP,eAAe,gBACT,KAAK,EAAE,uBACD,kBAAkB,KACrC,MA+BF,CAAA;AAscD,eAAe,WAAW,CAAA"}

package/dist/models/buildSchema.js

@@ -0,0 +1,438 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */ /* eslint-disable class-methods-use-this */ /* eslint-disable @typescript-eslint/no-use-before-define */ /* eslint-disable no-use-before-define */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _mongoose = require("mongoose");
+const _types = require("payload/types");
+const formatBaseSchema = (field, buildSchemaOptions)=>{
+    const { disableUnique, draftsEnabled, indexSortableFields } = buildSchemaOptions;
+    const schema = {
+        index: field.index || !disableUnique && field.unique || indexSortableFields || false,
+        required: false,
+        unique: !disableUnique && field.unique || false
+    };
+    if (schema.unique && (field.localized || draftsEnabled)) {
+        schema.sparse = true;
+    }
+    if (field.hidden) {
+        schema.hidden = true;
+    }
+    return schema;
+};
+const localizeSchema = (entity, schema, localization)=>{
+    if ((0, _types.fieldIsLocalized)(entity) && localization && Array.isArray(localization.locales)) {
+        return {
+            localized: true,
+            type: localization.localeCodes.reduce((localeSchema, locale)=>({
+                    ...localeSchema,
+                    [locale]: schema
+                }), {
+                _id: false
+            })
+        };
+    }
+    return schema;
+};
+const buildSchema = (config, configFields, buildSchemaOptions = {})=>{
+    const { allowIDField, options } = buildSchemaOptions;
+    let fields = {};
+    let schemaFields = configFields;
+    if (!allowIDField) {
+        const idField = schemaFields.find((field)=>(0, _types.fieldAffectsData)(field) && field.name === 'id');
+        if (idField) {
+            fields = {
+                _id: idField.type === 'number' ? Number : String
+            };
+            schemaFields = schemaFields.filter((field)=>!((0, _types.fieldAffectsData)(field) && field.name === 'id'));
+        }
+    }
+    const schema = new _mongoose.Schema(fields, options);
+    schemaFields.forEach((field)=>{
+        if (!(0, _types.fieldIsPresentationalOnly)(field)) {
+            const addFieldSchema = fieldToSchemaMap[field.type];
+            if (addFieldSchema) {
+                addFieldSchema(field, schema, config, buildSchemaOptions);
+            }
+        }
+    });
+    return schema;
+};
+const fieldToSchemaMap = {
+    array: (field, schema, config, buildSchemaOptions)=>{
+        const baseSchema = {
+            ...formatBaseSchema(field, buildSchemaOptions),
+            default: undefined,
+            type: [
+                buildSchema(config, field.fields, {
+                    allowIDField: true,
+                    disableUnique: buildSchemaOptions.disableUnique,
+                    draftsEnabled: buildSchemaOptions.draftsEnabled,
+                    options: {
+                        _id: false,
+                        id: false,
+                        minimize: false
+                    }
+                })
+            ]
+        };
+        schema.add({
+            [field.name]: localizeSchema(field, baseSchema, config.localization)
+        });
+    },
+    blocks: (field, schema, config, buildSchemaOptions)=>{
+        const fieldSchema = {
+            default: undefined,
+            type: [
+                new _mongoose.Schema({}, {
+                    _id: false,
+                    discriminatorKey: 'blockType'
+                })
+            ]
+        };
+        schema.add({
+            [field.name]: localizeSchema(field, fieldSchema, config.localization)
+        });
+        field.blocks.forEach((blockItem)=>{
+            const blockSchema = new _mongoose.Schema({}, {
+                _id: false,
+                id: false
+            });
+            blockItem.fields.forEach((blockField)=>{
+                const addFieldSchema = fieldToSchemaMap[blockField.type];
+                if (addFieldSchema) {
+                    addFieldSchema(blockField, blockSchema, config, buildSchemaOptions);
+                }
+            });
+            if (field.localized && config.localization) {
+                config.localization.localeCodes.forEach((localeCode)=>{
+                    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                    // @ts-ignore Possible incorrect typing in mongoose types, this works
+                    schema.path(`${field.name}.${localeCode}`).discriminator(blockItem.slug, blockSchema);
+                });
+            } else {
+                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                // @ts-ignore Possible incorrect typing in mongoose types, this works
+                schema.path(field.name).discriminator(blockItem.slug, blockSchema);
+            }
+        });
+    },
+    checkbox: (field, schema, config, buildSchemaOptions)=>{
+        const baseSchema = {
+            ...formatBaseSchema(field, buildSchemaOptions),
+            type: Boolean
+        };
+        schema.add({
+            [field.name]: localizeSchema(field, baseSchema, config.localization)
+        });
+    },
+    code: (field, schema, config, buildSchemaOptions)=>{
+        const baseSchema = {
+            ...formatBaseSchema(field, buildSchemaOptions),
+            type: String
+        };
+        schema.add({
+            [field.name]: localizeSchema(field, baseSchema, config.localization)
+        });
+    },
+    collapsible: (field, schema, config, buildSchemaOptions)=>{
+        field.fields.forEach((subField)=>{
+            const addFieldSchema = fieldToSchemaMap[subField.type];
+            if (addFieldSchema) {
+                addFieldSchema(subField, schema, config, buildSchemaOptions);
+            }
+        });
+    },
+    date: (field, schema, config, buildSchemaOptions)=>{
+        const baseSchema = {
+            ...formatBaseSchema(field, buildSchemaOptions),
+            type: Date
+        };
+        schema.add({
+            [field.name]: localizeSchema(field, baseSchema, config.localization)
+        });
+    },
+    email: (field, schema, config, buildSchemaOptions)=>{
+        const baseSchema = {
+            ...formatBaseSchema(field, buildSchemaOptions),
+            type: String
+        };
+        schema.add({
+            [field.name]: localizeSchema(field, baseSchema, config.localization)
+        });
+    },
+    group: (field, schema, config, buildSchemaOptions)=>{
+        const formattedBaseSchema = formatBaseSchema(field, buildSchemaOptions);
+        // carry indexSortableFields through to versions if drafts enabled
+        const indexSortableFields = buildSchemaOptions.indexSortableFields && field.name === 'version' && buildSchemaOptions.draftsEnabled;
+        const baseSchema = {
+            ...formattedBaseSchema,
+            type: buildSchema(config, field.fields, {
+                disableUnique: buildSchemaOptions.disableUnique,
+                draftsEnabled: buildSchemaOptions.draftsEnabled,
+                indexSortableFields,
+                options: {
+                    _id: false,
+                    id: false,
+                    minimize: false
+                }
+            })
+        };
+        schema.add({
+            [field.name]: localizeSchema(field, baseSchema, config.localization)
+        });
+    },
+    json: (field, schema, config, buildSchemaOptions)=>{
+        const baseSchema = {
+            ...formatBaseSchema(field, buildSchemaOptions),
+            type: _mongoose.Schema.Types.Mixed
+        };
+        schema.add({
+            [field.name]: localizeSchema(field, baseSchema, config.localization)
+        });
+    },
+    number: (field, schema, config, buildSchemaOptions)=>{
+        const baseSchema = {
+            ...formatBaseSchema(field, buildSchemaOptions),
+            type: field.hasMany ? [
+                Number
+            ] : Number
+        };
+        schema.add({
+            [field.name]: localizeSchema(field, baseSchema, config.localization)
+        });
+    },
+    point: (field, schema, config, buildSchemaOptions)=>{
+        const baseSchema = {
+            coordinates: {
+                default: field.defaultValue || undefined,
+                required: false,
+                type: [
+                    Number
+                ]
+            },
+            type: {
+                enum: [
+                    'Point'
+                ],
+                type: String
+            }
+        };
+        if (buildSchemaOptions.disableUnique && field.unique && field.localized) {
+            baseSchema.coordinates.sparse = true;
+        }
+        schema.add({
+            [field.name]: localizeSchema(field, baseSchema, config.localization)
+        });
+        if (field.index === true || field.index === undefined) {
+            const indexOptions = {};
+            if (!buildSchemaOptions.disableUnique && field.unique) {
+                indexOptions.sparse = true;
+                indexOptions.unique = true;
+            }
+            if (field.localized && config.localization) {
+                config.localization.locales.forEach((locale)=>{
+                    schema.index({
+                        [`${field.name}.${locale}`]: '2dsphere'
+                    }, indexOptions);
+                });
+            } else {
+                schema.index({
+                    [field.name]: '2dsphere'
+                }, indexOptions);
+            }
+        }
+    },
+    radio: (field, schema, config, buildSchemaOptions)=>{
+        const baseSchema = {
+            ...formatBaseSchema(field, buildSchemaOptions),
+            enum: field.options.map((option)=>{
+                if (typeof option === 'object') return option.value;
+                return option;
+            }),
+            type: String
+        };
+        schema.add({
+            [field.name]: localizeSchema(field, baseSchema, config.localization)
+        });
+    },
+    relationship: (field, schema, config, buildSchemaOptions)=>{
+        const hasManyRelations = Array.isArray(field.relationTo);
+        let schemaToReturn = {};
+        if (field.localized && config.localization) {
+            schemaToReturn = {
+                localized: true,
+                type: config.localization.localeCodes.reduce((locales, locale)=>{
+                    let localeSchema = {};
+                    if (hasManyRelations) {
+                        localeSchema = {
+                            ...formatBaseSchema(field, buildSchemaOptions),
+                            _id: false,
+                            relationTo: {
+                                enum: field.relationTo,
+                                type: String
+                            },
+                            type: _mongoose.Schema.Types.Mixed,
+                            value: {
+                                refPath: `${field.name}.${locale}.relationTo`,
+                                type: _mongoose.Schema.Types.Mixed
+                            }
+                        };
+                    } else {
+                        localeSchema = {
+                            ...formatBaseSchema(field, buildSchemaOptions),
+                            ref: field.relationTo,
+                            type: _mongoose.Schema.Types.Mixed
+                        };
+                    }
+                    return {
+                        ...locales,
+                        [locale]: field.hasMany ? {
+                            default: undefined,
+                            type: [
+                                localeSchema
+                            ]
+                        } : localeSchema
+                    };
+                }, {})
+            };
+        } else if (hasManyRelations) {
+            schemaToReturn = {
+                ...formatBaseSchema(field, buildSchemaOptions),
+                _id: false,
+                relationTo: {
+                    enum: field.relationTo,
+                    type: String
+                },
+                type: _mongoose.Schema.Types.Mixed,
+                value: {
+                    refPath: `${field.name}.relationTo`,
+                    type: _mongoose.Schema.Types.Mixed
+                }
+            };
+            if (field.hasMany) {
+                schemaToReturn = {
+                    default: undefined,
+                    type: [
+                        schemaToReturn
+                    ]
+                };
+            }
+        } else {
+            schemaToReturn = {
+                ...formatBaseSchema(field, buildSchemaOptions),
+                ref: field.relationTo,
+                type: _mongoose.Schema.Types.Mixed
+            };
+            if (field.hasMany) {
+                schemaToReturn = {
+                    default: undefined,
+                    type: [
+                        schemaToReturn
+                    ]
+                };
+            }
+        }
+        schema.add({
+            [field.name]: schemaToReturn
+        });
+    },
+    richText: (field, schema, config, buildSchemaOptions)=>{
+        const baseSchema = {
+            ...formatBaseSchema(field, buildSchemaOptions),
+            type: _mongoose.Schema.Types.Mixed
+        };
+        schema.add({
+            [field.name]: localizeSchema(field, baseSchema, config.localization)
+        });
+    },
+    row: (field, schema, config, buildSchemaOptions)=>{
+        field.fields.forEach((subField)=>{
+            const addFieldSchema = fieldToSchemaMap[subField.type];
+            if (addFieldSchema) {
+                addFieldSchema(subField, schema, config, buildSchemaOptions);
+            }
+        });
+    },
+    select: (field, schema, config, buildSchemaOptions)=>{
+        const baseSchema = {
+            ...formatBaseSchema(field, buildSchemaOptions),
+            enum: field.options.map((option)=>{
+                if (typeof option === 'object') return option.value;
+                return option;
+            }),
+            type: String
+        };
+        if (buildSchemaOptions.draftsEnabled || !field.required) {
+            baseSchema.enum.push(null);
+        }
+        schema.add({
+            [field.name]: localizeSchema(field, field.hasMany ? [
+                baseSchema
+            ] : baseSchema, config.localization)
+        });
+    },
+    tabs: (field, schema, config, buildSchemaOptions)=>{
+        field.tabs.forEach((tab)=>{
+            if ((0, _types.tabHasName)(tab)) {
+                const baseSchema = {
+                    type: buildSchema(config, tab.fields, {
+                        disableUnique: buildSchemaOptions.disableUnique,
+                        draftsEnabled: buildSchemaOptions.draftsEnabled,
+                        options: {
+                            _id: false,
+                            id: false,
+                            minimize: false
+                        }
+                    })
+                };
+                schema.add({
+                    [tab.name]: localizeSchema(tab, baseSchema, config.localization)
+                });
+            } else {
+                tab.fields.forEach((subField)=>{
+                    const addFieldSchema = fieldToSchemaMap[subField.type];
+                    if (addFieldSchema) {
+                        addFieldSchema(subField, schema, config, buildSchemaOptions);
+                    }
+                });
+            }
+        });
+    },
+    text: (field, schema, config, buildSchemaOptions)=>{
+        const baseSchema = {
+            ...formatBaseSchema(field, buildSchemaOptions),
+            type: String
+        };
+        schema.add({
+            [field.name]: localizeSchema(field, baseSchema, config.localization)
+        });
+    },
+    textarea: (field, schema, config, buildSchemaOptions)=>{
+        const baseSchema = {
+            ...formatBaseSchema(field, buildSchemaOptions),
+            type: String
+        };
+        schema.add({
+            [field.name]: localizeSchema(field, baseSchema, config.localization)
+        });
+    },
+    upload: (field, schema, config, buildSchemaOptions)=>{
+        const baseSchema = {
+            ...formatBaseSchema(field, buildSchemaOptions),
+            ref: field.relationTo,
+            type: _mongoose.Schema.Types.Mixed
+        };
+        schema.add({
+            [field.name]: localizeSchema(field, baseSchema, config.localization)
+        });
+    }
+};
+const _default = buildSchema;
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/models/buildSchema.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/ban-ts-comment */\n/* eslint-disable class-methods-use-this */\n/* eslint-disable @typescript-eslint/no-use-before-define */\n/* eslint-disable no-use-before-define */\nimport type { IndexOptions, SchemaOptions, SchemaTypeOptions } from 'mongoose'\nimport type { SanitizedConfig, SanitizedLocalizationConfig } from 'payload/config'\nimport type {\n  ArrayField,\n  Block,\n  BlockField,\n  CheckboxField,\n  CodeField,\n  CollapsibleField,\n  DateField,\n  EmailField,\n  Field,\n  GroupField,\n  JSONField,\n  NumberField,\n  PointField,\n  RadioField,\n  RelationshipField,\n  RichTextField,\n  RowField,\n  SelectField,\n  TabsField,\n  TextField,\n  TextareaField,\n  UploadField,\n} from 'payload/types'\nimport type { FieldAffectingData, NonPresentationalField, Tab, UnnamedTab } from 'payload/types'\n\nimport { Schema } from 'mongoose'\nimport {\n  fieldAffectsData,\n  fieldIsLocalized,\n  fieldIsPresentationalOnly,\n  tabHasName,\n} from 'payload/types'\n\nexport type BuildSchemaOptions = {\n  allowIDField?: boolean\n  disableUnique?: boolean\n  draftsEnabled?: boolean\n  indexSortableFields?: boolean\n  options?: SchemaOptions\n}\n\ntype FieldSchemaGenerator = (\n  field: Field,\n  schema: Schema,\n  config: SanitizedConfig,\n  buildSchemaOptions: BuildSchemaOptions,\n) => void\n\nconst formatBaseSchema = (field: FieldAffectingData, buildSchemaOptions: BuildSchemaOptions) => {\n  const { disableUnique, draftsEnabled, indexSortableFields } = buildSchemaOptions\n  const schema: SchemaTypeOptions<unknown> = {\n    index: field.index || (!disableUnique && field.unique) || indexSortableFields || false,\n    required: false,\n    unique: (!disableUnique && field.unique) || false,\n  }\n\n  if (schema.unique && (field.localized || draftsEnabled)) {\n    schema.sparse = true\n  }\n\n  if (field.hidden) {\n    schema.hidden = true\n  }\n\n  return schema\n}\n\nconst localizeSchema = (\n  entity: NonPresentationalField | Tab,\n  schema,\n  localization: SanitizedLocalizationConfig | false,\n) => {\n  if (fieldIsLocalized(entity) && localization && Array.isArray(localization.locales)) {\n    return {\n      localized: true,\n      type: localization.localeCodes.reduce(\n        (localeSchema, locale) => ({\n          ...localeSchema,\n          [locale]: schema,\n        }),\n        {\n          _id: false,\n        },\n      ),\n    }\n  }\n  return schema\n}\n\nconst buildSchema = (\n  config: SanitizedConfig,\n  configFields: Field[],\n  buildSchemaOptions: BuildSchemaOptions = {},\n): Schema => {\n  const { allowIDField, options } = buildSchemaOptions\n  let fields = {}\n\n  let schemaFields = configFields\n\n  if (!allowIDField) {\n    const idField = schemaFields.find((field) => fieldAffectsData(field) && field.name === 'id')\n    if (idField) {\n      fields = {\n        _id: idField.type === 'number' ? Number : String,\n      }\n      schemaFields = schemaFields.filter(\n        (field) => !(fieldAffectsData(field) && field.name === 'id'),\n      )\n    }\n  }\n\n  const schema = new Schema(fields, options)\n\n  schemaFields.forEach((field) => {\n    if (!fieldIsPresentationalOnly(field)) {\n      const addFieldSchema: FieldSchemaGenerator = fieldToSchemaMap[field.type]\n\n      if (addFieldSchema) {\n        addFieldSchema(field, schema, config, buildSchemaOptions)\n      }\n    }\n  })\n\n  return schema\n}\n\nconst fieldToSchemaMap: Record<string, FieldSchemaGenerator> = {\n  array: (\n    field: ArrayField,\n    schema: Schema,\n    config: SanitizedConfig,\n    buildSchemaOptions: BuildSchemaOptions,\n  ) => {\n    const baseSchema = {\n      ...formatBaseSchema(field, buildSchemaOptions),\n      default: undefined,\n      type: [\n        buildSchema(config, field.fields, {\n          allowIDField: true,\n          disableUnique: buildSchemaOptions.disableUnique,\n          draftsEnabled: buildSchemaOptions.draftsEnabled,\n          options: {\n            _id: false,\n            id: false,\n            minimize: false,\n          },\n        }),\n      ],\n    }\n\n    schema.add({\n      [field.name]: localizeSchema(field, baseSchema, config.localization),\n    })\n  },\n  blocks: (\n    field: BlockField,\n    schema: Schema,\n    config: SanitizedConfig,\n    buildSchemaOptions: BuildSchemaOptions,\n  ): void => {\n    const fieldSchema = {\n      default: undefined,\n      type: [new Schema({}, { _id: false, discriminatorKey: 'blockType' })],\n    }\n\n    schema.add({\n      [field.name]: localizeSchema(field, fieldSchema, config.localization),\n    })\n\n    field.blocks.forEach((blockItem: Block) => {\n      const blockSchema = new Schema({}, { _id: false, id: false })\n\n      blockItem.fields.forEach((blockField) => {\n        const addFieldSchema: FieldSchemaGenerator = fieldToSchemaMap[blockField.type]\n        if (addFieldSchema) {\n          addFieldSchema(blockField, blockSchema, config, buildSchemaOptions)\n        }\n      })\n\n      if (field.localized && config.localization) {\n        config.localization.localeCodes.forEach((localeCode) => {\n          // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n          // @ts-ignore Possible incorrect typing in mongoose types, this works\n          schema.path(`${field.name}.${localeCode}`).discriminator(blockItem.slug, blockSchema)\n        })\n      } else {\n        // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n        // @ts-ignore Possible incorrect typing in mongoose types, this works\n        schema.path(field.name).discriminator(blockItem.slug, blockSchema)\n      }\n    })\n  },\n  checkbox: (\n    field: CheckboxField,\n    schema: Schema,\n    config: SanitizedConfig,\n    buildSchemaOptions: BuildSchemaOptions,\n  ): void => {\n    const baseSchema = { ...formatBaseSchema(field, buildSchemaOptions), type: Boolean }\n\n    schema.add({\n      [field.name]: localizeSchema(field, baseSchema, config.localization),\n    })\n  },\n  code: (\n    field: CodeField,\n    schema: Schema,\n    config: SanitizedConfig,\n    buildSchemaOptions: BuildSchemaOptions,\n  ): void => {\n    const baseSchema = { ...formatBaseSchema(field, buildSchemaOptions), type: String }\n\n    schema.add({\n      [field.name]: localizeSchema(field, baseSchema, config.localization),\n    })\n  },\n  collapsible: (\n    field: CollapsibleField,\n    schema: Schema,\n    config: SanitizedConfig,\n    buildSchemaOptions: BuildSchemaOptions,\n  ): void => {\n    field.fields.forEach((subField: Field) => {\n      const addFieldSchema: FieldSchemaGenerator = fieldToSchemaMap[subField.type]\n\n      if (addFieldSchema) {\n        addFieldSchema(subField, schema, config, buildSchemaOptions)\n      }\n    })\n  },\n  date: (\n    field: DateField,\n    schema: Schema,\n    config: SanitizedConfig,\n    buildSchemaOptions: BuildSchemaOptions,\n  ): void => {\n    const baseSchema = { ...formatBaseSchema(field, buildSchemaOptions), type: Date }\n\n    schema.add({\n      [field.name]: localizeSchema(field, baseSchema, config.localization),\n    })\n  },\n  email: (\n    field: EmailField,\n    schema: Schema,\n    config: SanitizedConfig,\n    buildSchemaOptions: BuildSchemaOptions,\n  ): void => {\n    const baseSchema = { ...formatBaseSchema(field, buildSchemaOptions), type: String }\n\n    schema.add({\n      [field.name]: localizeSchema(field, baseSchema, config.localization),\n    })\n  },\n  group: (\n    field: GroupField,\n    schema: Schema,\n    config: SanitizedConfig,\n    buildSchemaOptions: BuildSchemaOptions,\n  ): void => {\n    const formattedBaseSchema = formatBaseSchema(field, buildSchemaOptions)\n\n    // carry indexSortableFields through to versions if drafts enabled\n    const indexSortableFields =\n      buildSchemaOptions.indexSortableFields &&\n      field.name === 'version' &&\n      buildSchemaOptions.draftsEnabled\n\n    const baseSchema = {\n      ...formattedBaseSchema,\n      type: buildSchema(config, field.fields, {\n        disableUnique: buildSchemaOptions.disableUnique,\n        draftsEnabled: buildSchemaOptions.draftsEnabled,\n        indexSortableFields,\n        options: {\n          _id: false,\n          id: false,\n          minimize: false,\n        },\n      }),\n    }\n\n    schema.add({\n      [field.name]: localizeSchema(field, baseSchema, config.localization),\n    })\n  },\n  json: (\n    field: JSONField,\n    schema: Schema,\n    config: SanitizedConfig,\n    buildSchemaOptions: BuildSchemaOptions,\n  ): void => {\n    const baseSchema = { ...formatBaseSchema(field, buildSchemaOptions), type: Schema.Types.Mixed }\n\n    schema.add({\n      [field.name]: localizeSchema(field, baseSchema, config.localization),\n    })\n  },\n  number: (\n    field: NumberField,\n    schema: Schema,\n    config: SanitizedConfig,\n    buildSchemaOptions: BuildSchemaOptions,\n  ): void => {\n    const baseSchema = {\n      ...formatBaseSchema(field, buildSchemaOptions),\n      type: field.hasMany ? [Number] : Number,\n    }\n\n    schema.add({\n      [field.name]: localizeSchema(field, baseSchema, config.localization),\n    })\n  },\n  point: (\n    field: PointField,\n    schema: Schema,\n    config: SanitizedConfig,\n    buildSchemaOptions: BuildSchemaOptions,\n  ): void => {\n    const baseSchema: SchemaTypeOptions<unknown> = {\n      coordinates: {\n        default: field.defaultValue || undefined,\n        required: false,\n        type: [Number],\n      },\n      type: {\n        enum: ['Point'],\n        type: String,\n      },\n    }\n    if (buildSchemaOptions.disableUnique && field.unique && field.localized) {\n      baseSchema.coordinates.sparse = true\n    }\n\n    schema.add({\n      [field.name]: localizeSchema(field, baseSchema, config.localization),\n    })\n\n    if (field.index === true || field.index === undefined) {\n      const indexOptions: IndexOptions = {}\n      if (!buildSchemaOptions.disableUnique && field.unique) {\n        indexOptions.sparse = true\n        indexOptions.unique = true\n      }\n      if (field.localized && config.localization) {\n        config.localization.locales.forEach((locale) => {\n          schema.index({ [`${field.name}.${locale}`]: '2dsphere' }, indexOptions)\n        })\n      } else {\n        schema.index({ [field.name]: '2dsphere' }, indexOptions)\n      }\n    }\n  },\n  radio: (\n    field: RadioField,\n    schema: Schema,\n    config: SanitizedConfig,\n    buildSchemaOptions: BuildSchemaOptions,\n  ): void => {\n    const baseSchema = {\n      ...formatBaseSchema(field, buildSchemaOptions),\n      enum: field.options.map((option) => {\n        if (typeof option === 'object') return option.value\n        return option\n      }),\n      type: String,\n    }\n\n    schema.add({\n      [field.name]: localizeSchema(field, baseSchema, config.localization),\n    })\n  },\n  relationship: (\n    field: RelationshipField,\n    schema: Schema,\n    config: SanitizedConfig,\n    buildSchemaOptions: BuildSchemaOptions,\n  ) => {\n    const hasManyRelations = Array.isArray(field.relationTo)\n    let schemaToReturn: { [key: string]: any } = {}\n\n    if (field.localized && config.localization) {\n      schemaToReturn = {\n        localized: true,\n        type: config.localization.localeCodes.reduce((locales, locale) => {\n          let localeSchema: { [key: string]: any } = {}\n\n          if (hasManyRelations) {\n            localeSchema = {\n              ...formatBaseSchema(field, buildSchemaOptions),\n              _id: false,\n              relationTo: { enum: field.relationTo, type: String },\n              type: Schema.Types.Mixed,\n              value: {\n                refPath: `${field.name}.${locale}.relationTo`,\n                type: Schema.Types.Mixed,\n              },\n            }\n          } else {\n            localeSchema = {\n              ...formatBaseSchema(field, buildSchemaOptions),\n              ref: field.relationTo,\n              type: Schema.Types.Mixed,\n            }\n          }\n\n          return {\n            ...locales,\n            [locale]: field.hasMany ? { default: undefined, type: [localeSchema] } : localeSchema,\n          }\n        }, {}),\n      }\n    } else if (hasManyRelations) {\n      schemaToReturn = {\n        ...formatBaseSchema(field, buildSchemaOptions),\n        _id: false,\n        relationTo: { enum: field.relationTo, type: String },\n        type: Schema.Types.Mixed,\n        value: {\n          refPath: `${field.name}.relationTo`,\n          type: Schema.Types.Mixed,\n        },\n      }\n\n      if (field.hasMany) {\n        schemaToReturn = {\n          default: undefined,\n          type: [schemaToReturn],\n        }\n      }\n    } else {\n      schemaToReturn = {\n        ...formatBaseSchema(field, buildSchemaOptions),\n        ref: field.relationTo,\n        type: Schema.Types.Mixed,\n      }\n\n      if (field.hasMany) {\n        schemaToReturn = {\n          default: undefined,\n          type: [schemaToReturn],\n        }\n      }\n    }\n\n    schema.add({\n      [field.name]: schemaToReturn,\n    })\n  },\n  richText: (\n    field: RichTextField,\n    schema: Schema,\n    config: SanitizedConfig,\n    buildSchemaOptions: BuildSchemaOptions,\n  ): void => {\n    const baseSchema = { ...formatBaseSchema(field, buildSchemaOptions), type: Schema.Types.Mixed }\n\n    schema.add({\n      [field.name]: localizeSchema(field, baseSchema, config.localization),\n    })\n  },\n  row: (\n    field: RowField,\n    schema: Schema,\n    config: SanitizedConfig,\n    buildSchemaOptions: BuildSchemaOptions,\n  ): void => {\n    field.fields.forEach((subField: Field) => {\n      const addFieldSchema: FieldSchemaGenerator = fieldToSchemaMap[subField.type]\n\n      if (addFieldSchema) {\n        addFieldSchema(subField, schema, config, buildSchemaOptions)\n      }\n    })\n  },\n  select: (\n    field: SelectField,\n    schema: Schema,\n    config: SanitizedConfig,\n    buildSchemaOptions: BuildSchemaOptions,\n  ): void => {\n    const baseSchema = {\n      ...formatBaseSchema(field, buildSchemaOptions),\n      enum: field.options.map((option) => {\n        if (typeof option === 'object') return option.value\n        return option\n      }),\n      type: String,\n    }\n\n    if (buildSchemaOptions.draftsEnabled || !field.required) {\n      baseSchema.enum.push(null)\n    }\n\n    schema.add({\n      [field.name]: localizeSchema(\n        field,\n        field.hasMany ? [baseSchema] : baseSchema,\n        config.localization,\n      ),\n    })\n  },\n  tabs: (\n    field: TabsField,\n    schema: Schema,\n    config: SanitizedConfig,\n    buildSchemaOptions: BuildSchemaOptions,\n  ): void => {\n    field.tabs.forEach((tab) => {\n      if (tabHasName(tab)) {\n        const baseSchema = {\n          type: buildSchema(config, tab.fields, {\n            disableUnique: buildSchemaOptions.disableUnique,\n            draftsEnabled: buildSchemaOptions.draftsEnabled,\n            options: {\n              _id: false,\n              id: false,\n              minimize: false,\n            },\n          }),\n        }\n\n        schema.add({\n          [tab.name]: localizeSchema(tab, baseSchema, config.localization),\n        })\n      } else {\n        tab.fields.forEach((subField: Field) => {\n          const addFieldSchema: FieldSchemaGenerator = fieldToSchemaMap[subField.type]\n\n          if (addFieldSchema) {\n            addFieldSchema(subField, schema, config, buildSchemaOptions)\n          }\n        })\n      }\n    })\n  },\n  text: (\n    field: TextField,\n    schema: Schema,\n    config: SanitizedConfig,\n    buildSchemaOptions: BuildSchemaOptions,\n  ): void => {\n    const baseSchema = { ...formatBaseSchema(field, buildSchemaOptions), type: String }\n\n    schema.add({\n      [field.name]: localizeSchema(field, baseSchema, config.localization),\n    })\n  },\n  textarea: (\n    field: TextareaField,\n    schema: Schema,\n    config: SanitizedConfig,\n    buildSchemaOptions: BuildSchemaOptions,\n  ): void => {\n    const baseSchema = { ...formatBaseSchema(field, buildSchemaOptions), type: String }\n\n    schema.add({\n      [field.name]: localizeSchema(field, baseSchema, config.localization),\n    })\n  },\n  upload: (\n    field: UploadField,\n    schema: Schema,\n    config: SanitizedConfig,\n    buildSchemaOptions: BuildSchemaOptions,\n  ): void => {\n    const baseSchema = {\n      ...formatBaseSchema(field, buildSchemaOptions),\n      ref: field.relationTo,\n      type: Schema.Types.Mixed,\n    }\n\n    schema.add({\n      [field.name]: localizeSchema(field, baseSchema, config.localization),\n    })\n  },\n}\n\nexport default buildSchema\n"],"names":["formatBaseSchema","field","buildSchemaOptions","disableUnique","draftsEnabled","indexSortableFields","schema","index","unique","required","localized","sparse","hidden","localizeSchema","entity","localization","fieldIsLocalized","Array","isArray","locales","type","localeCodes","reduce","localeSchema","locale","_id","buildSchema","config","configFields","allowIDField","options","fields","schemaFields","idField","find","fieldAffectsData","name","Number","String","filter","Schema","forEach","fieldIsPresentationalOnly","addFieldSchema","fieldToSchemaMap","array","baseSchema","default","undefined","id","minimize","add","blocks","fieldSchema","discriminatorKey","blockItem","blockSchema","blockField","localeCode","path","discriminator","slug","checkbox","Boolean","code","collapsible","subField","date","Date","email","group","formattedBaseSchema","json","Types","Mixed","number","hasMany","point","coordinates","defaultValue","enum","indexOptions","radio","map","option","value","relationship","hasManyRelations","relationTo","schemaToReturn","refPath","ref","richText","row","select","push","tabs","tab","tabHasName","text","textarea","upload"],"mappings":"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"}

package/dist/queries/buildAndOrConditions.d.ts

@@ -0,0 +1,11 @@
+import type { Payload } from 'payload';
+import type { Field, Where } from 'payload/types';
+export declare function buildAndOrConditions({ collectionSlug, fields, globalSlug, locale, payload, where, }: {
+    collectionSlug?: string;
+    fields: Field[];
+    globalSlug?: string;
+    locale?: string;
+    payload: Payload;
+    where: Where[];
+}): Promise<Record<string, unknown>[]>;
+//# sourceMappingURL=buildAndOrConditions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"buildAndOrConditions.d.ts","sourceRoot":"","sources":["../../src/queries/buildAndOrConditions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,SAAS,CAAA;AACtC,OAAO,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,eAAe,CAAA;AAIjD,wBAAsB,oBAAoB,CAAC,EACzC,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,CAAC,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,OAAO,CAAA;IAChB,KAAK,EAAE,KAAK,EAAE,CAAA;CACf,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,CAuBrC"}

package/dist/queries/buildAndOrConditions.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "buildAndOrConditions", {
+    enumerable: true,
+    get: function() {
+        return buildAndOrConditions;
+    }
+});
+const _parseParams = require("./parseParams");
+async function buildAndOrConditions({ collectionSlug, fields, globalSlug, locale, payload, where }) {
+    const completedConditions = [];
+    // Loop over all AND / OR operations and add them to the AND / OR query param
+    // Operations should come through as an array
+    // eslint-disable-next-line no-restricted-syntax
+    for (const condition of where){
+        // If the operation is properly formatted as an object
+        if (typeof condition === 'object') {
+            // eslint-disable-next-line no-await-in-loop
+            const result = await (0, _parseParams.parseParams)({
+                collectionSlug,
+                fields,
+                globalSlug,
+                locale,
+                payload,
+                where: condition
+            });
+            if (Object.keys(result).length > 0) {
+                completedConditions.push(result);
+            }
+        }
+    }
+    return completedConditions;
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/queries/buildQuery.d.ts

@@ -0,0 +1,15 @@
+import type { Payload } from 'payload';
+import type { Field, Where } from 'payload/types';
+type GetBuildQueryPluginArgs = {
+    collectionSlug?: string;
+    versionsFields?: Field[];
+};
+export type BuildQueryArgs = {
+    globalSlug?: string;
+    locale?: string;
+    payload: Payload;
+    where: Where;
+};
+declare const getBuildQueryPlugin: ({ collectionSlug, versionsFields }?: GetBuildQueryPluginArgs) => (schema: any) => void;
+export default getBuildQueryPlugin;
+//# sourceMappingURL=buildQuery.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"buildQuery.d.ts","sourceRoot":"","sources":["../../src/queries/buildQuery.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,SAAS,CAAA;AACtC,OAAO,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,eAAe,CAAA;AAMjD,KAAK,uBAAuB,GAAG;IAC7B,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,cAAc,CAAC,EAAE,KAAK,EAAE,CAAA;CACzB,CAAA;AAED,MAAM,MAAM,cAAc,GAAG;IAC3B,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,OAAO,CAAA;IAChB,KAAK,EAAE,KAAK,CAAA;CACb,CAAA;AAID,QAAA,MAAM,mBAAmB,wCAAwC,uBAAuB,0BAsCvF,CAAA;AAED,eAAe,mBAAmB,CAAA"}