@stackbit/cms-core 0.1.14-alpha.0 → 0.1.14-canary.0

package/dist/content-store.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ContentStore = void 0;
+exports.ContentStore = exports.StackbitPresetModelName = void 0;
 const lodash_1 = __importDefault(require("lodash"));
 const path_1 = __importDefault(require("path"));
 const sanitize_filename_1 = __importDefault(require("sanitize-filename"));
@@ -13,13 +13,15 @@ const utils_1 = require("@stackbit/utils");
 const timer_1 = require("./utils/timer");
 const search_utils_1 = require("./utils/search-utils");
 const csi_to_store_docs_converter_1 = require("./utils/csi-to-store-docs-converter");
-const store_to_csi_docs_converter_1 = require("./utils/store-to-csi-docs-converter");
 const content_store_utils_1 = require("./content-store-utils");
+const site_map_1 = require("./utils/site-map");
 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 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");
+exports.StackbitPresetModelName = 'stackbitPreset';
 class ContentStore {
     constructor(options) {
         this.contentSources = [];
@@ -29,6 +31,7 @@ class ContentStore {
         this.configModels = [];
         this.modelExtensions = null;
         this.presets = {};
+        this.siteMapEntryGroups = {};
         this.logger = options.logger.createLogger({ label: 'content-store' });
         this.userLogger = options.userLogger.createLogger({ label: 'content-store' });
         this.localDev = options.localDev;
@@ -79,7 +82,6 @@ class ContentStore {
                 this.yamlModels = await this.loadYamlModels({ stackbitConfig });
                 this.configModels = this.mergeConfigModels((_a = stackbitConfig.models) !== null && _a !== void 0 ? _a : [], this.yamlModels);
             }
-            this.presets = await this.loadPresets({ stackbitConfig });
         }
         await this.loadContentSourcesAndProcessData({ init: true });
         this.contentUpdatesWatchTimer.startTimer();
@@ -146,10 +148,10 @@ class ContentStore {
             // 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) {
+            if (presetsChanged && !this.usesContentSourcePresets()) {
                 this.logger.debug('identified change in stackbit preset files');
                 schemaChanged = true;
-                this.presets = await this.loadPresets({ stackbitConfig: this.stackbitConfig });
+                this.presets = await this.loadPresetsFromConfig({ stackbitConfig: this.stackbitConfig });
             }
         }
         const contentSourceIdsWithChangedSchema = [];
@@ -169,7 +171,7 @@ class ContentStore {
                 contentChangeEvents.push({ contentSourceId, contentChangeEvent: onFilesChangeResult.contentChangeEvent });
             }
         }
-        const contentChanges = {
+        let contentChanges = {
             updatedDocuments: [],
             updatedAssets: [],
             deletedDocuments: [],
@@ -182,14 +184,21 @@ class ContentStore {
             await this.loadContentSourcesAndProcessData({ init: false, contentSourceIds: contentSourceIdsWithChangedSchema });
         }
         else {
-            contentChangeEvents.reduce((contentChanges, { contentSourceId, contentChangeEvent }) => {
+            contentChanges = 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;
+                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)
+                };
             }, contentChanges);
+            this.siteMapEntryGroups = await (0, site_map_1.updateSiteMapEntriesWithContentChanges)({
+                siteMapEntryGroups: this.siteMapEntryGroups,
+                contentChanges,
+                stackbitConfig: this.stackbitConfig,
+                contentSourceDataById: this.contentSourceDataById
+            });
         }
         // TODO: maybe instead of returning object with results
         //  replace with this.onSchemaChangeCallback() and this.onContentChangeCallback(contentChanges) for consistency of data flow?
@@ -212,7 +221,7 @@ class ContentStore {
         }
         return configModelsResult.models;
     }
-    async loadPresets({ stackbitConfig }) {
+    async loadPresetsFromConfig({ 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;
@@ -231,6 +240,24 @@ class ContentStore {
         const { presets } = await this.handleConfigAssets({ presets: presetResult.presets });
         return presets;
     }
+    async loadPresetsFromContentSource(contentSourceData) {
+        const presets = lodash_1.default.reduce(contentSourceData.csiDocuments, (result, csiDocument) => {
+            if (csiDocument.modelName === exports.StackbitPresetModelName) {
+                const preset = (0, preset_utils_1.getPresetFromDocument)({
+                    srcType: contentSourceData.srcType,
+                    srcProjectId: contentSourceData.srcProjectId,
+                    csiDocument,
+                    csiAssetMap: contentSourceData.csiAssetMap,
+                    logger: this.logger
+                });
+                if (preset) {
+                    result[csiDocument.id] = preset;
+                }
+            }
+            return result;
+        }, {});
+        return presets;
+    }
     /**
      * This function reloads the data of the specified content-sources, while
      * reusing the cached data of the rest of the content-sources, then processes
@@ -249,7 +276,7 @@ class ContentStore {
      * @private
      */
     async loadContentSourcesAndProcessData({ init, contentSourceIds }) {
-        var _a, _b, _c, _d;
+        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 : [];
         const promises = contentSources.map((contentSourceInstance) => {
@@ -262,14 +289,38 @@ class ContentStore {
             }
         });
         const contentSourceRawDataArr = await Promise.all(promises);
+        // find first content source that supports presets
+        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);
+                    }
+                }
+                break;
+            }
+        }
+        // fallback to loading presets from config as usual
+        if (init && this.stackbitConfig && !this.presetsContentSource) {
+            this.presets = await this.loadPresetsFromConfig({ stackbitConfig: this.stackbitConfig });
+        }
         // update all content sources at once to prevent race conditions
         this.contentSourceDataById = await this.processData({
             stackbitConfig: this.stackbitConfig,
-            configModels: (_d = (_c = this.modelExtensions) !== null && _c !== void 0 ? _c : this.configModels) !== null && _d !== void 0 ? _d : [],
+            configModels: (_e = (_d = this.modelExtensions) !== null && _d !== void 0 ? _d : this.configModels) !== null && _e !== void 0 ? _e : [],
             presets: this.presets,
             contentSourceRawDataArr: contentSourceRawDataArr
         });
         this.contentSources = contentSources;
+        // generate create site map entries
+        this.siteMapEntryGroups = await (0, site_map_1.getSiteMapEntriesFromStackbitConfig)({
+            stackbitConfig: this.stackbitConfig,
+            contentSourceDataById: this.contentSourceDataById
+        });
     }
     async loadContentSourceData({ contentSourceInstance, init }) {
         var _a;
@@ -321,9 +372,15 @@ class ContentStore {
             getAsset({ assetId }) {
                 return csiAssetMap[assetId];
             },
-            onContentChange: (contentChangeEvent) => {
+            onContentChange: async (contentChangeEvent) => {
                 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 () => {
@@ -351,7 +408,9 @@ class ContentStore {
     }
     onContentChange(contentSourceId, contentChangeEvent) {
         // TODO: prevent content change process for contentSourceId if loading content is in progress
-        var _a, _b, _c, _d;
+        var _a, _b, _c, _d, _e, _f, _g;
+        // certain content changes, like preset changes are interpreted as schema changes
+        let schemaChanged = false;
         this.logger.debug('onContentChange', {
             contentSourceId,
             documentCount: contentChangeEvent.documents.length,
@@ -368,6 +427,19 @@ class ContentStore {
         const contentSourceData = this.getContentSourceDataByIdOrThrow(contentSourceId);
         // update contentSourceData with deleted documents
         contentChangeEvent.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;
+                const preset = this.presets[docId];
+                const model = contentSourceData.modelMap[preset.modelName];
+                delete this.presets[docId];
+                if (model && model.presets) {
+                    const presetIdIndex = model.presets.findIndex((presetId) => presetId === docId);
+                    model.presets.splice(presetIdIndex, 1);
+                }
+            }
             // delete document from documents map
             delete contentSourceData.documentMap[docId];
             delete contentSourceData.csiDocumentMap[docId];
@@ -450,10 +522,26 @@ class ContentStore {
                 contentSourceData.csiDocuments.push(csiDocument);
             }
             else {
-                // the indexes of documents and csiDocuments are always the same as they are always updated at the same time
                 contentSourceData.documents.splice(dataIndex, 1, document);
                 contentSourceData.csiDocuments.splice(dataIndex, 1, csiDocument);
             }
+            if (csiDocument.modelName === exports.StackbitPresetModelName) {
+                schemaChanged = true;
+                const preset = (0, preset_utils_1.getPresetFromDocument)({
+                    srcType: contentSourceData.srcType,
+                    srcProjectId: contentSourceData.srcProjectId,
+                    csiDocument,
+                    csiAssetMap: contentSourceData.csiAssetMap,
+                    logger: this.logger
+                });
+                if (preset) {
+                    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);
+                    }
+                }
+            }
             result.updatedDocuments.push({
                 srcType: contentSourceData.srcType,
                 srcProjectId: contentSourceData.srcProjectId,
@@ -480,6 +568,9 @@ class ContentStore {
                 srcObjectId: asset.srcObjectId
             });
         }
+        if (schemaChanged) {
+            (_g = this.onSchemaChangeCallback) === null || _g === void 0 ? void 0 : _g.call(this);
+        }
         return result;
     }
     async processData({ stackbitConfig, configModels, presets, contentSourceRawDataArr }) {
@@ -503,44 +594,58 @@ class ContentStore {
         // srcProjectId. If after the comparison, there are more than one model left,
         // log a warning and filter out that config model so it won't be merged with any
         // of the content source models.
-        const modelMatchErrors = [];
-        const filteredConfigModels = configModels.filter((configModel) => {
+        const nonMatchedModels = [];
+        const configModelsByContentSourceId = configModels.reduce((modelGroups, configModel) => {
             const csiModels = csiModelGroups[configModel.name];
             if (!csiModels) {
-                return false;
+                nonMatchedModels.push({
+                    configModel,
+                    matchedCSIModels: []
+                });
+                return modelGroups;
             }
             const matchedCSIModels = csiModels.filter((model) => {
                 const matchesType = !configModel.srcType || model.srcType === configModel.srcType;
                 const matchesId = !configModel.srcProjectId || model.srcProjectId === configModel.srcProjectId;
                 return matchesType && matchesId;
             });
-            if (matchedCSIModels.length === 0) {
-                return false;
-            }
-            if (matchedCSIModels.length === 1) {
-                return true;
+            if (matchedCSIModels.length !== 1) {
+                nonMatchedModels.push({
+                    configModel,
+                    matchedCSIModels
+                });
+                return modelGroups;
             }
-            modelMatchErrors.push({
-                configModel,
-                matchedCSIModels
-            });
-            return false;
-        });
+            const contentSource = matchedCSIModels[0];
+            const contentSourceId = (0, content_store_utils_1.getContentSourceId)(contentSource.srcType, contentSource.srcProjectId);
+            (0, utils_1.append)(modelGroups, contentSourceId, configModel);
+            return modelGroups;
+        }, {});
         // Log model matching warnings using user logger
-        for (const { configModel, matchedCSIModels } of modelMatchErrors) {
-            let message = `name: '${configModel.name}'`;
+        for (const { configModel, matchedCSIModels } of nonMatchedModels) {
+            let configModelMessage = `model name: '${configModel.name}'`;
             if (configModel.srcType) {
-                message += `, srcType: '${configModel.srcType}'`;
+                configModelMessage += `, srcType: '${configModel.srcType}'`;
             }
             if (configModel.srcProjectId) {
-                message += `, srcProjectId: '${configModel.srcProjectId}'`;
+                configModelMessage += `, srcProjectId: '${configModel.srcProjectId}'`;
             }
-            const matchesModelsMessage = matchedCSIModels.map((model) => `srcType: '${model.srcType}', srcProjectId: '${model.srcProjectId}'`).join('; ');
-            this.userLogger.warn(`model ${message} defined in stackbit config matches more that 1 model in the following content sources: ${matchesModelsMessage}`);
+            configModelMessage = configModelMessage + ` defined in stackbit config`;
+            let contentSourceModelsMessage;
+            if (matchedCSIModels.length) {
+                const matchesModelsMessage = matchedCSIModels.map((model) => `srcType: '${model.srcType}', srcProjectId: '${model.srcProjectId}'`).join('; ');
+                contentSourceModelsMessage = ` matches more that 1 model in the following content sources: ${matchesModelsMessage}`;
+            }
+            else {
+                contentSourceModelsMessage = ' does not match any content source model';
+            }
+            this.userLogger.warn(configModelMessage + contentSourceModelsMessage);
         }
         const modelsWithSource = contentSourceRawDataArr.reduce((accum, csData) => {
+            var _a;
+            const contentSourceId = (0, content_store_utils_1.getContentSourceId)(csData.srcType, csData.srcProjectId);
             const mergedModels = (0, sdk_1.mergeConfigModelsWithExternalModels)({
-                configModels: filteredConfigModels,
+                configModels: (_a = configModelsByContentSourceId[contentSourceId]) !== null && _a !== void 0 ? _a : [],
                 externalModels: csData.csiModels
             });
             const modelsWithSource = mergedModels.map((model) => {
@@ -559,27 +664,32 @@ class ContentStore {
         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.srcProjectId,
-                ...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;
+        let documentMapByContentSource = null;
+        if (stackbitConfig === null || stackbitConfig === void 0 ? void 0 : stackbitConfig.mapDocuments) {
+            const csiDocumentsWithSource = contentSourceRawDataArr.reduce((accum, csData) => {
+                const csiDocumentsWithSource = csData.csiDocuments.map((csiDocument) => ({
+                    srcType: csData.srcType,
+                    srcProjectId: csData.srcProjectId,
+                    ...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;
+            documentMapByContentSource = (0, content_store_utils_1.groupDocumentsByContentSource)({ documents: mappedDocs });
+        }
         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.srcProjectId], {});
-            const mappedCSIDocuments = lodash_1.default.get(documentMapByContentSource, [csData.srcType, csData.srcProjectId], []);
+            const csiDocuments = documentMapByContentSource
+                ? lodash_1.default.get(documentMapByContentSource, [csData.srcType, csData.srcProjectId], [])
+                : csData.csiDocuments;
             const documents = (0, csi_to_store_docs_converter_1.mapCSIDocumentsToStoreDocuments)({
-                csiDocuments: mappedCSIDocuments,
+                csiDocuments: csiDocuments,
                 contentSourceInstance: csData.instance,
                 defaultLocaleCode: csData.defaultLocaleCode,
                 modelMap: modelMap
@@ -622,6 +732,9 @@ class ContentStore {
         const contentSourceData = this.getContentSourceDataByIdOrThrow(contentSourceId);
         return contentSourceData.instance.getProjectEnvironment();
     }
+    usesContentSourcePresets() {
+        return Boolean(this.presetsContentSource);
+    }
     async hasAccess({ srcType, srcProjectId, user }) {
         let contentSourceDataArr;
         if (srcType && srcProjectId) {
@@ -697,50 +810,22 @@ class ContentStore {
         };
     }
     getSiteMapEntries({ locale } = {}) {
-        var _a;
-        if (!((_a = this.stackbitConfig) === null || _a === void 0 ? void 0 : _a.siteMap)) {
-            return [];
-        }
-        // TODO: cache siteMap in processData
-        const siteMapOptions = lodash_1.default.reduce(this.contentSourceDataById, (accum, contentSourceData) => {
-            return {
-                models: accum.models.concat(contentSourceData.models.map((model) => ({
-                    srcType: contentSourceData.srcType,
-                    srcProjectId: contentSourceData.srcProjectId,
-                    ...model
-                }))),
-                documents: accum.documents.concat((0, store_to_csi_docs_converter_1.mapStoreDocumentsToCSIDocumentsWithSource)(contentSourceData.documents))
-            };
-        }, { models: [], documents: [] });
-        const siteMapEntries = this.stackbitConfig.siteMap(siteMapOptions).reduce((accum, siteMapEntry) => {
-            // The site map entries are provided by user, sanitize them and filter out illegal entries
-            if (!siteMapEntry) {
-                return accum;
-            }
-            if (typeof siteMapEntry.urlPath !== 'string') {
-                return accum;
-            }
-            if ('document' in siteMapEntry) {
-                const doc = siteMapEntry.document;
-                if (!doc.srcType || !doc.srcProjectId || !doc.modelName || !doc.id) {
-                    return accum;
+        const siteMapEntries = lodash_1.default.reduce(this.siteMapEntryGroups, (accum, siteMapEntryGroup) => {
+            return lodash_1.default.reduce(siteMapEntryGroup, (accum, siteMapEntry) => {
+                if (!siteMapEntry.label) {
+                    const fieldLabelValue = (0, site_map_1.getDocumentFieldLabelValueForSiteMapEntry)({
+                        siteMapEntry,
+                        locale,
+                        contentSourceDataById: this.contentSourceDataById
+                    });
+                    siteMapEntry = {
+                        ...siteMapEntry,
+                        label: fieldLabelValue !== null && fieldLabelValue !== void 0 ? fieldLabelValue : siteMapEntry.urlPath
+                    };
                 }
-            }
-            if (!siteMapEntry.label) {
-                const fieldLabelValue = (0, content_store_utils_1.getDocumentFieldLabelValueForSiteMapEntry)({ siteMapEntry, locale, contentSourceDataById: this.contentSourceDataById });
-                siteMapEntry = {
-                    ...siteMapEntry,
-                    label: fieldLabelValue !== null && fieldLabelValue !== void 0 ? fieldLabelValue : siteMapEntry.urlPath
-                };
-            }
-            if (!siteMapEntry.stableId) {
-                siteMapEntry = {
-                    ...siteMapEntry,
-                    stableId: 'document' in siteMapEntry ? siteMapEntry.document.id : siteMapEntry.urlPath
-                };
-            }
-            accum.push(siteMapEntry);
-            return accum;
+                accum.push(siteMapEntry);
+                return accum;
+            }, accum);
         }, []);
         return lodash_1.default.isEmpty(locale) ? siteMapEntries : siteMapEntries.filter((siteMapEntry) => !siteMapEntry.locale || siteMapEntry.locale === locale);
     }
@@ -754,7 +839,8 @@ class ContentStore {
             const currentDocuments = lodash_1.default.isEmpty(locale)
                 ? contentSourceData.documents
                 : contentSourceData.documents.filter((document) => !document.locale || document.locale === locale);
-            return documents.concat(currentDocuments);
+            const filteredDocuments = currentDocuments.filter((document) => document.srcModelName !== exports.StackbitPresetModelName);
+            return documents.concat(filteredDocuments);
         }, []);
     }
     getAsset({ srcAssetId, srcProjectId, srcType }) {
@@ -780,7 +866,8 @@ class ContentStore {
                 ? contentSourceData.assets.filter((asset) => !asset.locale || asset.locale === locale)
                 : contentSourceData.assets;
             const currentLocale = locale !== null && locale !== void 0 ? locale : contentSourceData.defaultLocaleCode;
-            const documentObjects = (0, store_to_api_docs_converter_1.mapDocumentsToLocalizedApiObjects)(documents, currentLocale);
+            const filteredDocuments = documents.filter((document) => document.srcModelName !== exports.StackbitPresetModelName);
+            const documentObjects = (0, store_to_api_docs_converter_1.mapDocumentsToLocalizedApiObjects)(filteredDocuments, currentLocale);
             const imageObjects = (0, store_to_api_docs_converter_1.mapAssetsToLocalizedApiImages)(assets, currentLocale);
             return objects.concat(documentObjects, imageObjects);
         }, []);
@@ -889,6 +976,53 @@ class ContentStore {
         });
         return { srcDocumentId: updatedDocument.id };
     }
+    async createPreset({ preset, thumbnailAsset, user }) {
+        var _a;
+        if (!this.presetsContentSource) {
+            throw new Error('No content source available for preset saving');
+        }
+        let thumbnail;
+        if (thumbnailAsset) {
+            const assets = await this.uploadAssets({
+                srcType: this.presetsContentSource.getContentSourceType(),
+                srcProjectId: this.presetsContentSource.getProjectId(),
+                assets: [thumbnailAsset],
+                user
+            });
+            thumbnail = (_a = assets[0]) === null || _a === void 0 ? void 0 : _a.objectId;
+        }
+        const contentSourceData = this.getContentSourceDataByIdOrThrow((0, content_store_utils_1.getContentSourceIdForContentSource)(this.presetsContentSource));
+        const document = await this.createDocument({
+            srcType: this.presetsContentSource.getContentSourceType(),
+            srcProjectId: this.presetsContentSource.getProjectId(),
+            modelName: exports.StackbitPresetModelName,
+            object: {
+                ...(0, preset_utils_1.getDocumentObjectFromPreset)(preset, contentSourceData.modelMap[exports.StackbitPresetModelName]),
+                thumbnail
+            },
+            user
+        });
+        return { srcDocumentId: document.srcDocumentId };
+    }
+    async deletePreset({ presetId, user }) {
+        if (!this.presetsContentSource) {
+            throw new Error('No content source available for preset deleting');
+        }
+        await this.deleteDocument({
+            srcType: this.presetsContentSource.getContentSourceType(),
+            srcProjectId: this.presetsContentSource.getProjectId(),
+            srcDocumentId: presetId,
+            user
+        });
+        // 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: []
+        });
+    }
     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
@@ -1199,7 +1333,8 @@ class ContentStore {
             const contentSourceDocuments = lodash_1.default.isEmpty(locale)
                 ? contentSourceData.documents
                 : contentSourceData.documents.filter((document) => !document.locale || document.locale === locale);
-            documents.push(...contentSourceDocuments);
+            const filteredDocuments = contentSourceDocuments.filter((document) => document.srcModelName !== exports.StackbitPresetModelName);
+            documents.push(...filteredDocuments);
             if (contentSourceData.defaultLocaleCode) {
                 defaultLocales[contentSourceId] = contentSourceData.defaultLocaleCode;
             }