@payloadcms/db-mongodb 3.0.0-canary.b750ebf → 3.0.0-canary.b8c9483

package/dist/models/buildSchema.js

@@ -1,8 +1,13 @@
 import mongoose from 'mongoose';
-import { fieldAffectsData, fieldIsLocalized, fieldIsPresentationalOnly, tabHasName } from 'payload/shared';
+import { fieldAffectsData, fieldIsLocalized, fieldIsPresentationalOnly, fieldIsVirtual, 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 { disableUnique, draftsEnabled, indexSortableFields } = buildSchemaOptions;
     const schema = {
+        default: formatDefaultValue(field),
         index: field.index || !disableUnique && field.unique || indexSortableFields || false,
         required: false,
         unique: !disableUnique && field.unique || false
@@ -29,7 +34,7 @@ const localizeSchema = (entity, schema, localization)=>{
     }
     return schema;
 };
-const buildSchema = (config, configFields, buildSchemaOptions = {})=>{
+export const buildSchema = (payload, configFields, buildSchemaOptions = {})=>{
     const { allowIDField, options } = buildSchemaOptions;
     let fields = {};
     let schemaFields = configFields;
@@ -44,21 +49,24 @@ const buildSchema = (config, configFields, buildSchemaOptions = {})=>{
     }
     const schema = new mongoose.Schema(fields, options);
     schemaFields.forEach((field)=>{
+        if (fieldIsVirtual(field)) {
+            return;
+        }
         if (!fieldIsPresentationalOnly(field)) {
             const addFieldSchema = fieldToSchemaMap[field.type];
             if (addFieldSchema) {
-                addFieldSchema(field, schema, config, buildSchemaOptions);
+                addFieldSchema(field, schema, payload, buildSchemaOptions);
             }
         }
     });
     return schema;
 };
 const fieldToSchemaMap = {
-    array: (field, schema, config, buildSchemaOptions)=>{
+    array: (field, schema, payload, buildSchemaOptions)=>{
         const baseSchema = {
             ...formatBaseSchema(field, buildSchemaOptions),
             type: [
-                buildSchema(config, field.fields, {
+                buildSchema(payload, field.fields, {
                     allowIDField: true,
                     disableUnique: buildSchemaOptions.disableUnique,
                     draftsEnabled: buildSchemaOptions.draftsEnabled,
@@ -68,25 +76,23 @@ const fieldToSchemaMap = {
                         minimize: false
                     }
                 })
-            ],
-            default: undefined
+            ]
         };
         schema.add({
-            [field.name]: localizeSchema(field, baseSchema, config.localization)
+            [field.name]: localizeSchema(field, baseSchema, payload.config.localization)
         });
     },
-    blocks: (field, schema, config, buildSchemaOptions)=>{
+    blocks: (field, schema, payload, buildSchemaOptions)=>{
         const fieldSchema = {
             type: [
                 new mongoose.Schema({}, {
                     _id: false,
                     discriminatorKey: 'blockType'
                 })
-            ],
-            default: undefined
+            ]
         };
         schema.add({
-            [field.name]: localizeSchema(field, fieldSchema, config.localization)
+            [field.name]: localizeSchema(field, fieldSchema, payload.config.localization)
         });
         field.blocks.forEach((blockItem)=>{
             const blockSchema = new mongoose.Schema({}, {
@@ -96,11 +102,11 @@ const fieldToSchemaMap = {
             blockItem.fields.forEach((blockField)=>{
                 const addFieldSchema = fieldToSchemaMap[blockField.type];
                 if (addFieldSchema) {
-                    addFieldSchema(blockField, blockSchema, config, buildSchemaOptions);
+                    addFieldSchema(blockField, blockSchema, payload, buildSchemaOptions);
                 }
             });
-            if (field.localized && config.localization) {
-                config.localization.localeCodes.forEach((localeCode)=>{
+            if (field.localized && 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);
                 });
@@ -110,57 +116,60 @@ const fieldToSchemaMap = {
             }
         });
     },
-    checkbox: (field, schema, config, buildSchemaOptions)=>{
+    checkbox: (field, schema, payload, buildSchemaOptions)=>{
         const baseSchema = {
             ...formatBaseSchema(field, buildSchemaOptions),
             type: Boolean
         };
         schema.add({
-            [field.name]: localizeSchema(field, baseSchema, config.localization)
+            [field.name]: localizeSchema(field, baseSchema, payload.config.localization)
         });
     },
-    code: (field, schema, config, buildSchemaOptions)=>{
+    code: (field, schema, payload, buildSchemaOptions)=>{
         const baseSchema = {
             ...formatBaseSchema(field, buildSchemaOptions),
             type: String
         };
         schema.add({
-            [field.name]: localizeSchema(field, baseSchema, config.localization)
+            [field.name]: localizeSchema(field, baseSchema, payload.config.localization)
         });
     },
-    collapsible: (field, schema, config, buildSchemaOptions)=>{
+    collapsible: (field, schema, payload, buildSchemaOptions)=>{
         field.fields.forEach((subField)=>{
+            if (fieldIsVirtual(subField)) {
+                return;
+            }
             const addFieldSchema = fieldToSchemaMap[subField.type];
             if (addFieldSchema) {
-                addFieldSchema(subField, schema, config, buildSchemaOptions);
+                addFieldSchema(subField, schema, payload, buildSchemaOptions);
             }
         });
     },
-    date: (field, schema, config, buildSchemaOptions)=>{
+    date: (field, schema, payload, buildSchemaOptions)=>{
         const baseSchema = {
             ...formatBaseSchema(field, buildSchemaOptions),
             type: Date
         };
         schema.add({
-            [field.name]: localizeSchema(field, baseSchema, config.localization)
+            [field.name]: localizeSchema(field, baseSchema, payload.config.localization)
         });
     },
-    email: (field, schema, config, buildSchemaOptions)=>{
+    email: (field, schema, payload, buildSchemaOptions)=>{
         const baseSchema = {
             ...formatBaseSchema(field, buildSchemaOptions),
             type: String
         };
         schema.add({
-            [field.name]: localizeSchema(field, baseSchema, config.localization)
+            [field.name]: localizeSchema(field, baseSchema, payload.config.localization)
         });
     },
-    group: (field, schema, config, buildSchemaOptions)=>{
+    group: (field, schema, payload, 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, {
+            type: buildSchema(payload, field.fields, {
                 disableUnique: buildSchemaOptions.disableUnique,
                 draftsEnabled: buildSchemaOptions.draftsEnabled,
                 indexSortableFields,
@@ -172,19 +181,19 @@ const fieldToSchemaMap = {
             })
         };
         schema.add({
-            [field.name]: localizeSchema(field, baseSchema, config.localization)
+            [field.name]: localizeSchema(field, baseSchema, payload.config.localization)
         });
     },
-    json: (field, schema, config, buildSchemaOptions)=>{
+    json: (field, schema, payload, buildSchemaOptions)=>{
         const baseSchema = {
             ...formatBaseSchema(field, buildSchemaOptions),
             type: mongoose.Schema.Types.Mixed
         };
         schema.add({
-            [field.name]: localizeSchema(field, baseSchema, config.localization)
+            [field.name]: localizeSchema(field, baseSchema, payload.config.localization)
         });
     },
-    number: (field, schema, config, buildSchemaOptions)=>{
+    number: (field, schema, payload, buildSchemaOptions)=>{
         const baseSchema = {
             ...formatBaseSchema(field, buildSchemaOptions),
             type: field.hasMany ? [
@@ -192,22 +201,25 @@ const fieldToSchemaMap = {
             ] : Number
         };
         schema.add({
-            [field.name]: localizeSchema(field, baseSchema, config.localization)
+            [field.name]: localizeSchema(field, baseSchema, payload.config.localization)
         });
     },
-    point: (field, schema, config, buildSchemaOptions)=>{
+    point: (field, schema, payload, buildSchemaOptions)=>{
         const baseSchema = {
             type: {
                 type: String,
                 enum: [
                     'Point'
-                ]
+                ],
+                ...typeof field.defaultValue !== 'undefined' && {
+                    default: 'Point'
+                }
             },
             coordinates: {
                 type: [
                     Number
                 ],
-                default: field.defaultValue || undefined,
+                default: formatDefaultValue(field),
                 required: false
             }
         };
@@ -215,7 +227,7 @@ const fieldToSchemaMap = {
             baseSchema.coordinates.sparse = true;
         }
         schema.add({
-            [field.name]: localizeSchema(field, baseSchema, config.localization)
+            [field.name]: localizeSchema(field, baseSchema, payload.config.localization)
         });
         if (field.index === true || field.index === undefined) {
             const indexOptions = {};
@@ -223,8 +235,8 @@ const fieldToSchemaMap = {
                 indexOptions.sparse = true;
                 indexOptions.unique = true;
             }
-            if (field.localized && config.localization) {
-                config.localization.locales.forEach((locale)=>{
+            if (field.localized && payload.config.localization) {
+                payload.config.localization.locales.forEach((locale)=>{
                     schema.index({
                         [`${field.name}.${locale.code}`]: '2dsphere'
                     }, indexOptions);
@@ -236,25 +248,28 @@ const fieldToSchemaMap = {
             }
         }
     },
-    radio: (field, schema, config, buildSchemaOptions)=>{
+    radio: (field, schema, payload, buildSchemaOptions)=>{
         const baseSchema = {
             ...formatBaseSchema(field, buildSchemaOptions),
             type: String,
             enum: field.options.map((option)=>{
-                if (typeof option === 'object') return option.value;
+                if (typeof option === 'object') {
+                    return option.value;
+                }
                 return option;
             })
         };
         schema.add({
-            [field.name]: localizeSchema(field, baseSchema, config.localization)
+            [field.name]: localizeSchema(field, baseSchema, payload.config.localization)
         });
     },
-    relationship: (field, schema, config, buildSchemaOptions)=>{
+    relationship: (field, schema, payload, buildSchemaOptions)=>{
         const hasManyRelations = Array.isArray(field.relationTo);
         let schemaToReturn = {};
-        if (field.localized && config.localization) {
+        const valueType = getRelationshipValueType(field, payload);
+        if (field.localized && payload.config.localization) {
             schemaToReturn = {
-                type: config.localization.localeCodes.reduce((locales, locale)=>{
+                type: payload.config.localization.localeCodes.reduce((locales, locale)=>{
                     let localeSchema = {};
                     if (hasManyRelations) {
                         localeSchema = {
@@ -266,14 +281,14 @@ const fieldToSchemaMap = {
                                 enum: field.relationTo
                             },
                             value: {
-                                type: mongoose.Schema.Types.Mixed,
+                                type: valueType,
                                 refPath: `${field.name}.${locale}.relationTo`
                             }
                         };
                     } else {
                         localeSchema = {
                             ...formatBaseSchema(field, buildSchemaOptions),
-                            type: mongoose.Schema.Types.Mixed,
+                            type: valueType,
                             ref: field.relationTo
                         };
                     }
@@ -283,7 +298,7 @@ const fieldToSchemaMap = {
                             type: [
                                 localeSchema
                             ],
-                            default: undefined
+                            default: formatDefaultValue(field)
                         } : localeSchema
                     };
                 }, {}),
@@ -299,7 +314,7 @@ const fieldToSchemaMap = {
                     enum: field.relationTo
                 },
                 value: {
-                    type: mongoose.Schema.Types.Mixed,
+                    type: valueType,
                     refPath: `${field.name}.relationTo`
                 }
             };
@@ -308,13 +323,13 @@ const fieldToSchemaMap = {
                     type: [
                         schemaToReturn
                     ],
-                    default: undefined
+                    default: formatDefaultValue(field)
                 };
             }
         } else {
             schemaToReturn = {
                 ...formatBaseSchema(field, buildSchemaOptions),
-                type: mongoose.Schema.Types.Mixed,
+                type: valueType,
                 ref: field.relationTo
             };
             if (field.hasMany) {
@@ -322,7 +337,7 @@ const fieldToSchemaMap = {
                     type: [
                         schemaToReturn
                     ],
-                    default: undefined
+                    default: formatDefaultValue(field)
                 };
             }
         }
@@ -330,29 +345,34 @@ const fieldToSchemaMap = {
             [field.name]: schemaToReturn
         });
     },
-    richText: (field, schema, config, buildSchemaOptions)=>{
+    richText: (field, schema, payload, buildSchemaOptions)=>{
         const baseSchema = {
             ...formatBaseSchema(field, buildSchemaOptions),
             type: mongoose.Schema.Types.Mixed
         };
         schema.add({
-            [field.name]: localizeSchema(field, baseSchema, config.localization)
+            [field.name]: localizeSchema(field, baseSchema, payload.config.localization)
         });
     },
-    row: (field, schema, config, buildSchemaOptions)=>{
+    row: (field, schema, payload, buildSchemaOptions)=>{
         field.fields.forEach((subField)=>{
+            if (fieldIsVirtual(subField)) {
+                return;
+            }
             const addFieldSchema = fieldToSchemaMap[subField.type];
             if (addFieldSchema) {
-                addFieldSchema(subField, schema, config, buildSchemaOptions);
+                addFieldSchema(subField, schema, payload, buildSchemaOptions);
             }
         });
     },
-    select: (field, schema, config, buildSchemaOptions)=>{
+    select: (field, schema, payload, buildSchemaOptions)=>{
         const baseSchema = {
             ...formatBaseSchema(field, buildSchemaOptions),
             type: String,
             enum: field.options.map((option)=>{
-                if (typeof option === 'object') return option.value;
+                if (typeof option === 'object') {
+                    return option.value;
+                }
                 return option;
             })
         };
@@ -362,14 +382,17 @@ const fieldToSchemaMap = {
         schema.add({
             [field.name]: localizeSchema(field, field.hasMany ? [
                 baseSchema
-            ] : baseSchema, config.localization)
+            ] : baseSchema, payload.config.localization)
         });
     },
-    tabs: (field, schema, config, buildSchemaOptions)=>{
+    tabs: (field, schema, payload, buildSchemaOptions)=>{
         field.tabs.forEach((tab)=>{
             if (tabHasName(tab)) {
+                if (fieldIsVirtual(tab)) {
+                    return;
+                }
                 const baseSchema = {
-                    type: buildSchema(config, tab.fields, {
+                    type: buildSchema(payload, tab.fields, {
                         disableUnique: buildSchemaOptions.disableUnique,
                         draftsEnabled: buildSchemaOptions.draftsEnabled,
                         options: {
@@ -380,19 +403,22 @@ const fieldToSchemaMap = {
                     })
                 };
                 schema.add({
-                    [tab.name]: localizeSchema(tab, baseSchema, config.localization)
+                    [tab.name]: localizeSchema(tab, baseSchema, payload.config.localization)
                 });
             } else {
                 tab.fields.forEach((subField)=>{
+                    if (fieldIsVirtual(subField)) {
+                        return;
+                    }
                     const addFieldSchema = fieldToSchemaMap[subField.type];
                     if (addFieldSchema) {
-                        addFieldSchema(subField, schema, config, buildSchemaOptions);
+                        addFieldSchema(subField, schema, payload, buildSchemaOptions);
                     }
                 });
             }
         });
     },
-    text: (field, schema, config, buildSchemaOptions)=>{
+    text: (field, schema, payload, buildSchemaOptions)=>{
         const baseSchema = {
             ...formatBaseSchema(field, buildSchemaOptions),
             type: field.hasMany ? [
@@ -400,29 +426,119 @@ const fieldToSchemaMap = {
             ] : String
         };
         schema.add({
-            [field.name]: localizeSchema(field, baseSchema, config.localization)
+            [field.name]: localizeSchema(field, baseSchema, payload.config.localization)
         });
     },
-    textarea: (field, schema, config, buildSchemaOptions)=>{
+    textarea: (field, schema, payload, buildSchemaOptions)=>{
         const baseSchema = {
             ...formatBaseSchema(field, buildSchemaOptions),
             type: String
         };
         schema.add({
-            [field.name]: localizeSchema(field, baseSchema, config.localization)
+            [field.name]: localizeSchema(field, baseSchema, payload.config.localization)
         });
     },
-    upload: (field, schema, config, buildSchemaOptions)=>{
-        const baseSchema = {
-            ...formatBaseSchema(field, buildSchemaOptions),
-            type: mongoose.Schema.Types.Mixed,
-            ref: field.relationTo
-        };
+    upload: (field, schema, payload, buildSchemaOptions)=>{
+        const hasManyRelations = Array.isArray(field.relationTo);
+        let schemaToReturn = {};
+        const valueType = getRelationshipValueType(field, payload);
+        if (field.localized && payload.config.localization) {
+            schemaToReturn = {
+                type: payload.config.localization.localeCodes.reduce((locales, locale)=>{
+                    let localeSchema = {};
+                    if (hasManyRelations) {
+                        localeSchema = {
+                            ...formatBaseSchema(field, buildSchemaOptions),
+                            _id: false,
+                            type: mongoose.Schema.Types.Mixed,
+                            relationTo: {
+                                type: String,
+                                enum: field.relationTo
+                            },
+                            value: {
+                                type: valueType,
+                                refPath: `${field.name}.${locale}.relationTo`
+                            }
+                        };
+                    } else {
+                        localeSchema = {
+                            ...formatBaseSchema(field, buildSchemaOptions),
+                            type: valueType,
+                            ref: field.relationTo
+                        };
+                    }
+                    return {
+                        ...locales,
+                        [locale]: field.hasMany ? {
+                            type: [
+                                localeSchema
+                            ],
+                            default: formatDefaultValue(field)
+                        } : localeSchema
+                    };
+                }, {}),
+                localized: true
+            };
+        } else if (hasManyRelations) {
+            schemaToReturn = {
+                ...formatBaseSchema(field, buildSchemaOptions),
+                _id: false,
+                type: mongoose.Schema.Types.Mixed,
+                relationTo: {
+                    type: String,
+                    enum: field.relationTo
+                },
+                value: {
+                    type: valueType,
+                    refPath: `${field.name}.relationTo`
+                }
+            };
+            if (field.hasMany) {
+                schemaToReturn = {
+                    type: [
+                        schemaToReturn
+                    ],
+                    default: formatDefaultValue(field)
+                };
+            }
+        } else {
+            schemaToReturn = {
+                ...formatBaseSchema(field, buildSchemaOptions),
+                type: valueType,
+                ref: field.relationTo
+            };
+            if (field.hasMany) {
+                schemaToReturn = {
+                    type: [
+                        schemaToReturn
+                    ],
+                    default: formatDefaultValue(field)
+                };
+            }
+        }
         schema.add({
-            [field.name]: localizeSchema(field, baseSchema, config.localization)
+            [field.name]: schemaToReturn
         });
     }
 };
-export default buildSchema;
+const getRelationshipValueType = (field, payload)=>{
+    if (typeof field.relationTo === 'string') {
+        const { customIDType } = payload.collections[field.relationTo];
+        if (!customIDType) {
+            return mongoose.Schema.Types.ObjectId;
+        }
+        if (customIDType === 'number') {
+            return mongoose.Schema.Types.Number;
+        }
+        return mongoose.Schema.Types.String;
+    }
+    // has custom id relationTo
+    if (field.relationTo.some((relationTo)=>{
+        return !!payload.collections[relationTo].customIDType;
+    })) {
+        return mongoose.Schema.Types.Mixed;
+    }
+    return mongoose.Schema.Types.ObjectId;
+};
 
 //# sourceMappingURL=buildSchema.js.map