@stackbit/cms-core 0.1.11 → 0.1.12-locale.1

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 { getLocalizedFieldForLocale, UserCommandSpawner } from '@stackbit/types';
+import { getLocalizedFieldForLocale, ModelExtension, UserCommandSpawner } from '@stackbit/types';
 import {
     Config,
     Field,
@@ -105,6 +105,7 @@ export class ContentStore {
     private stackbitConfig: Config | null = null;
     private yamlModels: Model[] = [];
     private configModels: Model[] = [];
+    private modelExtensions: ModelExtension[] | null = null;
     private presets: PresetMap = {};
 
     constructor(options: ContentSourceOptions) {
@@ -152,22 +153,36 @@ export class ContentStore {
 
     async init({ stackbitConfig }: { stackbitConfig: Config | null }): Promise<void> {
         this.logger.debug('init');
+
+        this.stackbitConfig = stackbitConfig;
+
         if (stackbitConfig) {
-            this.yamlModels = await this.loadYamlModels({ stackbitConfig });
+            if (stackbitConfig.modelExtensions) {
+                this.modelExtensions = stackbitConfig.modelExtensions;
+            } else {
+                this.yamlModels = await this.loadYamlModels({ stackbitConfig });
+                this.configModels = this.mergeConfigModels(stackbitConfig.models ?? [], this.yamlModels);
+            }
             this.presets = await this.loadPresets({ stackbitConfig });
         }
-        await this.setStackbitConfig({ stackbitConfig });
+
+        await this.loadContentSourcesAndProcessData({ init: true });
+
         this.contentUpdatesWatchTimer.startTimer();
     }
 
     async onStackbitConfigChange({ stackbitConfig }: { stackbitConfig: Config | null }) {
         this.logger.debug('onStackbitConfigChange');
-        await this.setStackbitConfig({ stackbitConfig });
-    }
 
-    private async setStackbitConfig({ stackbitConfig }: { stackbitConfig: Config | null }) {
         this.stackbitConfig = stackbitConfig;
-        this.configModels = this.mergeConfigModels(this.stackbitConfig, this.yamlModels);
+
+        if (stackbitConfig) {
+            if (stackbitConfig.modelExtensions) {
+                this.modelExtensions = stackbitConfig.modelExtensions;
+            } else {
+                this.configModels = this.mergeConfigModels(stackbitConfig.models ?? [], this.yamlModels);
+            }
+        }
 
         await this.loadContentSourcesAndProcessData({ init: true });
     }
@@ -202,12 +217,16 @@ export class ContentStore {
         this.contentUpdatesWatchTimer.startTimer();
     }
 
+    stop() {
+        this.contentUpdatesWatchTimer.stopTimer();
+    }
+
     async onFilesChange(updatedFiles: string[]): Promise<{ schemaChanged?: boolean; contentChanges: ContentStoreTypes.ContentChangeResult }> {
         this.logger.debug('onFilesChange');
 
         let schemaChanged = false;
 
-        if (this.stackbitConfig) {
+        if (this.stackbitConfig && !this.stackbitConfig.modelExtensions) {
             // Check if any of the yaml models files were changed. If yaml model files were changed,
             // reload them and merge them with models defined in stackbit config.
             const modelDirs = getYamlModelDirs(this.stackbitConfig);
@@ -216,7 +235,7 @@ export class ContentStore {
                 this.logger.debug('identified change in stackbit model files');
                 schemaChanged = true;
                 this.yamlModels = await this.loadYamlModels({ stackbitConfig: this.stackbitConfig });
-                this.configModels = this.mergeConfigModels(this.stackbitConfig, this.yamlModels);
+                this.configModels = this.mergeConfigModels(this.stackbitConfig.models ?? [], this.yamlModels);
             }
 
             // Check if any of the preset files were changed. If presets were changed, reload them.
@@ -287,8 +306,8 @@ export class ContentStore {
         return yamlModelsResult.models;
     }
 
-    private mergeConfigModels(stackbitConfig: Config | null, modelsFromFiles: Model[]) {
-        const configModelsResult = mergeConfigModelsWithModelsFromFiles(stackbitConfig?.models ?? [], modelsFromFiles);
+    private mergeConfigModels(configModels: Model[], modelsFromFiles: Model[]) {
+        const configModelsResult = mergeConfigModelsWithModelsFromFiles(configModels, modelsFromFiles);
         for (const error of configModelsResult.errors) {
             this.userLogger.warn(error.message);
         }
@@ -352,7 +371,7 @@ export class ContentStore {
         // update all content sources at once to prevent race conditions
         this.contentSourceDataById = await this.processData({
             stackbitConfig: this.stackbitConfig,
-            configModels: this.configModels,
+            configModels: (this.modelExtensions as Model[]) ?? this.configModels ?? [],
             presets: this.presets,
             contentSourceRawDataArr: contentSourceRawDataArr
         });
@@ -613,9 +632,67 @@ export class ContentStore {
         presets: Record<string, Preset>;
         contentSourceRawDataArr: ContentSourceRawData[];
     }): Promise<Record<string, ContentSourceData>> {
+        // Group models from all content sources by their names
+
+        const csiModelGroups = contentSourceRawDataArr.reduce((modelGroups: Record<string, CSITypes.ModelWithSource[]>, csData) => {
+            return csData.csiModels.reduce((modelGroups, model) => {
+                if (!(model.name in modelGroups)) {
+                    modelGroups[model.name] = [];
+                }
+                modelGroups[model.name]!.push({
+                    srcType: csData.srcType,
+                    srcProjectId: csData.srcProjectId,
+                    ...model
+                });
+                return modelGroups;
+            }, modelGroups);
+        }, {});
+
+        // Match config models to the group of content source models with the same name.
+        // Then, match the config model to content source model by comparing srcType and
+        // 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 csiModels = csiModelGroups[configModel.name];
+            if (!csiModels) {
+                return false;
+            }
+            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;
+            }
+            modelMatchErrors.push({
+                configModel,
+                matchedCSIModels
+            });
+            return false;
+        }) as Model[];
+
+        // Log model matching warnings using user logger
+        for (const { configModel, matchedCSIModels } of modelMatchErrors) {
+            let message = `name: '${configModel.name}'`;
+            if (configModel.srcType) {
+                message += `, srcType: '${configModel.srcType}'`;
+            }
+            if (configModel.srcProjectId) {
+                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}`);
+        }
+
         const modelsWithSource = contentSourceRawDataArr.reduce((accum: CSITypes.ModelWithSource[], csData) => {
             const mergedModels = mergeConfigModelsWithExternalModels({
-                configModels: configModels,
+                configModels: filteredConfigModels,
                 externalModels: csData.csiModels
             });
             const modelsWithSource = mergedModels.map(
@@ -708,8 +785,11 @@ export class ContentStore {
         );
     }
 
-    getPresets(): Record<string, any> {
-        return this.presets ?? {};
+    getPresets({ locale }: { locale?: string } = {}): Record<string, any> {
+        if (!this.presets || !locale) {
+            return this.presets ?? {};
+        }
+        return _.pickBy(this.presets, (preset) => !preset.locale || preset.locale === locale);
     }
 
     getContentSourceEnvironment({ srcProjectId, srcType }: { srcProjectId: string; srcType: string }): string {
@@ -839,11 +919,14 @@ export class ContentStore {
         return contentSourceData.documentMap[srcDocumentId];
     }
 
-    getDocuments(): ContentStoreTypes.Document[] {
+    getDocuments({ locale }: { locale?: string }): ContentStoreTypes.Document[] {
         return _.reduce(
             this.contentSourceDataById,
             (documents: ContentStoreTypes.Document[], contentSourceData) => {
-                return documents.concat(contentSourceData.documents);
+                const currentDocuments = _.isEmpty(locale)
+                    ? contentSourceData.documents
+                    : contentSourceData.documents.filter(document => !document.locale || document.locale === locale)
+                return documents.concat(currentDocuments);
             },
             []
         );
@@ -855,23 +938,33 @@ export class ContentStore {
         return contentSourceData.assetMap[srcAssetId];
     }
 
-    getAssets(): ContentStoreTypes.Asset[] {
+    getAssets({ locale }: { locale?: string }): ContentStoreTypes.Asset[] {
         return _.reduce(
             this.contentSourceDataById,
             (assets: ContentStoreTypes.Asset[], contentSourceData) => {
-                return assets.concat(contentSourceData.assets);
+                const currentAssets = _.isEmpty(locale)
+                    ? contentSourceData.assets
+                    : contentSourceData.assets.filter(asset => !asset.locale || asset.locale === locale)
+                return assets.concat(currentAssets);
             },
             []
         );
     }
 
     getLocalizedApiObjects({ locale }: { locale?: string }): ContentStoreTypes.APIObject[] {
+        const hasExplicitLocale = !_.isEmpty(locale);
         return _.reduce(
             this.contentSourceDataById,
             (objects: ContentStoreTypes.APIObject[], contentSourceData) => {
-                locale = locale ?? contentSourceData.defaultLocaleCode;
-                const documentObjects = mapDocumentsToLocalizedApiObjects(contentSourceData.documents, locale);
-                const imageObjects = mapAssetsToLocalizedApiImages(contentSourceData.assets, locale);
+                const documents = hasExplicitLocale
+                    ? 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;
+                const currentLocale = locale ?? contentSourceData.defaultLocaleCode;
+                const documentObjects = mapDocumentsToLocalizedApiObjects(documents, currentLocale);
+                const imageObjects = mapAssetsToLocalizedApiImages(assets, currentLocale);
                 return objects.concat(documentObjects, imageObjects);
             },
             []
@@ -1418,7 +1511,7 @@ export class ContentStore {
             locale = locale ?? contentSourceData.defaultLocaleCode;
             const { documents, assets } = getCSIDocumentsAndAssetsFromContentSourceDataByIds(contentSourceData, contentSourceObjects);
             const userContext = getUserContextForSrcType(contentSourceData.srcType, user);
-            const internalValidationErrors = internalValidateContent(documents, assets, contentSourceData);
+            const internalValidationErrors = internalValidateContent(documents, assets, contentSourceData, locale);
             const validationResult = await contentSourceData.instance.validateDocuments({ documents, assets, locale, userContext });
             errors = errors.concat(
                 internalValidationErrors,
@@ -1466,22 +1559,34 @@ export class ContentStore {
         items: ContentStoreTypes.Document[];
     }> {
         this.logger.debug('searchDocuments');
-
+        const locale = data.locale;
         const objectsBySourceId = _.groupBy(data.models, (object) => getContentSourceId(object.srcType, object.srcProjectId));
+        const contentSourceIds = Object.keys(objectsBySourceId);
         const documents: ContentStoreTypes.Document[] = [];
         const schema: Record<string, Record<string, Record<string, Model>>> = {};
+        const defaultLocales: Record<string, string> = {};
 
-        Object.keys(objectsBySourceId).forEach((contentSourceId) => {
+        contentSourceIds.forEach((contentSourceId) => {
             const contentSourceData = this.getContentSourceDataByIdOrThrow(contentSourceId);
-
-            documents.push(...contentSourceData.documents);
+            
             _.set(schema, [contentSourceData.srcType, contentSourceData.srcProjectId], contentSourceData.modelMap);
+
+            const contentSourceDocuments = _.isEmpty(locale)
+                    ? contentSourceData.documents
+                    : contentSourceData.documents.filter(document => !document.locale || document.locale === locale)
+            documents.push(...contentSourceDocuments);
+
+            if (contentSourceData.defaultLocaleCode) {
+                defaultLocales[contentSourceId] = contentSourceData.defaultLocaleCode;
+            }
         });
 
         return searchDocuments({
             ...data,
             documents,
-            schema
+            schema,
+            locale,
+            defaultLocales
         });
     }
 
@@ -1544,13 +1649,16 @@ function getCSIDocumentsAndAssetsFromContentSourceDataByIds(
 function internalValidateContent(
     documents: CSITypes.Document[],
     assets: CSITypes.Asset[],
-    contentSourceData: ContentSourceData
+    contentSourceData: ContentSourceData,
+    locale?: string
 ): ContentStoreTypes.ValidationError[] {
     const errors: ContentStoreTypes.ValidationError[] = [];
     _.forEach(documents, (document) => {
         _.forEach(document.fields, (documentField, fieldName) => {
-            const localizedField = getLocalizedFieldForLocale(documentField)!;
-            errors.push(...validateDocumentFields(document, localizedField, [fieldName], contentSourceData));
+            const localizedField = getLocalizedFieldForLocale(documentField, locale);
+            if (localizedField) {
+                errors.push(...validateDocumentFields(document, localizedField, [fieldName], contentSourceData, locale));
+            }
         });
     });
     return errors;
@@ -1560,19 +1668,24 @@ function validateDocumentFields(
     document: CSITypes.Document,
     documentField: CSITypes.DocumentFieldNonLocalized,
     fieldPath: (string | number)[],
-    contentSourceData: ContentSourceData
+    contentSourceData: ContentSourceData,
+    locale?: string
 ): ContentStoreTypes.ValidationError[] {
     const errors: ContentStoreTypes.ValidationError[] = [];
 
     if (documentField.type === 'object') {
         _.forEach(documentField.fields, (documentField, fieldName) => {
-            const localizedField = getLocalizedFieldForLocale(documentField)!;
-            errors.push(...validateDocumentFields(document, localizedField, fieldPath.concat(fieldName), contentSourceData));
+            const localizedField = getLocalizedFieldForLocale(documentField, locale);
+            if (localizedField) {
+                errors.push(...validateDocumentFields(document, localizedField, fieldPath.concat(fieldName), contentSourceData, locale));
+            }
         });
     } else if (documentField.type === 'model') {
         _.forEach(documentField.fields, (documentField, fieldName) => {
-            const localizedField = getLocalizedFieldForLocale(documentField)!;
-            errors.push(...validateDocumentFields(document, localizedField, fieldPath.concat(fieldName), contentSourceData));
+            const localizedField = getLocalizedFieldForLocale(documentField, locale);
+            if (localizedField) {
+                errors.push(...validateDocumentFields(document, localizedField, fieldPath.concat(fieldName), contentSourceData, locale));
+            }
         });
     } else if (documentField.type === 'reference') {
         const objRef = documentField.refType === 'asset' ? contentSourceData.assetMap[documentField.refId] : contentSourceData.documentMap[documentField.refId];
@@ -1588,8 +1701,7 @@ function validateDocumentFields(
         }
     } else if (documentField.type === 'list') {
         _.forEach(documentField.items, (documentField, i) => {
-            const localizedField = getLocalizedFieldForLocale(documentField)!;
-            errors.push(...validateDocumentFields(document, documentField, fieldPath.concat(i), contentSourceData));
+            errors.push(...validateDocumentFields(document, documentField, fieldPath.concat(i), contentSourceData, locale));
         });
     }
 

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

@@ -48,6 +48,7 @@ function sourceAssetToStoreAsset({
         createdBy: csiAsset.createdBy,
         updatedAt: csiAsset.updatedAt,
         updatedBy: csiAsset.updatedBy,
+        locale: csiAsset.locale,
         fields: {
             title: {
                 label: 'Title',
@@ -131,6 +132,7 @@ function mapCSIDocumentToStoreDocument({
         createdBy: csiDocument.createdBy,
         updatedAt: csiDocument.updatedAt,
         updatedBy: csiDocument.updatedBy,
+        locale: csiDocument.locale,
         fields: mapCSIFieldsToStoreFields({
             csiDocumentFields: csiDocument.fields,
             modelFields: model.fields ?? [],
@@ -163,7 +165,16 @@ function mapCSIFieldsToStoreFields({
             modelField,
             context
         });
+        // Override document field types with specific model field types.
+        // For example when developer re-mapped content-source model "string"
+        // field to stackbit "color" field.
+        if (modelField.type === 'color' || modelField.type === 'style') {
+            docField.type = modelField.type;
+        }
         docField.label = modelField.label;
+        if ('localized' in modelField) {
+            docField.localized = modelField.localized;
+        }
         result[modelField.name] = docField;
         return result;
     }, {});

package/src/utils/duplicate-document.ts

@@ -14,7 +14,7 @@ export function mergeObjectWithDocument({
     duplicatableModels,
     nonDuplicatableModels
 }: {
-    object: Record<string, any> | undefined;
+    object: Record<string, unknown> | undefined;
     document: ContentStoreTypes.Document;
     locale?: string;
     documentMap: Record<string, ContentStoreTypes.Document>;
@@ -22,7 +22,7 @@ export function mergeObjectWithDocument({
     referenceBehavior?: 'copyReference' | 'duplicateContents';
     duplicatableModels?: string[];
     nonDuplicatableModels?: string[];
-}): Record<string, any> {
+}): Record<string, unknown> {
     return mergeObjectWithDocumentFields({
         object,
         documentFields: document.fields,
@@ -49,9 +49,9 @@ function mergeObjectWithDocumentFields({
     documentFields,
     ...context
 }: {
-    object: Record<string, any> | undefined;
+    object: Record<string, unknown> | undefined;
     documentFields: Record<string, ContentStoreTypes.DocumentField>;
-} & Context): Record<string, any> {
+} & Context): Record<string, unknown> {
     return _.reduce(
         documentFields,
         (object, documentField, fieldName) => {
@@ -74,9 +74,9 @@ function mergeObjectWithDocumentField({
     documentField,
     ...context
 }: {
-    value: any;
+    value: unknown;
     documentField: ContentStoreTypes.DocumentField;
-} & Context): any {
+} & Context): unknown {
     const locale = context.locale;
     switch (documentField.type) {
         case 'string':
@@ -108,7 +108,7 @@ function mergeObjectWithDocumentField({
         }
         case 'image': {
             const localizedField = getDocumentFieldForLocale(documentField, locale);
-            if (localizedField && !localizedField.isUnset) {
+            if (localizedField && !localizedField.isUnset && isPlainObjectOrUndefined(value)) {
                 return mergeObjectWithDocumentFields({
                     object: value,
                     documentFields: localizedField.fields,
@@ -119,7 +119,7 @@ function mergeObjectWithDocumentField({
         }
         case 'object': {
             const localizedField = getDocumentFieldForLocale(documentField, locale);
-            if (localizedField && !localizedField.isUnset) {
+            if (localizedField && !localizedField.isUnset && isPlainObjectOrUndefined(value)) {
                 return mergeObjectWithDocumentFields({
                     object: value,
                     documentFields: localizedField.fields,
@@ -130,7 +130,7 @@ function mergeObjectWithDocumentField({
         }
         case 'model': {
             const localizedField = getDocumentFieldForLocale(documentField, locale);
-            if (localizedField && !localizedField.isUnset) {
+            if (localizedField && !localizedField.isUnset && isPlainObjectOrUndefined(value)) {
                 if (value && value.$$type !== localizedField.srcModelName) {
                     // if the override object's $$type isn't equal to the type
                     // of the current object in the field, then use whatever
@@ -150,7 +150,7 @@ function mergeObjectWithDocumentField({
         }
         case 'reference': {
             const localizedField = getDocumentFieldForLocale(documentField, locale);
-            if (localizedField && !localizedField.isUnset) {
+            if (localizedField && !localizedField.isUnset && isPlainObjectOrUndefined(value)) {
                 if (value && value.$$ref) {
                     // if the override object has $$ref, use it
                     break;
@@ -230,6 +230,10 @@ function mergeObjectWithDocumentField({
     return value;
 }
 
+function isPlainObjectOrUndefined(value: unknown): value is Record<string, unknown> | undefined {
+    return typeof value === 'undefined' || _.isPlainObject(value);
+}
+
 function shouldDuplicate({
     referenceField,
     modelName,

package/src/utils/search-utils.ts

@@ -5,6 +5,7 @@ import { getLocalizedFieldForLocale } from '@stackbit/types';
 
 import { SearchFilter, SearchFilterItem } from '../types/search-filter';
 import { ContentStoreTypes } from '..';
+import { getContentSourceId } from '../content-store-utils';
 
 const META_FIELD = {
     createdAt: {
@@ -28,6 +29,7 @@ export const searchDocuments = (data: {
     documents: ContentStoreTypes.Document[];
     schema: Schema;
     locale?: string;
+    defaultLocales?: Record<string, string>
 }): {
     total: number;
     items: ContentStoreTypes.Document[];
@@ -39,6 +41,7 @@ export const searchDocuments = (data: {
     let allDocuments = 0;
 
     const matchedDocuments = documents.filter((document) => {
+        const contentSourceId = getContentSourceId(document.srcType, document.srcProjectId);
         const isIncludedModel = _.find(data.models, {
             srcType: document.srcType,
             srcProjectId: document.srcProjectId,
@@ -51,7 +54,7 @@ export const searchDocuments = (data: {
         allDocuments += 1;
 
         if (query) {
-            const matches = isDocumentMatchesPattern(document, query, data.locale);
+            const matches = isDocumentMatchesPattern(document, query, data.locale ?? data.defaultLocales?.[contentSourceId]);
             if (!matches) {
                 return false;
             }
@@ -61,7 +64,7 @@ export const searchDocuments = (data: {
             // only 'and' supported for now; later we can add e.g. 'or'
             const matches = data.filter.and.every((filter) => {
                 const field = getFieldForFilter(document, filter);
-                return isFieldMatchesFilter({ field, filter, document, schema, locale: data.locale });
+                return isFieldMatchesFilter({ field, filter, document, schema, locale: data.locale ?? data.defaultLocales?.[contentSourceId] });
             });
 
             if (!matches) {