@stackbit/cms-core 0.2.1 → 0.3.0-develop.1

package/dist/content-store.js

@@ -21,6 +21,14 @@ const duplicate_document_1 = require("./utils/duplicate-document");
 const model_utils_1 = require("./utils/model-utils");
 const common_schema_1 = require("./common/common-schema");
 const preset_utils_1 = require("./utils/preset-utils");
+const backward_compatibility_1 = require("./utils/backward-compatibility");
+const config_delegate_1 = require("./utils/config-delegate");
+const ContentStoreEventType = {
+    YamlModelFilesChange: 'yamlModelFilesChange',
+    PresetFilesChange: 'presetFilesChange',
+    ContentSourceInvalidateSchema: 'contentSourceInvalidateSchema',
+    ContentSourceContentChange: 'contentSourceContentChange'
+};
 exports.StackbitPresetModelName = 'stackbitPreset';
 class ContentStore {
     constructor(options) {
@@ -32,6 +40,8 @@ class ContentStore {
         this.modelExtensions = null;
         this.presets = {};
         this.siteMapEntryGroups = {};
+        this.processingContentSourcesPromise = null;
+        this.contentStoreEventQueue = [];
         this.logger = options.logger.createLogger({ label: 'content-store' });
         this.userLogger = options.userLogger.createLogger({ label: 'content-store' });
         this.localDev = options.localDev;
@@ -112,8 +122,9 @@ class ContentStore {
      * reducing the CMS API usage.
      */
     handleTimerTimeout() {
+        var _a;
         for (const contentSourceInstance of this.contentSources) {
-            contentSourceInstance.stopWatchingContentUpdates();
+            (_a = contentSourceInstance.stopWatchingContentUpdates) === null || _a === void 0 ? void 0 : _a.call(contentSourceInstance);
         }
     }
     /**
@@ -134,9 +145,8 @@ class ContentStore {
         this.contentUpdatesWatchTimer.stopTimer();
     }
     async onFilesChange(updatedFiles) {
-        var _a, _b, _c;
+        var _a;
         this.logger.debug('onFilesChange');
-        let schemaChanged = false;
         if (this.stackbitConfig && !this.stackbitConfig.modelExtensions) {
             // 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.
@@ -144,9 +154,11 @@ class ContentStore {
             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((_a = this.stackbitConfig.models) !== null && _a !== void 0 ? _a : [], this.yamlModels);
+                this.pushContentSourceEvent({
+                    eventName: ContentStoreEventType.YamlModelFilesChange
+                });
             }
         }
         if (this.stackbitConfig) {
@@ -155,57 +167,36 @@ class ContentStore {
             const presetsChanged = updatedFiles.find((updatedFile) => lodash_1.default.some(presetDirs, (presetDir) => updatedFile.startsWith(presetDir)));
             if (presetsChanged && !this.usesContentSourcePresets()) {
                 this.logger.debug('identified change in stackbit preset files');
-                schemaChanged = true;
                 this.presets = await this.loadPresetsFromConfig({ stackbitConfig: this.stackbitConfig });
+                this.pushContentSourceEvent({
+                    eventName: ContentStoreEventType.PresetFilesChange
+                });
             }
         }
-        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 onFilesChangeResult = (_c = (await ((_b = contentSourceInstance.onFilesChange) === null || _b === void 0 ? void 0 : _b.call(contentSourceInstance, { updatedFiles: updatedFiles })))) !== null && _c !== void 0 ? _c : {};
-            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 (onFilesChangeResult.schemaChanged) {
-                schemaChanged = true;
-                contentSourceIdsWithChangedSchema.push(contentSourceId);
+            const onFilesChangeResult = await contentSourceInstance.onFilesChange({ updatedFiles: updatedFiles });
+            // If the schema was changed in a specific content source, there is no need to process and notify for content changes.
+            // Because the schema changes will trigger loadContentSourcesAndProcessData and reload all models and content of that
+            // content source and send the schemaChanged notification that will cause the Studio to reload the schema and documents.
+            if (onFilesChangeResult.invalidateSchema) {
+                this.logger.debug(`schema was invalidated for contentSource: ${contentSourceId}`);
+                this.pushContentSourceEvent({
+                    eventName: ContentStoreEventType.ContentSourceInvalidateSchema,
+                    contentSourceId: contentSourceId
+                });
             }
-            else if (onFilesChangeResult.contentChangeEvent) {
-                contentChangeEvents.push({ contentSourceId, contentChangeEvent: onFilesChangeResult.contentChangeEvent });
+            else if (!(0, content_store_utils_1.isContentChangesEmpty)(onFilesChangeResult.contentChanges)) {
+                this.logger.debug(`content was changed for contentSource: ${contentSourceId}`);
+                this.pushContentSourceEvent({
+                    eventName: ContentStoreEventType.ContentSourceContentChange,
+                    contentSourceId: contentSourceId,
+                    contentChanges: onFilesChangeResult.contentChanges
+                });
             }
         }
-        // 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.loadContentSourcesAndProcessData({ init: false, contentSourceIds: contentSourceIdsWithChangedSchema });
-            this.onSchemaChangeCallback();
-        }
-        else {
-            const contentChanges = contentChangeEvents.reduce((contentChanges, { contentSourceId, contentChangeEvent }) => {
-                const contentChangeResult = this.onContentChange(contentSourceId, contentChangeEvent);
-                return {
-                    updatedDocuments: contentChanges.updatedDocuments.concat(contentChangeResult.updatedDocuments),
-                    updatedAssets: contentChanges.updatedAssets.concat(contentChangeResult.updatedAssets),
-                    deletedDocuments: contentChanges.deletedDocuments.concat(contentChangeResult.deletedDocuments),
-                    deletedAssets: contentChanges.deletedAssets.concat(contentChangeResult.deletedAssets)
-                };
-            }, {
-                updatedDocuments: [],
-                updatedAssets: [],
-                deletedDocuments: [],
-                deletedAssets: []
-            });
-            this.siteMapEntryGroups = await (0, site_map_1.updateSiteMapEntriesWithContentChanges)({
-                siteMapEntryGroups: this.siteMapEntryGroups,
-                contentChanges,
-                stackbitConfig: this.stackbitConfig,
-                contentSourceDataById: this.contentSourceDataById
-            });
-            this.onContentChangeCallback(contentChanges);
-        }
+        await this.processContentStoreEvents();
     }
     async loadYamlModels({ stackbitConfig }) {
         const yamlModelsResult = await (0, sdk_1.loadYamlModelsFromFiles)(stackbitConfig);
@@ -278,7 +269,10 @@ class ContentStore {
     async loadContentSourcesAndProcessData({ init, contentSourceIds }) {
         var _a, _b, _c, _d, _e;
         this.logger.debug('loadContentSourcesAndProcessData', { init, contentSourceIds });
-        const contentSources = (_b = (_a = this.stackbitConfig) === null || _a === void 0 ? void 0 : _a.contentSources) !== null && _b !== void 0 ? _b : [];
+        this.processingContentSourcesPromise = (0, utils_1.deferredPromise)();
+        const contentSources = ((_b = (_a = this.stackbitConfig) === null || _a === void 0 ? void 0 : _a.contentSources) !== null && _b !== void 0 ? _b : []).map((contentSource) => {
+            return (0, backward_compatibility_1.backwardCompatibleContentSource)(contentSource);
+        });
         const promises = contentSources.map((contentSourceInstance) => {
             const contentSourceId = (0, content_store_utils_1.getContentSourceIdForContentSource)(contentSourceInstance);
             if (init || !contentSourceIds || contentSourceIds.includes(contentSourceId)) {
@@ -293,13 +287,10 @@ class ContentStore {
         for (let i = 0; i < contentSources.length; i++) {
             const contentSourceDataRaw = contentSourceRawDataArr[i];
             if ((_c = contentSourceDataRaw === null || contentSourceDataRaw === void 0 ? void 0 : contentSourceDataRaw.csiModelMap) === null || _c === void 0 ? void 0 : _c[exports.StackbitPresetModelName]) {
-                this.presetsContentSource = contentSources[i];
-                if (this.presetsContentSource) {
-                    const contentSourceId = (0, content_store_utils_1.getContentSourceIdForContentSource)(this.presetsContentSource);
-                    // reload presets from content source only if needed
-                    if (init || !contentSourceIds || contentSourceIds.includes(contentSourceId)) {
-                        this.presets = await this.loadPresetsFromContentSource(contentSourceDataRaw);
-                    }
+                this.presetsContentSource = contentSourceDataRaw.instance;
+                // reload presets from content source only if needed
+                if (init || !contentSourceIds || contentSourceIds.includes(contentSourceDataRaw.id)) {
+                    this.presets = await this.loadPresetsFromContentSource(contentSourceDataRaw);
                 }
                 break;
             }
@@ -321,37 +312,274 @@ class ContentStore {
             stackbitConfig: this.stackbitConfig,
             contentSourceDataById: this.contentSourceDataById
         });
+        if (!init) {
+            this.onSchemaChangeCallback();
+        }
+        const processingPromise = this.processingContentSourcesPromise;
+        this.processingContentSourcesPromise = null;
+        // Do not "await" on processContentStoreEvents as it may introduce a deadlock with
+        // the nested loadContentSourcesAndProcessData call which is wrapped by deferWhileRunning.
+        this.processContentStoreEvents()
+            .catch((error) => {
+            this.logger.error('error processing content source events', { error });
+        })
+            .finally(() => {
+            processingPromise.resolve();
+        });
+    }
+    async processContentStoreEvents() {
+        // If the ContentStore is currently loading content sources, return to prevent parallel data updates.
+        // This method will be called once current loading cycle ends.
+        if (this.processingContentSourcesPromise) {
+            return this.processingContentSourcesPromise.promise;
+        }
+        const contentSourceIdsWithInvalidatedSchema = [];
+        const contentChanges = {
+            updatedDocuments: [],
+            updatedAssets: [],
+            deletedDocuments: [],
+            deletedAssets: []
+        };
+        let invalidateSchema = false;
+        let presetsUpdated = false;
+        const contentSourceEvents = this.contentStoreEventQueue;
+        this.contentStoreEventQueue = [];
+        for (const contentSourceEvent of contentSourceEvents) {
+            if (contentSourceEvent.eventName === ContentStoreEventType.YamlModelFilesChange ||
+                contentSourceEvent.eventName === ContentStoreEventType.PresetFilesChange) {
+                invalidateSchema = true;
+            }
+            else if (contentSourceEvent.eventName === ContentStoreEventType.ContentSourceInvalidateSchema) {
+                invalidateSchema = true;
+                contentSourceIdsWithInvalidatedSchema.push(contentSourceEvent.contentSourceId);
+            }
+            else if (contentSourceEvent.eventName === ContentStoreEventType.ContentSourceContentChange) {
+                const result = this.onContentChange(contentSourceEvent.contentSourceId, contentSourceEvent.contentChanges);
+                contentChanges.updatedDocuments = contentChanges.updatedDocuments.concat(result.contentChangeResult.updatedDocuments);
+                contentChanges.updatedAssets = contentChanges.updatedAssets.concat(result.contentChangeResult.updatedAssets);
+                contentChanges.deletedDocuments = contentChanges.deletedDocuments.concat(result.contentChangeResult.deletedDocuments);
+                contentChanges.deletedAssets = contentChanges.deletedAssets.concat(result.contentChangeResult.deletedAssets);
+                if (result.presetsUpdated) {
+                    presetsUpdated = true;
+                }
+            }
+        }
+        // If the schema was changed, call loadContentSourcesAndProcessData method, this will reload all the SiteMapEntries and call the onSchemaChangeCallback.
+        // As soon as the Studio receives the schemaChanged notification it will reload all the models and the documents.
+        if (invalidateSchema) {
+            await this.loadContentSourcesAndProcessData({
+                init: false,
+                contentSourceIds: contentSourceIdsWithInvalidatedSchema
+            });
+        }
+        else {
+            // If the schema wasn't changed, update SiteMapEntries with the changed content.
+            this.siteMapEntryGroups = await (0, site_map_1.updateSiteMapEntriesWithContentChanges)({
+                siteMapEntryGroups: this.siteMapEntryGroups,
+                contentChanges: contentChanges,
+                stackbitConfig: this.stackbitConfig,
+                contentSourceDataById: this.contentSourceDataById
+            });
+            // If presets were updated, call onSchemaChangeCallback to notify the Studio.
+            // The Studio will refresh the models and the documents, so no need to notify
+            // content changes in this case.
+            if (presetsUpdated) {
+                this.onSchemaChangeCallback();
+            }
+            else if (!(0, content_store_utils_1.isContentChangeResultEmpty)(contentChanges)) {
+                this.onContentChangeCallback(contentChanges);
+            }
+        }
+    }
+    pushContentSourceEvent(contentStoreEvent) {
+        if (contentStoreEvent.eventName === ContentStoreEventType.ContentSourceContentChange) {
+            // If a content source enqueued the 'contentSourceInvalidateSchema' event,
+            // don't push the 'contentSourceContentChange' event, because 'contentSourceInvalidateSchema'
+            // will reload all the content source data.
+            const hasContentSourceSchemaChangeEvent = this.contentStoreEventQueue.find((event) => event.eventName === ContentStoreEventType.ContentSourceInvalidateSchema && event.contentSourceId === contentStoreEvent.contentSourceId);
+            if (!hasContentSourceSchemaChangeEvent) {
+                this.contentStoreEventQueue.push(contentStoreEvent);
+            }
+        }
+        else if (contentStoreEvent.eventName === ContentStoreEventType.ContentSourceInvalidateSchema) {
+            // Clear any 'contentSourceContentChange' events for a content source,
+            // the 'contentSourceInvalidateSchema' will reload all the content source data.
+            this.clearEventsForContentSourceId(contentStoreEvent.contentSourceId);
+            this.contentStoreEventQueue.push(contentStoreEvent);
+        }
+        else if (contentStoreEvent.eventName === ContentStoreEventType.YamlModelFilesChange) {
+            this.contentStoreEventQueue = this.contentStoreEventQueue.filter((event) => event.eventName !== ContentStoreEventType.YamlModelFilesChange);
+            this.contentStoreEventQueue.push(contentStoreEvent);
+        }
+        else if (contentStoreEvent.eventName === ContentStoreEventType.PresetFilesChange) {
+            this.contentStoreEventQueue = this.contentStoreEventQueue.filter((event) => event.eventName !== ContentStoreEventType.PresetFilesChange);
+            this.contentStoreEventQueue.push(contentStoreEvent);
+        }
+    }
+    clearEventsForContentSourceId(contentSourceId) {
+        this.contentStoreEventQueue = this.contentStoreEventQueue.filter((contentSourceEvent) => {
+            if (contentSourceEvent.eventName === ContentStoreEventType.ContentSourceContentChange ||
+                contentSourceEvent.eventName === ContentStoreEventType.ContentSourceInvalidateSchema) {
+                return contentSourceEvent.contentSourceId !== contentSourceId;
+            }
+            return true;
+        });
     }
     async loadContentSourceData({ contentSourceInstance, init }) {
-        var _a;
+        var _a, _b, _c, _d, _e;
         const contentSourceId = (0, content_store_utils_1.getContentSourceIdForContentSource)(contentSourceInstance);
         this.logger.debug('loadContentSourceData', { contentSourceId, init });
+        // clear content source events emitted by this content source because all the content source data is reloaded
+        this.clearEventsForContentSourceId(contentSourceId);
+        const localCache = {};
+        const getContentSourceDataForCurrentInstance = (methodName) => {
+            const contentSourceData = this.contentSourceDataById[contentSourceId];
+            if (!contentSourceData) {
+                // When loading the content sources for the first time, this.contentSourceDataById will be empty.
+                // However, while being loaded, content sources may call cache methods, for example a content
+                // source may call getModelByName from within getDocuments. In this case, return locally cached data.
+                if (this.processingContentSourcesPromise) {
+                    return localCache;
+                }
+                const atLine = (0, content_store_utils_1.getErrorAtLine)(2, getContentSourceDataForCurrentInstance);
+                const errorMessage = `Error executing 'cache.${methodName}' method${atLine}. The content source with id '${contentSourceId}' was not found.`;
+                this.logger.error(errorMessage);
+                return;
+            }
+            if (contentSourceData.instance !== contentSourceInstance) {
+                const atLine = (0, content_store_utils_1.getErrorAtLine)(2, getContentSourceDataForCurrentInstance);
+                const errorMessage = `Content source life cycle error! The content source with id '${contentSourceId}' called the 'cache.${methodName}' ` +
+                    `method${atLine} after the destroy() method was called.`;
+                this.logger.error(errorMessage);
+                return;
+            }
+            // While loading the content source, it may call cache methods, when this happens, return the
+            // stale data overridden with the most frequent loaded data
+            if (this.processingContentSourcesPromise) {
+                return Object.assign(contentSourceData, localCache);
+            }
+            return contentSourceData;
+        };
+        const cache = {
+            getSchema: () => {
+                const contentSourceData = getContentSourceDataForCurrentInstance('getSchema');
+                if (!(contentSourceData === null || contentSourceData === void 0 ? void 0 : contentSourceData.csiSchema)) {
+                    const atLine = (0, content_store_utils_1.getErrorAtLine)(1);
+                    const errorMessage = `Content source life cycle error! The content source with id '${contentSourceId}' called the 'cache.getSchema' ` +
+                        `method${atLine} before the content source's getSchema() method was called.`;
+                    this.logger.error(errorMessage);
+                    return { models: [], locales: [], context: null };
+                }
+                return contentSourceData.csiSchema;
+            },
+            getModelByName: (modelName) => {
+                const contentSourceData = getContentSourceDataForCurrentInstance('getModelByName');
+                if (!(contentSourceData === null || contentSourceData === void 0 ? void 0 : contentSourceData.csiModelMap)) {
+                    const atLine = (0, content_store_utils_1.getErrorAtLine)(1);
+                    const errorMessage = `Content source life cycle error! The content source with id '${contentSourceId}' called the 'cache.getModelByName' ` +
+                        `method${atLine} before the content source's getSchema() method was called.`;
+                    this.logger.error(errorMessage);
+                    return;
+                }
+                return contentSourceData.csiModelMap[modelName];
+            },
+            getDocuments: () => {
+                var _a;
+                const contentSourceData = getContentSourceDataForCurrentInstance('getDocuments');
+                return (_a = contentSourceData === null || contentSourceData === void 0 ? void 0 : contentSourceData.csiDocuments) !== null && _a !== void 0 ? _a : [];
+            },
+            getDocumentById: (documentId) => {
+                var _a;
+                const contentSourceData = getContentSourceDataForCurrentInstance('getDocumentById');
+                return (_a = contentSourceData === null || contentSourceData === void 0 ? void 0 : contentSourceData.csiDocumentMap) === null || _a === void 0 ? void 0 : _a[documentId];
+            },
+            getAssets: () => {
+                var _a;
+                const contentSourceData = getContentSourceDataForCurrentInstance('getAssets');
+                return (_a = contentSourceData === null || contentSourceData === void 0 ? void 0 : contentSourceData.csiAssets) !== null && _a !== void 0 ? _a : [];
+            },
+            getAssetById: (assetId) => {
+                var _a;
+                const contentSourceData = getContentSourceDataForCurrentInstance('getAssetById');
+                return (_a = contentSourceData === null || contentSourceData === void 0 ? void 0 : contentSourceData.csiAssetMap) === null || _a === void 0 ? void 0 : _a[assetId];
+            },
+            updateContent: async (contentChanges) => {
+                const contentSourceData = getContentSourceDataForCurrentInstance('updateContent');
+                if (!contentSourceData) {
+                    return;
+                }
+                this.logger.debug('content source called updateContent', { contentSourceId });
+                this.pushContentSourceEvent({
+                    eventName: ContentStoreEventType.ContentSourceContentChange,
+                    contentSourceId: contentSourceId,
+                    contentChanges: contentChanges
+                });
+                await this.processContentStoreEvents();
+            },
+            invalidateSchema: async () => {
+                const contentSourceData = getContentSourceDataForCurrentInstance('invalidateSchema');
+                if (!contentSourceData) {
+                    return;
+                }
+                this.logger.debug('content source called invalidateSchema', { contentSourceId });
+                this.pushContentSourceEvent({
+                    eventName: ContentStoreEventType.ContentSourceInvalidateSchema,
+                    contentSourceId: contentSourceId
+                });
+                await this.processContentStoreEvents();
+            }
+        };
         if (init) {
+            this.userLogger.info(`Initializing content source: ${contentSourceInstance.getContentSourceType()} (project: ${contentSourceInstance.getProjectId()})`);
+            // When stackbit.config.js reloads, it loads new content source instances.
+            // Previously loaded content source instances must be destroyed.
+            const contentSourceData = this.contentSourceDataById[contentSourceId];
+            if (contentSourceData && contentSourceData.instance !== contentSourceInstance) {
+                this.logger.debug('destroy previous content source instance', { contentSourceId });
+                try {
+                    (_b = (_a = contentSourceData.instance).stopWatchingContentUpdates) === null || _b === void 0 ? void 0 : _b.call(_a);
+                    await contentSourceData.instance.destroy();
+                }
+                catch (error) {
+                    this.logger.debug('error destroying content source instance', { error });
+                }
+            }
+            // If an instance that wasn't destroyed calls one of the InitOptions method don't return any data.
             await contentSourceInstance.init({
                 logger: this.logger,
                 userLogger: this.userLogger,
-                userCommandSpawner: this.userCommandSpawner,
                 localDev: this.localDev,
                 webhookUrl: this.getWebhookUrl(contentSourceInstance.getContentSourceType(), contentSourceInstance.getProjectId()),
+                userCommandSpawner: this.userCommandSpawner,
                 devAppRestartNeeded: this.devAppRestartNeeded,
+                cache: cache,
                 runCommand: this.runCommand,
                 git: this.git
             });
         }
         else {
-            contentSourceInstance.stopWatchingContentUpdates();
             await contentSourceInstance.reset();
         }
-        const csiModels = await contentSourceInstance.getModels();
+        const version = await contentSourceInstance.getVersion();
+        const csiSchema = await contentSourceInstance.getSchema();
+        const csiModels = csiSchema.models;
         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 locales = csiSchema.locales;
+        const defaultLocaleCode = (_c = locales === null || locales === void 0 ? void 0 : locales.find((locale) => locale.default)) === null || _c === void 0 ? void 0 : _c.code;
+        localCache.csiSchema = csiSchema;
+        localCache.csiModels = csiModels;
+        localCache.csiModelMap = csiModelMap;
+        localCache.locales = locales;
         const csiDocuments = await contentSourceInstance.getDocuments({ modelMap: csiModelMap });
-        const csiAssets = await contentSourceInstance.getAssets();
         const csiDocumentMap = lodash_1.default.keyBy(csiDocuments, 'id');
+        localCache.csiDocuments = csiDocuments;
+        localCache.csiDocumentMap = csiDocumentMap;
+        const csiAssets = await contentSourceInstance.getAssets();
         const csiAssetMap = lodash_1.default.keyBy(csiAssets, 'id');
+        localCache.csiAssets = csiAssets;
+        localCache.csiAssetMap = csiAssetMap;
         const contentStoreAssets = (0, csi_to_store_docs_converter_1.mapCSIAssetsToStoreAssets)({
-            csiAssets,
+            csiAssets: csiAssets,
             contentSourceInstance,
             defaultLocaleCode
         });
@@ -359,55 +587,43 @@ class ContentStore {
         this.logger.debug('loaded content source data', {
             contentSourceId,
             defaultLocaleCode,
-            localesCount: locales.length,
+            localesCount: (_d = locales === null || locales === void 0 ? void 0 : locales.length) !== null && _d !== void 0 ? _d : 0,
             modelCount: csiModels.length,
             documentCount: csiDocuments.length,
             assetCount: csiAssets.length
         });
-        contentSourceInstance.startWatchingContentUpdates({
-            getModelMap: () => {
-                return csiModelMap;
-            },
-            getDocument({ documentId }) {
-                return csiDocumentMap[documentId];
-            },
-            getAsset({ assetId }) {
-                return csiAssetMap[assetId];
-            },
-            onContentChange: async (contentChangeEvent) => {
-                var _a;
-                if (((_a = this.contentSourceDataById[contentSourceId]) === null || _a === void 0 ? void 0 : _a.instance) !== contentSourceInstance) {
-                    this.logger.debug('old content source called onContentChange', { contentSourceId });
-                    return;
-                }
-                this.logger.debug('content source called onContentChange.', { contentSourceId });
-                const result = this.onContentChange(contentSourceId, contentChangeEvent);
-                this.siteMapEntryGroups = await (0, site_map_1.updateSiteMapEntriesWithContentChanges)({
-                    siteMapEntryGroups: this.siteMapEntryGroups,
-                    contentChanges: result,
-                    stackbitConfig: this.stackbitConfig,
-                    contentSourceDataById: this.contentSourceDataById
-                });
-                this.onContentChangeCallback(result);
-            },
-            onSchemaChange: async () => {
-                var _a;
-                if (((_a = this.contentSourceDataById[contentSourceId]) === null || _a === void 0 ? void 0 : _a.instance) !== contentSourceInstance) {
-                    this.logger.debug('old content source called onSchemaChange', { contentSourceId });
-                    return;
-                }
-                this.logger.debug('content source called onSchemaChange', { contentSourceId });
-                await this.loadContentSourcesAndProcessData({ init: false, contentSourceIds: [contentSourceId] });
-                this.onSchemaChangeCallback();
-            }
-        });
+        if (init) {
+            this.userLogger.info(`→ Loaded content source data: ${csiModels.length} model${csiModels.length !== 1 ? 's' : ''}, ${csiDocuments.length} document${csiDocuments.length !== 1 ? 's' : ''} and ${csiAssets.length} asset${csiAssets.length !== 1 ? 's' : ''}`);
+            // backward compatibility
+            (_e = contentSourceInstance.startWatchingContentUpdates) === null || _e === void 0 ? void 0 : _e.call(contentSourceInstance, {
+                getModelMap: () => {
+                    var _a;
+                    const contentSourceData = getContentSourceDataForCurrentInstance('getModelMap');
+                    return (_a = contentSourceData === null || contentSourceData === void 0 ? void 0 : contentSourceData.csiModelMap) !== null && _a !== void 0 ? _a : {};
+                },
+                getDocument: ({ documentId }) => {
+                    var _a;
+                    const contentSourceData = getContentSourceDataForCurrentInstance('getDocument');
+                    return (_a = contentSourceData === null || contentSourceData === void 0 ? void 0 : contentSourceData.csiDocumentMap) === null || _a === void 0 ? void 0 : _a[documentId];
+                },
+                getAsset: ({ assetId }) => {
+                    var _a;
+                    const contentSourceData = getContentSourceDataForCurrentInstance('getAsset');
+                    return (_a = contentSourceData === null || contentSourceData === void 0 ? void 0 : contentSourceData.csiAssetMap) === null || _a === void 0 ? void 0 : _a[assetId];
+                },
+                onContentChange: cache.updateContent,
+                onSchemaChange: cache.invalidateSchema
+            });
+        }
         return {
             id: contentSourceId,
+            version: version,
             srcType: contentSourceInstance.getContentSourceType(),
             srcProjectId: contentSourceInstance.getProjectId(),
             instance: contentSourceInstance,
             locales: locales,
             defaultLocaleCode: defaultLocaleCode,
+            csiSchema: csiSchema,
             csiModels: csiModels,
             csiModelMap: csiModelMap,
             csiDocuments: csiDocuments,
@@ -418,17 +634,22 @@ class ContentStore {
             assetMap: assetMap
         };
     }
-    onContentChange(contentSourceId, contentChangeEvent) {
-        // TODO: prevent content change process for contentSourceId if loading content is in progress
-        var _a, _b, _c, _d, _e, _f, _g;
+    onContentChange(contentSourceId, contentChanges) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
         // certain content changes, like preset changes are interpreted as schema changes
-        let schemaChanged = false;
+        let presetsUpdated = false;
+        const contentChangesReq = {
+            documents: (_a = contentChanges.documents) !== null && _a !== void 0 ? _a : [],
+            assets: (_b = contentChanges.assets) !== null && _b !== void 0 ? _b : [],
+            deletedDocumentIds: (_c = contentChanges.deletedDocumentIds) !== null && _c !== void 0 ? _c : [],
+            deletedAssetIds: (_d = contentChanges.deletedAssetIds) !== null && _d !== void 0 ? _d : []
+        };
         this.logger.debug('onContentChange', {
             contentSourceId,
-            documentCount: contentChangeEvent.documents.length,
-            assetCount: contentChangeEvent.assets.length,
-            deletedDocumentCount: contentChangeEvent.deletedDocumentIds.length,
-            deletedAssetCount: contentChangeEvent.deletedAssetIds.length
+            documentCount: contentChangesReq.documents.length,
+            assetCount: contentChangesReq.assets.length,
+            deletedDocumentCount: contentChangesReq.deletedDocumentIds.length,
+            deletedAssetCount: contentChangesReq.deletedAssetIds.length
         });
         const result = {
             updatedDocuments: [],
@@ -438,12 +659,12 @@ class ContentStore {
         };
         const contentSourceData = this.getContentSourceDataByIdOrThrow(contentSourceId);
         // update contentSourceData with deleted documents
-        contentChangeEvent.deletedDocumentIds.forEach((docId) => {
+        contentChangesReq.deletedDocumentIds.forEach((docId) => {
             var _a;
             // remove preset, make sure there is something to remove first because
             // were explicitly calling onContentChange from deletePreset as well
             if (this.presets[docId] && ((_a = contentSourceData.csiDocumentMap[docId]) === null || _a === void 0 ? void 0 : _a.modelName) === exports.StackbitPresetModelName) {
-                schemaChanged = true;
+                presetsUpdated = true;
                 const preset = this.presets[docId];
                 const model = contentSourceData.modelMap[preset.modelName];
                 delete this.presets[docId];
@@ -469,7 +690,7 @@ class ContentStore {
             });
         });
         // update contentSourceData with deleted assets
-        contentChangeEvent.deletedAssetIds.forEach((assetId) => {
+        contentChangesReq.deletedAssetIds.forEach((assetId) => {
             // delete document from asset map
             delete contentSourceData.assetMap[assetId];
             delete contentSourceData.csiAssetMap[assetId];
@@ -487,9 +708,9 @@ class ContentStore {
             });
         });
         // 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) => ({
+        let mappedDocs = contentChangesReq.documents;
+        if ((_e = this.stackbitConfig) === null || _e === void 0 ? void 0 : _e.mapDocuments) {
+            const csiDocumentsWithSource = contentChangesReq.documents.map((csiDocument) => ({
                 srcType: contentSourceData.srcType,
                 srcProjectId: contentSourceData.srcProjectId,
                 ...csiDocument
@@ -502,32 +723,36 @@ class ContentStore {
                 };
             });
             mappedDocs =
-                (_d = (_c = (_b = this.stackbitConfig) === null || _b === void 0 ? void 0 : _b.mapDocuments) === null || _c === void 0 ? void 0 : _c.call(_b, {
+                (_h = (_g = (_f = this.stackbitConfig) === null || _f === void 0 ? void 0 : _f.mapDocuments) === null || _g === void 0 ? void 0 : _g.call(_f, {
                     documents: lodash_1.default.cloneDeep(csiDocumentsWithSource),
                     models: lodash_1.default.cloneDeep(modelsWithSource)
-                })) !== null && _d !== void 0 ? _d : csiDocumentsWithSource;
+                })) !== null && _h !== void 0 ? _h : csiDocumentsWithSource;
         }
         // map csi documents and assets to content store documents and assets
         const documents = (0, csi_to_store_docs_converter_1.mapCSIDocumentsToStoreDocuments)({
             csiDocuments: mappedDocs,
             contentSourceInstance: contentSourceData.instance,
             modelMap: contentSourceData.modelMap,
-            defaultLocaleCode: contentSourceData.defaultLocaleCode
+            defaultLocaleCode: contentSourceData.defaultLocaleCode,
+            createConfigDelegate: (0, config_delegate_1.getCreateConfigDelegateThunk)({
+                getContentSourceDataById: () => this.contentSourceDataById,
+                logger: this.userLogger
+            })
         });
         const assets = (0, csi_to_store_docs_converter_1.mapCSIAssetsToStoreAssets)({
-            csiAssets: contentChangeEvent.assets,
+            csiAssets: contentChangesReq.assets,
             contentSourceInstance: contentSourceData.instance,
             defaultLocaleCode: contentSourceData.defaultLocaleCode
         });
         // update contentSourceData with new or updated documents and assets
-        Object.assign(contentSourceData.csiDocumentMap, lodash_1.default.keyBy(contentChangeEvent.documents, 'id'));
-        Object.assign(contentSourceData.csiAssetMap, lodash_1.default.keyBy(contentChangeEvent.assets, 'id'));
+        Object.assign(contentSourceData.csiDocumentMap, lodash_1.default.keyBy(contentChangesReq.documents, 'id'));
+        Object.assign(contentSourceData.csiAssetMap, lodash_1.default.keyBy(contentChangesReq.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++) {
             // the indexes of mapped documents and documents from changeEvent are the same
             const document = documents[idx];
-            const csiDocument = contentChangeEvent.documents[idx];
+            const csiDocument = contentChangesReq.documents[idx];
             const dataIndex = contentSourceData.documents.findIndex((existingDoc) => existingDoc.srcObjectId === document.srcObjectId);
             if (dataIndex === -1) {
                 contentSourceData.documents.push(document);
@@ -538,7 +763,7 @@ class ContentStore {
                 contentSourceData.csiDocuments.splice(dataIndex, 1, csiDocument);
             }
             if (csiDocument.modelName === exports.StackbitPresetModelName) {
-                schemaChanged = true;
+                presetsUpdated = true;
                 const preset = (0, preset_utils_1.getPresetFromDocument)({
                     srcType: contentSourceData.srcType,
                     srcProjectId: contentSourceData.srcProjectId,
@@ -550,7 +775,7 @@ class ContentStore {
                     this.presets[csiDocument.id] = preset;
                     if (dataIndex === -1) {
                         //TODO recalculate assets as well
-                        (_f = (_e = contentSourceData.modelMap[preset.modelName]) === null || _e === void 0 ? void 0 : _e.presets) === null || _f === void 0 ? void 0 : _f.push(csiDocument.id);
+                        (_k = (_j = contentSourceData.modelMap[preset.modelName]) === null || _j === void 0 ? void 0 : _j.presets) === null || _k === void 0 ? void 0 : _k.push(csiDocument.id);
                     }
                 }
             }
@@ -563,7 +788,7 @@ class ContentStore {
         for (let idx = 0; idx < assets.length; idx++) {
             // the indexes of mapped assets and assets from changeEvent are the same
             const asset = assets[idx];
-            const csiAsset = contentChangeEvent.assets[idx];
+            const csiAsset = contentChangesReq.assets[idx];
             const index = contentSourceData.assets.findIndex((existingAsset) => existingAsset.srcObjectId === asset.srcObjectId);
             if (index === -1) {
                 contentSourceData.assets.push(asset);
@@ -580,10 +805,10 @@ class ContentStore {
                 srcObjectId: asset.srcObjectId
             });
         }
-        if (schemaChanged) {
-            (_g = this.onSchemaChangeCallback) === null || _g === void 0 ? void 0 : _g.call(this);
-        }
-        return result;
+        return {
+            contentChangeResult: result,
+            presetsUpdated
+        };
     }
     async processData({ stackbitConfig, configModels, presets, contentSourceRawDataArr }) {
         // Group models from all content sources by their names
@@ -704,8 +929,12 @@ class ContentStore {
             const documents = (0, csi_to_store_docs_converter_1.mapCSIDocumentsToStoreDocuments)({
                 csiDocuments: csiDocuments,
                 contentSourceInstance: csData.instance,
+                modelMap: modelMap,
                 defaultLocaleCode: csData.defaultLocaleCode,
-                modelMap: modelMap
+                createConfigDelegate: (0, config_delegate_1.getCreateConfigDelegateThunk)({
+                    getContentSourceDataById: () => this.contentSourceDataById,
+                    logger: this.userLogger
+                })
             });
             return {
                 ...csData,
@@ -717,6 +946,16 @@ class ContentStore {
         });
         return lodash_1.default.keyBy(contentSourceDataArr, 'id');
     }
+    getContentSourceMeta() {
+        return lodash_1.default.reduce(this.contentSourceDataById, (result, contentSourceData) => {
+            return result.concat({
+                srcType: contentSourceData.srcType,
+                srcProjectId: contentSourceData.srcProjectId,
+                srcVersion: contentSourceData.version.contentSourceVersion,
+                csiVersion: contentSourceData.version.interfaceVersion
+            });
+        }, []);
+    }
     getModels() {
         return lodash_1.default.reduce(this.contentSourceDataById, (result, contentSourceData) => {
             const contentSourceType = contentSourceData.instance.getContentSourceType();
@@ -762,14 +1001,7 @@ class ContentStore {
             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
-            if (typeof result === 'boolean') {
-                result = {
-                    hasConnection: result,
-                    hasPermissions: result
-                };
-            }
+            const result = await contentSourceData.instance.hasAccess({ userContext });
             return {
                 hasConnection: accum.hasConnection && result.hasConnection,
                 hasPermissions: accum.hasPermissions && result.hasPermissions,
@@ -857,7 +1089,7 @@ class ContentStore {
         const contentSourceData = this.getContentSourceDataByIdOrThrow(contentSourceId);
         return contentSourceData.documentMap[srcDocumentId];
     }
-    getDocuments({ locale }) {
+    getDocuments({ locale } = {}) {
         return lodash_1.default.reduce(this.contentSourceDataById, (documents, contentSourceData) => {
             const currentDocuments = lodash_1.default.isEmpty(locale)
                 ? contentSourceData.documents
@@ -885,18 +1117,16 @@ class ContentStore {
             let documents = objectIds
                 ? contentSourceData.documents.filter((document) => objectIds.includes(document.srcObjectId))
                 : contentSourceData.documents;
-            documents = hasExplicitLocale
-                ? documents.filter((document) => !document.locale || document.locale === locale)
-                : documents;
-            let assets = objectIds
-                ? contentSourceData.assets.filter((asset) => objectIds.includes(asset.srcObjectId))
-                : contentSourceData.assets;
-            assets = hasExplicitLocale
-                ? assets.filter((asset) => !asset.locale || asset.locale === locale)
-                : assets;
+            documents = hasExplicitLocale ? documents.filter((document) => !document.locale || document.locale === locale) : documents;
+            let assets = objectIds ? contentSourceData.assets.filter((asset) => objectIds.includes(asset.srcObjectId)) : contentSourceData.assets;
+            assets = hasExplicitLocale ? assets.filter((asset) => !asset.locale || asset.locale === locale) : assets;
             const currentLocale = locale !== null && locale !== void 0 ? locale : contentSourceData.defaultLocaleCode;
             const filteredDocuments = documents.filter((document) => document.srcModelName !== exports.StackbitPresetModelName);
-            const documentObjects = (0, store_to_api_docs_converter_1.mapDocumentsToLocalizedApiObjects)(filteredDocuments, currentLocale);
+            const documentObjects = (0, store_to_api_docs_converter_1.mapDocumentsToLocalizedApiObjects)({
+                documents: filteredDocuments,
+                locale: currentLocale,
+                delegate: (0, config_delegate_1.createConfigDelegate)({ contentSourceDataById: this.contentSourceDataById, logger: this.userLogger })
+            });
             const imageObjects = (0, store_to_api_docs_converter_1.mapAssetsToLocalizedApiImages)(assets, this.staticAssetsPublicPath, currentLocale);
             return objects.concat(documentObjects, imageObjects);
         }, []);
@@ -1009,7 +1239,7 @@ class ContentStore {
                 refProjectId: refProjectId
             });
         }
-        const updatedDocument = await contentSourceData.instance.updateDocument({
+        await contentSourceData.instance.updateDocument({
             document: csiDocument,
             modelMap: csiModelMap,
             userContext: userContext,
@@ -1032,7 +1262,7 @@ class ContentStore {
                     }
             ]
         });
-        return { srcDocumentId: updatedDocument.id, createdDocumentId: result.srcDocumentId };
+        return { srcDocumentId: srcDocumentId, createdDocumentId: result.srcDocumentId };
     }
     async createPreset({ preset, thumbnailAsset, user }) {
         var _a;
@@ -1074,12 +1304,18 @@ class ContentStore {
         });
         // we delete presets immediately because some CMSs don't notify us
         // when documents have been deleted.
-        this.onContentChange((0, content_store_utils_1.getContentSourceIdForContentSource)(this.presetsContentSource), {
-            documents: [],
-            deletedDocumentIds: [presetId],
-            assets: [],
-            deletedAssetIds: []
+        const contentSourceId = (0, content_store_utils_1.getContentSourceIdForContentSource)(this.presetsContentSource);
+        this.pushContentSourceEvent({
+            eventName: ContentStoreEventType.ContentSourceContentChange,
+            contentSourceId: contentSourceId,
+            contentChanges: {
+                documents: [],
+                deletedDocumentIds: [presetId],
+                assets: [],
+                deletedAssetIds: []
+            }
         });
+        await this.processContentStoreEvents();
     }
     async uploadAndLinkAsset({ srcType, srcProjectId, srcDocumentId, fieldPath, asset, index, locale, user }) {
         this.logger.debug('uploadAndLinkAsset', { srcType, srcProjectId, srcDocumentId, fieldPath, index, locale });
@@ -1123,7 +1359,7 @@ class ContentStore {
             refType: 'asset',
             refId: result.id
         };
-        const updatedDocument = await contentSourceData.instance.updateDocument({
+        await contentSourceData.instance.updateDocument({
             document: csiDocument,
             modelMap: csiModelMap,
             userContext: userContext,
@@ -1146,7 +1382,7 @@ class ContentStore {
                     }
             ]
         });
-        return { srcDocumentId: updatedDocument.id };
+        return { srcDocumentId: srcDocumentId };
     }
     async createDocument({ srcType, srcProjectId, modelName, object, locale, defaultLocaleDocumentId, user }) {
         this.logger.debug('createDocument', { srcType, srcProjectId, modelName, locale });
@@ -1164,13 +1400,8 @@ class ContentStore {
                 user
             })
         });
-        this.logger.debug('created document', { srcType, srcProjectId, srcDocumentId: result.document.id, modelName });
-        // do not update cache in contentSourceData.documents and documentMap,
-        // instead wait for contentSource to call onContentChange(contentChangeEvent)
-        // and use data from contentChangeEvent to update the cache
-        // const newDocuments = [result.document, ...result.referencedDocuments];
-        // contentSourceData.documentMap = Object.assign(contentSourceData.documentMap, _.keyBy(newDocuments, 'srcObjectId'));
-        return { srcDocumentId: result.document.id };
+        this.logger.debug('created document', { srcType, srcProjectId, srcDocumentId: result.documentId, modelName });
+        return { srcDocumentId: result.documentId };
     }
     async updateDocument({ srcType, srcProjectId, srcDocumentId, updateOperations, user }) {
         this.logger.debug('updateDocument');
@@ -1256,17 +1487,13 @@ class ContentStore {
                     };
             }
         });
-        const updatedDocumentResult = await contentSourceData.instance.updateDocument({
+        await contentSourceData.instance.updateDocument({
             document: csiDocument,
             modelMap: csiModelMap,
             userContext,
             operations
         });
-        // do not update cache in contentSourceData.documents and documentMap,
-        // instead wait for contentSource to call onContentChange(contentChangeEvent)
-        // and use data from contentChangeEvent to update the cache
-        // contentSourceData.documentMap = Object.assign(contentSourceData.documentMap, { [document.srcObjectId]: document });
-        return { srcDocumentId: updatedDocumentResult.id };
+        return { srcDocumentId: srcDocumentId };
     }
     async duplicateDocument({ srcType, srcProjectId, srcDocumentId, object, locale, user }) {
         var _a, _b, _c;
@@ -1278,7 +1505,6 @@ class ContentStore {
             throw new Error(`no document with id '${srcDocumentId}' was found in ${contentSourceData.id}`);
         }
         const modelMap = contentSourceData.modelMap;
-        const csiModelMap = contentSourceData.csiModelMap;
         const model = modelMap[document.srcModelName];
         if (!model) {
             throw new Error(`no model with name '${document.srcModelName}' was found`);
@@ -1304,8 +1530,8 @@ class ContentStore {
                 user
             })
         });
-        this.logger.debug('duplicated document', { srcType, srcProjectId, srcDocumentId, newDocumentId: result.document.id, modelName: model.name });
-        return { srcDocumentId: result.document.id };
+        this.logger.debug('duplicated document', { srcType, srcProjectId, srcDocumentId, newDocumentId: result.documentId, modelName: model.name });
+        return { srcDocumentId: result.documentId };
     }
     async uploadAssets({ srcType, srcProjectId, assets, locale, user }) {
         this.logger.debug('uploadAssets');
@@ -1349,10 +1575,6 @@ class ContentStore {
             throw new Error(`no document with id '${srcDocumentId}' was found in ${contentSourceData.id}`);
         }
         await contentSourceData.instance.deleteDocument({ document: csiDocument, userContext });
-        // do not update cache in contentSourceData.documents and documentMap,
-        // instead wait for contentSource to call onContentChange(contentChangeEvent)
-        // and use data from contentChangeEvent to update the cache
-        // delete contentSourceData.documentMap[srcDocumentId];
     }
     async validateDocuments({ objects, locale, user }) {
         this.logger.debug('validateDocuments');