@stackbit/cms-core 0.1.3-alpha.2 → 0.1.3

package/src/content-store.ts

@@ -1,21 +1,28 @@
 import _ from 'lodash';
+import slugify from 'slugify';
 import path from 'path';
 import sanitizeFilename from 'sanitize-filename';
-
-import { Config, extendConfig, Field, loadConfigFromDir, Model, RawConfigWithPaths, Preset } from '@stackbit/sdk';
-import { deferWhileRunning, mapPromise, reducePromise } from '@stackbit/utils';
-
+import {
+    Config,
+    Model,
+    Field,
+    FieldList,
+    FieldListItems,
+    FieldListProps,
+    FieldModelProps,
+    FieldObjectProps,
+    FieldSpecificProps,
+    RawConfigWithPaths,
+    loadConfigFromDir,
+    extendConfig
+} from '@stackbit/sdk';
+import { deferWhileRunning, mapPromise, omitByNil } from '@stackbit/utils';
 import * as CSITypes from './content-source-interface';
+import { isLocalizedField, getLocalizedFieldForLocale } 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';
-import { SearchFilter } from './types/search-filter';
-import { searchDocuments } from './utils/search-utils';
-import { getLocalizedFieldForLocale } from './content-source-interface';
-import { mapCSIAssetsToStoreAssets, mapCSIDocumentsToStoreDocuments } from './utils/csi-to-store-docs-converter';
-import { getContentSourceId, getContentSourceIdForContentSource, getModelFieldForFieldAtPath, getUserContextForSrcType } from './content-store-utils';
-import { mapAssetsToLocalizedApiImages, mapDocumentsToLocalizedApiObjects, mapStoreAssetsToAPIAssets } from './utils/store-to-api-docs-converter';
-import { convertOperationField, createDocumentRecursively, getCreateDocumentThunk } from './utils/create-update-csi-docs';
 
 export interface ContentSourceOptions {
     logger: ContentStoreTypes.Logger;
@@ -148,6 +155,7 @@ export class ContentStore {
             } else {
                 this.rawStackbitConfig = null;
             }
+
         }
         await this.loadContentSources({ init });
     }
@@ -210,7 +218,7 @@ export class ContentStore {
         for (const contentSourceInstance of this.contentSources) {
             const contentSourceId = getContentSourceIdForContentSource(contentSourceInstance);
             this.logger.debug(`call onFilesChange for contentSource: ${contentSourceId}`);
-            const { schemaChanged, contentChangeEvent } = await contentSourceInstance.onFilesChange?.({ updatedFiles: updatedFiles }) ?? {};
+            const { schemaChanged, contentChangeEvent } = contentSourceInstance.onFilesChange?.({ updatedFiles: updatedFiles }) ?? {};
             this.logger.debug(`schemaChanged: ${schemaChanged}, has contentChangeEvent: ${!!contentChangeEvent}`);
             // if schema is changed, there is no need to return contentChanges
             // because schema changes reloads everything and implies content changes
@@ -242,7 +250,7 @@ export class ContentStore {
 
         const promises = contentSources.map((contentSourceInstance) => {
             return this.loadContentSourceData({ contentSourceInstance, init });
-        });
+        })
 
         const contentSourceDataArr = await Promise.all(promises);
         const contentSourceDataById: Record<string, ContentSourceData> = _.keyBy(contentSourceDataArr, 'id');
@@ -298,17 +306,8 @@ export class ContentStore {
 
             // TODO: load presets externally from config, and create additional map
             //  that maps presetIds by model name instead of storing that map inside every model
-
-            // Augment presets with srcType and srcProjectId if they don't exist
-            this.presets = _.reduce(Object.keys(config?.presets ?? {}), (accum: Record<string, Preset>, presetId) => {
-                const preset = config?.presets?.[presetId];
-                _.set(accum, [presetId], {
-                    ...preset,
-                    srcType: preset?.srcType ?? contentSourceInstance.getContentSourceType(),
-                    srcProjectId: preset?.srcProjectId ?? contentSourceInstance.getProjectId()
-                });
-                return accum
-            }, {});
+            // TODO: adjust presets to have srcType and srcProjectId
+            this.presets = config?.presets;
         }
 
         if (this.rawStackbitConfig?.mapModels) {
@@ -553,53 +552,11 @@ export class ContentStore {
         return contentSourceData.instance.getProjectEnvironment();
     }
 
-    async hasAccess({
-        srcType,
-        srcProjectId,
-        user
-    }: {
-        srcType?: string;
-        srcProjectId?: string;
-        user?: ContentStoreTypes.User;
-    }): Promise<ContentStoreTypes.HasAccessResult> {
-        let contentSourceDataArr: ContentSourceData[];
-        if (srcType && srcProjectId) {
-            const contentSourceId = getContentSourceId(srcType, srcProjectId);
-            const contentSourceData = this.getContentSourceDataByIdOrThrow(contentSourceId);
-            contentSourceDataArr = [contentSourceData];
-        } else {
-            contentSourceDataArr = Object.values(this.contentSourceDataById);
-        }
-        return reducePromise(
-            contentSourceDataArr,
-            async (accum: ContentStoreTypes.HasAccessResult, contentSourceData) => {
-                const srcType = contentSourceData.type;
-                const srcProjectId = contentSourceData.projectId;
-                const userContext = getUserContextForSrcType(srcType, user);
-                let result = await contentSourceData.instance.hasAccess({ userContext });
-                // backwards compatibility with older CSI version
-                if (typeof result === 'boolean') {
-                    result = {
-                        hasConnection: result,
-                        hasPermissions: result
-                    };
-                }
-                return {
-                    hasConnection: accum.hasConnection && result.hasConnection,
-                    hasPermissions: accum.hasPermissions && result.hasPermissions,
-                    contentSources: accum.contentSources.concat({
-                        srcType,
-                        srcProjectId,
-                        ...result
-                    })
-                }
-            },
-            {
-                hasConnection: true,
-                hasPermissions: true,
-                contentSources: []
-            }
-        );
+    hasAccess({ srcType, srcProjectId, user }: { srcType: string; srcProjectId: string; user?: ContentStoreTypes.User }): Promise<boolean> {
+        const contentSourceId = getContentSourceId(srcType, srcProjectId);
+        const contentSourceData = this.getContentSourceDataByIdOrThrow(contentSourceId);
+        const userContext = getUserContextForSrcType(srcType, user);
+        return contentSourceData.instance.hasAccess({ userContext });
     }
 
     hasChanges({
@@ -973,22 +930,21 @@ export class ContentStore {
         const contentSourceId = getContentSourceId(srcType, srcProjectId);
         const contentSourceData = this.getContentSourceDataByIdOrThrow(contentSourceId);
         const modelMap = contentSourceData.modelMap;
-        const csiModelMap = contentSourceData.csiModelMap;
-        const userContext = getUserContextForSrcType(srcType, user);
-        const resolvedLocale = locale ?? contentSourceData.defaultLocaleCode;
+        const model = modelMap[modelName];
+        if (!model) {
+            throw new Error(`no model with name '${modelName}' was found`);
+        }
 
+        locale = locale ?? contentSourceData.defaultLocaleCode;
+        const userContext = getUserContextForSrcType(srcType, user);
         const result = await createDocumentRecursively({
             object,
-            modelName,
+            model,
             modelMap,
-            createDocument: getCreateDocumentThunk({
-                locale: resolvedLocale,
-                csiModelMap,
-                userContext,
-                contentSourceInstance: contentSourceData.instance
-            })
+            locale,
+            userContext,
+            contentSourceInstance: contentSourceData.instance
         });
-
         this.logger.debug('created document', { srcType, srcProjectId, srcDocumentId: result.document.id, modelName });
 
         // do not update cache in contentSourceData.documents and documentMap,
@@ -1042,14 +998,11 @@ export class ContentStore {
                         const field = await convertOperationField({
                             operationField: updateOperation.field,
                             fieldPath: updateOperation.fieldPath,
+                            locale: updateOperation.locale,
                             modelField,
                             modelMap,
-                            createDocument: getCreateDocumentThunk({
-                                locale: updateOperation.locale,
-                                csiModelMap,
-                                userContext,
-                                contentSourceInstance: contentSourceData.instance
-                            })
+                            userContext,
+                            contentSourceInstance: contentSourceData.instance
                         });
                         return {
                             ...updateOperation,
@@ -1062,14 +1015,11 @@ export class ContentStore {
                         const item = await convertOperationField({
                             operationField: updateOperation.item,
                             fieldPath: updateOperation.fieldPath,
+                            locale: updateOperation.locale,
                             modelField,
                             modelMap,
-                            createDocument: getCreateDocumentThunk({
-                                locale: updateOperation.locale,
-                                csiModelMap,
-                                userContext,
-                                contentSourceInstance: contentSourceData.instance
-                            })
+                            userContext,
+                            contentSourceInstance: contentSourceData.instance
                         });
                         return {
                             ...updateOperation,
@@ -1121,10 +1071,8 @@ export class ContentStore {
             throw new Error(`no document with id '${srcDocumentId}' was found in ${contentSourceData.id}`);
         }
         const modelMap = contentSourceData.modelMap;
-        const csiModelMap = contentSourceData.csiModelMap;
         const model = modelMap[document.srcModelName];
-        const csiModel = csiModelMap[document.srcModelName];
-        if (!model || !csiModel) {
+        if (!model) {
             throw new Error(`no model with name '${document.srcModelName}' was found`);
         }
 
@@ -1133,7 +1081,7 @@ export class ContentStore {
         // TODO: take the data from the provided 'object' and merge them with
         //   DocumentFields of the existing Document:
         //   Option 1: Map the DocumentFields of the existing Document into flat
-        //     object with '$$ref' and '$$type' properties for references and
+        //     object with '$$ref' and '$type' properties for references and
         //     nested objects (needs to be implemented), and then merge it with
         //     the provided object recursively, and then pass that object to
         //     createNestedObjectRecursively()
@@ -1150,14 +1098,12 @@ export class ContentStore {
             modelMap: contentSourceData.modelMap
         });
 
-        // When passing model and modelMap to contentSourceInstance, we have to pass
-        // the original models (i.e., csiModel and csiModelMap) that we've received
-        // from that contentSourceInstance. We can't pass internal models as they
-        // might
         const documentResult = await contentSourceData.instance.createDocument({
             updateOperationFields,
-            model: csiModel,
-            modelMap: csiModelMap,
+            // TODO: pass csiModel
+            model,
+            // TODO: pass csiModelMap
+            modelMap,
             locale: contentSourceData.defaultLocaleCode,
             userContext
         });
@@ -1293,39 +1239,6 @@ export class ContentStore {
          */
     }
 
-    async searchDocuments(data: {
-        query?: string;
-        filter?: SearchFilter;
-        models: Array<{
-            srcProjectId: string;
-            srcType: string;
-            modelName: string;
-        }>;
-        locale?: string;
-    }): Promise<{
-        total: number;
-        items: ContentStoreTypes.Document[];
-    }> {
-        this.logger.debug('searchDocuments');
-
-        const objectsBySourceId = _.groupBy(data.models, (object) => getContentSourceId(object.srcType, object.srcProjectId));
-        const documents: ContentStoreTypes.Document[] = [];
-        const schema: Record<string, Record<string, Record<string, Model>>> = {};
-
-        Object.keys(objectsBySourceId).forEach((contentSourceId) => {
-            const contentSourceData = this.getContentSourceDataByIdOrThrow(contentSourceId);
-
-            documents.push(...contentSourceData.documents);
-            _.set(schema, [contentSourceData.type, contentSourceData.projectId], contentSourceData.modelMap);
-        })
-
-        return searchDocuments({
-            ...data,
-            documents,
-            schema
-        });
-    }
-
     async publishDocuments({ objects, user }: { objects: { srcType: string; srcProjectId: string; srcObjectId: string }[]; user?: ContentStoreTypes.User }) {
         this.logger.debug('publishDocuments');
 
@@ -1347,6 +1260,327 @@ export class ContentStore {
     }
 }
 
+export function getContentSourceId(contentSourceType: string, srcProjectId: string) {
+    return contentSourceType + ':' + srcProjectId;
+}
+
+function getUserContextForSrcType(srcType: string, user?: ContentStoreTypes.User): unknown {
+    return user?.connections?.find((connection) => connection.type === srcType);
+}
+
+function mapCSIAssetsToStoreAssets({
+    csiAssets,
+    contentSourceInstance,
+    defaultLocaleCode
+}: {
+    csiAssets: CSITypes.Asset[];
+    contentSourceInstance: CSITypes.ContentSourceInterface;
+    defaultLocaleCode?: string;
+}): ContentStoreTypes.Asset[] {
+    const extra = {
+        srcType: contentSourceInstance.getContentSourceType(),
+        srcProjectId: contentSourceInstance.getProjectId(),
+        srcProjectUrl: contentSourceInstance.getProjectManageUrl(),
+        srcEnvironment: contentSourceInstance.getProjectEnvironment()
+    };
+    return csiAssets.map((csiAsset) => sourceAssetToStoreAsset({ csiAsset, defaultLocaleCode, extra }));
+}
+
+function sourceAssetToStoreAsset({
+    csiAsset,
+    defaultLocaleCode,
+    extra
+}: {
+    csiAsset: CSITypes.Asset;
+    defaultLocaleCode?: string;
+    extra: { srcType: string; srcProjectId: string; srcProjectUrl: string; srcEnvironment: string };
+}): ContentStoreTypes.Asset {
+    return {
+        type: 'asset',
+        ...extra,
+        srcObjectId: csiAsset.id,
+        srcObjectUrl: csiAsset.manageUrl,
+        srcObjectLabel: getObjectLabel(csiAsset.fields, IMAGE_MODEL, defaultLocaleCode),
+        srcModelName: IMAGE_MODEL.name,
+        srcModelLabel: IMAGE_MODEL.label!,
+        isChanged: csiAsset.status === 'added' || csiAsset.status === 'modified',
+        status: csiAsset.status,
+        createdAt: csiAsset.createdAt,
+        createdBy: csiAsset.createdBy,
+        updatedAt: csiAsset.updatedAt,
+        updatedBy: csiAsset.updatedBy,
+        fields: {
+            title: {
+                label: 'Title',
+                ...csiAsset.fields.title
+            },
+            file: {
+                label: 'File',
+                ...csiAsset.fields.file
+            }
+        }
+    };
+}
+
+function mapCSIDocumentsToStoreDocuments({
+    csiDocuments,
+    contentSourceInstance,
+    modelMap,
+    defaultLocaleCode
+}: {
+    csiDocuments: CSITypes.Document[];
+    contentSourceInstance: CSITypes.ContentSourceInterface;
+    modelMap: Record<string, Model>;
+    defaultLocaleCode?: string;
+}): ContentStoreTypes.Document[] {
+    const extra = {
+        srcType: contentSourceInstance.getContentSourceType(),
+        srcProjectId: contentSourceInstance.getProjectId(),
+        srcProjectUrl: contentSourceInstance.getProjectManageUrl(),
+        srcEnvironment: contentSourceInstance.getProjectEnvironment()
+    };
+    return csiDocuments.map((csiDocument) =>
+        mapCSIDocumentToStoreDocument({ csiDocument, model: modelMap[csiDocument.modelName]!, modelMap, defaultLocaleCode, extra })
+    );
+}
+
+function mapCSIDocumentToStoreDocument({
+    csiDocument,
+    model,
+    modelMap,
+    defaultLocaleCode,
+    extra
+}: {
+    csiDocument: CSITypes.Document;
+    model: Model;
+    modelMap: Record<string, Model>;
+    defaultLocaleCode?: string;
+    extra: { srcType: string; srcProjectId: string; srcProjectUrl: string; srcEnvironment: string };
+}): ContentStoreTypes.Document {
+    return {
+        type: 'document',
+        ...extra,
+        srcObjectId: csiDocument.id,
+        srcObjectUrl: csiDocument.manageUrl,
+        srcObjectLabel: getObjectLabel(csiDocument.fields, model, defaultLocaleCode),
+        srcModelLabel: model.label ?? _.startCase(csiDocument.modelName),
+        srcModelName: csiDocument.modelName,
+        isChanged: csiDocument.status === 'added' || csiDocument.status === 'modified',
+        status: csiDocument.status,
+        createdAt: csiDocument.createdAt,
+        createdBy: csiDocument.createdBy,
+        updatedAt: csiDocument.updatedAt,
+        updatedBy: csiDocument.updatedBy,
+        fields: mapCSIFieldsToStoreFields({
+            csiDocumentFields: csiDocument.fields,
+            modelFields: model.fields ?? [],
+            context: {
+                modelMap,
+                defaultLocaleCode
+            }
+        })
+    };
+}
+
+type MapContext = {
+    modelMap: Record<string, Model>;
+    defaultLocaleCode?: string;
+};
+
+function mapCSIFieldsToStoreFields({
+    csiDocumentFields,
+    modelFields,
+    context
+}: {
+    csiDocumentFields: Record<string, CSITypes.DocumentField>;
+    modelFields: Field[];
+    context: MapContext;
+}): Record<string, ContentStoreTypes.DocumentField> {
+    return modelFields.reduce((result: Record<string, ContentStoreTypes.DocumentField>, modelField) => {
+        const csiDocumentField = csiDocumentFields[modelField.name];
+        const docField = mapCSIFieldToStoreField({
+            csiDocumentField,
+            modelField,
+            context
+        });
+        docField.label = modelField.label;
+        result[modelField.name] = docField;
+        return result;
+    }, {});
+}
+
+function mapCSIFieldToStoreField({
+    csiDocumentField,
+    modelField,
+    context
+}: {
+    csiDocumentField: CSITypes.DocumentField | undefined;
+    modelField: FieldSpecificProps;
+    context: MapContext;
+}): ContentStoreTypes.DocumentField {
+    if (!csiDocumentField) {
+        const isUnset = ['object', 'model', 'reference', 'richText', 'markdown', 'image', 'file', 'json'].includes(modelField.type);
+        return {
+            type: modelField.type,
+            ...(isUnset ? { isUnset } : null),
+            ...(modelField.type === 'list' ? { items: [] } : null)
+        } as ContentStoreTypes.DocumentField;
+    }
+    // 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, context);
+        case 'model':
+            return mapModelField(csiDocumentField as CSITypes.DocumentModelField, modelField, context);
+        case 'list':
+            return mapListField(csiDocumentField as CSITypes.DocumentListField, modelField, context);
+        case 'richText':
+            return mapRichTextField(csiDocumentField as CSITypes.DocumentRichTextField);
+        case 'markdown':
+            return mapMarkdownField(csiDocumentField as CSITypes.DocumentValueField);
+        default:
+            return csiDocumentField as ContentStoreTypes.DocumentField;
+    }
+}
+
+function mapObjectField(
+    csiDocumentField: CSITypes.DocumentObjectField,
+    modelField: FieldObjectProps,
+    context: MapContext
+): ContentStoreTypes.DocumentObjectField {
+    if (!isLocalizedField(csiDocumentField)) {
+        return {
+            type: csiDocumentField.type,
+            srcObjectLabel: getObjectLabel(csiDocumentField.fields ?? {}, modelField ?? [], context.defaultLocaleCode),
+            fields: mapCSIFieldsToStoreFields({
+                csiDocumentFields: csiDocumentField.fields ?? {},
+                modelFields: modelField.fields ?? [],
+                context
+            })
+        };
+    }
+    return {
+        type: csiDocumentField.type,
+        localized: true,
+        locales: _.mapValues(csiDocumentField.locales, (locale) => {
+            return {
+                locale: locale.locale,
+                srcObjectLabel: getObjectLabel(locale.fields ?? {}, modelField, locale.locale),
+                fields: mapCSIFieldsToStoreFields({
+                    csiDocumentFields: locale.fields ?? {},
+                    modelFields: modelField.fields ?? [],
+                    context
+                })
+            };
+        })
+    };
+}
+
+function mapModelField(csiDocumentField: CSITypes.DocumentModelField, modelField: FieldModelProps, context: MapContext): ContentStoreTypes.DocumentModelField {
+    if (!isLocalizedField(csiDocumentField)) {
+        const model = context.modelMap[csiDocumentField.modelName]!;
+        return {
+            type: csiDocumentField.type,
+            srcObjectLabel: getObjectLabel(csiDocumentField.fields ?? {}, model, context.defaultLocaleCode),
+            srcModelName: csiDocumentField.modelName,
+            srcModelLabel: model.label ?? _.startCase(model.name),
+            fields: mapCSIFieldsToStoreFields({
+                csiDocumentFields: csiDocumentField.fields ?? {},
+                modelFields: model.fields ?? [],
+                context
+            })
+        };
+    }
+    return {
+        type: csiDocumentField.type,
+        localized: true,
+        locales: _.mapValues(csiDocumentField.locales, (locale) => {
+            const model = context.modelMap[locale.modelName]!;
+            return {
+                locale: locale.locale,
+                srcObjectLabel: getObjectLabel(locale.fields ?? {}, model, locale.locale),
+                srcModelName: locale.modelName,
+                srcModelLabel: model.label ?? _.startCase(model.name),
+                fields: mapCSIFieldsToStoreFields({
+                    csiDocumentFields: locale.fields ?? {},
+                    modelFields: model.fields ?? [],
+                    context
+                })
+            };
+        })
+    };
+}
+
+function mapListField(csiDocumentField: CSITypes.DocumentListField, modelField: FieldListProps, context: MapContext): ContentStoreTypes.DocumentListField {
+    if (!isLocalizedField(csiDocumentField)) {
+        return {
+            type: csiDocumentField.type,
+            items: csiDocumentField.items.map((item) =>
+                mapCSIFieldToStoreField({
+                    csiDocumentField: item,
+                    modelField: modelField.items ?? { type: 'string' },
+                    context
+                })
+            )
+        };
+    }
+    return {
+        type: csiDocumentField.type,
+        localized: true,
+        locales: _.mapValues(csiDocumentField.locales, (locale) => {
+            return {
+                locale: locale.locale,
+                items: (locale.items ?? []).map((item) =>
+                    mapCSIFieldToStoreField({
+                        csiDocumentField: item,
+                        modelField: modelField.items ?? { type: 'string' },
+                        context
+                    })
+                )
+            };
+        })
+    };
+}
+
+function mapRichTextField(csiDocumentField: CSITypes.DocumentRichTextField): ContentStoreTypes.DocumentRichTextField {
+    if (!isLocalizedField(csiDocumentField)) {
+        return {
+            ...csiDocumentField,
+            multiElement: true
+        };
+    }
+    return {
+        type: csiDocumentField.type,
+        localized: true,
+        locales: _.mapValues(csiDocumentField.locales, (locale) => {
+            return {
+                ...locale,
+                multiElement: true
+            };
+        })
+    };
+}
+
+function mapMarkdownField(csiDocumentField: CSITypes.DocumentValueField): ContentStoreTypes.DocumentMarkdownField {
+    if (!isLocalizedField(csiDocumentField)) {
+        return {
+            type: 'markdown',
+            value: csiDocumentField.value,
+            multiElement: true
+        };
+    }
+    return {
+        type: 'markdown',
+        localized: true,
+        locales: _.mapValues(csiDocumentField.locales, (locale) => {
+            return {
+                ...locale,
+                multiElement: true
+            };
+        })
+    };
+}
+
 function mapStoreFieldsToOperationFields({
     documentFields,
     modelFields,
@@ -1360,6 +1594,714 @@ function mapStoreFieldsToOperationFields({
     throw new Error(`duplicateDocument not implemented yet`);
 }
 
+function getContentSourceIdForContentSource(contentSource: CSITypes.ContentSourceInterface): string {
+    return getContentSourceId(contentSource.getContentSourceType(), contentSource.getProjectId());
+}
+
+function extractTokensFromString(input: string): string[] {
+    return input.match(/(?<={)[^}]+(?=})/g) || [];
+}
+
+function sanitizeSlug(slug: string) {
+    return slug
+        .split('/')
+        .map((part) => slugify(part, { lower: true }))
+        .join('/');
+}
+
+function getObjectLabel(
+    documentFields: Record<string, CSITypes.DocumentField | CSITypes.AssetFileField>,
+    modelOrObjectField: Model | FieldObjectProps,
+    locale?: string
+): string {
+    const labelField = modelOrObjectField.labelField;
+    let label = null;
+    if (labelField) {
+        const field = _.get(documentFields, labelField, null);
+        if (field && ['string', 'url', 'slug', 'text', 'markdown', 'number', 'enum', 'date', 'datetime', 'color', 'image', 'file'].includes(field.type)) {
+            if (isLocalizedField(field) && locale) {
+                label = _.get(field, ['locales', locale, 'value'], null);
+            } else if (!isLocalizedField(field)) {
+                label = _.get(field, 'value', null);
+            }
+        }
+    }
+    if (!label) {
+        label = _.get(modelOrObjectField, 'label');
+    }
+    if (!label && _.has(modelOrObjectField, 'name')) {
+        label = _.startCase(_.get(modelOrObjectField, 'name'));
+    }
+    return label;
+}
+
+function mapDocumentsToLocalizedApiObjects(documents: ContentStoreTypes.Document[], locale?: string): ContentStoreTypes.APIDocumentObject[] {
+    return documents.map((document) => documentToLocalizedApiObject(document, locale));
+}
+
+function documentToLocalizedApiObject(document: ContentStoreTypes.Document, locale?: string): ContentStoreTypes.APIDocumentObject {
+    const { type, fields, ...rest } = document;
+    return {
+        type: 'object',
+        ...rest,
+        fields: toLocalizedAPIFields(fields, locale)
+    };
+}
+
+function toLocalizedAPIFields(docFields: Record<string, ContentStoreTypes.DocumentField>, locale?: string): Record<string, ContentStoreTypes.DocumentFieldAPI> {
+    return _.mapValues(docFields, (docField) => toLocalizedAPIField(docField, locale));
+}
+
+function toLocalizedAPIField(docField: ContentStoreTypes.DocumentField, locale?: string, isListItem = false): ContentStoreTypes.DocumentFieldAPI {
+    const hasUnsetFlag = ['object', 'model', 'reference', 'richText', 'markdown', 'image', 'file', 'json'].includes(docField.type);
+    let docFieldLocalized: ContentStoreTypes.DocumentFieldNonLocalized;
+    let unset = false;
+    if (docField.localized) {
+        const { locales, localized, ...base } = docField;
+        const localeProps = locale ? locales[locale] : undefined;
+        docFieldLocalized = {
+            ...base,
+            ...localeProps,
+            ...(hasUnsetFlag && !localeProps ? { isUnset: true } : null)
+        } as ContentStoreTypes.DocumentFieldNonLocalized;
+    } else {
+        docFieldLocalized = docField;
+    }
+
+    locale = locale ?? docFieldLocalized.locale;
+    const commonProps = isListItem
+        ? null
+        : {
+              localized: !!docField.localized,
+              ...(locale ? { locale } : null)
+          };
+
+    if (docFieldLocalized.type === 'object' || docFieldLocalized.type === 'model') {
+        return {
+            ...docFieldLocalized,
+            type: 'object',
+            ...commonProps,
+            ...(docFieldLocalized.isUnset
+                ? null
+                : {
+                      fields: toLocalizedAPIFields(docFieldLocalized.fields, locale)
+                  })
+        } as ContentStoreTypes.DocumentObjectFieldAPI | ContentStoreTypes.DocumentModelFieldAPI;
+    } else if (docFieldLocalized.type === 'reference') {
+        const { type, refType, ...rest } = docFieldLocalized;
+        // if reference field isUnset === true, it behaves like a regular object
+        if (rest.isUnset) {
+            return {
+                type: 'object',
+                ...rest,
+                ...commonProps
+            };
+        }
+        return {
+            type: 'unresolved_reference',
+            refType: refType === 'asset' ? 'image' : 'object',
+            ...rest,
+            ...commonProps
+        };
+    } else if (docFieldLocalized.type === 'list') {
+        // items can be undefined if the requested locale doesn't exist on a localized field
+        const { items, ...rest } = docFieldLocalized;
+        return {
+            ...rest,
+            ...commonProps,
+            items: (items ?? []).map((field) => toLocalizedAPIField(field, locale, true))
+        };
+    } else {
+        return {
+            ...docFieldLocalized,
+            ...commonProps
+        };
+    }
+}
+
+function mapAssetsToLocalizedApiImages(assets: ContentStoreTypes.Asset[], locale?: string): ContentStoreTypes.APIImageObject[] {
+    return assets.map((asset) => assetToLocalizedApiImage(asset, locale));
+}
+
+function assetToLocalizedApiImage(asset: ContentStoreTypes.Asset, locale?: string): ContentStoreTypes.APIImageObject {
+    const { type, fields, ...rest } = asset;
+    return {
+        type: 'image',
+        ...rest,
+        fields: localizeAssetFields(fields, locale)
+    };
+}
+
+function localizeAssetFields(assetFields: ContentStoreTypes.AssetFields, locale?: string): ContentStoreTypes.AssetFieldsAPI {
+    const fields: ContentStoreTypes.AssetFieldsAPI = {
+        title: {
+            type: 'string' as const,
+            value: null as any
+        },
+        url: {
+            type: 'string' as const,
+            value: null as any
+        }
+    };
+    const titleFieldNonLocalized = getDocumentFieldForLocale(assetFields.title, locale);
+    fields.title.value = titleFieldNonLocalized?.value;
+    fields.title.locale = locale ?? titleFieldNonLocalized?.locale;
+    const assetFileField = assetFields.file;
+    if (assetFileField.localized) {
+        if (locale) {
+            fields.url.value = assetFileField.locales[locale]?.url ?? null;
+            fields.url.locale = locale;
+        }
+    } else {
+        fields.url.value = assetFileField.url;
+        fields.url.locale = assetFileField.locale;
+    }
+    return fields;
+}
+
+function mapStoreAssetsToAPIAssets(assets: ContentStoreTypes.Asset[], locale?: string): ContentStoreTypes.APIAsset[] {
+    return assets.map((asset) => storeAssetToAPIAsset(asset, locale));
+}
+
+function storeAssetToAPIAsset(asset: ContentStoreTypes.Asset, locale?: string): ContentStoreTypes.APIAsset {
+    const assetTitleField = asset.fields.title;
+    const localizedTitleField = assetTitleField.localized ? assetTitleField.locales[locale!]! : assetTitleField;
+    const assetFileField = asset.fields.file;
+    const localizedFileField = assetFileField.localized ? assetFileField.locales[locale!]! : assetFileField;
+    return {
+        objectId: asset.srcObjectId,
+        createdAt: asset.createdAt,
+        url: localizedFileField.url,
+        ...omitByNil({
+            title: localizedTitleField.value,
+            fileName: localizedFileField.fileName,
+            contentType: localizedFileField.contentType,
+            size: localizedFileField.size,
+            width: localizedFileField.dimensions?.width,
+            height: localizedFileField.dimensions?.height
+        })
+    };
+}
+
+/**
+ * Iterates recursively objects with $$type and $$ref, creating nested objects
+ * as needed and returns standard ContentSourceInterface Documents
+ */
+async function createDocumentRecursively({
+    object,
+    model,
+    modelMap,
+    locale,
+    userContext,
+    contentSourceInstance
+}: {
+    object?: Record<string, any>;
+    model: Model;
+    modelMap: Record<string, Model>;
+    locale?: string;
+    userContext: unknown;
+    contentSourceInstance: CSITypes.ContentSourceInterface;
+}): Promise<{ document: CSITypes.Document; newRefDocuments: CSITypes.Document[] }> {
+    if (model.type === 'page') {
+        const tokens = extractTokensFromString(String(model.urlPath));
+        const slugField = _.last(tokens);
+        if (object && slugField && slugField in object) {
+            const slugFieldValue = object[slugField];
+            object[slugField] = sanitizeSlug(slugFieldValue);
+        }
+    }
+
+    const nestedResult = await createNestedObjectRecursively({
+        object,
+        modelFields: model.fields ?? [],
+        fieldPath: [],
+        modelMap,
+        locale,
+        userContext,
+        contentSourceInstance
+    });
+    const document = await contentSourceInstance.createDocument({
+        updateOperationFields: nestedResult.fields,
+        // TODO: pass csiModel
+        model,
+        // TODO: pass csiModelMap
+        modelMap,
+        locale,
+        userContext
+    });
+    return {
+        document: document,
+        newRefDocuments: nestedResult.newRefDocuments
+    };
+}
+
+async function createNestedObjectRecursively({
+    object,
+    modelFields,
+    fieldPath,
+    modelMap,
+    locale,
+    userContext,
+    contentSourceInstance
+}: {
+    object?: Record<string, any>;
+    modelFields: Field[];
+    fieldPath: (string | number)[];
+    modelMap: Record<string, Model>;
+    locale?: string;
+    userContext: unknown;
+    contentSourceInstance: CSITypes.ContentSourceInterface;
+}): Promise<{
+    fields: Record<string, CSITypes.UpdateOperationField>;
+    newRefDocuments: CSITypes.Document[];
+}> {
+    object = object ?? {};
+    const result: {
+        fields: Record<string, CSITypes.UpdateOperationField>;
+        newRefDocuments: CSITypes.Document[];
+    } = {
+        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];
+            _.pull(objectFieldNames, fieldName);
+        } else if (modelField.const) {
+            value = modelField.const;
+        } else if (!_.isNil(modelField.default)) {
+            value = modelField.default;
+        }
+        if (!_.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
+}: {
+    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,
+    fieldPath: (string | number)[],
+    modelMap: Record<string, Model>,
+    locale?: string
+): Field {
+    if (_.isEmpty(fieldPath)) {
+        throw new Error('the fieldPath can not be empty');
+    }
+
+    function getField(docField: ContentStoreTypes.DocumentField, modelField: FieldSpecificProps, fieldPath: (string | number)[]): Field {
+        const fieldName = _.head(fieldPath);
+        if (typeof fieldName === 'undefined') {
+            throw new Error('the first fieldPath item must be string');
+        }
+        const childFieldPath = _.tail(fieldPath);
+        let childDocField: ContentStoreTypes.DocumentField | undefined;
+        let childModelField: Field | undefined;
+        switch (docField.type) {
+            case 'object':
+                const localizedObjectField = getDocumentFieldForLocale(docField, locale);
+                if (!localizedObjectField) {
+                    throw new Error(`locale for field was not found`);
+                }
+                if (localizedObjectField.isUnset) {
+                    throw new Error(`field is not set`);
+                }
+                childDocField = localizedObjectField.fields[fieldName];
+                childModelField = _.find((modelField as FieldObjectProps).fields, (field) => field.name === fieldName);
+                if (!childDocField || !childModelField) {
+                    throw new Error(`field ${fieldName} doesn't exist`);
+                }
+                if (childFieldPath.length === 0) {
+                    return childModelField;
+                }
+                return getField(childDocField, childModelField, childFieldPath);
+            case 'model':
+                const localizedModelField = getDocumentFieldForLocale(docField, locale);
+                if (!localizedModelField) {
+                    throw new Error(`locale for field was not found`);
+                }
+                if (localizedModelField.isUnset) {
+                    throw new Error(`field is not set`);
+                }
+                const modelName = localizedModelField.srcModelName;
+                const childModel = modelMap[modelName];
+                if (!childModel) {
+                    throw new Error(`model ${modelName} doesn't exist`);
+                }
+                childModelField = _.find(childModel.fields, (field) => field.name === fieldName);
+                childDocField = localizedModelField.fields![fieldName];
+                if (!childDocField || !childModelField) {
+                    throw new Error(`field ${fieldName} doesn't exist`);
+                }
+                if (childFieldPath.length === 0) {
+                    return childModelField;
+                }
+                return getField(childDocField, childModelField!, childFieldPath);
+            case 'list':
+                const localizedListField = getDocumentFieldForLocale(docField, locale);
+                if (!localizedListField) {
+                    throw new Error(`locale for field was not found`);
+                }
+                const listItem = localizedListField.items && localizedListField.items[fieldName as number];
+                const listItemsModel = (modelField as FieldListProps).items;
+                if (!listItem || !listItemsModel) {
+                    throw new Error(`field ${fieldName} doesn't exist`);
+                }
+                if (childFieldPath.length === 0) {
+                    return modelField as FieldList;
+                }
+                if (!Array.isArray(listItemsModel)) {
+                    return getField(listItem, listItemsModel, childFieldPath);
+                } else {
+                    const fieldListItems = (listItemsModel as FieldListItems[]).find((listItemsModel) => listItemsModel.type === listItem.type);
+                    if (!fieldListItems) {
+                        throw new Error('cannot find matching field model');
+                    }
+                    return getField(listItem, fieldListItems, childFieldPath);
+                }
+            default:
+                if (!_.isEmpty(childFieldPath)) {
+                    throw new Error('illegal fieldPath');
+                }
+                return modelField as Field;
+        }
+    }
+
+    const fieldName = _.head(fieldPath);
+    const childFieldPath = _.tail(fieldPath);
+
+    if (typeof fieldName !== 'string') {
+        throw new Error('the first fieldPath item must be string');
+    }
+
+    const childDocField = document.fields[fieldName];
+    const childModelField = _.find(model.fields, { name: fieldName });
+
+    if (!childDocField || !childModelField) {
+        throw new Error(`field ${fieldName} doesn't exist`);
+    }
+
+    if (childFieldPath.length === 0) {
+        return childModelField;
+    }
+
+    return getField(childDocField, childModelField, childFieldPath);
+}
+
+async function convertOperationField({
+    operationField,
+    fieldPath,
+    modelField,
+    modelMap,
+    locale,
+    userContext,
+    contentSourceInstance
+}: {
+    operationField: ContentStoreTypes.UpdateOperationField;
+    fieldPath: (string | number)[];
+    modelField: Field;
+    modelMap: Record<string, Model>;
+    locale?: string;
+    userContext: unknown;
+    contentSourceInstance: CSITypes.ContentSourceInterface;
+}): Promise<CSITypes.UpdateOperationField> {
+    // 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': {
+            const result = await createNestedObjectRecursively({
+                object: operationField.object,
+                modelFields: (modelFieldOrListItems as FieldObjectProps).fields,
+                fieldPath: fieldPath,
+                modelMap,
+                locale,
+                userContext,
+                contentSourceInstance
+            });
+            return {
+                type: operationField.type,
+                fields: result.fields
+            };
+        }
+        case 'model': {
+            const model = modelMap[operationField.modelName];
+            if (!model) {
+                throw new Error(`error updating document, could not find document model: '${operationField.modelName}'`);
+            }
+            const result = await createNestedObjectRecursively({
+                object: operationField.object,
+                modelFields: model.fields!,
+                fieldPath,
+                modelMap,
+                locale,
+                userContext,
+                contentSourceInstance
+            });
+            return {
+                type: operationField.type,
+                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':
+            // When inserting new string value into a list, the client does not
+            // send value. Set an empty string value.
+            if (typeof operationField.value !== 'string') {
+                return {
+                    type: operationField.type,
+                    value: ''
+                };
+            }
+            return operationField as CSITypes.UpdateOperationField;
+        case 'enum':
+            // When inserting new enum value into a list, the client does not
+            // send value. Set first option as the value.
+            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;
+    }
+}
+
+function getDocumentFieldForLocale<Type extends ContentStoreTypes.FieldType>(
+    docField: ContentStoreTypes.DocumentFieldForType<Type>,
+    locale?: string
+): ContentStoreTypes.DocumentFieldNonLocalizedForType<Type> | null {
+    if (docField.localized) {
+        if (!locale) {
+            return null;
+        }
+        const { localized, locales, ...base } = docField;
+        const localizedField = locales[locale];
+        if (!localizedField) {
+            return null;
+        }
+        return ({
+            ...base,
+            ...localizedField
+        } as unknown) as ContentStoreTypes.DocumentFieldNonLocalizedForType<Type>;
+    } else {
+        return docField;
+    }
+}
+
 function getCSIDocumentsAndAssetsFromContentSourceDataByIds(
     contentSourceData: ContentSourceData,
     objects: { srcObjectId: string }[]