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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stackbit/cms-core",
-  "version": "0.1.13-alpha.0",
+  "version": "0.1.13",
   "description": "stackbit-dev",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -29,9 +29,9 @@
     "@babel/parser": "^7.11.5",
     "@babel/traverse": "^7.11.5",
     "@iarna/toml": "^2.2.3",
-    "@stackbit/sdk": "^0.3.9-alpha.0",
-    "@stackbit/types": "^0.1.7-alpha.0",
-    "@stackbit/utils": "^0.2.13-alpha.0",
+    "@stackbit/sdk": "^0.3.9",
+    "@stackbit/types": "^0.1.7",
+    "@stackbit/utils": "^0.2.12",
     "chalk": "^4.0.1",
     "esm": "^3.2.25",
     "fs-extra": "^8.1.0",
@@ -45,5 +45,5 @@
     "sanitize-filename": "^1.6.3",
     "slugify": "^1.6.5"
   },
-  "gitHead": "c655a5d1f3fa7d613fb20c173369cef8e141e633"
+  "gitHead": "c82a7ec57444318dbd585486d90275635373a6f0"
 }

package/src/content-store-types.ts

@@ -1,7 +1,42 @@
 import { DocumentStatus, FieldType } from '@stackbit/types';
+import { Model } from '@stackbit/sdk';
+import * as CSITypes from '@stackbit/types';
 
 export { FieldType, DocumentStatus, Logger } from '@stackbit/types';
 
+export interface ContentSourceData {
+    id: string;
+    instance: CSITypes.ContentSourceInterface;
+    srcType: string;
+    srcProjectId: string;
+    locales?: CSITypes.Locale[];
+    defaultLocaleCode?: string;
+    /* Array of extended and validated Models */
+    models: Model[];
+    /* Map of extended and validated Models by model name */
+    modelMap: Record<string, Model>;
+    /* Array of original Models (as provided by content source)  */
+    csiModels: CSITypes.Model[];
+    /* Map of original Models (as provided by content source) by model name */
+    csiModelMap: Record<string, CSITypes.Model>;
+    /* Array of original content source Documents */
+    csiDocuments: CSITypes.Document[];
+    /* Map of original content source Documents by document ID */
+    csiDocumentMap: Record<string, CSITypes.Document>;
+    /* Array of converted content-store Documents */
+    documents: Document[];
+    /* Map of converted content-store Documents by document ID */
+    documentMap: Record<string, Document>;
+    /* Array of original content source Assets */
+    csiAssets: CSITypes.Asset[];
+    /* Map of original content source Assets by asset ID */
+    csiAssetMap: Record<string, CSITypes.Asset>;
+    /* Array of converted content-store Assets */
+    assets: Asset[];
+    /* Map of converted content-store Assets by asset ID */
+    assetMap: Record<string, Asset>;
+}
+
 export interface Document {
     type: 'document';
     srcType: string;
@@ -170,7 +205,7 @@ export type DocumentFieldTypeLocalized<BaseFieldProps, LocalizedFieldProps> = Si
     BaseFieldProps & {
         label?: string;
         localized: true;
-        locales: Record<string, { locale: string } & Exclude<LocalizedFieldProps, DocumentFieldUnsetProps>>;
+        locales: Record<string, { locale: string } & Omit<Exclude<LocalizedFieldProps, DocumentFieldUnsetProps>, 'isUnset'>>;
     }
 >;
 
@@ -188,7 +223,7 @@ export type DocumentFieldTypeAPI<BaseFieldProps, LocalizedFieldProps> = BaseFiel
         description?: string;
         locale?: string;
         localized?: boolean;
-    } & ({ localized?: false; } | { localized: true; locale: string; });
+    } & ({ localized?: false } | { localized: true; locale: string });
 
 // any field that is not 'object' | 'model' | 'reference' | 'richText' | 'markdown' | 'list'
 export type DocumentValueFieldType = Exclude<FieldType, 'object' | 'model' | 'reference' | 'markdown' | 'richText' | 'list' | 'image'>;
@@ -306,11 +341,13 @@ export type DocumentListFieldAPI = DocumentFieldTypeAPI<DocumentListFieldBase, D
 export type DocumentListFieldBase = {
     type: 'list';
 };
+export type DocumentListFieldItems = Exclude<DocumentFieldNonLocalized, DocumentListFieldNonLocalized>;
 export type DocumentListFieldProps = {
-    items: DocumentField[];
+    items: DocumentListFieldItems[];
 };
+export type DocumentListFieldItemsAPI = Exclude<DocumentFieldAPI, DocumentListFieldAPI>;
 export type DocumentListFieldPropsAPI = {
-    items: DocumentFieldAPI[];
+    items: DocumentListFieldItemsAPI[];
 };
 
 // image

package/src/content-store-utils.ts

@@ -1,9 +1,8 @@
 import _ from 'lodash';
 import { Model } from '@stackbit/sdk';
 import { append } from '@stackbit/utils';
-import { Field, FieldList, FieldListItems, FieldListProps, FieldObjectProps, FieldSpecificProps } from '@stackbit/types';
+import { Field, FieldList, FieldListItems, FieldListProps, FieldObjectProps, FieldSpecificProps, SiteMapEntry } from '@stackbit/types';
 import * as CSITypes from '@stackbit/types';
-
 import * as ContentStoreTypes from './content-store-types';
 
 export function getContentSourceIdForContentSource(contentSource: CSITypes.ContentSourceInterface): string {
@@ -159,7 +158,11 @@ export function groupModelsByContentSource({ models }: { models: CSITypes.ModelW
     return modelMapByContentSource;
 }
 
-export function groupDocumentsByContentSource({ documents }: { documents: CSITypes.DocumentWithSource[] }): Record<string, Record<string, CSITypes.Document[]>> {
+export function groupDocumentsByContentSource({
+    documents
+}: {
+    documents: CSITypes.DocumentWithSource[];
+}): Record<string, Record<string, CSITypes.Document[]>> {
     const documentMapByContentSource: Record<string, Record<string, CSITypes.Document[]>> = {};
     for (const document of documents) {
         const { srcType, srcProjectId, ...rest } = document;
@@ -167,3 +170,58 @@ export function groupDocumentsByContentSource({ documents }: { documents: CSITyp
     }
     return documentMapByContentSource;
 }
+
+export function getCSIDocumentsAndAssetsFromContentSourceDataByIds(
+    contentSourceData: ContentStoreTypes.ContentSourceData,
+    objects: { srcObjectId: string }[]
+): {
+    documents: CSITypes.Document[];
+    assets: CSITypes.Asset[];
+} {
+    const documents: CSITypes.Document[] = [];
+    const assets: CSITypes.Asset[] = [];
+    for (const object of objects) {
+        if (object.srcObjectId in contentSourceData.csiDocumentMap) {
+            documents.push(contentSourceData.csiDocumentMap[object.srcObjectId]!);
+        } else if (object.srcObjectId in contentSourceData.csiAssetMap) {
+            assets.push(contentSourceData.csiAssetMap[object.srcObjectId]!);
+        }
+    }
+    return {
+        documents,
+        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,21 +3,20 @@ import path from 'path';
 import sanitizeFilename from 'sanitize-filename';
 
 import * as CSITypes from '@stackbit/types';
-import { getLocalizedFieldForLocale, ModelExtension, UserCommandSpawner } from '@stackbit/types';
+import { DocumentWithSource, getLocalizedFieldForLocale, ModelExtension, ModelWithSource, UserCommandSpawner } from '@stackbit/types';
 import {
     Config,
-    Field,
-    Model,
+    extendModelsWithPresetsIds,
+    getPresetDirs,
+    getYamlModelDirs,
     ImageModel,
-    Preset,
-    PresetMap,
     loadPresets,
-    getYamlModelDirs,
-    getPresetDirs,
     loadYamlModelsFromFiles,
+    mergeConfigModelsWithExternalModels,
     mergeConfigModelsWithModelsFromFiles,
-    extendModelsWithPresetsIds,
-    mergeConfigModelsWithExternalModels
+    Model,
+    Preset,
+    PresetMap
 } from '@stackbit/sdk';
 import { deferWhileRunning, mapPromise, reducePromise } from '@stackbit/utils';
 
@@ -26,13 +25,16 @@ 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,
-    groupModelsByContentSource,
-    groupDocumentsByContentSource
+    groupDocumentsByContentSource,
+    groupModelsByContentSource
 } from './content-store-utils';
 import { mapAssetsToLocalizedApiImages, mapDocumentsToLocalizedApiObjects, mapStoreAssetsToAPIAssets } from './utils/store-to-api-docs-converter';
 import { convertOperationField, createDocumentRecursively, getCreateDocumentThunk } from './utils/create-update-csi-docs';
@@ -54,39 +56,7 @@ export interface ContentSourceOptions {
     devAppRestartNeeded?: () => void;
 }
 
-interface ContentSourceData {
-    id: string;
-    instance: CSITypes.ContentSourceInterface;
-    srcType: string;
-    srcProjectId: string;
-    locales?: CSITypes.Locale[];
-    defaultLocaleCode?: string;
-    /* Array of extended and validated Models */
-    models: Model[];
-    /* Map of extended and validated Models by model name */
-    modelMap: Record<string, Model>;
-    /* Array of original Models (as provided by content source)  */
-    csiModels: CSITypes.Model[];
-    /* Map of original Models (as provided by content source) by model name */
-    csiModelMap: Record<string, CSITypes.Model>;
-    /* Array of original content source Documents */
-    csiDocuments: CSITypes.Document[];
-    /* Map of original content source Documents by document ID */
-    csiDocumentMap: Record<string, CSITypes.Document>;
-    /* Array of converted content-store Documents */
-    documents: ContentStoreTypes.Document[];
-    /* Map of converted content-store Documents by document ID */
-    documentMap: Record<string, ContentStoreTypes.Document>;
-    /* Array of original content source Assets */
-    csiAssets: CSITypes.Asset[];
-    /* Map of original content source Assets by asset ID */
-    csiAssetMap: Record<string, CSITypes.Asset>;
-    /* Array of converted content-store Assets */
-    assets: ContentStoreTypes.Asset[];
-    /* Map of converted content-store Assets by asset ID */
-    assetMap: Record<string, ContentStoreTypes.Asset>;
-}
-
+type ContentSourceData = ContentStoreTypes.ContentSourceData;
 type ContentSourceRawData = Omit<ContentSourceData, 'models' | 'modelMap' | 'documents' | 'documentMap'>;
 
 export class ContentStore {
@@ -687,7 +657,9 @@ export class ContentStore {
                 message += `, 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}`);
+            this.userLogger.warn(
+                `model ${message} defined in stackbit config matches more that 1 model in the following content sources: ${matchesModelsMessage}`
+            );
         }
 
         const modelsWithSource = contentSourceRawDataArr.reduce((accum: CSITypes.ModelWithSource[], csData) => {
@@ -905,6 +877,68 @@ 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))
+                };
+            },
+            { 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);
+    }
+
     getDocument({
         srcDocumentId,
         srcProjectId,
@@ -925,7 +959,7 @@ export class ContentStore {
             (documents: ContentStoreTypes.Document[], contentSourceData) => {
                 const currentDocuments = _.isEmpty(locale)
                     ? contentSourceData.documents
-                    : contentSourceData.documents.filter(document => !document.locale || document.locale === locale)
+                    : contentSourceData.documents.filter((document) => !document.locale || document.locale === locale);
                 return documents.concat(currentDocuments);
             },
             []
@@ -944,7 +978,7 @@ export class ContentStore {
             (assets: ContentStoreTypes.Asset[], contentSourceData) => {
                 const currentAssets = _.isEmpty(locale)
                     ? contentSourceData.assets
-                    : contentSourceData.assets.filter(asset => !asset.locale || asset.locale === locale)
+                    : contentSourceData.assets.filter((asset) => !asset.locale || asset.locale === locale);
                 return assets.concat(currentAssets);
             },
             []
@@ -957,10 +991,10 @@ export class ContentStore {
             this.contentSourceDataById,
             (objects: ContentStoreTypes.APIObject[], contentSourceData) => {
                 const documents = hasExplicitLocale
-                    ? contentSourceData.documents.filter(document => !document.locale || document.locale === locale)
+                    ? contentSourceData.documents.filter((document) => !document.locale || document.locale === locale)
                     : contentSourceData.documents;
                 const assets = hasExplicitLocale
-                    ? contentSourceData.assets.filter(asset => !asset.locale || asset.locale === locale)
+                    ? contentSourceData.assets.filter((asset) => !asset.locale || asset.locale === locale)
                     : contentSourceData.assets;
                 const currentLocale = locale ?? contentSourceData.defaultLocaleCode;
                 const documentObjects = mapDocumentsToLocalizedApiObjects(documents, currentLocale);
@@ -1568,12 +1602,12 @@ export class ContentStore {
 
         contentSourceIds.forEach((contentSourceId) => {
             const contentSourceData = this.getContentSourceDataByIdOrThrow(contentSourceId);
-            
+
             _.set(schema, [contentSourceData.srcType, contentSourceData.srcProjectId], contentSourceData.modelMap);
 
             const contentSourceDocuments = _.isEmpty(locale)
-                    ? contentSourceData.documents
-                    : contentSourceData.documents.filter(document => !document.locale || document.locale === locale)
+                ? contentSourceData.documents
+                : contentSourceData.documents.filter((document) => !document.locale || document.locale === locale);
             documents.push(...contentSourceDocuments);
 
             if (contentSourceData.defaultLocaleCode) {
@@ -1624,28 +1658,6 @@ export class ContentStore {
     }
 }
 
-function getCSIDocumentsAndAssetsFromContentSourceDataByIds(
-    contentSourceData: ContentSourceData,
-    objects: { srcObjectId: string }[]
-): {
-    documents: CSITypes.Document[];
-    assets: CSITypes.Asset[];
-} {
-    const documents: CSITypes.Document[] = [];
-    const assets: CSITypes.Asset[] = [];
-    for (const object of objects) {
-        if (object.srcObjectId in contentSourceData.csiDocumentMap) {
-            documents.push(contentSourceData.csiDocumentMap[object.srcObjectId]!);
-        } else if (object.srcObjectId in contentSourceData.csiAssetMap) {
-            assets.push(contentSourceData.csiAssetMap[object.srcObjectId]!);
-        }
-    }
-    return {
-        documents,
-        assets
-    };
-}
-
 function internalValidateContent(
     documents: CSITypes.Document[],
     assets: CSITypes.Asset[],

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

@@ -1,6 +1,6 @@
 import _ from 'lodash';
-import { Field, FieldListProps, FieldModelProps, FieldObjectProps, FieldSpecificProps, Model, ImageModel } from '@stackbit/sdk';
-import { isLocalizedField } from '@stackbit/types';
+import { Model, ImageModel } from '@stackbit/sdk';
+import { Field, FieldSpecificProps, FieldList, FieldModelProps, FieldObjectProps, isLocalizedField } from '@stackbit/types';
 import * as CSITypes from '@stackbit/types';
 
 import * as ContentStoreTypes from '../content-store-types';
@@ -163,6 +163,7 @@ function mapCSIFieldsToStoreFields({
         const docField = mapCSIFieldToStoreField({
             csiDocumentField,
             modelField,
+            localized: modelField.localized,
             context
         });
         // Override document field types with specific model field types.
@@ -172,9 +173,6 @@ function mapCSIFieldsToStoreFields({
             docField.type = modelField.type;
         }
         docField.label = modelField.label;
-        if ('localized' in modelField) {
-            docField.localized = modelField.localized;
-        }
         result[modelField.name] = docField;
         return result;
     }, {});
@@ -183,18 +181,24 @@ function mapCSIFieldsToStoreFields({
 function mapCSIFieldToStoreField({
     csiDocumentField,
     modelField,
+    localized,
     context
 }: {
     csiDocumentField: CSITypes.DocumentField | undefined;
-    modelField: FieldSpecificProps;
+    modelField: Field | FieldSpecificProps;
+    localized?: boolean;
     context: MapContext;
 }): ContentStoreTypes.DocumentField {
     if (!csiDocumentField) {
         const isUnset = ['object', 'model', 'reference', 'richText', 'markdown', 'image', 'file', 'json'].includes(modelField.type);
         return {
             type: modelField.type,
-            ...(isUnset ? { isUnset } : null),
-            ...(modelField.type === 'list' ? { items: [] } : null)
+            ...(localized
+                ? { localized, locales: {} }
+                : {
+                      ...(isUnset ? { isUnset } : null),
+                      ...(modelField.type === 'list' ? { items: [] } : null)
+                  })
         } as ContentStoreTypes.DocumentField;
     }
     // TODO: check if need to add "options" to "enum" and subtype/min/max to "number"
@@ -204,7 +208,8 @@ function mapCSIFieldToStoreField({
         case 'model':
             return mapModelField(csiDocumentField as CSITypes.DocumentModelField, modelField, context);
         case 'list':
-            return mapListField(csiDocumentField as CSITypes.DocumentListField, modelField, context);
+            // list can not be in list, so modelField must be FieldList
+            return mapListField(csiDocumentField as CSITypes.DocumentListField, modelField as FieldList, context);
         case 'richText':
             return mapRichTextField(csiDocumentField as CSITypes.DocumentRichTextField);
         case 'markdown':
@@ -282,7 +287,7 @@ function mapModelField(csiDocumentField: CSITypes.DocumentModelField, modelField
     };
 }
 
-function mapListField(csiDocumentField: CSITypes.DocumentListField, modelField: FieldListProps, context: MapContext): ContentStoreTypes.DocumentListField {
+function mapListField(csiDocumentField: CSITypes.DocumentListField, modelField: FieldList, context: MapContext): ContentStoreTypes.DocumentListField {
     if (!isLocalizedField(csiDocumentField)) {
         return {
             type: csiDocumentField.type,
@@ -290,8 +295,10 @@ function mapListField(csiDocumentField: CSITypes.DocumentListField, modelField:
                 mapCSIFieldToStoreField({
                     csiDocumentField: item,
                     modelField: modelField.items ?? { type: 'string' },
+                    // list items can not be localized, only the list itself can be localized
+                    localized: false,
                     context
-                })
+                }) as ContentStoreTypes.DocumentListFieldItems
             )
         };
     }
@@ -305,8 +312,10 @@ function mapListField(csiDocumentField: CSITypes.DocumentListField, modelField:
                     mapCSIFieldToStoreField({
                         csiDocumentField: item,
                         modelField: modelField.items ?? { type: 'string' },
+                        // list items can not be localized, only the list itself can be localized
+                        localized: false,
                         context
-                    })
+                    }) as ContentStoreTypes.DocumentListFieldItems
                 )
             };
         })

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

@@ -149,7 +149,7 @@ function toLocalizedAPIField(docField: ContentStoreTypes.DocumentField, locale?:
                 const { type, refType, localized, locales, ...base } = docField;
                 const localeProps = locales && locale ? locales[locale] : undefined;
                 // if reference field isUnset === true, it behaves like a regular object
-                if (!localeProps || localeProps.isUnset) {
+                if (!localeProps) {
                     return {
                         type: 'object',
                         isUnset: true,
@@ -186,14 +186,14 @@ function toLocalizedAPIField(docField: ContentStoreTypes.DocumentField, locale?:
                 return {
                     ...base,
                     ...localeProps,
-                    items: (localeProps?.items ?? []).map((field) => toLocalizedAPIField(field, locale, true)),
+                    items: (localeProps?.items ?? []).map((field) => toLocalizedAPIField(field, locale, true) as ContentStoreTypes.DocumentListFieldItemsAPI),
                     ...localeFields(localized)
                 };
             }
             return {
                 ...docField,
                 ...localeFields(docField.localized),
-                items: docField.items.map((field) => toLocalizedAPIField(field, locale, true))
+                items: docField.items.map((field) => toLocalizedAPIField(field, locale, true) as ContentStoreTypes.DocumentListFieldItemsAPI)
             };
         default:
             const _exhaustiveCheck: never = docField;