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

package/src/utils/csi-to-store-docs-converter.ts

@@ -1,11 +1,21 @@
 import _ from 'lodash';
-import { Model, ImageModel } from '@stackbit/sdk';
-import { Field, FieldSpecificProps, FieldList, FieldModelProps, FieldObjectProps, isLocalizedField, isDocumentFieldOneOfFieldTypes } from '@stackbit/types';
+import { Model, ObjectModel, ImageModel } from '@stackbit/sdk';
+import { omitByNil } from '@stackbit/utils';
+import {
+    Field,
+    FieldSpecificProps,
+    FieldList,
+    FieldModelProps,
+    FieldObjectProps,
+    isLocalizedField,
+    getLocalizedFieldForLocale,
+    isDocumentFieldOneOfFieldTypes
+} from '@stackbit/types';
 import * as CSITypes from '@stackbit/types';
 
 import * as ContentStoreTypes from '../types';
 import { IMAGE_MODEL } from '../common/common-schema';
-import { omitByNil } from '@stackbit/utils';
+import { BackCompatContentSourceInterface } from './backward-compatibility';
 
 export function mapCSIAssetsToStoreAssets({
     csiAssets,
@@ -13,7 +23,7 @@ export function mapCSIAssetsToStoreAssets({
     defaultLocaleCode
 }: {
     csiAssets: CSITypes.Asset[];
-    contentSourceInstance: CSITypes.ContentSourceInterface;
+    contentSourceInstance: BackCompatContentSourceInterface;
     defaultLocaleCode?: string;
 }): ContentStoreTypes.Asset[] {
     const extra = getMetadataFromContentStore({ contentSourceInstance });
@@ -40,7 +50,7 @@ function sourceAssetToStoreAsset({
         ...extra,
         srcObjectId: csiAsset.id,
         srcObjectUrl: csiAsset.manageUrl,
-        srcObjectLabel: getObjectLabel(csiAsset.fields, IMAGE_MODEL, defaultLocaleCode),
+        srcObjectLabel: getAssetLabel(csiAsset, defaultLocaleCode),
         srcModelName: IMAGE_MODEL.name,
         srcModelLabel: IMAGE_MODEL.label!,
         isChanged: csiAsset.status === 'added' || csiAsset.status === 'modified',
@@ -87,21 +97,24 @@ export function mapCSIDocumentsToStoreDocuments({
     csiDocuments,
     contentSourceInstance,
     modelMap,
-    defaultLocaleCode
+    defaultLocaleCode,
+    createConfigDelegate
 }: {
     csiDocuments: CSITypes.Document[];
-    contentSourceInstance: CSITypes.ContentSourceInterface;
+    contentSourceInstance: BackCompatContentSourceInterface;
     modelMap: Record<string, Model>;
     defaultLocaleCode?: string;
+    createConfigDelegate: () => CSITypes.ConfigDelegate;
 }): ContentStoreTypes.Document[] {
-    const extra = getMetadataFromContentStore({ contentSourceInstance });
+    const meta = getMetadataFromContentStore({ contentSourceInstance });
     return csiDocuments.map((csiDocument) =>
         mapCSIDocumentToStoreDocument({
             csiDocument,
             model: modelMap[csiDocument.modelName]!,
             modelMap,
             defaultLocaleCode,
-            extra
+            meta,
+            createConfigDelegate
         })
     );
 }
@@ -111,20 +124,30 @@ function mapCSIDocumentToStoreDocument({
     model,
     modelMap,
     defaultLocaleCode,
-    extra
+    meta,
+    createConfigDelegate
 }: {
     csiDocument: CSITypes.Document;
     model: Model;
     modelMap: Record<string, Model>;
     defaultLocaleCode?: string;
-    extra: { srcType: string; srcProjectId: string; srcProjectUrl: string; srcEnvironment: string };
+    meta: { srcType: string; srcProjectId: string; srcProjectUrl: string; srcEnvironment: string };
+    createConfigDelegate: () => CSITypes.ConfigDelegate;
 }): ContentStoreTypes.Document {
     return omitByNil({
         type: 'document',
-        ...extra,
+        ...meta,
         srcObjectId: csiDocument.id,
         srcObjectUrl: csiDocument.manageUrl,
-        srcObjectLabel: getObjectLabel(csiDocument.fields, model, defaultLocaleCode),
+        getPreview: ({ delegate, locale }: { delegate?: CSITypes.ConfigDelegate; locale?: string }) =>
+            getDocumentPreview({
+                csiDocument,
+                model,
+                srcType: meta.srcType,
+                srcProjectId: meta.srcProjectId,
+                delegate: delegate ?? createConfigDelegate(),
+                locale
+            }),
         srcModelLabel: model.label ?? _.startCase(csiDocument.modelName),
         srcModelName: csiDocument.modelName,
         isChanged: csiDocument.status === 'added' || csiDocument.status === 'modified',
@@ -133,21 +156,29 @@ function mapCSIDocumentToStoreDocument({
         createdBy: csiDocument.createdBy,
         updatedAt: csiDocument.updatedAt,
         updatedBy: csiDocument.updatedBy,
-        locale: csiDocument.locale,
+        locale: getDocumentLocale({ csiDocument, model }),
         fields: mapCSIFieldsToStoreFields({
             csiDocumentFields: csiDocument.fields,
             modelFields: model.fields ?? [],
             context: {
+                srcType: meta.srcType,
+                srcProjectId: meta.srcProjectId,
+                parentDocument: csiDocument,
                 modelMap,
-                defaultLocaleCode
+                defaultLocaleCode,
+                createConfigDelegate
             }
         })
     });
 }
 
 type MapContext = {
+    srcType: string;
+    srcProjectId: string;
+    parentDocument: CSITypes.Document;
     modelMap: Record<string, Model>;
     defaultLocaleCode?: string;
+    createConfigDelegate: () => CSITypes.ConfigDelegate;
 };
 
 function mapCSIFieldsToStoreFields({
@@ -225,7 +256,7 @@ function mapCSIFieldToStoreField({
         case 'reference':
             return csiDocumentField as ContentStoreTypes.DocumentField;
         case 'cross-reference':
-            return mapReferenceField(csiDocumentField);
+            return mapCrossReferenceField(csiDocumentField);
         case 'object':
             return mapObjectField(csiDocumentField as CSITypes.DocumentObjectField, modelField, context);
         case 'model':
@@ -244,7 +275,7 @@ function mapCSIFieldToStoreField({
     }
 }
 
-function mapReferenceField(csiDocumentField: CSITypes.DocumentField): ContentStoreTypes.DocumentCrossReferenceField {
+function mapCrossReferenceField(csiDocumentField: CSITypes.DocumentField): ContentStoreTypes.DocumentCrossReferenceField {
     const unlocalizedUnset = {
         type: 'cross-reference',
         refType: 'document',
@@ -342,10 +373,21 @@ function mapObjectField(
     modelField: FieldObjectProps,
     context: MapContext
 ): ContentStoreTypes.DocumentObjectField {
+    const _getObjectPreview = ({ delegate, locale }: { delegate?: CSITypes.ConfigDelegate; locale?: string }) => {
+        return getObjectPreview({
+            parentDocument: context.parentDocument,
+            documentField: csiDocumentField,
+            objectModelOrObjectField: modelField,
+            srcType: context.srcType,
+            srcProjectId: context.srcProjectId,
+            delegate: delegate ?? context.createConfigDelegate(),
+            locale
+        }) as ContentStoreTypes.DocumentObjectFieldPreview;
+    };
     if (!isLocalizedField(csiDocumentField)) {
         return {
             type: csiDocumentField.type,
-            srcObjectLabel: getObjectLabel(csiDocumentField.fields ?? {}, modelField ?? [], context.defaultLocaleCode),
+            getPreview: _getObjectPreview,
             fields: mapCSIFieldsToStoreFields({
                 csiDocumentFields: csiDocumentField.fields ?? {},
                 modelFields: modelField.fields ?? [],
@@ -359,7 +401,7 @@ function mapObjectField(
         locales: _.mapValues(csiDocumentField.locales, (locale) => {
             return {
                 locale: locale.locale,
-                srcObjectLabel: getObjectLabel(locale.fields ?? {}, modelField, locale.locale),
+                getPreview: _getObjectPreview,
                 fields: mapCSIFieldsToStoreFields({
                     csiDocumentFields: locale.fields ?? {},
                     modelFields: modelField.fields ?? [],
@@ -371,11 +413,24 @@ function mapObjectField(
 }
 
 function mapModelField(csiDocumentField: CSITypes.DocumentModelField, modelField: FieldModelProps, context: MapContext): ContentStoreTypes.DocumentModelField {
+    const _getObjectPreview =
+        (model: ObjectModel) =>
+        ({ delegate, locale }: { delegate?: CSITypes.ConfigDelegate; locale?: string }) => {
+            return getObjectPreview({
+                parentDocument: context.parentDocument,
+                documentField: csiDocumentField,
+                objectModelOrObjectField: model,
+                srcType: context.srcType,
+                srcProjectId: context.srcProjectId,
+                delegate: delegate ?? context.createConfigDelegate(),
+                locale
+            }) as ContentStoreTypes.DocumentModelFieldPreview;
+        };
     if (!isLocalizedField(csiDocumentField)) {
-        const model = context.modelMap[csiDocumentField.modelName]!;
+        const model = context.modelMap[csiDocumentField.modelName]! as ObjectModel;
         return {
             type: csiDocumentField.type,
-            srcObjectLabel: getObjectLabel(csiDocumentField.fields ?? {}, model, context.defaultLocaleCode),
+            getPreview: _getObjectPreview(model),
             srcModelName: csiDocumentField.modelName,
             srcModelLabel: model.label ?? _.startCase(model.name),
             fields: mapCSIFieldsToStoreFields({
@@ -389,10 +444,10 @@ function mapModelField(csiDocumentField: CSITypes.DocumentModelField, modelField
         type: csiDocumentField.type,
         localized: true,
         locales: _.mapValues(csiDocumentField.locales, (locale) => {
-            const model = context.modelMap[locale.modelName]!;
+            const model = context.modelMap[locale.modelName]! as ObjectModel;
             return {
                 locale: locale.locale,
-                srcObjectLabel: getObjectLabel(locale.fields ?? {}, model, locale.locale),
+                getPreview: _getObjectPreview(model),
                 srcModelName: locale.modelName,
                 srcModelLabel: model.label ?? _.startCase(model.name),
                 fields: mapCSIFieldsToStoreFields({
@@ -481,7 +536,7 @@ function mapMarkdownField(csiDocumentField: CSITypes.DocumentStringLikeField): C
     };
 }
 
-function getMetadataFromContentStore({ contentSourceInstance }: { contentSourceInstance: CSITypes.ContentSourceInterface }): {
+function getMetadataFromContentStore({ contentSourceInstance }: { contentSourceInstance: BackCompatContentSourceInterface }): {
     srcType: string;
     srcProjectId: string;
     srcProjectUrl: string;
@@ -495,28 +550,186 @@ function getMetadataFromContentStore({ contentSourceInstance }: { contentSourceI
     };
 }
 
-function getObjectLabel(
-    documentFields: Record<string, CSITypes.DocumentField | CSITypes.AssetFileField>,
-    modelOrObjectField: Model | FieldObjectProps | ImageModel,
-    locale?: string
-): string {
-    const labelField = modelOrObjectField.labelField;
-    let label = null;
-    if (labelField) {
-        const field = _.get(documentFields, labelField, null);
-        if (field && ['string', 'url', 'slug', 'text', 'markdown', 'number', 'enum', 'date', 'datetime', 'color', 'image', 'file'].includes(field.type)) {
-            if (isLocalizedField(field) && locale) {
-                label = _.get(field, ['locales', locale, 'value'], null);
-            } else if (!isLocalizedField(field)) {
-                label = _.get(field, 'value', null);
-            }
+export function getDocumentLocale({ csiDocument, model }: { csiDocument: CSITypes.Document; model: Model }): string | undefined {
+    if (csiDocument.locale) {
+        return csiDocument.locale;
+    }
+    if ((model.type === 'page' || model.type === 'data') && model.localized && typeof model.locale === 'function') {
+        return model.locale({ document: csiDocument, model });
+    }
+}
+
+export function getDocumentPreview({
+    csiDocument,
+    model,
+    srcType,
+    srcProjectId,
+    delegate,
+    locale
+}: {
+    csiDocument: CSITypes.Document;
+    model: Model;
+    srcType: string;
+    srcProjectId: string;
+    delegate: CSITypes.ConfigDelegate;
+    locale?: string;
+}): ContentStoreTypes.DocumentPreview {
+    let previewTitle: string | undefined;
+    if ('preview' in model && model.preview && (model.type === 'page' || model.type === 'data')) {
+        if (typeof model.preview === 'function') {
+            const previewResult = model.preview({
+                document: { ...csiDocument, srcType, srcProjectId },
+                currentLocale: locale,
+                ...delegate
+            });
+            previewTitle = previewResult.title;
+        } else if (model.preview.title) {
+            // do not pass locale when resolving automatically to use default locale
+            previewTitle = resolveDocumentLabelForFieldPath({
+                document: { ...csiDocument, srcType, srcProjectId },
+                fieldPath: model.preview.title,
+                delegate
+            });
         }
     }
-    if (!label) {
-        label = _.get(modelOrObjectField, 'label');
+    // if previewTitle was not resolved, resolve using model, at the worst case the model name or label will be used
+    if (!previewTitle) {
+        previewTitle = getObjectTitleFromLabelField({
+            document: { ...csiDocument, srcType, srcProjectId },
+            modelOrObjectField: model,
+            delegate,
+            locale
+        });
+    }
+    if (!previewTitle) {
+        previewTitle = getObjectTitleFromModel(model);
+    }
+    return { previewTitle };
+}
+
+function getObjectPreview<Type extends CSITypes.DocumentModelField | CSITypes.DocumentObjectField>({
+    parentDocument,
+    documentField,
+    objectModelOrObjectField,
+    srcType,
+    srcProjectId,
+    delegate,
+    locale
+}: {
+    parentDocument: CSITypes.Document;
+    documentField: Type;
+    objectModelOrObjectField: Type extends CSITypes.DocumentModelField ? ObjectModel : CSITypes.FieldObjectProps;
+    srcType: string;
+    srcProjectId: string;
+    delegate: CSITypes.ConfigDelegate;
+    locale?: string;
+}): ContentStoreTypes.DocumentObjectFieldPreview {
+    let previewTitle: string | undefined;
+    if ('preview' in objectModelOrObjectField && objectModelOrObjectField.preview) {
+        if (typeof objectModelOrObjectField.preview === 'function') {
+            const previewResult = objectModelOrObjectField.preview({
+                parentDocument: { ...parentDocument, srcType, srcProjectId },
+                documentField: documentField,
+                currentLocale: locale,
+                ...delegate
+            });
+            previewTitle = previewResult.title;
+        } else if (objectModelOrObjectField.preview.title) {
+            // do not pass locale when resolving automatically to use default locale
+            previewTitle = resolveDocumentLabelForFieldPath({
+                document: { ...parentDocument, srcType, srcProjectId },
+                fromField: documentField,
+                fieldPath: objectModelOrObjectField.preview.title,
+                delegate
+            });
+        }
+    }
+    if (!previewTitle) {
+        previewTitle = getObjectTitleFromLabelField({
+            document: { ...parentDocument, srcType, srcProjectId },
+            documentField,
+            modelOrObjectField: objectModelOrObjectField,
+            delegate,
+            locale
+        });
+    }
+    if (!previewTitle && 'name' in objectModelOrObjectField) {
+        previewTitle = getObjectTitleFromModel(objectModelOrObjectField);
+    }
+    return { previewTitle };
+}
+
+function resolveDocumentLabelForFieldPath({
+    document,
+    fromField,
+    fieldPath,
+    delegate
+}: {
+    document: CSITypes.DocumentWithSource;
+    fromField?: CSITypes.DocumentModelField | CSITypes.DocumentObjectField;
+    fieldPath: string;
+    delegate: CSITypes.ConfigDelegate;
+}): string | undefined {
+    const documentField = delegate.getDocumentFieldForFieldPath({
+        document: document,
+        fromField: fromField,
+        fieldPath: fieldPath
+    });
+    if (documentField && 'value' in documentField) {
+        return documentField.value;
+    }
+    return undefined;
+}
+
+function getObjectTitleFromLabelField({
+    document,
+    documentField,
+    modelOrObjectField,
+    delegate,
+    locale
+}: {
+    document: CSITypes.DocumentWithSource;
+    documentField?: CSITypes.DocumentModelField | CSITypes.DocumentObjectField;
+    modelOrObjectField: Model | FieldObjectProps | ImageModel;
+    delegate: CSITypes.ConfigDelegate;
+    locale?: string;
+}): string | undefined {
+    const labelField = modelOrObjectField.labelField;
+    if (!labelField) {
+        return;
     }
-    if (!label && _.has(modelOrObjectField, 'name')) {
-        label = _.startCase(_.get(modelOrObjectField, 'name'));
+    return resolveDocumentLabelForFieldPath({
+        document: document,
+        fromField: documentField,
+        fieldPath: labelField,
+        delegate
+    });
+}
+
+function getAssetLabel(csiAsset: CSITypes.Asset, locale?: string): string {
+    const imageModel = IMAGE_MODEL;
+    let label = getAssetLabelFromLabelField(csiAsset, imageModel, locale);
+    if (!label) {
+        label = getObjectTitleFromModel(imageModel);
     }
     return label;
 }
+
+function getAssetLabelFromLabelField(csiAsset: CSITypes.Asset, imageModel: ImageModel, locale?: string): string | undefined {
+    const labelField = imageModel.labelField;
+    if (!labelField) {
+        return;
+    }
+    const field = _.get(csiAsset.fields, labelField);
+    if (!field) {
+        return;
+    }
+    const localizedField = getLocalizedFieldForLocale(field as CSITypes.DocumentField, locale);
+    if (localizedField && 'value' in localizedField && localizedField.value) {
+        return localizedField.value;
+    }
+}
+
+function getObjectTitleFromModel(model: Model | ImageModel): string {
+    return model.label ? model.label : _.startCase(model.name);
+}

package/src/utils/site-map.ts

@@ -54,7 +54,7 @@ export async function getSiteMapEntriesFromStackbitConfig({
         { models: [], documents: [] }
     );
 
-    const rawSiteMapEntries = await stackbitConfig.siteMap(siteMapOptions);
+    const rawSiteMapEntries = stackbitConfig.siteMap(siteMapOptions);
 
     // The rawSiteMapEntries entries are provided by the user, sanitize them and filter out illegal entries
     return sanitizeAndGroupSiteMapEntries(rawSiteMapEntries);
@@ -95,6 +95,10 @@ export async function updateSiteMapEntriesWithContentChanges({
         return {};
     }
 
+    if (contentChanges.updatedDocuments.length === 0 && contentChanges.deletedDocuments.length === 0) {
+        return siteMapEntryGroups;
+    }
+
     // Create a map of changed documents by content source id
     const changedDocumentsByContentSourceId = contentChanges.updatedDocuments.reduce(
         (accum: Record<string, ContentStoreTypes.Document[]>, contentChangeResultItem) => {
@@ -177,7 +181,7 @@ function sanitizeAndGroupSiteMapEntries(siteMapEntries: SiteMapEntry[]): SiteMap
                     srcType: doc.srcType,
                     srcProjectId: doc.srcProjectId
                 }
-            }
+            };
         }
 
         if (!siteMapEntry.stableId) {
@@ -196,14 +200,22 @@ function sanitizeAndGroupSiteMapEntries(siteMapEntries: SiteMapEntry[]): SiteMap
 function getSiteMapGroupKey(siteMapEntry: SiteMapEntry): string {
     return 'document' in siteMapEntry
         ? getSiteMapGroupKeyForDocument({
-            srcType: siteMapEntry.document.srcType,
-            srcProjectId: siteMapEntry.document.srcProjectId,
-            srcDocumentId: siteMapEntry.document.id
-        })
+              srcType: siteMapEntry.document.srcType,
+              srcProjectId: siteMapEntry.document.srcProjectId,
+              srcDocumentId: siteMapEntry.document.id
+          })
         : SiteMapStaticEntriesKey.toString();
 }
 
-export function getSiteMapGroupKeyForDocument({ srcType, srcProjectId, srcDocumentId }: { srcType: string; srcProjectId: string; srcDocumentId: string }): string {
+export function getSiteMapGroupKeyForDocument({
+    srcType,
+    srcProjectId,
+    srcDocumentId
+}: {
+    srcType: string;
+    srcProjectId: string;
+    srcDocumentId: string;
+}): string {
     return `${srcType}:${srcProjectId}:${srcDocumentId}`;
 }