@stackbit/cms-contentstack 0.2.13-staging.1 → 0.2.13

package/dist/transformation-utils.js

@@ -1,730 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertOperationFieldValue = exports.getUpdatedEntryAtFieldPathWithOperation = exports.updateEntryFromUpdateOperations = exports.createEntryFromOperationFields = void 0;
-const uuid_1 = require("uuid");
-const lodash_1 = __importDefault(require("lodash"));
-function createEntryFromOperationFields({ updateOperationFields, model, getDocumentById, getModelByName, logger }) {
-    return lodash_1.default.reduce(updateOperationFields, (accum, updateOperationField, fieldName) => {
-        const modelField = getModelField(model, fieldName);
-        if (!modelField) {
-            return accum;
-        }
-        accum[fieldName] = convertOperationFieldValue({
-            updateOperationField,
-            modelField,
-            rootModel: model,
-            entryFieldPath: [fieldName],
-            modelFieldPath: [fieldName],
-            getDocumentById,
-            getModelByName,
-            errorPrefix: 'Error occurred while creating an entry.'
-        });
-        return accum;
-    }, { title: (0, uuid_1.v4)() });
-}
-exports.createEntryFromOperationFields = createEntryFromOperationFields;
-function updateEntryFromUpdateOperations({ entry, updateOperations, getDocumentById, getModelByName, logger }) {
-    var _a;
-    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.`);
-    }
-    // remove all model fields
-    for (const field of (_a = model.fields) !== null && _a !== void 0 ? _a : []) {
-        const { [field.name]: entryField, ...rest } = entry;
-        entry = rest;
-    }
-    return lodash_1.default.reduce(updateOperations, (entry, updateOperation) => {
-        return getUpdatedEntryAtFieldPathWithOperation({
-            entry,
-            updateOperation,
-            model,
-            getDocumentById,
-            getModelByName,
-            logger
-        });
-    }, entry);
-    // const updateStatements = updateOperations.map((updateOp) => {
-    //     switch (updateOp.opType) {
-    //         case 'set': {
-    //             const fieldValue = convertOperationFieldValue({
-    //                 updateOperationField: updateOp.field,
-    //                 rootModel: model,
-    //                 modelField: updateOp.modelField,
-    //                 modelFieldPath: transformToModelFieldPath(updateOp.fieldPath),
-    //                 entryFieldPath: transformToEntryFieldPath(updateOp.fieldPath),
-    //                 getDocumentById,
-    //                 getModelByName
-    //             });
-    //             return updateFieldAtFieldPath({
-    //                 entry,
-    //                 updateEntry,
-    //                 fieldPath: updateOp.fieldPath,
-    //                 fieldValue,
-    //                 model,
-    //                 getModelByName
-    //             });
-    //         }
-    //         case 'unset': {
-    //             return updateFieldAtFieldPath({
-    //                 entry,
-    //                 fieldPath: updateOp.fieldPath,
-    //                 value: null,
-    //                 model,
-    //                 getModelByName
-    //             });
-    //         }
-    //         case 'insert': {
-    //             const { item, index } = updateOp;
-    //
-    //             const container = getDataByPath(entry, updateOp.fieldPath, model, getModelByName) || [];
-    //             const convertedData = convertObject(container);
-    //
-    //             const fieldValue = convertOperationFieldValue(item, { name: '', ...updateOp.modelField }, getDocumentById, model, modelMap);
-    //
-    //             convertedData.splice(index, 0, fieldValue);
-    //
-    //             return updateFieldAtFieldPath(entry, updateOp.fieldPath, convertedData, model, getModelByName);
-    //         }
-    //         case 'remove': {
-    //             const { index } = updateOp;
-    //
-    //             const container = getDataByPath(entry, updateOp.fieldPath, model, getModelByName);
-    //             const convertedData = convertObject(container);
-    //
-    //             convertedData.splice(index, 1);
-    //             return updateFieldAtFieldPath(entry, updateOp.fieldPath, convertedData, model, getModelByName);
-    //         }
-    //         case 'reorder': {
-    //             const { order } = updateOp;
-    //
-    //             const container = getDataByPath(entry, updateOp.fieldPath, model, getModelByName);
-    //             const convertedData = convertObject(container);
-    //
-    //             const reorderedItems = order.map((itemIndex) => convertedData.at(itemIndex));
-    //             return updateFieldAtFieldPath(entry, updateOp.fieldPath, reorderedItems, model, getModelByName);
-    //         }
-    //
-    //         default: {
-    //             const _exhaustiveCheck: never = updateOp;
-    //             return _exhaustiveCheck;
-    //         }
-    //     }
-    // });
-    //
-    // return updateStatements.filter(Boolean);
-}
-exports.updateEntryFromUpdateOperations = updateEntryFromUpdateOperations;
-// export function getDataByPath(obj: any, fieldPath: (number | string)[], model: Model, modelMap: ModelMap): any {
-//     if (fieldPath.length === 0) {
-//         return obj;
-//     }
-//
-//     const currentFieldName = fieldPath[0] as string;
-//     const modelField = (model.fields || []).find((field) => field.name === currentFieldName);
-//
-//     if (!modelField) {
-//         return getDataByPath(obj[currentFieldName], fieldPath.slice(1), model, modelMap);
-//     }
-//
-//     if (fieldPath.length >= 2 && modelField.type === 'list' && modelField.items.type === 'model') {
-//         const isFieldBlockField = isBlocksField(modelField, model.name);
-//         const currentObj = handleGetDataGroup(obj, modelField);
-//
-//         if (!isFieldBlockField) {
-//             return getDataByPath(currentObj, fieldPath.slice(1), modelMap[modelField.items.models[0] as string] as Model, modelMap);
-//         }
-//
-//         const index = fieldPath[1] as number;
-//         const item = currentObj[index];
-//
-//         const blockType = Object.keys(item)[0] as string;
-//         const blockModelName = generateBlockModelName(model.name, blockType);
-//
-//         return getDataByPath(item[blockType], fieldPath.slice(2), modelMap[blockModelName] as Model, modelMap);
-//     }
-//
-//     return getDataByPath(handleGetDataGroup(obj, modelField), fieldPath.slice(1), model, modelMap);
-// }
-//
-// export function isBlocksField(field: Field, modelName: string) {
-//     return field.type === 'list' && field.items.type === 'model' && field.items.models?.some((fieldModel) => fieldModel.includes(`BLOCK_${modelName}__`));
-// }
-//
-// export function generateBlockModelName(modelName: string, blockName: string) {
-//     return `BLOCK_${modelName}__${blockName}`;
-// }
-//
-// export function convertObject(obj: any): any {
-//     if (obj === null) {
-//         return obj;
-//     }
-//
-//     if (typeof obj !== 'object') {
-//         return obj;
-//     }
-//
-//     if (Array.isArray(obj)) {
-//         return obj.map(convertObject);
-//     }
-//
-//     if (obj.hasOwnProperty('uid') && !obj.hasOwnProperty('_content_type_uid')) {
-//         return obj.uid;
-//     }
-//
-//     return Object.entries(obj).reduce((acc: Record<string, any>, [key, value]) => {
-//         if (value === null) {
-//             return acc;
-//         }
-//
-//         acc[key] = key === '_metadata' ? value : convertObject(value);
-//         return acc;
-//     }, {});
-// }
-function getUpdatedEntryAtFieldPathWithOperation({ entry, updateOperation, model, getDocumentById, getModelByName, logger }) {
-    let opMessage;
-    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) {
-        return new Error(`${errorPrefix} ${detailedMessage}`);
-    }
-    function iterateModel({ value, model, fieldPath, entryFieldPath, modelFieldPath }) {
-        if (fieldPath.length === 0) {
-            return getValueForOperation({
-                updateOperation,
-                value,
-                rootEntry: entry,
-                rootModel: model,
-                entryFieldPath,
-                modelFieldPath,
-                getDocumentById,
-                getModelByName,
-                errorPrefix,
-                logger
-            });
-        }
-        const fieldName = lodash_1.default.head(fieldPath);
-        const fieldPathTail = lodash_1.default.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)
-            })
-        };
-    }
-    function iterateField({ value, modelField, fieldPath, rootModel, entryFieldPath, modelFieldPath }) {
-        var _a, _b;
-        if (fieldPath.length === 0) {
-            return getValueForOperation({
-                updateOperation,
-                value,
-                rootEntry: entry,
-                rootModel,
-                entryFieldPath,
-                modelFieldPath,
-                getDocumentById,
-                getModelByName,
-                errorPrefix,
-                logger
-            });
-        }
-        const fieldName = lodash_1.default.head(fieldPath);
-        const fieldPathTail = lodash_1.default.tail(fieldPath);
-        // 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.`);
-        }
-        if (typeof fieldName !== 'string') {
-            throw createError(`The field '${fieldName}' in field path '${entryFieldPath.concat(fieldName).join('.')}' ` +
-                `is not a string, 'typeof ${fieldName} === ${typeof fieldName}'.`);
-        }
-        if (modelField.type === 'object') {
-            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') {
-            const fieldValue = value[fieldName];
-            const fieldPathStr = modelFieldPath.join('.');
-            const blockMap = (_b = (_a = rootModel.context) === null || _a === void 0 ? void 0 : _a.blockMap) === null || _b === void 0 ? void 0 : _b[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].
-                // The fieldValue must be an object with a single property matching the block uid
-                if (fieldPathTail.length === 0) {
-                    return {
-                        ...value,
-                        [fieldName]: getValueForOperation({
-                            updateOperation,
-                            value: value[fieldName],
-                            rootEntry: entry,
-                            rootModel,
-                            entryFieldPath: entryFieldPath.concat(fieldName),
-                            modelFieldPath: modelFieldPath.concat(fieldName),
-                            getDocumentById,
-                            getModelByName,
-                            errorPrefix,
-                            logger
-                        })
-                    };
-                }
-                if (!isObject(fieldValue)) {
-                    throw createError(`The field path '${entryFieldPath.concat(fieldName).join('.')}' points to an empty value.`);
-                }
-                const blockUIDs = lodash_1.default.keys(fieldValue);
-                const blockUID = blockUIDs[0];
-                if (blockUIDs.length !== 1 || !blockUID) {
-                    throw createError(`The modular block at field path '${entryFieldPath.concat(fieldName).join('.')}' has no UID.`);
-                }
-                const nestedBlock = fieldValue[blockUID];
-                if (!isObject(nestedBlock)) {
-                    throw createError(`The field path '${entryFieldPath.concat(fieldName).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.concat(fieldName).join('.')}'.`);
-                }
-                const nestedModel = getModelByName(modelName);
-                if (!nestedModel) {
-                    throw createError(`Could not find model named '${modelName}' for modular block '${blockUID}' ` +
-                        `at field path '${entryFieldPath.concat(fieldName).join('.')}'.`);
-                }
-                return {
-                    ...value,
-                    [fieldName]: {
-                        [blockUID]: iterateModel({
-                            value: nestedBlock,
-                            fieldPath: fieldPathTail,
-                            model: nestedModel,
-                            entryFieldPath: entryFieldPath.concat(fieldName),
-                            modelFieldPath: modelFieldPath.concat(fieldName)
-                        })
-                    }
-                };
-            }
-            else {
-                // This is as a regular global field (model) with a single model or as a __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.concat(fieldName).join('.')}.'`);
-                }
-                return {
-                    ...value,
-                    [fieldName]: iterateModel({
-                        value: isObject(fieldValue) ? fieldValue : undefined,
-                        fieldPath: fieldPathTail,
-                        model: nestedModel,
-                        entryFieldPath: entryFieldPath.concat(fieldName),
-                        modelFieldPath: modelFieldPath.concat(fieldName)
-                    })
-                };
-            }
-        }
-        else if (modelField.type === 'list') {
-            const fieldValue = value[fieldName];
-            if (fieldPathTail.length === 0) {
-                return {
-                    ...value,
-                    [fieldName]: getValueForOperation({
-                        updateOperation,
-                        value: fieldValue,
-                        rootEntry: entry,
-                        rootModel,
-                        entryFieldPath: entryFieldPath.concat(fieldName),
-                        modelFieldPath: modelFieldPath.concat(fieldName),
-                        getDocumentById,
-                        getModelByName,
-                        errorPrefix,
-                        logger
-                    })
-                };
-            }
-            if (!Array.isArray(fieldValue)) {
-                throw createError(`The value at field path '${entryFieldPath.concat(fieldName).join('.')}' is not an array.`);
-            }
-            const nestedModel = modelField.items;
-            const itemIndex = lodash_1.default.toNumber(lodash_1.default.head(fieldPathTail));
-            return {
-                ...value,
-                [fieldName]: fieldValue.slice().splice(itemIndex, 1, iterateField({
-                    value: fieldValue[itemIndex],
-                    fieldPath: lodash_1.default.tail(fieldPathTail),
-                    modelField: nestedModel,
-                    rootModel,
-                    entryFieldPath: entryFieldPath.concat([fieldName, itemIndex]),
-                    modelFieldPath: modelFieldPath.concat(fieldName)
-                }))
-            };
-        }
-        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: []
-    });
-}
-exports.getUpdatedEntryAtFieldPathWithOperation = getUpdatedEntryAtFieldPathWithOperation;
-function getValueForOperation({ updateOperation, value, rootModel, entryFieldPath, modelFieldPath, getDocumentById, getModelByName, errorPrefix, logger }) {
-    switch (updateOperation.opType) {
-        case 'set':
-            return convertOperationFieldValue({
-                updateOperationField: updateOperation.field,
-                modelField: updateOperation.modelField,
-                rootModel: rootModel,
-                entryFieldPath: entryFieldPath,
-                modelFieldPath: modelFieldPath,
-                getModelByName,
-                getDocumentById,
-                errorPrefix
-            });
-        case 'unset': {
-            // TODO: is unset different per type?
-            return null;
-        }
-        case 'insert': {
-            if (!Array.isArray(value)) {
-                // TODO: error
-                return {};
-            }
-            const newValue = convertOperationFieldValue({
-                updateOperationField: updateOperation.item,
-                modelField: updateOperation.modelField,
-                rootModel: rootModel,
-                entryFieldPath: entryFieldPath,
-                modelFieldPath: modelFieldPath,
-                getModelByName,
-                getDocumentById,
-                errorPrefix
-            });
-            if (typeof updateOperation.index === 'undefined') {
-                return value.concat(newValue);
-            }
-            else {
-                return value.slice().splice(updateOperation.index, 0, newValue);
-            }
-        }
-        case 'remove': {
-            if (!Array.isArray(value)) {
-                // TODO: error
-                return {};
-            }
-            return value.slice().splice(updateOperation.index, 1);
-        }
-        case 'reorder': {
-            if (!Array.isArray(value)) {
-                // TODO: error
-                return {};
-            }
-            return updateOperation.order.map((newIndex) => value[newIndex]);
-        }
-        default: {
-            const _exhaustiveCheck = updateOperation;
-            return _exhaustiveCheck;
-        }
-    }
-}
-// export function updateField({
-//     entry,
-//     updateOperations,
-//     fieldPath,
-//     fieldValue,
-//     model,
-//     getModelByName
-// }: {
-//     entry: Entry;
-//     updateOperations: Record<string, any>;
-//     fieldPath: (number | string)[];
-//     fieldValue: any;
-//     model: ModelWithContext;
-//     getModelByName: GetModelByName;
-// }): Record<string, any> {
-//     if (fieldPath.length == 0) {
-//         return fieldValue;
-//     }
-//
-//     const currentFieldName = fieldPath[0] as string;
-//     const modelField = getModelField(model, currentFieldName) as Field;
-//
-//     if (fieldPath.length == 1) {
-//         return handleGroup(currentFieldName, modelField, fieldValue);
-//     }
-//
-//     if (modelField.type === 'list') {
-//         const index = fieldPath[1] as number;
-//
-//         if (modelField.items.type === 'model') {
-//             const isFieldBlockField = isBlocksField(modelField, model.name);
-//             const currentObject = entry[currentFieldName][index];
-//
-//             const itemModelName = isFieldBlockField
-//                 ? generateBlockModelName(model.name, Object.keys(currentObject)[0] as string)
-//                 : (modelField.items.models[0] as string);
-//             const cleanBlockModelName = itemModelName.replace(`BLOCK_${model.name}__`, '');
-//
-//             const data = {
-//                 UPDATE: {
-//                     index,
-//                     data: isFieldBlockField
-//                         ? handleGroup(
-//                               itemModelName.replace(`BLOCK_${model.name}__`, ''),
-//                               modelField,
-//                               updateFieldAtFieldPath(
-//                                   currentObject[cleanBlockModelName],
-//                                   fieldPath.slice(2),
-//                                   fieldValue,
-//                                   getModelByName(itemModelName),
-//                                   getModelByName
-//                               )
-//                           )
-//                         : updateFieldAtFieldPath(currentObject, fieldPath.slice(2), fieldValue, getModelByName(itemModelName), getModelByName)
-//                 }
-//             };
-//
-//             return handleGroup(currentFieldName, modelField, data);
-//         }
-//
-//         return {
-//             [currentFieldName]: {
-//                 UPDATE: {
-//                     index,
-//                     data: updateFieldAtFieldPath(entry[currentFieldName][index], fieldPath.slice(2), fieldValue, model, getModelByName)
-//                 }
-//             }
-//         };
-//     }
-//
-//     return handleGroup(currentFieldName, modelField, updateFieldAtFieldPath(entry[currentFieldName], fieldPath.slice(1), fieldValue, model, getModelByName));
-// }
-function convertOperationFieldValue({ updateOperationField, rootModel, modelField, entryFieldPath, modelFieldPath, getDocumentById, getModelByName, errorPrefix }) {
-    var _a, _b;
-    function createError(detailedMessage) {
-        return new Error(`${errorPrefix} ${detailedMessage}`);
-    }
-    switch (updateOperationField.type) {
-        case 'string':
-        case 'url':
-        case 'slug':
-        case 'text':
-        case 'markdown':
-        case 'html':
-        case 'date':
-        case 'datetime':
-        case 'color':
-        case 'enum': {
-            return 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 === null || updateOperationField === void 0 ? void 0 : updateOperationField.refType) === 'asset') {
-                return updateOperationField.refId;
-            }
-            const document = getDocumentById(updateOperationField === null || updateOperationField === void 0 ? void 0 : updateOperationField.refId);
-            if (!document) {
-                throw createError(`Could not find entry with ID '${updateOperationField === null || updateOperationField === void 0 ? void 0 : updateOperationField.refId}' referenced at field path ${entryFieldPath.join('.')}.`);
-            }
-            return {
-                uid: updateOperationField.refId,
-                _content_type_uid: document.modelName
-            };
-        }
-        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 lodash_1.default.reduce(updateOperationField.fields, (accum, nestedUpdateOperationField, fieldName) => {
-                const nestedModelField = getModelField(modelField, fieldName);
-                if (!nestedModelField) {
-                    return accum;
-                }
-                accum[fieldName] = convertOperationFieldValue({
-                    updateOperationField: nestedUpdateOperationField,
-                    rootModel,
-                    modelField: nestedModelField,
-                    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 = (_b = (_a = rootModel.context) === null || _a === void 0 ? void 0 : _a.blockMap) === null || _b === void 0 ? void 0 : _b[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]: lodash_1.default.reduce(updateOperationField.fields, (accum, nestedUpdateOperationField, fieldName) => {
-                        const nestedModelField = getModelField(nestedModel, fieldName);
-                        if (!nestedModelField) {
-                            return accum;
-                        }
-                        accum[fieldName] = convertOperationFieldValue({
-                            updateOperationField: nestedUpdateOperationField,
-                            rootModel: nestedModel,
-                            modelField: nestedModelField,
-                            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 __link_model
-                return lodash_1.default.reduce(updateOperationField.fields, (accum, nestedUpdateOperationField, fieldName) => {
-                    const nestedModelField = getModelField(nestedModel, fieldName);
-                    if (!nestedModelField) {
-                        return accum;
-                    }
-                    accum[fieldName] = convertOperationFieldValue({
-                        updateOperationField: nestedUpdateOperationField,
-                        rootModel: nestedModel,
-                        modelField: nestedModelField,
-                        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 lodash_1.default.reduce(updateOperationField.items, (accum, listItem, index) => {
-                return convertOperationFieldValue({
-                    updateOperationField: listItem,
-                    rootModel,
-                    modelField: modelField.items,
-                    entryFieldPath: entryFieldPath.concat(index),
-                    modelFieldPath: modelFieldPath,
-                    getDocumentById,
-                    getModelByName,
-                    errorPrefix
-                });
-            }, []);
-        }
-        default: {
-            const _exhaustiveCheck = updateOperationField;
-            return _exhaustiveCheck;
-        }
-    }
-}
-exports.convertOperationFieldValue = convertOperationFieldValue;
-function getModelField(model, fieldName) {
-    var _a;
-    return (_a = model.fields) === null || _a === void 0 ? void 0 : _a.find((field) => field.name === fieldName);
-}
-function isObject(value) {
-    return lodash_1.default.isPlainObject(value);
-}
-// function handleGroup(fieldName: string, modelField: Field, value: any) {
-//     if (modelField?.group) {
-//         return {
-//             [modelField.group]: {
-//                 [fieldName]: value
-//             }
-//         };
-//     }
-//
-//     return {
-//         [fieldName]: value
-//     };
-// }
-//
-// function handleGetDataGroup(obj: Record<string, any>, modelField: Field) {
-//     const fieldName = modelField.name;
-//     if (modelField.group) {
-//         return obj[modelField.group][fieldName];
-//     }
-//
-//     return obj[fieldName];
-// }
-//# sourceMappingURL=transformation-utils.js.map