@stackbit/cms-contentstack 0.1.1-staging.0

package/src/contentstack-entries-converter.ts

@@ -0,0 +1,438 @@
+import _ from 'lodash';
+import * as StackbitTypes from '@stackbit/types';
+import { getAssetUrl, getEntryUrl } from './contentstack-utils';
+import type { Entry, Asset, Environment, User } from './contentstack-types';
+import type { ModelWithContext } from './contentstack-schema-converter';
+
+export type DocumentWithContext = StackbitTypes.Document<DocumentContext>;
+export type DocumentContext = unknown;
+export type AssetWithContext = StackbitTypes.Asset<AssetContext>;
+export type AssetContext = unknown;
+
+type GetModelByName = (modelName: string) => ModelWithContext | undefined;
+
+export function convertEntries(options: {
+    entries: Entry[];
+    apiKey: string;
+    getModelByName: GetModelByName;
+    usersById: Record<string, User>;
+    publishEnvironment: Environment;
+    logger: StackbitTypes.Logger;
+}): DocumentWithContext[] {
+    const { entries, ...rest } = options;
+    return entries.map((entry) =>
+        convertEntry({
+            entry,
+            ...rest
+        })
+    );
+}
+
+export function convertEntry({
+    entry,
+    apiKey,
+    getModelByName,
+    usersById,
+    publishEnvironment,
+    status,
+    logger
+}: {
+    entry: Entry;
+    apiKey: string;
+    getModelByName: GetModelByName;
+    usersById: Record<string, User>;
+    publishEnvironment: Environment;
+    status?: StackbitTypes.DocumentStatus;
+    logger: StackbitTypes.Logger;
+}): DocumentWithContext {
+    const model = getModelByName(entry.content_type_uid);
+    if (!model) {
+        throw new Error(`error converting an entry, model '${entry.content_type_uid}' not found`);
+    }
+    return {
+        type: 'document',
+        id: entry.uid,
+        manageUrl: getEntryUrl({ apiKey, entry }),
+        modelName: entry.content_type_uid,
+        status: status ?? getEntryPublishStatus(entry, publishEnvironment),
+        createdAt: entry.created_at,
+        updatedAt: entry.updated_at,
+        ...getEntityCreatedAndUpdatedBy(usersById, entry),
+        locale: entry.locale,
+        context: {},
+        fields: convertFields({
+            entry,
+            modelFields: model.fields ?? [],
+            rootEntry: entry,
+            rootModel: model,
+            entryFieldPath: [],
+            modelFieldPath: [],
+            getModelByName,
+            logger
+        })
+    };
+}
+
+function convertFields({
+    entry,
+    modelFields,
+    rootEntry,
+    rootModel,
+    entryFieldPath,
+    modelFieldPath,
+    getModelByName,
+    logger
+}: {
+    entry: Record<string, unknown>;
+    modelFields: StackbitTypes.Field[];
+    rootEntry: Entry;
+    rootModel: ModelWithContext;
+    entryFieldPath: (string | number)[];
+    modelFieldPath: string[];
+    getModelByName: GetModelByName;
+    logger: StackbitTypes.Logger;
+}): Record<string, StackbitTypes.DocumentField> {
+    const modelFieldsByName = _.keyBy(modelFields, 'name');
+    return _.entries(entry).reduce((documentFields: Record<string, StackbitTypes.DocumentField>, [fieldName, fieldValue]) => {
+        const modelField = modelFieldsByName[fieldName];
+        if (!modelField) {
+            return documentFields;
+        }
+        const documentField = convertField({
+            fieldValue: fieldValue,
+            modelField: modelField,
+            rootEntry: rootEntry,
+            rootModel: rootModel,
+            entryFieldPath: entryFieldPath.concat(fieldName),
+            modelFieldPath: modelFieldPath.concat(fieldName),
+            getModelByName,
+            logger
+        });
+        if (typeof documentField !== 'undefined') {
+            documentFields[fieldName] = documentField;
+        }
+        return documentFields;
+    }, {});
+}
+
+type ConvertFieldOptions<ModelField extends StackbitTypes.Field | StackbitTypes.FieldListItems> = {
+    fieldValue: unknown;
+    modelField: ModelField;
+    rootEntry: Entry;
+    rootModel: ModelWithContext;
+    entryFieldPath: (string | number)[];
+    modelFieldPath: string[];
+    getModelByName: GetModelByName;
+    logger: StackbitTypes.Logger;
+};
+function convertField(options: ConvertFieldOptions<StackbitTypes.Field>): StackbitTypes.DocumentField | undefined;
+function convertField(options: ConvertFieldOptions<StackbitTypes.FieldListItems>): StackbitTypes.DocumentListFieldItems | undefined;
+function convertField<ModelField extends StackbitTypes.Field | StackbitTypes.FieldListItems>({
+    fieldValue,
+    modelField,
+    rootEntry,
+    rootModel,
+    entryFieldPath,
+    modelFieldPath,
+    getModelByName,
+    logger
+}: {
+    fieldValue: unknown;
+    modelField: ModelField;
+    rootEntry: Entry;
+    rootModel: ModelWithContext;
+    entryFieldPath: (string | number)[];
+    modelFieldPath: string[];
+    getModelByName: GetModelByName;
+    logger: StackbitTypes.Logger;
+}): StackbitTypes.DocumentField | StackbitTypes.DocumentListFieldItems | undefined {
+    if (_.isNil(fieldValue) || fieldValue === '') {
+        return;
+    }
+
+    const errorPrefix = `Error occurred while converting entry '${rootEntry.uid}'.`;
+
+    switch (modelField.type) {
+        case 'string':
+        case 'url':
+        case 'slug':
+        case 'text':
+        case 'markdown':
+        case 'html':
+        case 'date':
+        case 'datetime':
+        case 'color':
+        case 'enum':
+            return {
+                type: modelField.type,
+                value: fieldValue as string
+            };
+        case 'number':
+        case 'boolean':
+        case 'json':
+            return {
+                type: modelField.type,
+                value: fieldValue as any
+            };
+        case 'richText':
+            return {
+                type: modelField.type,
+                value: fieldValue
+            };
+        case 'image':
+            if (!isObject(fieldValue) || typeof fieldValue.uid !== 'string') {
+                return;
+            }
+            return {
+                type: 'reference',
+                refType: 'asset',
+                refId: fieldValue.uid
+            };
+        case 'file':
+            if (!isObject(fieldValue) || typeof fieldValue.uid !== 'string') {
+                return;
+            }
+            return {
+                type: 'file',
+                value: fieldValue.uid
+            };
+        case 'reference':
+            // references fields always returned as arrays, even if they are not marked as multiple
+            if (Array.isArray(fieldValue) && fieldValue.length === 1) {
+                fieldValue = fieldValue[0];
+            }
+            if (!isObject(fieldValue) || typeof fieldValue.uid !== 'string') {
+                return;
+            }
+            return {
+                type: 'reference',
+                refType: 'document',
+                refId: fieldValue.uid
+            };
+        case 'object': {
+            if (!isObject(fieldValue)) {
+                logger.warn(`${errorPrefix} The value of a group field at field path ${entryFieldPath.join('.')} is not an object.`);
+                return;
+            }
+            return {
+                type: 'object',
+                fields: convertFields({
+                    entry: fieldValue,
+                    modelFields: modelField.fields,
+                    rootEntry,
+                    rootModel,
+                    modelFieldPath,
+                    entryFieldPath,
+                    getModelByName,
+                    logger
+                })
+            };
+        }
+        case 'model': {
+            const fieldPathStr = modelFieldPath.join('.');
+            const blockMap = rootModel.context?.blockMap?.[fieldPathStr];
+            if (blockMap) {
+                // this is a modular blocks field with keys mapping to inline (object) or global (model) fields
+                // mapped by context.blockMap[blockUID]
+                if (!isObject(fieldValue)) {
+                    logger.warn(`${errorPrefix} The value of a modular block at field path ${entryFieldPath.join('.')} is not an object.`);
+                    return;
+                }
+                // The fieldValue must be an object with a single property matching the block uid
+                const blockUIDs = _.keys(fieldValue);
+                const blockUID = blockUIDs[0];
+                if (blockUIDs.length !== 1 || !blockUID) {
+                    logger.warn(
+                        `${errorPrefix} The object wrapping a modular block at field path ${entryFieldPath.join('.')} ` +
+                            `does not have a modular block uid property.`
+                    );
+                    return;
+                }
+                const nestedEntry = fieldValue[blockUID];
+                if (!isObject(nestedEntry)) {
+                    return;
+                }
+                const modelName = blockMap.blockIdToModelName[blockUID];
+                if (!modelName) {
+                    logger.warn(`${errorPrefix} Could not match model name for modular block '${blockUID}' at field path ${entryFieldPath.join('.')}.`);
+                    return;
+                }
+                const nestedModel = getModelByName(modelName);
+                if (!nestedModel) {
+                    logger.warn(
+                        `${errorPrefix} Could not find model named '${modelName}' for modular block '${blockUID}' at field path ${entryFieldPath.join('.')}.`
+                    );
+                    return;
+                }
+                return {
+                    type: 'model',
+                    modelName: modelName,
+                    fields: convertFields({
+                        entry: nestedEntry,
+                        modelFields: nestedModel.fields ?? [],
+                        rootEntry,
+                        rootModel: nestedModel,
+                        entryFieldPath: entryFieldPath.concat(blockUID),
+                        modelFieldPath: [],
+                        getModelByName,
+                        logger
+                    })
+                };
+            } else {
+                // this is as a regular global field (model) with a single model or as a CNTSTK_LINK_MODEL
+                if (modelField.models.length !== 1) {
+                    logger.warn(`${errorPrefix} The global field at field path ${entryFieldPath.join('.')} has more than one model name.`);
+                    return;
+                }
+                const modelName = modelField.models[0]!;
+                const nestedModel = getModelByName(modelName);
+                if (!nestedModel) {
+                    logger.warn(`${errorPrefix} Could not find model named '${modelName}' for global field at field path ${entryFieldPath.join('.')}.`);
+                    return;
+                }
+                if (!isObject(fieldValue)) {
+                    logger.warn(`${errorPrefix} The value of a global field at field path ${entryFieldPath.join('.')} is not an object.`);
+                    return;
+                }
+                return {
+                    type: 'model',
+                    modelName: modelName,
+                    fields: convertFields({
+                        entry: fieldValue,
+                        modelFields: nestedModel.fields ?? [],
+                        rootEntry,
+                        rootModel: nestedModel,
+                        entryFieldPath: entryFieldPath,
+                        modelFieldPath: [],
+                        getModelByName,
+                        logger
+                    })
+                };
+            }
+        }
+        case 'list': {
+            if (!Array.isArray(fieldValue)) {
+                logger.warn(`${errorPrefix} The value of a list field at field path ${entryFieldPath.join('.')} is not an array.`);
+                return;
+            }
+            return {
+                type: 'list',
+                items: _.reduce(
+                    fieldValue,
+                    (documentListFieldItems: StackbitTypes.DocumentListFieldItems[], value, index) => {
+                        const documentListFieldItem = convertField({
+                            fieldValue: value,
+                            modelField: modelField.items,
+                            rootEntry,
+                            rootModel,
+                            entryFieldPath: entryFieldPath.concat(index),
+                            modelFieldPath,
+                            getModelByName,
+                            logger
+                        });
+                        if (!documentListFieldItem) {
+                            logger.debug(
+                                `${errorPrefix} One of the items of a list at field path ${entryFieldPath.join('.')} ` +
+                                    `could not be converted, skipping the whole list field.`
+                            );
+                            return documentListFieldItems;
+                        }
+                        return documentListFieldItems.concat(documentListFieldItem);
+                    },
+                    []
+                )
+            };
+        }
+        case 'cross-reference':
+        case 'style':
+            logger.warn(`${errorPrefix} Field type ${modelField.type} at field path ${entryFieldPath.join('.')}.`);
+            return;
+        default: {
+            const _exhaustiveCheck: never = modelField;
+            return _exhaustiveCheck;
+        }
+    }
+}
+
+export function convertAssets(options: {
+    assets: Asset[];
+    apiKey: string;
+    usersById: Record<string, User>;
+    publishEnvironment: Environment;
+}): AssetWithContext[] {
+    const { assets, ...rest } = options;
+    return assets.map((asset) => convertAsset({ asset, ...rest }));
+}
+
+export function convertAsset({
+    asset,
+    apiKey,
+    usersById,
+    publishEnvironment
+}: {
+    asset: Asset;
+    apiKey: string;
+    usersById: Record<string, User>;
+    publishEnvironment: Environment;
+}): AssetWithContext {
+    return {
+        type: 'asset',
+        id: asset.uid,
+        manageUrl: getAssetUrl({ apiKey, asset }),
+        status: getAssetPublishStatus(asset, publishEnvironment),
+        createdAt: asset.created_at,
+        updatedAt: asset.updated_at,
+        ...getEntityCreatedAndUpdatedBy(usersById, asset),
+        context: {},
+        fields: {
+            title: {
+                type: 'string',
+                value: asset.title ?? asset.filename ?? ''
+            },
+            file: {
+                type: 'assetFile',
+                url: asset.url!,
+                fileName: asset.filename,
+                contentType: asset.content_type,
+                size: Number(asset.file_size)
+            }
+        }
+    };
+}
+
+function getEntryPublishStatus(entry: Entry, publishEnvironment: Environment): StackbitTypes.DocumentStatus {
+    // Get the publish that matches the publish environment and the entry's locale
+    const publishDetailsForEnv = _.filter(entry.publish_details, _.matchesProperty('environment', publishEnvironment.uid));
+    const publishForLocale = _.find(publishDetailsForEnv, _.matchesProperty('locale', entry.locale));
+    if (publishForLocale) {
+        return entry._version === publishForLocale.version ? 'published' : 'modified';
+    }
+    return 'added';
+}
+
+function getAssetPublishStatus(asset: Asset, publishEnvironment: Environment): StackbitTypes.DocumentStatus {
+    // Get the publish that matches the publish environment and the asset's locale
+    const publishDetailsForEnv = _.filter(asset.publish_details, _.matchesProperty('environment', publishEnvironment.uid));
+    if (publishDetailsForEnv?.length === 1) {
+        const publish = publishDetailsForEnv[0]!;
+        return asset._version === publish.version ? 'published' : 'modified';
+    }
+    return 'added';
+}
+
+function getEntityCreatedAndUpdatedBy(usersById: Record<string, User>, entity: Entry | Asset) {
+    const result: { createdBy?: string; updatedBy?: string[] } = {};
+    const createdBy = usersById[entity.created_by];
+    if (createdBy && createdBy.email) {
+        result.createdBy = createdBy.email;
+    }
+    const updatedBy = usersById[entity.updated_by];
+    if (updatedBy && updatedBy.email) {
+        result.updatedBy = [updatedBy.email];
+    }
+    return result;
+}
+
+function isObject(value: unknown): value is Record<string, unknown> {
+    return _.isPlainObject(value);
+}