@stackbit/cms-core 0.1.12-locale.0 → 0.1.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stackbit/cms-core",
-  "version": "0.1.12-locale.0",
+  "version": "0.1.12",
   "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.8-locale.0",
-    "@stackbit/types": "^0.1.6-locale.0",
-    "@stackbit/utils": "^0.2.11",
+    "@stackbit/sdk": "^0.3.8",
+    "@stackbit/types": "^0.1.6",
+    "@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": "5ae211b3a7770c097d36efe3b860ed4d4d8a3c25"
+  "gitHead": "6704c5d8fe0e139797c6e29555cc1e71e611d281"
 }

package/src/content-store-types.ts

@@ -188,7 +188,7 @@ export type DocumentFieldTypeAPI<BaseFieldProps, LocalizedFieldProps> = BaseFiel
         description?: string;
         locale?: string;
         localized?: boolean;
-    };
+    } & ({ 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'>;

package/src/content-store-utils.ts

@@ -27,7 +27,7 @@ export function getDocumentFieldForLocale<Type extends ContentStoreTypes.FieldTy
             return null;
         }
         const { localized, locales, ...base } = docField;
-        const localizedField = locales[locale];
+        const localizedField = locales?.[locale];
         if (!localizedField) {
             return null;
         }

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(
@@ -712,7 +789,7 @@ export class ContentStore {
         if (!this.presets || !locale) {
             return this.presets ?? {};
         }
-        return _.pickBy(this.presets, preset => !preset.locale || preset.locale === locale);
+        return _.pickBy(this.presets, (preset) => !preset.locale || preset.locale === locale);
     }
 
     getContentSourceEnvironment({ srcProjectId, srcType }: { srcProjectId: string; srcType: string }): string {
@@ -842,18 +919,13 @@ export class ContentStore {
         return contentSourceData.documentMap[srcDocumentId];
     }
 
-    getDocuments({ contentSourceIds, locale }: { contentSourceIds?: string[], locale?: string }): ContentStoreTypes.Document[] {
-        const hasExplicitLocale = !_.isEmpty(locale);
+    getDocuments({ locale }: { locale?: string }): ContentStoreTypes.Document[] {
         return _.reduce(
             this.contentSourceDataById,
             (documents: ContentStoreTypes.Document[], contentSourceData) => {
-                if (contentSourceIds && !contentSourceIds.includes(contentSourceData.id)) {
-                    return documents;
-                }
-                const currentLocale = locale ?? contentSourceData.defaultLocaleCode;
-                const currentDocuments = hasExplicitLocale
-                    ? contentSourceData.documents.filter(document => !document.locale || document.locale === currentLocale)
-                    : contentSourceData.documents;
+                const currentDocuments = _.isEmpty(locale)
+                    ? contentSourceData.documents
+                    : contentSourceData.documents.filter(document => !document.locale || document.locale === locale)
                 return documents.concat(currentDocuments);
             },
             []
@@ -867,14 +939,12 @@ export class ContentStore {
     }
 
     getAssets({ locale }: { locale?: string }): ContentStoreTypes.Asset[] {
-        const hasExplicitLocale = !_.isEmpty(locale);
         return _.reduce(
             this.contentSourceDataById,
             (assets: ContentStoreTypes.Asset[], contentSourceData) => {
-                const currentLocale = locale ?? contentSourceData.defaultLocaleCode;
-                const currentAssets = hasExplicitLocale
-                    ? contentSourceData.assets.filter(asset => !asset.locale || asset.locale === currentLocale)
-                    : contentSourceData.assets;
+                const currentAssets = _.isEmpty(locale)
+                    ? contentSourceData.assets
+                    : contentSourceData.assets.filter(asset => !asset.locale || asset.locale === locale)
                 return assets.concat(currentAssets);
             },
             []
@@ -886,13 +956,13 @@ export class ContentStore {
         return _.reduce(
             this.contentSourceDataById,
             (objects: ContentStoreTypes.APIObject[], contentSourceData) => {
-                const currentLocale = locale ?? contentSourceData.defaultLocaleCode;
                 const documents = hasExplicitLocale
-                    ? contentSourceData.documents.filter(document => !document.locale || document.locale === currentLocale)
+                    ? contentSourceData.documents.filter(document => !document.locale || document.locale === locale)
                     : contentSourceData.documents;
                 const assets = hasExplicitLocale
-                    ? contentSourceData.assets.filter(asset => !asset.locale || asset.locale === currentLocale)
+                    ? 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);
@@ -1441,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,
@@ -1489,17 +1559,25 @@ export class ContentStore {
         items: ContentStoreTypes.Document[];
     }> {
         this.logger.debug('searchDocuments');
-        let locale = data.locale;
+        const locale = data.locale;
         const objectsBySourceId = _.groupBy(data.models, (object) => getContentSourceId(object.srcType, object.srcProjectId));
         const contentSourceIds = Object.keys(objectsBySourceId);
-        const documents: ContentStoreTypes.Document[] = this.getDocuments({ contentSourceIds, locale });
+        const documents: ContentStoreTypes.Document[] = [];
         const schema: Record<string, Record<string, Record<string, Model>>> = {};
+        const defaultLocales: Record<string, string> = {};
 
         contentSourceIds.forEach((contentSourceId) => {
             const contentSourceData = this.getContentSourceDataByIdOrThrow(contentSourceId);
+            
             _.set(schema, [contentSourceData.srcType, contentSourceData.srcProjectId], contentSourceData.modelMap);
-            if (!locale && contentSourceData.defaultLocaleCode) {
-                locale = contentSourceData.defaultLocaleCode;
+
+            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;
             }
         });
 
@@ -1507,7 +1585,8 @@ export class ContentStore {
             ...data,
             documents,
             schema,
-            locale
+            locale,
+            defaultLocales
         });
     }
 
@@ -1570,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;
@@ -1586,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];
@@ -1614,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

@@ -165,8 +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;
-        docField.localized = modelField.localized;
+        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) {

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

@@ -22,16 +22,19 @@ function toLocalizedAPIFields(docFields: Record<string, ContentStoreTypes.Docume
 
 function toLocalizedAPIField(docField: ContentStoreTypes.DocumentField, locale?: string, isListItem = false): ContentStoreTypes.DocumentFieldAPI {
     type ToBoolean<T extends boolean | undefined> = T extends true ? true : false;
-    function localeFields<T extends boolean | undefined>(localized: T): null | { localized: ToBoolean<T>; locale?: string } {
+    function localeFields<T extends boolean | undefined>(localized: T): null | { localized: false } | { localized: true; locale: string } {
         const isLocalized = !!localized as ToBoolean<T>;
         if (isListItem) {
             return null;
         }
         if (!isLocalized) {
             return {
-                localized: isLocalized
+                localized: false
             };
         }
+        if (!locale) {
+            return null;
+        }
         return {
             localized: isLocalized,
             locale: locale
@@ -239,20 +242,23 @@ function localizeAssetFields(assetFields: ContentStoreTypes.AssetFields, locale?
 }
 
 export function mapStoreAssetsToAPIAssets(assets: ContentStoreTypes.Asset[], locale?: string): ContentStoreTypes.APIAsset[] {
-    return assets.map((asset) => storeAssetToAPIAsset(asset, locale));
+    return assets.map((asset) => storeAssetToAPIAsset(asset, locale)).filter((asset): asset is ContentStoreTypes.APIAsset => !!asset);
 }
 
-function storeAssetToAPIAsset(asset: ContentStoreTypes.Asset, locale?: string): ContentStoreTypes.APIAsset {
+function storeAssetToAPIAsset(asset: ContentStoreTypes.Asset, locale?: string): ContentStoreTypes.APIAsset | null {
     const assetTitleField = asset.fields.title;
-    const localizedTitleField = assetTitleField.localized ? assetTitleField.locales?.[locale!]! : assetTitleField;
+    const localizedTitleField = assetTitleField.localized ? assetTitleField.locales?.[locale!] : assetTitleField;
     const assetFileField = asset.fields.file;
-    const localizedFileField = assetFileField.localized ? assetFileField.locales?.[locale!]! : assetFileField;
+    const localizedFileField = assetFileField.localized ? assetFileField.locales?.[locale!] : assetFileField;
+    if (!localizedFileField) {
+        return null;
+    }
     return {
         objectId: asset.srcObjectId,
         createdAt: asset.createdAt,
         url: localizedFileField.url,
         ...omitByNil({
-            title: localizedTitleField.value,
+            title: localizedTitleField?.value ?? null,
             fileName: localizedFileField.fileName,
             contentType: localizedFileField.contentType,
             size: localizedFileField.size,