@stackbit/cms-core 0.1.1 → 0.1.3-alpha.0

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

@@ -0,0 +1,365 @@
+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;
+}

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

@@ -0,0 +1,246 @@
+import _ from 'lodash';
+import { omitByNil } from '@stackbit/utils';
+import * as ContentStoreTypes from '../content-store-types';
+import { getDocumentFieldForLocale } from '../content-store-utils';
+
+export function mapDocumentsToLocalizedApiObjects(documents: ContentStoreTypes.Document[], locale?: string): ContentStoreTypes.APIDocumentObject[] {
+    return documents.map((document) => documentToLocalizedApiObject(document, locale));
+}
+
+function documentToLocalizedApiObject(document: ContentStoreTypes.Document, locale?: string): ContentStoreTypes.APIDocumentObject {
+    const { type, fields, ...rest } = document;
+    return {
+        type: 'object',
+        ...rest,
+        fields: toLocalizedAPIFields(fields, locale)
+    };
+}
+
+function toLocalizedAPIFields(docFields: Record<string, ContentStoreTypes.DocumentField>, locale?: string): Record<string, ContentStoreTypes.DocumentFieldAPI> {
+    return _.mapValues(docFields, (docField) => toLocalizedAPIField(docField, locale));
+}
+
+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
+              };
+    }
+    switch (docField.type) {
+        case 'string':
+        case 'text':
+        case 'url':
+        case 'slug':
+        case 'html':
+        case 'number':
+        case 'boolean':
+        case 'enum':
+        case 'date':
+        case 'datetime':
+        case 'color':
+        case 'style':
+        case 'file':
+        case 'json':
+        case 'markdown':
+        case 'richText':
+            if (docField.localized) {
+                const { localized, locales, ...base } = docField;
+                const localeProps = locale ? locales[locale] : undefined;
+                return {
+                    ...base,
+                    ...(localeProps ?? { value: null }),
+                    ...localeFields(localized, locale),
+                    ...(['file', 'json', 'markdown', 'richText'].includes(docField.type) && !localeProps ? { isUnset: true } : null)
+                };
+            }
+            return {
+                ...docField,
+                ...localeFields(docField.localized, docField.locale)
+            };
+        case 'image':
+            if (docField.localized) {
+                const { localized, locales, ...base } = docField;
+                const localeProps = locale ? locales[locale] : undefined;
+                return {
+                    ...base,
+                    ...(localeProps ?? { isUnset: true }),
+                    ...localeFields(localized, locale)
+                };
+            }
+            return {
+                ...docField,
+                ...localeFields(docField.localized, docField.locale)
+            };
+        case 'object':
+        case 'model':
+            if (docField.localized) {
+                if (docField.type === 'object') {
+                    const { localized, locales, ...base } = docField;
+                    const localeProps = locale ? locales[locale] : undefined;
+                    return {
+                        ...base,
+                        ...(localeProps
+                            ? {
+                                  ...localeProps,
+                                  fields: toLocalizedAPIFields(localeProps.fields, locale)
+                              }
+                            : { isUnset: true }),
+                        ...localeFields(localized, locale)
+                    };
+                } else {
+                    const { localized, locales, ...base } = docField;
+                    const localeProps = locale ? locales[locale] : undefined;
+                    return {
+                        ...base,
+                        type: 'object',
+                        ...(localeProps
+                            ? {
+                                  ...localeProps,
+                                  fields: toLocalizedAPIFields(localeProps.fields, locale)
+                              }
+                            : { isUnset: true }),
+                        ...localeFields(localized, locale)
+                    };
+                }
+            }
+            return {
+                ...(!docField.isUnset
+                    ? {
+                          ...docField,
+                          type: 'object',
+                          fields: toLocalizedAPIFields(docField.fields, locale)
+                      }
+                    : {
+                          ...docField,
+                          type: 'object'
+                      }),
+                ...localeFields(docField.localized, docField.locale)
+            };
+        case 'reference':
+            if (docField.localized) {
+                const { type, refType, localized, locales, ...base } = docField;
+                const localeProps = 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)
+                    };
+                }
+                return {
+                    type: 'unresolved_reference',
+                    refType: refType === 'asset' ? 'image' : 'object',
+                    ...base,
+                    ...localeProps,
+                    ...localeFields(localized, locale)
+                };
+            }
+            const { type, refType, ...base } = docField;
+            if (base.isUnset) {
+                return {
+                    type: 'object',
+                    ...base,
+                    ...localeFields(docField.localized, docField.locale)
+                };
+            }
+            return {
+                type: 'unresolved_reference',
+                refType: refType === 'asset' ? 'image' : 'object',
+                ...base,
+                ...localeFields(docField.localized, docField.locale)
+            };
+        case 'list':
+            if (docField.localized) {
+                const { localized, locales, ...base } = docField;
+                const localeProps = locale ? locales[locale] : undefined;
+                return {
+                    ...base,
+                    ...localeProps,
+                    items: (localeProps?.items ?? []).map((field) => toLocalizedAPIField(field, locale, true)),
+                    ...localeFields(localized, locale)
+                };
+            }
+            return {
+                ...docField,
+                ...localeFields(docField.localized, docField.locale),
+                items: docField.items.map((field) => toLocalizedAPIField(field, locale, true))
+            };
+        default:
+            const _exhaustiveCheck: never = docField;
+            console.error(`toLocalizedAPIField _exhaustiveCheck failed, docField.type: ${docField['type']}`);
+            return _exhaustiveCheck;
+    }
+}
+
+export function mapAssetsToLocalizedApiImages(assets: ContentStoreTypes.Asset[], locale?: string): ContentStoreTypes.APIImageObject[] {
+    return assets.map((asset) => assetToLocalizedApiImage(asset, locale));
+}
+
+function assetToLocalizedApiImage(asset: ContentStoreTypes.Asset, locale?: string): ContentStoreTypes.APIImageObject {
+    const { type, fields, ...rest } = asset;
+    return {
+        type: 'image',
+        ...rest,
+        fields: localizeAssetFields(fields, locale)
+    };
+}
+
+function localizeAssetFields(assetFields: ContentStoreTypes.AssetFields, locale?: string): ContentStoreTypes.AssetFieldsAPI {
+    const fields: ContentStoreTypes.AssetFieldsAPI = {
+        title: {
+            type: 'string' as const,
+            value: null as any
+        },
+        url: {
+            type: 'string' as const,
+            value: null as any
+        }
+    };
+    const titleFieldNonLocalized = getDocumentFieldForLocale(assetFields.title, locale);
+    fields.title.value = titleFieldNonLocalized?.value;
+    fields.title.locale = locale ?? titleFieldNonLocalized?.locale;
+    const assetFileField = assetFields.file;
+    if (assetFileField.localized) {
+        if (locale) {
+            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;
+}
+
+export function mapStoreAssetsToAPIAssets(assets: ContentStoreTypes.Asset[], locale?: string): ContentStoreTypes.APIAsset[] {
+    return assets.map((asset) => storeAssetToAPIAsset(asset, locale));
+}
+
+function storeAssetToAPIAsset(asset: ContentStoreTypes.Asset, locale?: string): ContentStoreTypes.APIAsset {
+    const assetTitleField = asset.fields.title;
+    const localizedTitleField = assetTitleField.localized ? assetTitleField.locales[locale!]! : assetTitleField;
+    const assetFileField = asset.fields.file;
+    const localizedFileField = assetFileField.localized ? assetFileField.locales[locale!]! : assetFileField;
+    return {
+        objectId: asset.srcObjectId,
+        createdAt: asset.createdAt,
+        url: localizedFileField.url,
+        ...omitByNil({
+            title: localizedTitleField.value,
+            fileName: localizedFileField.fileName,
+            contentType: localizedFileField.contentType,
+            size: localizedFileField.size,
+            width: localizedFileField.dimensions?.width,
+            height: localizedFileField.dimensions?.height
+        })
+    };
+}