@stackbit/cms-contentstack 0.1.1-staging.0

package/src/contentstack-schema-converter.ts

@@ -0,0 +1,486 @@
+import _ from 'lodash';
+import * as StackbitTypes from '@stackbit/types';
+import type {
+    ContenteStackFieldText,
+    ContentStackField,
+    ContentStackFieldDate,
+    ContentStackFieldNumber,
+    ContentStackLocale,
+    ContentType,
+    GlobalField
+} from './contentstack-types';
+
+export type ModelWithContext = StackbitTypes.Model<ModelContext>;
+export type ModelContext = {
+    clonedFromModel?: string;
+    referencedIn?: ReferencedIn;
+    blockMap?: BlockMap;
+};
+export type ReferencedIn = {
+    modelName: string;
+    fieldPath: string;
+    blockUID: string;
+};
+export type BlockMap = Record<
+    string,
+    {
+        modelNameToBlockId: Record<string, string>;
+        blockIdToModelName: Record<string, string>;
+    }
+>;
+
+type AddBlockMap = (options: { blockFieldPath: string; modelName: string; blockUID: string }) => void;
+type AddBlockModel = (model: ModelWithContext) => void;
+type CloneModelOptions = { origModelUID: string; newModelName: string; label: string; referencedIn: ReferencedIn };
+type CloneModel = (options: CloneModelOptions) => void;
+
+export function convertLocales({
+    contentStackLocales,
+    masterLocale,
+    logger
+}: {
+    contentStackLocales: ContentStackLocale[];
+    masterLocale?: string;
+    logger: StackbitTypes.Logger;
+}): StackbitTypes.Locale[] {
+    const locales: StackbitTypes.Locale[] = contentStackLocales.map((locale) => ({ code: locale.code }));
+
+    if (masterLocale) {
+        const defaultLocale = locales.find((locale) => locale.code === masterLocale);
+        if (defaultLocale) {
+            defaultLocale.default = true;
+        } else {
+            throw new Error(
+                `The 'masterLocale' '${masterLocale}' provided to ContentStackSource constructor ` +
+                    `does not match any locale code: [${locales.map((locale) => locale.code).join(', ')}]`
+            );
+        }
+    } else if (locales.length === 1) {
+        logger.info(`The Contentstack stack has a single '${locales[0]!.code}' locale, using it as master locale`);
+        locales[0]!.default = true;
+    } else {
+        throw new Error(
+            `Stack has multiple locales: [${locales.map((locale) => locale.code).join(', ')}], ` +
+                `please specify which one should be used as the master locale using the 'masterLocale' property ` +
+                `in the ContentStackSource constructor options`
+        );
+    }
+
+    return locales;
+}
+
+export function convertModels({ contentStackModels }: { contentStackModels: (ContentType | GlobalField)[] }): ModelWithContext[] {
+    const modelsToClone: CloneModelOptions[] = [];
+    const models = contentStackModels.reduce((stackbitModels: ModelWithContext[], contentStackModel) => {
+        const blockModels: ModelWithContext[] = [];
+        const stackbitModel = convertModel({
+            contentStackModel: contentStackModel,
+            addBlockModel: (model: ModelWithContext) => {
+                blockModels.push(model);
+            },
+            cloneModel: (options) => {
+                modelsToClone.push(options);
+            }
+        });
+        return stackbitModels.concat(stackbitModel, blockModels);
+    }, []);
+    const modelMap = _.keyBy(models, 'name');
+    const clonedModels = modelsToClone.map((options): ModelWithContext => {
+        const model = modelMap[options.origModelUID];
+        if (!model) {
+            throw new Error(`could not clone model, model ${options.origModelUID} not found`);
+        }
+        return {
+            ...model,
+            name: options.newModelName,
+            label: options.label,
+            context: _.omitBy(
+                {
+                    clonedFromModel: options.origModelUID,
+                    referencedIn: options.referencedIn
+                },
+                _.isNil
+            )
+        };
+    });
+    const linkModel: ModelWithContext = {
+        type: 'object',
+        name: 'CNTSTK_LINK_MODEL',
+        label: 'Link',
+        fields: [
+            { type: 'string', name: 'title', label: 'Title', default: '' },
+            { type: 'string', name: 'href', label: 'URL', default: '' }
+        ]
+    };
+    return [...models, ...clonedModels, linkModel];
+}
+
+function convertModel({
+    contentStackModel,
+    addBlockModel,
+    cloneModel,
+    referencedIn
+}: {
+    contentStackModel: ContentType | GlobalField;
+    addBlockModel: AddBlockModel;
+    cloneModel: CloneModel;
+    referencedIn?: ReferencedIn;
+}): ModelWithContext {
+    const blockMap: BlockMap = {};
+    const isContentType = 'options' in contentStackModel;
+    return {
+        type: isContentType ? (contentStackModel.options?.is_page ? 'page' : 'data') : 'object',
+        name: contentStackModel.uid,
+        label: contentStackModel.title,
+        ...(_.isEmpty(contentStackModel.description) ? null : { description: contentStackModel.description }),
+        ...(isContentType ? { labelField: 'title' } : null),
+        ...(isContentType && contentStackModel.options?.singleton ? { singleInstance: true } : null),
+        fields: convertFields({
+            contentStackFields: contentStackModel.schema,
+            parentModelName: contentStackModel.uid,
+            isNested: !!referencedIn,
+            fieldPath: [],
+            addBlockMap: ({ blockFieldPath, modelName, blockUID }) => {
+                if (!blockMap[blockFieldPath]) {
+                    blockMap[blockFieldPath] = {
+                        modelNameToBlockId: {},
+                        blockIdToModelName: {}
+                    };
+                }
+                blockMap[blockFieldPath]!.modelNameToBlockId[modelName] = blockUID;
+                blockMap[blockFieldPath]!.blockIdToModelName[blockUID] = modelName;
+            },
+            addBlockModel,
+            cloneModel
+        }),
+        context: _.omitBy(
+            {
+                ...(_.isEmpty(blockMap) ? null : { blockMap }),
+                referencedIn
+            },
+            _.isNil
+        )
+    };
+}
+
+function convertFields(options: {
+    contentStackFields: ContentStackField[];
+    parentModelName: string;
+    isNested: boolean;
+    fieldPath: string[];
+    addBlockMap: AddBlockMap;
+    addBlockModel: AddBlockModel;
+    cloneModel: CloneModel;
+}): StackbitTypes.Field[] {
+    const { contentStackFields, fieldPath, ...rest } = options;
+    return contentStackFields.map((field) =>
+        convertField({
+            field,
+            fieldPath: fieldPath.concat(field.uid),
+            ...rest
+        })
+    );
+}
+
+function convertField({
+    field,
+    parentModelName,
+    isNested,
+    fieldPath,
+    addBlockMap,
+    addBlockModel,
+    cloneModel
+}: {
+    field: ContentStackField;
+    parentModelName: string;
+    isNested: boolean;
+    fieldPath: string[];
+    addBlockMap: AddBlockMap;
+    addBlockModel: AddBlockModel;
+    cloneModel: CloneModel;
+}): StackbitTypes.Field {
+    switch (field.data_type) {
+        case 'text': {
+            if (field.field_metadata?.multiline) {
+                return toFieldOrListField(field, {
+                    type: 'text'
+                });
+            } else if (field.field_metadata?.markdown) {
+                return toFieldOrListField(field, {
+                    type: 'markdown'
+                });
+            } else if (field.field_metadata?.allow_rich_text) {
+                return toFieldOrListField(field, {
+                    // Stackbit doesn't support HTML editor
+                    // type: 'html'
+                    type: 'text'
+                });
+            } else if (field.enum) {
+                return toEnumField(field as StackbitTypes.RequiredBy<ContenteStackFieldText, 'enum'>);
+            } else if (field.uid === 'slug' || (field.uid === 'url' && field.field_metadata?._default === true)) {
+                return toFieldOrListField(field, {
+                    type: 'slug'
+                });
+            } else {
+                return toFieldOrListField(field, {
+                    type: 'string'
+                });
+            }
+        }
+
+        case 'boolean':
+            return toFieldOrListField(field, {
+                type: 'boolean'
+            });
+
+        case 'json':
+            if (field.field_metadata?.allow_json_rte) {
+                return toFieldOrListField(field, {
+                    type: 'richText'
+                });
+            }
+            return toFieldOrListField(field, {
+                type: 'json'
+            });
+
+        case 'file':
+            return toFieldOrListField(field, {
+                type: field.field_metadata?.image ? 'image' : 'file'
+            });
+
+        case 'isodate': {
+            const fieldType = field.field_metadata?.hide_time ? 'date' : 'datetime';
+            return toFieldOrListField(
+                field,
+                {
+                    type: fieldType
+                },
+                (defaultValue: ContentStackFieldDate['field_metadata']['default_value']) => {
+                    if (defaultValue?.custom && defaultValue?.date) {
+                        if (fieldType === 'datetime' && defaultValue?.time) {
+                            return new Date(`${defaultValue?.date}T${defaultValue?.time}`).toISOString();
+                        } else {
+                            return defaultValue?.date;
+                        }
+                    }
+                    return undefined;
+                }
+            );
+        }
+        case 'number': {
+            if (field.enum) {
+                return toEnumField(field as StackbitTypes.RequiredBy<ContentStackFieldNumber, 'enum'>);
+            }
+            const min = !_.isNil(field.min) ? { min: field.min } : null;
+            const max = !_.isNil(field.max) ? { max: field.max } : null;
+            return toFieldOrListField(field, {
+                type: 'number',
+                ...min,
+                ...max
+            });
+        }
+
+        case 'link': {
+            return toFieldOrListField(
+                field,
+                {
+                    type: 'model',
+                    models: ['CNTSTK_LINK_MODEL']
+                },
+                (value: any): any => {
+                    // rewrite url property to href
+                    if (!value) {
+                        return value;
+                    }
+                    const { url, ...rest } = value;
+                    return {
+                        ...rest,
+                        href: url
+                    };
+                }
+            );
+        }
+
+        case 'group': {
+            return toFieldOrListField(field, {
+                type: 'object',
+                fields: convertFields({
+                    contentStackFields: field.schema,
+                    parentModelName: parentModelName,
+                    isNested,
+                    fieldPath,
+                    addBlockMap,
+                    addBlockModel,
+                    cloneModel
+                })
+            });
+        }
+
+        case 'global_field': {
+            // ContentStack global fields can only reference one model
+            return toFieldOrListField(field, {
+                type: 'model',
+                models: field.reference_to ? [field.reference_to] : []
+            });
+        }
+
+        case 'reference': {
+            // in reference fields, the "field_metadata.ref_multiple" is responsible for marking the field as list, not "multiple".
+            return toFieldOrListField(field, {
+                type: 'reference',
+                models: field.reference_to || []
+            });
+        }
+
+        case 'blocks': {
+            const commonProps = getStackbitFieldPropsFromContentStackField(field, true);
+            // blocks, are always lists
+            const referencedModelCountMap: Record<string, number> = {};
+            return {
+                type: 'list',
+                ...commonProps,
+                items: {
+                    type: 'model',
+                    models: field.blocks.map((block) => {
+                        const modelName = `${isNested ? '' : 'BLOCK_'}${parentModelName}__${fieldPath.length ? fieldPath.join('.') + '__' : ''}${block.uid}`;
+                        if ('schema' in block) {
+                            const contentStackModel = {
+                                uid: modelName,
+                                title: block.title,
+                                schema: block.schema
+                            } as GlobalField;
+                            const blockModel = convertModel({
+                                contentStackModel,
+                                addBlockModel,
+                                cloneModel,
+                                referencedIn: {
+                                    modelName: parentModelName,
+                                    fieldPath: fieldPath.join('.'),
+                                    blockUID: block.uid
+                                }
+                            });
+                            addBlockModel(blockModel);
+                            addBlockMap({ blockFieldPath: fieldPath.join('.'), modelName, blockUID: block.uid });
+                            return modelName;
+                        } else if ('reference_to' in block) {
+                            // Blocks can reference the same global field in different blocks (with different uid)
+                            // If the referenced global field (object model) is defined only in one block,
+                            // then don't create a new model and reuse the referenced model. Add a map entry between
+                            // the block's uid and the model's name, so when a new object is added to this field,
+                            // we will know to which block uid to assign.
+                            if (typeof referencedModelCountMap[block.reference_to] === 'undefined') {
+                                referencedModelCountMap[block.reference_to] = 1;
+                            } else {
+                                referencedModelCountMap[block.reference_to] += 1;
+                            }
+                            if (referencedModelCountMap[block.reference_to] === 1) {
+                                addBlockMap({ blockFieldPath: fieldPath.join('.'), modelName: block.reference_to, blockUID: block.uid });
+                                return block.reference_to;
+                            } else {
+                                // If the referenced global field is used more than once, then create a new model
+                                // by cloning the original model and ad a mao entry between the block's uid and the
+                                // cloned model name.
+                                cloneModel({
+                                    origModelUID: block.reference_to,
+                                    newModelName: modelName,
+                                    label: block.title,
+                                    referencedIn: {
+                                        modelName: parentModelName,
+                                        fieldPath: fieldPath.join('.'),
+                                        blockUID: block.uid
+                                    }
+                                });
+                                addBlockMap({ blockFieldPath: fieldPath.join('.'), modelName, blockUID: block.uid });
+                                return modelName;
+                            }
+                        } else {
+                            throw new Error(`block doesn't have 'schema' nor 'reference_to'`);
+                        }
+                    })
+                }
+            };
+        }
+        default: {
+            const _exhaustiveCheck: never = field;
+            return _exhaustiveCheck;
+        }
+    }
+}
+
+function toEnumField(
+    field: StackbitTypes.RequiredBy<ContenteStackFieldText, 'enum'> | StackbitTypes.RequiredBy<ContentStackFieldNumber, 'enum'>
+): StackbitTypes.Field {
+    const isList = field.multiple;
+    const commonProps = getStackbitFieldPropsFromContentStackField(field, isList);
+    const options: StackbitTypes.FieldEnumOptionValue[] | StackbitTypes.FieldEnumOptionObject[] = field.enum.advanced
+        ? field.enum.choices.map((choice) => ({ label: choice.key, value: choice.value }))
+        : field.enum.choices.map((choice) => choice.value);
+    if (isList) {
+        return {
+            type: 'list',
+            ...commonProps,
+            ...(field.display_type === 'checkbox' ? { controlType: 'checkbox' } : null),
+            items: {
+                type: 'enum',
+                options
+            }
+        };
+    } else {
+        return {
+            type: 'enum',
+            ...commonProps,
+            controlType: field.display_type === 'radio' ? 'button-group' : 'dropdown',
+            options: options
+        };
+    }
+}
+
+function toFieldOrListField(
+    field: ContentStackField,
+    fieldSpecificProps: Exclude<StackbitTypes.FieldSpecificProps, StackbitTypes.FieldStyleProps | StackbitTypes.FieldListProps>,
+    resolveDefault?: (value: unknown) => unknown
+): Exclude<StackbitTypes.Field, StackbitTypes.FieldStyle> {
+    // In reference fields, the "field_metadata.ref_multiple" is responsible for marking the field as list, not "multiple".
+    const isList = field.data_type === 'reference' ? field.field_metadata?.ref_multiple : field.multiple;
+    // In lists resolve defaults to a list with a single value
+    const commonProps = getStackbitFieldPropsFromContentStackField(field, isList, resolveDefault);
+    if (isList) {
+        return {
+            type: 'list',
+            ...commonProps,
+            items: fieldSpecificProps
+        };
+    }
+    return {
+        ...fieldSpecificProps,
+        ...commonProps
+    };
+}
+
+function getStackbitFieldPropsFromContentStackField(
+    field: ContentStackField,
+    isList: boolean,
+    resolveDefault?: (value: unknown) => unknown
+): {
+    name: string;
+    label?: string;
+    description?: string;
+    required?: boolean;
+    default?: any;
+} {
+    const description = field.field_metadata?.description;
+    const defaultValue = field.field_metadata?.default_value;
+    const resolvedDefault = defaultValue === null || defaultValue === '' ? undefined : resolveDefault ? resolveDefault(defaultValue) : defaultValue;
+    return {
+        name: field.uid,
+        label: field.display_name,
+        ..._.omitBy(
+            {
+                description: description || undefined,
+                required: field.mandatory || undefined,
+                default: !_.isNil(resolvedDefault) && isList ? [resolvedDefault] : resolvedDefault
+            },
+            _.isNil
+        )
+    };
+}