@payloadcms/db-mongodb 3.24.0-canary.72057b1 → 3.24.0-canary.80e034e

package/dist/models/buildSchema.js

@@ -1,10 +1,10 @@
 import mongoose from 'mongoose';
-import { fieldAffectsData, fieldIsLocalized, fieldIsPresentationalOnly, fieldIsVirtual, tabHasName } from 'payload/shared';
+import { fieldAffectsData, fieldIsPresentationalOnly, fieldIsVirtual, fieldShouldBeLocalized, tabHasName } from 'payload/shared';
 /**
  * get a field's defaultValue only if defined and not dynamic so that it can be set on the field schema
  * @param field
  */ const formatDefaultValue = (field)=>typeof field.defaultValue !== 'undefined' && typeof field.defaultValue !== 'function' ? field.defaultValue : undefined;
-const formatBaseSchema = (field, buildSchemaOptions)=>{
+const formatBaseSchema = ({ buildSchemaOptions, field, parentIsLocalized })=>{
     const { disableUnique, draftsEnabled, indexSortableFields } = buildSchemaOptions;
     const schema = {
         default: formatDefaultValue(field),
@@ -12,7 +12,10 @@ const formatBaseSchema = (field, buildSchemaOptions)=>{
         required: false,
         unique: !disableUnique && field.unique || false
     };
-    if (schema.unique && (field.localized || draftsEnabled || fieldAffectsData(field) && field.type !== 'group' && field.type !== 'tab' && field.required !== true)) {
+    if (schema.unique && (fieldShouldBeLocalized({
+        field,
+        parentIsLocalized
+    }) || draftsEnabled || fieldAffectsData(field) && field.type !== 'group' && field.type !== 'tab' && field.required !== true)) {
         schema.sparse = true;
     }
     if (field.hidden) {
@@ -20,8 +23,11 @@ const formatBaseSchema = (field, buildSchemaOptions)=>{
     }
     return schema;
 };
-const localizeSchema = (entity, schema, localization)=>{
-    if (fieldIsLocalized(entity) && localization && Array.isArray(localization.locales)) {
+const localizeSchema = (entity, schema, localization, parentIsLocalized)=>{
+    if (fieldShouldBeLocalized({
+        field: entity,
+        parentIsLocalized
+    }) && localization && Array.isArray(localization.locales)) {
         return {
             type: localization.localeCodes.reduce((localeSchema, locale)=>({
                     ...localeSchema,
@@ -34,7 +40,8 @@ const localizeSchema = (entity, schema, localization)=>{
     }
     return schema;
 };
-export const buildSchema = (payload, configFields, buildSchemaOptions = {})=>{
+export const buildSchema = (args)=>{
+    const { buildSchemaOptions = {}, configFields, parentIsLocalized, payload } = args;
     const { allowIDField, options } = buildSchemaOptions;
     let fields = {};
     let schemaFields = configFields;
@@ -55,34 +62,43 @@ export const buildSchema = (payload, configFields, buildSchemaOptions = {})=>{
         if (!fieldIsPresentationalOnly(field)) {
             const addFieldSchema = fieldToSchemaMap[field.type];
             if (addFieldSchema) {
-                addFieldSchema(field, schema, payload, buildSchemaOptions);
+                addFieldSchema(field, schema, payload, buildSchemaOptions, parentIsLocalized);
             }
         }
     });
     return schema;
 };
 const fieldToSchemaMap = {
-    array: (field, schema, payload, buildSchemaOptions)=>{
+    array: (field, schema, payload, buildSchemaOptions, parentIsLocalized)=>{
         const baseSchema = {
-            ...formatBaseSchema(field, buildSchemaOptions),
+            ...formatBaseSchema({
+                buildSchemaOptions,
+                field,
+                parentIsLocalized
+            }),
             type: [
-                buildSchema(payload, field.fields, {
-                    allowIDField: true,
-                    disableUnique: buildSchemaOptions.disableUnique,
-                    draftsEnabled: buildSchemaOptions.draftsEnabled,
-                    options: {
-                        _id: false,
-                        id: false,
-                        minimize: false
-                    }
+                buildSchema({
+                    buildSchemaOptions: {
+                        allowIDField: true,
+                        disableUnique: buildSchemaOptions.disableUnique,
+                        draftsEnabled: buildSchemaOptions.draftsEnabled,
+                        options: {
+                            _id: false,
+                            id: false,
+                            minimize: false
+                        }
+                    },
+                    configFields: field.fields,
+                    parentIsLocalized: parentIsLocalized || field.localized,
+                    payload
                 })
             ]
         };
         schema.add({
-            [field.name]: localizeSchema(field, baseSchema, payload.config.localization)
+            [field.name]: localizeSchema(field, baseSchema, payload.config.localization, parentIsLocalized)
         });
     },
-    blocks: (field, schema, payload, buildSchemaOptions)=>{
+    blocks: (field, schema, payload, buildSchemaOptions, parentIsLocalized)=>{
         const fieldSchema = {
             type: [
                 new mongoose.Schema({}, {
@@ -92,119 +108,156 @@ const fieldToSchemaMap = {
             ]
         };
         schema.add({
-            [field.name]: localizeSchema(field, fieldSchema, payload.config.localization)
+            [field.name]: localizeSchema(field, fieldSchema, payload.config.localization, parentIsLocalized)
         });
-        field.blocks.forEach((blockItem)=>{
+        (field.blockReferences ?? field.blocks).forEach((blockItem)=>{
             const blockSchema = new mongoose.Schema({}, {
                 _id: false,
                 id: false
             });
-            blockItem.fields.forEach((blockField)=>{
+            const block = typeof blockItem === 'string' ? payload.blocks[blockItem] : blockItem;
+            block.fields.forEach((blockField)=>{
                 const addFieldSchema = fieldToSchemaMap[blockField.type];
                 if (addFieldSchema) {
-                    addFieldSchema(blockField, blockSchema, payload, buildSchemaOptions);
+                    addFieldSchema(blockField, blockSchema, payload, buildSchemaOptions, parentIsLocalized || field.localized);
                 }
             });
-            if (field.localized && payload.config.localization) {
+            if (fieldShouldBeLocalized({
+                field,
+                parentIsLocalized
+            }) && payload.config.localization) {
                 payload.config.localization.localeCodes.forEach((localeCode)=>{
                     // @ts-expect-error Possible incorrect typing in mongoose types, this works
-                    schema.path(`${field.name}.${localeCode}`).discriminator(blockItem.slug, blockSchema);
+                    schema.path(`${field.name}.${localeCode}`).discriminator(block.slug, blockSchema);
                 });
             } else {
                 // @ts-expect-error Possible incorrect typing in mongoose types, this works
-                schema.path(field.name).discriminator(blockItem.slug, blockSchema);
+                schema.path(field.name).discriminator(block.slug, blockSchema);
             }
         });
     },
-    checkbox: (field, schema, payload, buildSchemaOptions)=>{
+    checkbox: (field, schema, payload, buildSchemaOptions, parentIsLocalized)=>{
         const baseSchema = {
-            ...formatBaseSchema(field, buildSchemaOptions),
+            ...formatBaseSchema({
+                buildSchemaOptions,
+                field,
+                parentIsLocalized
+            }),
             type: Boolean
         };
         schema.add({
-            [field.name]: localizeSchema(field, baseSchema, payload.config.localization)
+            [field.name]: localizeSchema(field, baseSchema, payload.config.localization, parentIsLocalized)
         });
     },
-    code: (field, schema, payload, buildSchemaOptions)=>{
+    code: (field, schema, payload, buildSchemaOptions, parentIsLocalized)=>{
         const baseSchema = {
-            ...formatBaseSchema(field, buildSchemaOptions),
+            ...formatBaseSchema({
+                buildSchemaOptions,
+                field,
+                parentIsLocalized
+            }),
             type: String
         };
         schema.add({
-            [field.name]: localizeSchema(field, baseSchema, payload.config.localization)
+            [field.name]: localizeSchema(field, baseSchema, payload.config.localization, parentIsLocalized)
         });
     },
-    collapsible: (field, schema, payload, buildSchemaOptions)=>{
+    collapsible: (field, schema, payload, buildSchemaOptions, parentIsLocalized)=>{
         field.fields.forEach((subField)=>{
             if (fieldIsVirtual(subField)) {
                 return;
             }
             const addFieldSchema = fieldToSchemaMap[subField.type];
             if (addFieldSchema) {
-                addFieldSchema(subField, schema, payload, buildSchemaOptions);
+                addFieldSchema(subField, schema, payload, buildSchemaOptions, parentIsLocalized);
             }
         });
     },
-    date: (field, schema, payload, buildSchemaOptions)=>{
+    date: (field, schema, payload, buildSchemaOptions, parentIsLocalized)=>{
         const baseSchema = {
-            ...formatBaseSchema(field, buildSchemaOptions),
+            ...formatBaseSchema({
+                buildSchemaOptions,
+                field,
+                parentIsLocalized
+            }),
             type: Date
         };
         schema.add({
-            [field.name]: localizeSchema(field, baseSchema, payload.config.localization)
+            [field.name]: localizeSchema(field, baseSchema, payload.config.localization, parentIsLocalized)
         });
     },
-    email: (field, schema, payload, buildSchemaOptions)=>{
+    email: (field, schema, payload, buildSchemaOptions, parentIsLocalized)=>{
         const baseSchema = {
-            ...formatBaseSchema(field, buildSchemaOptions),
+            ...formatBaseSchema({
+                buildSchemaOptions,
+                field,
+                parentIsLocalized
+            }),
             type: String
         };
         schema.add({
-            [field.name]: localizeSchema(field, baseSchema, payload.config.localization)
+            [field.name]: localizeSchema(field, baseSchema, payload.config.localization, parentIsLocalized)
         });
     },
-    group: (field, schema, payload, buildSchemaOptions)=>{
-        const formattedBaseSchema = formatBaseSchema(field, buildSchemaOptions);
+    group: (field, schema, payload, buildSchemaOptions, parentIsLocalized)=>{
+        const formattedBaseSchema = formatBaseSchema({
+            buildSchemaOptions,
+            field,
+            parentIsLocalized
+        });
         // carry indexSortableFields through to versions if drafts enabled
         const indexSortableFields = buildSchemaOptions.indexSortableFields && field.name === 'version' && buildSchemaOptions.draftsEnabled;
         const baseSchema = {
             ...formattedBaseSchema,
-            type: buildSchema(payload, field.fields, {
-                disableUnique: buildSchemaOptions.disableUnique,
-                draftsEnabled: buildSchemaOptions.draftsEnabled,
-                indexSortableFields,
-                options: {
-                    _id: false,
-                    id: false,
-                    minimize: false
-                }
+            type: buildSchema({
+                buildSchemaOptions: {
+                    disableUnique: buildSchemaOptions.disableUnique,
+                    draftsEnabled: buildSchemaOptions.draftsEnabled,
+                    indexSortableFields,
+                    options: {
+                        _id: false,
+                        id: false,
+                        minimize: false
+                    }
+                },
+                configFields: field.fields,
+                parentIsLocalized: parentIsLocalized || field.localized,
+                payload
             })
         };
         schema.add({
-            [field.name]: localizeSchema(field, baseSchema, payload.config.localization)
+            [field.name]: localizeSchema(field, baseSchema, payload.config.localization, parentIsLocalized)
         });
     },
-    json: (field, schema, payload, buildSchemaOptions)=>{
+    json: (field, schema, payload, buildSchemaOptions, parentIsLocalized)=>{
         const baseSchema = {
-            ...formatBaseSchema(field, buildSchemaOptions),
+            ...formatBaseSchema({
+                buildSchemaOptions,
+                field,
+                parentIsLocalized
+            }),
             type: mongoose.Schema.Types.Mixed
         };
         schema.add({
-            [field.name]: localizeSchema(field, baseSchema, payload.config.localization)
+            [field.name]: localizeSchema(field, baseSchema, payload.config.localization, parentIsLocalized)
         });
     },
-    number: (field, schema, payload, buildSchemaOptions)=>{
+    number: (field, schema, payload, buildSchemaOptions, parentIsLocalized)=>{
         const baseSchema = {
-            ...formatBaseSchema(field, buildSchemaOptions),
+            ...formatBaseSchema({
+                buildSchemaOptions,
+                field,
+                parentIsLocalized
+            }),
             type: field.hasMany ? [
                 Number
             ] : Number
         };
         schema.add({
-            [field.name]: localizeSchema(field, baseSchema, payload.config.localization)
+            [field.name]: localizeSchema(field, baseSchema, payload.config.localization, parentIsLocalized)
         });
     },
-    point: (field, schema, payload, buildSchemaOptions)=>{
+    point: (field, schema, payload, buildSchemaOptions, parentIsLocalized)=>{
         const baseSchema = {
             type: {
                 type: String,
@@ -223,11 +276,14 @@ const fieldToSchemaMap = {
                 required: false
             }
         };
-        if (buildSchemaOptions.disableUnique && field.unique && field.localized) {
+        if (buildSchemaOptions.disableUnique && field.unique && fieldShouldBeLocalized({
+            field,
+            parentIsLocalized
+        })) {
             baseSchema.coordinates.sparse = true;
         }
         schema.add({
-            [field.name]: localizeSchema(field, baseSchema, payload.config.localization)
+            [field.name]: localizeSchema(field, baseSchema, payload.config.localization, parentIsLocalized)
         });
         if (field.index === true || field.index === undefined) {
             const indexOptions = {};
@@ -235,7 +291,10 @@ const fieldToSchemaMap = {
                 indexOptions.sparse = true;
                 indexOptions.unique = true;
             }
-            if (field.localized && payload.config.localization) {
+            if (fieldShouldBeLocalized({
+                field,
+                parentIsLocalized
+            }) && payload.config.localization) {
                 payload.config.localization.locales.forEach((locale)=>{
                     schema.index({
                         [`${field.name}.${locale.code}`]: '2dsphere'
@@ -248,9 +307,13 @@ const fieldToSchemaMap = {
             }
         }
     },
-    radio: (field, schema, payload, buildSchemaOptions)=>{
+    radio: (field, schema, payload, buildSchemaOptions, parentIsLocalized)=>{
         const baseSchema = {
-            ...formatBaseSchema(field, buildSchemaOptions),
+            ...formatBaseSchema({
+                buildSchemaOptions,
+                field,
+                parentIsLocalized
+            }),
             type: String,
             enum: field.options.map((option)=>{
                 if (typeof option === 'object') {
@@ -260,20 +323,28 @@ const fieldToSchemaMap = {
             })
         };
         schema.add({
-            [field.name]: localizeSchema(field, baseSchema, payload.config.localization)
+            [field.name]: localizeSchema(field, baseSchema, payload.config.localization, parentIsLocalized)
         });
     },
-    relationship: (field, schema, payload, buildSchemaOptions)=>{
+    relationship: (field, schema, payload, buildSchemaOptions, parentIsLocalized)=>{
         const hasManyRelations = Array.isArray(field.relationTo);
         let schemaToReturn = {};
         const valueType = getRelationshipValueType(field, payload);
-        if (field.localized && payload.config.localization) {
+        if (fieldShouldBeLocalized({
+            field,
+            parentIsLocalized
+        }) && payload.config.localization) {
             schemaToReturn = {
+                _id: false,
                 type: payload.config.localization.localeCodes.reduce((locales, locale)=>{
                     let localeSchema = {};
                     if (hasManyRelations) {
                         localeSchema = {
-                            ...formatBaseSchema(field, buildSchemaOptions),
+                            ...formatBaseSchema({
+                                buildSchemaOptions,
+                                field,
+                                parentIsLocalized
+                            }),
                             _id: false,
                             type: mongoose.Schema.Types.Mixed,
                             relationTo: {
@@ -287,7 +358,11 @@ const fieldToSchemaMap = {
                         };
                     } else {
                         localeSchema = {
-                            ...formatBaseSchema(field, buildSchemaOptions),
+                            ...formatBaseSchema({
+                                buildSchemaOptions,
+                                field,
+                                parentIsLocalized
+                            }),
                             type: valueType,
                             ref: field.relationTo
                         };
@@ -306,7 +381,11 @@ const fieldToSchemaMap = {
             };
         } else if (hasManyRelations) {
             schemaToReturn = {
-                ...formatBaseSchema(field, buildSchemaOptions),
+                ...formatBaseSchema({
+                    buildSchemaOptions,
+                    field,
+                    parentIsLocalized
+                }),
                 _id: false,
                 type: mongoose.Schema.Types.Mixed,
                 relationTo: {
@@ -328,7 +407,11 @@ const fieldToSchemaMap = {
             }
         } else {
             schemaToReturn = {
-                ...formatBaseSchema(field, buildSchemaOptions),
+                ...formatBaseSchema({
+                    buildSchemaOptions,
+                    field,
+                    parentIsLocalized
+                }),
                 type: valueType,
                 ref: field.relationTo
             };
@@ -345,29 +428,37 @@ const fieldToSchemaMap = {
             [field.name]: schemaToReturn
         });
     },
-    richText: (field, schema, payload, buildSchemaOptions)=>{
+    richText: (field, schema, payload, buildSchemaOptions, parentIsLocalized)=>{
         const baseSchema = {
-            ...formatBaseSchema(field, buildSchemaOptions),
+            ...formatBaseSchema({
+                buildSchemaOptions,
+                field,
+                parentIsLocalized
+            }),
             type: mongoose.Schema.Types.Mixed
         };
         schema.add({
-            [field.name]: localizeSchema(field, baseSchema, payload.config.localization)
+            [field.name]: localizeSchema(field, baseSchema, payload.config.localization, parentIsLocalized)
         });
     },
-    row: (field, schema, payload, buildSchemaOptions)=>{
+    row: (field, schema, payload, buildSchemaOptions, parentIsLocalized)=>{
         field.fields.forEach((subField)=>{
             if (fieldIsVirtual(subField)) {
                 return;
             }
             const addFieldSchema = fieldToSchemaMap[subField.type];
             if (addFieldSchema) {
-                addFieldSchema(subField, schema, payload, buildSchemaOptions);
+                addFieldSchema(subField, schema, payload, buildSchemaOptions, parentIsLocalized);
             }
         });
     },
-    select: (field, schema, payload, buildSchemaOptions)=>{
+    select: (field, schema, payload, buildSchemaOptions, parentIsLocalized)=>{
         const baseSchema = {
-            ...formatBaseSchema(field, buildSchemaOptions),
+            ...formatBaseSchema({
+                buildSchemaOptions,
+                field,
+                parentIsLocalized
+            }),
             type: String,
             enum: field.options.map((option)=>{
                 if (typeof option === 'object') {
@@ -382,28 +473,33 @@ const fieldToSchemaMap = {
         schema.add({
             [field.name]: localizeSchema(field, field.hasMany ? [
                 baseSchema
-            ] : baseSchema, payload.config.localization)
+            ] : baseSchema, payload.config.localization, parentIsLocalized)
         });
     },
-    tabs: (field, schema, payload, buildSchemaOptions)=>{
+    tabs: (field, schema, payload, buildSchemaOptions, parentIsLocalized)=>{
         field.tabs.forEach((tab)=>{
             if (tabHasName(tab)) {
                 if (fieldIsVirtual(tab)) {
                     return;
                 }
                 const baseSchema = {
-                    type: buildSchema(payload, tab.fields, {
-                        disableUnique: buildSchemaOptions.disableUnique,
-                        draftsEnabled: buildSchemaOptions.draftsEnabled,
-                        options: {
-                            _id: false,
-                            id: false,
-                            minimize: false
-                        }
+                    type: buildSchema({
+                        buildSchemaOptions: {
+                            disableUnique: buildSchemaOptions.disableUnique,
+                            draftsEnabled: buildSchemaOptions.draftsEnabled,
+                            options: {
+                                _id: false,
+                                id: false,
+                                minimize: false
+                            }
+                        },
+                        configFields: tab.fields,
+                        parentIsLocalized: parentIsLocalized || tab.localized,
+                        payload
                     })
                 };
                 schema.add({
-                    [tab.name]: localizeSchema(tab, baseSchema, payload.config.localization)
+                    [tab.name]: localizeSchema(tab, baseSchema, payload.config.localization, parentIsLocalized)
                 });
             } else {
                 tab.fields.forEach((subField)=>{
@@ -412,43 +508,59 @@ const fieldToSchemaMap = {
                     }
                     const addFieldSchema = fieldToSchemaMap[subField.type];
                     if (addFieldSchema) {
-                        addFieldSchema(subField, schema, payload, buildSchemaOptions);
+                        addFieldSchema(subField, schema, payload, buildSchemaOptions, parentIsLocalized || tab.localized);
                     }
                 });
             }
         });
     },
-    text: (field, schema, payload, buildSchemaOptions)=>{
+    text: (field, schema, payload, buildSchemaOptions, parentIsLocalized)=>{
         const baseSchema = {
-            ...formatBaseSchema(field, buildSchemaOptions),
+            ...formatBaseSchema({
+                buildSchemaOptions,
+                field,
+                parentIsLocalized
+            }),
             type: field.hasMany ? [
                 String
             ] : String
         };
         schema.add({
-            [field.name]: localizeSchema(field, baseSchema, payload.config.localization)
+            [field.name]: localizeSchema(field, baseSchema, payload.config.localization, parentIsLocalized)
         });
     },
-    textarea: (field, schema, payload, buildSchemaOptions)=>{
+    textarea: (field, schema, payload, buildSchemaOptions, parentIsLocalized)=>{
         const baseSchema = {
-            ...formatBaseSchema(field, buildSchemaOptions),
+            ...formatBaseSchema({
+                buildSchemaOptions,
+                field,
+                parentIsLocalized
+            }),
             type: String
         };
         schema.add({
-            [field.name]: localizeSchema(field, baseSchema, payload.config.localization)
+            [field.name]: localizeSchema(field, baseSchema, payload.config.localization, parentIsLocalized)
         });
     },
-    upload: (field, schema, payload, buildSchemaOptions)=>{
+    upload: (field, schema, payload, buildSchemaOptions, parentIsLocalized)=>{
         const hasManyRelations = Array.isArray(field.relationTo);
         let schemaToReturn = {};
         const valueType = getRelationshipValueType(field, payload);
-        if (field.localized && payload.config.localization) {
+        if (fieldShouldBeLocalized({
+            field,
+            parentIsLocalized
+        }) && payload.config.localization) {
             schemaToReturn = {
+                _id: false,
                 type: payload.config.localization.localeCodes.reduce((locales, locale)=>{
                     let localeSchema = {};
                     if (hasManyRelations) {
                         localeSchema = {
-                            ...formatBaseSchema(field, buildSchemaOptions),
+                            ...formatBaseSchema({
+                                buildSchemaOptions,
+                                field,
+                                parentIsLocalized
+                            }),
                             _id: false,
                             type: mongoose.Schema.Types.Mixed,
                             relationTo: {
@@ -462,7 +574,11 @@ const fieldToSchemaMap = {
                         };
                     } else {
                         localeSchema = {
-                            ...formatBaseSchema(field, buildSchemaOptions),
+                            ...formatBaseSchema({
+                                buildSchemaOptions,
+                                field,
+                                parentIsLocalized
+                            }),
                             type: valueType,
                             ref: field.relationTo
                         };
@@ -481,7 +597,11 @@ const fieldToSchemaMap = {
             };
         } else if (hasManyRelations) {
             schemaToReturn = {
-                ...formatBaseSchema(field, buildSchemaOptions),
+                ...formatBaseSchema({
+                    buildSchemaOptions,
+                    field,
+                    parentIsLocalized
+                }),
                 _id: false,
                 type: mongoose.Schema.Types.Mixed,
                 relationTo: {
@@ -503,7 +623,11 @@ const fieldToSchemaMap = {
             }
         } else {
             schemaToReturn = {
-                ...formatBaseSchema(field, buildSchemaOptions),
+                ...formatBaseSchema({
+                    buildSchemaOptions,
+                    field,
+                    parentIsLocalized
+                }),
                 type: valueType,
                 ref: field.relationTo
             };