@stackbit/cms-core 0.0.19-alpha.0 → 0.0.19-alpha.1

package/dist/content-store.js

@@ -920,26 +920,27 @@ function mapCSIDocumentToStoreDocument({ csiDocument, model, modelMap, defaultLo
         fields: mapCSIFieldsToStoreFields({
             csiDocumentFields: csiDocument.fields,
             modelFields: (_b = model.fields) !== null && _b !== void 0 ? _b : [],
-            modelMap,
-            defaultLocaleCode
+            context: {
+                modelMap,
+                defaultLocaleCode
+            }
         })
     };
 }
-function mapCSIFieldsToStoreFields({ csiDocumentFields, modelFields, modelMap, defaultLocaleCode }) {
+function mapCSIFieldsToStoreFields({ csiDocumentFields, modelFields, context }) {
     return modelFields.reduce((result, modelField) => {
         const csiDocumentField = csiDocumentFields[modelField.name];
-        const docField = mapSourceFieldToStoreField({
+        const docField = mapCSIFieldToStoreField({
             csiDocumentField,
             modelField,
-            modelMap,
-            defaultLocaleCode
+            context
         });
         docField.label = modelField.label;
         result[modelField.name] = docField;
         return result;
     }, {});
 }
-function mapSourceFieldToStoreField({ csiDocumentField, modelField, modelMap, defaultLocaleCode }) {
+function mapCSIFieldToStoreField({ csiDocumentField, modelField, context }) {
     if (!csiDocumentField) {
         const isUnset = ['object', 'model', 'reference', 'richText', 'markdown', 'image', 'file', 'json'].includes(modelField.type);
         return {
@@ -951,11 +952,11 @@ function mapSourceFieldToStoreField({ csiDocumentField, modelField, modelMap, de
     // TODO: check if need to add "options" to "enum" and subtype/min/max to "number"
     switch (modelField.type) {
         case 'object':
-            return mapObjectField(csiDocumentField, modelField, modelMap, defaultLocaleCode);
+            return mapObjectField(csiDocumentField, modelField, context);
         case 'model':
-            return mapModelField(csiDocumentField, modelField, modelMap, defaultLocaleCode);
+            return mapModelField(csiDocumentField, modelField, context);
         case 'list':
-            return mapListField(csiDocumentField, modelField, modelMap, defaultLocaleCode);
+            return mapListField(csiDocumentField, modelField, context);
         case 'richText':
             return mapRichTextField(csiDocumentField);
         case 'markdown':
@@ -964,17 +965,16 @@ function mapSourceFieldToStoreField({ csiDocumentField, modelField, modelMap, de
             return csiDocumentField;
     }
 }
-function mapObjectField(csiDocumentField, modelField, modelMap, defaultLocaleCode) {
+function mapObjectField(csiDocumentField, modelField, context) {
     var _a, _b, _c;
     if (!(0, content_source_interface_1.isLocalizedField)(csiDocumentField)) {
         return {
             type: csiDocumentField.type,
-            srcObjectLabel: getObjectLabel((_a = csiDocumentField.fields) !== null && _a !== void 0 ? _a : {}, modelField !== null && modelField !== void 0 ? modelField : [], defaultLocaleCode),
+            srcObjectLabel: getObjectLabel((_a = csiDocumentField.fields) !== null && _a !== void 0 ? _a : {}, modelField !== null && modelField !== void 0 ? modelField : [], context.defaultLocaleCode),
             fields: mapCSIFieldsToStoreFields({
                 csiDocumentFields: (_b = csiDocumentField.fields) !== null && _b !== void 0 ? _b : {},
                 modelFields: (_c = modelField.fields) !== null && _c !== void 0 ? _c : [],
-                modelMap,
-                defaultLocaleCode
+                context
             })
         };
     }
@@ -989,27 +989,25 @@ function mapObjectField(csiDocumentField, modelField, modelMap, defaultLocaleCod
                 fields: mapCSIFieldsToStoreFields({
                     csiDocumentFields: (_b = locale.fields) !== null && _b !== void 0 ? _b : {},
                     modelFields: (_c = modelField.fields) !== null && _c !== void 0 ? _c : [],
-                    modelMap,
-                    defaultLocaleCode
+                    context
                 })
             };
         })
     };
 }
-function mapModelField(csiDocumentField, modelField, modelMap, defaultLocaleCode) {
+function mapModelField(csiDocumentField, modelField, context) {
     var _a, _b, _c, _d;
     if (!(0, content_source_interface_1.isLocalizedField)(csiDocumentField)) {
-        const model = modelMap[csiDocumentField.modelName];
+        const model = context.modelMap[csiDocumentField.modelName];
         return {
             type: csiDocumentField.type,
-            srcObjectLabel: getObjectLabel((_a = csiDocumentField.fields) !== null && _a !== void 0 ? _a : {}, model, defaultLocaleCode),
+            srcObjectLabel: getObjectLabel((_a = csiDocumentField.fields) !== null && _a !== void 0 ? _a : {}, model, context.defaultLocaleCode),
             srcModelName: csiDocumentField.modelName,
             srcModelLabel: (_b = model.label) !== null && _b !== void 0 ? _b : lodash_1.default.startCase(model.name),
             fields: mapCSIFieldsToStoreFields({
                 csiDocumentFields: (_c = csiDocumentField.fields) !== null && _c !== void 0 ? _c : {},
                 modelFields: (_d = model.fields) !== null && _d !== void 0 ? _d : [],
-                modelMap,
-                defaultLocaleCode
+                context
             })
         };
     }
@@ -1018,7 +1016,7 @@ function mapModelField(csiDocumentField, modelField, modelMap, defaultLocaleCode
         localized: true,
         locales: lodash_1.default.mapValues(csiDocumentField.locales, (locale) => {
             var _a, _b, _c, _d;
-            const model = modelMap[locale.modelName];
+            const model = context.modelMap[locale.modelName];
             return {
                 locale: locale.locale,
                 srcObjectLabel: getObjectLabel((_a = locale.fields) !== null && _a !== void 0 ? _a : {}, model, locale.locale),
@@ -1027,24 +1025,22 @@ function mapModelField(csiDocumentField, modelField, modelMap, defaultLocaleCode
                 fields: mapCSIFieldsToStoreFields({
                     csiDocumentFields: (_c = locale.fields) !== null && _c !== void 0 ? _c : {},
                     modelFields: (_d = model.fields) !== null && _d !== void 0 ? _d : [],
-                    modelMap,
-                    defaultLocaleCode
+                    context
                 })
             };
         })
     };
 }
-function mapListField(csiDocumentField, modelField, modelMap, defaultLocaleCode) {
+function mapListField(csiDocumentField, modelField, context) {
     if (!(0, content_source_interface_1.isLocalizedField)(csiDocumentField)) {
         return {
             type: csiDocumentField.type,
             items: csiDocumentField.items.map((item) => {
                 var _a;
-                return mapSourceFieldToStoreField({
+                return mapCSIFieldToStoreField({
                     csiDocumentField: item,
                     modelField: (_a = modelField.items) !== null && _a !== void 0 ? _a : { type: 'string' },
-                    modelMap,
-                    defaultLocaleCode
+                    context
                 });
             })
         };
@@ -1058,11 +1054,10 @@ function mapListField(csiDocumentField, modelField, modelMap, defaultLocaleCode)
                 locale: locale.locale,
                 items: ((_a = locale.items) !== null && _a !== void 0 ? _a : []).map((item) => {
                     var _a;
-                    return mapSourceFieldToStoreField({
+                    return mapCSIFieldToStoreField({
                         csiDocumentField: item,
                         modelField: (_a = modelField.items) !== null && _a !== void 0 ? _a : { type: 'string' },
-                        modelMap,
-                        defaultLocaleCode
+                        context
                     });
                 })
             };
@@ -1322,192 +1317,200 @@ async function createDocumentRecursively({ object, model, modelMap, locale, user
     };
 }
 async function createNestedObjectRecursively({ object, modelFields, fieldPath, modelMap, locale, userContext, contentSourceInstance }) {
-    const createNestedField = async ({ value, modelField, fieldPath }) => {
-        var _a;
-        if (modelField.type === 'object') {
-            const result = await createNestedObjectRecursively({
-                object: value,
-                modelFields: modelField.fields,
-                fieldPath,
+    object = object !== null && object !== void 0 ? object : {};
+    const result = {
+        fields: {},
+        newRefDocuments: []
+    };
+    const objectFieldNames = Object.keys(object);
+    for (const modelField of modelFields) {
+        const fieldName = modelField.name;
+        let value;
+        if (fieldName in object) {
+            value = object[fieldName];
+            lodash_1.default.pull(objectFieldNames, fieldName);
+        }
+        else if (modelField.const) {
+            value = modelField.const;
+        }
+        else if (!lodash_1.default.isNil(modelField.default)) {
+            value = modelField.default;
+        }
+        if (!lodash_1.default.isNil(value)) {
+            const fieldResult = await createNestedField({
+                value,
+                modelField,
+                fieldPath: fieldPath.concat(fieldName),
                 modelMap,
                 locale,
                 userContext,
                 contentSourceInstance
             });
+            result.fields[fieldName] = fieldResult.field;
+            result.newRefDocuments = result.newRefDocuments.concat(fieldResult.newRefDocuments);
+        }
+    }
+    if (objectFieldNames.length > 0) {
+        throw new Error(`no model fields found when creating a document with fields: '${objectFieldNames.join(', ')}'`);
+    }
+    return result;
+}
+async function createNestedField({ value, modelField, fieldPath, modelMap, locale, userContext, contentSourceInstance }) {
+    var _a;
+    if (modelField.type === 'object') {
+        const result = await createNestedObjectRecursively({
+            object: value,
+            modelFields: modelField.fields,
+            fieldPath,
+            modelMap,
+            locale,
+            userContext,
+            contentSourceInstance
+        });
+        return {
+            field: {
+                type: 'object',
+                fields: result.fields
+            },
+            newRefDocuments: result.newRefDocuments
+        };
+    }
+    else if (modelField.type === 'model') {
+        let { $$type, ...rest } = value;
+        const modelNames = modelField.models;
+        // for backward compatibility check if the object has 'type' instead of '$$type' because older projects use
+        // the 'type' property in default values
+        if (!$$type && 'type' in rest) {
+            $$type = rest.type;
+            rest = lodash_1.default.omit(rest, 'type');
+        }
+        const modelName = $$type !== null && $$type !== void 0 ? $$type : (modelNames.length === 1 ? modelNames[0] : null);
+        if (!modelName) {
+            throw new Error(`no $$type was specified for nested model`);
+        }
+        const model = modelMap[modelName];
+        if (!model) {
+            throw new Error(`no model with name '${modelName}' was found`);
+        }
+        const result = await createNestedObjectRecursively({
+            object: rest,
+            modelFields: (_a = model.fields) !== null && _a !== void 0 ? _a : [],
+            fieldPath,
+            modelMap,
+            locale,
+            userContext,
+            contentSourceInstance
+        });
+        return {
+            field: {
+                type: 'model',
+                modelName: modelName,
+                fields: result.fields
+            },
+            newRefDocuments: result.newRefDocuments
+        };
+    }
+    else if (modelField.type === 'image') {
+        let refId;
+        if (lodash_1.default.isPlainObject(value)) {
+            refId = value.$$ref;
+        }
+        else {
+            refId = value;
+        }
+        if (!refId) {
+            throw new Error(`reference field must specify a value`);
+        }
+        return {
+            field: {
+                type: 'reference',
+                refType: 'asset',
+                refId: refId
+            },
+            newRefDocuments: []
+        };
+    }
+    else if (modelField.type === 'reference') {
+        let { $$ref: refId = null, $$type: modelName = null, ...rest } = lodash_1.default.isPlainObject(value) ? value : { $$ref: value };
+        if (refId) {
             return {
                 field: {
-                    type: 'object',
-                    fields: result.fields
+                    type: 'reference',
+                    refType: 'document',
+                    refId: refId
                 },
-                newRefDocuments: result.newRefDocuments
+                newRefDocuments: []
             };
         }
-        else if (modelField.type === 'model') {
-            let { $$type, ...rest } = value;
+        else {
             const modelNames = modelField.models;
-            // for backward compatibility check if the object has 'type' instead of '$$type' because older projects use
-            // the 'type' property in default values
-            if (!$$type && 'type' in rest) {
-                $$type = rest.type;
-                rest = lodash_1.default.omit(rest, 'type');
-            }
-            const modelName = $$type !== null && $$type !== void 0 ? $$type : (modelNames.length === 1 ? modelNames[0] : null);
             if (!modelName) {
-                throw new Error(`no $$type was specified for nested model`);
+                // for backward compatibility check if the object has 'type' instead of '$$type' because older projects use
+                // the 'type' property in default values
+                if ('type' in rest) {
+                    modelName = rest.type;
+                    rest = lodash_1.default.omit(rest, 'type');
+                }
+                else if (modelNames.length === 1) {
+                    modelName = modelNames[0];
+                }
             }
             const model = modelMap[modelName];
             if (!model) {
                 throw new Error(`no model with name '${modelName}' was found`);
             }
-            const result = await createNestedObjectRecursively({
+            const { document, newRefDocuments } = await createDocumentRecursively({
                 object: rest,
-                modelFields: (_a = model.fields) !== null && _a !== void 0 ? _a : [],
-                fieldPath,
+                model: model,
                 modelMap,
                 locale,
                 userContext,
                 contentSourceInstance
             });
-            return {
-                field: {
-                    type: 'model',
-                    modelName: modelName,
-                    fields: result.fields
-                },
-                newRefDocuments: result.newRefDocuments
-            };
-        }
-        else if (modelField.type === 'image') {
-            let refId;
-            if (lodash_1.default.isPlainObject(value)) {
-                refId = value.$$ref;
-            }
-            else {
-                refId = value;
-            }
-            if (!refId) {
-                throw new Error(`reference field must specify a value`);
-            }
             return {
                 field: {
                     type: 'reference',
-                    refType: 'asset',
-                    refId: refId
+                    refType: 'document',
+                    refId: document.id
                 },
-                newRefDocuments: []
+                newRefDocuments: [document, ...newRefDocuments]
             };
         }
-        else if (modelField.type === 'reference') {
-            let { $$ref: refId = null, $$type: modelName = null, ...rest } = lodash_1.default.isPlainObject(value) ? value : { $$ref: value };
-            if (refId) {
-                return {
-                    field: {
-                        type: 'reference',
-                        refType: 'document',
-                        refId: refId
-                    },
-                    newRefDocuments: []
-                };
-            }
-            else {
-                const modelNames = modelField.models;
-                if (!modelName) {
-                    // for backward compatibility check if the object has 'type' instead of '$$type' because older projects use
-                    // the 'type' property in default values
-                    if ('type' in rest) {
-                        modelName = rest.type;
-                        rest = lodash_1.default.omit(rest, 'type');
-                    }
-                    else if (modelNames.length === 1) {
-                        modelName = modelNames[0];
-                    }
-                }
-                const model = modelMap[modelName];
-                if (!model) {
-                    throw new Error(`no model with name '${modelName}' was found`);
-                }
-                const { document, newRefDocuments } = await createDocumentRecursively({
-                    object: rest,
-                    model: model,
-                    modelMap,
-                    locale,
-                    userContext,
-                    contentSourceInstance
-                });
-                return {
-                    field: {
-                        type: 'reference',
-                        refType: 'document',
-                        refId: document.id
-                    },
-                    newRefDocuments: [document, ...newRefDocuments]
-                };
-            }
+    }
+    else if (modelField.type === 'list') {
+        if (!Array.isArray(value)) {
+            throw new Error(`value for list field must be array`);
         }
-        else if (modelField.type === 'list') {
-            if (!Array.isArray(value)) {
-                throw new Error(`value for list field must be array`);
-            }
-            const itemsField = modelField.items;
-            if (!itemsField) {
-                throw new Error(`list field does not define items`);
-            }
-            const arrayResult = await (0, utils_1.mapPromise)(value, async (item, index) => {
-                return createNestedField({
-                    value: item,
-                    modelField: itemsField,
-                    fieldPath: fieldPath.concat(index)
-                });
-            });
-            return {
-                field: {
-                    type: 'list',
-                    items: arrayResult.map((result) => result.field)
-                },
-                newRefDocuments: arrayResult.reduce((result, { newRefDocuments }) => result.concat(newRefDocuments), [])
-            };
+        const itemsField = modelField.items;
+        if (!itemsField) {
+            throw new Error(`list field does not define items`);
         }
+        const arrayResult = await (0, utils_1.mapPromise)(value, async (item, index) => {
+            return createNestedField({
+                value: item,
+                modelField: itemsField,
+                fieldPath: fieldPath.concat(index),
+                modelMap,
+                locale,
+                userContext,
+                contentSourceInstance
+            });
+        });
         return {
             field: {
-                type: modelField.type,
-                value: value
+                type: 'list',
+                items: arrayResult.map((result) => result.field)
             },
-            newRefDocuments: []
+            newRefDocuments: arrayResult.reduce((result, { newRefDocuments }) => result.concat(newRefDocuments), [])
         };
-    };
-    object = object !== null && object !== void 0 ? object : {};
-    const result = {
-        fields: {},
+    }
+    return {
+        field: {
+            type: modelField.type,
+            value: value
+        },
         newRefDocuments: []
     };
-    const objectFieldNames = Object.keys(object);
-    for (const modelField of modelFields) {
-        const fieldName = modelField.name;
-        let value;
-        if (fieldName in object) {
-            value = object[fieldName];
-            lodash_1.default.pull(objectFieldNames, fieldName);
-        }
-        else if (modelField.const) {
-            value = modelField.const;
-        }
-        else if (!lodash_1.default.isNil(modelField.default)) {
-            value = modelField.default;
-        }
-        if (!lodash_1.default.isNil(value)) {
-            const fieldResult = await createNestedField({
-                value,
-                modelField,
-                fieldPath: fieldPath.concat(fieldName)
-            });
-            result.fields[fieldName] = fieldResult.field;
-            result.newRefDocuments = result.newRefDocuments.concat(fieldResult.newRefDocuments);
-        }
-    }
-    if (objectFieldNames.length > 0) {
-        throw new Error(`no model fields found when creating a document with fields: '${objectFieldNames.join(', ')}'`);
-    }
-    return result;
 }
 function getModelFieldForFieldAtPath(document, model, fieldPath, modelMap, locale) {
     if (lodash_1.default.isEmpty(fieldPath)) {
@@ -1607,12 +1610,13 @@ function getModelFieldForFieldAtPath(document, model, fieldPath, modelMap, local
     return getField(childDocField, childModelField, childFieldPath);
 }
 async function convertOperationField({ operationField, fieldPath, modelField, modelMap, locale, userContext, contentSourceInstance }) {
-    let result;
+    // for insert operations, the modelField will be of the list, so get the modelField of the list items
+    const modelFieldOrListItems = modelField.type === 'list' ? modelField.items : modelField;
     switch (operationField.type) {
-        case 'object':
-            result = await createNestedObjectRecursively({
+        case 'object': {
+            const result = await createNestedObjectRecursively({
                 object: operationField.object,
-                modelFields: modelField.fields,
+                modelFields: modelFieldOrListItems.fields,
                 fieldPath: fieldPath,
                 modelMap,
                 locale,
@@ -1623,12 +1627,13 @@ async function convertOperationField({ operationField, fieldPath, modelField, mo
                 type: operationField.type,
                 fields: result.fields
             };
-        case 'model':
+        }
+        case 'model': {
             const model = modelMap[operationField.modelName];
             if (!model) {
                 throw new Error(`error updating document, could not find document model: '${operationField.modelName}'`);
             }
-            result = await createNestedObjectRecursively({
+            const result = await createNestedObjectRecursively({
                 object: operationField.object,
                 modelFields: model.fields,
                 fieldPath,
@@ -1642,6 +1647,54 @@ async function convertOperationField({ operationField, fieldPath, modelField, mo
                 modelName: operationField.modelName,
                 fields: result.fields
             };
+        }
+        case 'list': {
+            if (modelField.type !== 'list') {
+                throw new Error(`'the operation field type '${operationField.type}' does not match the model field type '${modelField.type}'`);
+            }
+            const result = await (0, utils_1.mapPromise)(operationField.items, async (item, index) => {
+                const result = await createNestedField({
+                    value: item,
+                    modelField: modelField.items,
+                    fieldPath,
+                    modelMap,
+                    locale,
+                    userContext,
+                    contentSourceInstance
+                });
+                return result.field;
+            });
+            return {
+                type: operationField.type,
+                items: result
+            };
+        }
+        case 'string':
+            if (typeof operationField.value !== 'string') {
+                return {
+                    type: operationField.type,
+                    value: ''
+                };
+            }
+            return operationField;
+        case 'enum':
+            if (typeof operationField.value !== 'string') {
+                if (modelFieldOrListItems.type !== 'enum') {
+                    throw new Error(`'the operation field type 'enum' does not match the model field type '${modelFieldOrListItems.type}'`);
+                }
+                const option = modelFieldOrListItems.options[0];
+                const optionValue = typeof option === 'object' ? option.value : option;
+                return {
+                    type: operationField.type,
+                    value: optionValue
+                };
+            }
+            return operationField;
+        case 'image':
+            if (typeof operationField.value !== 'string') {
+                throw new Error('image value was not specified');
+            }
+            return operationField;
         default:
             return operationField;
     }