@stackbit/cms-core 0.1.21 → 0.1.22-alpha.0

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

@@ -5,6 +5,7 @@ import * as CSITypes from '@stackbit/types';
 
 import * as ContentStoreTypes from '../content-store-types';
 import { IMAGE_MODEL } from '../common/common-schema';
+import { omitByNil } from '@stackbit/utils';
 
 export function mapCSIAssetsToStoreAssets({
     csiAssets,
@@ -34,7 +35,7 @@ function sourceAssetToStoreAsset({
     defaultLocaleCode?: string;
     extra: { srcType: string; srcProjectId: string; srcProjectUrl: string; srcEnvironment: string };
 }): ContentStoreTypes.Asset {
-    return {
+    return omitByNil({
         type: 'asset',
         ...extra,
         srcObjectId: csiAsset.id,
@@ -59,7 +60,7 @@ function sourceAssetToStoreAsset({
                 ...csiAsset.fields.file
             }
         }
-    };
+    });
 }
 
 /**
@@ -118,7 +119,7 @@ function mapCSIDocumentToStoreDocument({
     defaultLocaleCode?: string;
     extra: { srcType: string; srcProjectId: string; srcProjectUrl: string; srcEnvironment: string };
 }): ContentStoreTypes.Document {
-    return {
+    return omitByNil({
         type: 'document',
         ...extra,
         srcObjectId: csiDocument.id,
@@ -141,7 +142,7 @@ function mapCSIDocumentToStoreDocument({
                 defaultLocaleCode
             }
         })
-    };
+    });
 }
 
 type MapContext = {
@@ -184,7 +185,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 +224,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 +244,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 +386,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 +404,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

@@ -1,14 +1,15 @@
 import _ from 'lodash';
 
 import * as ContentStoreTypes from '../content-store-types';
-import { getDocumentFieldForLocale } from '../content-store-utils';
+import { getContentSourceId, getDocumentFieldForLocale } from '../content-store-utils';
 import { IMAGE_MODEL } from '../common/common-schema';
 
 export function mergeObjectWithDocument({
     object,
     document,
     locale,
-    documentMap,
+    contentSourceId,
+    contentSourceDataById,
     seenReferences = [],
     referenceBehavior,
     duplicatableModels,
@@ -17,7 +18,8 @@ export function mergeObjectWithDocument({
     object: Record<string, unknown> | undefined;
     document: ContentStoreTypes.Document;
     locale?: string;
-    documentMap: Record<string, ContentStoreTypes.Document>;
+    contentSourceId: string;
+    contentSourceDataById: Record<string, ContentStoreTypes.ContentSourceData>;
     seenReferences?: string[];
     referenceBehavior?: 'copyReference' | 'duplicateContents';
     duplicatableModels?: string[];
@@ -27,7 +29,8 @@ export function mergeObjectWithDocument({
         object,
         documentFields: document.fields,
         locale,
-        documentMap,
+        contentSourceId,
+        contentSourceDataById,
         seenReferences: seenReferences.concat(document.srcObjectId),
         referenceBehavior,
         duplicatableModels,
@@ -37,7 +40,8 @@ export function mergeObjectWithDocument({
 
 type Context = {
     locale?: string;
-    documentMap: Record<string, ContentStoreTypes.Document>;
+    contentSourceId: string;
+    contentSourceDataById: Record<string, ContentStoreTypes.ContentSourceData>;
     seenReferences: string[];
     referenceBehavior?: 'copyReference' | 'duplicateContents';
     duplicatableModels?: string[];
@@ -156,11 +160,16 @@ function mergeObjectWithDocumentField({
                     break;
                 }
                 if (localizedField.refType === 'asset') {
+                    // assets always duplicated by reference
                     return {
                         $$ref: localizedField.refId
                     };
                 } else {
-                    const document = context.documentMap[localizedField.refId];
+                    const contentSourceData = context.contentSourceDataById[context.contentSourceId];
+                    if (!contentSourceData) {
+                        throw new Error(`no content source data for id '${context.contentSourceId}'`);
+                    }
+                    const document = contentSourceData.documentMap[localizedField.refId];
                     if (!document) {
                         break;
                     }
@@ -186,7 +195,8 @@ function mergeObjectWithDocumentField({
                                 object: value,
                                 document,
                                 locale: context.locale,
-                                documentMap: context.documentMap,
+                                contentSourceId: context.contentSourceId,
+                                contentSourceDataById: context.contentSourceDataById,
                                 seenReferences: context.seenReferences.concat(document.srcObjectId),
                                 referenceBehavior: context.referenceBehavior,
                                 duplicatableModels: context.duplicatableModels,
@@ -202,6 +212,77 @@ function mergeObjectWithDocumentField({
             }
             break;
         }
+        case 'cross-reference':
+            const localizedField = getDocumentFieldForLocale(documentField, locale);
+            if (localizedField && !localizedField.isUnset && isPlainObjectOrUndefined(value)) {
+                if (value && value.$$ref) {
+                    // if the override object has $$ref, use it
+                    break;
+                }
+                if (localizedField.refType === 'asset') {
+                    // assets always duplicated by reference
+                    return {
+                        $$ref: localizedField.refId,
+                        $$refSrcType: localizedField.refSrcType,
+                        $$refProjectId: localizedField.refProjectId
+                    };
+                } else {
+                    const contentSourceId = getContentSourceId(localizedField.refSrcType, localizedField.refProjectId);
+                    const contentSourceData = context.contentSourceDataById[contentSourceId];
+                    if (!contentSourceData) {
+                        throw new Error(`no content source data for id '${context.contentSourceId}'`);
+                    }
+                    const document = contentSourceData.documentMap[localizedField.refId];
+                    if (!document) {
+                        break;
+                    }
+                    const shouldDuplicateDocument = shouldDuplicate({
+                        referenceField: localizedField,
+                        modelName: document.srcModelName,
+                        seenReferences: context.seenReferences,
+                        referenceBehavior: context.referenceBehavior,
+                        duplicatableModels: context.duplicatableModels,
+                        nonDuplicatableModels: context.nonDuplicatableModels
+                    });
+                    if (shouldDuplicateDocument || (value && value.$$type)) {
+                        if (
+                            value &&
+                            (value.$$type !== document.srcModelName ||
+                                value.$$refSrcType !== document.srcType ||
+                                value.$$refProjectId !== document.srcProjectId)
+                        ) {
+                            // if the override object has $$type different from
+                            // the type of the document that is currently
+                            // referenced in the field, then create and link a
+                            // new document according to the provided object
+                            break;
+                        }
+                        return {
+                            $$type: document.srcModelName,
+                            $$refSrcType: document.srcType,
+                            $$refProjectId: document.srcProjectId,
+                            ...mergeObjectWithDocument({
+                                object: value,
+                                document,
+                                locale: context.locale,
+                                contentSourceId: context.contentSourceId,
+                                contentSourceDataById: context.contentSourceDataById,
+                                seenReferences: context.seenReferences.concat(document.srcObjectId),
+                                referenceBehavior: context.referenceBehavior,
+                                duplicatableModels: context.duplicatableModels,
+                                nonDuplicatableModels: context.nonDuplicatableModels
+                            })
+                        };
+                    } else {
+                        return {
+                            $$ref: localizedField.refId,
+                            $$refSrcType: localizedField.refSrcType,
+                            $$refProjectId: localizedField.refProjectId
+                        };
+                    }
+                }
+            }
+            break;
         case 'list': {
             const localizedField = getDocumentFieldForLocale(documentField, locale);
             if (value) {
@@ -210,13 +291,15 @@ function mergeObjectWithDocumentField({
                 break;
             }
             if (localizedField) {
-                return (localizedField.items ?? []).map((field) =>
-                    mergeObjectWithDocumentField({
-                        value: undefined,
-                        documentField: field,
-                        ...context
-                    })
-                ).filter((value) => typeof value !== 'undefined') // if locale passed, it may return undefined for items localized to a different locale;
+                return (localizedField.items ?? [])
+                    .map((field) =>
+                        mergeObjectWithDocumentField({
+                            value: undefined,
+                            documentField: field,
+                            ...context
+                        })
+                    )
+                    .filter((value) => typeof value !== 'undefined'); // if locale passed, it may return undefined for items localized to a different locale;
             }
             break;
         }
@@ -242,7 +325,7 @@ function shouldDuplicate({
     nonDuplicatableModels,
     duplicatableModels
 }: {
-    referenceField: ContentStoreTypes.DocumentReferenceFieldNonLocalized & { isUnset?: false };
+    referenceField: { refId: string; isUnset?: false };
     modelName: string;
     seenReferences: string[];
     referenceBehavior?: 'copyReference' | 'duplicateContents';