@stackbit/cms-contentstack 0.1.1-staging.0

package/src/contentstack-operation-converter.ts

@@ -0,0 +1,703 @@
+import { v4 as uuidv4 } from 'uuid';
+import _ from 'lodash';
+import * as StackbitTypes from '@stackbit/types';
+import type { EntryData } from '@contentstack/management/types/stack/contentType/entry';
+import type { Entry, Asset } from './contentstack-types';
+import type { ModelWithContext } from './contentstack-schema-converter';
+import type { DocumentWithContext } from './contentstack-entries-converter';
+
+type GetModelByName = (modelName: string) => ModelWithContext | undefined;
+type GetDocumentById = (documentId: string) => DocumentWithContext | undefined;
+
+export function createEntryFromOperationFields({
+    updateOperationFields,
+    model,
+    getDocumentById,
+    getModelByName,
+    logger
+}: {
+    updateOperationFields: Record<string, StackbitTypes.UpdateOperationField>;
+    model: ModelWithContext;
+    getDocumentById: GetDocumentById;
+    getModelByName: GetModelByName;
+    logger: StackbitTypes.Logger;
+}): EntryData {
+    return _.reduce(
+        updateOperationFields,
+        (accum: EntryData, updateOperationField, fieldName) => {
+            const modelField = getModelField(model, fieldName);
+            if (!modelField) {
+                return accum;
+            }
+            accum[fieldName] = convertOperationFieldValue({
+                updateOperationField,
+                modelField,
+                isInList: false,
+                rootModel: model,
+                entryFieldPath: [fieldName],
+                modelFieldPath: [fieldName],
+                getDocumentById,
+                getModelByName,
+                errorPrefix: 'Error occurred while creating an entry.'
+            });
+            return accum;
+        },
+        { title: uuidv4() }
+    );
+}
+
+export function updateEntryFromUpdateOperations({
+    entry,
+    updateOperations,
+    getDocumentById,
+    getModelByName,
+    logger
+}: {
+    entry: Entry;
+    updateOperations: StackbitTypes.UpdateOperation[];
+    getDocumentById: GetDocumentById;
+    getModelByName: GetModelByName;
+    logger: StackbitTypes.Logger;
+}): Entry {
+    const model = getModelByName(entry.content_type_uid);
+    if (!model) {
+        throw new Error(`Error occurred while updating entry ${entry.uid}, model ${entry.content_type_uid} not found.`);
+    }
+
+    let updatedEntry = _.reduce(
+        updateOperations,
+        (entry: Entry, updateOperation) => {
+            return getUpdatedEntryAtFieldPathWithOperation({
+                entry,
+                updateOperation,
+                model,
+                getDocumentById,
+                getModelByName,
+                logger
+            });
+        },
+        entry
+    );
+
+    // Create a copy of the entry and remove fields that were not updated.
+    const modelFieldsMap = _.keyBy(model.fields, 'name');
+    const updatedRootFieldNames = updateOperations.reduce((fieldNamesMap, updateOperations) => {
+        fieldNamesMap[updateOperations.fieldPath[0] as string] = true;
+        return fieldNamesMap;
+    }, {} as Record<string, boolean>);
+    // const includedMetaProps = _.transform(
+    //     ['uid', 'stackHeaders', 'content_type_uid', 'taxonomy_uid', 'locale', '_version', 'urlPath'],
+    //     (map, value) => {
+    //         map[value] = true;
+    //     },
+    //     {} as Record<string, boolean>
+    // );
+    updatedEntry = _.reduce(
+        updatedEntry,
+        (newEntry, value, prop) => {
+            if (!modelFieldsMap[prop] || updatedRootFieldNames[prop]) {
+                newEntry[prop] = value;
+            }
+            return newEntry;
+        },
+        {} as Entry
+    );
+
+    return sanitizeForUpdate(updatedEntry);
+}
+
+export function getUpdatedEntryAtFieldPathWithOperation({
+    entry,
+    updateOperation,
+    model,
+    getDocumentById,
+    getModelByName,
+    logger
+}: {
+    entry: Entry;
+    updateOperation: StackbitTypes.UpdateOperation;
+    model: ModelWithContext;
+    getDocumentById: GetDocumentById;
+    getModelByName: GetModelByName;
+    logger: StackbitTypes.Logger;
+}): Entry {
+    let opMessage: string;
+    switch (updateOperation.opType) {
+        case 'set':
+            opMessage = 'setting a field';
+            break;
+        case 'unset':
+            opMessage = 'unsetting a field';
+            break;
+        case 'insert':
+            opMessage = 'inserting an item into a list';
+            break;
+        case 'remove':
+            opMessage = 'removing an item from a list';
+            break;
+        case 'reorder':
+            opMessage = 'reordering a list';
+            break;
+    }
+    const errorPrefix = `Error occurred while ${opMessage} in entry '${entry.uid}'.`;
+
+    function createError(detailedMessage: string) {
+        return new Error(`${errorPrefix} ${detailedMessage}`);
+    }
+
+    function iterateModel<Type extends Record<string, unknown>>({
+        value,
+        model,
+        fieldPath,
+        entryFieldPath,
+        modelFieldPath
+    }: {
+        value?: Type;
+        model: ModelWithContext;
+        fieldPath: (number | string)[];
+        entryFieldPath: (string | number)[];
+        modelFieldPath: string[];
+    }): Type {
+        if (fieldPath.length === 0) {
+            return getValueForOperation({
+                updateOperation,
+                value,
+                rootEntry: entry,
+                rootModel: model,
+                entryFieldPath,
+                modelFieldPath,
+                getDocumentById,
+                getModelByName,
+                errorPrefix,
+                logger
+            });
+        }
+        const fieldName = _.head(fieldPath)!;
+        const fieldPathTail = _.tail(fieldPath);
+        if (typeof fieldName !== 'string') {
+            throw createError(
+                `The field '${fieldName}' in field path '${entryFieldPath.concat(fieldName).join('.')}' ` +
+                    `is not a string, 'typeof ${fieldName} === ${typeof fieldName}'.`
+            );
+        }
+        const modelField = getModelField(model, fieldName);
+        if (!modelField) {
+            throw createError(
+                `The field '${fieldName}' in field path '${entryFieldPath.concat(fieldName).join('.')}' does not exist in model '${model.name}'.`
+            );
+        }
+        return {
+            ...value,
+            [fieldName]: iterateField({
+                value: value ? value[fieldName] : undefined,
+                modelField,
+                fieldPath: fieldPathTail,
+                rootModel: model,
+                entryFieldPath: entryFieldPath.concat(fieldName),
+                modelFieldPath: modelFieldPath.concat(fieldName)
+            })
+        } as Type;
+    }
+
+    function iterateField({
+        value,
+        modelField,
+        fieldPath,
+        rootModel,
+        entryFieldPath,
+        modelFieldPath
+    }: {
+        value?: unknown;
+        modelField: StackbitTypes.FieldSpecificProps;
+        fieldPath: (number | string)[];
+        rootModel: ModelWithContext;
+        entryFieldPath: (string | number)[];
+        modelFieldPath: string[];
+    }): unknown {
+        if (fieldPath.length === 0) {
+            return getValueForOperation({
+                updateOperation,
+                value,
+                rootEntry: entry,
+                rootModel,
+                entryFieldPath,
+                modelFieldPath,
+                getDocumentById,
+                getModelByName,
+                errorPrefix,
+                logger
+            });
+        }
+
+        if (modelField.type === 'object') {
+            // The value must be an object to apply the operation on its nested field with name fieldName,
+            // otherwise the fieldPath is illegal
+            if (!isObject(value)) {
+                throw createError(`The field path '${entryFieldPath.join('.')}' points to an empty value.`);
+            }
+            const fieldName = _.head(fieldPath)!;
+            const fieldPathTail = _.tail(fieldPath);
+            if (typeof fieldName !== 'string') {
+                throw createError(
+                    `The field '${fieldName}' in field path '${entryFieldPath.concat(fieldName).join('.')}' ` +
+                        `is not a string, 'typeof ${fieldName} === ${typeof fieldName}'.`
+                );
+            }
+            const childModelField = getModelField(modelField, fieldName);
+            if (!childModelField) {
+                throw createError(
+                    `The field '${fieldName}' in field path '${entryFieldPath.concat(fieldName).join('.')}' does not exist in model '${model.name}'.`
+                );
+            }
+            return {
+                ...value,
+                [fieldName]: iterateField({
+                    value: value ? value[fieldName] : undefined,
+                    modelField: childModelField,
+                    fieldPath: fieldPathTail,
+                    rootModel,
+                    entryFieldPath: entryFieldPath.concat(fieldName),
+                    modelFieldPath: modelFieldPath.concat(fieldName)
+                })
+            };
+        } else if (modelField.type === 'model') {
+            // The value must be an object to apply the operation on its nested field with name fieldName,
+            // otherwise the fieldPath is illegal
+            if (!isObject(value)) {
+                throw createError(`The field path '${entryFieldPath.join('.')}' points to an empty value.`);
+            }
+            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 model.context.blockMap[blockUID].
+                const blockUIDs = _.keys(value);
+                const blockUID = blockUIDs[0];
+                if (blockUIDs.length !== 1 || !blockUID) {
+                    throw createError(`The modular block at field path '${entryFieldPath.join('.')}' has no UID.`);
+                }
+                const block = value[blockUID];
+                if (!isObject(block)) {
+                    throw createError(`The field path '${entryFieldPath.join('.')}' points to an empty modular block '${blockUID}'.`);
+                }
+                const modelName = blockMap.blockIdToModelName[blockUID];
+                if (!modelName) {
+                    throw createError(`Could not match model name for modular block '${blockUID}' at field path '${entryFieldPath.join('.')}'.`);
+                }
+                const nestedModel = getModelByName(modelName);
+                if (!nestedModel) {
+                    throw createError(
+                        `Could not find model named '${modelName}' for modular block '${blockUID}' ` + `at field path '${entryFieldPath.join('.')}'.`
+                    );
+                }
+                return {
+                    [blockUID]: iterateModel({
+                        value: block,
+                        fieldPath: fieldPath,
+                        model: nestedModel,
+                        entryFieldPath: entryFieldPath,
+                        modelFieldPath: []
+                    })
+                };
+            } else {
+                // This is as a regular global field (model) with a single model or as a CNTSTK_LINK_MODEL
+                if (modelField.models.length !== 1) {
+                    throw createError(
+                        `A model field at field path '${entryFieldPath.join('.')}' has more than one (or zero) models ${modelField.models.join('.')}.`
+                    );
+                }
+                const modelName = modelField.models[0]!;
+                const nestedModel = getModelByName(modelName);
+                if (!nestedModel) {
+                    throw createError(`Could not find model named '${modelName}' for object at field path '${entryFieldPath.join('.')}.'`);
+                }
+                return iterateModel({
+                    value: value,
+                    fieldPath: fieldPath,
+                    model: nestedModel,
+                    entryFieldPath: entryFieldPath,
+                    modelFieldPath: []
+                });
+            }
+        } else if (modelField.type === 'list') {
+            // The value must be an array to apply the operation on its nested items with item index,
+            // otherwise the fieldPath is illegal
+            if (!Array.isArray(value)) {
+                throw createError(`The value at field path '${entryFieldPath.join('.')}' is not an array.`);
+            }
+            const fieldName = _.head(fieldPath)!;
+            const fieldPathTail = _.tail(fieldPath);
+            const index = _.toNumber(fieldName);
+            if (typeof index !== 'number' || _.isNaN(index)) {
+                throw createError(
+                    `The field '${fieldName}' in field path '${entryFieldPath.concat(fieldName).join('.')}' ` +
+                        `is not a string, 'typeof ${fieldName} === ${typeof fieldName}'.`
+                );
+            }
+            const newArray = value.slice();
+            newArray.splice(
+                index,
+                1,
+                iterateField({
+                    value: value[index],
+                    fieldPath: fieldPathTail,
+                    modelField: modelField.items,
+                    rootModel,
+                    entryFieldPath: entryFieldPath.concat(index),
+                    modelFieldPath: modelFieldPath
+                })
+            );
+            return newArray;
+        }
+        throw createError(`The field type '${modelField.type}' at field path '${entryFieldPath.join('.')}' is not a container type (object, model, list).`);
+    }
+
+    return iterateModel({
+        value: entry,
+        model,
+        fieldPath: updateOperation.fieldPath,
+        entryFieldPath: [],
+        modelFieldPath: []
+    });
+}
+
+function getValueForOperation({
+    updateOperation,
+    value,
+    rootModel,
+    entryFieldPath,
+    modelFieldPath,
+    getDocumentById,
+    getModelByName,
+    errorPrefix,
+    logger
+}: {
+    updateOperation: StackbitTypes.UpdateOperation;
+    value: unknown;
+    rootEntry: Entry;
+    rootModel: ModelWithContext;
+    entryFieldPath: (string | number)[];
+    modelFieldPath: string[];
+    getDocumentById: GetDocumentById;
+    getModelByName: GetModelByName;
+    errorPrefix: string;
+    logger: StackbitTypes.Logger;
+}) {
+    switch (updateOperation.opType) {
+        case 'set':
+            return convertOperationFieldValue({
+                updateOperationField: updateOperation.field,
+                modelField: updateOperation.modelField,
+                isInList: false,
+                rootModel: rootModel,
+                entryFieldPath: entryFieldPath,
+                modelFieldPath: modelFieldPath,
+                getModelByName,
+                getDocumentById,
+                errorPrefix
+            });
+        case 'unset': {
+            return null;
+        }
+        case 'insert': {
+            if (typeof value === 'undefined') {
+                value = [];
+            }
+            if (!Array.isArray(value)) {
+                throw new Error(`${errorPrefix} The field path points to a non array value.`);
+            }
+            const newValue = convertOperationFieldValue({
+                updateOperationField: updateOperation.item,
+                modelField: updateOperation.modelField.items,
+                isInList: true,
+                rootModel: rootModel,
+                entryFieldPath: entryFieldPath,
+                modelFieldPath: modelFieldPath,
+                getModelByName,
+                getDocumentById,
+                errorPrefix
+            });
+            if (typeof updateOperation.index === 'undefined') {
+                return value.concat(newValue);
+            }
+            const newArray = value.slice();
+            newArray.splice(updateOperation.index, 0, newValue);
+            return newArray;
+        }
+        case 'remove': {
+            if (typeof value === 'undefined') {
+                value = [];
+            }
+            if (!Array.isArray(value)) {
+                throw new Error(`${errorPrefix} The field path points to a non array value.`);
+            }
+            const newArray = value.slice();
+            newArray.splice(updateOperation.index, 1);
+            return newArray;
+        }
+        case 'reorder': {
+            if (typeof value === 'undefined') {
+                value = [];
+            }
+            if (!Array.isArray(value)) {
+                throw new Error(`${errorPrefix} The field path points to a non array value.`);
+            }
+            return updateOperation.order.map((newIndex) => (value as any[])[newIndex]);
+        }
+        default: {
+            const _exhaustiveCheck: never = updateOperation;
+            return _exhaustiveCheck;
+        }
+    }
+}
+
+export function convertOperationFieldValue({
+    updateOperationField,
+    rootModel,
+    modelField,
+    isInList,
+    entryFieldPath,
+    modelFieldPath,
+    getDocumentById,
+    getModelByName,
+    errorPrefix
+}: {
+    updateOperationField: StackbitTypes.UpdateOperationField;
+    rootModel: ModelWithContext;
+    modelField: StackbitTypes.FieldSpecificProps;
+    isInList: boolean;
+    entryFieldPath: (string | number)[];
+    modelFieldPath: string[];
+    getDocumentById: GetDocumentById;
+    getModelByName: GetModelByName;
+    errorPrefix: string;
+}): any {
+    function createError(detailedMessage: string) {
+        return new Error(`${errorPrefix} ${detailedMessage}`);
+    }
+
+    switch (updateOperationField.type) {
+        case 'string':
+        case 'url':
+        case 'slug':
+        case 'text':
+        case 'markdown':
+        case 'html':
+        case 'color': {
+            // when adding item to a list, it can't be empty string or undefined,
+            // otherwise Contentstack will not add it to the list
+            if (isInList && (updateOperationField.value === '' || _.isNil(updateOperationField.value))) {
+                return ' ';
+            }
+            return updateOperationField.value;
+        }
+        case 'date':
+        case 'datetime': {
+            if (_.isEmpty(updateOperationField.value)) {
+                return new Date().toISOString();
+            }
+            return updateOperationField.value;
+        }
+        case 'enum': {
+            if (updateOperationField.value === '') {
+                return null;
+            }
+            const firstOption = (modelField as StackbitTypes.FieldEnum).options[0];
+            const optionValue = firstOption && isObject(firstOption) ? firstOption.value : firstOption;
+            const isNumberEnum = typeof optionValue === 'number';
+            if (isNumberEnum) {
+                return _.toNumber(updateOperationField.value);
+            } else {
+                return _.toString(updateOperationField.value);
+            }
+        }
+        case 'number': {
+            return updateOperationField.value || 0;
+        }
+        case 'boolean': {
+            return updateOperationField.value || false;
+        }
+        case 'file':
+        case 'image': {
+            return updateOperationField.value || null;
+        }
+        case 'richText':
+        case 'json':
+        case 'style':
+        case 'cross-reference': {
+            return updateOperationField.value;
+        }
+        case 'reference': {
+            if (updateOperationField?.refType === 'asset') {
+                return updateOperationField.refId;
+            }
+            const document = getDocumentById(updateOperationField?.refId);
+            if (!document) {
+                throw createError(`Could not find entry with ID '${updateOperationField?.refId}' referenced at field path ${entryFieldPath.join('.')}.`);
+            }
+            const refObject = {
+                uid: updateOperationField.refId,
+                _content_type_uid: document.modelName
+            };
+            // references fields are always stored as arrays, even if they are not marked as multiple
+            return isInList ? refObject : [refObject];
+        }
+        case 'object': {
+            if (modelField.type !== 'object') {
+                throw createError(
+                    `The operation field type 'object' does not match model field type '${modelField.type}' at field path ${entryFieldPath.join('.')}.`
+                );
+            }
+            return _.reduce(
+                updateOperationField.fields,
+                (accum: Record<string, unknown>, nestedUpdateOperationField, fieldName) => {
+                    const nestedModelField = getModelField(modelField, fieldName);
+                    if (!nestedModelField) {
+                        return accum;
+                    }
+                    accum[fieldName] = convertOperationFieldValue({
+                        updateOperationField: nestedUpdateOperationField,
+                        rootModel,
+                        modelField: nestedModelField,
+                        isInList: false,
+                        entryFieldPath: entryFieldPath.concat(fieldName),
+                        modelFieldPath: modelFieldPath.concat(fieldName),
+                        getDocumentById,
+                        getModelByName,
+                        errorPrefix
+                    });
+                    return accum;
+                },
+                {}
+            );
+        }
+        case 'model': {
+            if (modelField.type !== 'model') {
+                throw createError(
+                    `The operation field type 'model' does not match model field type '${modelField.type}' at field path ${entryFieldPath.join('.')}.`
+                );
+            }
+            const nestedModel = getModelByName(updateOperationField.modelName);
+            if (!nestedModel) {
+                throw createError(`Could not find model named '${updateOperationField.modelName}' for field at path '${entryFieldPath.join('.')}'.`);
+            }
+            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]
+                const blockUID = blockMap.modelNameToBlockId[updateOperationField.modelName];
+                if (!blockUID) {
+                    throw createError(
+                        `Could not match modular block UI for model '${updateOperationField.modelName}' for field path '${entryFieldPath.join('.')}'.`
+                    );
+                }
+                return {
+                    [blockUID]: _.reduce(
+                        updateOperationField.fields,
+                        (accum: Record<string, unknown>, nestedUpdateOperationField, fieldName) => {
+                            const nestedModelField = getModelField(nestedModel, fieldName);
+                            if (!nestedModelField) {
+                                return accum;
+                            }
+                            accum[fieldName] = convertOperationFieldValue({
+                                updateOperationField: nestedUpdateOperationField,
+                                rootModel: nestedModel,
+                                modelField: nestedModelField,
+                                isInList: false,
+                                entryFieldPath: entryFieldPath.concat([blockUID, fieldName]),
+                                modelFieldPath: [fieldName],
+                                getDocumentById,
+                                getModelByName,
+                                errorPrefix
+                            });
+                            return accum;
+                        },
+                        {}
+                    )
+                };
+            } else {
+                // this is a regular global field (model) with a single model or as a CNTSTK_LINK_MODEL
+                return _.reduce(
+                    updateOperationField.fields,
+                    (accum: Record<string, unknown>, nestedUpdateOperationField, fieldName) => {
+                        const nestedModelField = getModelField(nestedModel, fieldName);
+                        if (!nestedModelField) {
+                            return accum;
+                        }
+                        accum[fieldName] = convertOperationFieldValue({
+                            updateOperationField: nestedUpdateOperationField,
+                            rootModel: nestedModel,
+                            modelField: nestedModelField,
+                            isInList: false,
+                            entryFieldPath: entryFieldPath.concat(fieldName),
+                            modelFieldPath: [fieldName],
+                            getDocumentById,
+                            getModelByName,
+                            errorPrefix
+                        });
+                        return accum;
+                    },
+                    {}
+                );
+            }
+        }
+        case 'list': {
+            if (modelField.type !== 'list') {
+                throw createError(
+                    `The operation field type 'list' does not match model field type '${modelField.type}' at field path ${entryFieldPath.join('.')}.`
+                );
+            }
+            return _.reduce(
+                updateOperationField.items,
+                (accum: any[], listItem: StackbitTypes.UpdateOperationListFieldItem, index) => {
+                    accum.push(
+                        convertOperationFieldValue({
+                            updateOperationField: listItem,
+                            rootModel,
+                            modelField: modelField.items,
+                            isInList: true,
+                            entryFieldPath: entryFieldPath.concat(index),
+                            modelFieldPath: modelFieldPath,
+                            getDocumentById,
+                            getModelByName,
+                            errorPrefix
+                        })
+                    );
+                    return accum;
+                },
+                []
+            );
+        }
+        default: {
+            const _exhaustiveCheck: never = updateOperationField;
+            return _exhaustiveCheck;
+        }
+    }
+}
+
+function getModelField(model: ModelWithContext | StackbitTypes.FieldObjectProps, fieldName: string) {
+    return model.fields?.find((field) => field.name === fieldName);
+}
+
+function isObject(value: unknown): value is Record<string, unknown> {
+    return _.isPlainObject(value);
+}
+
+function sanitizeForUpdate(entry: Entry): Entry {
+    return _.cloneDeepWith(entry, (value) => {
+        if (isAsset(value)) {
+            return value.uid;
+        }
+    });
+}
+
+function isAsset(value: unknown): value is Asset {
+    if (!isObject(value) || !value.uid) {
+        return false;
+    }
+    // if all asset keys are present in the value, then it is an asset
+    const imageKeys = ['uid', 'created_at', 'updated_at', 'created_by', 'updated_by', 'content_type', 'file_size', 'filename', 'url'];
+    const objectKeys = _.keys(value);
+    return _.difference(imageKeys, objectKeys).length === 0;
+}