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

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

@@ -1,365 +0,0 @@
-import _ from 'lodash';
-import { Field, FieldListProps, FieldModelProps, FieldObjectProps, FieldSpecificProps, Model } from '@stackbit/sdk';
-import { isLocalizedField } from '../content-source-interface';
-import * as CSITypes from '../content-source-interface';
-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;
-}