@stackbit/cms-core 0.1.6 → 0.1.7

package/dist/content-store.js

@@ -16,11 +16,16 @@ const csi_to_store_docs_converter_1 = require("./utils/csi-to-store-docs-convert
 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");
+const model_utils_1 = require("./utils/model-utils");
+const common_schema_1 = require("./common/common-schema");
 class ContentStore {
     constructor(options) {
         this.contentSources = [];
         this.contentSourceDataById = {};
-        this.rawStackbitConfig = null;
+        this.stackbitConfig = null;
+        this.yamlModels = [];
+        this.configModels = [];
+        this.presets = {};
         this.logger = options.logger.createLogger({ label: 'content-store' });
         this.userLogger = options.userLogger.createLogger({ label: 'content-store' });
         this.localDev = options.localDev;
@@ -63,6 +68,10 @@ class ContentStore {
     }
     async init({ stackbitConfig }) {
         this.logger.debug('init');
+        if (stackbitConfig) {
+            this.yamlModels = await this.loadYamlModels({ stackbitConfig });
+            this.presets = await this.loadPresets({ stackbitConfig });
+        }
         await this.setStackbitConfig({ stackbitConfig, init: true });
     }
     async onStackbitConfigChange({ stackbitConfig }) {
@@ -70,38 +79,17 @@ class ContentStore {
         await this.setStackbitConfig({ stackbitConfig, init: true });
     }
     async setStackbitConfig({ stackbitConfig, init }) {
-        // TODO: Use stackbitConfig instead of loading rawStackbitConfig here
-        //  by splitting config loader into independent phases:
-        //  1. load and validate only the root config props
-        //  2. load content-source models
-        //  3. merge content-source models with config.models or via config.mapModels, sanitize and validate
-        //  4. load presets, adjust presets to have srcType and srcProjectId
-        if (!stackbitConfig) {
-            this.rawStackbitConfig = null;
-        }
-        else {
-            const rawConfigResult = await (0, sdk_1.loadConfigFromDir)({
-                dirPath: stackbitConfig.dirPath,
-                logger: this.logger
-            });
-            for (const error of rawConfigResult.errors) {
-                this.userLogger.warn(error.message);
-            }
-            if (rawConfigResult.config) {
-                this.rawStackbitConfig = {
-                    ...rawConfigResult.config,
-                    contentSources: stackbitConfig.contentSources
-                };
-            }
-            else {
-                this.rawStackbitConfig = null;
-            }
-        }
-        await this.loadContentSources({ init });
+        this.stackbitConfig = stackbitConfig;
+        this.configModels = this.mergeConfigModels(this.stackbitConfig, this.yamlModels);
+        await this.loadAllContentSourcesAndProcessData({ init });
     }
     /**
      * This method is called when contentUpdatesWatchTimer receives timeout.
-     * It then notifies all content sources to stop watching for content changes.
+     * This happens when the user is not using the Stackbit app for some time
+     * but container is not hibernated.
+     * It then notifies all content sources to stop watching for content
+     * changes, which in turn stops polling CMS for content changes and helps
+     * reducing the CMS API usage.
      */
     handleTimerTimeout() {
         for (const contentSourceInstance of this.contentSources) {
@@ -119,7 +107,7 @@ class ContentStore {
             return;
         }
         this.logger.debug('keepAlive => contentUpdatesWatchTimer is not running => load content source data');
-        await this.loadContentSources({ init: false });
+        await this.loadAllContentSourcesAndProcessData({ init: false });
     }
     /**
      * This method is called when a content source notifies Stackbit of models
@@ -132,65 +120,155 @@ class ContentStore {
      */
     async onContentSourceSchemaChange({ contentSourceId }) {
         this.logger.debug('onContentSourceSchemaChange', { contentSourceId });
-        const contentSourceData = this.getContentSourceDataByIdOrThrow(contentSourceId);
-        this.contentSourceDataById[contentSourceId] = await this.loadContentSourceData({
-            contentSourceInstance: contentSourceData.instance,
-            init: false
-        });
-        this.onSchemaChangeCallback();
+        await this.reloadContentSourcesByIdAndProcessData({ contentSourceIds: [contentSourceId] });
     }
     async onFilesChange(updatedFiles) {
         var _a, _b;
         this.logger.debug('onFilesChange');
-        let someContentSourceSchemaUpdated = false;
-        const contentChanges = {
-            updatedDocuments: [],
-            updatedAssets: [],
-            deletedDocuments: [],
-            deletedAssets: []
-        };
+        let schemaChanged = false;
+        if (this.stackbitConfig) {
+            // Check if any of the yaml models files were changed. If yaml model files were changed,
+            // reload them and merge them with models defined in stackbit config.
+            const modelDirs = (0, sdk_1.getYamlModelDirs)(this.stackbitConfig);
+            const yamlModelsChanged = updatedFiles.find((updatedFile) => lodash_1.default.some(modelDirs, (modelDir) => updatedFile.startsWith(modelDir)));
+            if (yamlModelsChanged) {
+                this.logger.debug('identified change in stackbit model files');
+                schemaChanged = true;
+                this.yamlModels = await this.loadYamlModels({ stackbitConfig: this.stackbitConfig });
+                this.configModels = this.mergeConfigModels(this.stackbitConfig, this.yamlModels);
+            }
+            // Check if any of the preset files were changed. If presets were changed, reload them.
+            const presetDirs = (0, sdk_1.getPresetDirs)(this.stackbitConfig);
+            const presetsChanged = updatedFiles.find((updatedFile) => lodash_1.default.some(presetDirs, (presetDir) => updatedFile.startsWith(presetDir)));
+            if (presetsChanged) {
+                this.logger.debug('identified change in stackbit preset files');
+                schemaChanged = true;
+                this.presets = await this.loadPresets({ stackbitConfig: this.stackbitConfig });
+            }
+        }
+        const contentSourceIdsWithChangedSchema = [];
+        const contentChangeEvents = [];
         for (const contentSourceInstance of this.contentSources) {
             const contentSourceId = (0, content_store_utils_1.getContentSourceIdForContentSource)(contentSourceInstance);
             this.logger.debug(`call onFilesChange for contentSource: ${contentSourceId}`);
-            const { schemaChanged, contentChangeEvent } = (_b = (await ((_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}`);
+            const onFilesChangeResult = (_b = (await ((_a = contentSourceInstance.onFilesChange) === null || _a === void 0 ? void 0 : _a.call(contentSourceInstance, { updatedFiles: updatedFiles })))) !== null && _b !== void 0 ? _b : {};
+            this.logger.debug(`schemaChanged: ${onFilesChangeResult.schemaChanged}, has contentChangeEvent: ${!!onFilesChangeResult.contentChangeEvent}`);
             // if schema is changed, there is no need to return contentChanges
             // because schema changes reloads everything and implies content changes
-            if (schemaChanged) {
-                someContentSourceSchemaUpdated = true;
-                this.contentSourceDataById[contentSourceId] = await this.loadContentSourceData({ contentSourceInstance, init: false });
+            if (onFilesChangeResult.schemaChanged) {
+                schemaChanged = true;
+                contentSourceIdsWithChangedSchema.push(contentSourceId);
+            }
+            else if (onFilesChangeResult.contentChangeEvent) {
+                contentChangeEvents.push({ contentSourceId, contentChangeEvent: onFilesChangeResult.contentChangeEvent });
             }
-            else if (contentChangeEvent) {
+        }
+        const contentChanges = {
+            updatedDocuments: [],
+            updatedAssets: [],
+            deletedDocuments: [],
+            deletedAssets: []
+        };
+        // If the schema was changed, there is no need to accumulate or notify about content changes.
+        // The processData will update the store with the latest data. And once the Studio receives
+        // the schemaChanged notification it will reload all the models and the documents with their latest state.
+        if (schemaChanged) {
+            await this.reloadContentSourcesByIdAndProcessData({ contentSourceIds: contentSourceIdsWithChangedSchema });
+        }
+        else {
+            contentChangeEvents.reduce((contentChanges, { contentSourceId, contentChangeEvent }) => {
                 const contentChangeResult = this.onContentChange(contentSourceId, contentChangeEvent);
                 contentChanges.updatedDocuments = contentChanges.updatedDocuments.concat(contentChangeResult.updatedDocuments);
                 contentChanges.updatedAssets = contentChanges.updatedAssets.concat(contentChangeResult.updatedAssets);
                 contentChanges.deletedDocuments = contentChanges.deletedDocuments.concat(contentChangeResult.deletedDocuments);
                 contentChanges.deletedAssets = contentChanges.deletedAssets.concat(contentChangeResult.deletedAssets);
-            }
+                return contentChanges;
+            }, contentChanges);
         }
         return {
-            schemaChanged: someContentSourceSchemaUpdated,
+            schemaChanged: schemaChanged,
             contentChanges: contentChanges
         };
     }
-    async loadContentSources({ init }) {
+    async loadYamlModels({ stackbitConfig }) {
+        const yamlModelsResult = await (0, sdk_1.loadYamlModelsFromFiles)(stackbitConfig);
+        for (const error of yamlModelsResult.errors) {
+            this.userLogger.warn(error.message);
+        }
+        return yamlModelsResult.models;
+    }
+    mergeConfigModels(stackbitConfig, modelsFromFiles) {
+        var _a;
+        const configModelsResult = (0, sdk_1.mergeConfigModelsWithModelsFromFiles)((_a = stackbitConfig === null || stackbitConfig === void 0 ? void 0 : stackbitConfig.models) !== null && _a !== void 0 ? _a : [], modelsFromFiles);
+        for (const error of configModelsResult.errors) {
+            this.userLogger.warn(error.message);
+        }
+        return configModelsResult.models;
+    }
+    async loadPresets({ stackbitConfig }) {
+        var _a;
+        const contentSources = (_a = stackbitConfig === null || stackbitConfig === void 0 ? void 0 : stackbitConfig.contentSources) !== null && _a !== void 0 ? _a : [];
+        const singleContentSource = contentSources.length === 1 ? contentSources[0] : null;
+        const presetResult = await (0, sdk_1.loadPresets)({
+            config: stackbitConfig,
+            ...(singleContentSource
+                ? {
+                    fallbackSrcType: singleContentSource.getContentSourceType(),
+                    fallbackSrcProjectId: singleContentSource.getProjectId()
+                }
+                : null)
+        });
+        for (const error of presetResult.errors) {
+            this.userLogger.warn(error.message);
+        }
+        const { presets } = await this.handleConfigAssets({ presets: presetResult.presets });
+        return presets;
+    }
+    async loadAllContentSourcesAndProcessData({ init }) {
         var _a, _b;
-        this.logger.debug('loadContentSources', { init });
+        this.logger.debug('loadAllContentSourcesAndProcessData', { init });
         this.contentUpdatesWatchTimer.stopTimer();
-        // TODO: move CSITypes to separate package so Config will be able to use them
-        const contentSources = ((_b = (_a = this.rawStackbitConfig) === null || _a === void 0 ? void 0 : _a.contentSources) !== null && _b !== void 0 ? _b : []);
+        const contentSources = (_b = (_a = this.stackbitConfig) === null || _a === void 0 ? void 0 : _a.contentSources) !== null && _b !== void 0 ? _b : [];
         const promises = contentSources.map((contentSourceInstance) => {
             return this.loadContentSourceData({ contentSourceInstance, init });
         });
-        const contentSourceDataArr = await Promise.all(promises);
-        const contentSourceDataById = lodash_1.default.keyBy(contentSourceDataArr, 'id');
+        const contentSourceRawDataArr = await Promise.all(promises);
         // update all content sources at once to prevent race conditions
+        this.contentSourceDataById = await this.processData({
+            stackbitConfig: this.stackbitConfig,
+            configModels: this.configModels,
+            presets: this.presets,
+            contentSourceRawDataArr: contentSourceRawDataArr
+        });
         this.contentSources = contentSources;
-        this.contentSourceDataById = contentSourceDataById;
+        this.contentUpdatesWatchTimer.startTimer();
+    }
+    async reloadContentSourcesByIdAndProcessData({ contentSourceIds }) {
+        this.logger.debug('reloadContentSourcesByIdAndProcessData', { contentSourceIds });
+        this.contentUpdatesWatchTimer.stopTimer();
+        const promises = this.contentSources.map((contentSourceInstance) => {
+            const contentSourceId = (0, content_store_utils_1.getContentSourceIdForContentSource)(contentSourceInstance);
+            if (contentSourceIds.includes(contentSourceId)) {
+                return this.loadContentSourceData({
+                    contentSourceInstance: contentSourceInstance,
+                    init: false
+                });
+            }
+            else {
+                return Promise.resolve(lodash_1.default.omit(this.contentSourceDataById[contentSourceId], ['models', 'modelMap', 'documents', 'documentMap']));
+            }
+        });
+        const contentSourceRawDataArr = await Promise.all(promises);
+        this.contentSourceDataById = await this.processData({
+            stackbitConfig: this.stackbitConfig,
+            configModels: this.configModels,
+            presets: this.presets,
+            contentSourceRawDataArr: contentSourceRawDataArr
+        });
         this.contentUpdatesWatchTimer.startTimer();
     }
     async loadContentSourceData({ contentSourceInstance, init }) {
-        var _a, _b, _c, _d, _e;
+        var _a;
         const contentSourceId = (0, content_store_utils_1.getContentSourceIdForContentSource)(contentSourceInstance);
         this.logger.debug('loadContentSourceData', { contentSourceId, init });
         if (init) {
@@ -207,87 +285,27 @@ class ContentStore {
             contentSourceInstance.stopWatchingContentUpdates();
             await contentSourceInstance.reset();
         }
-        // TODO: introduce optimization: don't fetch content source models,
-        //  documents, assets if only stackbitConfig was changed
         const csiModels = await contentSourceInstance.getModels();
-        const locales = await (contentSourceInstance === null || contentSourceInstance === void 0 ? void 0 : contentSourceInstance.getLocales());
-        const defaultLocaleCode = (_a = locales === null || locales === void 0 ? void 0 : locales.find((locale) => locale.default)) === null || _a === void 0 ? void 0 : _a.code;
-        // for older versions of stackbit, it uses models to extend content source models
-        let modelsNoImage = [];
-        let imageModel;
-        if (this.rawStackbitConfig) {
-            const result = await (0, sdk_1.extendConfig)({
-                config: this.rawStackbitConfig,
-                externalModels: csiModels
-            });
-            for (const error of (_b = result === null || result === void 0 ? void 0 : result.errors) !== null && _b !== void 0 ? _b : []) {
-                this.userLogger.warn(error.message);
-            }
-            const config = await this.handleConfigAssets(result.config);
-            const modelsWithImageModel = (_c = config === null || config === void 0 ? void 0 : config.models) !== null && _c !== void 0 ? _c : [];
-            const imageModelIndex = modelsWithImageModel.findIndex((model) => (0, sdk_1.isImageModel)(model));
-            if (imageModelIndex > -1) {
-                imageModel = modelsWithImageModel[imageModelIndex];
-                modelsWithImageModel.splice(imageModelIndex, 1);
-            }
-            modelsNoImage = modelsWithImageModel;
-            // TODO: load presets externally from config, and create additional map
-            //  that maps presetIds by model name instead of storing that map inside every model
-            // Augment presets with srcType and srcProjectId if they don't exist
-            this.presets = 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 ((_e = this.rawStackbitConfig) === null || _e === void 0 ? void 0 : _e.mapModels) {
-            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 = imageModel ? [...modelsNoImage, imageModel] : modelsNoImage;
-        const modelMap = lodash_1.default.keyBy(models, 'name');
         const csiModelMap = lodash_1.default.keyBy(csiModels, 'name');
+        const locales = await contentSourceInstance.getLocales();
+        const defaultLocaleCode = (_a = locales === null || locales === void 0 ? void 0 : locales.find((locale) => locale.default)) === null || _a === void 0 ? void 0 : _a.code;
         const csiDocuments = await contentSourceInstance.getDocuments({ modelMap: csiModelMap });
         const csiAssets = await contentSourceInstance.getAssets();
         const csiDocumentMap = lodash_1.default.keyBy(csiDocuments, 'id');
         const csiAssetMap = lodash_1.default.keyBy(csiAssets, 'id');
-        const contentStoreDocuments = (0, csi_to_store_docs_converter_1.mapCSIDocumentsToStoreDocuments)({
-            csiDocuments,
-            contentSourceInstance,
-            modelMap,
-            defaultLocaleCode
-        });
         const contentStoreAssets = (0, csi_to_store_docs_converter_1.mapCSIAssetsToStoreAssets)({
             csiAssets,
             contentSourceInstance,
             defaultLocaleCode
         });
-        const documentMap = lodash_1.default.keyBy(contentStoreDocuments, 'srcObjectId');
         const assetMap = lodash_1.default.keyBy(contentStoreAssets, 'srcObjectId');
         this.logger.debug('loaded content source data', {
             contentSourceId,
-            locales,
             defaultLocaleCode,
-            modelCount: models.length,
-            documentCount: contentStoreDocuments.length,
-            assetCount: contentStoreAssets.length
+            localesCount: locales.length,
+            modelCount: csiModels.length,
+            documentCount: csiDocuments.length,
+            assetCount: csiAssets.length
         });
         contentSourceInstance.startWatchingContentUpdates({
             getModelMap: () => {
@@ -306,27 +324,20 @@ class ContentStore {
             },
             onSchemaChange: async () => {
                 this.logger.debug('content source called onSchemaChange', { contentSourceId });
-                this.contentSourceDataById[contentSourceId] = await this.loadContentSourceData({
-                    contentSourceInstance: contentSourceInstance,
-                    init: false
-                });
-                this.onSchemaChangeCallback();
+                await this.reloadContentSourcesByIdAndProcessData({ contentSourceIds: [contentSourceId] });
             }
         });
         return {
             id: contentSourceId,
-            type: contentSourceInstance.getContentSourceType(),
-            projectId: contentSourceInstance.getProjectId(),
+            srcType: contentSourceInstance.getContentSourceType(),
+            srcProjectId: contentSourceInstance.getProjectId(),
             instance: contentSourceInstance,
             locales: locales,
             defaultLocaleCode: defaultLocaleCode,
-            models: models,
-            modelMap: modelMap,
+            csiModels: csiModels,
             csiModelMap: csiModelMap,
             csiDocuments: csiDocuments,
             csiDocumentMap: csiDocumentMap,
-            documents: contentStoreDocuments,
-            documentMap: documentMap,
             csiAssets: csiAssets,
             csiAssetMap: csiAssetMap,
             assets: contentStoreAssets,
@@ -335,6 +346,7 @@ class ContentStore {
     }
     onContentChange(contentSourceId, contentChangeEvent) {
         // TODO: prevent content change process for contentSourceId if loading content is in progress
+        var _a, _b, _c, _d;
         this.logger.debug('onContentChange', {
             contentSourceId,
             documentCount: contentChangeEvent.documents.length,
@@ -362,8 +374,8 @@ class ContentStore {
                 contentSourceData.csiDocuments.splice(index, 1);
             }
             result.deletedDocuments.push({
-                srcType: contentSourceData.type,
-                srcProjectId: contentSourceData.projectId,
+                srcType: contentSourceData.srcType,
+                srcProjectId: contentSourceData.srcProjectId,
                 srcObjectId: docId
             });
         });
@@ -380,14 +392,35 @@ class ContentStore {
                 contentSourceData.csiAssets.splice(index, 1);
             }
             result.deletedAssets.push({
-                srcType: contentSourceData.type,
-                srcProjectId: contentSourceData.projectId,
+                srcType: contentSourceData.srcType,
+                srcProjectId: contentSourceData.srcProjectId,
                 srcObjectId: assetId
             });
         });
+        // map csi documents through stackbitConfig.mapDocuments
+        let mappedDocs = contentChangeEvent.documents;
+        if ((_a = this.stackbitConfig) === null || _a === void 0 ? void 0 : _a.mapDocuments) {
+            const csiDocumentsWithSource = contentChangeEvent.documents.map((csiDocument) => ({
+                srcType: contentSourceData.srcType,
+                srcProjectId: contentSourceData.srcProjectId,
+                ...csiDocument
+            }));
+            const modelsWithSource = contentSourceData.models.map((model) => {
+                return {
+                    srcType: contentSourceData.srcType,
+                    srcProjectId: contentSourceData.srcProjectId,
+                    ...model
+                };
+            });
+            mappedDocs =
+                (_d = (_c = (_b = this.stackbitConfig) === null || _b === void 0 ? void 0 : _b.mapDocuments) === null || _c === void 0 ? void 0 : _c.call(_b, {
+                    documents: lodash_1.default.cloneDeep(csiDocumentsWithSource),
+                    models: lodash_1.default.cloneDeep(modelsWithSource)
+                })) !== null && _d !== void 0 ? _d : csiDocumentsWithSource;
+        }
         // map csi documents and assets to content store documents and assets
         const documents = (0, csi_to_store_docs_converter_1.mapCSIDocumentsToStoreDocuments)({
-            csiDocuments: contentChangeEvent.documents,
+            csiDocuments: mappedDocs,
             contentSourceInstance: contentSourceData.instance,
             modelMap: contentSourceData.modelMap,
             defaultLocaleCode: contentSourceData.defaultLocaleCode
@@ -399,7 +432,7 @@ class ContentStore {
         });
         // update contentSourceData with new or updated documents and assets
         Object.assign(contentSourceData.csiDocumentMap, lodash_1.default.keyBy(contentChangeEvent.documents, 'id'));
-        Object.assign(contentSourceData.csiAssets, lodash_1.default.keyBy(contentChangeEvent.assets, 'id'));
+        Object.assign(contentSourceData.csiAssetMap, lodash_1.default.keyBy(contentChangeEvent.assets, 'id'));
         Object.assign(contentSourceData.documentMap, lodash_1.default.keyBy(documents, 'srcObjectId'));
         Object.assign(contentSourceData.assetMap, lodash_1.default.keyBy(assets, 'srcObjectId'));
         for (let idx = 0; idx < documents.length; idx++) {
@@ -417,8 +450,8 @@ class ContentStore {
                 contentSourceData.csiDocuments.splice(dataIndex, 1, csiDocument);
             }
             result.updatedDocuments.push({
-                srcType: contentSourceData.type,
-                srcProjectId: contentSourceData.projectId,
+                srcType: contentSourceData.srcType,
+                srcProjectId: contentSourceData.srcProjectId,
                 srcObjectId: document.srcObjectId
             });
         }
@@ -437,18 +470,77 @@ class ContentStore {
                 contentSourceData.csiAssets.splice(index, 1, csiAsset);
             }
             result.updatedAssets.push({
-                srcType: contentSourceData.type,
-                srcProjectId: contentSourceData.projectId,
+                srcType: contentSourceData.srcType,
+                srcProjectId: contentSourceData.srcProjectId,
                 srcObjectId: asset.srcObjectId
             });
         }
         return result;
     }
+    async processData({ stackbitConfig, configModels, presets, contentSourceRawDataArr }) {
+        var _a, _b, _c, _d;
+        const modelsWithSource = contentSourceRawDataArr.reduce((accum, csData) => {
+            const mergedModels = (0, sdk_1.mergeConfigModelsWithExternalModels)({
+                configModels: configModels,
+                externalModels: csData.csiModels
+            });
+            const modelsWithSource = mergedModels.map((model) => {
+                return {
+                    srcType: csData.srcType,
+                    srcProjectId: csData.id,
+                    ...model
+                };
+            });
+            return accum.concat(modelsWithSource);
+        }, []);
+        // TODO: Is there a better way than deep cloning objects before passing them to user methods?
+        //   Not cloning mutable objects will break the internal state if user mutates the objects.
+        const mappedModels = (_b = (_a = stackbitConfig === null || stackbitConfig === void 0 ? void 0 : stackbitConfig.mapModels) === null || _a === void 0 ? void 0 : _a.call(stackbitConfig, { models: lodash_1.default.cloneDeep(modelsWithSource) })) !== null && _b !== void 0 ? _b : modelsWithSource;
+        const normalizedModels = (0, model_utils_1.normalizeModels)({ models: mappedModels, logger: this.userLogger });
+        const validatedModels = (0, model_utils_1.validateModels)({ models: normalizedModels, logger: this.userLogger });
+        const modelsWithPresetsIds = (0, sdk_1.extendModelsWithPresetsIds)({ models: validatedModels, presets });
+        const { models } = await this.handleConfigAssets({ models: modelsWithPresetsIds });
+        const csiDocumentsWithSource = contentSourceRawDataArr.reduce((accum, csData) => {
+            const csiDocumentsWithSource = csData.csiDocuments.map((csiDocument) => ({
+                srcType: csData.srcType,
+                srcProjectId: csData.id,
+                ...csiDocument
+            }));
+            return accum.concat(csiDocumentsWithSource);
+        }, []);
+        // TODO: Is there a better way than deep cloning objects before passing them to user methods?
+        //   Not cloning mutable objects will break the internal state if user mutates the objects.
+        const mappedDocs = (_d = (_c = stackbitConfig === null || stackbitConfig === void 0 ? void 0 : stackbitConfig.mapDocuments) === null || _c === void 0 ? void 0 : _c.call(stackbitConfig, {
+            documents: lodash_1.default.cloneDeep(csiDocumentsWithSource),
+            models: lodash_1.default.cloneDeep(models)
+        })) !== null && _d !== void 0 ? _d : csiDocumentsWithSource;
+        const modelMapByContentSource = (0, content_store_utils_1.groupModelsByContentSource)({ models: models });
+        const documentMapByContentSource = (0, content_store_utils_1.groupDocumentsByContentSource)({ documents: mappedDocs });
+        const contentSourceDataArr = contentSourceRawDataArr.map((csData) => {
+            const modelMap = lodash_1.default.get(modelMapByContentSource, [csData.srcType, csData.id], {});
+            const mappedCSIDocuments = lodash_1.default.get(documentMapByContentSource, [csData.srcType, csData.id]);
+            const documents = (0, csi_to_store_docs_converter_1.mapCSIDocumentsToStoreDocuments)({
+                csiDocuments: mappedCSIDocuments,
+                contentSourceInstance: csData.instance,
+                defaultLocaleCode: csData.defaultLocaleCode,
+                modelMap: modelMap
+            });
+            return {
+                ...csData,
+                models: Object.values(modelMap),
+                modelMap,
+                documents,
+                documentMap: lodash_1.default.keyBy(documents, 'srcObjectId')
+            };
+        });
+        return lodash_1.default.keyBy(contentSourceDataArr, 'id');
+    }
     getModels() {
         return lodash_1.default.reduce(this.contentSourceDataById, (result, contentSourceData) => {
             const contentSourceType = contentSourceData.instance.getContentSourceType();
             const srcProjectId = contentSourceData.instance.getProjectId();
             lodash_1.default.set(result, [contentSourceType, srcProjectId], contentSourceData.modelMap);
+            lodash_1.default.set(result, [contentSourceType, srcProjectId, '__image_model'], common_schema_1.IMAGE_MODEL);
             return result;
         }, {});
     }
@@ -479,8 +571,8 @@ class ContentStore {
             contentSourceDataArr = Object.values(this.contentSourceDataById);
         }
         return (0, utils_1.reducePromise)(contentSourceDataArr, async (accum, contentSourceData) => {
-            const srcType = contentSourceData.type;
-            const srcProjectId = contentSourceData.projectId;
+            const srcType = contentSourceData.srcType;
+            const srcProjectId = contentSourceData.srcProjectId;
             const userContext = (0, content_store_utils_1.getUserContextForSrcType)(srcType, user);
             let result = await contentSourceData.instance.hasAccess({ userContext });
             // backwards compatibility with older CSI version
@@ -949,13 +1041,13 @@ class ContentStore {
             const contentSourceData = this.getContentSourceDataByIdOrThrow(contentSourceId);
             locale = locale !== null && locale !== void 0 ? locale : contentSourceData.defaultLocaleCode;
             const { documents, assets } = getCSIDocumentsAndAssetsFromContentSourceDataByIds(contentSourceData, contentSourceObjects);
-            const userContext = (0, content_store_utils_1.getUserContextForSrcType)(contentSourceData.type, user);
+            const userContext = (0, content_store_utils_1.getUserContextForSrcType)(contentSourceData.srcType, 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) => ({
                 message: validationError.message,
-                srcType: contentSourceData.type,
-                srcProjectId: contentSourceData.projectId,
+                srcType: contentSourceData.srcType,
+                srcProjectId: contentSourceData.srcProjectId,
                 srcObjectType: validationError.objectType,
                 srcObjectId: validationError.objectId,
                 fieldPath: validationError.fieldPath,
@@ -986,7 +1078,7 @@ class ContentStore {
         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);
+            lodash_1.default.set(schema, [contentSourceData.srcType, contentSourceData.srcProjectId], contentSourceData.modelMap);
         });
         return (0, search_utils_1.searchDocuments)({
             ...data,
@@ -999,7 +1091,7 @@ class ContentStore {
         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 = (0, content_store_utils_1.getUserContextForSrcType)(contentSourceData.type, user);
+            const userContext = (0, content_store_utils_1.getUserContextForSrcType)(contentSourceData.srcType, user);
             const { documents, assets } = getCSIDocumentsAndAssetsFromContentSourceDataByIds(contentSourceData, contentSourceObjects);
             await contentSourceData.instance.publishDocuments({ documents, assets, userContext });
         }
@@ -1074,8 +1166,8 @@ function validateDocumentFields(document, documentField, fieldPath, contentSourc
         if (!objRef) {
             errors.push({
                 fieldPath,
-                srcType: contentSourceData.type,
-                srcProjectId: contentSourceData.projectId,
+                srcType: contentSourceData.srcType,
+                srcProjectId: contentSourceData.srcProjectId,
                 srcObjectType: documentField.refType,
                 srcObjectId: document.id,
                 message: `Can't find referenced ${documentField.refType}: ${documentField.refId}`