@reltio/components 1.4.2208 → 1.4.2210

package/features/workflow/helpers/validation.js

@@ -0,0 +1,326 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+import { clone } from 'ramda';
+import i18n from 'ui-i18n';
+import { findAttributeTypeByUri, DCRTypes, getRequiredAttributeTypesByTypeUri, buildError, ErrorType, getParentUri, findAttributeValuesByTypeUri, isEmptyValue, isOv, isIgnored, ErrorSource, evaluateErrorPath, isReference } from '@reltio/mdm-sdk';
+var ALLOWED_CHANGE_TYPES = [
+    DCRTypes.UPDATE_ATTRIBUTE,
+    DCRTypes.INSERT_ATTRIBUTE,
+    DCRTypes.DELETE_ATTRIBUTE,
+    DCRTypes.IGNORE_ATTRIBUTE
+];
+export var getValidationErrors = function (_a) {
+    var changes = _a.changes, userChanges = _a.userChanges, entitiesOrRelations = _a.entitiesOrRelations, metadata = _a.metadata;
+    var _b = validateTopLevelAttributes({
+        changes: changes,
+        userChanges: userChanges,
+        entitiesOrRelations: entitiesOrRelations,
+        metadata: metadata
+    }), topLevelErrors = _b.errors, topRejectedChangeIds = _b.topRejectedChangeIds;
+    var complexErrors = validateComplexAttributes({ changes: changes, userChanges: userChanges, metadata: metadata, topRejectedChangeIds: topRejectedChangeIds });
+    return __spreadArray(__spreadArray([], topLevelErrors, true), complexErrors, true);
+};
+var validateTopLevelAttributes = function (_a) {
+    var changes = _a.changes, userChanges = _a.userChanges, entitiesOrRelations = _a.entitiesOrRelations, metadata = _a.metadata;
+    var errors = [];
+    var topRejectedChangeIds = [];
+    var _loop_1 = function (entityUri) {
+        var entityOrRelation = entitiesOrRelations[entityUri];
+        var objectChanges = changes[entityUri] || [];
+        var requiredAttributeUris = getRequiredAttributeUris(metadata, entityOrRelation.type);
+        var changesByAttributePath = {};
+        objectChanges.forEach(function (change) {
+            var _a;
+            var attributeTypeUri = change.refAttributeType || change.attributeType;
+            if (!change.type ||
+                !ALLOWED_CHANGE_TYPES.includes(change.type) ||
+                !requiredAttributeUris.includes(change.attributeType || '')) {
+                return;
+            }
+            var foundUserChanges = getTopLevelUserChangesByChangeId(userChanges, change.id);
+            foundUserChanges.forEach(function (userChange) {
+                if (userChange.data.isRejected) {
+                    topRejectedChangeIds.push(change.id);
+                }
+            });
+            var hasUserChanges = foundUserChanges.length > 0;
+            var adjustedChange = adjustChangeWithUserChanges(change, foundUserChanges);
+            var currentAttributePath = getCurrentAttributePath(change.attributePath);
+            if (!changesByAttributePath[currentAttributePath]) {
+                var objectValues = findAttributeValuesByTypeUri(metadata, entityOrRelation, attributeTypeUri);
+                changesByAttributePath[currentAttributePath] = {
+                    changes: [],
+                    objectValues: objectValues,
+                    attributeTypeUri: attributeTypeUri,
+                    attributeType: findAttributeTypeByUri(metadata, attributeTypeUri),
+                    parentUri: getParentUri(change.attributePath),
+                    lineIds: []
+                };
+            }
+            if (adjustedChange) {
+                changesByAttributePath[currentAttributePath].changes.push(adjustedChange);
+            }
+            if (hasUserChanges) {
+                changesByAttributePath[currentAttributePath].hasUserChanges = true;
+            }
+            (_a = changesByAttributePath[currentAttributePath].lineIds).push.apply(_a, foundUserChanges.map(function (userChange) { return userChange.lineId; }));
+        });
+        Object.values(changesByAttributePath).forEach(function (_a) {
+            var _b;
+            var hasUserChanges = _a.hasUserChanges, objectValues = _a.objectValues, attributeChanges = _a.changes, attributeTypeUri = _a.attributeTypeUri, attributeType = _a.attributeType, parentUri = _a.parentUri, lineIds = _a.lineIds;
+            if (hasUserChanges && !hasAttributeValue(objectValues, attributeChanges, entityUri)) {
+                var valueUri = (_b = objectValues === null || objectValues === void 0 ? void 0 : objectValues[0]) === null || _b === void 0 ? void 0 : _b.uri;
+                errors.push(createRequiredError({
+                    attributeType: attributeType,
+                    attributeTypeUri: attributeTypeUri,
+                    parentUri: parentUri,
+                    lineIds: lineIds,
+                    metadata: metadata,
+                    entityUri: entityUri,
+                    entitiesMap: entitiesOrRelations,
+                    valueUri: valueUri
+                }));
+            }
+        });
+    };
+    for (var entityUri in entitiesOrRelations) {
+        _loop_1(entityUri);
+    }
+    return { errors: errors, topRejectedChangeIds: topRejectedChangeIds };
+};
+var validateComplexAttributes = function (_a) {
+    var changes = _a.changes, userChanges = _a.userChanges, metadata = _a.metadata, _b = _a.topRejectedChangeIds, topRejectedChangeIds = _b === void 0 ? [] : _b;
+    var errors = [];
+    var _loop_2 = function (entityUri) {
+        var objectChanges = changes[entityUri] || [];
+        objectChanges.forEach(function (change) {
+            var _a, _b, _c, _d;
+            if (topRejectedChangeIds.includes(change.id)) {
+                return;
+            }
+            var hasComplexValue = (typeof ((_a = change.newValue) === null || _a === void 0 ? void 0 : _a.value) === 'object' &&
+                !Array.isArray((_b = change.newValue) === null || _b === void 0 ? void 0 : _b.value)) ||
+                (typeof ((_c = change.oldValue) === null || _c === void 0 ? void 0 : _c.value) === 'object' &&
+                    !Array.isArray((_d = change.oldValue) === null || _d === void 0 ? void 0 : _d.value));
+            var isCreateType = change.type === DCRTypes.CREATE_ENTITY || change.type === DCRTypes.CREATE_RELATIONSHIP;
+            if (!hasComplexValue && !isCreateType) {
+                return;
+            }
+            var foundUserChanges = getUserChangesByChangeId(userChanges, change.id);
+            var complexErrors = validateRequiredComplexAttributes({
+                metadata: metadata,
+                change: change,
+                userChanges: foundUserChanges,
+                entityUri: entityUri
+            });
+            errors.push.apply(errors, complexErrors);
+        });
+    };
+    for (var entityUri in changes) {
+        _loop_2(entityUri);
+    }
+    return errors;
+};
+var getTopLevelUserChangesByChangeId = function (userChanges, changeId) {
+    return getUserChangesByChangeId(userChanges, changeId).filter(function (userChange) { return userChange.lineId.split('/').length === 3; });
+};
+var getUserChangesByChangeId = function (userChanges, changeId) {
+    return userChanges.filter(function (userChange) { return userChange.lineId.split('/')[1] === changeId; });
+};
+var getIsChangeRejected = function (userChanges, changeType) {
+    if (userChanges.length === 0)
+        return false;
+    var isInsertType = changeType === DCRTypes.INSERT_ATTRIBUTE;
+    return userChanges.some(function (userChange) { var _a; return userChange.data.isRejected || (isInsertType && isEmptyValue((_a = userChange.data.value) === null || _a === void 0 ? void 0 : _a.value)); });
+};
+var adjustChangeWithUserChanges = function (change, userChanges) {
+    var _a;
+    if (getIsChangeRejected(userChanges, change.type)) {
+        return null;
+    }
+    if (change.type === DCRTypes.UPDATE_ATTRIBUTE && userChanges.length > 0) {
+        if (isEmptyValue((_a = userChanges[0].data.value) === null || _a === void 0 ? void 0 : _a.value)) {
+            return __assign(__assign({}, change), { type: DCRTypes.DELETE_ATTRIBUTE });
+        }
+    }
+    return change;
+};
+var getCurrentAttributePath = function (attributePath) {
+    var parts = attributePath.split('/');
+    return parts.slice(0, parts.length % 2 === 0 ? parts.length - 1 : parts.length).join('/');
+};
+var getEntityValueUri = function (entityOrRelationTypeUri, change) {
+    if (change.refObjectURI) {
+        var relationId = change.refObjectURI.split('/').pop();
+        var refAttributeTypeParts = change.refAttributeType.split('/attributes/');
+        return "".concat(entityOrRelationTypeUri, "/attributes/").concat(refAttributeTypeParts[1], "/").concat(relationId, "/").concat(change.attributePath);
+    }
+    return "".concat(entityOrRelationTypeUri, "/attributes/").concat(change.attributePath);
+};
+var hasAttributeValue = function (objectValues, changes, entityUri) {
+    var values = clone(objectValues);
+    var _loop_3 = function (change) {
+        if (change.type === DCRTypes.UPDATE_ATTRIBUTE || change.type === DCRTypes.INSERT_ATTRIBUTE) {
+            return { value: true };
+        }
+        var valueUri = getEntityValueUri(entityUri, change);
+        var valueIndex = values.findIndex(function (value) { return value.uri === valueUri; });
+        if (change.type === DCRTypes.DELETE_ATTRIBUTE) {
+            if (valueIndex !== -1) {
+                values.splice(valueIndex, 1);
+            }
+        }
+        else if (change.type === DCRTypes.IGNORE_ATTRIBUTE && valueIndex !== -1) {
+            values[valueIndex].ignored = change.newPinOrIgnoreValue;
+        }
+    };
+    for (var _i = 0, changes_1 = changes; _i < changes_1.length; _i++) {
+        var change = changes_1[_i];
+        var state_1 = _loop_3(change);
+        if (typeof state_1 === "object")
+            return state_1.value;
+    }
+    return values.filter(isOv).filter(function (value) { return !isIgnored(value); }).length > 0;
+};
+var getEntityTypeUriFromAttributeUri = function (attributeUri) {
+    return attributeUri.split('/').slice(0, 3).join('/');
+};
+var getAttributeTypeUriFromLineId = function (attributeTypeUri, lineId) {
+    var EXCLUDED_PARTS = new Set(['value', 'newValue', 'oldValue', 'attributes']);
+    var lineParts = lineId
+        .split('/')
+        .slice(2)
+        .filter(function (part) {
+        if (!isNaN(Number(part)))
+            return false;
+        return !EXCLUDED_PARTS.has(part);
+    });
+    return __spreadArray([attributeTypeUri], lineParts, true).join('/attributes/');
+};
+var getEntityTypeUriFromChange = function (change) {
+    if (change.type === DCRTypes.CREATE_ENTITY || change.type === DCRTypes.CREATE_RELATIONSHIP) {
+        return change.objectType || '';
+    }
+    return getEntityTypeUriFromAttributeUri(change.attributeType || change.objectType || '');
+};
+var getRequiredAttributeUris = function (metadata, typeUri) {
+    var requiredAttrTypes = getRequiredAttributeTypesByTypeUri(metadata, typeUri, true) || [];
+    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 error = buildError({
+        type: ErrorType.missed,
+        attributeType: attributeType,
+        attributeTypeUri: attributeTypeUri,
+        parentUri: parentUri,
+        message: i18n.text('Attribute is required'),
+        source: ErrorSource.local,
+        alwaysShow: true,
+        uri: lineIds[0]
+    });
+    var path = [];
+    if ((entitiesMap === null || entitiesMap === void 0 ? void 0 : entitiesMap[entityUri]) && valueUri) {
+        path = evaluateErrorPath({
+            entityUri: entityUri,
+            metadata: metadata,
+            entitiesMap: entitiesMap
+        }, valueUri);
+    }
+    return {
+        error: __assign(__assign({}, error), { path: path }),
+        lineIds: lineIds
+    };
+};
+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) {
+        return [];
+    }
+    var valueHolder = change.type === DCRTypes.CREATE_ENTITY || change.type === DCRTypes.CREATE_RELATIONSHIP ? 'attributes' : 'value';
+    var rootAttributeTypeUri = change.refAttributeType || change.attributeType || change.objectType;
+    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 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 collectErrors = function (attributes) {
+        var errors = [];
+        var visitValue = function (value, path) {
+            var isRejected = checkIsChangeRejected(path.slice(0, -1).join('/'));
+            if (typeof value === 'string') {
+                return !isRejected;
+            }
+            if (isRejected) {
+                return false;
+            }
+            var anyFieldHasValue = false;
+            Object.entries(value).forEach(function (_a) {
+                var fieldName = _a[0], subAttributes = _a[1];
+                var anyChildHasValue = false;
+                var attributePath = __spreadArray(__spreadArray([], path, true), [fieldName], false);
+                var rejectedLineIds = [];
+                subAttributes.forEach(function (subAttribute, index) {
+                    var childPath = __spreadArray(__spreadArray([], attributePath, true), [index, 'value'], false);
+                    var childHasValue = visitValue(subAttribute.value, childPath);
+                    if (!childHasValue) {
+                        rejectedLineIds.push(calculateLineIdFromPath(childPath.slice(0, -1).join('/')));
+                    }
+                    anyChildHasValue = anyChildHasValue || childHasValue;
+                });
+                anyFieldHasValue = anyFieldHasValue || anyChildHasValue;
+                if (!anyChildHasValue) {
+                    var attributeTypeUri = getAttributeTypeUriFromLineId(isReferenceType ? entityTypeUri : rootAttributeTypeUri, rejectedLineIds[0]);
+                    var isRequired = requiredAttributeUris.includes(attributeTypeUri);
+                    if (isRequired) {
+                        errors.push(createRequiredError({
+                            attributeType: findAttributeTypeByUri(metadata, attributeTypeUri),
+                            attributeTypeUri: attributeTypeUri,
+                            lineIds: rejectedLineIds
+                        }));
+                    }
+                }
+            });
+            return anyFieldHasValue;
+        };
+        var hasValue = visitValue(attributes, [valueHolder]);
+        if (!hasValue && attributeType.required) {
+            errors.push(createRequiredError({
+                attributeType: attributeType,
+                attributeTypeUri: attributeType.uri,
+                lineIds: [calculateLineIdFromPath()]
+            }));
+        }
+        return errors;
+    };
+    return collectErrors((_b = change.newValue) === null || _b === void 0 ? void 0 : _b[valueHolder]);
+};

package/features/workflow/hooks/useApplyDcrChanges.js

@@ -41,30 +41,40 @@ import { isEmpty } from 'ramda';
 import { useMdmMetadata } from '../../../contexts/MdmModuleContext';
 import { ChangeRequestEditorContext } from '../contexts/ChangeRequestEditorContext';
 import { buildDCRSavePlan } from '../helpers/dcr';
+import { useDCRValidation } from './useDCRValidation';
 var withChangeRequestId = function (dcrUri) { return function (url) {
     return url + (url.includes('?') ? '&' : '?') + "changeRequestId=".concat(encodeURIComponent(dcrUri.split('/')[1]));
 }; };
 export var useApplyDcrChanges = function (dcr) {
     var getLinesByChangeId = useContextSelector(ChangeRequestEditorContext, function (context) { return context.getLinesByChangeId; });
     var metadata = useMdmMetadata();
+    var getErrors = useDCRValidation(dcr);
     var applyDcrChanges = useCallback(function () { return __awaiter(void 0, void 0, void 0, function () {
-        var _a, rejectedChangeIds, updatedChanges, deleteEntityAttributes, deleteRelationAttributes, deleteChangeResults, deleteEntityAttributesResults, deleteRelationAttributesResults, deleteChangeFailures, error_1, deleteEntityAttributesFailures, deleteRelationAttributesFailures;
+        var errors, _a, rejectedChangeIds, updatedChanges, deleteEntityAttributes, deleteRelationAttributes, deleteChangeResults, deleteEntityAttributesResults, deleteRelationAttributesResults, deleteChangeFailures, error_1, deleteEntityAttributesFailures, deleteRelationAttributesFailures;
         return __generator(this, function (_b) {
             switch (_b.label) {
                 case 0:
-                    if (!(dcr === null || dcr === void 0 ? void 0 : dcr.changes)) return [3 /*break*/, 11];
+                    if (!(dcr === null || dcr === void 0 ? void 0 : dcr.changes)) return [3 /*break*/, 12];
+                    return [4 /*yield*/, getErrors()];
+                case 1:
+                    errors = _b.sent();
+                    if (errors.length > 0) {
+                        return [2 /*return*/, {
+                                proceed: false
+                            }];
+                    }
                     _a = buildDCRSavePlan(dcr.changes, getLinesByChangeId, metadata), rejectedChangeIds = _a.rejectedChangeIds, updatedChanges = _a.updatedChanges, deleteEntityAttributes = _a.deleteEntityAttributes, deleteRelationAttributes = _a.deleteRelationAttributes;
                     deleteChangeResults = [];
                     deleteEntityAttributesResults = [];
                     deleteRelationAttributesResults = [];
-                    if (!(rejectedChangeIds.length > 0)) return [3 /*break*/, 2];
+                    if (!(rejectedChangeIds.length > 0)) return [3 /*break*/, 3];
                     return [4 /*yield*/, promiseAllSettled(rejectedChangeIds.map(function (changeId) {
                             return deleteChangeRequestItem({ dcrUri: dcr.uri, changeItemId: changeId });
                         }))];
-                case 1:
-                    deleteChangeResults = _b.sent();
-                    _b.label = 2;
                 case 2:
+                    deleteChangeResults = _b.sent();
+                    _b.label = 3;
+                case 3:
                     deleteChangeFailures = deleteChangeResults.filter(function (result) { return result.status === 'rejected'; });
                     if (deleteChangeFailures.length) {
                         return [2 /*return*/, {
@@ -72,22 +82,22 @@ export var useApplyDcrChanges = function (dcr) {
                                 error: new Error("Failed to delete DCR change(s): ".concat(deleteChangeFailures.map(function (result) { return result.reason; }).join(', ')))
                             }];
                     }
-                    if (!!isEmpty(updatedChanges)) return [3 /*break*/, 6];
-                    _b.label = 3;
-                case 3:
-                    _b.trys.push([3, 5, , 6]);
-                    return [4 /*yield*/, updateChangeRequest({ dcrUri: dcr.uri, payload: updatedChanges })];
+                    if (!!isEmpty(updatedChanges)) return [3 /*break*/, 7];
+                    _b.label = 4;
                 case 4:
-                    _b.sent();
-                    return [3 /*break*/, 6];
+                    _b.trys.push([4, 6, , 7]);
+                    return [4 /*yield*/, updateChangeRequest({ dcrUri: dcr.uri, payload: updatedChanges })];
                 case 5:
+                    _b.sent();
+                    return [3 /*break*/, 7];
+                case 6:
                     error_1 = _b.sent();
                     return [2 /*return*/, {
                             proceed: false,
                             error: error_1
                         }];
-                case 6:
-                    if (!!isEmpty(deleteEntityAttributes)) return [3 /*break*/, 8];
+                case 7:
+                    if (!!isEmpty(deleteEntityAttributes)) return [3 /*break*/, 9];
                     return [4 /*yield*/, promiseAllSettled(Object.entries(deleteEntityAttributes).map(function (_a) {
                             var entityUri = _a[0], diff = _a[1];
                             return entityCumulativeUpdate({
@@ -96,10 +106,10 @@ export var useApplyDcrChanges = function (dcr) {
                                 uriPreprocessor: withChangeRequestId(dcr.uri)
                             });
                         }))];
-                case 7:
-                    deleteEntityAttributesResults = _b.sent();
-                    _b.label = 8;
                 case 8:
+                    deleteEntityAttributesResults = _b.sent();
+                    _b.label = 9;
+                case 9:
                     deleteEntityAttributesFailures = deleteEntityAttributesResults.filter(function (result) { return result.status === 'rejected'; });
                     if (deleteEntityAttributesFailures.length) {
                         return [2 /*return*/, {
@@ -107,7 +117,7 @@ export var useApplyDcrChanges = function (dcr) {
                                 error: new Error("Failed to delete entity attributes: ".concat(deleteEntityAttributesFailures.map(function (result) { return result.reason; }).join(', ')))
                             }];
                     }
-                    if (!!isEmpty(deleteRelationAttributes)) return [3 /*break*/, 10];
+                    if (!!isEmpty(deleteRelationAttributes)) return [3 /*break*/, 11];
                     return [4 /*yield*/, promiseAllSettled(Object.entries(deleteRelationAttributes).map(function (_a) {
                             var relationUri = _a[0], diff = _a[1];
                             return updateRelationWithDiff({
@@ -116,10 +126,10 @@ export var useApplyDcrChanges = function (dcr) {
                                 uriPreprocessor: withChangeRequestId(dcr.uri)
                             });
                         }))];
-                case 9:
-                    deleteRelationAttributesResults = _b.sent();
-                    _b.label = 10;
                 case 10:
+                    deleteRelationAttributesResults = _b.sent();
+                    _b.label = 11;
+                case 11:
                     deleteRelationAttributesFailures = deleteRelationAttributesResults.filter(function (result) { return result.status === 'rejected'; });
                     if (deleteRelationAttributesFailures.length) {
                         return [2 /*return*/, {
@@ -130,12 +140,12 @@ export var useApplyDcrChanges = function (dcr) {
                     return [2 /*return*/, {
                             proceed: true
                         }];
-                case 11: return [2 /*return*/, {
+                case 12: return [2 /*return*/, {
                         proceed: false,
                         error: new Error('No changes to apply')
                     }];
             }
         });
-    }); }, [dcr, getLinesByChangeId, metadata]);
+    }); }, [dcr, getLinesByChangeId, metadata, getErrors]);
     return applyDcrChanges;
 };

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

@@ -0,0 +1,5 @@
+import { ChangeRequest } from '@reltio/mdm-sdk';
+export declare const useDCRValidation: (dcr: ChangeRequest) => () => Promise<{
+    error: import("@reltio/mdm-sdk").AttributeError;
+    lineIds: string[];
+}[]>;

package/features/workflow/hooks/useDCRValidation.js

@@ -0,0 +1,149 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import { useMemo, useEffect, useCallback, useRef } from 'react';
+import { useContextSelector } from '@fluentui/react-context-selector';
+import { DCRTypes, isRelationUri, getRelation, findConnectionRelationObjectByRelationUri } from '@reltio/mdm-sdk';
+import { useMdmMetadata, useMdmEntity, useMdmDcrReviewValidation } from '../../../contexts/MdmModuleContext';
+import { useSafePromise } from '../../../hooks/useSafePromise';
+import { MdmModuleValuesContext } from '../../../contexts/MdmModuleContext/context';
+import { ChangeRequestEditorContext } from '../contexts/ChangeRequestEditorContext';
+import { getValidationErrors } from '../helpers/validation';
+export var useDCRValidation = function (dcr) {
+    var metadata = useMdmMetadata();
+    var currentEntity = useMdmEntity();
+    var dcrReviewValidation = useMdmDcrReviewValidation();
+    var relationsState = useContextSelector(MdmModuleValuesContext, function (context) { return context.relations; });
+    var getAllChanges = useContextSelector(ChangeRequestEditorContext, function (context) { return context.getAllChanges; });
+    var setErrors = useContextSelector(ChangeRequestEditorContext, function (context) { return context.setErrors; });
+    var relationsRef = useRef(null);
+    var safePromise = useSafePromise();
+    var findRelationInStore = useCallback(function (uri) {
+        if (!relationsState)
+            return null;
+        for (var viewId in relationsState) {
+            var viewState = relationsState[viewId];
+            if (viewState === null || viewState === void 0 ? void 0 : viewState.connections) {
+                return findConnectionRelationObjectByRelationUri(viewState.connections, uri);
+            }
+        }
+        return null;
+    }, [relationsState]);
+    var urisFromDcr = useMemo(function () {
+        var result = [];
+        if (!(dcr === null || dcr === void 0 ? void 0 : dcr.changes))
+            return result;
+        for (var key in dcr.changes) {
+            var changes = dcr.changes[key] || [];
+            var hasCreate = changes.some(function (c) { return (c === null || c === void 0 ? void 0 : c.type) === DCRTypes.CREATE_ENTITY || (c === null || c === void 0 ? void 0 : c.type) === DCRTypes.CREATE_RELATIONSHIP; });
+            if (!hasCreate) {
+                result.push(key);
+            }
+        }
+        return result;
+    }, [dcr]);
+    var localObjects = useMemo(function () {
+        var currentEntityObject = {};
+        currentEntityObject[currentEntity === null || currentEntity === void 0 ? void 0 : currentEntity.uri] = currentEntity;
+        return urisFromDcr.reduce(function (acc, uri) {
+            if (isRelationUri(uri)) {
+                var localRelation = findRelationInStore(uri);
+                if (localRelation) {
+                    acc[uri] = localRelation;
+                }
+            }
+            return acc;
+        }, currentEntityObject);
+    }, [urisFromDcr, findRelationInStore, currentEntity]);
+    useEffect(function () {
+        if (!dcrReviewValidation || !urisFromDcr.length || (relationsRef === null || relationsRef === void 0 ? void 0 : relationsRef.current))
+            return;
+        var relationsPromises = [];
+        urisFromDcr.forEach(function (uri) {
+            if (isRelationUri(uri) && !localObjects[uri]) {
+                relationsPromises.push(getRelation(uri));
+            }
+        });
+        relationsRef.current = safePromise(Promise.all(relationsPromises));
+    }, [dcrReviewValidation, urisFromDcr, findRelationInStore, safePromise, localObjects]);
+    var getErrors = useCallback(function () { return __awaiter(void 0, void 0, void 0, function () {
+        var relations, _a, loadedRelationsObject, objectsByUri, userChanges, errors;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    if (!dcrReviewValidation) {
+                        return [2 /*return*/, []];
+                    }
+                    if (!relationsRef.current) return [3 /*break*/, 2];
+                    return [4 /*yield*/, relationsRef.current];
+                case 1:
+                    _a = _b.sent();
+                    return [3 /*break*/, 3];
+                case 2:
+                    _a = [];
+                    _b.label = 3;
+                case 3:
+                    relations = _a;
+                    loadedRelationsObject = relations.reduce(function (acc, relation) {
+                        acc[relation.uri] = relation;
+                        return acc;
+                    }, {});
+                    objectsByUri = __assign(__assign({}, localObjects), loadedRelationsObject);
+                    userChanges = getAllChanges();
+                    errors = getValidationErrors({
+                        changes: dcr === null || dcr === void 0 ? void 0 : dcr.changes,
+                        userChanges: userChanges,
+                        entitiesOrRelations: objectsByUri,
+                        metadata: metadata
+                    });
+                    setErrors(errors);
+                    return [2 /*return*/, errors];
+            }
+        });
+    }); }, [dcrReviewValidation, dcr === null || dcr === void 0 ? void 0 : dcr.changes, getAllChanges, localObjects, metadata, setErrors]);
+    return getErrors;
+};

package/features/workflow/types.d.ts

@@ -1,4 +1,4 @@
-import { AttributeType, DCRAttributeValue, DCROperationTypes, DCRRelationInfo, EnrichedChangeValue, TRelationType, ChangeValue } from '@reltio/mdm-sdk';
+import { AttributeType, DCRAttributeValue, DCROperationTypes, DCRRelationInfo, EnrichedChangeValue, TRelationType, ChangeValue, SimpleAttributeValue, PrimitiveValue } from '@reltio/mdm-sdk';
 export type TaskAction = {
     text: string;
     onClick: (comment: string) => void;
@@ -23,3 +23,10 @@ export type BeforeActionOutcome = {
     proceed: boolean;
     error?: unknown;
 };
+export type LineDataValue = SimpleAttributeValue | {
+    value: string[] | PrimitiveValue;
+};
+export type LineData = {
+    value?: LineDataValue;
+    isRejected?: boolean;
+};

package/hooks/useScrollToAttributeError/useScrollToAttributeError.d.ts

@@ -3,8 +3,9 @@ import { ScrollToElementContext } from '../../contexts/ScrollToElementContext';
 type Props = {
     highlightedError: ContextType<typeof ScrollToElementContext> | null;
     isSimple?: boolean;
+    className?: string;
 };
-export declare const useScrollToAttributeError: ({ highlightedError: context, isSimple }: Props) => {
+export declare const useScrollToAttributeError: ({ highlightedError: context, isSimple, className }: Props) => {
     ref: import("react").MutableRefObject<HTMLDivElement>;
     errorClassName: string;
 } | {

package/hooks/useScrollToAttributeError/useScrollToAttributeError.js

@@ -5,7 +5,7 @@ import { ErrorSeverity } from '@reltio/mdm-sdk';
 import { useStyles } from './styles';
 export var useScrollToAttributeError = function (_a) {
     var _b;
-    var context = _a.highlightedError, _c = _a.isSimple, isSimple = _c === void 0 ? false : _c;
+    var context = _a.highlightedError, _c = _a.isSimple, isSimple = _c === void 0 ? false : _c, className = _a.className;
     var styles = useStyles();
     var ref = useRef(null);
     var severity = pathOr(ErrorSeverity.ERROR, ['element', 'severity'])(context);
@@ -13,7 +13,7 @@ export var useScrollToAttributeError = function (_a) {
         _b[styles.highlightError] = severity === ErrorSeverity.ERROR,
         _b[styles.highlightWarning] = severity === ErrorSeverity.WARNING,
         _b[styles.simpleAttribute] = isSimple,
-        _b));
+        _b), className);
     useEffect(function () {
         if (context) {
             context.scrollIntoRef(ref);