@reltio/components 1.4.2233 → 1.4.2234

package/EntitySelector/EntitySelector.js

@@ -94,7 +94,7 @@ export var EntitySelector = function (_a) {
         return (__assign(__assign({}, (TextFieldProps || {})), (_a = {}, _a['data-reltio-id'] = 'reltio-entity-selector', _a)));
     }, [TextFieldProps]);
     return (React.createElement(React.Fragment, null,
-        React.createElement(DropDownSelector, __assign({ value: !isEmpty(entity) ? entity : undefined, inputValue: inputValue, onInputChange: handleInputChange, getOptions: getOptions, getOptionLabel: prop('entityLabel'), onChange: handleChange, onCreate: handleCreate, onClear: handleClear, label: label, createLabel: createLabel, canCreateOption: canCreateEntity, components: __assign(__assign({ Option: EntityOption, SingleValue: SingleValue }, groupComponent), clearComponent), currentEntityType: currentEntityType, isClearable: true, disableLinkClick: disableLinkClick, TextFieldProps: textFieldProps }, dropDownSelectorProps)),
+        React.createElement(DropDownSelector, __assign({ key: entityTypesUris.join(','), value: !isEmpty(entity) ? entity : undefined, inputValue: inputValue, onInputChange: handleInputChange, getOptions: getOptions, getOptionLabel: prop('entityLabel'), onChange: handleChange, onCreate: handleCreate, onClear: handleClear, label: label, createLabel: createLabel, canCreateOption: canCreateEntity, components: __assign(__assign({ Option: EntityOption, SingleValue: SingleValue }, groupComponent), clearComponent), currentEntityType: currentEntityType, isClearable: true, disableLinkClick: disableLinkClick, TextFieldProps: textFieldProps }, dropDownSelectorProps)),
         isTempEntity && (React.createElement("div", { "data-reltio-id": "entity-creator", className: styles.creatorWrapper },
             React.createElement(EntityCreator, { mode: mode, attributeTypesSelectionStrategy: attributeTypesSelectionStrategy, entityType: currentEntityType, entityUri: entity.entityUri })))));
 };

package/EntitySelector/EntitySelector.test.js

@@ -385,6 +385,29 @@ describe('Entity selector tests', function () {
             }
         });
     }); });
+    it('should call typeAheadSearch with new entity types when entityTypesUris prop changes after rerender', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var initialProps, _a, user, rerender, updatedProps;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    initialProps = __assign(__assign({}, defaultProps), { entityTypesUris: ['configuration/entityTypes/HCP'] });
+                    _a = setUp({ props: initialProps }), user = _a.user, rerender = _a.rerender;
+                    return [4 /*yield*/, user.click(screen.getByTestId('select-dropdown-indicator'))];
+                case 1:
+                    _b.sent();
+                    expect(typeAheadSearch).toHaveBeenCalledWith([defaultMetadata.entityTypes[0]], '', expect.any(Object));
+                    typeAheadSearch.mockClear();
+                    updatedProps = __assign(__assign({}, defaultProps), { entityTypesUris: ['configuration/entityTypes/HCP', 'configuration/entityTypes/Company'] });
+                    rerender(React.createElement(MdmModuleProvider, { values: defaultMdmValues, actions: defaultMdmActions },
+                        React.createElement(EntitySelector, __assign({}, updatedProps))));
+                    return [4 /*yield*/, user.click(screen.getByTestId('select-dropdown-indicator'))];
+                case 2:
+                    _b.sent();
+                    expect(typeAheadSearch).toHaveBeenCalledWith([defaultMetadata.entityTypes[0], defaultMetadata.entityTypes[1]], '', expect.any(Object));
+                    return [2 /*return*/];
+            }
+        });
+    }); });
     it('should render create button and handle click correctly for single entity type in case of onCreate prop is passed and input is filled', function () { return __awaiter(void 0, void 0, void 0, function () {
         var props, user;
         return __generator(this, function (_a) {

package/RelationEditor/RelationEditor.js

@@ -15,7 +15,7 @@ import classnames from 'classnames';
 import { always, assoc, concat, differenceWith, equals, forEach, map, path, pick, pipe, prop, propEq, when, uniq, curry, values, flatten, any } from 'ramda';
 import Button from '@mui/material/Button';
 import Typography from '@mui/material/Typography';
-import { createTemporaryEntity, findRelatedTemporaryEntities, getActivenessAttributes, getCreatableAttributeTypes, getEntityType, getErrorMessage, getErrorId, omitMarks, relationEditorAttributeTypesSelectionStrategy, validateConnection, updateConnectionEntityLabel, isTempUri, isEmptyValue, getRelationAttributesList, getDefaultRelationTypeObject, getInOutRelations, isSuggestMode, isAttributeTypeError, getRelationUriFromConnection, getRelationEditorActiveError, getRelationAttributesFromConnection, getEntityUriFromConnection, evaluateErrorPath, AttributeValuePathItemType, getAllRelationEditorActiveErrors, isAttributeHasMaskedValue } from '@reltio/mdm-sdk';
+import { createTemporaryEntity, Directions, findRelatedTemporaryEntities, getActivenessAttributes, getCreatableAttributeTypes, getEntityType, getErrorMessage, getErrorId, getRelationType, getSuitableEntityTypeUrisForRelationTypes, isAvailableRelationBetweenEntities, omitMarks, relationEditorAttributeTypesSelectionStrategy, validateConnection, updateConnectionEntityLabel, isTempUri, isEmptyValue, getRelationAttributesList, getDefaultRelationTypeObject, getInOutRelations, isSuggestMode, isAttributeTypeError, getRelationUriFromConnection, getRelationEditorActiveError, getRelationAttributesFromConnection, getEntityUriFromConnection, evaluateErrorPath, AttributeValuePathItemType, getAllRelationEditorActiveErrors, isAttributeHasMaskedValue } from '@reltio/mdm-sdk';
 import { ConnectionRelationTypeSelector } from '../ConnectionRelationTypeSelector';
 import { ErrorWrapper } from '../ErrorWrapper';
 import { EntitySelector } from '../EntitySelector';
@@ -110,7 +110,6 @@ var RelationEditor = function (_a) {
             areRelatedEntitiesChanged(initialRelatedTempEntities.current, relatedTempEntities));
     var applyAction = useMemo(function () { return curry(isNew ? addRelation : editRelation); }, [isNew, addRelation, editRelation]);
     var canCreateNewEntity = !isSuggestMode(mode) || !isTempUri(mainEntity === null || mainEntity === void 0 ? void 0 : mainEntity.uri) || !isEmptyValue(authoringItems);
-    var onRelationTypeChange = useCallback(function (relationType) { return setRelationType(config.id, relationUri, relationType); }, [config, relationUri, setRelationType]);
     var handleClose = useCallback(function () { return closeRelationEditor(config.id, relationUri); }, [config, relationUri, closeRelationEditor]);
     var updateModifiedEntityLabel = useCallback(function (connection) {
         if (modifiedEntity) {
@@ -121,6 +120,31 @@ var RelationEditor = function (_a) {
     }, [modifiedEntity, metadata]);
     var setModifiedEntity = useCallback(function (entity) { return entityCreated(entity); }, [entityCreated]);
     var deleteModifiedEntity = useCallback(function (entityUri) { return entityDeleted(entityUri); }, [entityDeleted]);
+    var onRelationTypeChange = useCallback(function (newRelationType) {
+        var connectionEntity = connection.entity;
+        var hasConnectionEntity = connectionEntity && connectionEntity.entityUri;
+        var isEntitySuitableForNewRelationType = mainEntity &&
+            newRelationType &&
+            hasConnectionEntity &&
+            isAvailableRelationBetweenEntities(newRelationType.direction === Directions.OUT, __assign(__assign({}, connectionEntity), { type: connectionEntity.entityType }), mainEntity, metadata, newRelationType.type);
+        setRelationType(config.id, relationUri, newRelationType);
+        if (hasConnectionEntity && !isEntitySuitableForNewRelationType) {
+            if (modifiedEntity) {
+                deleteModifiedEntity(modifiedEntity.uri);
+            }
+            setRelationEntity(config.id, relationUri, {});
+        }
+    }, [
+        metadata,
+        connection.entity,
+        mainEntity,
+        setRelationType,
+        config.id,
+        relationUri,
+        modifiedEntity,
+        setRelationEntity,
+        deleteModifiedEntity
+    ]);
     var onChangeEntity = useCallback(function (entity) {
         if (modifiedEntity) {
             deleteModifiedEntity(modifiedEntity.uri);
@@ -190,8 +214,15 @@ var RelationEditor = function (_a) {
     var entityTypesUris = useMemo(function () {
         var _a;
         var _b = config, content = _b.content, contentSecondLevel = _b.contentSecondLevel;
-        return ((_a = (contentSecondLevel && connection.parentEntityUri ? contentSecondLevel.entityTypes : content.entityTypes)) !== null && _a !== void 0 ? _a : []);
-    }, [config, connection.parentEntityUri]);
+        var entityTypeUrisFromConfig = (_a = (contentSecondLevel && connection.parentEntityUri ? contentSecondLevel.entityTypes : content.entityTypes)) !== null && _a !== void 0 ? _a : [];
+        var relationTypeObj = relationType ? getRelationType(metadata, relationType) : null;
+        var suitableEntityTypeUrisForRelationType = relationTypeObj
+            ? getSuitableEntityTypeUrisForRelationTypes(direction === Directions.OUT, metadata, [relationTypeObj])
+            : [];
+        return entityTypeUrisFromConfig.length > 0
+            ? entityTypeUrisFromConfig.filter(function (uri) { return suitableEntityTypeUrisForRelationType.includes(uri); })
+            : suitableEntityTypeUrisForRelationType;
+    }, [config, connection.parentEntityUri, relationType, direction, metadata]);
     var isEntityHasMaskedAttrValue = pipe(values, flatten, any(isAttributeHasMaskedValue))(((_d = (_c = connection.entity) === null || _c === void 0 ? void 0 : _c.object) === null || _d === void 0 ? void 0 : _d.attributes) || {});
     var isMasked = showMasking && isEntityHasMaskedAttrValue;
     return (React.createElement(React.Fragment, null,

package/RelationEditor/RelationEditor.test.js

@@ -293,6 +293,51 @@ describe('relation editor behaviour', function () {
             }
         });
     }); });
+    it('should pass only entity types suitable for current relation type to EntitySelector', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var config, props, user;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    typeAheadSearch.mockResolvedValue([
+                        { type: 'configuration/entityTypes/Location', label: 'location entity 1', uri: 'entities/0C32GxR' }
+                    ]);
+                    config = __assign(__assign({}, defaultProps.config), { content: {
+                            entityTypes: ['configuration/entityTypes/Location', 'configuration/entityTypes/HCA'],
+                            outRelations: [{ uri: 'configuration/relationTypes/HasAddress', label: '{directionalLabel}' }]
+                        } });
+                    props = __assign(__assign({}, defaultProps), { config: config });
+                    user = setUp({ props: props }).user;
+                    return [4 /*yield*/, user.click(screen.getByTestId('select-dropdown-indicator'))];
+                case 1:
+                    _a.sent();
+                    expect(typeAheadSearch).toHaveBeenCalledWith([defaultProps.metadata.entityTypes[1]], '', expect.any(Object));
+                    expect(typeAheadSearch).not.toHaveBeenCalledWith(expect.arrayContaining([expect.objectContaining({ uri: 'configuration/entityTypes/HCA' })]), expect.any(String), expect.any(Object));
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should pass all suitable entity types from metadata to EntitySelector when entityTypes from config is empty', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var config, props, user;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    typeAheadSearch.mockResolvedValue([
+                        { type: 'configuration/entityTypes/Location', label: 'location entity 1', uri: 'entities/0C32GxR' }
+                    ]);
+                    config = __assign(__assign({}, defaultProps.config), { content: {
+                            entityTypes: [],
+                            outRelations: [{ uri: 'configuration/relationTypes/HasAddress', label: '{directionalLabel}' }]
+                        } });
+                    props = __assign(__assign({}, defaultProps), { config: config });
+                    user = setUp({ props: props }).user;
+                    return [4 /*yield*/, user.click(screen.getByTestId('select-dropdown-indicator'))];
+                case 1:
+                    _a.sent();
+                    expect(typeAheadSearch).toHaveBeenCalledWith([defaultProps.metadata.entityTypes[1]], '', expect.any(Object));
+                    return [2 /*return*/];
+            }
+        });
+    }); });
     it('should render attributes list correctly', function () { return __awaiter(void 0, void 0, void 0, function () {
         var labels, values;
         return __generator(this, function (_a) {
@@ -351,7 +396,7 @@ describe('relation editor behaviour', function () {
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
-                    connection = __assign(__assign({}, defaultProps.connection), { parentEntityUri: 'entities/HsPM72G' });
+                    connection = __assign(__assign({}, defaultProps.connection), { parentEntityUri: 'entities/HsPM72G', relation: __assign(__assign({}, defaultRelation), { relationType: 'configuration/relationTypes/InternalHCAtoHCA', direction: 'out' }) });
                     config = __assign(__assign({}, defaultProps.config), { contentSecondLevel: {
                             entityTypes: ['configuration/entityTypes/HCA'],
                             outRelations: [{ uri: 'configuration/relationTypes/InternalHCAtoHCA', label: '{directionalLabel}' }]
@@ -458,6 +503,43 @@ describe('relation editor behaviour', function () {
             }
         });
     }); });
+    it('should clear connection entity and delete modified entity when relation type changes to one unsuitable for current connection entity', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var entityUri, modifiedEntity, connection, config, mdmValues, props, user;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    entityUri = 'entities/uri$$tempLocation';
+                    modifiedEntity = {
+                        type: 'configuration/entityTypes/Location',
+                        uri: entityUri,
+                        attributes: {}
+                    };
+                    connection = __assign(__assign({}, defaultProps.connection), { entity: { entityUri: entityUri, entityType: 'configuration/entityTypes/Location' } });
+                    config = __assign(__assign({}, defaultProps.config), { content: {
+                            entityTypes: ['configuration/entityTypes/Location', 'configuration/entityTypes/HCA'],
+                            inRelations: [{ uri: 'configuration/relationTypes/InternalHCAtoHCA', label: '{directionalLabel}' }],
+                            outRelations: [{ uri: 'configuration/relationTypes/HasAddress', label: '{directionalLabel}' }]
+                        } });
+                    mdmValues = __assign(__assign({}, defaultMdmValues), { modifiedEntities: (_a = {}, _a[entityUri] = modifiedEntity, _a) });
+                    props = __assign(__assign({}, defaultProps), { config: config, connection: connection });
+                    user = setUp({ mdmValues: mdmValues, props: props }).user;
+                    return [4 /*yield*/, user.click(within(screen.getByTestId('relation-type-selector')).getByTestId('select-dropdown-indicator'))];
+                case 1:
+                    _b.sent();
+                    return [4 /*yield*/, user.click(screen.getByText('InternalHCAtoHCA affiliation'))];
+                case 2:
+                    _b.sent();
+                    expect(mdmActions.setRelationType).toHaveBeenCalledWith(props.config.id, props.connection.relation.relationUri, expect.objectContaining({
+                        direction: 'in',
+                        type: expect.objectContaining({ uri: 'configuration/relationTypes/InternalHCAtoHCA' })
+                    }));
+                    expect(mdmActions.entityDeleted).toHaveBeenCalledWith(entityUri);
+                    expect(mdmActions.setRelationEntity).toHaveBeenCalledWith(props.config.id, props.connection.relation.relationUri, {});
+                    return [2 /*return*/];
+            }
+        });
+    }); });
     it('should show "create entity" button if mode is not suggesting', function () { return __awaiter(void 0, void 0, void 0, function () {
         var user, inputs;
         return __generator(this, function (_a) {
@@ -496,24 +578,24 @@ describe('relation editor behaviour', function () {
         });
     }); });
     it('should hide create button for one of the entity types when user lacks metadata permissions', function () { return __awaiter(void 0, void 0, void 0, function () {
-        var props, user, inputs;
+        var connection, props, user, inputs;
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
+                    connection = __assign(__assign({}, defaultProps.connection), { relation: __assign(__assign({}, defaultRelation), { relationType: 'configuration/relationTypes/HasAddress', direction: 'out' }) });
                     props = pipe(assocPath(['metadata', 'entityTypes', 1, 'access'], ['READ', 'UPDATE', 'INITIATE_CHANGE_REQUEST']), assocPath(['config', 'content'], {
                         entityTypes: ['configuration/entityTypes/Location', 'configuration/entityTypes/HCA'],
                         outRelations: [
                             { uri: 'configuration/relationTypes/HasAddress', label: '{directionalLabel}' },
                             { uri: 'configuration/relationTypes/InternalHCAtoHCA', label: '{directionalLabel}' }
                         ]
-                    }))(defaultProps);
+                    }), assocPath(['connection'], connection))(defaultProps);
                     user = setUp({ props: props }).user;
                     inputs = screen.getAllByRole('combobox');
                     return [4 /*yield*/, user.click(inputs[1])];
                 case 1:
                     _a.sent();
                     expect(screen.queryByText('Create new Address')).not.toBeInTheDocument();
-                    expect(screen.getByText('Create new HCA')).toBeInTheDocument();
                     return [2 /*return*/];
             }
         });

package/cjs/EntitySelector/EntitySelector.js

@@ -123,7 +123,7 @@ var EntitySelector = function (_a) {
         return (__assign(__assign({}, (TextFieldProps || {})), (_a = {}, _a['data-reltio-id'] = 'reltio-entity-selector', _a)));
     }, [TextFieldProps]);
     return (react_1.default.createElement(react_1.default.Fragment, null,
-        react_1.default.createElement(DropDownSelector_1.DropDownSelector, __assign({ value: !(0, ramda_1.isEmpty)(entity) ? entity : undefined, inputValue: inputValue, onInputChange: handleInputChange, getOptions: getOptions, getOptionLabel: (0, ramda_1.prop)('entityLabel'), onChange: handleChange, onCreate: handleCreate, onClear: handleClear, label: label, createLabel: createLabel, canCreateOption: canCreateEntity, components: __assign(__assign({ Option: EntityOption_1.EntityOption, SingleValue: SingleValue_1.SingleValue }, groupComponent), clearComponent), currentEntityType: currentEntityType, isClearable: true, disableLinkClick: disableLinkClick, TextFieldProps: textFieldProps }, dropDownSelectorProps)),
+        react_1.default.createElement(DropDownSelector_1.DropDownSelector, __assign({ key: entityTypesUris.join(','), value: !(0, ramda_1.isEmpty)(entity) ? entity : undefined, inputValue: inputValue, onInputChange: handleInputChange, getOptions: getOptions, getOptionLabel: (0, ramda_1.prop)('entityLabel'), onChange: handleChange, onCreate: handleCreate, onClear: handleClear, label: label, createLabel: createLabel, canCreateOption: canCreateEntity, components: __assign(__assign({ Option: EntityOption_1.EntityOption, SingleValue: SingleValue_1.SingleValue }, groupComponent), clearComponent), currentEntityType: currentEntityType, isClearable: true, disableLinkClick: disableLinkClick, TextFieldProps: textFieldProps }, dropDownSelectorProps)),
         isTempEntity && (react_1.default.createElement("div", { "data-reltio-id": "entity-creator", className: styles.creatorWrapper },
             react_1.default.createElement(EntityCreator_1.EntityCreator, { mode: mode, attributeTypesSelectionStrategy: attributeTypesSelectionStrategy, entityType: currentEntityType, entityUri: entity.entityUri })))));
 };

package/cjs/EntitySelector/EntitySelector.test.js

@@ -390,6 +390,29 @@ describe('Entity selector tests', function () {
             }
         });
     }); });
+    it('should call typeAheadSearch with new entity types when entityTypesUris prop changes after rerender', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var initialProps, _a, user, rerender, updatedProps;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    initialProps = __assign(__assign({}, defaultProps), { entityTypesUris: ['configuration/entityTypes/HCP'] });
+                    _a = setUp({ props: initialProps }), user = _a.user, rerender = _a.rerender;
+                    return [4 /*yield*/, user.click(react_2.screen.getByTestId('select-dropdown-indicator'))];
+                case 1:
+                    _b.sent();
+                    expect(mdm_sdk_1.typeAheadSearch).toHaveBeenCalledWith([defaultMetadata.entityTypes[0]], '', expect.any(Object));
+                    mdm_sdk_1.typeAheadSearch.mockClear();
+                    updatedProps = __assign(__assign({}, defaultProps), { entityTypesUris: ['configuration/entityTypes/HCP', 'configuration/entityTypes/Company'] });
+                    rerender(react_1.default.createElement(MdmModuleContext_1.MdmModuleProvider, { values: defaultMdmValues, actions: defaultMdmActions },
+                        react_1.default.createElement(EntitySelector_1.EntitySelector, __assign({}, updatedProps))));
+                    return [4 /*yield*/, user.click(react_2.screen.getByTestId('select-dropdown-indicator'))];
+                case 2:
+                    _b.sent();
+                    expect(mdm_sdk_1.typeAheadSearch).toHaveBeenCalledWith([defaultMetadata.entityTypes[0], defaultMetadata.entityTypes[1]], '', expect.any(Object));
+                    return [2 /*return*/];
+            }
+        });
+    }); });
     it('should render create button and handle click correctly for single entity type in case of onCreate prop is passed and input is filled', function () { return __awaiter(void 0, void 0, void 0, function () {
         var props, user;
         return __generator(this, function (_a) {

package/cjs/RelationEditor/RelationEditor.js

@@ -138,7 +138,6 @@ var RelationEditor = function (_a) {
             areRelatedEntitiesChanged(initialRelatedTempEntities.current, relatedTempEntities));
     var applyAction = (0, react_1.useMemo)(function () { return (0, ramda_1.curry)(isNew ? addRelation : editRelation); }, [isNew, addRelation, editRelation]);
     var canCreateNewEntity = !(0, mdm_sdk_1.isSuggestMode)(mode) || !(0, mdm_sdk_1.isTempUri)(mainEntity === null || mainEntity === void 0 ? void 0 : mainEntity.uri) || !(0, mdm_sdk_1.isEmptyValue)(authoringItems);
-    var onRelationTypeChange = (0, react_1.useCallback)(function (relationType) { return setRelationType(config.id, relationUri, relationType); }, [config, relationUri, setRelationType]);
     var handleClose = (0, react_1.useCallback)(function () { return closeRelationEditor(config.id, relationUri); }, [config, relationUri, closeRelationEditor]);
     var updateModifiedEntityLabel = (0, react_1.useCallback)(function (connection) {
         if (modifiedEntity) {
@@ -149,6 +148,31 @@ var RelationEditor = function (_a) {
     }, [modifiedEntity, metadata]);
     var setModifiedEntity = (0, react_1.useCallback)(function (entity) { return entityCreated(entity); }, [entityCreated]);
     var deleteModifiedEntity = (0, react_1.useCallback)(function (entityUri) { return entityDeleted(entityUri); }, [entityDeleted]);
+    var onRelationTypeChange = (0, react_1.useCallback)(function (newRelationType) {
+        var connectionEntity = connection.entity;
+        var hasConnectionEntity = connectionEntity && connectionEntity.entityUri;
+        var isEntitySuitableForNewRelationType = mainEntity &&
+            newRelationType &&
+            hasConnectionEntity &&
+            (0, mdm_sdk_1.isAvailableRelationBetweenEntities)(newRelationType.direction === mdm_sdk_1.Directions.OUT, __assign(__assign({}, connectionEntity), { type: connectionEntity.entityType }), mainEntity, metadata, newRelationType.type);
+        setRelationType(config.id, relationUri, newRelationType);
+        if (hasConnectionEntity && !isEntitySuitableForNewRelationType) {
+            if (modifiedEntity) {
+                deleteModifiedEntity(modifiedEntity.uri);
+            }
+            setRelationEntity(config.id, relationUri, {});
+        }
+    }, [
+        metadata,
+        connection.entity,
+        mainEntity,
+        setRelationType,
+        config.id,
+        relationUri,
+        modifiedEntity,
+        setRelationEntity,
+        deleteModifiedEntity
+    ]);
     var onChangeEntity = (0, react_1.useCallback)(function (entity) {
         if (modifiedEntity) {
             deleteModifiedEntity(modifiedEntity.uri);
@@ -218,8 +242,15 @@ var RelationEditor = function (_a) {
     var entityTypesUris = (0, react_1.useMemo)(function () {
         var _a;
         var _b = config, content = _b.content, contentSecondLevel = _b.contentSecondLevel;
-        return ((_a = (contentSecondLevel && connection.parentEntityUri ? contentSecondLevel.entityTypes : content.entityTypes)) !== null && _a !== void 0 ? _a : []);
-    }, [config, connection.parentEntityUri]);
+        var entityTypeUrisFromConfig = (_a = (contentSecondLevel && connection.parentEntityUri ? contentSecondLevel.entityTypes : content.entityTypes)) !== null && _a !== void 0 ? _a : [];
+        var relationTypeObj = relationType ? (0, mdm_sdk_1.getRelationType)(metadata, relationType) : null;
+        var suitableEntityTypeUrisForRelationType = relationTypeObj
+            ? (0, mdm_sdk_1.getSuitableEntityTypeUrisForRelationTypes)(direction === mdm_sdk_1.Directions.OUT, metadata, [relationTypeObj])
+            : [];
+        return entityTypeUrisFromConfig.length > 0
+            ? entityTypeUrisFromConfig.filter(function (uri) { return suitableEntityTypeUrisForRelationType.includes(uri); })
+            : suitableEntityTypeUrisForRelationType;
+    }, [config, connection.parentEntityUri, relationType, direction, metadata]);
     var isEntityHasMaskedAttrValue = (0, ramda_1.pipe)(ramda_1.values, ramda_1.flatten, (0, ramda_1.any)(mdm_sdk_1.isAttributeHasMaskedValue))(((_d = (_c = connection.entity) === null || _c === void 0 ? void 0 : _c.object) === null || _d === void 0 ? void 0 : _d.attributes) || {});
     var isMasked = showMasking && isEntityHasMaskedAttrValue;
     return (react_1.default.createElement(react_1.default.Fragment, null,

package/cjs/RelationEditor/RelationEditor.test.js

@@ -298,6 +298,51 @@ describe('relation editor behaviour', function () {
             }
         });
     }); });
+    it('should pass only entity types suitable for current relation type to EntitySelector', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var config, props, user;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    mdm_sdk_1.typeAheadSearch.mockResolvedValue([
+                        { type: 'configuration/entityTypes/Location', label: 'location entity 1', uri: 'entities/0C32GxR' }
+                    ]);
+                    config = __assign(__assign({}, defaultProps.config), { content: {
+                            entityTypes: ['configuration/entityTypes/Location', 'configuration/entityTypes/HCA'],
+                            outRelations: [{ uri: 'configuration/relationTypes/HasAddress', label: '{directionalLabel}' }]
+                        } });
+                    props = __assign(__assign({}, defaultProps), { config: config });
+                    user = setUp({ props: props }).user;
+                    return [4 /*yield*/, user.click(react_2.screen.getByTestId('select-dropdown-indicator'))];
+                case 1:
+                    _a.sent();
+                    expect(mdm_sdk_1.typeAheadSearch).toHaveBeenCalledWith([defaultProps.metadata.entityTypes[1]], '', expect.any(Object));
+                    expect(mdm_sdk_1.typeAheadSearch).not.toHaveBeenCalledWith(expect.arrayContaining([expect.objectContaining({ uri: 'configuration/entityTypes/HCA' })]), expect.any(String), expect.any(Object));
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should pass all suitable entity types from metadata to EntitySelector when entityTypes from config is empty', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var config, props, user;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    mdm_sdk_1.typeAheadSearch.mockResolvedValue([
+                        { type: 'configuration/entityTypes/Location', label: 'location entity 1', uri: 'entities/0C32GxR' }
+                    ]);
+                    config = __assign(__assign({}, defaultProps.config), { content: {
+                            entityTypes: [],
+                            outRelations: [{ uri: 'configuration/relationTypes/HasAddress', label: '{directionalLabel}' }]
+                        } });
+                    props = __assign(__assign({}, defaultProps), { config: config });
+                    user = setUp({ props: props }).user;
+                    return [4 /*yield*/, user.click(react_2.screen.getByTestId('select-dropdown-indicator'))];
+                case 1:
+                    _a.sent();
+                    expect(mdm_sdk_1.typeAheadSearch).toHaveBeenCalledWith([defaultProps.metadata.entityTypes[1]], '', expect.any(Object));
+                    return [2 /*return*/];
+            }
+        });
+    }); });
     it('should render attributes list correctly', function () { return __awaiter(void 0, void 0, void 0, function () {
         var labels, values;
         return __generator(this, function (_a) {
@@ -356,7 +401,7 @@ describe('relation editor behaviour', function () {
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
-                    connection = __assign(__assign({}, defaultProps.connection), { parentEntityUri: 'entities/HsPM72G' });
+                    connection = __assign(__assign({}, defaultProps.connection), { parentEntityUri: 'entities/HsPM72G', relation: __assign(__assign({}, defaultRelation), { relationType: 'configuration/relationTypes/InternalHCAtoHCA', direction: 'out' }) });
                     config = __assign(__assign({}, defaultProps.config), { contentSecondLevel: {
                             entityTypes: ['configuration/entityTypes/HCA'],
                             outRelations: [{ uri: 'configuration/relationTypes/InternalHCAtoHCA', label: '{directionalLabel}' }]
@@ -463,6 +508,43 @@ describe('relation editor behaviour', function () {
             }
         });
     }); });
+    it('should clear connection entity and delete modified entity when relation type changes to one unsuitable for current connection entity', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var entityUri, modifiedEntity, connection, config, mdmValues, props, user;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    entityUri = 'entities/uri$$tempLocation';
+                    modifiedEntity = {
+                        type: 'configuration/entityTypes/Location',
+                        uri: entityUri,
+                        attributes: {}
+                    };
+                    connection = __assign(__assign({}, defaultProps.connection), { entity: { entityUri: entityUri, entityType: 'configuration/entityTypes/Location' } });
+                    config = __assign(__assign({}, defaultProps.config), { content: {
+                            entityTypes: ['configuration/entityTypes/Location', 'configuration/entityTypes/HCA'],
+                            inRelations: [{ uri: 'configuration/relationTypes/InternalHCAtoHCA', label: '{directionalLabel}' }],
+                            outRelations: [{ uri: 'configuration/relationTypes/HasAddress', label: '{directionalLabel}' }]
+                        } });
+                    mdmValues = __assign(__assign({}, defaultMdmValues), { modifiedEntities: (_a = {}, _a[entityUri] = modifiedEntity, _a) });
+                    props = __assign(__assign({}, defaultProps), { config: config, connection: connection });
+                    user = setUp({ mdmValues: mdmValues, props: props }).user;
+                    return [4 /*yield*/, user.click((0, react_2.within)(react_2.screen.getByTestId('relation-type-selector')).getByTestId('select-dropdown-indicator'))];
+                case 1:
+                    _b.sent();
+                    return [4 /*yield*/, user.click(react_2.screen.getByText('InternalHCAtoHCA affiliation'))];
+                case 2:
+                    _b.sent();
+                    expect(mdmActions.setRelationType).toHaveBeenCalledWith(props.config.id, props.connection.relation.relationUri, expect.objectContaining({
+                        direction: 'in',
+                        type: expect.objectContaining({ uri: 'configuration/relationTypes/InternalHCAtoHCA' })
+                    }));
+                    expect(mdmActions.entityDeleted).toHaveBeenCalledWith(entityUri);
+                    expect(mdmActions.setRelationEntity).toHaveBeenCalledWith(props.config.id, props.connection.relation.relationUri, {});
+                    return [2 /*return*/];
+            }
+        });
+    }); });
     it('should show "create entity" button if mode is not suggesting', function () { return __awaiter(void 0, void 0, void 0, function () {
         var user, inputs;
         return __generator(this, function (_a) {
@@ -501,24 +583,24 @@ describe('relation editor behaviour', function () {
         });
     }); });
     it('should hide create button for one of the entity types when user lacks metadata permissions', function () { return __awaiter(void 0, void 0, void 0, function () {
-        var props, user, inputs;
+        var connection, props, user, inputs;
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
+                    connection = __assign(__assign({}, defaultProps.connection), { relation: __assign(__assign({}, defaultRelation), { relationType: 'configuration/relationTypes/HasAddress', direction: 'out' }) });
                     props = (0, ramda_1.pipe)((0, ramda_1.assocPath)(['metadata', 'entityTypes', 1, 'access'], ['READ', 'UPDATE', 'INITIATE_CHANGE_REQUEST']), (0, ramda_1.assocPath)(['config', 'content'], {
                         entityTypes: ['configuration/entityTypes/Location', 'configuration/entityTypes/HCA'],
                         outRelations: [
                             { uri: 'configuration/relationTypes/HasAddress', label: '{directionalLabel}' },
                             { uri: 'configuration/relationTypes/InternalHCAtoHCA', label: '{directionalLabel}' }
                         ]
-                    }))(defaultProps);
+                    }), (0, ramda_1.assocPath)(['connection'], connection))(defaultProps);
                     user = setUp({ props: props }).user;
                     inputs = react_2.screen.getAllByRole('combobox');
                     return [4 /*yield*/, user.click(inputs[1])];
                 case 1:
                     _a.sent();
                     expect(react_2.screen.queryByText('Create new Address')).not.toBeInTheDocument();
-                    expect(react_2.screen.getByText('Create new HCA')).toBeInTheDocument();
                     return [2 /*return*/];
             }
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reltio/components",
-  "version": "1.4.2233",
+  "version": "1.4.2234",
   "license": "SEE LICENSE IN LICENSE FILE",
   "main": "./cjs/index.js",
   "module": "./index.js",