@stackbit/cms-core 0.1.10-alpha.0 → 0.1.11

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

@@ -70,12 +70,26 @@ function toLocalizedAPIField(docField: ContentStoreTypes.DocumentField, locale?:
                 const localeProps = locale ? locales[locale] : undefined;
                 return {
                     ...base,
-                    ...(localeProps ?? { isUnset: true }),
+                    ...(localeProps
+                        ? {
+                              ...localeProps,
+                              fields: toLocalizedAPIFields(localeProps.fields, locale) as ContentStoreTypes.ImageFieldsAPI
+                          }
+                        : { isUnset: true }),
                     ...localeFields(localized, locale)
                 };
             }
             return {
-                ...docField,
+                ...(!docField.isUnset
+                    ? {
+                          ...docField,
+                          type: 'image',
+                          fields: toLocalizedAPIFields(docField.fields, locale) as ContentStoreTypes.ImageFieldsAPI
+                      }
+                    : {
+                          ...docField,
+                          type: 'image'
+                      }),
                 ...localeFields(docField.localized, docField.locale)
             };
         case 'object':