@reltio/graph 1.4.1585 → 1.4.1586-mui5

package/src/utils/__tests__/hopsData.spec.ts

@@ -0,0 +1,456 @@
+import {MultiGraph} from 'graphology';
+import {HopsResponse} from '@reltio/mdm-sdk';
+import {mergeHopsData, removeRelationFromHopsData} from '../hopsData';
+import {fillGraphWithHopsResponse} from '../graph';
+
+describe('Hops Data utils', () => {
+    describe('removeRelationFromHopsData behavior', () => {
+        it('should remove relation for simple cases', () => {
+            const data: HopsResponse = {
+                entities: [
+                    {uri: 'e1', type: '', traversedRelations: 2},
+                    {uri: 'e2', type: '', traversedRelations: 2},
+                    {uri: 'e3', type: '', traversedRelations: 2}
+                ],
+                relations: [
+                    {
+                        uri: 'r1',
+                        type: '',
+                        startObject: {
+                            objectURI: 'e1'
+                        },
+                        endObject: {
+                            objectURI: 'e2'
+                        }
+                    },
+                    {
+                        uri: 'r2',
+                        type: '',
+                        startObject: {
+                            objectURI: 'e2'
+                        },
+                        endObject: {
+                            objectURI: 'e3'
+                        }
+                    },
+                    {
+                        uri: 'r3',
+                        type: '',
+                        startObject: {
+                            objectURI: 'e3'
+                        },
+                        endObject: {
+                            objectURI: 'e1'
+                        }
+                    }
+                ]
+            };
+            const relationUriToRemove = 'r1';
+            const graph = new MultiGraph();
+            fillGraphWithHopsResponse(graph, data);
+            graph.dropEdge(relationUriToRemove);
+
+            const mainEntityUri = 'e1';
+            expect(removeRelationFromHopsData(mainEntityUri, relationUriToRemove, graph, data)).toEqual({
+                updatedData: {
+                    entities: [
+                        {...data.entities[0], traversedRelations: 1},
+                        {...data.entities[1], traversedRelations: 1},
+                        data.entities[2]
+                    ],
+                    relations: [data.relations[1], data.relations[2]]
+                },
+                removedEntitiesUris: []
+            });
+        });
+
+        it('should remove relation and isolated node', () => {
+            const data: HopsResponse = {
+                entities: [
+                    {uri: 'e1', type: '', traversedRelations: 1},
+                    {uri: 'e2', type: '', traversedRelations: 2},
+                    {uri: 'e3', type: '', traversedRelations: 1}
+                ],
+                relations: [
+                    {
+                        uri: 'r1',
+                        type: '',
+                        startObject: {
+                            objectURI: 'e1'
+                        },
+                        endObject: {
+                            objectURI: 'e2'
+                        }
+                    },
+                    {
+                        uri: 'r2',
+                        type: '',
+                        startObject: {
+                            objectURI: 'e2'
+                        },
+                        endObject: {
+                            objectURI: 'e3'
+                        }
+                    }
+                ]
+            };
+            const relationUriToRemove = 'r2';
+            const graph = new MultiGraph();
+            fillGraphWithHopsResponse(graph, data);
+            graph.dropEdge(relationUriToRemove);
+
+            const mainEntityUri = 'e1';
+            expect(removeRelationFromHopsData(mainEntityUri, relationUriToRemove, graph, data)).toEqual({
+                updatedData: {
+                    entities: [data.entities[0], {...data.entities[1], traversedRelations: 1}],
+                    relations: [data.relations[0]]
+                },
+                removedEntitiesUris: ['e3']
+            });
+        });
+
+        it('should remove relation and isolated simple subgraph', () => {
+            const data: HopsResponse = {
+                entities: [
+                    {uri: 'e1', type: '', traversedRelations: 1},
+                    {uri: 'e2', type: '', traversedRelations: 2},
+                    {uri: 'e3', type: '', traversedRelations: 1}
+                ],
+                relations: [
+                    {
+                        uri: 'r1',
+                        type: '',
+                        startObject: {
+                            objectURI: 'e1'
+                        },
+                        endObject: {
+                            objectURI: 'e2'
+                        }
+                    },
+                    {
+                        uri: 'r2',
+                        type: '',
+                        startObject: {
+                            objectURI: 'e2'
+                        },
+                        endObject: {
+                            objectURI: 'e3'
+                        }
+                    }
+                ]
+            };
+            const relationUriToRemove = 'r1';
+            const graph = new MultiGraph();
+            fillGraphWithHopsResponse(graph, data);
+            graph.dropEdge(relationUriToRemove);
+
+            const mainEntityUri = 'e1';
+            expect(removeRelationFromHopsData(mainEntityUri, relationUriToRemove, graph, data)).toEqual({
+                updatedData: {
+                    entities: [{...data.entities[0], traversedRelations: 0}],
+                    relations: []
+                },
+                removedEntitiesUris: ['e2', 'e3']
+            });
+        });
+
+        it('should remove relation and isolated complex subgraph', () => {
+            const data: HopsResponse = {
+                entities: [
+                    {uri: 'e1', type: '', traversedRelations: 1},
+                    {uri: 'e2', type: '', traversedRelations: 2},
+                    {uri: 'e3', type: '', traversedRelations: 3},
+                    {uri: 'e4', type: '', traversedRelations: 3},
+                    {uri: 'e5', type: '', traversedRelations: 1},
+                    {uri: 'e6', type: '', traversedRelations: 2}
+                ],
+                relations: [
+                    {
+                        uri: 'r1',
+                        type: '',
+                        startObject: {
+                            objectURI: 'e1'
+                        },
+                        endObject: {
+                            objectURI: 'e2'
+                        }
+                    },
+                    {
+                        uri: 'r2',
+                        type: '',
+                        startObject: {
+                            objectURI: 'e2'
+                        },
+                        endObject: {
+                            objectURI: 'e3'
+                        }
+                    },
+                    {
+                        uri: 'r3',
+                        type: '',
+                        startObject: {
+                            objectURI: 'e3'
+                        },
+                        endObject: {
+                            objectURI: 'e4'
+                        }
+                    },
+                    {
+                        uri: 'r4',
+                        type: '',
+                        startObject: {
+                            objectURI: 'e3'
+                        },
+                        endObject: {
+                            objectURI: 'e6'
+                        }
+                    },
+                    {
+                        uri: 'r5',
+                        type: '',
+                        startObject: {
+                            objectURI: 'e4'
+                        },
+                        endObject: {
+                            objectURI: 'e6'
+                        }
+                    },
+                    {
+                        uri: 'r6',
+                        type: '',
+                        startObject: {
+                            objectURI: 'e4'
+                        },
+                        endObject: {
+                            objectURI: 'e5'
+                        }
+                    }
+                ]
+            };
+            const relationUriToRemove = 'r2';
+            const graph = new MultiGraph();
+            fillGraphWithHopsResponse(graph, data);
+            graph.dropEdge(relationUriToRemove);
+
+            const mainEntityUri = 'e1';
+            expect(removeRelationFromHopsData(mainEntityUri, relationUriToRemove, graph, data)).toEqual({
+                updatedData: {
+                    entities: [data.entities[0], {...data.entities[1], traversedRelations: 1}],
+                    relations: [data.relations[0]]
+                },
+                removedEntitiesUris: ['e3', 'e4', 'e6', 'e5']
+            });
+        });
+
+        it('should not remove complex subgraph if it is not isolated', () => {
+            const data: HopsResponse = {
+                entities: [
+                    {uri: 'e1', type: '', traversedRelations: 2},
+                    {uri: 'e2', type: '', traversedRelations: 2},
+                    {uri: 'e3', type: '', traversedRelations: 3},
+                    {uri: 'e4', type: '', traversedRelations: 3},
+                    {uri: 'e5', type: '', traversedRelations: 2},
+                    {uri: 'e6', type: '', traversedRelations: 2}
+                ],
+                relations: [
+                    {
+                        uri: 'r1',
+                        type: '',
+                        startObject: {
+                            objectURI: 'e1'
+                        },
+                        endObject: {
+                            objectURI: 'e2'
+                        }
+                    },
+                    {
+                        uri: 'r2',
+                        type: '',
+                        startObject: {
+                            objectURI: 'e2'
+                        },
+                        endObject: {
+                            objectURI: 'e3'
+                        }
+                    },
+                    {
+                        uri: 'r3',
+                        type: '',
+                        startObject: {
+                            objectURI: 'e3'
+                        },
+                        endObject: {
+                            objectURI: 'e4'
+                        }
+                    },
+                    {
+                        uri: 'r4',
+                        type: '',
+                        startObject: {
+                            objectURI: 'e3'
+                        },
+                        endObject: {
+                            objectURI: 'e6'
+                        }
+                    },
+                    {
+                        uri: 'r5',
+                        type: '',
+                        startObject: {
+                            objectURI: 'e4'
+                        },
+                        endObject: {
+                            objectURI: 'e6'
+                        }
+                    },
+                    {
+                        uri: 'r6',
+                        type: '',
+                        startObject: {
+                            objectURI: 'e4'
+                        },
+                        endObject: {
+                            objectURI: 'e5'
+                        }
+                    },
+                    {
+                        // additional path to e1
+                        uri: 'r7',
+                        type: '',
+                        startObject: {
+                            objectURI: 'e5'
+                        },
+                        endObject: {
+                            objectURI: 'e1'
+                        }
+                    }
+                ]
+            };
+            const relationUriToRemove = 'r2';
+            const graph = new MultiGraph();
+            fillGraphWithHopsResponse(graph, data);
+            graph.dropEdge(relationUriToRemove);
+
+            const mainEntityUri = 'e1';
+            expect(removeRelationFromHopsData(mainEntityUri, relationUriToRemove, graph, data)).toEqual({
+                updatedData: {
+                    entities: [
+                        data.entities[0],
+                        {...data.entities[1], traversedRelations: 1},
+                        {...data.entities[2], traversedRelations: 2},
+                        data.entities[3],
+                        data.entities[4],
+                        data.entities[5]
+                    ],
+                    relations: data.relations.filter((relation) => relation.uri !== relationUriToRemove)
+                },
+                removedEntitiesUris: []
+            });
+        });
+    });
+
+    describe('mergeHopsData behavior', () => {
+        it('should merge data', () => {
+            const data: HopsResponse = {
+                entities: [
+                    {uri: 'e1', type: '', traversedRelations: 2, untraversedRelations: 0},
+                    {uri: 'e2', type: '', traversedRelations: 2, untraversedRelations: 1},
+                    {uri: 'e3', type: '', traversedRelations: 2, untraversedRelations: 2}
+                ],
+                relations: [
+                    {
+                        uri: 'r1',
+                        type: '',
+                        startObject: {
+                            objectURI: 'e1'
+                        },
+                        endObject: {
+                            objectURI: 'e2'
+                        }
+                    },
+                    {
+                        uri: 'r2',
+                        type: '',
+                        startObject: {
+                            objectURI: 'e2'
+                        },
+                        endObject: {
+                            objectURI: 'e3'
+                        }
+                    },
+                    {
+                        uri: 'r3',
+                        type: '',
+                        startObject: {
+                            objectURI: 'e3'
+                        },
+                        endObject: {
+                            objectURI: 'e1'
+                        }
+                    }
+                ]
+            };
+
+            const newData: HopsResponse = {
+                entities: [
+                    {uri: 'e2', type: '', traversedRelations: 3, untraversedRelations: 0},
+                    {uri: 'e4', type: '', traversedRelations: 1, untraversedRelations: 2},
+                    {uri: 'e1', type: '', traversedRelations: 1, untraversedRelations: 1}
+                ],
+                relations: [
+                    {
+                        uri: 'r1',
+                        type: '',
+                        startObject: {
+                            objectURI: 'e1'
+                        },
+                        endObject: {
+                            objectURI: 'e2'
+                        }
+                    },
+                    {
+                        uri: 'r2',
+                        type: '',
+                        startObject: {
+                            objectURI: 'e2'
+                        },
+                        endObject: {
+                            objectURI: 'e3'
+                        }
+                    },
+                    {
+                        uri: 'r4',
+                        type: '',
+                        startObject: {
+                            objectURI: 'e2'
+                        },
+                        endObject: {
+                            objectURI: 'e4'
+                        }
+                    }
+                ]
+            };
+            expect(mergeHopsData(data, newData, 'e2')).toEqual({
+                entities: [
+                    data.entities[0],
+                    {...data.entities[1], traversedRelations: 3, untraversedRelations: 0},
+                    data.entities[2],
+                    {uri: 'e4', type: '', traversedRelations: 1, untraversedRelations: 2}
+                ],
+                relations: [
+                    ...data.relations,
+                    {
+                        uri: 'r4',
+                        type: '',
+                        startObject: {
+                            objectURI: 'e2'
+                        },
+                        endObject: {
+                            objectURI: 'e4'
+                        }
+                    }
+                ]
+            });
+        });
+    });
+});

package/src/utils/__tests__/processResponceToGraph.spec.ts

@@ -0,0 +1,165 @@
+import processResponseToGraph from '../processResponseToGraph';
+import {RelationTypeDirection} from '@reltio/mdm-sdk';
+
+const response = {
+    entities: [
+        {
+            uri: 'entities/369r4MS',
+            type: 'configuration/entityTypes/Employee',
+            label: 'Eugeny Gorshkov',
+            secondaryLabel: '',
+            traversedRelations: 0,
+            untraversedRelations: 5
+        },
+        {
+            uri: 'entities/369uzJA',
+            type: 'configuration/entityTypes/Employee',
+            label: 'Oleg Mikhailov',
+            secondaryLabel: '',
+            traversedRelations: 1,
+            untraversedRelations: 0
+        },
+        {
+            uri: 'entities/HAWcyp1',
+            type: 'configuration/entityTypes/Course',
+            label: 'ROP-0112 Data Security',
+            secondaryLabel: '',
+            traversedRelations: 2,
+            untraversedRelations: 5
+        }
+    ],
+    relations: [
+        {
+            uri: 'relations/9cdak6R',
+            type: 'configuration/relationTypes/ContactToCourse',
+            startObject: {
+                directionalLabel: '',
+                objectURI: 'entities/HAWcyp1'
+            },
+            endObject: {
+                directionalLabel: '',
+                objectURI: 'entities/369uzJA'
+            },
+            direction: RelationTypeDirection.directed
+        },
+        {
+            uri: 'relations/0L81as4',
+            type: 'configuration/relationTypes/ContactToCourse',
+            startObject: {
+                directionalLabel: '',
+                objectURI: 'entities/369uzJA'
+            },
+            endObject: {
+                directionalLabel: '',
+                objectURI: 'entities/HAWZkUt'
+            },
+            direction: RelationTypeDirection.directed
+        },
+        {
+            uri: 'relations/0C1hBCo',
+            type: 'configuration/relationTypes/ContactToCourse',
+            startObject: {
+                directionalLabel: '',
+                objectURI: 'entities/HAWcyp1'
+            },
+            endObject: {
+                directionalLabel: '',
+                objectURI: 'entities/369uzJA'
+            },
+            direction: RelationTypeDirection.directed
+        },
+        {
+            uri: 'relations/WkSntXP',
+            type: 'configuration/relationTypes/ContactToCourse',
+            startObject: {
+                directionalLabel: '',
+                objectURI: 'entities/369uzJA'
+            },
+            endObject: {
+                directionalLabel: '',
+                objectURI: 'entities/369r4MS'
+            },
+            direction: RelationTypeDirection.directed
+        },
+        {
+            uri: 'relations/WdfntXP',
+            type: 'configuration/relationTypes/ContactToCourse',
+            startObject: {
+                directionalLabel: '',
+                objectURI: 'entities/369r4MS'
+            },
+            endObject: {
+                directionalLabel: '',
+                objectURI: 'entities/369uzJA'
+            },
+            direction: RelationTypeDirection.bidirectional
+        }
+    ]
+};
+
+const expectedGraph = {
+    nodes: [
+        {
+            id: 'entities/369r4MS',
+            name: 'Eugeny Gorshkov',
+            entityTypeUri: 'configuration/entityTypes/Employee',
+            traversedRelationsCount: 0,
+            untraversedRelationsCount: 5
+        },
+        {
+            id: 'entities/369uzJA',
+            name: 'Oleg Mikhailov',
+            entityTypeUri: 'configuration/entityTypes/Employee',
+            traversedRelationsCount: 1,
+            untraversedRelationsCount: 0
+        },
+        {
+            id: 'entities/HAWcyp1',
+            name: 'ROP-0112 Data Security',
+            entityTypeUri: 'configuration/entityTypes/Course',
+            traversedRelationsCount: 2,
+            untraversedRelationsCount: 5
+        }
+    ],
+    edges: [
+        {
+            from: 'entities/HAWcyp1',
+            to: 'entities/369uzJA',
+            key: 'relations/9cdak6R',
+            relationTypeUri: 'configuration/relationTypes/ContactToCourse',
+            direction: RelationTypeDirection.directed
+        },
+        {
+            from: 'entities/HAWcyp1',
+            to: 'entities/369uzJA',
+            key: 'relations/0C1hBCo',
+            relationTypeUri: 'configuration/relationTypes/ContactToCourse',
+            direction: RelationTypeDirection.directed
+        },
+        {
+            from: 'entities/369uzJA',
+            to: 'entities/369r4MS',
+            key: 'relations/WkSntXP',
+            relationTypeUri: 'configuration/relationTypes/ContactToCourse',
+            direction: RelationTypeDirection.directed
+        },
+        {
+            from: 'entities/369r4MS',
+            to: 'entities/369uzJA',
+            key: 'relations/WdfntXP',
+            relationTypeUri: 'configuration/relationTypes/ContactToCourse',
+            direction: RelationTypeDirection.bidirectional
+        }
+    ]
+};
+
+describe('Graph processResponseToGraph behavior', () => {
+    it('should process response to graph data format', () => {
+        const graph = processResponseToGraph(response);
+        expect(graph).toEqual(expectedGraph);
+    });
+    it('should process response without relations to graph data format', () => {
+        const graph = processResponseToGraph({entities: response.entities});
+        expect(graph).toEqual({nodes: expectedGraph.nodes, edges: []});
+    });
+});

package/src/utils/graph.ts

@@ -0,0 +1,83 @@
+import Graph from 'graphology';
+import {toUndirected} from 'graphology-operators';
+import {bidirectional} from 'graphology-shortest-path';
+import {uniq} from 'ramda';
+import {HopsResponse, getLabel} from '@reltio/mdm-sdk';
+import processResponseToGraph from './processResponseToGraph';
+
+export const fillGraphWithHopsResponse = (graph: Graph, data: HopsResponse) => {
+    const graphologyData = processResponseToGraph(data);
+    graphologyData.nodes.forEach((node) => {
+        if (!graph.hasNode(node.id)) {
+            graph.addNode(node.id, {
+                label: getLabel(node.name),
+                entityTypeUri: node.entityTypeUri,
+                traversedRelationsCount: node.traversedRelationsCount,
+                untraversedRelationsCount: node.untraversedRelationsCount,
+                x: 1,
+                y: 1
+            });
+        }
+    });
+    graphologyData.edges.forEach((edge) => {
+        const isSelfRelation = edge.from === edge.to;
+
+        if (!graph.hasEdge(edge.key)) {
+            graph.addEdgeWithKey(edge.key, edge.from, edge.to, {
+                size: 1,
+                color: 'rgba(0, 0, 0, 0.2)',
+                forceLabel: isSelfRelation,
+                loop: isSelfRelation,
+                relationTypeUri: edge.relationTypeUri,
+                direction: edge.direction
+            });
+        }
+    });
+};
+
+export const removeNodesFromGraph = (graph: Graph, nodesIdsToRemove?: string[]) => {
+    (nodesIdsToRemove || []).forEach((id) => {
+        graph.dropNode(id);
+    });
+};
+
+const getIsolatedNodeId = (undirectedGraph: Graph, firstNode: string, secondaryNode: string) => {
+    return !bidirectional(undirectedGraph, firstNode, secondaryNode) ? secondaryNode : null;
+};
+
+const findSubgraphNodes = (nodeId: string, graph: Graph, foundNodes: string[] = []): string[] => {
+    const nodes = graph.neighbors(nodeId).filter((node) => !foundNodes.includes(node));
+    foundNodes.push(...nodes);
+    nodes.forEach((neighborNodeId) => findSubgraphNodes(neighborNodeId, graph, foundNodes));
+    return foundNodes;
+};
+
+export const getIsolatedNodes = (entityUri: string, mainNode: string, nodes: string[], graph: Graph) => {
+    const undirectedGraph = toUndirected(graph);
+
+    const dropEdge = (firstNode: string, secondNode: string) => {
+        const edges = undirectedGraph.filterEdges(firstNode, secondNode, (x) => !!x);
+        edges.forEach((edge) => undirectedGraph.dropEdge(edge));
+    };
+
+    nodes.forEach((node) => {
+        dropEdge(mainNode, node);
+        undirectedGraph.forEachNeighbor(node, (neighborNode) => {
+            dropEdge(node, neighborNode);
+        });
+    });
+
+    const isolatedNodes = [];
+    undirectedGraph.nodes().forEach((node) => {
+        if (getIsolatedNodeId(undirectedGraph, entityUri, node)) {
+            isolatedNodes.push(node);
+        }
+    });
+
+    return uniq(
+        isolatedNodes.reduce(
+            (nodes, isolatedNode) => findSubgraphNodes(isolatedNode, undirectedGraph, nodes),
+            [...isolatedNodes]
+        )
+    );
+};