@stackbit/cms-core 0.1.20 → 0.1.21-cross-references.0

package/src/content-store.ts

@@ -32,7 +32,8 @@ import {
     getModelFieldForFieldAtPath,
     getUserContextForSrcType,
     groupDocumentsByContentSource,
-    groupModelsByContentSource
+    groupModelsByContentSource,
+    updateOperationValueFieldWithCrossReference
 } from './content-store-utils';
 import {
     getSiteMapEntriesFromStackbitConfig,
@@ -1174,6 +1175,8 @@ export class ContentStore {
         srcDocumentId,
         fieldPath,
         modelName,
+        refSrcType,
+        refProjectId,
         object,
         index,
         locale,
@@ -1184,12 +1187,14 @@ export class ContentStore {
         srcDocumentId: string;
         fieldPath: (string | number)[];
         modelName?: string;
+        refSrcType?: string;
+        refProjectId?: string;
         object?: Record<string, any>;
         index?: number;
         locale?: string;
         user?: ContentStoreTypes.User;
-    }): Promise<{ srcDocumentId: string, createdDocumentId: string }> {
-        this.logger.debug('createAndLinkDocument', { srcType, srcProjectId, srcDocumentId, fieldPath, modelName, index, locale });
+    }): Promise<{ srcDocumentId: string; createdDocumentId: string }> {
+        this.logger.debug('createAndLinkDocument', { srcType, srcProjectId, srcDocumentId, fieldPath, modelName, refSrcType, refProjectId, index, locale });
 
         const contentSourceId = getContentSourceId(srcType, srcProjectId);
         const contentSourceData = this.getContentSourceDataByIdOrThrow(contentSourceId);
@@ -1203,36 +1208,51 @@ export class ContentStore {
 
         // get the document model
         const documentModelName = document.srcModelName;
+        const modelMap = contentSourceData.modelMap;
+        const model = modelMap[documentModelName];
         const csiModelMap = contentSourceData.csiModelMap;
         const csiModel = csiModelMap[documentModelName];
-        if (!csiModel) {
+        if (!model || !csiModel) {
             throw new Error(`error updating document, could not find document model: '${documentModelName}'`);
         }
 
         // get the 'reference' model field in the updated document that will be used to link the new document
         locale = locale ?? contentSourceData.defaultLocaleCode;
+        const modelField = getModelFieldForFieldAtPath(document, model, fieldPath, modelMap, locale);
         const csiModelField = getModelFieldForFieldAtPath(document, csiModel, fieldPath, csiModelMap, locale);
-        if (!csiModelField) {
+        if (!modelField || !csiModelField) {
             throw Error(`the "fieldPath" points to non existing model field: ${fieldPath.join('.')}`);
         }
-        const fieldProps = csiModelField.type === 'list' ? csiModelField.items! : csiModelField;
-        if (fieldProps.type !== 'reference') {
+        const fieldProps = modelField.type === 'list' ? modelField.items! : modelField;
+        const csiFieldProps = csiModelField.type === 'list' ? csiModelField.items! : csiModelField;
+        if (fieldProps.type !== 'reference' && fieldProps.type !== 'cross-reference') {
             throw Error(`error in "createAndLinkDocument", this operation can only be used on reference field: ${fieldPath.join('.')}`);
         }
 
         // get the model name for the new document
         if (!modelName && fieldProps.models.length === 1) {
-            modelName = fieldProps.models[0];
+            if (fieldProps.type === 'reference') {
+                modelName = fieldProps.models[0];
+            } else if (fieldProps.type === 'cross-reference') {
+                modelName = fieldProps.models[0]!.modelName;
+            }
         }
         if (!modelName) {
             throw Error(`error in "createAndLinkDocument", missing "modelName": ${fieldPath.join('.')}`);
         }
 
+        if (fieldProps.type === 'reference') {
+            refSrcType = srcType;
+            refProjectId = srcProjectId;
+        } else if (!refSrcType || !refProjectId) {
+            throw Error(`the "refSrcType" and "refProjectId" must be specified when linking a cross-reference field: ${fieldPath.join('.')}`);
+        }
+
         // create the new document
         const result = await this.createDocument({
             object: object,
-            srcProjectId: srcProjectId,
-            srcType: srcType,
+            srcProjectId: refProjectId,
+            srcType: refSrcType,
             modelName: modelName,
             locale: locale,
             user: user
@@ -1240,17 +1260,29 @@ export class ContentStore {
 
         // update the document by linking the field to the created document
         const userContext = getUserContextForSrcType(srcType, user);
-        const field = {
-            type: 'reference',
-            refType: 'document',
-            refId: result.srcDocumentId
-        } as const;
+        let field: CSITypes.UpdateOperationField;
+        if (fieldProps.type === 'reference') {
+            field = {
+                type: 'reference',
+                refType: 'document',
+                refId: result.srcDocumentId
+            } as CSITypes.UpdateOperationReferenceField;
+        } else {
+            if (!['string', 'text', 'json'].includes(csiFieldProps.type)) {
+                throw new Error(`The 'cross-reference' field can be only applied on string, text and json fields: ${fieldPath.join('.')}`);
+            }
+            field = updateOperationValueFieldWithCrossReference(csiFieldProps.type as 'string' | 'text' | 'json', {
+                refId: result.srcDocumentId,
+                refSrcType: refSrcType,
+                refProjectId: refProjectId
+            });
+        }
         const updatedDocument = await contentSourceData.instance.updateDocument({
             document: csiDocument,
             modelMap: csiModelMap,
             userContext: userContext,
             operations: [
-                csiModelField.type === 'list'
+                modelField.type === 'list'
                     ? {
                           opType: 'insert',
                           fieldPath: fieldPath,
@@ -1426,7 +1458,7 @@ export class ContentStore {
         object,
         locale,
         defaultLocaleDocumentId,
-        user,
+        user
     }: {
         srcType: string;
         srcProjectId: string;
@@ -1440,22 +1472,17 @@ export class ContentStore {
 
         const contentSourceId = getContentSourceId(srcType, srcProjectId);
         const contentSourceData = this.getContentSourceDataByIdOrThrow(contentSourceId);
-        const modelMap = contentSourceData.modelMap;
-        const csiModelMap = contentSourceData.csiModelMap;
-        const userContext = getUserContextForSrcType(srcType, user);
         const resolvedLocale = locale ?? contentSourceData.defaultLocaleCode;
 
         const result = await createDocumentRecursively({
             object,
             modelName,
-            modelMap,
-            csiModelMap,
+            contentSourceId,
+            contentSourceDataById: this.contentSourceDataById,
             createDocument: getCreateDocumentThunk({
                 locale: resolvedLocale,
-                csiModelMap,
-                userContext,
                 defaultLocaleDocumentId,
-                contentSourceInstance: contentSourceData.instance
+                user
             })
         });
 
@@ -1518,11 +1545,11 @@ export class ContentStore {
                             csiModelField,
                             modelMap,
                             csiModelMap,
+                            contentSourceId,
+                            contentSourceDataById: this.contentSourceDataById,
                             createDocument: getCreateDocumentThunk({
                                 locale: updateOperation.locale,
-                                csiModelMap,
-                                userContext,
-                                contentSourceInstance: contentSourceData.instance
+                                user
                             })
                         });
                         return {
@@ -1546,11 +1573,11 @@ export class ContentStore {
                             csiModelField: csiModelField.items,
                             modelMap,
                             csiModelMap,
+                            contentSourceId,
+                            contentSourceDataById: this.contentSourceDataById,
                             createDocument: getCreateDocumentThunk({
                                 locale: updateOperation.locale,
-                                csiModelMap,
-                                userContext,
-                                contentSourceInstance: contentSourceData.instance
+                                user
                             })
                         });
                         return {
@@ -1617,7 +1644,6 @@ export class ContentStore {
             throw new Error(`no model with name '${document.srcModelName}' was found`);
         }
 
-        const userContext = getUserContextForSrcType(srcType, user);
         const resolvedLocale = locale ?? contentSourceData.defaultLocaleCode;
 
         const extendedObject = mergeObjectWithDocument({
@@ -1633,13 +1659,11 @@ export class ContentStore {
         const result = await createDocumentRecursively({
             object: extendedObject,
             modelName: model.name,
-            modelMap,
-            csiModelMap,
+            contentSourceId,
+            contentSourceDataById: this.contentSourceDataById,
             createDocument: getCreateDocumentThunk({
                 locale: resolvedLocale,
-                csiModelMap,
-                userContext,
-                contentSourceInstance: contentSourceData.instance
+                user
             })
         });
 

package/src/utils/create-update-csi-docs.ts

@@ -7,41 +7,41 @@ import { fieldPathToString, mapPromise } from '@stackbit/utils';
 import * as CSITypes from '@stackbit/types';
 
 import * as ContentStoreTypes from '../content-store-types';
+import { getContentSourceId, getUserContextForSrcType, updateOperationValueFieldWithCrossReference } from '../content-store-utils';
 
 export type CreateDocumentCallback = ({
     updateOperationFields,
+    contentSourceData,
     modelName
 }: {
     updateOperationFields: Record<string, CSITypes.UpdateOperationField>;
+    contentSourceData: ContentStoreTypes.ContentSourceData;
     modelName: string;
 }) => Promise<CSITypes.Document>;
 
 export function getCreateDocumentThunk({
-    csiModelMap,
     locale,
     defaultLocaleDocumentId,
-    userContext,
-    contentSourceInstance
+    user
 }: {
-    csiModelMap: Record<string, CSIModel>;
     locale?: string;
     defaultLocaleDocumentId?: string;
-    userContext: unknown;
-    contentSourceInstance: CSITypes.ContentSourceInterface;
+    user?: ContentStoreTypes.User;
 }): CreateDocumentCallback {
-    return async ({ updateOperationFields, modelName }) => {
+    return async ({ updateOperationFields, modelName, contentSourceData }) => {
         // When passing model and modelMap to contentSourceInstance, we have to pass
         // the original models (i.e., csiModel and csiModelMap) that we've received
         // from that contentSourceInstance. We can't pass internal models as they
         // might
-        const csiModel = csiModelMap[modelName];
+        const csiModel = contentSourceData.csiModelMap[modelName];
         if (!csiModel) {
             throw new Error(`no model with name '${modelName}' was found`);
         }
-        return await contentSourceInstance.createDocument({
+        const userContext = getUserContextForSrcType(contentSourceData.srcType, user);
+        return await contentSourceData.instance.createDocument({
             updateOperationFields: updateOperationFields,
             model: csiModel,
-            modelMap: csiModelMap,
+            modelMap: contentSourceData.csiModelMap,
             locale,
             defaultLocaleDocumentId,
             userContext
@@ -90,18 +90,24 @@ export function getCreateDocumentThunk({
 export async function createDocumentRecursively({
     object,
     modelName,
-    modelMap,
-    csiModelMap,
+    contentSourceId,
+    contentSourceDataById,
     createDocument
 }: {
     object?: Record<string, any>;
     modelName: string;
-    modelMap: Record<string, SDKModel>;
-    csiModelMap: Record<string, CSIModel>;
+    contentSourceId: string;
+    contentSourceDataById: Record<string, ContentStoreTypes.ContentSourceData>;
     createDocument: CreateDocumentCallback;
 }): Promise<{ document: CSITypes.Document; newRefDocuments: CSITypes.Document[] }> {
+    const contentSourceData = contentSourceDataById[contentSourceId];
+    if (!contentSourceData) {
+        throw new Error(`no content source data for id '${contentSourceId}'`);
+    }
+    const modelMap = contentSourceData.modelMap;
+    const csiModelMap = contentSourceData.csiModelMap;
     const model = modelMap[modelName];
-    const csiModel = csiModelMap[modelName];
+    const csiModel = contentSourceData.csiModelMap[modelName];
     if (!model || !csiModel) {
         throw new Error(`no model with name '${modelName}' was found`);
     }
@@ -121,11 +127,14 @@ export async function createDocumentRecursively({
         fieldPath: [modelName],
         modelMap,
         csiModelMap,
+        contentSourceId,
+        contentSourceDataById,
         createDocument
     });
 
     const document = await createDocument({
         updateOperationFields: nestedResult.fields,
+        contentSourceData: contentSourceData,
         modelName: modelName
     });
     return {
@@ -152,6 +161,8 @@ async function createObjectRecursively({
     fieldPath,
     modelMap,
     csiModelMap,
+    contentSourceId,
+    contentSourceDataById,
     createDocument
 }: {
     object?: Record<string, any>;
@@ -160,6 +171,8 @@ async function createObjectRecursively({
     fieldPath: (string | number)[];
     modelMap: Record<string, SDKModel>;
     csiModelMap: Record<string, CSIModel>;
+    contentSourceId: string;
+    contentSourceDataById: Record<string, ContentStoreTypes.ContentSourceData>;
     createDocument: CreateDocumentCallback;
 }): Promise<{
     fields: Record<string, CSITypes.UpdateOperationField>;
@@ -206,6 +219,8 @@ async function createObjectRecursively({
                 fieldPath: fieldPath.concat(fieldName),
                 modelMap,
                 csiModelMap,
+                contentSourceId,
+                contentSourceDataById,
                 createDocument
             });
             result.fields[fieldName] = fieldResult.field;
@@ -226,6 +241,8 @@ async function createUpdateOperationFieldRecursively({
     fieldPath,
     modelMap,
     csiModelMap,
+    contentSourceId,
+    contentSourceDataById,
     createDocument
 }: {
     value: any;
@@ -234,6 +251,8 @@ async function createUpdateOperationFieldRecursively({
     fieldPath: (string | number)[];
     modelMap: Record<string, SDKModel>;
     csiModelMap: Record<string, CSIModel>;
+    contentSourceId: string;
+    contentSourceDataById: Record<string, ContentStoreTypes.ContentSourceData>;
     createDocument: CreateDocumentCallback;
 }): Promise<{ field: CSITypes.UpdateOperationField; newRefDocuments: CSITypes.Document[] }> {
     if (csiModelField.type === 'object') {
@@ -247,6 +266,8 @@ async function createUpdateOperationFieldRecursively({
             fieldPath,
             modelMap,
             csiModelMap,
+            contentSourceId,
+            contentSourceDataById,
             createDocument
         });
         return {
@@ -284,6 +305,8 @@ async function createUpdateOperationFieldRecursively({
             fieldPath,
             modelMap,
             csiModelMap,
+            contentSourceId,
+            contentSourceDataById,
             createDocument
         });
         return {
@@ -340,11 +363,14 @@ async function createUpdateOperationFieldRecursively({
                     modelName = modelNames[0];
                 }
             }
+            if (!modelName) {
+                throw new Error('reference field type must have $$type or $$ref properties when creating new documents');
+            }
             const { document, newRefDocuments } = await createDocumentRecursively({
                 object: rest,
                 modelName,
-                modelMap,
-                csiModelMap,
+                contentSourceId,
+                contentSourceDataById,
                 createDocument
             });
             return {
@@ -356,6 +382,39 @@ async function createUpdateOperationFieldRecursively({
                 newRefDocuments: [document, ...newRefDocuments]
             };
         }
+    } else if (['string', 'text', 'json'].includes(csiModelField.type) && modelField.type === 'cross-reference') {
+        const fieldType = csiModelField.type as 'string' | 'text' | 'json';
+        let { $$ref: refId = null, $$type: modelName = null, $$refSrcType: refSrcType = null, $$refProjectId: refProjectId = null, ...rest } = value;
+        let refObject;
+        const newRefDocuments: CSITypes.Document[] = [];
+        if (refId && refSrcType && refProjectId) {
+            refObject = { refId, refSrcType, refProjectId };
+        } else {
+            if (!modelName || !refSrcType || !refProjectId) {
+                const models = modelField.models;
+                if (models && models.length === 1) {
+                    modelName = models[0]!.modelName;
+                    refSrcType = models[0]!.srcType;
+                    refProjectId = models[0]!.srcProjectId;
+                }
+            }
+            if (!modelName || !refSrcType || !refProjectId) {
+                throw new Error('reference field type must have $$type or $$ref properties when creating new documents');
+            }
+            const { document, newRefDocuments } = await createDocumentRecursively({
+                object: rest,
+                modelName,
+                contentSourceId: getContentSourceId(refSrcType, refProjectId),
+                contentSourceDataById,
+                createDocument
+            });
+            newRefDocuments.push(document, ...newRefDocuments);
+            refObject = { refId: document.id, refSrcType, refProjectId };
+        }
+        return {
+            field: updateOperationValueFieldWithCrossReference(fieldType, refObject),
+            newRefDocuments
+        };
     } else if (csiModelField.type === 'list') {
         if (modelField.type !== 'list') {
             throw new Error(`field type mismatch between external and internal models at field path ${fieldPathToString(fieldPath)}`);
@@ -378,6 +437,8 @@ async function createUpdateOperationFieldRecursively({
                     fieldPath: fieldPath.concat(index),
                     modelMap,
                     csiModelMap,
+                    contentSourceId,
+                    contentSourceDataById,
                     createDocument
                 });
                 if (result.field.type === 'list') {
@@ -425,6 +486,8 @@ export async function convertOperationField({
     csiModelField,
     modelMap,
     csiModelMap,
+    contentSourceId,
+    contentSourceDataById,
     createDocument
 }: {
     operationField: ContentStoreTypes.UpdateOperationField;
@@ -433,6 +496,8 @@ export async function convertOperationField({
     csiModelField: FieldSpecificProps;
     modelMap: Record<string, SDKModel>;
     csiModelMap: Record<string, SDKModel>;
+    contentSourceId: string;
+    contentSourceDataById: Record<string, ContentStoreTypes.ContentSourceData>;
     createDocument: CreateDocumentCallback;
 }): Promise<CSITypes.UpdateOperationField> {
     switch (operationField.type) {
@@ -447,6 +512,8 @@ export async function convertOperationField({
                 fieldPath,
                 modelMap,
                 csiModelMap,
+                contentSourceId,
+                contentSourceDataById,
                 createDocument
             });
             return {
@@ -467,6 +534,8 @@ export async function convertOperationField({
                 fieldPath,
                 modelMap,
                 csiModelMap,
+                contentSourceId,
+                contentSourceDataById,
                 createDocument
             });
             return {
@@ -476,7 +545,23 @@ export async function convertOperationField({
             };
         }
         case 'reference':
+            // ContentStore and CSI 'reference' operation field have the same format
             return operationField;
+        case 'cross-reference':
+            if (csiModelField.type !== 'string' && csiModelField.type !== 'text' && csiModelField.type !== 'json') {
+                throw new Error(
+                    `update operation with with 'cross-reference' field can be performed on 'string', 'text' and 'json' content-source field types only, got '${csiModelField.type}'`
+                );
+            }
+            const refObject = {
+                refId: operationField.refId,
+                refSrcType: operationField.refSrcType,
+                refProjectId: operationField.refProjectId
+            };
+            return {
+                type: csiModelField.type,
+                value: csiModelField.type === 'json' ? refObject : JSON.stringify(refObject)
+            };
         case 'list': {
             if (modelField.type !== 'list' || csiModelField.type !== 'list') {
                 throw new Error(`the operation field type '${operationField.type}' does not match the model field type '${modelField.type}'`);
@@ -491,6 +576,8 @@ export async function convertOperationField({
                         fieldPath: fieldPath.concat(index),
                         modelMap,
                         csiModelMap,
+                        contentSourceId,
+                        contentSourceDataById,
                         createDocument
                     });
                     if (result.field.type === 'list') {
@@ -506,7 +593,9 @@ export async function convertOperationField({
         }
         case 'enum':
             if (csiModelField.type !== 'enum' && csiModelField.type !== 'string') {
-                throw new Error(`the operation field type 'enum' can be performed on 'string' and 'enum' content-source field types '${csiModelField.type}'`);
+                throw new Error(
+                    `update operation with 'enum' field can be performed on 'string' and 'enum' content-source field types only, got '${csiModelField.type}'`
+                );
             }
             // When inserting new enum value into a list, the client does not
             // send value. Set first option as the value.
@@ -543,6 +632,8 @@ export async function convertOperationField({
                 fieldPath,
                 modelMap,
                 csiModelMap,
+                contentSourceId,
+                contentSourceDataById,
                 createDocument
             });
             return result.field;

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

@@ -184,7 +184,7 @@ function mapCSIFieldToStoreField({
     context: MapContext;
 }): ContentStoreTypes.DocumentField {
     if (!csiDocumentField) {
-        const isUnset = ['object', 'model', 'reference', 'richText', 'markdown', 'image', 'file', 'json'].includes(modelField.type);
+        const isUnset = ['object', 'model', 'reference', 'cross-reference', 'richText', 'markdown', 'image', 'file', 'json'].includes(modelField.type);
         return {
             type: modelField.type,
             ...(localized
@@ -223,6 +223,8 @@ function mapCSIFieldToStoreField({
         case 'file':
         case 'reference':
             return csiDocumentField as ContentStoreTypes.DocumentField;
+        case 'cross-reference':
+            return mapReferenceField(csiDocumentField)
         case 'object':
             return mapObjectField(csiDocumentField as CSITypes.DocumentObjectField, modelField, context);
         case 'model':
@@ -241,6 +243,76 @@ function mapCSIFieldToStoreField({
     }
 }
 
+function mapReferenceField(csiDocumentField: CSITypes.DocumentField): ContentStoreTypes.DocumentCrossReferenceField {
+    const unlocalizedUnset = {
+        type: 'cross-reference',
+        refType: 'document',
+        isUnset: true
+    } as const;
+    if (csiDocumentField.type !== 'string' && csiDocumentField.type !== 'text' && csiDocumentField.type !== 'json') {
+        if (isLocalizedField(csiDocumentField)) {
+            return {
+                type: 'cross-reference',
+                refType: 'document',
+                localized: true,
+                locales: {}
+            };
+        }
+        return unlocalizedUnset;
+    }
+    const parseRefObject = (value: any): { refId: string; refSrcType: string; refProjectId: string } | null => {
+        if (typeof value === 'string') {
+            try {
+                value = JSON.parse(value);
+            } catch (error) {
+                return null;
+            }
+        }
+        if (_.isPlainObject(value) && 'refId' in value && 'refSrcType' in value && 'refProjectId' in value) {
+            return {
+                refId: value.refId,
+                refSrcType: value.refSrcType,
+                refProjectId: value.refProjectId
+            };
+        }
+        return null;
+    };
+    if (isLocalizedField(csiDocumentField)) {
+        csiDocumentField.locales;
+        return {
+            type: 'cross-reference',
+            refType: 'document',
+            localized: true,
+            locales: _.reduce(
+                csiDocumentField.locales,
+                (accum: Record<string, { locale: string; refId: string; refSrcType: string; refProjectId: string }>, locale, localeKey) => {
+                    const refObject = parseRefObject(locale.value);
+                    if (refObject) {
+                        accum[localeKey] = {
+                            locale: locale.locale,
+                            ...refObject
+                        };
+                    }
+                    return accum;
+                },
+                {}
+            )
+        };
+    }
+    if (!('value' in csiDocumentField)) {
+        return unlocalizedUnset;
+    }
+    const refObject = parseRefObject(csiDocumentField.value);
+    if (!refObject) {
+        return unlocalizedUnset;
+    }
+    return {
+        type: 'cross-reference',
+        refType: 'document',
+        ...refObject
+    };
+}
+
 function mapObjectField(
     csiDocumentField: CSITypes.DocumentObjectField,
     modelField: FieldObjectProps,
@@ -313,14 +385,15 @@ function mapListField(csiDocumentField: CSITypes.DocumentListField, modelField:
     if (!isLocalizedField(csiDocumentField)) {
         return {
             type: csiDocumentField.type,
-            items: csiDocumentField.items.map((item) =>
-                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
+            items: csiDocumentField.items.map(
+                (item) =>
+                    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
             )
         };
     }
@@ -330,14 +403,15 @@ function mapListField(csiDocumentField: CSITypes.DocumentListField, modelField:
         locales: _.mapValues(csiDocumentField.locales, (locale) => {
             return {
                 locale: locale.locale,
-                items: (locale.items ?? []).map((item) =>
-                    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
+                items: (locale.items ?? []).map(
+                    (item) =>
+                        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/duplicate-document.ts

@@ -202,6 +202,9 @@ function mergeObjectWithDocumentField({
             }
             break;
         }
+        case 'cross-reference':
+            // TODO: implement duplicating documents with cross-references
+            break;
         case 'list': {
             const localizedField = getDocumentFieldForLocale(documentField, locale);
             if (value) {