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

package/src/utils/duplicate-document.ts

@@ -0,0 +1,254 @@
+import _ from 'lodash';
+
+import * as ContentStoreTypes from '../content-store-types';
+import { getDocumentFieldForLocale } from '../content-store-utils';
+import { IMAGE_MODEL } from '../common/common-schema';
+
+export function mergeObjectWithDocument({
+    object,
+    document,
+    locale,
+    documentMap,
+    seenReferences = [],
+    referenceBehavior,
+    duplicatableModels,
+    nonDuplicatableModels
+}: {
+    object: Record<string, any> | undefined;
+    document: ContentStoreTypes.Document;
+    locale?: string;
+    documentMap: Record<string, ContentStoreTypes.Document>;
+    seenReferences?: string[];
+    referenceBehavior?: 'copyReference' | 'duplicateContents';
+    duplicatableModels?: string[];
+    nonDuplicatableModels?: string[];
+}): Record<string, any> {
+    return mergeObjectWithDocumentFields({
+        object,
+        documentFields: document.fields,
+        locale,
+        documentMap,
+        seenReferences: seenReferences.concat(document.srcObjectId),
+        referenceBehavior,
+        duplicatableModels,
+        nonDuplicatableModels
+    });
+}
+
+type Context = {
+    locale?: string;
+    documentMap: Record<string, ContentStoreTypes.Document>;
+    seenReferences: string[];
+    referenceBehavior?: 'copyReference' | 'duplicateContents';
+    duplicatableModels?: string[];
+    nonDuplicatableModels?: string[];
+};
+
+function mergeObjectWithDocumentFields({
+    object,
+    documentFields,
+    ...context
+}: {
+    object: Record<string, any> | undefined;
+    documentFields: Record<string, ContentStoreTypes.DocumentField>;
+} & Context): Record<string, any> {
+    return _.reduce(
+        documentFields,
+        (object, documentField, fieldName) => {
+            const value = mergeObjectWithDocumentField({
+                value: object[fieldName],
+                documentField,
+                ...context
+            });
+            if (typeof value !== 'undefined') {
+                object[fieldName] = value;
+            }
+            return object;
+        },
+        Object.assign({}, object)
+    );
+}
+
+function mergeObjectWithDocumentField({
+    value,
+    documentField,
+    ...context
+}: {
+    value: any;
+    documentField: ContentStoreTypes.DocumentField;
+} & Context): any {
+    const locale = context.locale;
+    switch (documentField.type) {
+        case 'string':
+        case 'text':
+        case 'html':
+        case 'slug':
+        case 'url':
+        case 'color':
+        case 'boolean':
+        case 'number':
+        case 'date':
+        case 'datetime':
+        case 'enum':
+        case 'file':
+        case 'json':
+        case 'style':
+        case 'markdown':
+        case 'richText': {
+            // if a value was provided explicitly, use it to override the value
+            // of the matching field in the duplicated document.
+            if (typeof value !== 'undefined') {
+                return value;
+            }
+            const localizedField = getDocumentFieldForLocale(documentField, locale);
+            if (localizedField) {
+                return localizedField.value;
+            }
+            break;
+        }
+        case 'image': {
+            const localizedField = getDocumentFieldForLocale(documentField, locale);
+            if (localizedField && !localizedField.isUnset) {
+                return mergeObjectWithDocumentFields({
+                    object: value,
+                    documentFields: localizedField.fields,
+                    ...context
+                });
+            }
+            break;
+        }
+        case 'object': {
+            const localizedField = getDocumentFieldForLocale(documentField, locale);
+            if (localizedField && !localizedField.isUnset) {
+                return mergeObjectWithDocumentFields({
+                    object: value,
+                    documentFields: localizedField.fields,
+                    ...context
+                });
+            }
+            break;
+        }
+        case 'model': {
+            const localizedField = getDocumentFieldForLocale(documentField, locale);
+            if (localizedField && !localizedField.isUnset) {
+                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
+                    // was passed in the object.
+                    break;
+                }
+                return {
+                    $$type: localizedField.srcModelName,
+                    ...mergeObjectWithDocumentFields({
+                        object: value,
+                        documentFields: localizedField.fields,
+                        ...context
+                    })
+                };
+            }
+            break;
+        }
+        case 'reference': {
+            const localizedField = getDocumentFieldForLocale(documentField, locale);
+            if (localizedField && !localizedField.isUnset) {
+                if (value && value.$$ref) {
+                    // if the override object has $$ref, use it
+                    break;
+                }
+                if (localizedField.refType === 'asset') {
+                    return {
+                        $$ref: localizedField.refId
+                    };
+                } else {
+                    const document = context.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) {
+                            // 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,
+                            ...mergeObjectWithDocument({
+                                object: value,
+                                document,
+                                locale: context.locale,
+                                documentMap: context.documentMap,
+                                seenReferences: context.seenReferences.concat(document.srcObjectId),
+                                referenceBehavior: context.referenceBehavior,
+                                duplicatableModels: context.duplicatableModels,
+                                nonDuplicatableModels: context.nonDuplicatableModels
+                            })
+                        };
+                    } else {
+                        return {
+                            $$ref: localizedField.refId
+                        };
+                    }
+                }
+            }
+            break;
+        }
+        case 'list': {
+            const localizedField = getDocumentFieldForLocale(documentField, locale);
+            if (value) {
+                // do not try to merge provided list items with existing items
+                // because array items can not be matched by names like fields do.
+                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;
+            }
+            break;
+        }
+        default: {
+            const _exhaustiveCheck: never = documentField;
+            return _exhaustiveCheck;
+        }
+    }
+    // if the document value was not set and no merging occurred use the value
+    // that was provided to override the field in the duplicated document
+    return value;
+}
+
+function shouldDuplicate({
+    referenceField,
+    modelName,
+    seenReferences,
+    referenceBehavior,
+    nonDuplicatableModels,
+    duplicatableModels
+}: {
+    referenceField: ContentStoreTypes.DocumentReferenceFieldNonLocalized & { isUnset?: false };
+    modelName: string;
+    seenReferences: string[];
+    referenceBehavior?: 'copyReference' | 'duplicateContents';
+    nonDuplicatableModels?: string[];
+    duplicatableModels?: string[];
+}) {
+    return (
+        !seenReferences.includes(referenceField.refId) &&
+        modelName !== IMAGE_MODEL.name &&
+        ((referenceBehavior === 'duplicateContents' && !(nonDuplicatableModels ?? []).includes(modelName)) ||
+            (referenceBehavior === 'copyReference' && (duplicatableModels ?? []).includes(modelName)))
+    );
+}

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

@@ -22,16 +22,20 @@ 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,
-        _locale: string | undefined
-    ): null | { localized: ToBoolean<T>; locale: string | undefined } {
-        return isListItem
-            ? null
-            : {
-                  localized: !!localized as ToBoolean<T>,
-                  locale: locale ?? _locale
-              };
+    function localeFields<T extends boolean | undefined>(localized: T): null | { localized: ToBoolean<T>; locale?: string } {
+        const isLocalized = !!localized as ToBoolean<T>;
+        if (isListItem) {
+            return null;
+        }
+        if (!isLocalized) {
+            return {
+                localized: isLocalized
+            };
+        }
+        return {
+            localized: isLocalized,
+            locale: locale
+        };
     }
     switch (docField.type) {
         case 'string':
@@ -52,38 +56,52 @@ function toLocalizedAPIField(docField: ContentStoreTypes.DocumentField, locale?:
         case 'richText':
             if (docField.localized) {
                 const { localized, locales, ...base } = docField;
-                const localeProps = locale ? locales[locale] : undefined;
+                const localeProps = locales && locale ? locales[locale] : undefined;
                 return {
                     ...base,
                     ...(localeProps ?? { value: null }),
-                    ...localeFields(localized, locale),
+                    ...localeFields(localized),
                     ...(['file', 'json', 'markdown', 'richText'].includes(docField.type) && !localeProps ? { isUnset: true } : null)
                 };
             }
             return {
                 ...docField,
-                ...localeFields(docField.localized, docField.locale)
+                ...localeFields(docField.localized)
             };
         case 'image':
             if (docField.localized) {
                 const { localized, locales, ...base } = docField;
-                const localeProps = locale ? locales[locale] : undefined;
+                const localeProps = locales && locale ? locales[locale] : undefined;
                 return {
                     ...base,
-                    ...(localeProps ?? { isUnset: true }),
-                    ...localeFields(localized, locale)
+                    ...(localeProps
+                        ? {
+                              ...localeProps,
+                              fields: toLocalizedAPIFields(localeProps.fields, locale) as ContentStoreTypes.ImageFieldsAPI
+                          }
+                        : { isUnset: true }),
+                    ...localeFields(localized)
                 };
             }
             return {
-                ...docField,
-                ...localeFields(docField.localized, docField.locale)
+                ...(!docField.isUnset
+                    ? {
+                          ...docField,
+                          type: 'image',
+                          fields: toLocalizedAPIFields(docField.fields, locale) as ContentStoreTypes.ImageFieldsAPI
+                      }
+                    : {
+                          ...docField,
+                          type: 'image'
+                      }),
+                ...localeFields(docField.localized)
             };
         case 'object':
         case 'model':
             if (docField.localized) {
                 if (docField.type === 'object') {
                     const { localized, locales, ...base } = docField;
-                    const localeProps = locale ? locales[locale] : undefined;
+                    const localeProps = locales && locale ? locales[locale] : undefined;
                     return {
                         ...base,
                         ...(localeProps
@@ -92,11 +110,11 @@ function toLocalizedAPIField(docField: ContentStoreTypes.DocumentField, locale?:
                                   fields: toLocalizedAPIFields(localeProps.fields, locale)
                               }
                             : { isUnset: true }),
-                        ...localeFields(localized, locale)
+                        ...localeFields(localized)
                     };
                 } else {
                     const { localized, locales, ...base } = docField;
-                    const localeProps = locale ? locales[locale] : undefined;
+                    const localeProps = locales && locale ? locales[locale] : undefined;
                     return {
                         ...base,
                         type: 'object',
@@ -106,7 +124,7 @@ function toLocalizedAPIField(docField: ContentStoreTypes.DocumentField, locale?:
                                   fields: toLocalizedAPIFields(localeProps.fields, locale)
                               }
                             : { isUnset: true }),
-                        ...localeFields(localized, locale)
+                        ...localeFields(localized)
                     };
                 }
             }
@@ -121,19 +139,19 @@ function toLocalizedAPIField(docField: ContentStoreTypes.DocumentField, locale?:
                           ...docField,
                           type: 'object'
                       }),
-                ...localeFields(docField.localized, docField.locale)
+                ...localeFields(docField.localized)
             };
         case 'reference':
             if (docField.localized) {
                 const { type, refType, localized, locales, ...base } = docField;
-                const localeProps = locale ? locales[locale] : undefined;
+                const localeProps = locales && locale ? locales[locale] : undefined;
                 // if reference field isUnset === true, it behaves like a regular object
                 if (!localeProps || localeProps.isUnset) {
                     return {
                         type: 'object',
                         isUnset: true,
                         ...base,
-                        ...localeFields(localized, locale)
+                        ...localeFields(localized)
                     };
                 }
                 return {
@@ -141,7 +159,7 @@ function toLocalizedAPIField(docField: ContentStoreTypes.DocumentField, locale?:
                     refType: refType === 'asset' ? 'image' : 'object',
                     ...base,
                     ...localeProps,
-                    ...localeFields(localized, locale)
+                    ...localeFields(localized)
                 };
             }
             const { type, refType, ...base } = docField;
@@ -149,29 +167,29 @@ function toLocalizedAPIField(docField: ContentStoreTypes.DocumentField, locale?:
                 return {
                     type: 'object',
                     ...base,
-                    ...localeFields(docField.localized, docField.locale)
+                    ...localeFields(docField.localized)
                 };
             }
             return {
                 type: 'unresolved_reference',
                 refType: refType === 'asset' ? 'image' : 'object',
                 ...base,
-                ...localeFields(docField.localized, docField.locale)
+                ...localeFields(docField.localized)
             };
         case 'list':
             if (docField.localized) {
                 const { localized, locales, ...base } = docField;
-                const localeProps = locale ? locales[locale] : undefined;
+                const localeProps = locales && locale ? locales[locale] : undefined;
                 return {
                     ...base,
                     ...localeProps,
                     items: (localeProps?.items ?? []).map((field) => toLocalizedAPIField(field, locale, true)),
-                    ...localeFields(localized, locale)
+                    ...localeFields(localized)
                 };
             }
             return {
                 ...docField,
-                ...localeFields(docField.localized, docField.locale),
+                ...localeFields(docField.localized),
                 items: docField.items.map((field) => toLocalizedAPIField(field, locale, true))
             };
         default:
@@ -207,16 +225,15 @@ function localizeAssetFields(assetFields: ContentStoreTypes.AssetFields, locale?
     };
     const titleFieldNonLocalized = getDocumentFieldForLocale(assetFields.title, locale);
     fields.title.value = titleFieldNonLocalized?.value;
-    fields.title.locale = locale ?? titleFieldNonLocalized?.locale;
+    fields.title.locale = locale;
     const assetFileField = assetFields.file;
     if (assetFileField.localized) {
         if (locale) {
-            fields.url.value = assetFileField.locales[locale]?.url ?? null;
+            fields.url.value = assetFileField.locales?.[locale]?.url ?? null;
             fields.url.locale = locale;
         }
     } else {
         fields.url.value = assetFileField.url;
-        fields.url.locale = assetFileField.locale;
     }
     return fields;
 }
@@ -227,9 +244,9 @@ export function mapStoreAssetsToAPIAssets(assets: ContentStoreTypes.Asset[], loc
 
 function storeAssetToAPIAsset(asset: ContentStoreTypes.Asset, locale?: string): ContentStoreTypes.APIAsset {
     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;
     return {
         objectId: asset.srcObjectId,
         createdAt: asset.createdAt,