@stackbit/cms-core 0.1.3 → 0.1.4-alpha.1

package/src/content-store.ts

@@ -1,28 +1,20 @@
 import _ from 'lodash';
-import slugify from 'slugify';
 import path from 'path';
 import sanitizeFilename from 'sanitize-filename';
-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 CSITypes from '@stackbit/types';
+import { getLocalizedFieldForLocale, UserCommandSpawner } from '@stackbit/types';
+import { Config, extendConfig, Field, loadConfigFromDir, Model, ImageModel, isImageModel, Preset, RawConfigWithPaths } from '@stackbit/sdk';
+import { deferWhileRunning, mapPromise, reducePromise } from '@stackbit/utils';
+
 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 { 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;
@@ -46,7 +38,7 @@ interface ContentSourceData {
     /* Map of extended and validated Models by model name */
     modelMap: Record<string, Model>;
     /* Map of original Models (as provided by content source) by model name */
-    csiModelMap: Record<string, Model>;
+    csiModelMap: Record<string, CSITypes.Model>;
     /* Array of original content source Documents */
     csiDocuments: CSITypes.Document[];
     /* Map of original content source Documents by document ID */
@@ -155,7 +147,6 @@ export class ContentStore {
             } else {
                 this.rawStackbitConfig = null;
             }
-
         }
         await this.loadContentSources({ init });
     }
@@ -218,7 +209,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 } = contentSourceInstance.onFilesChange?.({ updatedFiles: updatedFiles }) ?? {};
+            const { schemaChanged, contentChangeEvent } = (await 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
@@ -250,7 +241,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');
@@ -292,7 +283,8 @@ export class ContentStore {
         const defaultLocaleCode = locales?.find((locale) => locale.default)?.code;
 
         // for older versions of stackbit, it uses models to extend content source models
-        let models: Model[] = [];
+        let modelsNoImage: Exclude<Model, ImageModel>[] = [];
+        let imageModel: ImageModel | undefined;
         if (this.rawStackbitConfig) {
             const result = await extendConfig({
                 config: this.rawStackbitConfig,
@@ -302,28 +294,57 @@ export class ContentStore {
                 this.userLogger.warn(error.message);
             }
             const config = await this.handleConfigAssets(result.config);
-            models = config?.models ?? [];
+            const modelsWithImageModel = config?.models ?? [];
+            const imageModelIndex = modelsWithImageModel.findIndex((model) => isImageModel(model));
+            if (imageModelIndex > -1) {
+                imageModel = modelsWithImageModel[imageModelIndex] as ImageModel;
+                modelsWithImageModel.splice(imageModelIndex, 1);
+            }
+            modelsNoImage = modelsWithImageModel as Exclude<Model, ImageModel>[];
 
             // TODO: load presets externally from config, and create additional map
             //  that maps presetIds by model name instead of storing that map inside every model
-            // TODO: adjust presets to have srcType and srcProjectId
-            this.presets = config?.presets;
+
+            // 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;
+                },
+                {}
+            );
         }
 
         if (this.rawStackbitConfig?.mapModels) {
-            models = this.rawStackbitConfig.mapModels({
-                models: models,
-                contentSourceType: contentSourceInstance.getContentSourceType(),
-                contentSourceProjectId: contentSourceInstance.getProjectId()
+            const srcType = contentSourceInstance.getContentSourceType();
+            const srcProjectId = contentSourceInstance.getProjectId();
+            const modelsWithSource = modelsNoImage.map((model) => ({
+                srcType,
+                srcProjectId,
+                ...model
+            }));
+            const mappedModels = this.rawStackbitConfig.mapModels({
+                models: modelsWithSource
+            });
+            modelsNoImage = mappedModels.map((model) => {
+                const { srcType, srcProjectId, ...rest } = model;
+                return rest;
             });
         }
 
+        const models: Model[] = imageModel ? [...modelsNoImage, imageModel] : modelsNoImage;
         const modelMap = _.keyBy(models, 'name');
-        const csiDocuments = await contentSourceInstance.getDocuments({ modelMap });
+        const csiModelMap = _.keyBy(csiModels, 'name');
+        const csiDocuments = await contentSourceInstance.getDocuments({ modelMap: csiModelMap });
         const csiAssets = await contentSourceInstance.getAssets();
         const csiDocumentMap = _.keyBy(csiDocuments, 'id');
         const csiAssetMap = _.keyBy(csiAssets, 'id');
-        const csiModelMap = _.keyBy(csiModels, 'name');
 
         const contentStoreDocuments = mapCSIDocumentsToStoreDocuments({
             csiDocuments,
@@ -552,11 +573,53 @@ export class ContentStore {
         return contentSourceData.instance.getProjectEnvironment();
     }
 
-    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 });
+    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: []
+            }
+        );
     }
 
     hasChanges({
@@ -930,21 +993,22 @@ export class ContentStore {
         const contentSourceId = getContentSourceId(srcType, srcProjectId);
         const contentSourceData = this.getContentSourceDataByIdOrThrow(contentSourceId);
         const modelMap = contentSourceData.modelMap;
-        const model = modelMap[modelName];
-        if (!model) {
-            throw new Error(`no model with name '${modelName}' was found`);
-        }
-
-        locale = locale ?? contentSourceData.defaultLocaleCode;
+        const csiModelMap = contentSourceData.csiModelMap;
         const userContext = getUserContextForSrcType(srcType, user);
+        const resolvedLocale = locale ?? contentSourceData.defaultLocaleCode;
+
         const result = await createDocumentRecursively({
             object,
-            model,
+            modelName,
             modelMap,
-            locale,
-            userContext,
-            contentSourceInstance: contentSourceData.instance
+            createDocument: getCreateDocumentThunk({
+                locale: resolvedLocale,
+                csiModelMap,
+                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,
@@ -998,11 +1062,14 @@ export class ContentStore {
                         const field = await convertOperationField({
                             operationField: updateOperation.field,
                             fieldPath: updateOperation.fieldPath,
-                            locale: updateOperation.locale,
                             modelField,
                             modelMap,
-                            userContext,
-                            contentSourceInstance: contentSourceData.instance
+                            createDocument: getCreateDocumentThunk({
+                                locale: updateOperation.locale,
+                                csiModelMap,
+                                userContext,
+                                contentSourceInstance: contentSourceData.instance
+                            })
                         });
                         return {
                             ...updateOperation,
@@ -1015,11 +1082,14 @@ export class ContentStore {
                         const item = await convertOperationField({
                             operationField: updateOperation.item,
                             fieldPath: updateOperation.fieldPath,
-                            locale: updateOperation.locale,
                             modelField,
                             modelMap,
-                            userContext,
-                            contentSourceInstance: contentSourceData.instance
+                            createDocument: getCreateDocumentThunk({
+                                locale: updateOperation.locale,
+                                csiModelMap,
+                                userContext,
+                                contentSourceInstance: contentSourceData.instance
+                            })
                         });
                         return {
                             ...updateOperation,
@@ -1071,8 +1141,10 @@ 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];
-        if (!model) {
+        const csiModel = csiModelMap[document.srcModelName];
+        if (!model || !csiModel) {
             throw new Error(`no model with name '${document.srcModelName}' was found`);
         }
 
@@ -1081,7 +1153,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()
@@ -1098,12 +1170,14 @@ 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,
-            // TODO: pass csiModel
-            model,
-            // TODO: pass csiModelMap
-            modelMap,
+            model: csiModel,
+            modelMap: csiModelMap,
             locale: contentSourceData.defaultLocaleCode,
             userContext
         });
@@ -1239,6 +1313,39 @@ 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');
 
@@ -1260,327 +1367,6 @@ 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,
@@ -1594,714 +1380,6 @@ 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 }[]