@reltio/components 1.4.2243 → 1.4.2244

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) {
@@ -57,7 +100,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 +112,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 +152,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 +170,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 +196,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 +206,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,12 +239,14 @@ 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'
@@ -205,7 +271,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 +294,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: {} };
@@ -144,4 +144,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);
+};

package/features/workflow/helpers/validation.js

@@ -226,13 +226,13 @@ var getRequiredAttributeUris = function (metadata, typeUri) {
     return requiredAttrTypes.map(function (attr) { return attr.uri; });
 };
 var createRequiredError = function (_a) {
-    var attributeType = _a.attributeType, attributeTypeUri = _a.attributeTypeUri, parentUri = _a.parentUri, lineIds = _a.lineIds, metadata = _a.metadata, entityUri = _a.entityUri, entitiesMap = _a.entitiesMap, valueUri = _a.valueUri;
+    var attributeType = _a.attributeType, attributeTypeUri = _a.attributeTypeUri, parentUri = _a.parentUri, lineIds = _a.lineIds, metadata = _a.metadata, entityUri = _a.entityUri, entitiesMap = _a.entitiesMap, valueUri = _a.valueUri, _b = _a.errorType, errorType = _b === void 0 ? ErrorType.missed : _b, _c = _a.message, message = _c === void 0 ? i18n.text('Attribute is required') : _c;
     var error = buildError({
-        type: ErrorType.missed,
+        type: errorType,
         attributeType: attributeType,
         attributeTypeUri: attributeTypeUri,
         parentUri: parentUri,
-        message: i18n.text('Attribute is required'),
+        message: message,
         source: ErrorSource.local,
         uri: lineIds[0]
     });
@@ -252,27 +252,37 @@ var createRequiredError = function (_a) {
 var validateRequiredComplexAttributes = function (_a) {
     var _b;
     var metadata = _a.metadata, change = _a.change, userChanges = _a.userChanges, entityUri = _a.entityUri;
-    if (userChanges.length === 0 || change.type === DCRTypes.DELETE_ATTRIBUTE) {
+    if (change.type === DCRTypes.DELETE_ATTRIBUTE) {
         return [];
     }
     var valueHolder = change.type === DCRTypes.CREATE_ENTITY || change.type === DCRTypes.CREATE_RELATIONSHIP ? 'attributes' : 'value';
     var rootAttributeTypeUri = change.refAttributeType || change.attributeType || change.objectType;
+    if (!rootAttributeTypeUri) {
+        return [];
+    }
     var attributeType = findAttributeTypeByUri(metadata, rootAttributeTypeUri);
     var isReferenceType = isReference(attributeType);
-    var entityTypeUri = isReferenceType ? attributeType.relationshipTypeURI : getEntityTypeUriFromChange(change);
-    var requiredAttributeUris = getRequiredAttributeUris(metadata, entityTypeUri);
     var calculateLineIdFromPath = function (path) {
         if (path === void 0) { path = ''; }
         var entityId = entityUri.split('/').pop() || '';
         return "".concat(entityId, "/").concat(change.id, "/newValue").concat(path ? "/".concat(path) : '');
     };
+    var entityTypeUri = isReferenceType ? attributeType.relationshipTypeURI : getEntityTypeUriFromChange(change);
+    var requiredAttributeUris = getRequiredAttributeUris(metadata, entityTypeUri);
     var checkIsChangeRejected = function (path) {
         var _a, _b, _c;
         var searchLineId = calculateLineIdFromPath(path);
         var lineUserChanges = userChanges.find(function (userChange) { return userChange.lineId === searchLineId; });
         return (((_a = lineUserChanges === null || lineUserChanges === void 0 ? void 0 : lineUserChanges.data) === null || _a === void 0 ? void 0 : _a.isRejected) || (lineUserChanges && isEmptyValue((_c = (_b = lineUserChanges === null || lineUserChanges === void 0 ? void 0 : lineUserChanges.data) === null || _b === void 0 ? void 0 : _b.value) === null || _c === void 0 ? void 0 : _c.value)));
     };
+    var checkHasUserValue = function (path) {
+        var _a, _b;
+        var searchLineId = calculateLineIdFromPath(path);
+        var lineUserChange = userChanges.find(function (userChange) { return userChange.lineId === searchLineId; });
+        return Boolean(lineUserChange && !isEmptyValue((_b = (_a = lineUserChange.data) === null || _a === void 0 ? void 0 : _a.value) === null || _b === void 0 ? void 0 : _b.value));
+    };
     var collectErrors = function (attributes) {
+        var _a;
         var errors = [];
         var visitValue = function (value, path) {
             var isRejected = checkIsChangeRejected(path.slice(0, -1).join('/'));
@@ -282,6 +292,9 @@ var validateRequiredComplexAttributes = function (_a) {
             if (isRejected) {
                 return false;
             }
+            if (value === undefined) {
+                return checkHasUserValue(path.slice(0, -1).join('/'));
+            }
             var anyFieldHasValue = false;
             Object.entries(value).forEach(function (_a) {
                 var fieldName = _a[0], subAttributes = _a[1];
@@ -319,6 +332,18 @@ var validateRequiredComplexAttributes = function (_a) {
                 lineIds: [calculateLineIdFromPath()]
             }));
         }
+        if (isReferenceType && change.type === DCRTypes.INSERT_ATTRIBUTE) {
+            var refEntity = (_a = change.newValue) === null || _a === void 0 ? void 0 : _a.refEntity;
+            if (!(refEntity === null || refEntity === void 0 ? void 0 : refEntity.objectURI)) {
+                errors.push(createRequiredError({
+                    attributeType: attributeType,
+                    attributeTypeUri: attributeType.uri,
+                    lineIds: [calculateLineIdFromPath()],
+                    errorType: ErrorType.missedRefEntity,
+                    message: i18n.text('Entity is required')
+                }));
+            }
+        }
         return errors;
     };
     return collectErrors((_b = change.newValue) === null || _b === void 0 ? void 0 : _b[valueHolder]);

package/features/workflow/hooks/useApplyDcrChanges.d.ts

@@ -1,3 +1,3 @@
-import { ChangeRequest } from '@reltio/mdm-sdk';
-import { BeforeActionOutcome } from '../types';
+import { type ChangeRequest } from '@reltio/mdm-sdk';
+import type { BeforeActionOutcome } from '../types';
 export declare const useApplyDcrChanges: (dcr: ChangeRequest) => () => Promise<BeforeActionOutcome>;