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

package/dist/content-store.js

@@ -3,16 +3,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getContentSourceId = exports.ContentStore = void 0;
+exports.ContentStore = void 0;
 const lodash_1 = __importDefault(require("lodash"));
-const slugify_1 = __importDefault(require("slugify"));
 const path_1 = __importDefault(require("path"));
 const sanitize_filename_1 = __importDefault(require("sanitize-filename"));
 const sdk_1 = require("@stackbit/sdk");
 const utils_1 = require("@stackbit/utils");
-const content_source_interface_1 = require("./content-source-interface");
-const common_schema_1 = require("./common/common-schema");
 const timer_1 = require("./utils/timer");
+const search_utils_1 = require("./utils/search-utils");
+const content_source_interface_1 = require("./content-source-interface");
+const csi_to_store_docs_converter_1 = require("./utils/csi-to-store-docs-converter");
+const content_store_utils_1 = require("./content-store-utils");
+const store_to_api_docs_converter_1 = require("./utils/store-to-api-docs-converter");
+const create_update_csi_docs_1 = require("./utils/create-update-csi-docs");
 class ContentStore {
     constructor(options) {
         this.contentSources = [];
@@ -40,7 +43,7 @@ class ContentStore {
             thisArg: this,
             // Group the deferred calls by content source ID.
             groupResolver: ({ contentSourceInstance }) => {
-                return getContentSourceIdForContentSource(contentSourceInstance);
+                return (0, content_store_utils_1.getContentSourceIdForContentSource)(contentSourceInstance);
             },
             // When the loadContentSourceData call is called multiple times with
             // different "init" values, ensure that the deferred call will be
@@ -145,7 +148,7 @@ class ContentStore {
             deletedAssets: []
         };
         for (const contentSourceInstance of this.contentSources) {
-            const contentSourceId = getContentSourceIdForContentSource(contentSourceInstance);
+            const contentSourceId = (0, content_store_utils_1.getContentSourceIdForContentSource)(contentSourceInstance);
             this.logger.debug(`call onFilesChange for contentSource: ${contentSourceId}`);
             const { schemaChanged, contentChangeEvent } = (_b = (_a = contentSourceInstance.onFilesChange) === null || _a === void 0 ? void 0 : _a.call(contentSourceInstance, { updatedFiles: updatedFiles })) !== null && _b !== void 0 ? _b : {};
             this.logger.debug(`schemaChanged: ${schemaChanged}, has contentChangeEvent: ${!!contentChangeEvent}`);
@@ -185,8 +188,8 @@ class ContentStore {
         this.contentUpdatesWatchTimer.startTimer();
     }
     async loadContentSourceData({ contentSourceInstance, init }) {
-        var _a, _b, _c, _d;
-        const contentSourceId = getContentSourceIdForContentSource(contentSourceInstance);
+        var _a, _b, _c, _d, _e;
+        const contentSourceId = (0, content_store_utils_1.getContentSourceIdForContentSource)(contentSourceInstance);
         this.logger.debug('loadContentSourceData', { contentSourceId, init });
         if (init) {
             await contentSourceInstance.init({
@@ -219,10 +222,19 @@ class ContentStore {
             models = (_c = config === null || config === void 0 ? void 0 : config.models) !== null && _c !== void 0 ? _c : [];
             // 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 === null || config === void 0 ? void 0 : config.presets;
+            // Augment presets with srcType and srcProjectId if they don't exist
+            this.presets = lodash_1.default.reduce(Object.keys((_d = config === null || config === void 0 ? void 0 : config.presets) !== null && _d !== void 0 ? _d : {}), (accum, presetId) => {
+                var _a, _b, _c;
+                const preset = (_a = config === null || config === void 0 ? void 0 : config.presets) === null || _a === void 0 ? void 0 : _a[presetId];
+                lodash_1.default.set(accum, [presetId], {
+                    ...preset,
+                    srcType: (_b = preset === null || preset === void 0 ? void 0 : preset.srcType) !== null && _b !== void 0 ? _b : contentSourceInstance.getContentSourceType(),
+                    srcProjectId: (_c = preset === null || preset === void 0 ? void 0 : preset.srcProjectId) !== null && _c !== void 0 ? _c : contentSourceInstance.getProjectId()
+                });
+                return accum;
+            }, {});
         }
-        if ((_d = this.rawStackbitConfig) === null || _d === void 0 ? void 0 : _d.mapModels) {
+        if ((_e = this.rawStackbitConfig) === null || _e === void 0 ? void 0 : _e.mapModels) {
             models = this.rawStackbitConfig.mapModels({
                 models: models,
                 contentSourceType: contentSourceInstance.getContentSourceType(),
@@ -235,13 +247,13 @@ class ContentStore {
         const csiDocumentMap = lodash_1.default.keyBy(csiDocuments, 'id');
         const csiAssetMap = lodash_1.default.keyBy(csiAssets, 'id');
         const csiModelMap = lodash_1.default.keyBy(csiModels, 'name');
-        const contentStoreDocuments = mapCSIDocumentsToStoreDocuments({
+        const contentStoreDocuments = (0, csi_to_store_docs_converter_1.mapCSIDocumentsToStoreDocuments)({
             csiDocuments,
             contentSourceInstance,
             modelMap,
             defaultLocaleCode
         });
-        const contentStoreAssets = mapCSIAssetsToStoreAssets({
+        const contentStoreAssets = (0, csi_to_store_docs_converter_1.mapCSIAssetsToStoreAssets)({
             csiAssets,
             contentSourceInstance,
             defaultLocaleCode
@@ -353,13 +365,13 @@ class ContentStore {
             });
         });
         // map csi documents and assets to content store documents and assets
-        const documents = mapCSIDocumentsToStoreDocuments({
+        const documents = (0, csi_to_store_docs_converter_1.mapCSIDocumentsToStoreDocuments)({
             csiDocuments: contentChangeEvent.documents,
             contentSourceInstance: contentSourceData.instance,
             modelMap: contentSourceData.modelMap,
             defaultLocaleCode: contentSourceData.defaultLocaleCode
         });
-        const assets = mapCSIAssetsToStoreAssets({
+        const assets = (0, csi_to_store_docs_converter_1.mapCSIAssetsToStoreAssets)({
             csiAssets: contentChangeEvent.assets,
             contentSourceInstance: contentSourceData.instance,
             defaultLocaleCode: contentSourceData.defaultLocaleCode
@@ -431,25 +443,56 @@ class ContentStore {
         return (_a = this.presets) !== null && _a !== void 0 ? _a : {};
     }
     getContentSourceEnvironment({ srcProjectId, srcType }) {
-        const contentSourceId = getContentSourceId(srcType, srcProjectId);
+        const contentSourceId = (0, content_store_utils_1.getContentSourceId)(srcType, srcProjectId);
         const contentSourceData = this.getContentSourceDataByIdOrThrow(contentSourceId);
         return contentSourceData.instance.getProjectEnvironment();
     }
-    hasAccess({ srcType, srcProjectId, user }) {
-        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 }) {
+        let contentSourceDataArr;
+        if (srcType && srcProjectId) {
+            const contentSourceId = (0, content_store_utils_1.getContentSourceId)(srcType, srcProjectId);
+            const contentSourceData = this.getContentSourceDataByIdOrThrow(contentSourceId);
+            contentSourceDataArr = [contentSourceData];
+        }
+        else {
+            contentSourceDataArr = Object.values(this.contentSourceDataById);
+        }
+        return (0, utils_1.reducePromise)(contentSourceDataArr, async (accum, contentSourceData) => {
+            const srcType = contentSourceData.type;
+            const srcProjectId = contentSourceData.projectId;
+            const userContext = (0, content_store_utils_1.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({ srcType, srcProjectId, documents }) {
         let result;
         if (srcType && srcProjectId) {
-            const contentSourceId = getContentSourceId(srcType, srcProjectId);
+            const contentSourceId = (0, content_store_utils_1.getContentSourceId)(srcType, srcProjectId);
             const contentSourceData = this.getContentSourceDataByIdOrThrow(contentSourceId);
             result = [...contentSourceData.documents, ...contentSourceData.assets];
         }
         else if (documents && documents.length > 0) {
-            const documentsBySourceId = lodash_1.default.groupBy(documents, (document) => getContentSourceId(document.srcType, document.srcProjectId));
+            const documentsBySourceId = lodash_1.default.groupBy(documents, (document) => (0, content_store_utils_1.getContentSourceId)(document.srcType, document.srcProjectId));
             result = lodash_1.default.reduce(documentsBySourceId, (result, documents, contentSourceId) => {
                 const contentSourceData = this.getContentSourceDataByIdOrThrow(contentSourceId);
                 for (const document of documents) {
@@ -479,7 +522,7 @@ class ContentStore {
         };
     }
     getDocument({ srcDocumentId, srcProjectId, srcType }) {
-        const contentSourceId = getContentSourceId(srcType, srcProjectId);
+        const contentSourceId = (0, content_store_utils_1.getContentSourceId)(srcType, srcProjectId);
         const contentSourceData = this.getContentSourceDataByIdOrThrow(contentSourceId);
         return contentSourceData.documentMap[srcDocumentId];
     }
@@ -489,7 +532,7 @@ class ContentStore {
         }, []);
     }
     getAsset({ srcAssetId, srcProjectId, srcType }) {
-        const contentSourceId = getContentSourceId(srcType, srcProjectId);
+        const contentSourceId = (0, content_store_utils_1.getContentSourceId)(srcType, srcProjectId);
         const contentSourceData = this.getContentSourceDataByIdOrThrow(contentSourceId);
         return contentSourceData.assetMap[srcAssetId];
     }
@@ -501,21 +544,21 @@ class ContentStore {
     getLocalizedApiObjects({ locale }) {
         return lodash_1.default.reduce(this.contentSourceDataById, (objects, contentSourceData) => {
             locale = locale !== null && locale !== void 0 ? locale : contentSourceData.defaultLocaleCode;
-            const documentObjects = mapDocumentsToLocalizedApiObjects(contentSourceData.documents, locale);
-            const imageObjects = mapAssetsToLocalizedApiImages(contentSourceData.assets, locale);
+            const documentObjects = (0, store_to_api_docs_converter_1.mapDocumentsToLocalizedApiObjects)(contentSourceData.documents, locale);
+            const imageObjects = (0, store_to_api_docs_converter_1.mapAssetsToLocalizedApiImages)(contentSourceData.assets, locale);
             return objects.concat(documentObjects, imageObjects);
         }, []);
     }
     getApiAssets({ srcType, srcProjectId, pageSize = 20, pageNum = 1, searchQuery } = {}) {
         let assets;
         if (srcProjectId && srcType) {
-            const contentSourceId = getContentSourceId(srcType, srcProjectId);
+            const contentSourceId = (0, content_store_utils_1.getContentSourceId)(srcType, srcProjectId);
             const contentSourceData = this.getContentSourceDataByIdOrThrow(contentSourceId);
-            assets = mapStoreAssetsToAPIAssets(contentSourceData.assets, contentSourceData.defaultLocaleCode);
+            assets = (0, store_to_api_docs_converter_1.mapStoreAssetsToAPIAssets)(contentSourceData.assets, contentSourceData.defaultLocaleCode);
         }
         else {
             assets = lodash_1.default.reduce(this.contentSourceDataById, (result, contentSourceData) => {
-                const assets = mapStoreAssetsToAPIAssets(contentSourceData.assets, contentSourceData.defaultLocaleCode);
+                const assets = (0, store_to_api_docs_converter_1.mapStoreAssetsToAPIAssets)(contentSourceData.assets, contentSourceData.defaultLocaleCode);
                 return result.concat(assets);
             }, []);
         }
@@ -537,7 +580,7 @@ class ContentStore {
     }
     async createAndLinkDocument({ srcType, srcProjectId, srcDocumentId, fieldPath, modelName, object, index, locale, user }) {
         this.logger.debug('createAndLinkDocument', { srcType, srcProjectId, srcDocumentId, fieldPath, modelName, index, locale });
-        const contentSourceId = getContentSourceId(srcType, srcProjectId);
+        const contentSourceId = (0, content_store_utils_1.getContentSourceId)(srcType, srcProjectId);
         const contentSourceData = this.getContentSourceDataByIdOrThrow(contentSourceId);
         // get the document that is being updated
         const document = contentSourceData.documentMap[srcDocumentId];
@@ -554,7 +597,7 @@ class ContentStore {
         }
         // get the 'reference' model field in the updated document that will be used to link the new document
         locale = locale !== null && locale !== void 0 ? locale : contentSourceData.defaultLocaleCode;
-        const modelField = getModelFieldForFieldAtPath(document, model, fieldPath, csiModelMap, locale);
+        const modelField = (0, content_store_utils_1.getModelFieldForFieldAtPath)(document, model, fieldPath, csiModelMap, locale);
         if (!modelField) {
             throw Error(`the "fieldPath" points to non existing model field: ${fieldPath.join('.')}`);
         }
@@ -579,7 +622,7 @@ class ContentStore {
             user: user
         });
         // update the document by linking the field to the created document
-        const userContext = getUserContextForSrcType(srcType, user);
+        const userContext = (0, content_store_utils_1.getUserContextForSrcType)(srcType, user);
         const field = {
             type: 'reference',
             refType: 'document',
@@ -613,7 +656,7 @@ class ContentStore {
     async uploadAndLinkAsset({ srcType, srcProjectId, srcDocumentId, fieldPath, asset, index, locale, user }) {
         this.logger.debug('uploadAndLinkAsset', { srcType, srcProjectId, srcDocumentId, fieldPath, index, locale });
         // get the document that is being updated
-        const contentSourceId = getContentSourceId(srcType, srcProjectId);
+        const contentSourceId = (0, content_store_utils_1.getContentSourceId)(srcType, srcProjectId);
         const contentSourceData = this.getContentSourceDataByIdOrThrow(contentSourceId);
         const document = contentSourceData.documentMap[srcDocumentId];
         const csiDocument = contentSourceData.csiDocumentMap[srcDocumentId];
@@ -629,7 +672,7 @@ class ContentStore {
         }
         // get the 'reference' model field in the updated document that will be used to link the new asset
         locale = locale !== null && locale !== void 0 ? locale : contentSourceData.defaultLocaleCode;
-        const modelField = getModelFieldForFieldAtPath(document, csiModel, fieldPath, csiModelMap, locale);
+        const modelField = (0, content_store_utils_1.getModelFieldForFieldAtPath)(document, csiModel, fieldPath, csiModelMap, locale);
         if (!modelField) {
             throw Error(`the "fieldPath" points to non existing model field: ${fieldPath.join('.')}`);
         }
@@ -638,7 +681,7 @@ class ContentStore {
             throw Error(`error in "uploadAndLinkAsset", this operation can only be used on reference and image fields: ${fieldPath.join('.')}`);
         }
         // upload the new asset
-        const userContext = getUserContextForSrcType(srcType, user);
+        const userContext = (0, content_store_utils_1.getUserContextForSrcType)(srcType, user);
         const result = await contentSourceData.instance.uploadAsset({
             url: asset.url,
             fileName: asset.metadata.name,
@@ -679,22 +722,22 @@ class ContentStore {
     }
     async createDocument({ srcType, srcProjectId, modelName, object, locale, user }) {
         this.logger.debug('createDocument', { srcType, srcProjectId, modelName, locale });
-        const contentSourceId = getContentSourceId(srcType, srcProjectId);
+        const contentSourceId = (0, content_store_utils_1.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 !== null && locale !== void 0 ? locale : contentSourceData.defaultLocaleCode;
-        const userContext = getUserContextForSrcType(srcType, user);
-        const result = await createDocumentRecursively({
+        const csiModelMap = contentSourceData.csiModelMap;
+        const userContext = (0, content_store_utils_1.getUserContextForSrcType)(srcType, user);
+        const resolvedLocale = locale !== null && locale !== void 0 ? locale : contentSourceData.defaultLocaleCode;
+        const result = await (0, create_update_csi_docs_1.createDocumentRecursively)({
             object,
-            model,
+            modelName,
             modelMap,
-            locale,
-            userContext,
-            contentSourceInstance: contentSourceData.instance
+            createDocument: (0, create_update_csi_docs_1.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,
@@ -706,9 +749,9 @@ class ContentStore {
     }
     async updateDocument({ srcType, srcProjectId, srcDocumentId, updateOperations, user }) {
         this.logger.debug('updateDocument');
-        const contentSourceId = getContentSourceId(srcType, srcProjectId);
+        const contentSourceId = (0, content_store_utils_1.getContentSourceId)(srcType, srcProjectId);
         const contentSourceData = this.getContentSourceDataByIdOrThrow(contentSourceId);
-        const userContext = getUserContextForSrcType(srcType, user);
+        const userContext = (0, content_store_utils_1.getUserContextForSrcType)(srcType, user);
         const document = contentSourceData.documentMap[srcDocumentId];
         const csiDocument = contentSourceData.csiDocumentMap[srcDocumentId];
         if (!document || !csiDocument) {
@@ -724,17 +767,20 @@ class ContentStore {
         const operations = await (0, utils_1.mapPromise)(updateOperations, async (updateOperation) => {
             var _a;
             const locale = (_a = updateOperation.locale) !== null && _a !== void 0 ? _a : contentSourceData.defaultLocaleCode;
-            const modelField = getModelFieldForFieldAtPath(document, model, updateOperation.fieldPath, modelMap, locale);
+            const modelField = (0, content_store_utils_1.getModelFieldForFieldAtPath)(document, model, updateOperation.fieldPath, modelMap, locale);
             switch (updateOperation.opType) {
                 case 'set':
-                    const field = await convertOperationField({
+                    const field = await (0, create_update_csi_docs_1.convertOperationField)({
                         operationField: updateOperation.field,
                         fieldPath: updateOperation.fieldPath,
-                        locale: updateOperation.locale,
                         modelField,
                         modelMap,
-                        userContext,
-                        contentSourceInstance: contentSourceData.instance
+                        createDocument: (0, create_update_csi_docs_1.getCreateDocumentThunk)({
+                            locale: updateOperation.locale,
+                            csiModelMap,
+                            userContext,
+                            contentSourceInstance: contentSourceData.instance
+                        })
                     });
                     return {
                         ...updateOperation,
@@ -744,14 +790,17 @@ class ContentStore {
                 case 'unset':
                     return { ...updateOperation, modelField };
                 case 'insert':
-                    const item = await convertOperationField({
+                    const item = await (0, create_update_csi_docs_1.convertOperationField)({
                         operationField: updateOperation.item,
                         fieldPath: updateOperation.fieldPath,
-                        locale: updateOperation.locale,
                         modelField,
                         modelMap,
-                        userContext,
-                        contentSourceInstance: contentSourceData.instance
+                        createDocument: (0, create_update_csi_docs_1.getCreateDocumentThunk)({
+                            locale: updateOperation.locale,
+                            csiModelMap,
+                            userContext,
+                            contentSourceInstance: contentSourceData.instance
+                        })
                     });
                     return {
                         ...updateOperation,
@@ -778,22 +827,24 @@ class ContentStore {
     }
     async duplicateDocument({ srcType, srcProjectId, srcDocumentId, object, user }) {
         this.logger.debug('duplicateDocument');
-        const contentSourceId = getContentSourceId(srcType, srcProjectId);
+        const contentSourceId = (0, content_store_utils_1.getContentSourceId)(srcType, srcProjectId);
         const contentSourceData = this.getContentSourceDataByIdOrThrow(contentSourceId);
         const document = contentSourceData.documentMap[srcDocumentId];
         if (!document) {
             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`);
         }
-        const userContext = getUserContextForSrcType(srcType, user);
+        const userContext = (0, content_store_utils_1.getUserContextForSrcType)(srcType, user);
         // 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()
@@ -809,12 +860,14 @@ class ContentStore {
             modelFields: model.fields,
             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
         });
@@ -822,10 +875,10 @@ class ContentStore {
     }
     async uploadAssets({ srcType, srcProjectId, assets, locale, user }) {
         this.logger.debug('uploadAssets');
-        const contentSourceId = getContentSourceId(srcType, srcProjectId);
+        const contentSourceId = (0, content_store_utils_1.getContentSourceId)(srcType, srcProjectId);
         const contentSourceData = this.getContentSourceDataByIdOrThrow(contentSourceId);
         const sourceAssets = [];
-        const userContext = getUserContextForSrcType(srcType, user);
+        const userContext = (0, content_store_utils_1.getUserContextForSrcType)(srcType, user);
         locale = locale !== null && locale !== void 0 ? locale : contentSourceData.defaultLocaleCode;
         for (const asset of assets) {
             let base64 = undefined;
@@ -845,17 +898,17 @@ class ContentStore {
             });
             sourceAssets.push(sourceAsset);
         }
-        const storeAssets = mapCSIAssetsToStoreAssets({
+        const storeAssets = (0, csi_to_store_docs_converter_1.mapCSIAssetsToStoreAssets)({
             csiAssets: sourceAssets,
             contentSourceInstance: contentSourceData.instance,
             defaultLocaleCode: contentSourceData.defaultLocaleCode
         });
-        return mapStoreAssetsToAPIAssets(storeAssets, locale);
+        return (0, store_to_api_docs_converter_1.mapStoreAssetsToAPIAssets)(storeAssets, locale);
     }
     async deleteDocument({ srcType, srcProjectId, srcDocumentId, user }) {
         this.logger.debug('deleteDocument');
-        const userContext = getUserContextForSrcType(srcType, user);
-        const contentSourceId = getContentSourceId(srcType, srcProjectId);
+        const userContext = (0, content_store_utils_1.getUserContextForSrcType)(srcType, user);
+        const contentSourceId = (0, content_store_utils_1.getContentSourceId)(srcType, srcProjectId);
         const contentSourceData = this.getContentSourceDataByIdOrThrow(contentSourceId);
         const csiDocument = contentSourceData.csiDocumentMap[srcDocumentId];
         if (!csiDocument) {
@@ -869,13 +922,13 @@ class ContentStore {
     }
     async validateDocuments({ objects, locale, user }) {
         this.logger.debug('validateDocuments');
-        const objectsBySourceId = lodash_1.default.groupBy(objects, (object) => getContentSourceId(object.srcType, object.srcProjectId));
+        const objectsBySourceId = lodash_1.default.groupBy(objects, (object) => (0, content_store_utils_1.getContentSourceId)(object.srcType, object.srcProjectId));
         let errors = [];
         for (const [contentSourceId, contentSourceObjects] of Object.entries(objectsBySourceId)) {
             const contentSourceData = this.getContentSourceDataByIdOrThrow(contentSourceId);
             locale = locale !== null && locale !== void 0 ? locale : contentSourceData.defaultLocaleCode;
             const { documents, assets } = getCSIDocumentsAndAssetsFromContentSourceDataByIds(contentSourceData, contentSourceObjects);
-            const userContext = getUserContextForSrcType(contentSourceData.type, user);
+            const userContext = (0, content_store_utils_1.getUserContextForSrcType)(contentSourceData.type, user);
             const internalValidationErrors = internalValidateContent(documents, assets, contentSourceData);
             const validationResult = await contentSourceData.instance.validateDocuments({ documents, assets, locale, userContext });
             errors = errors.concat(internalValidationErrors, validationResult.errors.map((validationError) => ({
@@ -904,12 +957,28 @@ class ContentStore {
         );
          */
     }
+    async searchDocuments(data) {
+        this.logger.debug('searchDocuments');
+        const objectsBySourceId = lodash_1.default.groupBy(data.models, (object) => (0, content_store_utils_1.getContentSourceId)(object.srcType, object.srcProjectId));
+        const documents = [];
+        const schema = {};
+        Object.keys(objectsBySourceId).forEach((contentSourceId) => {
+            const contentSourceData = this.getContentSourceDataByIdOrThrow(contentSourceId);
+            documents.push(...contentSourceData.documents);
+            lodash_1.default.set(schema, [contentSourceData.type, contentSourceData.projectId], contentSourceData.modelMap);
+        });
+        return (0, search_utils_1.searchDocuments)({
+            ...data,
+            documents,
+            schema
+        });
+    }
     async publishDocuments({ objects, user }) {
         this.logger.debug('publishDocuments');
-        const objectsBySourceId = lodash_1.default.groupBy(objects, (object) => getContentSourceId(object.srcType, object.srcProjectId));
+        const objectsBySourceId = lodash_1.default.groupBy(objects, (object) => (0, content_store_utils_1.getContentSourceId)(object.srcType, object.srcProjectId));
         for (const [contentSourceId, contentSourceObjects] of Object.entries(objectsBySourceId)) {
             const contentSourceData = this.getContentSourceDataByIdOrThrow(contentSourceId);
-            const userContext = getUserContextForSrcType(contentSourceData.type, user);
+            const userContext = (0, content_store_utils_1.getUserContextForSrcType)(contentSourceData.type, user);
             const { documents, assets } = getCSIDocumentsAndAssetsFromContentSourceDataByIds(contentSourceData, contentSourceObjects);
             await contentSourceData.instance.publishDocuments({ documents, assets, userContext });
         }
@@ -923,881 +992,10 @@ class ContentStore {
     }
 }
 exports.ContentStore = ContentStore;
-function getContentSourceId(contentSourceType, srcProjectId) {
-    return contentSourceType + ':' + srcProjectId;
-}
-exports.getContentSourceId = getContentSourceId;
-function getUserContextForSrcType(srcType, user) {
-    var _a;
-    return (_a = user === null || user === void 0 ? void 0 : user.connections) === null || _a === void 0 ? void 0 : _a.find((connection) => connection.type === srcType);
-}
-function mapCSIAssetsToStoreAssets({ csiAssets, contentSourceInstance, defaultLocaleCode }) {
-    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 }) {
-    return {
-        type: 'asset',
-        ...extra,
-        srcObjectId: csiAsset.id,
-        srcObjectUrl: csiAsset.manageUrl,
-        srcObjectLabel: getObjectLabel(csiAsset.fields, common_schema_1.IMAGE_MODEL, defaultLocaleCode),
-        srcModelName: common_schema_1.IMAGE_MODEL.name,
-        srcModelLabel: common_schema_1.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 }) {
-    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 }) {
-    var _a, _b;
-    return {
-        type: 'document',
-        ...extra,
-        srcObjectId: csiDocument.id,
-        srcObjectUrl: csiDocument.manageUrl,
-        srcObjectLabel: getObjectLabel(csiDocument.fields, model, defaultLocaleCode),
-        srcModelLabel: (_a = model.label) !== null && _a !== void 0 ? _a : lodash_1.default.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: (_b = model.fields) !== null && _b !== void 0 ? _b : [],
-            context: {
-                modelMap,
-                defaultLocaleCode
-            }
-        })
-    };
-}
-function mapCSIFieldsToStoreFields({ csiDocumentFields, modelFields, context }) {
-    return modelFields.reduce((result, 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 }) {
-    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)
-        };
-    }
-    // TODO: check if need to add "options" to "enum" and subtype/min/max to "number"
-    switch (modelField.type) {
-        case 'object':
-            return mapObjectField(csiDocumentField, modelField, context);
-        case 'model':
-            return mapModelField(csiDocumentField, modelField, context);
-        case 'list':
-            return mapListField(csiDocumentField, modelField, context);
-        case 'richText':
-            return mapRichTextField(csiDocumentField);
-        case 'markdown':
-            return mapMarkdownField(csiDocumentField);
-        default:
-            return csiDocumentField;
-    }
-}
-function mapObjectField(csiDocumentField, modelField, context) {
-    var _a, _b, _c;
-    if (!(0, content_source_interface_1.isLocalizedField)(csiDocumentField)) {
-        return {
-            type: csiDocumentField.type,
-            srcObjectLabel: getObjectLabel((_a = csiDocumentField.fields) !== null && _a !== void 0 ? _a : {}, modelField !== null && modelField !== void 0 ? modelField : [], context.defaultLocaleCode),
-            fields: mapCSIFieldsToStoreFields({
-                csiDocumentFields: (_b = csiDocumentField.fields) !== null && _b !== void 0 ? _b : {},
-                modelFields: (_c = modelField.fields) !== null && _c !== void 0 ? _c : [],
-                context
-            })
-        };
-    }
-    return {
-        type: csiDocumentField.type,
-        localized: true,
-        locales: lodash_1.default.mapValues(csiDocumentField.locales, (locale) => {
-            var _a, _b, _c;
-            return {
-                locale: locale.locale,
-                srcObjectLabel: getObjectLabel((_a = locale.fields) !== null && _a !== void 0 ? _a : {}, modelField, locale.locale),
-                fields: mapCSIFieldsToStoreFields({
-                    csiDocumentFields: (_b = locale.fields) !== null && _b !== void 0 ? _b : {},
-                    modelFields: (_c = modelField.fields) !== null && _c !== void 0 ? _c : [],
-                    context
-                })
-            };
-        })
-    };
-}
-function mapModelField(csiDocumentField, modelField, context) {
-    var _a, _b, _c, _d;
-    if (!(0, content_source_interface_1.isLocalizedField)(csiDocumentField)) {
-        const model = context.modelMap[csiDocumentField.modelName];
-        return {
-            type: csiDocumentField.type,
-            srcObjectLabel: getObjectLabel((_a = csiDocumentField.fields) !== null && _a !== void 0 ? _a : {}, model, context.defaultLocaleCode),
-            srcModelName: csiDocumentField.modelName,
-            srcModelLabel: (_b = model.label) !== null && _b !== void 0 ? _b : lodash_1.default.startCase(model.name),
-            fields: mapCSIFieldsToStoreFields({
-                csiDocumentFields: (_c = csiDocumentField.fields) !== null && _c !== void 0 ? _c : {},
-                modelFields: (_d = model.fields) !== null && _d !== void 0 ? _d : [],
-                context
-            })
-        };
-    }
-    return {
-        type: csiDocumentField.type,
-        localized: true,
-        locales: lodash_1.default.mapValues(csiDocumentField.locales, (locale) => {
-            var _a, _b, _c, _d;
-            const model = context.modelMap[locale.modelName];
-            return {
-                locale: locale.locale,
-                srcObjectLabel: getObjectLabel((_a = locale.fields) !== null && _a !== void 0 ? _a : {}, model, locale.locale),
-                srcModelName: locale.modelName,
-                srcModelLabel: (_b = model.label) !== null && _b !== void 0 ? _b : lodash_1.default.startCase(model.name),
-                fields: mapCSIFieldsToStoreFields({
-                    csiDocumentFields: (_c = locale.fields) !== null && _c !== void 0 ? _c : {},
-                    modelFields: (_d = model.fields) !== null && _d !== void 0 ? _d : [],
-                    context
-                })
-            };
-        })
-    };
-}
-function mapListField(csiDocumentField, modelField, context) {
-    if (!(0, content_source_interface_1.isLocalizedField)(csiDocumentField)) {
-        return {
-            type: csiDocumentField.type,
-            items: csiDocumentField.items.map((item) => {
-                var _a;
-                return mapCSIFieldToStoreField({
-                    csiDocumentField: item,
-                    modelField: (_a = modelField.items) !== null && _a !== void 0 ? _a : { type: 'string' },
-                    context
-                });
-            })
-        };
-    }
-    return {
-        type: csiDocumentField.type,
-        localized: true,
-        locales: lodash_1.default.mapValues(csiDocumentField.locales, (locale) => {
-            var _a;
-            return {
-                locale: locale.locale,
-                items: ((_a = locale.items) !== null && _a !== void 0 ? _a : []).map((item) => {
-                    var _a;
-                    return mapCSIFieldToStoreField({
-                        csiDocumentField: item,
-                        modelField: (_a = modelField.items) !== null && _a !== void 0 ? _a : { type: 'string' },
-                        context
-                    });
-                })
-            };
-        })
-    };
-}
-function mapRichTextField(csiDocumentField) {
-    if (!(0, content_source_interface_1.isLocalizedField)(csiDocumentField)) {
-        return {
-            ...csiDocumentField,
-            multiElement: true
-        };
-    }
-    return {
-        type: csiDocumentField.type,
-        localized: true,
-        locales: lodash_1.default.mapValues(csiDocumentField.locales, (locale) => {
-            return {
-                ...locale,
-                multiElement: true
-            };
-        })
-    };
-}
-function mapMarkdownField(csiDocumentField) {
-    if (!(0, content_source_interface_1.isLocalizedField)(csiDocumentField)) {
-        return {
-            type: 'markdown',
-            value: csiDocumentField.value,
-            multiElement: true
-        };
-    }
-    return {
-        type: 'markdown',
-        localized: true,
-        locales: lodash_1.default.mapValues(csiDocumentField.locales, (locale) => {
-            return {
-                ...locale,
-                multiElement: true
-            };
-        })
-    };
-}
 function mapStoreFieldsToOperationFields({ documentFields, modelFields, modelMap }) {
     // TODO: implement
     throw new Error(`duplicateDocument not implemented yet`);
 }
-function getContentSourceIdForContentSource(contentSource) {
-    return getContentSourceId(contentSource.getContentSourceType(), contentSource.getProjectId());
-}
-function extractTokensFromString(input) {
-    return input.match(/(?<={)[^}]+(?=})/g) || [];
-}
-function sanitizeSlug(slug) {
-    return slug
-        .split('/')
-        .map((part) => (0, slugify_1.default)(part, { lower: true }))
-        .join('/');
-}
-function getObjectLabel(documentFields, modelOrObjectField, locale) {
-    const labelField = modelOrObjectField.labelField;
-    let label = null;
-    if (labelField) {
-        const field = lodash_1.default.get(documentFields, labelField, null);
-        if (field && ['string', 'url', 'slug', 'text', 'markdown', 'number', 'enum', 'date', 'datetime', 'color', 'image', 'file'].includes(field.type)) {
-            if ((0, content_source_interface_1.isLocalizedField)(field) && locale) {
-                label = lodash_1.default.get(field, ['locales', locale, 'value'], null);
-            }
-            else if (!(0, content_source_interface_1.isLocalizedField)(field)) {
-                label = lodash_1.default.get(field, 'value', null);
-            }
-        }
-    }
-    if (!label) {
-        label = lodash_1.default.get(modelOrObjectField, 'label');
-    }
-    if (!label && lodash_1.default.has(modelOrObjectField, 'name')) {
-        label = lodash_1.default.startCase(lodash_1.default.get(modelOrObjectField, 'name'));
-    }
-    return label;
-}
-function mapDocumentsToLocalizedApiObjects(documents, locale) {
-    return documents.map((document) => documentToLocalizedApiObject(document, locale));
-}
-function documentToLocalizedApiObject(document, locale) {
-    const { type, fields, ...rest } = document;
-    return {
-        type: 'object',
-        ...rest,
-        fields: toLocalizedAPIFields(fields, locale)
-    };
-}
-function toLocalizedAPIFields(docFields, locale) {
-    return lodash_1.default.mapValues(docFields, (docField) => toLocalizedAPIField(docField, locale));
-}
-function toLocalizedAPIField(docField, locale, isListItem = false) {
-    const hasUnsetFlag = ['object', 'model', 'reference', 'richText', 'markdown', 'image', 'file', 'json'].includes(docField.type);
-    let docFieldLocalized;
-    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)
-        };
-    }
-    else {
-        docFieldLocalized = docField;
-    }
-    locale = locale !== null && locale !== void 0 ? 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)
-                })
-        };
-    }
-    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 !== null && items !== void 0 ? items : []).map((field) => toLocalizedAPIField(field, locale, true))
-        };
-    }
-    else {
-        return {
-            ...docFieldLocalized,
-            ...commonProps
-        };
-    }
-}
-function mapAssetsToLocalizedApiImages(assets, locale) {
-    return assets.map((asset) => assetToLocalizedApiImage(asset, locale));
-}
-function assetToLocalizedApiImage(asset, locale) {
-    const { type, fields, ...rest } = asset;
-    return {
-        type: 'image',
-        ...rest,
-        fields: localizeAssetFields(fields, locale)
-    };
-}
-function localizeAssetFields(assetFields, locale) {
-    var _a, _b;
-    const fields = {
-        title: {
-            type: 'string',
-            value: null
-        },
-        url: {
-            type: 'string',
-            value: null
-        }
-    };
-    const titleFieldNonLocalized = getDocumentFieldForLocale(assetFields.title, locale);
-    fields.title.value = titleFieldNonLocalized === null || titleFieldNonLocalized === void 0 ? void 0 : titleFieldNonLocalized.value;
-    fields.title.locale = locale !== null && locale !== void 0 ? locale : titleFieldNonLocalized === null || titleFieldNonLocalized === void 0 ? void 0 : titleFieldNonLocalized.locale;
-    const assetFileField = assetFields.file;
-    if (assetFileField.localized) {
-        if (locale) {
-            fields.url.value = (_b = (_a = assetFileField.locales[locale]) === null || _a === void 0 ? void 0 : _a.url) !== null && _b !== void 0 ? _b : null;
-            fields.url.locale = locale;
-        }
-    }
-    else {
-        fields.url.value = assetFileField.url;
-        fields.url.locale = assetFileField.locale;
-    }
-    return fields;
-}
-function mapStoreAssetsToAPIAssets(assets, locale) {
-    return assets.map((asset) => storeAssetToAPIAsset(asset, locale));
-}
-function storeAssetToAPIAsset(asset, locale) {
-    var _a, _b;
-    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,
-        ...(0, utils_1.omitByNil)({
-            title: localizedTitleField.value,
-            fileName: localizedFileField.fileName,
-            contentType: localizedFileField.contentType,
-            size: localizedFileField.size,
-            width: (_a = localizedFileField.dimensions) === null || _a === void 0 ? void 0 : _a.width,
-            height: (_b = localizedFileField.dimensions) === null || _b === void 0 ? void 0 : _b.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 }) {
-    var _a;
-    if (model.type === 'page') {
-        const tokens = extractTokensFromString(String(model.urlPath));
-        const slugField = lodash_1.default.last(tokens);
-        if (object && slugField && slugField in object) {
-            const slugFieldValue = object[slugField];
-            object[slugField] = sanitizeSlug(slugFieldValue);
-        }
-    }
-    const nestedResult = await createNestedObjectRecursively({
-        object,
-        modelFields: (_a = model.fields) !== null && _a !== void 0 ? _a : [],
-        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 = object !== null && object !== void 0 ? object : {};
-    const result = {
-        fields: {},
-        newRefDocuments: []
-    };
-    const objectFieldNames = Object.keys(object);
-    for (const modelField of modelFields) {
-        const fieldName = modelField.name;
-        let value;
-        if (fieldName in object) {
-            value = object[fieldName];
-            lodash_1.default.pull(objectFieldNames, fieldName);
-        }
-        else if (modelField.const) {
-            value = modelField.const;
-        }
-        else if (!lodash_1.default.isNil(modelField.default)) {
-            value = modelField.default;
-        }
-        if (!lodash_1.default.isNil(value)) {
-            const fieldResult = await createNestedField({
-                value,
-                modelField,
-                fieldPath: fieldPath.concat(fieldName),
-                modelMap,
-                locale,
-                userContext,
-                contentSourceInstance
-            });
-            result.fields[fieldName] = fieldResult.field;
-            result.newRefDocuments = result.newRefDocuments.concat(fieldResult.newRefDocuments);
-        }
-    }
-    if (objectFieldNames.length > 0) {
-        throw new Error(`no model fields found when creating a document with fields: '${objectFieldNames.join(', ')}'`);
-    }
-    return result;
-}
-async function createNestedField({ value, modelField, fieldPath, modelMap, locale, userContext, contentSourceInstance }) {
-    var _a;
-    if (modelField.type === 'object') {
-        const result = await createNestedObjectRecursively({
-            object: value,
-            modelFields: modelField.fields,
-            fieldPath,
-            modelMap,
-            locale,
-            userContext,
-            contentSourceInstance
-        });
-        return {
-            field: {
-                type: 'object',
-                fields: result.fields
-            },
-            newRefDocuments: result.newRefDocuments
-        };
-    }
-    else if (modelField.type === 'model') {
-        let { $$type, ...rest } = value;
-        const modelNames = modelField.models;
-        // for backward compatibility check if the object has 'type' instead of '$$type' because older projects use
-        // the 'type' property in default values
-        if (!$$type && 'type' in rest) {
-            $$type = rest.type;
-            rest = lodash_1.default.omit(rest, 'type');
-        }
-        const modelName = $$type !== null && $$type !== void 0 ? $$type : (modelNames.length === 1 ? modelNames[0] : null);
-        if (!modelName) {
-            throw new Error(`no $$type was specified for nested model`);
-        }
-        const model = modelMap[modelName];
-        if (!model) {
-            throw new Error(`no model with name '${modelName}' was found`);
-        }
-        const result = await createNestedObjectRecursively({
-            object: rest,
-            modelFields: (_a = model.fields) !== null && _a !== void 0 ? _a : [],
-            fieldPath,
-            modelMap,
-            locale,
-            userContext,
-            contentSourceInstance
-        });
-        return {
-            field: {
-                type: 'model',
-                modelName: modelName,
-                fields: result.fields
-            },
-            newRefDocuments: result.newRefDocuments
-        };
-    }
-    else if (modelField.type === 'image') {
-        let refId;
-        if (lodash_1.default.isPlainObject(value)) {
-            refId = value.$$ref;
-        }
-        else {
-            refId = value;
-        }
-        if (!refId) {
-            throw new Error(`reference field must specify a value`);
-        }
-        return {
-            field: {
-                type: 'reference',
-                refType: 'asset',
-                refId: refId
-            },
-            newRefDocuments: []
-        };
-    }
-    else if (modelField.type === 'reference') {
-        let { $$ref: refId = null, $$type: modelName = null, ...rest } = lodash_1.default.isPlainObject(value) ? value : { $$ref: value };
-        if (refId) {
-            return {
-                field: {
-                    type: 'reference',
-                    refType: 'document',
-                    refId: refId
-                },
-                newRefDocuments: []
-            };
-        }
-        else {
-            const modelNames = modelField.models;
-            if (!modelName) {
-                // for backward compatibility check if the object has 'type' instead of '$$type' because older projects use
-                // the 'type' property in default values
-                if ('type' in rest) {
-                    modelName = rest.type;
-                    rest = lodash_1.default.omit(rest, 'type');
-                }
-                else if (modelNames.length === 1) {
-                    modelName = modelNames[0];
-                }
-            }
-            const model = modelMap[modelName];
-            if (!model) {
-                throw new Error(`no model with name '${modelName}' was found`);
-            }
-            const { document, newRefDocuments } = await createDocumentRecursively({
-                object: rest,
-                model: model,
-                modelMap,
-                locale,
-                userContext,
-                contentSourceInstance
-            });
-            return {
-                field: {
-                    type: 'reference',
-                    refType: 'document',
-                    refId: document.id
-                },
-                newRefDocuments: [document, ...newRefDocuments]
-            };
-        }
-    }
-    else if (modelField.type === 'list') {
-        if (!Array.isArray(value)) {
-            throw new Error(`value for list field must be array`);
-        }
-        const itemsField = modelField.items;
-        if (!itemsField) {
-            throw new Error(`list field does not define items`);
-        }
-        const arrayResult = await (0, utils_1.mapPromise)(value, async (item, index) => {
-            return createNestedField({
-                value: item,
-                modelField: itemsField,
-                fieldPath: fieldPath.concat(index),
-                modelMap,
-                locale,
-                userContext,
-                contentSourceInstance
-            });
-        });
-        return {
-            field: {
-                type: 'list',
-                items: arrayResult.map((result) => result.field)
-            },
-            newRefDocuments: arrayResult.reduce((result, { newRefDocuments }) => result.concat(newRefDocuments), [])
-        };
-    }
-    return {
-        field: {
-            type: modelField.type,
-            value: value
-        },
-        newRefDocuments: []
-    };
-}
-function getModelFieldForFieldAtPath(document, model, fieldPath, modelMap, locale) {
-    if (lodash_1.default.isEmpty(fieldPath)) {
-        throw new Error('the fieldPath can not be empty');
-    }
-    function getField(docField, modelField, fieldPath) {
-        const fieldName = lodash_1.default.head(fieldPath);
-        if (typeof fieldName === 'undefined') {
-            throw new Error('the first fieldPath item must be string');
-        }
-        const childFieldPath = lodash_1.default.tail(fieldPath);
-        let childDocField;
-        let childModelField;
-        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 = lodash_1.default.find(modelField.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 = lodash_1.default.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];
-                const listItemsModel = modelField.items;
-                if (!listItem || !listItemsModel) {
-                    throw new Error(`field ${fieldName} doesn't exist`);
-                }
-                if (childFieldPath.length === 0) {
-                    return modelField;
-                }
-                if (!Array.isArray(listItemsModel)) {
-                    return getField(listItem, listItemsModel, childFieldPath);
-                }
-                else {
-                    const fieldListItems = listItemsModel.find((listItemsModel) => listItemsModel.type === listItem.type);
-                    if (!fieldListItems) {
-                        throw new Error('cannot find matching field model');
-                    }
-                    return getField(listItem, fieldListItems, childFieldPath);
-                }
-            default:
-                if (!lodash_1.default.isEmpty(childFieldPath)) {
-                    throw new Error('illegal fieldPath');
-                }
-                return modelField;
-        }
-    }
-    const fieldName = lodash_1.default.head(fieldPath);
-    const childFieldPath = lodash_1.default.tail(fieldPath);
-    if (typeof fieldName !== 'string') {
-        throw new Error('the first fieldPath item must be string');
-    }
-    const childDocField = document.fields[fieldName];
-    const childModelField = lodash_1.default.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 }) {
-    // for insert operations, the modelField will be of the list, so get the modelField of the list items
-    const modelFieldOrListItems = modelField.type === 'list' ? modelField.items : modelField;
-    switch (operationField.type) {
-        case 'object': {
-            const result = await createNestedObjectRecursively({
-                object: operationField.object,
-                modelFields: modelFieldOrListItems.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 (0, utils_1.mapPromise)(operationField.items, async (item, index) => {
-                const result = await createNestedField({
-                    value: item,
-                    modelField: modelField.items,
-                    fieldPath,
-                    modelMap,
-                    locale,
-                    userContext,
-                    contentSourceInstance
-                });
-                return result.field;
-            });
-            return {
-                type: operationField.type,
-                items: result
-            };
-        }
-        case 'string':
-            // 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;
-        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;
-        case 'image':
-            return operationField;
-        default:
-            return operationField;
-    }
-}
-function getDocumentFieldForLocale(docField, locale) {
-    if (docField.localized) {
-        if (!locale) {
-            return null;
-        }
-        const { localized, locales, ...base } = docField;
-        const localizedField = locales[locale];
-        if (!localizedField) {
-            return null;
-        }
-        return {
-            ...base,
-            ...localizedField
-        };
-    }
-    else {
-        return docField;
-    }
-}
 function getCSIDocumentsAndAssetsFromContentSourceDataByIds(contentSourceData, objects) {
     const documents = [];
     const assets = [];