Merge branch 'dev' into dependabot/npm_and_yarn/npm_and_yarn-04d31be16b

Author: pradeeban

server/controller/workflow.py

@@ -1,11 +1,18 @@
-from model.workflows import *
+from model.workflows import WorkFlowModel
 from flask import request, make_response, Blueprint
 import defusedxml.ElementTree as ET
 
 workFlow = Blueprint('workflow', __name__)
 workFlowModel = WorkFlowModel()
 
 
+def isMissingWorkflow(graphml):
+    if graphml is None:
+        return True
+    # Backward-compatible guard for legacy model return type.
+    return isinstance(graphml, tuple) and len(graphml) > 0 and graphml[0] is False
+
+
 def getLasteshActionHash(root):
     xmlns = root.tag[root.tag.index('{')+1:root.tag.rindex('}')]
     return root.find(f'{{{xmlns}}}graph')\
@@ -32,7 +39,7 @@ def postWorkflow():
 @workFlow.route("/<serverID>")
 def getWorkflow(serverID):
     graphml = workFlowModel.get(serverID)
-    if graphml is None:
+    if isMissingWorkflow(graphml):
         return "Not Found", 404
     if('X-Latest-Hash' in request.headers):
         latestHash = request.headers['X-Latest-Hash']

server/model/workflows.py

@@ -32,7 +32,7 @@ def insert(self, graphml, latestHash):
     def get(self, serverID):
         cl = self.collection.find_one({'serverID': serverID})
         if not cl:
-            return False, 'Record Not Found'
+            return None
         return cl['graphml']
 
     def update(self, serverID, graphml, latestHash, allHash):

server/requirements.txt

@@ -1,5 +1,5 @@
 dnspython==2.6.1
-Flask==2.2.5
+Flask==3.1.3
 python-dotenv==0.19.0
 pymongo==4.6.3
 gunicorn==23.0.0

server/tests/test_workflow_controller.py

@@ -0,0 +1,82 @@
+import importlib
+import pathlib
+import sys
+import types
+import unittest
+
+from flask import Flask
+
+VALID_GRAPHML = (
+    '<graphml xmlns="http://graphml.graphdrawing.org/xmlns">'
+    '<graph edgedefault="directed">'
+    '<actionHistory><hash>hash-1</hash></actionHistory>'
+    '</graph>'
+    '</graphml>'
+)
+
+
+class FakeWorkFlowModel:
+    def __init__(self, graph_response):
+        self.graph_response = graph_response
+
+    def get(self, _server_id):
+        return self.graph_response
+
+
+class WorkflowControllerTests(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        server_root = pathlib.Path(__file__).resolve().parents[1]
+        if str(server_root) not in sys.path:
+            sys.path.insert(0, str(server_root))
+
+        fake_model_pkg = types.ModuleType('model')
+        fake_model_workflows = types.ModuleType('model.workflows')
+
+        class StubWorkFlowModel:
+            def get(self, _server_id):
+                return None
+
+        fake_model_workflows.WorkFlowModel = StubWorkFlowModel
+        fake_model_pkg.workflows = fake_model_workflows
+
+        sys.modules['model'] = fake_model_pkg
+        sys.modules['model.workflows'] = fake_model_workflows
+
+        if 'controller.workflow' in sys.modules:
+            del sys.modules['controller.workflow']
+        cls.workflow_module = importlib.import_module('controller.workflow')
+
+    def make_client(self, graph_response):
+        self.workflow_module.workFlowModel = FakeWorkFlowModel(graph_response)
+        app = Flask(__name__)
+        app.register_blueprint(self.workflow_module.workFlow, url_prefix='/workflow')
+        return app.test_client()
+
+    def test_missing_workflow_returns_404_for_none(self):
+        client = self.make_client(None)
+        response = client.get('/workflow/missing-id')
+        self.assertEqual(response.status_code, 404)
+        self.assertEqual(response.get_data(as_text=True), 'Not Found')
+
+    def test_missing_workflow_returns_404_for_legacy_tuple(self):
+        client = self.make_client((False, 'Record Not Found'))
+        response = client.get('/workflow/missing-id')
+        self.assertEqual(response.status_code, 404)
+        self.assertEqual(response.get_data(as_text=True), 'Not Found')
+
+    def test_hash_header_returns_400_for_different_history(self):
+        client = self.make_client(VALID_GRAPHML)
+        response = client.get('/workflow/existing-id', headers={'X-Latest-Hash': 'unknown-hash'})
+        self.assertEqual(response.status_code, 400)
+        self.assertEqual(response.get_data(as_text=True), 'Different History')
+
+    def test_hash_header_returns_200_for_matching_history(self):
+        client = self.make_client(VALID_GRAPHML)
+        response = client.get('/workflow/existing-id', headers={'X-Latest-Hash': 'hash-1'})
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.get_data(as_text=True), VALID_GRAPHML)
+
+
+if __name__ == '__main__':
+    unittest.main()

src/GraphArea.jsx

@@ -56,11 +56,12 @@ function Graph({
     }, [active, instance, graphID, dispatcher]);
 
     useEffect(() => {
-        if (ref.current) {
-            setContainerDim(ref.current);
-            window.addEventListener('resize', () => setContainerDim(ref.current));
-            setInstance(initialiseNewGraph());
-        }
+        if (!ref.current) return;
+        setContainerDim(ref.current);
+        const handleResize = () => setContainerDim(ref.current);
+        window.addEventListener('resize', handleResize);
+        setInstance(initialiseNewGraph());
+        return () => window.removeEventListener('resize', handleResize);
     }, [ref]);
 
     // Update theme when darkMode changes

src/component/File-drag-drop.jsx

@@ -6,42 +6,58 @@ import { readFile } from '../toolbarActions/toolbarFunctions';
 
 const app = ({ superState, dispatcher }) => {
     const fileRef = React.useRef();
+    const superStateRef = React.useRef(superState);
+    const dispatcherRef = React.useRef(dispatcher);
+
+    useEffect(() => {
+        superStateRef.current = superState;
+        dispatcherRef.current = dispatcher;
+    });
 
     useEffect(() => {
         dispatcher({ type: T.SET_FILE_REF, payload: fileRef });
         const p = document.getElementsByTagName('body')[0];
         const c = document.getElementsByClassName('drag-drop-area')[0];
         let cc = 0;
-        p.addEventListener('dragenter', (e) => {
+
+        const onDragEnter = (e) => {
             e.preventDefault();
             cc += 1;
             if (cc === 1) c.classList.remove('hidden');
-        });
-        p.addEventListener('dragleave', (e) => {
+        };
+        const onDragLeave = (e) => {
             e.preventDefault();
             cc -= 1;
             if (cc === 0) c.classList.add('hidden');
-        });
-
-        p.addEventListener('dragover', (e) => {
+        };
+        const onDragOver = (e) => { e.preventDefault(); };
+        const onDragReset = (e) => {
             e.preventDefault();
-        });
-        ['dragend', 'dragexit', 'drop'].forEach((dragEvent) => {
-            p.addEventListener(dragEvent, (e) => {
-                e.preventDefault();
-                cc = 0;
-                c.classList.add('hidden');
-            });
-        });
-
-        p.addEventListener('drop', (e) => {
+            cc = 0;
+            c.classList.add('hidden');
+        };
+        const onDrop = (e) => {
             e.preventDefault();
             fileRef.current.value = null;
             if (e.dataTransfer.files.length === 1
                 && e.dataTransfer.files[0].name.split('.').slice(-1)[0] === 'graphml') {
-                readFile(superState, dispatcher, e.dataTransfer.files[0]);
+                readFile(superStateRef.current, dispatcherRef.current, e.dataTransfer.files[0]);
             }
-        });
+        };
+
+        p.addEventListener('dragenter', onDragEnter);
+        p.addEventListener('dragleave', onDragLeave);
+        p.addEventListener('dragover', onDragOver);
+        ['dragend', 'dragexit', 'drop'].forEach((dragEvent) => p.addEventListener(dragEvent, onDragReset));
+        p.addEventListener('drop', onDrop);
+
+        return () => {
+            p.removeEventListener('dragenter', onDragEnter);
+            p.removeEventListener('dragleave', onDragLeave);
+            p.removeEventListener('dragover', onDragOver);
+            ['dragend', 'dragexit', 'drop'].forEach((dragEvent) => p.removeEventListener(dragEvent, onDragReset));
+            p.removeEventListener('drop', onDrop);
+        };
     }, []);
     return (
         <div className="drag-drop-area hidden">

src/component/Header.jsx

@@ -31,12 +31,14 @@ const setHotKeys = (actions) => {
         event.preventDefault();
         map[handler.shortcut].click();
     });
+    return keys;
 };
 
 const Header = ({ superState, dispatcher }) => {
     const actions = toolbarList(superState, dispatcher);
     React.useEffect(() => {
-        setHotKeys(actions, superState, dispatcher);
+        const keys = setHotKeys(actions);
+        return () => { if (keys) hotkeys.unbind(keys); };
     }, []);
 
     return (

src/component/TabBar.jsx

@@ -63,6 +63,11 @@ const TabBar = ({ superState, dispatcher }) => {
             const el = document.querySelector('.tab.tab-graph.selected > .tab-act.close');
             if (el) el.click();
         });
+        return () => {
+            hotkeys.unbind('ctrl+shift+m,command+shift+m');
+            hotkeys.unbind('ctrl+shift+e,command+shift+e');
+            hotkeys.unbind('ctrl+shift+l,command+shift+l');
+        };
     }, []);
 
     return (

src/graph-builder/graph-core/3-component.js

@@ -234,10 +234,10 @@ class GraphComponent extends GraphCanvas {
     }
 
     setEdgeNodeValidator({ nodeValidator, edgeValidator }) {
-        // eslint-disable-next-line no-eval
-        this.nodeValidator = eval(nodeValidator);
-        // eslint-disable-next-line no-eval
-        this.edgeValidator = eval(edgeValidator);
+        // eslint-disable-next-line no-new-func
+        this.nodeValidator = new Function(`return ${nodeValidator}`)();
+        // eslint-disable-next-line no-new-func
+        this.edgeValidator = new Function(`return ${edgeValidator}`)();
     }
 
     getNodesEdges() {