kie-issues#1298: Decision Services & multiple DRDs: make it possible o add external Decisions to a Decision Service

packages/dmn-editor-envelope/src/DmnEditorRoot.tsx

@@ -19,7 +19,7 @@
 
 import * as __path from "path";
 import * as React from "react";
-import { useEffect, useMemo, useState } from "react";
+import { useCallback, useEffect, useMemo, useState } from "react";
 import * as DmnEditor from "@kie-tools/dmn-editor/dist/DmnEditor";
 import { normalize, Normalized } from "@kie-tools/dmn-editor/dist/normalization/normalize";
 import { DMN_LATEST_VERSION, DmnLatestModel, DmnMarshaller, getMarshaller } from "@kie-tools/dmn-marshaller";
@@ -563,6 +563,94 @@ function ExternalModelsManager({
     };
   }, [thisDmnsNormalizedPosixPathRelativeToTheWorkspaceRoot]);
 
+  const getIncludedNamespacesFromModel = useCallback((model: Normalized<DmnLatestModel>) => {
+    return (model.definitions.import ?? [])
+      .map((i) => getNamespaceOfDmnImport({ dmnImport: i }))
+      .join(NAMESPACES_EFFECT_SEPARATOR);
+  }, []);
+
+  const getDmnsByNamespace = useCallback((resources: (ResourceContent | undefined)[]) => {
+    const ret = new Map<string, ResourceContent>();
+    for (let i = 0; i < resources.length; i++) {
+      const resource = resources[i];
+      if (!resource) {
+        continue;
+      }
+
+      const content = resource.content ?? "";
+      const ext = __path.extname(resource.normalizedPosixPathRelativeToTheWorkspaceRoot);
+      if (ext === ".dmn") {
+        const namespace = domParser.getDomDocument(content).documentElement.getAttribute("namespace");
+        if (namespace) {
+          // Check for multiplicity of namespaces on DMN models
+          if (ret.has(namespace)) {
+            console.warn(
+              `DMN EDITOR ROOT: Multiple DMN models encountered with the same namespace '${namespace}': '${
+                resource.normalizedPosixPathRelativeToTheWorkspaceRoot
+              }' and '${
+                ret.get(namespace)!.normalizedPosixPathRelativeToTheWorkspaceRoot
+              }'. The latter will be considered.`
+            );
+          }
+
+          ret.set(namespace, resource);
+        }
+      }
+    }
+
+    return ret;
+  }, []);
+
+  // Load all included models from the model and the included models of those models, recursively.
+  const loadDependentModels = useCallback(
+    (
+      model: Normalized<DmnLatestModel>,
+      externalModelsIndex: DmnEditor.ExternalModelsIndex,
+      resourcesByNamespace: Map<string, ResourceContent>,
+      loadedDmnsByPathRelativeToTheWorkspaceRoot: Set<string>,
+      thisDmnsNormalizedPosixPathRelativeToTheWorkspaceRoot: string
+    ) => {
+      const includedNamespaces = new Set(getIncludedNamespacesFromModel(model).split(NAMESPACES_EFFECT_SEPARATOR));
+
+      for (const includedNamespace of includedNamespaces) {
+        if (!resourcesByNamespace.has(includedNamespace)) {
+          console.warn(
+            `DMN EDITOR ROOT: The included namespace '${includedNamespace}' for the model '${model.definitions["@_id"]}' can not be found.`
+          );
+        } else {
+          const resource = resourcesByNamespace.get(includedNamespace)!;
+          if (loadedDmnsByPathRelativeToTheWorkspaceRoot.has(resource.normalizedPosixPathRelativeToTheWorkspaceRoot)) {
+            continue;
+          }
+
+          const normalizedPosixPathRelativeToTheOpenFile = __path.relative(
+            __path.dirname(thisDmnsNormalizedPosixPathRelativeToTheWorkspaceRoot),
+            resource.normalizedPosixPathRelativeToTheWorkspaceRoot
+          );
+          const content = resource.content ?? "";
+          const includedModel = normalize(getMarshaller(content, { upgradeTo: "latest" }).parser.parse());
+          externalModelsIndex[includedNamespace] = {
+            normalizedPosixPathRelativeToTheOpenFile,
+            model: includedModel,
+            type: "dmn",
+            svg: "",
+          };
+
+          loadedDmnsByPathRelativeToTheWorkspaceRoot.add(resource.normalizedPosixPathRelativeToTheWorkspaceRoot);
+
+          loadDependentModels(
+            includedModel,
+            externalModelsIndex,
+            resourcesByNamespace,
+            loadedDmnsByPathRelativeToTheWorkspaceRoot,
+            thisDmnsNormalizedPosixPathRelativeToTheWorkspaceRoot
+          );
+        }
+      }
+    },
+    [getIncludedNamespacesFromModel]
+  );
+
   // This effect actually populates `externalModelsByNamespace` through the `onChange` call.
   useEffect(() => {
     let canceled = false;
@@ -594,7 +682,7 @@ function ExternalModelsManager({
         const externalModelsIndex: DmnEditor.ExternalModelsIndex = {};
 
         const namespacesSet = new Set(namespaces.split(NAMESPACES_EFFECT_SEPARATOR));
-
+        const loadedDmnsByPathRelativeToTheWorkspaceRoot = new Set<string>();
         for (let i = 0; i < resources.length; i++) {
           const resource = resources[i];
           if (!resource) {
@@ -623,6 +711,7 @@ function ExternalModelsManager({
                 );
               }
 
+              loadedDmnsByPathRelativeToTheWorkspaceRoot.add(resource.normalizedPosixPathRelativeToTheWorkspaceRoot);
               externalModelsIndex[namespace] = {
                 normalizedPosixPathRelativeToTheOpenFile,
                 model: normalize(getMarshaller(content, { upgradeTo: "latest" }).parser.parse()),
@@ -645,6 +734,19 @@ function ExternalModelsManager({
           }
         }
 
+        const dmnsByNamespace = getDmnsByNamespace(resources);
+        for (const dmn of dmnsByNamespace.values()) {
+          const content = dmn.content ?? "";
+          const model = normalize(getMarshaller(content, { upgradeTo: "latest" }).parser.parse());
+          loadDependentModels(
+            model,
+            externalModelsIndex,
+            dmnsByNamespace,
+            loadedDmnsByPathRelativeToTheWorkspaceRoot,
+            thisDmnsNormalizedPosixPathRelativeToTheWorkspaceRoot
+          );
+        }
+
         if (!canceled) {
           onChange(externalModelsIndex);
         }
@@ -663,6 +765,8 @@ function ExternalModelsManager({
     externalUpdatesCount,
     workspaceRootAbsolutePosixPath,
     externalModelsManagerDoneBootstraping,
+    getDmnsByNamespace,
+    loadDependentModels,
   ]);
 
   return <></>;

packages/dmn-editor/src/DmnEditor.tsx

@@ -399,7 +399,9 @@ export const DmnEditorInternal = ({
         </Tab>
 
         <Tab eventKey={DmnEditorTab.INCLUDED_MODELS} title={tabTitle.includedModels}>
-          {navigationTab === DmnEditorTab.INCLUDED_MODELS && <IncludedModels />}
+          <div data-testid={"kie-tools--dmn-editor--included-models-container"}>
+            {navigationTab === DmnEditorTab.INCLUDED_MODELS && <IncludedModels />}
+          </div>
         </Tab>
       </Tabs>
     </div>

packages/dmn-editor/src/autolayout/AutolayoutButton.tsx

@@ -58,6 +58,7 @@ export function AutolayoutButton() {
         __readonly_drdIndex: s.computed(s).getDrdIndex(),
         __readonly_dmnObjectNamespace: s.dmn.model.definitions["@_namespace"],
         __readonly_externalDmnsIndex: s.computed(s).getExternalModelTypesByNamespace(externalModelsByNamespace).dmns,
+        __readonly_externalModelsByNamespace: externalModelsByNamespace,
       });
     });
   }, [dmnEditorStoreApi, externalModelsByNamespace]);

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

@@ -246,6 +246,7 @@ export const Diagram = React.forwardRef<DiagramRef, { container: React.RefObject
               shapeId: targetNode.data.shape["@_id"],
             },
             keepWaypoints: false,
+            externalModelsByNamespace,
           });
         });
       },
@@ -337,6 +338,7 @@ export const Diagram = React.forwardRef<DiagramRef, { container: React.RefObject
                   })["@_height"],
                 },
               },
+              externalModelsByNamespace,
             });
             state.diagram._selectedNodes = [newNodeId];
             state.focus.consumableId = newNodeId;
@@ -670,6 +672,7 @@ export const Diagram = React.forwardRef<DiagramRef, { container: React.RefObject
                 })["@_height"],
               },
             },
+            externalModelsByNamespace,
           });
 
           state.diagram._selectedNodes = [newDmnObejctHref];
@@ -876,6 +879,7 @@ export const Diagram = React.forwardRef<DiagramRef, { container: React.RefObject
                   __readonly_externalModelTypesByNamespace: state
                     .computed(state)
                     .getExternalModelTypesByNamespace(externalModelsByNamespace),
+                  externalModelsByNamespace,
                 });
                 state.dispatch(state).diagram.setNodeStatus(node.id, {
                   selected: false,
@@ -897,7 +901,7 @@ export const Diagram = React.forwardRef<DiagramRef, { container: React.RefObject
           }
         });
       },
-      [reactFlowInstance, dmnEditorStoreApi, externalModelsByNamespace]
+      [dmnEditorStoreApi, externalModelsByNamespace]
     );
 
     const resetToBeforeEditingBegan = useCallback(() => {
@@ -990,8 +994,9 @@ export const Diagram = React.forwardRef<DiagramRef, { container: React.RefObject
                 for (let i = 0; i < selectedNodes.length; i++) {
                   deleteDecisionFromDecisionService({
                     definitions: state.dmn.model.definitions,
-                    decisionId: selectedNodes[i].data.dmnObject!["@_id"]!, // We can assume that all selected nodes are Decisions because the contaiment was validated above.
+                    decisionHref: selectedNodes[i].id, // We can assume that all selected nodes are Decisions because the contaiment was validated above.
                     decisionServiceId: p.data.dmnObject!["@_id"]!,
+                    externalModelsByNamespace,
                   });
                 }
               } else {
@@ -1007,12 +1012,13 @@ export const Diagram = React.forwardRef<DiagramRef, { container: React.RefObject
                 addDecisionToDecisionService({
                   definitions: state.dmn.model.definitions,
                   drdIndex: state.computed(state).getDrdIndex(),
-                  decisionId: selectedNodes[i].data.dmnObject!["@_id"]!, // We can assume that all selected nodes are Decisions because the contaiment was validated above.
+                  decisionHref: selectedNodes[i].id, // We can assume that all selected nodes are Decisions because the contaiment was validated above.
                   decisionServiceId: state
                     .computed(state)
                     .getDiagramData(externalModelsByNamespace)
                     .nodesById.get(dropTargetNode.id)!.data.dmnObject!["@_id"]!,
                   snapGrid: state.diagram.snapGrid,
+                  externalModelsByNamespace,
                 });
               }
             } else {
@@ -1047,6 +1053,7 @@ export const Diagram = React.forwardRef<DiagramRef, { container: React.RefObject
                     drdIndex: state.computed(state).getDrdIndex(),
                     edge: { id: change.id, dmnObject: edge.data.dmnObject },
                     mode: EdgeDeletionMode.FROM_DRG_AND_ALL_DRDS,
+                    externalModelsByNamespace,
                   });
                   state.dispatch(state).diagram.setEdgeStatus(change.id, {
                     selected: false,
@@ -1125,6 +1132,7 @@ export const Diagram = React.forwardRef<DiagramRef, { container: React.RefObject
               shapeId: targetNode.data.shape["@_id"],
             },
             keepWaypoints: true,
+            externalModelsByNamespace: externalModelsByNamespace,
           });
 
           // The DMN Edge changed nodes, so we need to delete the old one, but keep the waypoints on the same DRD.
@@ -1134,6 +1142,7 @@ export const Diagram = React.forwardRef<DiagramRef, { container: React.RefObject
               drdIndex: state.computed(state).getDrdIndex(),
               edge: { id: oldEdge.id, dmnObject: oldEdge.data!.dmnObject },
               mode: EdgeDeletionMode.FROM_DRG_AND_ALL_DRDS,
+              externalModelsByNamespace,
             });
 
             const deletedWaypoints = deletedDmnEdgeOnCurrentDrd?.["di:waypoint"];
@@ -1435,6 +1444,7 @@ function DmnDiagramWithoutDrd() {
                     __readonly_externalDmnsIndex: dereferencedState
                       .computed(dereferencedState)
                       .getExternalModelTypesByNamespace(externalModelsByNamespace).dmns,
+                    __readonly_externalModelsByNamespace: externalModelsByNamespace,
                   });
                   s.dmn.model = dereferencedState.dmn.model;
                 });
@@ -1463,6 +1473,7 @@ function DmnDiagramEmptyState({
   isReadOnly?: boolean;
 }) {
   const dmnEditorStoreApi = useDmnEditorStoreApi();
+  const { externalModelsByNamespace } = useExternalModels();
 
   return (
     <Bullseye
@@ -1524,6 +1535,7 @@ function DmnDiagramEmptyState({
                             })["@_height"],
                           },
                         },
+                        externalModelsByNamespace,
                       });
 
                       const drgElementIndex = (state.dmn.model.definitions.drgElement ?? []).length - 1;
@@ -1584,6 +1596,7 @@ function DmnDiagramEmptyState({
                           type: NODE_TYPES.inputData,
                           bounds: inputDataNodeBounds,
                         },
+                        externalModelsByNamespace,
                       });
 
                       const { href: decisionNodeHref } = addConnectedNode({
@@ -1609,6 +1622,7 @@ function DmnDiagramEmptyState({
                             })["@_height"],
                           },
                         },
+                        externalModelsByNamespace: externalModelsByNamespace,
                       });
 
                       state.diagram._selectedNodes = [decisionNodeHref];

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

@@ -134,6 +134,7 @@ export function DiagramCommands(props: {}) {
               drdIndex: state.computed(state).getDrdIndex(),
               edge: { id: edge.id, dmnObject: edge.data!.dmnObject },
               mode: EdgeDeletionMode.FROM_DRG_AND_ALL_DRDS,
+              externalModelsByNamespace,
             });
             state.dispatch(state).diagram.setEdgeStatus(edge.id, {
               selected: false,
@@ -160,6 +161,7 @@ export function DiagramCommands(props: {}) {
                   __readonly_externalModelTypesByNamespace: state
                     .computed(state)
                     .getExternalModelTypesByNamespace(externalModelsByNamespace),
+                  externalModelsByNamespace,
                 });
                 state.dispatch(state).diagram.setNodeStatus(node.id, {
                   selected: false,
@@ -239,12 +241,25 @@ export function DiagramCommands(props: {}) {
             definitions: state.dmn.model.definitions,
             drdIndex: state.computed(state).getDrdIndex(),
           });
-          diagramElements.push(...clipboard.shapes.map((s) => ({ ...s, __$$element: "dmndi:DMNShape" as const })));
-          diagramElements.push(...clipboard.edges.map((s) => ({ ...s, __$$element: "dmndi:DMNEdge" as const })));
+          diagramElements.push(
+            ...clipboard.shapes.map((s) => ({
+              ...s,
+              __$$element: "dmndi:DMNShape" as const,
+            }))
+          );
+          diagramElements.push(
+            ...clipboard.edges.map((s) => ({
+              ...s,
+              __$$element: "dmndi:DMNEdge" as const,
+            }))
+          );
 
           widths.push(...clipboard.widths);
 
-          repopulateInputDataAndDecisionsOnAllDecisionServices({ definitions: state.dmn.model.definitions });
+          repopulateInputDataAndDecisionsOnAllDecisionServices({
+            definitions: state.dmn.model.definitions,
+            externalModelsByNamespace,
+          });
 
           state.diagram._selectedNodes = [...clipboard.drgElements, ...clipboard.artifacts].map((s) =>
             buildXmlHref({ id: s["@_id"]! })
@@ -256,7 +271,7 @@ export function DiagramCommands(props: {}) {
         });
       });
     };
-  }, [dmnEditorStoreApi, commandsRef]);
+  }, [dmnEditorStoreApi, commandsRef, externalModelsByNamespace]);
 
   // Select/deselect all nodes
   useEffect(() => {
@@ -317,12 +332,13 @@ export function DiagramCommands(props: {}) {
               padding: CONTAINER_NODES_DESIRABLE_PADDING,
             }),
           },
+          externalModelsByNamespace,
         });
 
         state.dispatch(state).diagram.setNodeStatus(newNodeId, { selected: true });
       });
     };
-  }, [dmnEditorStoreApi, commandsRef, rf]);
+  }, [dmnEditorStoreApi, commandsRef, rf, externalModelsByNamespace]);
 
   // Toggle hierarchy highlights
   useEffect(() => {
@@ -393,8 +409,12 @@ export function DiagramCommands(props: {}) {
               drdIndex: state.computed(state).getDrdIndex(),
               edge: { id: edge.id, dmnObject: edge.data!.dmnObject },
               mode: EdgeDeletionMode.FROM_CURRENT_DRD_ONLY,
+              externalModelsByNamespace,
+            });
+            state.dispatch(state).diagram.setEdgeStatus(edge.id, {
+              selected: false,
+              draggingWaypoint: false,
             });
-            state.dispatch(state).diagram.setEdgeStatus(edge.id, { selected: false, draggingWaypoint: false });
           }
         }
 
@@ -415,6 +435,7 @@ export function DiagramCommands(props: {}) {
             __readonly_dmnObjectId: node.data.dmnObject?.["@_id"],
             __readonly_nodeNature: nodeNatures[node.type as NodeType],
             mode: NodeDeletionMode.FROM_CURRENT_DRD_ONLY,
+            externalModelsByNamespace,
           });
 
           if (deletedShape) {