kie-issues#886: On the DMN Editor, adding waypoints to edges that don't have a corresponding DMNEdge associated with it should create the DMNEdge and add the waypoint normally

packages/dmn-editor/src/diagram/Diagram.tsx

@@ -216,7 +216,7 @@
           const sourceBounds = sourceNode.data.shape["dc:Bounds"];
           const targetBounds = targetNode.data.shape["dc:Bounds"];
           if (!sourceBounds || !targetBounds) {
-            throw new Error("Cannot create connection without target bounds!");
+            throw new Error("Cannot create connection without source and target bounds!");
           }
 
           // --------- This is where we draw the line between the diagram and the model.
@@ -897,7 +897,7 @@
           }
         });
       },
       [reactFlowInstance, dmnEditorStoreApi, externalModelsByNamespace]
     );
 
     const resetToBeforeEditingBegan = useCallback(() => {

packages/dmn-editor/src/diagram/connections/isValidConnection.ts

@@ -39,14 +39,18 @@ export function checkIsValidConnection(
 export function _checkIsValidConnection(
   sourceNode: { type?: string; data: DmnDiagramNodeData } | undefined,
   targetNode: { type?: string; data: DmnDiagramNodeData } | undefined,
-  edgeType: string | null | undefined
+  edgeType: string | null | undefined,
+  extraArg?: { allowExternalTarget: boolean }
 ) {
   if (!sourceNode?.type || !targetNode?.type || !edgeType) {
     return false;
   }
 
-  // External nodes cannot be targeted
-  if (targetNode.data.dmnObjectQName.prefix) {
+  // External nodes cannot be targeted by default
+  // However there are exceptions, for example adding a waypoint on the edge
+  const targetsExternalNode = targetNode.data.dmnObjectQName.prefix !== undefined;
+  const allowExternalTarget = extraArg?.allowExternalTarget ?? false;
+  if (targetsExternalNode && !allowExternalTarget) {
     return false;
   }
 

packages/dmn-editor/src/diagram/edges/usePotentialWaypointControls.ts

@@ -25,6 +25,12 @@ import { snapPoint } from "../SnapGrid";
 import { DC__Point } from "@kie-tools/dmn-marshaller/dist/schemas/dmn-1_5/ts-gen/types";
 import { DmnDiagramNodeData } from "../nodes/Nodes";
 import { DmnDiagramEdgeData } from "./Edges";
+import { useExternalModels } from "../../includedModels/DmnEditorDependenciesContext";
+import { addEdge } from "../../mutations/addEdge";
+import { EdgeType, NodeType } from "../connections/graphStructure";
+import { PositionalNodeHandleId } from "../connections/PositionalNodeHandles";
+import { getHandlePosition } from "../maths/DmnMaths";
+import { xmlHrefToQName } from "../../xml/xmlHrefToQName";
 
 export function usePotentialWaypointControls(
   waypoints: DC__Point[],
@@ -38,6 +44,7 @@ export function usePotentialWaypointControls(
   const isDraggingWaypoint = useDmnEditorStore((s) => !!s.diagram.draggingWaypoints.find((e) => e === edgeId));
   const dmnEditorStoreApi = useDmnEditorStoreApi();
   const reactFlowInstance = RF.useReactFlow<DmnDiagramNodeData, DmnDiagramEdgeData>();
+  const { externalModelsByNamespace } = useExternalModels();
 
   const [potentialWaypoint, setPotentialWaypoint] = useState<ReturnType<typeof approximateClosestPoint> | undefined>(
     undefined
@@ -74,12 +81,82 @@ export function usePotentialWaypointControls(
   }, [snapGrid, potentialWaypoint]);
 
   const onDoubleClick = useCallback(() => {
-    if (!potentialWaypoint || !snappedPotentialWaypoint || edgeIndex === undefined) {
+    if (!potentialWaypoint || !snappedPotentialWaypoint) {
       return;
     }
 
+    if (edgeIndex === undefined) {
+      /**
+       * This means we are adding a first waypoint to one of following edges:
+       * - an edge in a non default DRD
+       * - an edge targeting an external node
+       */
+      dmnEditorStoreApi.setState((state) => {
+        const nodesById = state.computed(state).getDiagramData(externalModelsByNamespace).nodesById;
+        const edge = state.computed(state).getDiagramData(externalModelsByNamespace).edgesById.get(edgeId);
+        if (edge === undefined || edge.data?.dmnShapeSource === undefined || edge.data?.dmnShapeTarget == undefined) {
+          console.debug(
+            `DMN DIAGRAM: We can not add DMNEdge for '${edgeId}' edge into diagram. There are missing data edge: ${edge}, edge.data: ${edge?.data}`
+          );
+          return;
+        }
+
+        const edgeSourceBounds = edge.data?.dmnShapeSource["dc:Bounds"];
+        const edgeTargetBounds = edge.data?.dmnShapeTarget["dc:Bounds"];
+        if (edgeSourceBounds === undefined || edgeTargetBounds === undefined) {
+          console.debug(
+            `DMN DIAGRAM: We can not add DMNEdge for '${edgeId}' edge into diagram. There are missing data edgeSourceBounds: ${edgeSourceBounds}, edgeTargetBounds: ${edgeTargetBounds}`
+          );
+          return;
+        }
+
+        const sourceNode = nodesById.get(edge.source);
+        const targetNode = nodesById.get(edge.target);
+        if (sourceNode === undefined || targetNode === undefined) {
+          console.debug(
+            `DMN DIAGRAM: We can not add DMNEdge for '${edgeId}' edge into diagram. There are missing data sourceNode: ${sourceNode}, targetNode: ${targetNode}`
+          );
+          return;
+        }
+
+        const targetsExternalNode = targetNode.data.dmnObjectQName.prefix !== undefined;
+        const requirementEdgeQNameRelativeToThisDmn = xmlHrefToQName(edgeId, state.dmn.model.definitions);
+        addEdge({
+          definitions: state.dmn.model.definitions,
+          drdIndex: state.computed(state).getDrdIndex(),
+          edge: {
+            type: edge.type as EdgeType,
+            targetHandle: getHandlePosition({ shapeBounds: edgeTargetBounds, waypoint: snappedPotentialWaypoint })
+              .handlePosition as PositionalNodeHandleId,
+            sourceHandle: getHandlePosition({ shapeBounds: edgeSourceBounds, waypoint: snappedPotentialWaypoint })
+              .handlePosition as PositionalNodeHandleId,
+            autoPositionedEdgeMarker: undefined,
+          },
+          sourceNode: {
+            type: sourceNode.type as NodeType,
+            data: sourceNode.data,
+            href: edge.source,
+            bounds: edgeSourceBounds,
+            shapeId: edge.data?.dmnShapeSource["@_id"],
+          },
+          targetNode: {
+            type: targetNode.type as NodeType,
+            href: edge.target,
+            data: targetNode.data,
+            bounds: edgeTargetBounds,
+            index: nodesById.get(edge.target)?.data.index ?? 0,
+            shapeId: edge.data?.dmnShapeTarget["@_id"],
+          },
+          keepWaypoints: false,
+          dmnElementRefOfDmnEdge: targetsExternalNode ? requirementEdgeQNameRelativeToThisDmn : undefined,
+        });
+
+        console.debug(`DMN DIAGRAM: DMNEdge for '${edgeId}' edge was added into diagram.`);
+      });
+    }
+
     if (isExistingWaypoint(snappedPotentialWaypoint)) {
-      console.debug("Preventing overlapping waypoint creation.");
+      console.debug("DMN DIAGRAM: Preventing overlapping waypoint creation.");
       return;
     }
 
@@ -96,18 +173,27 @@ export function usePotentialWaypointControls(
     }
 
     dmnEditorStoreApi.setState((state) => {
+      const edgeQName = xmlHrefToQName(edgeId, state.dmn.model.definitions);
+      const dmnEdgeIndex = state.computed(state).indexedDrd().dmnEdgesByDmnElementRef.get(edgeQName)?.index;
+      if (dmnEdgeIndex === undefined) {
+        throw new Error(`DMN DIAGRAM: Diagram computed state does not contain DMNEdge for '${edgeId}' edge.`);
+      }
       addEdgeWaypoint({
         definitions: state.dmn.model.definitions,
         drdIndex,
         beforeIndex: i - 1,
-        edgeIndex,
+        dmnEdgeIndex,
         waypoint: snappedPotentialWaypoint,
       });
+
+      console.debug(`DMN DIAGRAM: Waypoint on the DMNEdge for '${edgeId}' edge was added.`);
     });
   }, [
     drdIndex,
     dmnEditorStoreApi,
+    edgeId,
     edgeIndex,
+    externalModelsByNamespace,
     isExistingWaypoint,
     potentialWaypoint,
     snappedPotentialWaypoint,

packages/dmn-editor/src/mutations/addEdge.ts

@@ -27,7 +27,6 @@ import {
   DMN15__tInformationRequirement,
   DMN15__tKnowledgeRequirement,
   DMNDI15__DMNEdge,
-  DMNDI15__DMNShape,
 } from "@kie-tools/dmn-marshaller/dist/schemas/dmn-1_5/ts-gen/types";
 import { PositionalNodeHandleId } from "../diagram/connections/PositionalNodeHandles";
 import { EdgeType, NodeType } from "../diagram/connections/graphStructure";
@@ -49,6 +48,7 @@ export function addEdge({
   targetNode,
   edge,
   keepWaypoints,
+  dmnElementRefOfDmnEdge,
 }: {
   definitions: Normalized<DMN15__tDefinitions>;
   drdIndex: number;
@@ -74,14 +74,17 @@ export function addEdge({
     autoPositionedEdgeMarker: AutoPositionedEdgeMarker | undefined;
   };
   keepWaypoints: boolean;
+  // QName format, used as dmnElementRef for DMNEdge targeting an external node
+  dmnElementRefOfDmnEdge?: string;
 }) {
-  if (!_checkIsValidConnection(sourceNode, targetNode, edge.type)) {
+  const externalTargetAllowed = dmnElementRefOfDmnEdge !== undefined;
+  if (!_checkIsValidConnection(sourceNode, targetNode, edge.type, { allowExternalTarget: externalTargetAllowed })) {
     throw new Error(`DMN MUTATION: Invalid structure: (${sourceNode.type}) --${edge.type}--> (${targetNode.type}) `);
   }
 
   const newEdgeId = generateUuid();
 
-  let existingEdgeId: string | undefined = undefined;
+  let existingRequirementOrAssociationId: string | undefined = dmnElementRefOfDmnEdge;
 
   // Associations
   if (edge.type === EDGE_TYPES.association) {
@@ -99,29 +102,29 @@ export function addEdge({
       definitions.artifact,
       (a) => a.__$$element === "association" && areAssociationsEquivalent(a, newAssociation)
     );
-    existingEdgeId = removed?.["@_id"];
+    existingRequirementOrAssociationId = removed?.["@_id"];
 
     // Replace with the new one.
     definitions.artifact?.push({
       __$$element: "association",
       ...newAssociation,
-      "@_id": tryKeepingEdgeId(existingEdgeId, newEdgeId),
+      "@_id": tryKeepingEdgeId(existingRequirementOrAssociationId, newEdgeId),
     });
   }
   // Requirements
-  else {
+  else if (!externalTargetAllowed) {
     const requirements = getRequirementsFromEdge(sourceNode, newEdgeId, edge.type);
     const drgElement = definitions.drgElement![targetNode.index] as Normalized<DMN15__tDecision>; // We cast to tDecision here because it has all three types of requirement.
     if (requirements?.informationRequirement) {
       drgElement.informationRequirement ??= [];
       const removed = removeFirstMatchIfPresent(drgElement.informationRequirement, (ir) =>
         doesInformationRequirementsPointTo(ir, sourceNode.href)
       );
-      existingEdgeId = removed?.["@_id"];
+      existingRequirementOrAssociationId = removed?.["@_id"];
       drgElement.informationRequirement?.push(
         ...requirements.informationRequirement.map((s) => ({
           ...s,
-          "@_id": tryKeepingEdgeId(existingEdgeId, newEdgeId),
+          "@_id": tryKeepingEdgeId(existingRequirementOrAssociationId, newEdgeId),
         }))
       );
     }
@@ -131,11 +134,11 @@ export function addEdge({
       const removed = removeFirstMatchIfPresent(drgElement.knowledgeRequirement, (kr) =>
         doesKnowledgeRequirementsPointTo(kr, sourceNode.href)
       );
-      existingEdgeId = removed?.["@_id"];
+      existingRequirementOrAssociationId = removed?.["@_id"];
       drgElement.knowledgeRequirement?.push(
         ...requirements.knowledgeRequirement.map((s) => ({
           ...s,
-          "@_id": tryKeepingEdgeId(existingEdgeId, newEdgeId),
+          "@_id": tryKeepingEdgeId(existingRequirementOrAssociationId, newEdgeId),
         }))
       );
     }
@@ -145,11 +148,11 @@ export function addEdge({
       const removed = removeFirstMatchIfPresent(drgElement.authorityRequirement, (ar) =>
         doesAuthorityRequirementsPointTo(ar, sourceNode.href)
       );
-      existingEdgeId = removed?.["@_id"];
+      existingRequirementOrAssociationId = removed?.["@_id"];
       drgElement.authorityRequirement?.push(
         ...requirements.authorityRequirement.map((s) => ({
           ...s,
-          "@_id": tryKeepingEdgeId(existingEdgeId, newEdgeId),
+          "@_id": tryKeepingEdgeId(existingRequirementOrAssociationId, newEdgeId),
         }))
       );
     }
@@ -160,7 +163,7 @@ export function addEdge({
   // Remove existing
   const removedDmnEdge = removeFirstMatchIfPresent(
     diagramElements,
-    (e) => e.__$$element === "dmndi:DMNEdge" && e["@_dmnElementRef"] === existingEdgeId
+    (e) => e.__$$element === "dmndi:DMNEdge" && e["@_dmnElementRef"] === existingRequirementOrAssociationId
   ) as Normalized<DMNDI15__DMNEdge> | undefined;
 
   const newWaypoints = keepWaypoints
@@ -179,7 +182,7 @@ export function addEdge({
     "@_id":
       withoutDiscreteAutoPosinitioningMarker(removedDmnEdge?.["@_id"] ?? generateUuid()) +
       (edge.autoPositionedEdgeMarker ?? ""),
-    "@_dmnElementRef": existingEdgeId ?? newEdgeId,
+    "@_dmnElementRef": existingRequirementOrAssociationId ?? newEdgeId,
     "@_sourceElement": sourceNode.shapeId,
     "@_targetElement": targetNode.shapeId,
     "di:waypoint": newWaypoints,

packages/dmn-editor/src/mutations/addEdgeWaypoint.ts

@@ -24,21 +24,21 @@ import { Normalized } from "../normalization/normalize";
 export function addEdgeWaypoint({
   definitions,
   drdIndex,
-  edgeIndex,
+  dmnEdgeIndex,
   beforeIndex,
   waypoint,
 }: {
   definitions: Normalized<DMN15__tDefinitions>;
   drdIndex: number;
-  edgeIndex: number;
+  dmnEdgeIndex: number;
   beforeIndex: number;
   waypoint: DC__Point;
 }) {
   const { diagramElements } = addOrGetDrd({ definitions, drdIndex });
 
-  const diagramElement = diagramElements[edgeIndex];
+  const diagramElement = diagramElements[dmnEdgeIndex];
   if (diagramElement.__$$element !== "dmndi:DMNEdge") {
-    throw new Error("DMN MUTATION: Can't remove a waypoint from an element that is not a DMNEdge.");
+    throw new Error("DMN MUTATION: Can't add a waypoint for an element that is not a DMNEdge.");
   }
 
   if (beforeIndex > (diagramElement["di:waypoint"]?.length ?? 0) - 1) {

packages/dmn-editor/src/mutations/addShape.ts

@@ -20,7 +20,6 @@
 import {
   DC__Point,
   DMN15__tDefinitions,
-  DMNDI15__DMNDecisionServiceDividerLine,
   DMNDI15__DMNShape,
 } from "@kie-tools/dmn-marshaller/dist/schemas/dmn-1_5/ts-gen/types";
 import { NodeType } from "../diagram/connections/graphStructure";

packages/dmn-editor/src/mutations/addStandaloneNode.ts

@@ -18,7 +18,7 @@
  */
 
 import { switchExpression } from "@kie-tools-core/switch-expression-ts";
-import { DmnBuiltInDataType, generateUuid } from "@kie-tools/boxed-expression-component/dist/api";
+import { generateUuid } from "@kie-tools/boxed-expression-component/dist/api";
 import { DC__Bounds, DMN15__tDefinitions } from "@kie-tools/dmn-marshaller/dist/schemas/dmn-1_5/ts-gen/types";
 import { NodeType } from "../diagram/connections/graphStructure";
 import { NODE_TYPES } from "../diagram/nodes/NodeTypes";