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

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,20 +25,22 @@ 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';
 import { mergeObjectWithDocument } from './utils/duplicate-document';
 import { normalizeModels, validateModels } from './utils/model-utils';
 import { IMAGE_MODEL } from './common/common-schema';
-import { getPresetFromDocument } from './utils/preset-utils';
 
 export type HandleConfigAssets = <T extends Model>({ models, presets }: { models?: T[]; presets?: PresetMap }) => Promise<{ models: T[]; presets: PresetMap }>;
 
@@ -55,42 +56,8 @@ 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 ContentSourceRawData = Omit<ContentSourceData, 'models' | 'modelMap' | 'documents' | 'documentMap' | 'presetMap'>;
-
-const StackbitPresetModelName = 'stackbitPreset';
+type ContentSourceData = ContentStoreTypes.ContentSourceData;
+type ContentSourceRawData = Omit<ContentSourceData, 'models' | 'modelMap' | 'documents' | 'documentMap'>;
 
 export class ContentStore {
     private readonly logger: ContentStoreTypes.Logger;
@@ -104,7 +71,6 @@ export class ContentStore {
     private readonly devAppRestartNeeded?: () => void;
     private contentSources: CSITypes.ContentSourceInterface[] = [];
     private contentSourceDataById: Record<string, ContentSourceData> = {};
-    private presetsContentSource?: CSITypes.ContentSourceInterface;
     private contentUpdatesWatchTimer: Timer;
     private stackbitConfig: Config | null = null;
     private yamlModels: Model[] = [];
@@ -167,6 +133,7 @@ export class ContentStore {
                 this.yamlModels = await this.loadYamlModels({ stackbitConfig });
                 this.configModels = this.mergeConfigModels(stackbitConfig.models ?? [], this.yamlModels);
             }
+            this.presets = await this.loadPresets({ stackbitConfig });
         }
 
         await this.loadContentSourcesAndProcessData({ init: true });
@@ -244,10 +211,10 @@ export class ContentStore {
             // Check if any of the preset files were changed. If presets were changed, reload them.
             const presetDirs = getPresetDirs(this.stackbitConfig);
             const presetsChanged = updatedFiles.find((updatedFile) => _.some(presetDirs, (presetDir) => updatedFile.startsWith(presetDir)));
-            if (presetsChanged && !this.canManagePresets()) {
+            if (presetsChanged) {
                 this.logger.debug('identified change in stackbit preset files');
                 schemaChanged = true;
-                this.presets = await this.loadPresetsFromConfig({ stackbitConfig: this.stackbitConfig });
+                this.presets = await this.loadPresets({ stackbitConfig: this.stackbitConfig });
             }
         }
 
@@ -317,7 +284,7 @@ export class ContentStore {
         return configModelsResult.models;
     }
 
-    private async loadPresetsFromConfig({ stackbitConfig }: { stackbitConfig: Config }): Promise<PresetMap> {
+    private async loadPresets({ stackbitConfig }: { stackbitConfig: Config }): Promise<Record<string, Preset>> {
         const contentSources = stackbitConfig?.contentSources ?? [];
         const singleContentSource = contentSources.length === 1 ? contentSources[0] : null;
         const presetResult = await loadPresets({
@@ -336,19 +303,6 @@ export class ContentStore {
         return presets;
     }
 
-    private async loadPresetsFromContentSource(contentSourceData: ContentSourceRawData): Promise<PresetMap> {
-        const presets = _.reduce(contentSourceData.csiDocuments, (result: Record<string, Preset>, document) => {
-            if (document.modelName === StackbitPresetModelName) {
-                const preset = getPresetFromDocument(document, contentSourceData.csiAssetMap);
-                if (preset) {
-                    result[document.id] = preset;
-                }
-            }
-            return result;
-        }, {});
-        return presets;
-    }
-
     /**
      * This function reloads the data of the specified content-sources, while
      * reusing the cached data of the rest of the content-sources, then processes
@@ -384,21 +338,6 @@ export class ContentStore {
 
         const contentSourceRawDataArr = await Promise.all(promises);
 
-        // find first content source that supports presets
-        for (let i = 0; i < contentSources.length; i++) {
-            const contentSourceDataRaw = contentSourceRawDataArr[i];
-            if (contentSourceDataRaw?.csiModelMap?.[StackbitPresetModelName]) {
-                this.presetsContentSource = contentSources[i];
-                this.presets = await this.loadPresetsFromContentSource(contentSourceDataRaw);
-                break;
-            }
-        }
-        
-        // fallback to loading presets from config as usual
-        if (this.stackbitConfig && !this.presetsContentSource && _.isEmpty(this.presets)) {
-            this.presets = await this.loadPresetsFromConfig({ stackbitConfig: this.stackbitConfig });
-        }
-
         // update all content sources at once to prevent race conditions
         this.contentSourceDataById = await this.processData({
             stackbitConfig: this.stackbitConfig,
@@ -503,9 +442,6 @@ export class ContentStore {
     private onContentChange(contentSourceId: string, contentChangeEvent: CSITypes.ContentChangeEvent): ContentStoreTypes.ContentChangeResult {
         // TODO: prevent content change process for contentSourceId if loading content is in progress
 
-        // certain content changes, like preset changes are interpreted as schema changes
-        let schemaChanged = false;
-
         this.logger.debug('onContentChange', {
             contentSourceId,
             documentCount: contentChangeEvent.documents.length,
@@ -616,22 +552,14 @@ export class ContentStore {
             // the indexes of mapped documents and documents from changeEvent are the same
             const document = documents[idx]!;
             const csiDocument = contentChangeEvent.documents[idx]!;
-            if (csiDocument.modelName === StackbitPresetModelName) {
-                const preset = getPresetFromDocument(csiDocument, contentSourceData.csiAssetMap);
-                if (preset) {
-                    this.presets[csiDocument.id] = preset;
-                    schemaChanged = true;
-                }
+            const dataIndex = contentSourceData.documents.findIndex((existingDoc) => existingDoc.srcObjectId === document.srcObjectId);
+            if (dataIndex === -1) {
+                contentSourceData.documents.push(document);
+                contentSourceData.csiDocuments.push(csiDocument);
             } else {
-                const dataIndex = contentSourceData.documents.findIndex((existingDoc) => existingDoc.srcObjectId === document.srcObjectId);
-                if (dataIndex === -1) {
-                    contentSourceData.documents.push(document);
-                    contentSourceData.csiDocuments.push(csiDocument);
-                } else {
-                    // the indexes of documents and csiDocuments are always the same as they are always updated at the same time
-                    contentSourceData.documents.splice(dataIndex, 1, document);
-                    contentSourceData.csiDocuments.splice(dataIndex, 1, csiDocument);
-                }
+                // the indexes of documents and csiDocuments are always the same as they are always updated at the same time
+                contentSourceData.documents.splice(dataIndex, 1, document);
+                contentSourceData.csiDocuments.splice(dataIndex, 1, csiDocument);
             }
             result.updatedDocuments.push({
                 srcType: contentSourceData.srcType,
@@ -660,10 +588,6 @@ export class ContentStore {
             });
         }
 
-        if (schemaChanged) {
-            this.onSchemaChangeCallback?.();
-        }
-
         return result;
     }
 
@@ -733,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) => {
@@ -787,9 +713,8 @@ export class ContentStore {
             (csData): ContentSourceData => {
                 const modelMap = _.get(modelMapByContentSource, [csData.srcType, csData.srcProjectId], {});
                 const mappedCSIDocuments = _.get(documentMapByContentSource, [csData.srcType, csData.srcProjectId], []);
-                const filteredCSIDocuments = mappedCSIDocuments.filter(document => document.modelName !== StackbitPresetModelName);
                 const documents = mapCSIDocumentsToStoreDocuments({
-                    csiDocuments: filteredCSIDocuments,
+                    csiDocuments: mappedCSIDocuments,
                     contentSourceInstance: csData.instance,
                     defaultLocaleCode: csData.defaultLocaleCode,
                     modelMap: modelMap
@@ -845,10 +770,6 @@ export class ContentStore {
         return contentSourceData.instance.getProjectEnvironment();
     }
 
-    canManagePresets() {
-        return Boolean(this.presetsContentSource);
-    }
-
     async hasAccess({
         srcType,
         srcProjectId,
@@ -956,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,
@@ -976,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);
             },
             []
@@ -995,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);
             },
             []
@@ -1008,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);
@@ -1171,51 +1154,6 @@ export class ContentStore {
         return { srcDocumentId: updatedDocument.id };
     }
 
-    async createPreset({ preset, thumbnailAsset, user }: { preset: Preset, thumbnailAsset: ContentStoreTypes.UploadAssetData, user?: ContentStoreTypes.User }): Promise<{ srcDocumentId: string }> {
-        if (!this.presetsContentSource) {
-            throw new Error('No content source available for preset saving');
-        }
-        let thumbnail: string | undefined;
-        if (thumbnailAsset) {
-            const assets = await this.uploadAssets({
-                srcType: this.presetsContentSource.getContentSourceType(),
-                srcProjectId: this.presetsContentSource.getProjectId(),
-                assets: [thumbnailAsset],
-                user
-            });
-            thumbnail = assets[0]?.objectId;
-        }
-        const document = await this.createDocument({
-            srcType: this.presetsContentSource.getContentSourceType(),
-            srcProjectId: this.presetsContentSource.getProjectId(),
-            modelName: StackbitPresetModelName,
-            object: {
-                label: preset.label,
-                thumbnail,
-                data: _.omit(preset, 'thumbnail')
-            },
-            user
-        });
-        return { srcDocumentId: document.srcDocumentId };
-    }
-
-    async deletePreset({ presetId, user }: { presetId: string, user?: ContentStoreTypes.User }) {
-        if (!this.presetsContentSource) {
-            throw new Error('No content source available for preset deleting');
-        }
-        await this.deleteDocument({
-            srcType: this.presetsContentSource.getContentSourceType(),
-            srcProjectId: this.presetsContentSource.getProjectId(),
-            srcDocumentId: presetId,
-            user
-        });
-
-        // we delete presets immediately because some CMSs don't notify us
-        // when documents have been deleted.
-        delete this.presets[presetId];
-        this.onSchemaChangeCallback?.();
-    }
-
     async uploadAndLinkAsset({
         srcType,
         srcProjectId,
@@ -1664,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) {
@@ -1720,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;