@reltio/graph 1.4.1585 → 1.4.1586-mui5

package/src/utils/graphLayout.ts

@@ -0,0 +1,70 @@
+import {RelationTypeDirection} from '@reltio/mdm-sdk';
+import Graph from 'graphology';
+import {bidirectional} from 'graphology-shortest-path';
+import {GraphPathType} from '../types/graphDataTypes';
+
+const directionTypes = {
+    [RelationTypeDirection.bidirectional]: 'doubleArrow',
+    [RelationTypeDirection.directed]: 'arrow',
+    [RelationTypeDirection.undirected]: 'line'
+};
+
+export const directionTypeToEdgeType = (directionType: RelationTypeDirection) =>
+    directionTypes[directionType] || 'line';
+
+export const mouseIsOnNode = (mouseX: number, mouseY: number, nodeX: number, nodeY: number, size: number): boolean => {
+    return (
+        mouseX > nodeX - size &&
+        mouseX < nodeX + size &&
+        mouseY > nodeY - size &&
+        mouseY < nodeY + size &&
+        Math.sqrt(Math.pow(mouseX - nodeX, 2) + Math.pow(mouseY - nodeY, 2)) < size
+    );
+};
+
+export const getMousePos = (canvas: HTMLCanvasElement, event: MouseEvent) => {
+    const rect = canvas.getBoundingClientRect();
+    const x = ((event.clientX - rect.left) / (rect.right - rect.left)) * canvas.width;
+    const y = ((event.clientY - rect.top) / (rect.bottom - rect.top)) * canvas.height;
+    return {x, y};
+};
+
+export const edgePathFromNodePath = (graph: Graph, nodes: string[], isDirected = false): string[] => {
+    const edges = [];
+    const searchFn = isDirected ? 'findOutEdge' : 'findEdge';
+    if (nodes) {
+        nodes.forEach((startNode, index, array) => {
+            const secondNode = array[index + 1];
+
+            if (secondNode) {
+                edges.push(graph[searchFn](startNode, secondNode, (x) => !!x));
+            }
+        });
+    }
+    return edges;
+};
+
+type GetPathToNodeProps = {
+    graph: Graph;
+    undirectedGraph: Graph;
+    selectedNode: string;
+    rootNodeUri: string;
+};
+
+export const getPathToNode = ({
+    graph,
+    undirectedGraph,
+    selectedNode,
+    rootNodeUri
+}: GetPathToNodeProps): GraphPathType => {
+    if (graph && undirectedGraph && rootNodeUri && selectedNode && rootNodeUri !== selectedNode) {
+        try {
+            const nodes = bidirectional(undirectedGraph, rootNodeUri, selectedNode);
+            const edges = edgePathFromNodePath(graph, nodes);
+            return nodes ? {edges, nodes} : {};
+        } catch (e) {
+            //if there is no node, we return empty object
+        }
+    }
+    return {};
+};

package/src/utils/hopsData.ts

@@ -0,0 +1,198 @@
+import Graph from 'graphology';
+import {
+    always,
+    append,
+    chain,
+    cond,
+    either,
+    equals,
+    evolve,
+    includes,
+    map,
+    pick,
+    pipe,
+    prop,
+    propEq,
+    reject,
+    T,
+    uniq,
+    without
+} from 'ramda';
+import {bidirectional} from 'graphology-shortest-path';
+import {toUndirected} from 'graphology-operators';
+import {
+    getEndObjectUri,
+    getRelationType,
+    getStartObjectUri,
+    HopEntity,
+    HopRelation,
+    HopsResponse,
+    Metadata,
+    Relation,
+    TRelationType
+} from '@reltio/mdm-sdk';
+
+const addRelationToHopsData = (data: HopsResponse, respondedRelation: Relation, metadata: Metadata): HopsResponse => {
+    const startEntityUri = respondedRelation.startObject.objectURI;
+    const endEntityUri = respondedRelation.endObject.objectURI;
+    const nodeUris = [startEntityUri, endEntityUri];
+    const entitiesUris = data.entities.map(prop('uri'));
+    const relationType: TRelationType = getRelationType(metadata, respondedRelation.type);
+
+    const extraEntityUri = nodeUris.find((node) => !includes(node, entitiesUris));
+    const extraEntity =
+        extraEntityUri &&
+        (respondedRelation.startObject.objectURI === extraEntityUri
+            ? respondedRelation.startObject
+            : respondedRelation.endObject);
+
+    const extraEntityFormatted = extraEntity && {
+        type: extraEntity.type,
+        label: extraEntity.label,
+        uri: extraEntity.objectURI,
+        traversedRelations: 0,
+        untraversedRelations: 1
+    };
+
+    const relation: HopRelation = {
+        ...pick(['uri', 'type', 'attributes', 'startDate', 'endDate', 'crosswalks', 'direction'], respondedRelation),
+        startObject: pick(['objectURI', 'directionalLabel'], respondedRelation.startObject),
+        endObject: pick(['objectURI', 'directionalLabel'], respondedRelation.endObject),
+        direction: relationType?.direction
+    };
+
+    const updateTraversedRelationsCount = (entity) => {
+        if (entity.uri === startEntityUri || entity.uri === endEntityUri) {
+            return {
+                ...entity,
+                traversedRelations: entity.traversedRelations + 1
+            };
+        }
+        return entity;
+    };
+
+    const newData = {
+        entities: (extraEntityFormatted ? data.entities.concat([extraEntityFormatted]) : data.entities).map(
+            updateTraversedRelationsCount
+        ),
+        relations: (data.relations || []).concat([relation])
+    };
+
+    return newData;
+};
+
+const removeRelationFromHopsData = (
+    entityUri: string,
+    relationUri: string,
+    graph: Graph,
+    data: HopsResponse
+): {updatedData: HopsResponse; removedEntitiesUris: string[]} => {
+    const relation = data.relations.find(propEq('uri', relationUri));
+    const startNodeId: string = getStartObjectUri(relation);
+    const endNodeId: string = getEndObjectUri(relation);
+    const undirectedGraph = toUndirected(graph);
+    const isolatedNodeId: string = cond([
+        [() => !bidirectional(undirectedGraph, entityUri, startNodeId), always(startNodeId)],
+        [() => !bidirectional(undirectedGraph, entityUri, endNodeId), always(endNodeId)],
+        [T, always(null)]
+    ])();
+
+    const updateTraversedRelationsCount = (entity) => {
+        if (entity.uri === startNodeId || entity.uri === endNodeId) {
+            return {
+                ...entity,
+                traversedRelations: entity.traversedRelations - 1
+            };
+        }
+        return entity;
+    };
+
+    const dataWithoutRelation: HopsResponse = evolve({
+        entities: map(updateTraversedRelationsCount),
+        relations: reject(propEq('uri', relationUri))
+    })(data);
+    const {updatedData, removedEntitiesUris} = isolatedNodeId
+        ? removeIsolatedSubgraph(isolatedNodeId, dataWithoutRelation)
+        : {
+            updatedData: dataWithoutRelation,
+            removedEntitiesUris: []
+        };
+    return {updatedData, removedEntitiesUris};
+};
+
+const removeIsolatedSubgraph = (isolatedNodeId: string, data: HopsResponse) => {
+    const isolatedRelations = findSubgraphRelations(isolatedNodeId, data);
+    const isolatedEntitiesUris: string[] = pipe(
+        getAllRelatedEntitiesUris,
+        append(isolatedNodeId),
+        uniq
+    )(isolatedRelations);
+    const updatedData: HopsResponse = evolve({
+        relations: reject((relation) => isolatedRelations.includes(relation)),
+        entities: reject((entity) => isolatedEntitiesUris.includes(entity.uri))
+    })(data);
+    return {
+        updatedData,
+        removedEntitiesUris: isolatedEntitiesUris
+    };
+};
+
+const findSubgraphRelations = (
+    nodeId: string,
+    data: HopsResponse,
+    foundRelations: HopRelation[] = []
+): HopRelation[] => {
+    const relations = data.relations
+        .filter((relation) => !foundRelations.includes(relation))
+        .filter(either(pipe(getStartObjectUri, equals(nodeId)), pipe(getEndObjectUri, equals(nodeId))));
+    foundRelations.push(...relations);
+    const relatedNodes: string[] = pipe(getAllRelatedEntitiesUris, without([nodeId]))(relations);
+    relatedNodes.forEach((relatedNodeId) => findSubgraphRelations(relatedNodeId, data, foundRelations));
+    return foundRelations;
+};
+
+const getAllRelatedEntitiesUris = (relations: HopRelation[]): string[] =>
+    pipe(
+        chain((relation) => [getStartObjectUri(relation), getEndObjectUri(relation)]),
+        uniq
+    )(relations);
+
+const mergeHopsData = (data: HopsResponse, newData: HopsResponse, hopsEntityUri: string) => {
+    const {entities: hopsEntities = [], relations: hopsRelations = []} = newData;
+
+    const newEntities = hopsEntities.reduce(
+        (entities: HopEntity[], entity: HopEntity): HopEntity[] => {
+            if (!entities.some(({uri}) => uri === entity.uri)) {
+                entities.push(entity);
+            } else if (entity.uri === hopsEntityUri) {
+                const index = entities.findIndex(({uri}) => uri === hopsEntityUri);
+
+                entities[index] = {
+                    ...entities[index],
+                    traversedRelations: entity.traversedRelations,
+                    untraversedRelations: entity.untraversedRelations
+                };
+            }
+            return entities;
+        },
+        [...(data.entities || [])]
+    );
+
+    const newRelations = hopsRelations.reduce(
+        (relations: HopRelation[], relation: HopRelation): HopRelation[] => {
+            if (!relations.some(({uri}) => uri === relation.uri)) {
+                relations.push(relation);
+            }
+
+            return relations;
+        },
+        [...(data.relations || [])]
+    );
+
+    return {
+        entities: newEntities,
+        relations: newRelations
+    };
+};
+
+export {addRelationToHopsData, removeRelationFromHopsData, mergeHopsData};

package/src/utils/processResponseToGraph.ts

@@ -0,0 +1,32 @@
+import {HopsResponse, RelationTypeDirection} from '@reltio/mdm-sdk';
+import {Node, Edge, GraphologyGraphData} from '../types/graphDataTypes';
+
+const processResponseToGraph = (data: HopsResponse): GraphologyGraphData => {
+    const nodesSet = new Set<string>();
+    const relationsSet = new Set<string>();
+    data.entities.forEach((entity) => nodesSet.add(entity.uri));
+    const filteredRelations =
+        data.relations?.filter(
+            (relation) => nodesSet.has(relation.startObject.objectURI) && nodesSet.has(relation.endObject.objectURI)
+        ) || [];
+    filteredRelations.forEach((relation) => {
+        relationsSet.add(
+            `${relation.startObject.objectURI}--${relation.endObject.objectURI}--${relation.uri}--${relation.type}--${relation.direction}`
+        );
+    });
+    const nodes: Node[] = data.entities.map((entity) => ({
+        id: entity.uri,
+        name: entity.label,
+        entityTypeUri: entity.type,
+        traversedRelationsCount: entity.traversedRelations,
+        untraversedRelationsCount: entity.untraversedRelations
+    }));
+    const edges: Edge[] = [];
+    relationsSet.forEach((relationKey) => {
+        const [from, to, key, relationTypeUri, direction] = relationKey.split('--');
+        edges.push({from, to, key, relationTypeUri, direction: direction as RelationTypeDirection});
+    });
+    return {nodes, edges};
+};
+
+export default processResponseToGraph;

package/tsconfig.json

@@ -0,0 +1,4 @@
+{
+  "extends": "../../tsconfig.json",
+  "include": ["src", "../../custom.d.ts"]
+}

package/webpack.config.js

@@ -0,0 +1,10 @@
+const {merge} = require('webpack-merge');
+const qxComponents = require('../../webpack.qx.components');
+
+const devServerPort = 8896;
+
+module.exports = merge(qxComponents, {
+    devServer: {
+        port: devServerPort
+    }
+});