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

package/src/content-store.ts

@@ -17,13 +17,11 @@ import {
 } from '@stackbit/sdk';
 import { mapPromise, omitByNil } from '@stackbit/utils';
 import * as CSITypes from './content-source-interface';
-import {
-    DocumentObjectField,
-    isLocalizedField
-} from './content-source-interface';
+import { isLocalizedField } from './content-source-interface';
 import * as ContentStoreTypes from './content-store-types';
 import { IMAGE_MODEL } from './common/common-schema';
 import { Timer } from './utils/timer';
+import { UserCommandSpawner } from './common/common-types';
 
 export interface ContentSourceOptions {
     logger: ContentStoreTypes.Logger;
@@ -31,6 +29,7 @@ export interface ContentSourceOptions {
     localDev: boolean;
     stackbitYamlDir: string;
     contentSources: CSITypes.ContentSourceInterface[];
+    userCommandSpawner?: UserCommandSpawner;
     onSchemaChangeCallback: () => void;
     onContentChangeCallback: (contentChanges: ContentStoreTypes.ContentChangeResult) => void;
     handleConfigAssets: (config: Config) => Promise<Config>;
@@ -59,6 +58,7 @@ export class ContentStore {
     private readonly contentSources: CSITypes.ContentSourceInterface[];
     private readonly logger: ContentStoreTypes.Logger;
     private readonly userLogger: ContentStoreTypes.Logger;
+    private readonly userCommandSpawner?: UserCommandSpawner;
     private readonly localDev: boolean;
     private readonly stackbitYamlDir: string; // TODO: remove stackbitYamlDir, ContentStore should not be aware of filesystem, instead pass autoreloading Config object
     private readonly onSchemaChangeCallback: () => void;
@@ -73,6 +73,7 @@ export class ContentStore {
         this.logger = options.logger.createLogger({ label: 'content-store' });
         this.userLogger = options.userLogger.createLogger({ label: 'content-store' });
         this.localDev = options.localDev;
+        this.userCommandSpawner = options.userCommandSpawner;
         this.stackbitYamlDir = options.stackbitYamlDir; // TODO: remove stackbitYamlDir, ContentStore should not be aware of filesystem, instead pass autoreloading Config object
         this.contentSources = options.contentSources;
         this.onSchemaChangeCallback = options.onSchemaChangeCallback;
@@ -226,6 +227,7 @@ export class ContentStore {
             await contentSourceInstance.init({
                 logger: this.logger,
                 userLogger: this.userLogger,
+                userCommandSpawner: this.userCommandSpawner,
                 localDev: this.localDev
             });
         } else {
@@ -411,7 +413,7 @@ export class ContentStore {
             const dataIndex = contentSourceData.documents.findIndex((existingDoc) => existingDoc.srcObjectId === document.srcObjectId);
             if (dataIndex === -1) {
                 contentSourceData.documents.push(document);
-                contentSourceData.csiDocuments.push(csiDocument)
+                contentSourceData.csiDocuments.push(csiDocument);
             } else {
                 // the indexes of documents and csiDocuments are always the same as they are always updated at the same time
                 contentSourceData.documents.splice(dataIndex, 1, document);
@@ -1283,30 +1285,34 @@ function mapCSIDocumentToStoreDocument({
         fields: mapCSIFieldsToStoreFields({
             csiDocumentFields: csiDocument.fields,
             modelFields: model.fields ?? [],
-            modelMap,
-            defaultLocaleCode
+            context: {
+                modelMap,
+                defaultLocaleCode
+            }
         })
     };
 }
 
+type MapContext = {
+    modelMap: Record<string, Model>;
+    defaultLocaleCode?: string;
+};
+
 function mapCSIFieldsToStoreFields({
     csiDocumentFields,
     modelFields,
-    modelMap,
-    defaultLocaleCode
+    context
 }: {
     csiDocumentFields: Record<string, CSITypes.DocumentField>;
     modelFields: Field[];
-    modelMap: Record<string, Model>;
-    defaultLocaleCode?: string;
+    context: MapContext;
 }): Record<string, ContentStoreTypes.DocumentField> {
     return modelFields.reduce((result: Record<string, ContentStoreTypes.DocumentField>, 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;
@@ -1314,16 +1320,14 @@ function mapCSIFieldsToStoreFields({
     }, {});
 }
 
-function mapSourceFieldToStoreField({
+function mapCSIFieldToStoreField({
     csiDocumentField,
     modelField,
-    modelMap,
-    defaultLocaleCode
+    context
 }: {
     csiDocumentField: CSITypes.DocumentField | undefined;
     modelField: FieldSpecificProps;
-    modelMap: Record<string, Model>;
-    defaultLocaleCode?: string;
+    context: MapContext;
 }): ContentStoreTypes.DocumentField {
     if (!csiDocumentField) {
         const isUnset = ['object', 'model', 'reference', 'richText', 'markdown', 'image', 'file', 'json'].includes(modelField.type);
@@ -1336,11 +1340,11 @@ function mapSourceFieldToStoreField({
     // TODO: check if need to add "options" to "enum" and subtype/min/max to "number"
     switch (modelField.type) {
         case 'object':
-            return mapObjectField(csiDocumentField as CSITypes.DocumentObjectField, modelField, modelMap, defaultLocaleCode);
+            return mapObjectField(csiDocumentField as CSITypes.DocumentObjectField, modelField, context);
         case 'model':
-            return mapModelField(csiDocumentField as CSITypes.DocumentModelField, modelField, modelMap, defaultLocaleCode);
+            return mapModelField(csiDocumentField as CSITypes.DocumentModelField, modelField, context);
         case 'list':
-            return mapListField(csiDocumentField as CSITypes.DocumentListField, modelField, modelMap, defaultLocaleCode);
+            return mapListField(csiDocumentField as CSITypes.DocumentListField, modelField, context);
         case 'richText':
             return mapRichTextField(csiDocumentField as CSITypes.DocumentRichTextField);
         case 'markdown':
@@ -1353,18 +1357,16 @@ function mapSourceFieldToStoreField({
 function mapObjectField(
     csiDocumentField: CSITypes.DocumentObjectField,
     modelField: FieldObjectProps,
-    modelMap: Record<string, Model>,
-    defaultLocaleCode?: string
+    context: MapContext
 ): ContentStoreTypes.DocumentObjectField {
     if (!isLocalizedField(csiDocumentField)) {
         return {
             type: csiDocumentField.type,
-            srcObjectLabel: getObjectLabel(csiDocumentField.fields ?? {}, modelField ?? [], defaultLocaleCode),
+            srcObjectLabel: getObjectLabel(csiDocumentField.fields ?? {}, modelField ?? [], context.defaultLocaleCode),
             fields: mapCSIFieldsToStoreFields({
                 csiDocumentFields: csiDocumentField.fields ?? {},
                 modelFields: modelField.fields ?? [],
-                modelMap,
-                defaultLocaleCode
+                context
             })
         };
     }
@@ -1378,32 +1380,25 @@ function mapObjectField(
                 fields: mapCSIFieldsToStoreFields({
                     csiDocumentFields: locale.fields ?? {},
                     modelFields: modelField.fields ?? [],
-                    modelMap,
-                    defaultLocaleCode
+                    context
                 })
             };
         })
     };
 }
 
-function mapModelField(
-    csiDocumentField: CSITypes.DocumentModelField,
-    modelField: FieldModelProps,
-    modelMap: Record<string, Model>,
-    defaultLocaleCode?: string
-): ContentStoreTypes.DocumentModelField {
+function mapModelField(csiDocumentField: CSITypes.DocumentModelField, modelField: FieldModelProps, context: MapContext): ContentStoreTypes.DocumentModelField {
     if (!isLocalizedField(csiDocumentField)) {
-        const model = modelMap[csiDocumentField.modelName]!;
+        const model = context.modelMap[csiDocumentField.modelName]!;
         return {
             type: csiDocumentField.type,
-            srcObjectLabel: getObjectLabel(csiDocumentField.fields ?? {}, model, defaultLocaleCode),
+            srcObjectLabel: getObjectLabel(csiDocumentField.fields ?? {}, model, context.defaultLocaleCode),
             srcModelName: csiDocumentField.modelName,
             srcModelLabel: model.label ?? _.startCase(model.name),
             fields: mapCSIFieldsToStoreFields({
                 csiDocumentFields: csiDocumentField.fields ?? {},
                 modelFields: model.fields ?? [],
-                modelMap,
-                defaultLocaleCode
+                context
             })
         };
     }
@@ -1411,7 +1406,7 @@ function mapModelField(
         type: csiDocumentField.type,
         localized: true,
         locales: _.mapValues(csiDocumentField.locales, (locale) => {
-            const model = modelMap[locale.modelName]!;
+            const model = context.modelMap[locale.modelName]!;
             return {
                 locale: locale.locale,
                 srcObjectLabel: getObjectLabel(locale.fields ?? {}, model, locale.locale),
@@ -1420,29 +1415,22 @@ function mapModelField(
                 fields: mapCSIFieldsToStoreFields({
                     csiDocumentFields: locale.fields ?? {},
                     modelFields: model.fields ?? [],
-                    modelMap,
-                    defaultLocaleCode
+                    context
                 })
             };
         })
     };
 }
 
-function mapListField(
-    csiDocumentField: CSITypes.DocumentListField,
-    modelField: FieldListProps,
-    modelMap: Record<string, Model>,
-    defaultLocaleCode?: string
-): ContentStoreTypes.DocumentListField {
+function mapListField(csiDocumentField: CSITypes.DocumentListField, modelField: FieldListProps, context: MapContext): ContentStoreTypes.DocumentListField {
     if (!isLocalizedField(csiDocumentField)) {
         return {
             type: csiDocumentField.type,
             items: csiDocumentField.items.map((item) =>
-                mapSourceFieldToStoreField({
+                mapCSIFieldToStoreField({
                     csiDocumentField: item,
                     modelField: modelField.items ?? { type: 'string' },
-                    modelMap,
-                    defaultLocaleCode
+                    context
                 })
             )
         };
@@ -1454,11 +1442,10 @@ function mapListField(
             return {
                 locale: locale.locale,
                 items: (locale.items ?? []).map((item) =>
-                    mapSourceFieldToStoreField({
+                    mapCSIFieldToStoreField({
                         csiDocumentField: item,
                         modelField: modelField.items ?? { type: 'string' },
-                        modelMap,
-                        defaultLocaleCode
+                        context
                     })
                 )
             };
@@ -1603,6 +1590,7 @@ function toLocalizedAPIField(docField: ContentStoreTypes.DocumentField, locale?:
     if (docFieldLocalized.type === 'object' || docFieldLocalized.type === 'model') {
         return {
             ...docFieldLocalized,
+            type: 'object',
             ...commonProps,
             ...(docFieldLocalized.isUnset
                 ? null
@@ -1743,7 +1731,7 @@ async function createDocumentRecursively({
         contentSourceInstance
     });
     const document = await contentSourceInstance.createDocument({
-        documentFields: nestedResult.fields,
+        documentFields: nestedResult.fields as Record<string, CSITypes.DocumentField>,
         model,
         modelMap,
         locale,
@@ -1772,166 +1760,12 @@ async function createNestedObjectRecursively({
     userContext: unknown;
     contentSourceInstance: CSITypes.ContentSourceInterface;
 }): Promise<{
-    fields: Record<string, CSITypes.DocumentFieldNonLocalized>;
+    fields: Record<string, CSITypes.UpdateOperationField>;
     newRefDocuments: CSITypes.Document[];
 }> {
-    const createNestedField = async ({
-        value,
-        modelField,
-        fieldPath
-    }: {
-        value: any;
-        modelField: FieldSpecificProps;
-        fieldPath: (string | number)[];
-    }): Promise<{ field: CSITypes.DocumentFieldNonLocalized; newRefDocuments: CSITypes.Document[] }> => {
-        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 = _.omit(rest, 'type');
-            }
-            const modelName = $$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: model.fields ?? [],
-                fieldPath,
-                modelMap,
-                locale,
-                userContext,
-                contentSourceInstance
-            });
-            return {
-                field: {
-                    type: 'model',
-                    modelName: modelName,
-                    fields: result.fields
-                },
-                newRefDocuments: result.newRefDocuments
-            };
-        } else if (modelField.type === 'image') {
-            let refId: string | undefined;
-            if (_.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 } = _.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 = _.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`);
-            }
-            const itemsField = modelField.items;
-            if (!itemsField) {
-                throw new Error(`list field does not define items`);
-            }
-            const arrayResult = await 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: CSITypes.Document[], { newRefDocuments }) => result.concat(newRefDocuments), [])
-            };
-        }
-        return {
-            field: {
-                type: modelField.type,
-                value: value
-            } as CSITypes.DocumentFieldNonLocalized,
-            newRefDocuments: []
-        };
-    };
-
     object = object ?? {};
     const result: {
-        fields: Record<string, CSITypes.DocumentFieldNonLocalized>;
+        fields: Record<string, CSITypes.UpdateOperationField>;
         newRefDocuments: CSITypes.Document[];
     } = {
         fields: {},
@@ -1953,7 +1787,11 @@ async function createNestedObjectRecursively({
             const fieldResult = await createNestedField({
                 value,
                 modelField,
-                fieldPath: fieldPath.concat(fieldName)
+                fieldPath: fieldPath.concat(fieldName),
+                modelMap,
+                locale,
+                userContext,
+                contentSourceInstance
             });
             result.fields[fieldName] = fieldResult.field;
             result.newRefDocuments = result.newRefDocuments.concat(fieldResult.newRefDocuments);
@@ -1966,6 +1804,172 @@ async function createNestedObjectRecursively({
     return result;
 }
 
+async function createNestedField({
+    value,
+    modelField,
+    fieldPath,
+    modelMap,
+    locale,
+    userContext,
+    contentSourceInstance
+}: {
+    value: any;
+    modelField: FieldSpecificProps;
+    fieldPath: (string | number)[];
+    modelMap: Record<string, Model>;
+    locale?: string;
+    userContext: unknown;
+    contentSourceInstance: CSITypes.ContentSourceInterface;
+}): Promise<{ field: CSITypes.UpdateOperationField; newRefDocuments: CSITypes.Document[] }> {
+    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 = _.omit(rest, 'type');
+        }
+        const modelName = $$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: model.fields ?? [],
+            fieldPath,
+            modelMap,
+            locale,
+            userContext,
+            contentSourceInstance
+        });
+        return {
+            field: {
+                type: 'model',
+                modelName: modelName,
+                fields: result.fields
+            },
+            newRefDocuments: result.newRefDocuments
+        };
+    } else if (modelField.type === 'image') {
+        let refId: string | undefined;
+        if (_.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 } = _.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 = _.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`);
+        }
+        const itemsField = modelField.items;
+        if (!itemsField) {
+            throw new Error(`list field does not define items`);
+        }
+        const arrayResult = await mapPromise(value, async (item, index) => {
+            return createNestedField({
+                value: item,
+                modelField: itemsField,
+                fieldPath: fieldPath.concat(index),
+                modelMap,
+                locale,
+                userContext,
+                contentSourceInstance
+            });
+        });
+        return {
+            field: {
+                type: 'list',
+                items: arrayResult.map((result) => result.field)
+            },
+            newRefDocuments: arrayResult.reduce((result: CSITypes.Document[], { newRefDocuments }) => result.concat(newRefDocuments), [])
+        };
+    }
+    return {
+        field: {
+            type: modelField.type,
+            value: value
+        },
+        newRefDocuments: []
+    };
+}
+
 function getModelFieldForFieldAtPath(
     document: ContentStoreTypes.Document,
     model: Model,
@@ -2093,12 +2097,13 @@ async function convertOperationField({
     userContext: unknown;
     contentSourceInstance: CSITypes.ContentSourceInterface;
 }): Promise<CSITypes.UpdateOperationField> {
-    let result;
+    // for insert operations, the modelField will be of the list, so get the modelField of the list items
+    const modelFieldOrListItems: FieldSpecificProps = 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 as FieldObjectProps).fields,
+                modelFields: (modelFieldOrListItems as FieldObjectProps).fields,
                 fieldPath: fieldPath,
                 modelMap,
                 locale,
@@ -2109,12 +2114,13 @@ async function convertOperationField({
                 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,
@@ -2128,6 +2134,51 @@ async function convertOperationField({
                 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 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 as CSITypes.UpdateOperationField;
+        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 as CSITypes.UpdateOperationField;
+        case 'image':
+            return operationField as CSITypes.UpdateOperationField;
         default:
             return operationField as CSITypes.UpdateOperationField;
     }