@reltio/components 1.4.2243 → 1.4.2245

package/features/workflow/helpers/dcr.js

@@ -18,8 +18,51 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     }
     return to.concat(ar || Array.prototype.slice.call(from));
 };
-import { createEntryDeleteAttribute, DCRTypes, findAttributeTypeByUri, isEntityUri, isNested, isRelationTypeUri, isRelationUri } from '@reltio/mdm-sdk';
+import { createEntryDeleteAttribute, DCRTypes, EventType, findAttributeTypeByUri, getReferencedEntityTypeUriFromAttrType, isEmptyValue, isEntityUri, isNested, isRelationTypeUri, isRelationUri } from '@reltio/mdm-sdk';
 import { allPass, append, assocPath, concat, curry, dissocPath, equals, filter, flatten, fromPairs, groupBy, has, hasPath, isEmpty, isNil, keys, map, partition, path, pathOr, pipe, pluck, prop, propOr, toPairs, values, uniq, uniqBy, when } from 'ramda';
+import { ADDED_CHANGE_ID_PREFIX } from '../contexts/AddedAttributesContext';
+var isAddedChange = function (changeId) { return changeId === null || changeId === void 0 ? void 0 : changeId.startsWith(ADDED_CHANGE_ID_PREFIX); };
+var normalizeReferenceValueForApi = function (val, change, metadata) {
+    var attrType = findAttributeTypeByUri(metadata, change.attributeType);
+    return __assign(__assign(__assign({}, val), { refEntity: {
+            objectURI: val.refEntity.objectURI,
+            type: getReferencedEntityTypeUriFromAttrType(attrType)
+        } }), (change.crosswalk && {
+        refRelation: {
+            type: change.crosswalk.type
+        }
+    }));
+};
+var dcrChangeToInsertDiffEntry = function (change, objectUri, metadata) {
+    var _a, _b;
+    switch (change.type) {
+        case DCRTypes.INSERT_ATTRIBUTE: {
+            var newVal = change.newValue;
+            var normalized = newVal.refEntity !== undefined ? normalizeReferenceValueForApi(newVal, change, metadata) : newVal;
+            var attributePath = change.attributePath;
+            if (change.refObjectURI && change.refAttributeType) {
+                var refAttrName = change.refAttributeType.split('/attributes/')[1];
+                var refInstanceId = change.refObjectURI.split('/')[1];
+                attributePath = "".concat(refAttrName, "/").concat(refInstanceId, "/").concat(attributePath);
+            }
+            return {
+                type: EventType.INSERT_ATTRIBUTE,
+                uri: "".concat(objectUri, "/attributes/").concat(attributePath),
+                newValue: [normalized]
+            };
+        }
+        case DCRTypes.UPDATE_TAGS:
+            return { type: EventType.UPDATE_TAGS, newValue: change.newValue };
+        case DCRTypes.UPDATE_ROLES:
+            return { type: EventType.UPDATE_ROLES, newValue: change.newValue };
+        case DCRTypes.UPDATE_START_DATE:
+            return { type: EventType.UPDATE_START_DATE, newValue: { value: (_a = change.newValue) === null || _a === void 0 ? void 0 : _a[0] } };
+        case DCRTypes.UPDATE_END_DATE:
+            return { type: EventType.UPDATE_END_DATE, newValue: { value: (_b = change.newValue) === null || _b === void 0 ? void 0 : _b[0] } };
+        default:
+            return null;
+    }
+};
 export var getEntitiesObjects = filter(pipe(prop('uri'), isEntityUri));
 export var getRelationsObjects = filter(pipe(prop('uri'), isRelationUri));
 var getRelations = function (objectsWithChanges, entityUri) {
@@ -41,11 +84,12 @@ export var createEntityRelationsObjectByRelation = curry(function (objectsInfo,
     return entity ? { entity: __assign(__assign({}, entity), { uri: relation.startObjectUri }), relations: relations } : { relations: relations };
 });
 export var concatEntityRelationsObjects = function (acc, object) {
+    var _a, _b;
     var entity = object.entity, relations = object.relations;
     var entityUri = entity.uri;
     var mergedRelations = pipe(pathOr([], [entityUri, 'relations']), concat(relations), uniq)(acc);
     acc[entityUri] = {
-        entity: entity,
+        entity: (_b = (_a = acc[entityUri]) === null || _a === void 0 ? void 0 : _a.entity) !== null && _b !== void 0 ? _b : entity,
         relations: mergedRelations
     };
     return acc;
@@ -57,7 +101,7 @@ export var isCreateEntityOperation = function (dcr) {
     return dcr.type === DCRTypes.CREATE_ENTITY;
 };
 var cleanValueRecursively = function (value) {
-    if (typeof value === 'string' || isEmpty(value)) {
+    if (isNil(value) || typeof value === 'string' || isEmpty(value)) {
         return value;
     }
     var cleanedProperties = map(function (propertyValues) {
@@ -69,7 +113,7 @@ var cleanValueRecursively = function (value) {
         })
             .filter(function (item) {
             var itemValue = item.value;
-            return !isEmpty(itemValue) && !isNil(itemValue);
+            return (!isEmpty(itemValue) && !isNil(itemValue)) || 'lookupCode' in item;
         });
     }, value);
     return filter(function (propertyValues) { return !isEmpty(propertyValues); }, cleanedProperties);
@@ -109,12 +153,16 @@ var calculateValuePath = function (key, change) {
         case DCRTypes.UPDATE_END_DATE:
             return __spreadArray(__spreadArray([], path, true), [0], false);
         case DCRTypes.CREATE_RELATIONSHIP:
+        case DCRTypes.CREATE_ENTITY:
             if (path.length === 2) {
-                if (path[1] === 'activeness.startDate') {
-                    return [path[0], 'startDate'];
-                }
-                if (path[1] === 'activeness.endDate') {
-                    return [path[0], 'endDate'];
+                switch (path[1]) {
+                    case 'roles':
+                    case 'tags':
+                        return path;
+                    case 'activeness.startDate':
+                        return [path[0], 'startDate'];
+                    case 'activeness.endDate':
+                        return [path[0], 'endDate'];
                 }
             }
             return __spreadArray(__spreadArray([], path, true), ['value'], false);
@@ -123,6 +171,12 @@ var calculateValuePath = function (key, change) {
     }
 };
 var valuesAreEqual = function (oldValue, newValue) {
+    if (typeof oldValue === 'object' &&
+        typeof newValue === 'object' &&
+        !Array.isArray(oldValue) &&
+        !Array.isArray(newValue)) {
+        return equals(oldValue, newValue);
+    }
     var sortWithLocale = function (array) { return array.slice().sort(function (a, b) { return a.localeCompare(b); }); };
     if (Array.isArray(oldValue) && Array.isArray(newValue)) {
         return oldValue.length === newValue.length && equals(sortWithLocale(oldValue), sortWithLocale(newValue));
@@ -143,6 +197,7 @@ export var buildDCRSavePlan = function (changes, getLinesByChangeId, metadata) {
     var rejectedChangeIds = [];
     var updatedChanges = {};
     var deleteAttributes = {};
+    var insertAttributes = {};
     for (var _i = 0, _c = Object.entries(changes); _i < _c.length; _i++) {
         var _d = _c[_i], objectUri = _d[0], objectChanges = _d[1];
         var rawChanges = new Map();
@@ -152,18 +207,28 @@ export var buildDCRSavePlan = function (changes, getLinesByChangeId, metadata) {
                 var key = _a[0], lineData = _a[1];
                 return key.split('/').length === 3 &&
                     (lineData.isRejected ||
-                        (isEmpty((_b = lineData.value) === null || _b === void 0 ? void 0 : _b.value) && change.type !== DCRTypes.UPDATE_ATTRIBUTE));
+                        (isEmptyValue((_b = lineData.value) === null || _b === void 0 ? void 0 : _b.value) && change.type !== DCRTypes.UPDATE_ATTRIBUTE));
             }))(change), rejectedRootLines = _h[0], otherLines = _h[1];
-            rejectedChangeIds.push.apply(rejectedChangeIds, rejectedRootLines.map(function (_a) {
-                var key = _a[0];
-                return key.split('/')[1];
-            }));
+            var isNew = isAddedChange(change.id);
+            if (!isNew) {
+                rejectedChangeIds.push.apply(rejectedChangeIds, rejectedRootLines.map(function (_a) {
+                    var key = _a[0];
+                    return key.split('/')[1];
+                }));
+            }
+            var newValueObj = change.newValue;
+            var hasNonEmptyNewValue = Array.isArray(change.newValue) ||
+                !isEmptyValue(newValueObj === null || newValueObj === void 0 ? void 0 : newValueObj.value) ||
+                'lookupCode' in (newValueObj !== null && newValueObj !== void 0 ? newValueObj : {});
+            if (isNew && otherLines.length === 0 && rejectedRootLines.length === 0 && hasNonEmptyNewValue) {
+                rawChanges.set(change.id, change);
+            }
             var rejectedRootLinesMap = new Map(rejectedRootLines);
             for (var _j = 0, otherLines_1 = otherLines; _j < otherLines_1.length; _j++) {
                 var _k = otherLines_1[_j], key = _k[0], lineData = _k[1];
                 var rootId = key.split('/').slice(0, 3).join('/');
                 var newValue = (_a = lineData.value) === null || _a === void 0 ? void 0 : _a.value;
-                if (rootId === key && change.type === DCRTypes.UPDATE_ATTRIBUTE && isEmpty(newValue)) {
+                if (!isNew && rootId === key && change.type === DCRTypes.UPDATE_ATTRIBUTE && isEmptyValue(newValue)) {
                     var attributeUri = [objectUri, 'attributes', change.attributePath].join('/');
                     var entry = __assign(__assign({}, createEntryDeleteAttribute({ uri: attributeUri })[0]), (change.crosswalk && { crosswalk: change.crosswalk }));
                     deleteAttributes[objectUri] = uniqBy(prop('uri'), append(entry, propOr([], objectUri, deleteAttributes)));
@@ -175,18 +240,28 @@ export var buildDCRSavePlan = function (changes, getLinesByChangeId, metadata) {
                     var oldValue = getOldValueByNewValuePath(valuePath, change);
                     var initialChange = rawChanges.has(change.id) ? rawChanges.get(change.id) : change;
                     var updatedChange = void 0;
-                    if (lineData.isRejected || isEmpty(newValue)) {
+                    if (lineData.isRejected || isEmptyValue(newValue)) {
                         updatedChange = assocPath(valuePath, null, initialChange);
                     }
                     else if (!valuesAreEqual(oldDCRValue, newValue)) {
                         if (oldValue && valuesAreEqual(oldValue, newValue)) {
-                            rejectedChangeIds.push(change.id);
+                            if (!isNew) {
+                                rejectedChangeIds.push(change.id);
+                            }
                         }
                         else {
                             var processedNewValue = typeof oldDCRValue === 'string' && typeof newValue === 'number'
                                 ? newValue.toString()
                                 : newValue;
                             updatedChange = assocPath(valuePath, processedNewValue, initialChange);
+                            var lineValue = lineData.value;
+                            if (lineValue && typeof lineValue === 'object' && 'lookupCode' in lineValue) {
+                                var parentPath = valuePath.slice(0, -1);
+                                updatedChange = assocPath(__spreadArray(__spreadArray([], parentPath, true), ['lookupCode'], false), lineValue.lookupCode, updatedChange);
+                                if ('lookupRawValue' in lineValue) {
+                                    updatedChange = assocPath(__spreadArray(__spreadArray([], parentPath, true), ['lookupRawValue'], false), lineValue.lookupRawValue, updatedChange);
+                                }
+                            }
                         }
                     }
                     if (updatedChange) {
@@ -205,7 +280,15 @@ export var buildDCRSavePlan = function (changes, getLinesByChangeId, metadata) {
             var isNestedChange = has('attributeType', cleanedChange) &&
                 isNested(findAttributeTypeByUri(metadata, cleanedChange.attributeType));
             if (isNestedChange && isEmpty((_b = cleanedChange.newValue) === null || _b === void 0 ? void 0 : _b.value)) {
-                rejectedChangeIds.push(cleanedChange.id);
+                if (!isAddedChange(cleanedChange.id)) {
+                    rejectedChangeIds.push(cleanedChange.id);
+                }
+            }
+            else if (isAddedChange(cleanedChange.id)) {
+                var diffEntry = dcrChangeToInsertDiffEntry(cleanedChange, objectUri, metadata);
+                if (diffEntry) {
+                    insertAttributes[objectUri] = append(diffEntry, propOr([], objectUri, insertAttributes));
+                }
             }
             else {
                 updatedChanges[objectUri] = append(cleanedChange, propOr([], objectUri, updatedChanges));
@@ -220,10 +303,30 @@ export var buildDCRSavePlan = function (changes, getLinesByChangeId, metadata) {
     }, toPairs(deleteAttributes));
     var deleteRelationAttributes = fromPairs(deleteAttributesGroups.relation || []);
     var deleteEntityAttributes = fromPairs(deleteAttributesGroups.entity || []);
+    var insertAttributesGroups = groupBy(function (_a) {
+        var uri = _a[0];
+        return (isRelationUri(uri) ? 'relation' : 'entity');
+    }, toPairs(insertAttributes));
+    var insertRelationAttributes = fromPairs(insertAttributesGroups.relation || []);
+    var insertEntityAttributes = fromPairs(insertAttributesGroups.entity || []);
     return {
         rejectedChangeIds: rejectedChangeIds,
         updatedChanges: updatedChanges,
         deleteEntityAttributes: deleteEntityAttributes,
-        deleteRelationAttributes: deleteRelationAttributes
+        deleteRelationAttributes: deleteRelationAttributes,
+        insertEntityAttributes: insertEntityAttributes,
+        insertRelationAttributes: insertRelationAttributes
     };
 };
+export var mergeExistingRolesAndTags = function (diff, entity) {
+    return diff.map(function (entry) {
+        var _a, _b;
+        if (entry.type === EventType.UPDATE_TAGS && ((_a = entity.tags) === null || _a === void 0 ? void 0 : _a.length)) {
+            return __assign(__assign({}, entry), { newValue: uniq(__spreadArray(__spreadArray([], entity.tags, true), entry.newValue, true)) });
+        }
+        if (entry.type === EventType.UPDATE_ROLES && ((_b = entity.roles) === null || _b === void 0 ? void 0 : _b.length)) {
+            return __assign(__assign({}, entry), { newValue: uniq(__spreadArray(__spreadArray([], entity.roles, true), entry.newValue, true)) });
+        }
+        return entry;
+    });
+};

package/features/workflow/helpers/dcr.test.js

@@ -10,7 +10,7 @@ var __assign = (this && this.__assign) || function () {
     return __assign.apply(this, arguments);
 };
 import { DCRChangeRequestState, DCRTypes } from '@reltio/mdm-sdk';
-import { concatEntityRelationsObjects, createEntityRelationsObjectByEntity, createEntityRelationsObjectByRelation, extractObjectsFromChangeRequest, getEntityUriForChangeRequest, isCreateEntityOperation } from './dcr';
+import { buildDCRSavePlan, concatEntityRelationsObjects, createEntityRelationsObjectByEntity, createEntityRelationsObjectByRelation, extractObjectsFromChangeRequest, getEntityUriForChangeRequest, isCreateEntityOperation } from './dcr';
 describe('dcr helpers tests', function () {
     it('extractObjectsFromChangeRequest behaviour', function () {
         var objectsInfo = { id1: {}, id2: {}, id3: {} };
@@ -126,6 +126,55 @@ describe('dcr helpers tests', function () {
             'entities/10f6Jabc': objects[3]
         });
     });
+    it('concatEntityRelationsObjects preserves existing entity when duplicate uri appears', function () {
+        var originalEntity = {
+            uri: 'entities/10f6JMNk',
+            isExist: true,
+            label: 'Test Label',
+            secondaryLabel: '',
+            type: 'configuration/entityTypes/Type'
+        };
+        var fetchedEntity = {
+            uri: 'entities/10f6JMNk',
+            type: 'configuration/entityTypes/Type',
+            label: 'Test Label',
+            secondaryLabel: '',
+            roles: ['configuration/roles/Admin']
+        };
+        var objects = [
+            {
+                entity: originalEntity,
+                relations: [
+                    {
+                        uri: 'relations/rel1',
+                        type: 'configuration/relationTypes/HasAddress',
+                        startObjectUri: 'entities/10f6JMNk',
+                        startObjectLabel: 'label 1',
+                        endObjectUri: 'entities/abc',
+                        endObjectLabel: 'label 2',
+                        isExist: true
+                    }
+                ]
+            },
+            {
+                entity: fetchedEntity,
+                relations: [
+                    {
+                        uri: 'relations/rel2',
+                        type: 'configuration/relationTypes/HasAddress',
+                        startObjectUri: 'entities/10f6JMNk',
+                        startObjectLabel: 'label 1',
+                        endObjectUri: 'entities/def',
+                        endObjectLabel: 'label 3',
+                        isExist: true
+                    }
+                ]
+            }
+        ];
+        var result = objects.reduce(function (acc, object) { return concatEntityRelationsObjects(acc, object); }, {});
+        expect(result['entities/10f6JMNk'].entity).toBe(originalEntity);
+        expect(result['entities/10f6JMNk'].relations).toEqual([objects[1].relations[0], objects[0].relations[0]]);
+    });
     it('getEntityUriForChangeRequest behaviour', function () {
         expect(getEntityUriForChangeRequest('dcrUri', 'entityUri')).toBe('dcrUri/changes/entityUri');
     });
@@ -144,4 +193,126 @@ describe('dcr helpers tests', function () {
         expect(isCreateEntityOperation(change)).toBe(true);
         expect(isCreateEntityOperation(__assign(__assign({}, change), { type: DCRTypes.CREATE_RELATIONSHIP }))).toBe(false);
     });
+    describe('buildDCRSavePlan', function () {
+        var emptyMetadata = { entityTypes: [], relationTypes: [] };
+        var noLineData = function () { return []; };
+        var emptyPlan = {
+            rejectedChangeIds: [],
+            updatedChanges: {},
+            deleteEntityAttributes: {},
+            deleteRelationAttributes: {},
+            insertEntityAttributes: {},
+            insertRelationAttributes: {}
+        };
+        it('should include added attribute with defaultValue when no lineData exists', function () {
+            var changes = {
+                'entities/456': [
+                    {
+                        id: 'added|simple1',
+                        type: DCRTypes.INSERT_ATTRIBUTE,
+                        attributePath: 'Surname',
+                        attributeType: 'configuration/entityTypes/HCP/attributes/Surname',
+                        newValue: { value: 'DefaultSurname' }
+                    }
+                ]
+            };
+            var result = buildDCRSavePlan(changes, noLineData, emptyMetadata);
+            expect(result).toEqual(__assign(__assign({}, emptyPlan), { insertEntityAttributes: {
+                    'entities/456': [
+                        {
+                            type: 'INSERT_ATTRIBUTE',
+                            uri: 'entities/456/attributes/Surname',
+                            newValue: [{ value: 'DefaultSurname' }]
+                        }
+                    ]
+                } }));
+        });
+        it('should include added lookup attribute with lookupCode when no lineData exists', function () {
+            var changes = {
+                'entities/456': [
+                    {
+                        id: 'added|lookup1',
+                        type: DCRTypes.INSERT_ATTRIBUTE,
+                        attributePath: 'Country',
+                        attributeType: 'configuration/entityTypes/HCP/attributes/Country',
+                        newValue: { value: '', lookupCode: 'ALBY' }
+                    }
+                ]
+            };
+            var result = buildDCRSavePlan(changes, noLineData, emptyMetadata);
+            expect(result).toEqual(__assign(__assign({}, emptyPlan), { insertEntityAttributes: {
+                    'entities/456': [
+                        {
+                            type: 'INSERT_ATTRIBUTE',
+                            uri: 'entities/456/attributes/Country',
+                            newValue: [{ value: '', lookupCode: 'ALBY' }]
+                        }
+                    ]
+                } }));
+        });
+        it('should preserve lookup sub-attribute with lookupCode inside nested parent', function () {
+            var metadata = {
+                entityTypes: [
+                    {
+                        uri: 'configuration/entityTypes/HCP',
+                        attributes: [
+                            {
+                                uri: 'configuration/entityTypes/HCP/attributes/Details',
+                                name: 'Details',
+                                type: 'Nested',
+                                attributes: [
+                                    {
+                                        uri: 'configuration/entityTypes/HCP/attributes/Details/attributes/Country',
+                                        name: 'Country',
+                                        type: 'String'
+                                    },
+                                    {
+                                        uri: 'configuration/entityTypes/HCP/attributes/Details/attributes/Notes',
+                                        name: 'Notes',
+                                        type: 'String'
+                                    }
+                                ]
+                            }
+                        ]
+                    }
+                ]
+            };
+            var changes = {
+                'entities/456': [
+                    {
+                        id: 'added|nested1',
+                        type: DCRTypes.INSERT_ATTRIBUTE,
+                        attributePath: 'Details',
+                        attributeType: 'configuration/entityTypes/HCP/attributes/Details',
+                        newValue: {
+                            value: {
+                                Country: [{ value: '', lookupCode: 'ALBY' }],
+                                Notes: [{ value: '' }]
+                            }
+                        }
+                    }
+                ]
+            };
+            var notesLineData = [
+                ['456/added|nested1/newValue/value/Notes/0', { value: { value: 'User typed note' } }]
+            ];
+            var result = buildDCRSavePlan(changes, function (changeId) { return (changeId === 'added|nested1' ? notesLineData : []); }, metadata);
+            expect(result).toEqual(__assign(__assign({}, emptyPlan), { insertEntityAttributes: {
+                    'entities/456': [
+                        {
+                            type: 'INSERT_ATTRIBUTE',
+                            uri: 'entities/456/attributes/Details',
+                            newValue: [
+                                {
+                                    value: {
+                                        Country: [{ value: '', lookupCode: 'ALBY' }],
+                                        Notes: [{ value: 'User typed note' }]
+                                    }
+                                }
+                            ]
+                        }
+                    ]
+                } }));
+        });
+    });
 });

package/features/workflow/helpers/merge.d.ts

@@ -1,4 +1,7 @@
 import { GroupedObjectsInfo, Metadata, EnrichedDCRChanges, EnrichedChangeValue, ChangeValue, DCRChanges } from '@reltio/mdm-sdk';
 import { Diff } from '../types';
 export declare const extractLineIds: (value: ChangeValue | EnrichedChangeValue) => string[] | undefined;
+export declare const extractAddedId: (value: {
+    addedId?: string;
+}) => string | undefined;
 export declare const mergeChanges: (metadata: Metadata, changes: EnrichedDCRChanges | DCRChanges, entityInfo: GroupedObjectsInfo["entity"], relationsInfo: GroupedObjectsInfo["relations"]) => [Diff[], Diff[]];

package/features/workflow/helpers/merge.js

@@ -23,6 +23,9 @@ var SPECIAL_ATTRIBUTES_NAMES = [
 export var extractLineIds = function (value) {
     return typeof value === 'object' && 'lineIds' in value ? value.lineIds : undefined;
 };
+export var extractAddedId = function (value) {
+    return typeof value === 'object' && value !== null && 'addedId' in value ? value.addedId : undefined;
+};
 var prepareStartOrEndDate = function (_a) {
     var newValue = _a.newValue, oldValue = _a.oldValue;
     var actualNewValue = newValue && 'value' in newValue ? newValue.value : newValue;
@@ -68,6 +71,15 @@ var prepareStartOrEndDate = function (_a) {
             }
         ];
     }
+    var addedId = newValue === null || newValue === void 0 ? void 0 : newValue.addedId;
+    if (addedId) {
+        return [
+            {
+                type: DCRTypes.INSERT_ATTRIBUTE,
+                newValue: __assign({ value: undefined, lineIds: extractLineIds(newValue) }, (addedId && { addedId: addedId }))
+            }
+        ];
+    }
 };
 var prepareRolesOrTags = function (change) {
     var _a = change.newValue, newValue = _a === void 0 ? [] : _a, _b = change.oldValue, oldValue = _b === void 0 ? [] : _b;
@@ -75,11 +87,12 @@ var prepareRolesOrTags = function (change) {
     var preparedOldValue = 'value' in oldValue ? oldValue.value : oldValue;
     var diffNewValue = difference(preparedNewValue, preparedOldValue);
     var diffOldValue = difference(preparedOldValue, preparedNewValue);
+    var addedId = extractAddedId(newValue);
     var items = [];
     if (diffNewValue.length) {
         items.push({
             type: DCRTypes.INSERT_ATTRIBUTE,
-            newValue: { value: diffNewValue, lineIds: extractLineIds(newValue) }
+            newValue: __assign({ value: diffNewValue, lineIds: extractLineIds(newValue) }, (addedId && { addedId: addedId }))
         });
     }
     if (diffOldValue.length) {
@@ -88,6 +101,12 @@ var prepareRolesOrTags = function (change) {
             oldValue: { value: diffOldValue, lineIds: extractLineIds(oldValue) }
         });
     }
+    if (items.length === 0 && addedId) {
+        items.push({
+            type: DCRTypes.INSERT_ATTRIBUTE,
+            newValue: { value: [], lineIds: extractLineIds(newValue), addedId: addedId }
+        });
+    }
     return items;
 };
 var getPath = function (change) {
@@ -143,46 +162,38 @@ var createEntityOrRelation = function (metadata, value) {
         newObject['defaultProfilePicValue'] = [defaultProfilePicValue];
     }
     if (roles) {
+        var addedId = extractAddedId(roles);
         newObject[EntityAttrTypes.roles.name] = [
             {
                 type: DCRTypes.INSERT_ATTRIBUTE,
-                newValue: {
-                    value: roles.map(getRoleLabel(metadata)).join(', '),
-                    lineIds: lineIds && ["".concat(lineIds[0], "/").concat(EntityAttrTypes.roles.name)]
-                }
+                newValue: __assign({ value: addedId ? [] : roles.map(getRoleLabel(metadata)), lineIds: lineIds && ["".concat(lineIds[0], "/").concat(EntityAttrTypes.roles.name)] }, (addedId && { addedId: addedId }))
             }
         ];
     }
     if (tags) {
+        var addedId = extractAddedId(tags);
         newObject[EntityAttrTypes.tags.name] = [
             {
                 type: DCRTypes.INSERT_ATTRIBUTE,
-                newValue: {
-                    value: tags.join(', '),
-                    lineIds: lineIds && ["".concat(lineIds[0], "/").concat(EntityAttrTypes.tags.name)]
-                }
+                newValue: __assign({ value: addedId ? [] : tags, lineIds: lineIds && ["".concat(lineIds[0], "/").concat(EntityAttrTypes.tags.name)] }, (addedId && { addedId: addedId }))
             }
         ];
     }
-    if (startDate) {
+    if (startDate !== undefined) {
+        var addedId = extractAddedId(startDate);
         newObject[EntityAttrTypes.startDate.name] = [
             {
                 type: DCRTypes.INSERT_ATTRIBUTE,
-                newValue: {
-                    value: startDate,
-                    lineIds: lineIds && ["".concat(lineIds[0], "/").concat(EntityAttrTypes.startDate.name)]
-                }
+                newValue: __assign({ value: addedId ? undefined : startDate, lineIds: lineIds && ["".concat(lineIds[0], "/").concat(EntityAttrTypes.startDate.name)] }, (addedId && { addedId: addedId }))
             }
         ];
     }
-    if (endDate) {
+    if (endDate !== undefined) {
+        var addedId = extractAddedId(endDate);
         newObject[EntityAttrTypes.endDate.name] = [
             {
                 type: DCRTypes.INSERT_ATTRIBUTE,
-                newValue: {
-                    value: endDate,
-                    lineIds: lineIds && ["".concat(lineIds[0], "/").concat(EntityAttrTypes.endDate.name)]
-                }
+                newValue: __assign({ value: addedId ? undefined : endDate, lineIds: lineIds && ["".concat(lineIds[0], "/").concat(EntityAttrTypes.endDate.name)] }, (addedId && { addedId: addedId }))
             }
         ];
     }

package/features/workflow/helpers/merge.test.js

@@ -61,7 +61,8 @@ describe('mergeChanges tests', function () {
                     level: 1,
                     newValue: changes[entityUri][0].newValue,
                     operation: 'ignored',
-                    isReferenceSubAttribute: false
+                    isReferenceSubAttribute: false,
+                    attributePath: 'Identifiers/45uypcuAz/Type/45uypcyRF'
                 }
             ],
             []

package/features/workflow/helpers/moreAttributesScope.d.ts

@@ -0,0 +1,4 @@
+import { type AttributeType, type Metadata } from '@reltio/mdm-sdk';
+export declare const getAvailableAttributeTypesForEntity: (metadata: Metadata, entityTypeUri: string) => AttributeType[];
+export declare const getAvailableAttributeTypesForRelation: (metadata: Metadata, relationTypeUri: string) => AttributeType[];
+export declare const getAvailableSubAttributesForNestedOrReference: (metadata: Metadata, attributeType: AttributeType) => AttributeType[];

package/features/workflow/helpers/moreAttributesScope.js

@@ -0,0 +1,14 @@
+import { getAttributeTypeSubAttributes, getCreatableAttributeTypes, getEditableAttributeTypeSubAttributes, getRelationAttributesList, isReference, Mode } from '@reltio/mdm-sdk';
+import { getFilteredAttrTypes } from '../../../helpers/attributesView';
+export var getAvailableAttributeTypesForEntity = function (metadata, entityTypeUri) {
+    return getCreatableAttributeTypes(Mode.Suggesting, getFilteredAttrTypes(metadata, entityTypeUri, [], []));
+};
+export var getAvailableAttributeTypesForRelation = function (metadata, relationTypeUri) {
+    return getCreatableAttributeTypes(Mode.Suggesting, getRelationAttributesList(metadata, relationTypeUri));
+};
+export var getAvailableSubAttributesForNestedOrReference = function (metadata, attributeType) {
+    var subAttributes = isReference(attributeType)
+        ? getEditableAttributeTypeSubAttributes(metadata, attributeType) || []
+        : getAttributeTypeSubAttributes(metadata, attributeType) || [];
+    return getCreatableAttributeTypes(Mode.Suggesting, subAttributes);
+};