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

package/src/utils/preset-utils.ts

@@ -0,0 +1,94 @@
+import _ from 'lodash';
+import { Preset } from '@stackbit/sdk';
+import * as CSITypes from '@stackbit/types';
+import { DocumentField, getLocalizedFieldForLocale, Logger, Model } from '@stackbit/types';
+
+function getPresetData(presetId: string, field: DocumentField, logger?: Logger) {
+    const dataField = getLocalizedFieldForLocale(field);
+    let data;
+    if (dataField?.type === 'json') {
+        data = dataField.value;
+    } else if (dataField?.type === 'string' || dataField?.type === 'text') {
+        try {
+            data = JSON.parse(dataField.value);
+        } catch (err) {
+            logger?.error(`Can't parse data field for preset ${presetId}`);
+        }
+    }
+    return data;
+}
+
+function getPresetThumbnail(presetId: string, thumbnailField: DocumentField, csiAssetMap: Record<string, CSITypes.Asset>, logger?: Logger) {
+    let thumbnail;
+    if (thumbnailField?.type === 'image') {
+        const imageFields = getLocalizedFieldForLocale(thumbnailField)?.fields;
+        if (imageFields) {
+            const urlField = imageFields.url;
+            if (urlField?.localized) {
+                const vals = Object.values(urlField.locales);
+                if (vals?.length) {
+                    thumbnail = vals[0]?.value;
+                }
+            } else {
+                thumbnail = urlField.value;
+            }
+        }
+    } else if (thumbnailField?.type === 'reference' && thumbnailField.refType === 'asset') {
+        const refId = getLocalizedFieldForLocale(thumbnailField)?.refId;
+        if (refId) {
+            const fileField = csiAssetMap[refId]?.fields.file;
+            if (fileField?.localized) {
+                const vals = Object.values(fileField.locales);
+                if (vals?.length) {
+                    thumbnail = vals[0]?.url;
+                }
+            } else {
+                thumbnail = fileField?.url;
+            }
+        } else {
+            logger?.warn(`No thumbnail reference found for preset ${presetId}`);
+        }
+    }
+    return thumbnail;
+}
+
+export function getPresetFromDocument({
+    srcType,
+    srcProjectId,
+    csiDocument,
+    csiAssetMap,
+    logger
+}: {
+    srcType: string;
+    srcProjectId: string;
+    csiDocument: CSITypes.Document;
+    csiAssetMap: Record<string, CSITypes.Asset>;
+    logger?: Logger;
+}): Preset | null {
+    const data = csiDocument.fields['data'] ? getPresetData(csiDocument.id, csiDocument.fields['data'], logger) : null;
+    if (!data) {
+        logger?.warn(`Error finding preset data for preset ${csiDocument.id}`);
+        return null;
+    }
+    const thumbnail = csiDocument.fields['thumbnail'] ? getPresetThumbnail(csiDocument.id, csiDocument.fields['thumbnail'], csiAssetMap, logger) : null;
+    return {
+        srcType,
+        srcProjectId,
+        ...data,
+        thumbnail
+    };
+}
+
+export function getDocumentObjectFromPreset(preset: Preset, model?: Model): Record<string, any> {
+    let presetData: Record<string, any> | string = _.omit(preset, 'thumbnail');
+    if (model && model.fields) {
+        const dataField = model.fields.find((field) => field.name === 'data');
+        if (dataField?.type === 'string' || dataField?.type === 'text') {
+            presetData = JSON.stringify(presetData, null, 2);
+        }
+    }
+    return {
+        label: preset.label,
+        data: presetData
+    };
+}

package/src/utils/site-map.ts

@@ -0,0 +1,224 @@
+import _ from 'lodash';
+import { Config } from '@stackbit/sdk';
+import { append } from '@stackbit/utils';
+import { SiteMapEntry } from '@stackbit/types';
+import * as CSITypes from '@stackbit/types';
+import * as ContentStoreTypes from '../content-store-types';
+import { mapStoreDocumentsToCSIDocumentsWithSource } from './store-to-csi-docs-converter';
+import { getContentSourceId, getDocumentFieldForLocale } from '../content-store-utils';
+
+export const SiteMapStaticEntriesKey = Symbol.for('SiteMapStaticEntriesKey');
+export type SiteMapEntriesSourceKeys = string | symbol;
+/**
+ * SiteMapEntryGroups is a two level hashmap.
+ * If the SiteMapEntry is document-related, the first level key will be an
+ * identifier of the document including content source, and the second key will
+ * be the stableId. If the SiteMapEntry is static entry, the first key will
+ * be a constant Symbol and the second key will be the stableId.
+ * {
+ *     `{srcType}:{srcProjectId}:{srcDocumentId}`: {
+ *         `{stableId}`: SiteMapEntry
+ *     },
+ *     [SiteMapStaticEntriesKey]: {
+ *         `{stableId}`: SiteMapEntry
+ *     }
+ * }
+ */
+export type SiteMapEntryGroups = Record<SiteMapEntriesSourceKeys, Record<string, SiteMapEntry>>;
+
+export async function getSiteMapEntriesFromStackbitConfig({
+    stackbitConfig,
+    contentSourceDataById
+}: {
+    stackbitConfig: Config | null;
+    contentSourceDataById: Record<string, ContentStoreTypes.ContentSourceData>;
+}): Promise<SiteMapEntryGroups> {
+    if (!stackbitConfig?.siteMap) {
+        return {};
+    }
+
+    const siteMapOptions = _.reduce(
+        contentSourceDataById,
+        (accum: { models: CSITypes.ModelWithSource[]; documents: CSITypes.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))
+            };
+        },
+        { models: [], documents: [] }
+    );
+
+    const rawSiteMapEntries = await stackbitConfig.siteMap(siteMapOptions);
+
+    // The rawSiteMapEntries entries are provided by the user, sanitize them and filter out illegal entries
+    return sanitizeAndGroupSiteMapEntries(rawSiteMapEntries);
+}
+
+/**
+ * Because the sitemap is directly affected by documents, the sitemap can change
+ * whenever there is a content change. For example, if a new document is added
+ * or deleted, a new sitemap entry would be added or deleted respectively.
+ * Likewise, if a slug of an existing document is changed, the sitemap entry for
+ * that document would also change.
+ *
+ * However, to improve overall performance, we don't want to call
+ * stackbitConfig.siteMap() with all the documents when a small set of documents
+ * is changed. Instead, we want to call stackbitConfig.siteMap() with only the
+ * changed documents. Then we merge the partial sitemap entries with the
+ * existing sitemap entries using sitemap entry identifiers such as
+ * srcDocumentId for document-related entries and stackbitId for static entries.
+ *
+ * @param siteMapEntries Existing sitemap entries
+ * @param contentChanges A ContentChangeResult including new, changed and
+ *   deleted documents
+ * @param stackbitConfig Stackbit config
+ * @param contentSourceDataById ContentSourceData by content source IDs
+ */
+export async function updateSiteMapEntriesWithContentChanges({
+    siteMapEntryGroups,
+    contentChanges,
+    stackbitConfig,
+    contentSourceDataById
+}: {
+    siteMapEntryGroups: SiteMapEntryGroups;
+    contentChanges: ContentStoreTypes.ContentChangeResult;
+    stackbitConfig: Config | null;
+    contentSourceDataById: Record<string, ContentStoreTypes.ContentSourceData>;
+}): Promise<SiteMapEntryGroups> {
+    if (!stackbitConfig?.siteMap) {
+        return {};
+    }
+
+    // Create a map of changed documents by content source id
+    const changedDocumentsByContentSourceId = contentChanges.updatedDocuments.reduce(
+        (accum: Record<string, ContentStoreTypes.Document[]>, contentChangeResultItem) => {
+            const contentSourceId = getContentSourceId(contentChangeResultItem.srcType, contentChangeResultItem.srcProjectId);
+            const document = contentSourceDataById[contentSourceId]?.documentMap[contentChangeResultItem.srcObjectId];
+            if (document) {
+                append(accum, contentSourceId, document);
+            }
+            return accum;
+        },
+        {}
+    );
+
+    // Create siteMap parameters from changed documents
+    const partialSiteMapOptions = _.reduce(
+        contentSourceDataById,
+        (accum: { models: CSITypes.ModelWithSource[]; documents: CSITypes.DocumentWithSource[] }, contentSourceData) => {
+            const changedDocuments = changedDocumentsByContentSourceId[contentSourceData.id] ?? [];
+            return {
+                models: accum.models.concat(
+                    contentSourceData.models.map((model) => ({
+                        srcType: contentSourceData.srcType,
+                        srcProjectId: contentSourceData.srcProjectId,
+                        ...model
+                    }))
+                ),
+                documents: accum.documents.concat(mapStoreDocumentsToCSIDocumentsWithSource(changedDocuments))
+            };
+        },
+        { models: [], documents: [] }
+    );
+
+    const partialRawSiteMapEntries = await stackbitConfig.siteMap(partialSiteMapOptions);
+
+    // The partialRawSiteMapEntries entries are provided by the user, sanitize them and filter out illegal entries
+    const partialSiteMapEntryGroups = sanitizeAndGroupSiteMapEntries(partialRawSiteMapEntries);
+
+    siteMapEntryGroups = _.reduce(
+        contentChanges.deletedDocuments,
+        (accum, contentChangeResultItem: ContentStoreTypes.ContentChangeResultItem) => {
+            const siteMapGroupKey = `${contentChangeResultItem.srcType}:${contentChangeResultItem.srcProjectId}:${contentChangeResultItem.srcObjectId}`;
+            delete accum[siteMapGroupKey];
+            return accum;
+        },
+        siteMapEntryGroups
+    );
+
+    siteMapEntryGroups = _.reduce(
+        partialSiteMapEntryGroups,
+        (accum, newSiteMapEntriesByStableId, siteMapGroupKey) => {
+            accum[siteMapGroupKey] = newSiteMapEntriesByStableId;
+            return accum;
+        },
+        siteMapEntryGroups
+    );
+
+    return siteMapEntryGroups;
+}
+
+function sanitizeAndGroupSiteMapEntries(siteMapEntries: SiteMapEntry[]): SiteMapEntryGroups {
+    return siteMapEntries.reduce((accum: SiteMapEntryGroups, siteMapEntry) => {
+        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.stableId) {
+            siteMapEntry = {
+                ...siteMapEntry,
+                stableId: 'document' in siteMapEntry ? siteMapEntry.document.id : siteMapEntry.urlPath
+            };
+        }
+
+        const groupKey = getSiteMapGroupKey(siteMapEntry);
+        _.set(accum, [groupKey, siteMapEntry.stableId!], siteMapEntry);
+        return accum;
+    }, {});
+}
+
+function getSiteMapGroupKey(siteMapEntry: SiteMapEntry) {
+    return 'document' in siteMapEntry
+        ? `${siteMapEntry.document.srcType}:${siteMapEntry.document.srcProjectId}:${siteMapEntry.document.id}`
+        : SiteMapStaticEntriesKey;
+}
+
+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);
+}