@stackbit/cms-core 0.1.3 → 0.1.4-alpha.1

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

@@ -0,0 +1,366 @@
+import _ from 'lodash';
+import { Field, FieldListProps, FieldModelProps, FieldObjectProps, FieldSpecificProps, Model } from '@stackbit/sdk';
+import { isLocalizedField } from '@stackbit/types';
+import * as CSITypes from '@stackbit/types';
+
+import * as ContentStoreTypes from '../content-store-types';
+import { IMAGE_MODEL } from '../common/common-schema';
+
+export function mapCSIAssetsToStoreAssets({
+    csiAssets,
+    contentSourceInstance,
+    defaultLocaleCode
+}: {
+    csiAssets: CSITypes.Asset[];
+    contentSourceInstance: CSITypes.ContentSourceInterface;
+    defaultLocaleCode?: string;
+}): ContentStoreTypes.Asset[] {
+    const extra = getMetadataFromContentStore({ contentSourceInstance });
+    return csiAssets.map((csiAsset) =>
+        sourceAssetToStoreAsset({
+            csiAsset,
+            defaultLocaleCode,
+            extra
+        })
+    );
+}
+
+function sourceAssetToStoreAsset({
+    csiAsset,
+    defaultLocaleCode,
+    extra
+}: {
+    csiAsset: CSITypes.Asset;
+    defaultLocaleCode?: string;
+    extra: { srcType: string; srcProjectId: string; srcProjectUrl: string; srcEnvironment: string };
+}): ContentStoreTypes.Asset {
+    return {
+        type: 'asset',
+        ...extra,
+        srcObjectId: csiAsset.id,
+        srcObjectUrl: csiAsset.manageUrl,
+        srcObjectLabel: getObjectLabel(csiAsset.fields, IMAGE_MODEL, defaultLocaleCode),
+        srcModelName: IMAGE_MODEL.name,
+        srcModelLabel: IMAGE_MODEL.label!,
+        isChanged: csiAsset.status === 'added' || csiAsset.status === 'modified',
+        status: csiAsset.status,
+        createdAt: csiAsset.createdAt,
+        createdBy: csiAsset.createdBy,
+        updatedAt: csiAsset.updatedAt,
+        updatedBy: csiAsset.updatedBy,
+        fields: {
+            title: {
+                label: 'Title',
+                ...csiAsset.fields.title
+            },
+            file: {
+                label: 'File',
+                ...csiAsset.fields.file
+            }
+        }
+    };
+}
+
+export function mapCSIDocumentsToStoreDocuments({
+    csiDocuments,
+    contentSourceInstance,
+    modelMap,
+    defaultLocaleCode
+}: {
+    csiDocuments: CSITypes.Document[];
+    contentSourceInstance: CSITypes.ContentSourceInterface;
+    modelMap: Record<string, Model>;
+    defaultLocaleCode?: string;
+}): ContentStoreTypes.Document[] {
+    const extra = getMetadataFromContentStore({ contentSourceInstance });
+    return csiDocuments.map((csiDocument) =>
+        mapCSIDocumentToStoreDocument({
+            csiDocument,
+            model: modelMap[csiDocument.modelName]!,
+            modelMap,
+            defaultLocaleCode,
+            extra
+        })
+    );
+}
+
+function mapCSIDocumentToStoreDocument({
+    csiDocument,
+    model,
+    modelMap,
+    defaultLocaleCode,
+    extra
+}: {
+    csiDocument: CSITypes.Document;
+    model: Model;
+    modelMap: Record<string, Model>;
+    defaultLocaleCode?: string;
+    extra: { srcType: string; srcProjectId: string; srcProjectUrl: string; srcEnvironment: string };
+}): ContentStoreTypes.Document {
+    return {
+        type: 'document',
+        ...extra,
+        srcObjectId: csiDocument.id,
+        srcObjectUrl: csiDocument.manageUrl,
+        srcObjectLabel: getObjectLabel(csiDocument.fields, model, defaultLocaleCode),
+        srcModelLabel: model.label ?? _.startCase(csiDocument.modelName),
+        srcModelName: csiDocument.modelName,
+        isChanged: csiDocument.status === 'added' || csiDocument.status === 'modified',
+        status: csiDocument.status,
+        createdAt: csiDocument.createdAt,
+        createdBy: csiDocument.createdBy,
+        updatedAt: csiDocument.updatedAt,
+        updatedBy: csiDocument.updatedBy,
+        fields: mapCSIFieldsToStoreFields({
+            csiDocumentFields: csiDocument.fields,
+            modelFields: model.fields ?? [],
+            context: {
+                modelMap,
+                defaultLocaleCode
+            }
+        })
+    };
+}
+
+type MapContext = {
+    modelMap: Record<string, Model>;
+    defaultLocaleCode?: string;
+};
+
+function mapCSIFieldsToStoreFields({
+    csiDocumentFields,
+    modelFields,
+    context
+}: {
+    csiDocumentFields: Record<string, CSITypes.DocumentField>;
+    modelFields: Field[];
+    context: MapContext;
+}): Record<string, ContentStoreTypes.DocumentField> {
+    return modelFields.reduce((result: Record<string, ContentStoreTypes.DocumentField>, modelField) => {
+        const csiDocumentField = csiDocumentFields[modelField.name];
+        const docField = mapCSIFieldToStoreField({
+            csiDocumentField,
+            modelField,
+            context
+        });
+        docField.label = modelField.label;
+        result[modelField.name] = docField;
+        return result;
+    }, {});
+}
+
+function mapCSIFieldToStoreField({
+    csiDocumentField,
+    modelField,
+    context
+}: {
+    csiDocumentField: CSITypes.DocumentField | undefined;
+    modelField: FieldSpecificProps;
+    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)
+        } as ContentStoreTypes.DocumentField;
+    }
+    // TODO: check if need to add "options" to "enum" and subtype/min/max to "number"
+    switch (modelField.type) {
+        case 'object':
+            return mapObjectField(csiDocumentField as CSITypes.DocumentObjectField, modelField, context);
+        case 'model':
+            return mapModelField(csiDocumentField as CSITypes.DocumentModelField, modelField, context);
+        case 'list':
+            return mapListField(csiDocumentField as CSITypes.DocumentListField, modelField, context);
+        case 'richText':
+            return mapRichTextField(csiDocumentField as CSITypes.DocumentRichTextField);
+        case 'markdown':
+            return mapMarkdownField(csiDocumentField as CSITypes.DocumentValueField);
+        default:
+            return csiDocumentField as ContentStoreTypes.DocumentField;
+    }
+}
+
+function mapObjectField(
+    csiDocumentField: CSITypes.DocumentObjectField,
+    modelField: FieldObjectProps,
+    context: MapContext
+): ContentStoreTypes.DocumentObjectField {
+    if (!isLocalizedField(csiDocumentField)) {
+        return {
+            type: csiDocumentField.type,
+            srcObjectLabel: getObjectLabel(csiDocumentField.fields ?? {}, modelField ?? [], context.defaultLocaleCode),
+            fields: mapCSIFieldsToStoreFields({
+                csiDocumentFields: csiDocumentField.fields ?? {},
+                modelFields: modelField.fields ?? [],
+                context
+            })
+        };
+    }
+    return {
+        type: csiDocumentField.type,
+        localized: true,
+        locales: _.mapValues(csiDocumentField.locales, (locale) => {
+            return {
+                locale: locale.locale,
+                srcObjectLabel: getObjectLabel(locale.fields ?? {}, modelField, locale.locale),
+                fields: mapCSIFieldsToStoreFields({
+                    csiDocumentFields: locale.fields ?? {},
+                    modelFields: modelField.fields ?? [],
+                    context
+                })
+            };
+        })
+    };
+}
+
+function mapModelField(csiDocumentField: CSITypes.DocumentModelField, modelField: FieldModelProps, context: MapContext): ContentStoreTypes.DocumentModelField {
+    if (!isLocalizedField(csiDocumentField)) {
+        const model = context.modelMap[csiDocumentField.modelName]!;
+        return {
+            type: csiDocumentField.type,
+            srcObjectLabel: getObjectLabel(csiDocumentField.fields ?? {}, model, context.defaultLocaleCode),
+            srcModelName: csiDocumentField.modelName,
+            srcModelLabel: model.label ?? _.startCase(model.name),
+            fields: mapCSIFieldsToStoreFields({
+                csiDocumentFields: csiDocumentField.fields ?? {},
+                modelFields: model.fields ?? [],
+                context
+            })
+        };
+    }
+    return {
+        type: csiDocumentField.type,
+        localized: true,
+        locales: _.mapValues(csiDocumentField.locales, (locale) => {
+            const model = context.modelMap[locale.modelName]!;
+            return {
+                locale: locale.locale,
+                srcObjectLabel: getObjectLabel(locale.fields ?? {}, model, locale.locale),
+                srcModelName: locale.modelName,
+                srcModelLabel: model.label ?? _.startCase(model.name),
+                fields: mapCSIFieldsToStoreFields({
+                    csiDocumentFields: locale.fields ?? {},
+                    modelFields: model.fields ?? [],
+                    context
+                })
+            };
+        })
+    };
+}
+
+function mapListField(csiDocumentField: CSITypes.DocumentListField, modelField: FieldListProps, context: MapContext): ContentStoreTypes.DocumentListField {
+    if (!isLocalizedField(csiDocumentField)) {
+        return {
+            type: csiDocumentField.type,
+            items: csiDocumentField.items.map((item) =>
+                mapCSIFieldToStoreField({
+                    csiDocumentField: item,
+                    modelField: modelField.items ?? { type: 'string' },
+                    context
+                })
+            )
+        };
+    }
+    return {
+        type: csiDocumentField.type,
+        localized: true,
+        locales: _.mapValues(csiDocumentField.locales, (locale) => {
+            return {
+                locale: locale.locale,
+                items: (locale.items ?? []).map((item) =>
+                    mapCSIFieldToStoreField({
+                        csiDocumentField: item,
+                        modelField: modelField.items ?? { type: 'string' },
+                        context
+                    })
+                )
+            };
+        })
+    };
+}
+
+function mapRichTextField(csiDocumentField: CSITypes.DocumentRichTextField): ContentStoreTypes.DocumentRichTextField {
+    if (!isLocalizedField(csiDocumentField)) {
+        return {
+            ...csiDocumentField,
+            multiElement: true
+        };
+    }
+    return {
+        type: csiDocumentField.type,
+        localized: true,
+        locales: _.mapValues(csiDocumentField.locales, (locale) => {
+            return {
+                ...locale,
+                multiElement: true
+            };
+        })
+    };
+}
+
+function mapMarkdownField(csiDocumentField: CSITypes.DocumentValueField): ContentStoreTypes.DocumentMarkdownField {
+    if (!isLocalizedField(csiDocumentField)) {
+        return {
+            type: 'markdown',
+            value: csiDocumentField.value,
+            multiElement: true
+        };
+    }
+    return {
+        type: 'markdown',
+        localized: true,
+        locales: _.mapValues(csiDocumentField.locales, (locale) => {
+            return {
+                ...locale,
+                multiElement: true
+            };
+        })
+    };
+}
+
+function getMetadataFromContentStore({
+    contentSourceInstance
+}: {
+    contentSourceInstance: CSITypes.ContentSourceInterface;
+}): {
+    srcType: string;
+    srcProjectId: string;
+    srcProjectUrl: string;
+    srcEnvironment: string;
+} {
+    return {
+        srcType: contentSourceInstance.getContentSourceType(),
+        srcProjectId: contentSourceInstance.getProjectId(),
+        srcProjectUrl: contentSourceInstance.getProjectManageUrl(),
+        srcEnvironment: contentSourceInstance.getProjectEnvironment()
+    };
+}
+
+function getObjectLabel(
+    documentFields: Record<string, CSITypes.DocumentField | CSITypes.AssetFileField>,
+    modelOrObjectField: Model | FieldObjectProps,
+    locale?: string
+): string {
+    const labelField = modelOrObjectField.labelField;
+    let label = null;
+    if (labelField) {
+        const field = _.get(documentFields, labelField, null);
+        if (field && ['string', 'url', 'slug', 'text', 'markdown', 'number', 'enum', 'date', 'datetime', 'color', 'image', 'file'].includes(field.type)) {
+            if (isLocalizedField(field) && locale) {
+                label = _.get(field, ['locales', locale, 'value'], null);
+            } else if (!isLocalizedField(field)) {
+                label = _.get(field, 'value', null);
+            }
+        }
+    }
+    if (!label) {
+        label = _.get(modelOrObjectField, 'label');
+    }
+    if (!label && _.has(modelOrObjectField, 'name')) {
+        label = _.startCase(_.get(modelOrObjectField, 'name'));
+    }
+    return label;
+}