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

package/src/content-store-utils.ts

@@ -192,36 +192,3 @@ export function getCSIDocumentsAndAssetsFromContentSourceDataByIds(
         assets
     };
 }
-
-export function getDocumentFieldLabelValueForSiteMapEntry({
-    siteMapEntry,
-    locale,
-    contentSourceDataById
-}: {
-    siteMapEntry: SiteMapEntry;
-    locale?: string;
-    contentSourceDataById: Record<string, ContentStoreTypes.ContentSourceData>;
-}): string | null {
-    if (!('document' in siteMapEntry)) {
-        return null;
-    }
-    const contentSourceId = getContentSourceId(siteMapEntry.document.srcType, siteMapEntry.document.srcProjectId);
-    const contentSourceData = contentSourceDataById[contentSourceId];
-    if (!contentSourceData) {
-        return null;
-    }
-    const labelFieldName = contentSourceData.modelMap[siteMapEntry.document.modelName]?.labelField;
-    const document = contentSourceData.documentMap[siteMapEntry.document.id];
-    if (!labelFieldName || !document) {
-        return null;
-    }
-    const labelField = document.fields[labelFieldName];
-    if (!labelField) {
-        return null;
-    }
-    const localizedLabelField = getDocumentFieldForLocale(labelField, locale);
-    if (!localizedLabelField || !('value' in localizedLabelField) || !localizedLabelField.value) {
-        return null;
-    }
-    return String(localizedLabelField.value);
-}

package/src/content-store.ts

@@ -3,7 +3,7 @@ import path from 'path';
 import sanitizeFilename from 'sanitize-filename';
 
 import * as CSITypes from '@stackbit/types';
-import { DocumentWithSource, getLocalizedFieldForLocale, ModelExtension, ModelWithSource, UserCommandSpawner } from '@stackbit/types';
+import { getLocalizedFieldForLocale, ModelExtension, UserCommandSpawner } from '@stackbit/types';
 import {
     Config,
     extendModelsWithPresetsIds,
@@ -18,29 +18,34 @@ import {
     Preset,
     PresetMap
 } from '@stackbit/sdk';
-import { deferWhileRunning, mapPromise, reducePromise } from '@stackbit/utils';
+import { append, deferWhileRunning, mapPromise, reducePromise } from '@stackbit/utils';
 
 import * as ContentStoreTypes from './content-store-types';
 import { Timer } from './utils/timer';
 import { SearchFilter } from './types/search-filter';
 import { searchDocuments } from './utils/search-utils';
 import { mapCSIAssetsToStoreAssets, mapCSIDocumentsToStoreDocuments } from './utils/csi-to-store-docs-converter';
-import { mapStoreDocumentsToCSIDocumentsWithSource } from './utils/store-to-csi-docs-converter';
 import {
     getContentSourceId,
     getContentSourceIdForContentSource,
-    getDocumentFieldLabelValueForSiteMapEntry,
     getCSIDocumentsAndAssetsFromContentSourceDataByIds,
     getModelFieldForFieldAtPath,
     getUserContextForSrcType,
     groupDocumentsByContentSource,
     groupModelsByContentSource
 } from './content-store-utils';
+import {
+    getSiteMapEntriesFromStackbitConfig,
+    updateSiteMapEntriesWithContentChanges,
+    getDocumentFieldLabelValueForSiteMapEntry,
+    SiteMapEntryGroups
+} from './utils/site-map';
 import { mapAssetsToLocalizedApiImages, mapDocumentsToLocalizedApiObjects, mapStoreAssetsToAPIAssets } from './utils/store-to-api-docs-converter';
 import { convertOperationField, createDocumentRecursively, getCreateDocumentThunk } from './utils/create-update-csi-docs';
 import { mergeObjectWithDocument } from './utils/duplicate-document';
 import { normalizeModels, validateModels } from './utils/model-utils';
 import { IMAGE_MODEL } from './common/common-schema';
+import { getDocumentObjectFromPreset, getPresetFromDocument } from './utils/preset-utils';
 
 export type HandleConfigAssets = <T extends Model>({ models, presets }: { models?: T[]; presets?: PresetMap }) => Promise<{ models: T[]; presets: PresetMap }>;
 
@@ -59,6 +64,8 @@ export interface ContentSourceOptions {
 type ContentSourceData = ContentStoreTypes.ContentSourceData;
 type ContentSourceRawData = Omit<ContentSourceData, 'models' | 'modelMap' | 'documents' | 'documentMap'>;
 
+export const StackbitPresetModelName = 'stackbitPreset';
+
 export class ContentStore {
     private readonly logger: ContentStoreTypes.Logger;
     private readonly userLogger: ContentStoreTypes.Logger;
@@ -71,12 +78,14 @@ export class ContentStore {
     private readonly devAppRestartNeeded?: () => void;
     private contentSources: CSITypes.ContentSourceInterface[] = [];
     private contentSourceDataById: Record<string, ContentSourceData> = {};
+    private presetsContentSource?: CSITypes.ContentSourceInterface;
     private contentUpdatesWatchTimer: Timer;
     private stackbitConfig: Config | null = null;
     private yamlModels: Model[] = [];
     private configModels: Model[] = [];
     private modelExtensions: ModelExtension[] | null = null;
     private presets: PresetMap = {};
+    private siteMapEntryGroups: SiteMapEntryGroups = {};
 
     constructor(options: ContentSourceOptions) {
         this.logger = options.logger.createLogger({ label: 'content-store' });
@@ -133,7 +142,6 @@ export class ContentStore {
                 this.yamlModels = await this.loadYamlModels({ stackbitConfig });
                 this.configModels = this.mergeConfigModels(stackbitConfig.models ?? [], this.yamlModels);
             }
-            this.presets = await this.loadPresets({ stackbitConfig });
         }
 
         await this.loadContentSourcesAndProcessData({ init: true });
@@ -211,10 +219,10 @@ export class ContentStore {
             // Check if any of the preset files were changed. If presets were changed, reload them.
             const presetDirs = getPresetDirs(this.stackbitConfig);
             const presetsChanged = updatedFiles.find((updatedFile) => _.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 });
             }
         }
 
@@ -237,7 +245,7 @@ export class ContentStore {
             }
         }
 
-        const contentChanges: ContentStoreTypes.ContentChangeResult = {
+        let contentChanges: ContentStoreTypes.ContentChangeResult = {
             updatedDocuments: [],
             updatedAssets: [],
             deletedDocuments: [],
@@ -250,14 +258,22 @@ export class ContentStore {
         if (schemaChanged) {
             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 updateSiteMapEntriesWithContentChanges({
+                siteMapEntryGroups: this.siteMapEntryGroups,
+                contentChanges,
+                stackbitConfig: this.stackbitConfig,
+                contentSourceDataById: this.contentSourceDataById
+            });
         }
 
         // TODO: maybe instead of returning object with results
@@ -284,7 +300,7 @@ export class ContentStore {
         return configModelsResult.models;
     }
 
-    private async loadPresets({ stackbitConfig }: { stackbitConfig: Config }): Promise<Record<string, Preset>> {
+    private async loadPresetsFromConfig({ stackbitConfig }: { stackbitConfig: Config }): Promise<PresetMap> {
         const contentSources = stackbitConfig?.contentSources ?? [];
         const singleContentSource = contentSources.length === 1 ? contentSources[0] : null;
         const presetResult = await loadPresets({
@@ -303,6 +319,29 @@ export class ContentStore {
         return presets;
     }
 
+    private async loadPresetsFromContentSource(contentSourceData: ContentSourceRawData): Promise<PresetMap> {
+        const presets = _.reduce(
+            contentSourceData.csiDocuments,
+            (result: Record<string, Preset>, csiDocument) => {
+                if (csiDocument.modelName === StackbitPresetModelName) {
+                    const preset = 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
@@ -338,6 +377,27 @@ export 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 (contentSourceDataRaw?.csiModelMap?.[StackbitPresetModelName]) {
+                this.presetsContentSource = contentSources[i];
+                if (this.presetsContentSource) {
+                    const contentSourceId = 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,
@@ -346,6 +406,12 @@ export class ContentStore {
             contentSourceRawDataArr: contentSourceRawDataArr
         });
         this.contentSources = contentSources;
+
+        // generate create site map entries
+        this.siteMapEntryGroups = await getSiteMapEntriesFromStackbitConfig({
+            stackbitConfig: this.stackbitConfig,
+            contentSourceDataById: this.contentSourceDataById
+        });
     }
 
     private async loadContentSourceData({
@@ -409,9 +475,15 @@ export class ContentStore {
             getAsset({ assetId }: { assetId: string }) {
                 return csiAssetMap[assetId];
             },
-            onContentChange: (contentChangeEvent: CSITypes.ContentChangeEvent) => {
+            onContentChange: async (contentChangeEvent: CSITypes.ContentChangeEvent) => {
                 this.logger.debug('content source called onContentChange', { contentSourceId });
                 const result = this.onContentChange(contentSourceId, contentChangeEvent);
+                this.siteMapEntryGroups = await updateSiteMapEntriesWithContentChanges({
+                    siteMapEntryGroups: this.siteMapEntryGroups,
+                    contentChanges: result,
+                    stackbitConfig: this.stackbitConfig,
+                    contentSourceDataById: this.contentSourceDataById
+                });
                 this.onContentChangeCallback(result);
             },
             onSchemaChange: async () => {
@@ -442,6 +514,9 @@ export class ContentStore {
     private onContentChange(contentSourceId: string, contentChangeEvent: CSITypes.ContentChangeEvent): ContentStoreTypes.ContentChangeResult {
         // TODO: prevent content change process for contentSourceId if loading content is in progress
 
+        // certain content changes, like preset changes are interpreted as schema changes
+        let schemaChanged = false;
+
         this.logger.debug('onContentChange', {
             contentSourceId,
             documentCount: contentChangeEvent.documents.length,
@@ -461,6 +536,19 @@ export class ContentStore {
 
         // update contentSourceData with deleted documents
         contentChangeEvent.deletedDocumentIds.forEach((docId) => {
+            // remove preset, make sure there is something to remove first because
+            // were explicitly calling onContentChange from deletePreset as well
+            if (this.presets[docId] && contentSourceData.csiDocumentMap[docId]?.modelName === 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];
@@ -557,10 +645,26 @@ export class ContentStore {
                 contentSourceData.documents.push(document);
                 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 === StackbitPresetModelName) {
+                schemaChanged = true;
+                const preset = 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
+                        contentSourceData.modelMap[preset.modelName]?.presets?.push(csiDocument.id);
+                    }
+                }
+            }
             result.updatedDocuments.push({
                 srcType: contentSourceData.srcType,
                 srcProjectId: contentSourceData.srcProjectId,
@@ -588,6 +692,10 @@ export class ContentStore {
             });
         }
 
+        if (schemaChanged) {
+            this.onSchemaChangeCallback?.();
+        }
+
         return result;
     }
 
@@ -623,48 +731,58 @@ export 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: { configModel: ModelExtension; matchedCSIModels: CSITypes.ModelWithSource[] }[] = [];
-        const filteredConfigModels = (configModels as ModelExtension[]).filter((configModel) => {
+        const nonMatchedModels: { configModel: ModelExtension; matchedCSIModels: CSITypes.ModelWithSource[] }[] = [];
+        const configModelsByContentSourceId = (configModels as ModelExtension[]).reduce((modelGroups: Record<string, Model[]>, 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;
-        }) as Model[];
+            const contentSource = matchedCSIModels[0]!;
+            const contentSourceId = getContentSourceId(contentSource.srcType, contentSource.srcProjectId);
+            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: CSITypes.ModelWithSource[], csData) => {
+            const contentSourceId = getContentSourceId(csData.srcType, csData.srcProjectId);
             const mergedModels = mergeConfigModelsWithExternalModels({
-                configModels: filteredConfigModels,
+                configModels: configModelsByContentSourceId[contentSourceId] ?? [],
                 externalModels: csData.csiModels
             });
             const modelsWithSource = mergedModels.map(
@@ -687,34 +805,39 @@ export class ContentStore {
         const modelsWithPresetsIds = extendModelsWithPresetsIds({ models: validatedModels, presets });
         const { models } = await this.handleConfigAssets({ models: modelsWithPresetsIds });
 
-        const csiDocumentsWithSource = contentSourceRawDataArr.reduce((accum: CSITypes.DocumentWithSource[], csData) => {
-            const csiDocumentsWithSource = csData.csiDocuments.map(
-                (csiDocument): CSITypes.DocumentWithSource => ({
-                    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 =
-            stackbitConfig?.mapDocuments?.({
-                documents: _.cloneDeep(csiDocumentsWithSource),
-                models: _.cloneDeep(models)
-            }) ?? csiDocumentsWithSource;
+        let documentMapByContentSource: Record<string, Record<string, CSITypes.Document[]>> | null = null;
+        if (stackbitConfig?.mapDocuments) {
+            const csiDocumentsWithSource = contentSourceRawDataArr.reduce((accum: CSITypes.DocumentWithSource[], csData) => {
+                const csiDocumentsWithSource = csData.csiDocuments.map(
+                    (csiDocument): CSITypes.DocumentWithSource => ({
+                        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 =
+                stackbitConfig?.mapDocuments?.({
+                    documents: _.cloneDeep(csiDocumentsWithSource),
+                    models: _.cloneDeep(models)
+                }) ?? csiDocumentsWithSource;
+            documentMapByContentSource = groupDocumentsByContentSource({ documents: mappedDocs });
+        }
 
         const modelMapByContentSource = groupModelsByContentSource({ models: models });
-        const documentMapByContentSource = groupDocumentsByContentSource({ documents: mappedDocs });
 
         const contentSourceDataArr = contentSourceRawDataArr.map(
             (csData): ContentSourceData => {
                 const modelMap = _.get(modelMapByContentSource, [csData.srcType, csData.srcProjectId], {});
-                const mappedCSIDocuments = _.get(documentMapByContentSource, [csData.srcType, csData.srcProjectId], []);
+                const csiDocuments = documentMapByContentSource
+                    ? _.get(documentMapByContentSource, [csData.srcType, csData.srcProjectId], [])
+                    : csData.csiDocuments;
                 const documents = mapCSIDocumentsToStoreDocuments({
-                    csiDocuments: mappedCSIDocuments,
+                    csiDocuments: csiDocuments,
                     contentSourceInstance: csData.instance,
                     defaultLocaleCode: csData.defaultLocaleCode,
                     modelMap: modelMap
@@ -770,6 +893,10 @@ export class ContentStore {
         return contentSourceData.instance.getProjectEnvironment();
     }
 
+    usesContentSourcePresets() {
+        return Boolean(this.presetsContentSource);
+    }
+
     async hasAccess({
         srcType,
         srcProjectId,
@@ -878,64 +1005,32 @@ export class ContentStore {
     }
 
     getSiteMapEntries({ locale }: { locale?: string } = {}): CSITypes.SiteMapEntry[] {
-        if (!this.stackbitConfig?.siteMap) {
-            return [];
-        }
-
-        // TODO: cache siteMap in processData
-        const siteMapOptions = _.reduce(
-            this.contentSourceDataById,
-            (accum: { models: ModelWithSource[]; documents: DocumentWithSource[] }, contentSourceData) => {
-                return {
-                    models: accum.models.concat(
-                        contentSourceData.models.map((model) => ({
-                            srcType: contentSourceData.srcType,
-                            srcProjectId: contentSourceData.srcProjectId,
-                            ...model
-                        }))
-                    ),
-                    documents: accum.documents.concat(mapStoreDocumentsToCSIDocumentsWithSource(contentSourceData.documents))
-                };
+        const siteMapEntries = _.reduce(
+            this.siteMapEntryGroups,
+            (accum: CSITypes.SiteMapEntry[], siteMapEntryGroup) => {
+                return _.reduce(
+                    siteMapEntryGroup,
+                    (accum: CSITypes.SiteMapEntry[], siteMapEntry) => {
+                        if (!siteMapEntry.label) {
+                            const fieldLabelValue = getDocumentFieldLabelValueForSiteMapEntry({
+                                siteMapEntry,
+                                locale,
+                                contentSourceDataById: this.contentSourceDataById
+                            });
+                            siteMapEntry = {
+                                ...siteMapEntry,
+                                label: fieldLabelValue ?? siteMapEntry.urlPath
+                            };
+                        }
+                        accum.push(siteMapEntry);
+                        return accum;
+                    },
+                    accum
+                );
             },
-            { models: [], documents: [] }
+            []
         );
 
-        const siteMapEntries = this.stackbitConfig.siteMap(siteMapOptions).reduce((accum: CSITypes.SiteMapEntry[], 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;
-                }
-            }
-
-            if (!siteMapEntry.label) {
-                const fieldLabelValue = getDocumentFieldLabelValueForSiteMapEntry({ siteMapEntry, locale, contentSourceDataById: this.contentSourceDataById });
-                siteMapEntry = {
-                    ...siteMapEntry,
-                    label: fieldLabelValue ?? siteMapEntry.urlPath
-                };
-            }
-
-            if (!siteMapEntry.stableId) {
-                siteMapEntry = {
-                    ...siteMapEntry,
-                    stableId: 'document' in siteMapEntry ? siteMapEntry.document.id : siteMapEntry.urlPath
-                };
-            }
-
-            accum.push(siteMapEntry);
-            return accum;
-        }, []);
-
         return _.isEmpty(locale) ? siteMapEntries : siteMapEntries.filter((siteMapEntry) => !siteMapEntry.locale || siteMapEntry.locale === locale);
     }
 
@@ -960,7 +1055,8 @@ export class ContentStore {
                 const currentDocuments = _.isEmpty(locale)
                     ? contentSourceData.documents
                     : contentSourceData.documents.filter((document) => !document.locale || document.locale === locale);
-                return documents.concat(currentDocuments);
+                const filteredDocuments = currentDocuments.filter((document) => document.srcModelName !== StackbitPresetModelName);
+                return documents.concat(filteredDocuments);
             },
             []
         );
@@ -997,7 +1093,8 @@ export class ContentStore {
                     ? contentSourceData.assets.filter((asset) => !asset.locale || asset.locale === locale)
                     : contentSourceData.assets;
                 const currentLocale = locale ?? contentSourceData.defaultLocaleCode;
-                const documentObjects = mapDocumentsToLocalizedApiObjects(documents, currentLocale);
+                const filteredDocuments = documents.filter((document) => document.srcModelName !== StackbitPresetModelName);
+                const documentObjects = mapDocumentsToLocalizedApiObjects(filteredDocuments, currentLocale);
                 const imageObjects = mapAssetsToLocalizedApiImages(assets, currentLocale);
                 return objects.concat(documentObjects, imageObjects);
             },
@@ -1154,6 +1251,63 @@ export class ContentStore {
         return { srcDocumentId: updatedDocument.id };
     }
 
+    async createPreset({
+        preset,
+        thumbnailAsset,
+        user
+    }: {
+        preset: Preset;
+        thumbnailAsset: ContentStoreTypes.UploadAssetData;
+        user?: ContentStoreTypes.User;
+    }): Promise<{ srcDocumentId: string }> {
+        if (!this.presetsContentSource) {
+            throw new Error('No content source available for preset saving');
+        }
+        let thumbnail: string | undefined;
+        if (thumbnailAsset) {
+            const assets = await this.uploadAssets({
+                srcType: this.presetsContentSource.getContentSourceType(),
+                srcProjectId: this.presetsContentSource.getProjectId(),
+                assets: [thumbnailAsset],
+                user
+            });
+            thumbnail = assets[0]?.objectId;
+        }
+        const contentSourceData = this.getContentSourceDataByIdOrThrow(getContentSourceIdForContentSource(this.presetsContentSource));
+        const document = await this.createDocument({
+            srcType: this.presetsContentSource.getContentSourceType(),
+            srcProjectId: this.presetsContentSource.getProjectId(),
+            modelName: StackbitPresetModelName,
+            object: {
+                ...getDocumentObjectFromPreset(preset, contentSourceData.modelMap[StackbitPresetModelName]),
+                thumbnail
+            },
+            user
+        });
+        return { srcDocumentId: document.srcDocumentId };
+    }
+
+    async deletePreset({ presetId, user }: { presetId: string; user?: ContentStoreTypes.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(getContentSourceIdForContentSource(this.presetsContentSource), {
+            documents: [],
+            deletedDocumentIds: [presetId],
+            assets: [],
+            deletedAssetIds: []
+        });
+    }
+
     async uploadAndLinkAsset({
         srcType,
         srcProjectId,
@@ -1608,7 +1762,9 @@ export class ContentStore {
             const contentSourceDocuments = _.isEmpty(locale)
                 ? contentSourceData.documents
                 : contentSourceData.documents.filter((document) => !document.locale || document.locale === locale);
-            documents.push(...contentSourceDocuments);
+
+            const filteredDocuments = contentSourceDocuments.filter((document) => document.srcModelName !== StackbitPresetModelName);
+            documents.push(...filteredDocuments);
 
             if (contentSourceData.defaultLocaleCode) {
                 defaultLocales[contentSourceId] = contentSourceData.defaultLocaleCode;