@nyaruka/temba-components 0.132.0 → 0.134.0

package/test/temba-flow-editor-node.test.ts

@@ -1200,6 +1200,230 @@ describe('EditorNode', () => {
       // 3. New JSPlumb connections are created with connectIds
       // This sequence ensures JSPlumb visuals stay in sync with the flow definition
     });
+
+    it('reroutes connections when removing node with multiple exits pointing to same destination', async () => {
+      // Test case: node with multiple exits, but all point to the same destination
+      const mockNode: Node = {
+        uuid: 'test-node',
+        actions: [
+          {
+            type: 'send_msg',
+            uuid: 'action-1',
+            text: 'Hello',
+            quick_replies: []
+          } as any
+        ],
+        exits: [
+          { uuid: 'exit-1', destination_uuid: 'node-after' },
+          { uuid: 'exit-2', destination_uuid: 'node-after' },
+          { uuid: 'exit-3', destination_uuid: 'node-after' }
+        ]
+      };
+
+      const mockFlowDefinition = {
+        language: 'en',
+        localization: {},
+        name: 'Test Flow',
+        type: 'messaging' as const,
+        uuid: 'test-uuid',
+        revision: 1,
+        spec_version: '14.3',
+        nodes: [
+          {
+            uuid: 'node-before',
+            actions: [],
+            exits: [{ uuid: 'exit-before', destination_uuid: 'test-node' }]
+          },
+          mockNode,
+          {
+            uuid: 'node-after',
+            actions: [],
+            exits: []
+          }
+        ],
+        _ui: {
+          nodes: {},
+          languages: []
+        }
+      };
+
+      // Set up the zustand store with our test flow
+      const { zustand } = await import('../src/store/AppState');
+      zustand.setState({
+        flowDefinition: mockFlowDefinition as any
+      });
+
+      // Verify initial state - node-before points to test-node
+      const initialNodeBefore = zustand
+        .getState()
+        .flowDefinition.nodes.find((n) => n.uuid === 'node-before');
+      expect(initialNodeBefore.exits[0].destination_uuid).to.equal('test-node');
+
+      // Call removeNodes to trigger the rerouting logic
+      zustand.getState().removeNodes(['test-node']);
+
+      // Verify that the node was removed
+      const remainingNodes = zustand.getState().flowDefinition.nodes;
+      expect(remainingNodes.find((n) => n.uuid === 'test-node')).to.be
+        .undefined;
+
+      // Verify that node-before's exit was rerouted to node-after
+      const updatedNodeBefore = remainingNodes.find(
+        (n) => n.uuid === 'node-before'
+      );
+      expect(updatedNodeBefore.exits[0].destination_uuid).to.equal(
+        'node-after'
+      );
+    });
+
+    it('does not reroute connections when node has exits with different destinations', async () => {
+      // Test case: node with multiple exits pointing to different destinations
+      const mockNode: Node = {
+        uuid: 'test-node',
+        actions: [
+          {
+            type: 'send_msg',
+            uuid: 'action-1',
+            text: 'Hello',
+            quick_replies: []
+          } as any
+        ],
+        exits: [
+          { uuid: 'exit-1', destination_uuid: 'node-after-1' },
+          { uuid: 'exit-2', destination_uuid: 'node-after-2' }
+        ]
+      };
+
+      const mockFlowDefinition = {
+        language: 'en',
+        localization: {},
+        name: 'Test Flow',
+        type: 'messaging' as const,
+        uuid: 'test-uuid',
+        revision: 1,
+        spec_version: '14.3',
+        nodes: [
+          {
+            uuid: 'node-before',
+            actions: [],
+            exits: [{ uuid: 'exit-before', destination_uuid: 'test-node' }]
+          },
+          mockNode,
+          {
+            uuid: 'node-after-1',
+            actions: [],
+            exits: []
+          },
+          {
+            uuid: 'node-after-2',
+            actions: [],
+            exits: []
+          }
+        ],
+        _ui: {
+          nodes: {},
+          languages: []
+        }
+      };
+
+      // Set up the zustand store with our test flow
+      const { zustand } = await import('../src/store/AppState');
+      zustand.setState({
+        flowDefinition: mockFlowDefinition as any
+      });
+
+      // Verify initial state
+      const initialNodeBefore = zustand
+        .getState()
+        .flowDefinition.nodes.find((n) => n.uuid === 'node-before');
+      expect(initialNodeBefore.exits[0].destination_uuid).to.equal('test-node');
+
+      // Call removeNodes
+      zustand.getState().removeNodes(['test-node']);
+
+      // Verify that the node was removed
+      const remainingNodes = zustand.getState().flowDefinition.nodes;
+      expect(remainingNodes.find((n) => n.uuid === 'test-node')).to.be
+        .undefined;
+
+      // Verify that incoming connection was cleared (set to null), not rerouted
+      const updatedNodeBefore = remainingNodes.find(
+        (n) => n.uuid === 'node-before'
+      );
+      expect(updatedNodeBefore.exits[0].destination_uuid).to.be.null;
+    });
+
+    it('does not reroute connections when node has exits with null destinations', async () => {
+      // Test case: node with some exits having null destinations
+      const mockNode: Node = {
+        uuid: 'test-node',
+        actions: [
+          {
+            type: 'send_msg',
+            uuid: 'action-1',
+            text: 'Hello',
+            quick_replies: []
+          } as any
+        ],
+        exits: [
+          { uuid: 'exit-1', destination_uuid: 'node-after' },
+          { uuid: 'exit-2', destination_uuid: null }
+        ]
+      };
+
+      const mockFlowDefinition = {
+        language: 'en',
+        localization: {},
+        name: 'Test Flow',
+        type: 'messaging' as const,
+        uuid: 'test-uuid',
+        revision: 1,
+        spec_version: '14.3',
+        nodes: [
+          {
+            uuid: 'node-before',
+            actions: [],
+            exits: [{ uuid: 'exit-before', destination_uuid: 'test-node' }]
+          },
+          mockNode,
+          {
+            uuid: 'node-after',
+            actions: [],
+            exits: []
+          }
+        ],
+        _ui: {
+          nodes: {},
+          languages: []
+        }
+      };
+
+      // Set up the zustand store with our test flow
+      const { zustand } = await import('../src/store/AppState');
+      zustand.setState({
+        flowDefinition: mockFlowDefinition as any
+      });
+
+      // Verify initial state
+      const initialNodeBefore = zustand
+        .getState()
+        .flowDefinition.nodes.find((n) => n.uuid === 'node-before');
+      expect(initialNodeBefore.exits[0].destination_uuid).to.equal('test-node');
+
+      // Call removeNodes
+      zustand.getState().removeNodes(['test-node']);
+
+      // Verify that the node was removed
+      const remainingNodes = zustand.getState().flowDefinition.nodes;
+      expect(remainingNodes.find((n) => n.uuid === 'test-node')).to.be
+        .undefined;
+
+      // Verify that incoming connection was cleared (set to null), not rerouted
+      const updatedNodeBefore = remainingNodes.find(
+        (n) => n.uuid === 'node-before'
+      );
+      expect(updatedNodeBefore.exits[0].destination_uuid).to.be.null;
+    });
   });
 
   describe('add action button', () => {

package/test/temba-utils-uuid.test.ts

@@ -1,5 +1,5 @@
 import { assert } from '@open-wc/testing';
-import { generateUUID } from '../src/utils';
+import { generateUUID, generateUUIDv7 } from '../src/utils';
 
 describe('UUID Generation', () => {
   it('generates a valid UUID v4 format', () => {
@@ -45,4 +45,64 @@ describe('UUID Generation', () => {
     // All should be unique
     assert.equal(uuids.size, count, 'All generated UUIDs should be unique');
   });
+
+  it('generates a valid UUID v7 format', () => {
+    const uuid = generateUUIDv7();
+
+    // check that it's a string
+    assert.isString(uuid);
+
+    // check UUID v7 format: xxxxxxxx-xxxx-7xxx-yxxx-xxxxxxxxxxxx
+    const uuidPattern =
+      /^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+    assert.match(uuid, uuidPattern, 'Should match UUID v7 format');
+
+    // check length
+    assert.equal(uuid.length, 36);
+
+    // check that it contains hyphens in the right places
+    assert.equal(uuid[8], '-');
+    assert.equal(uuid[13], '-');
+    assert.equal(uuid[18], '-');
+    assert.equal(uuid[23], '-');
+  });
+
+  it('generates unique UUIDs v7', () => {
+    const uuid1 = generateUUIDv7();
+    const uuid2 = generateUUIDv7();
+    const uuid3 = generateUUIDv7();
+
+    // all should be different
+    assert.notEqual(uuid1, uuid2);
+    assert.notEqual(uuid2, uuid3);
+    assert.notEqual(uuid1, uuid3);
+  });
+
+  it('generates time-ordered UUIDs v7', () => {
+    const uuid1 = generateUUIDv7();
+    // small delay to ensure different timestamp
+    const delayPromise = new Promise((resolve) => setTimeout(resolve, 5));
+    return delayPromise.then(() => {
+      const uuid2 = generateUUIDv7();
+
+      // uuid v7 should be sortable by timestamp
+      // the first uuid should come before the second when compared as strings
+      assert.isTrue(
+        uuid1 < uuid2,
+        'Earlier UUID should be lexicographically smaller'
+      );
+    });
+  });
+
+  it('generates many unique UUIDs v7', () => {
+    const uuids = new Set();
+    const count = 1000;
+
+    for (let i = 0; i < count; i++) {
+      uuids.add(generateUUIDv7());
+    }
+
+    // all should be unique
+    assert.equal(uuids.size, count, 'All generated UUIDs should be unique');
+  });
 });

package/test/utils.test.ts

@@ -240,7 +240,11 @@ export const waitForCondition = async (
   }
 };
 
-export const assertScreenshot = async (filename: string, clip: Clip) => {
+export const assertScreenshot = async (
+  filename: string,
+  clip: Clip,
+  waitForNetwork: boolean = false
+) => {
   // detect if we're running in copilot's environment and use adaptive threshold
   const isCopilotEnvironment = (window as any).isCopilotEnvironment;
   const threshold = isCopilotEnvironment ? 1.0 : 0.1;
@@ -251,7 +255,8 @@ export const assertScreenshot = async (filename: string, clip: Clip) => {
       `${filename}.png`,
       clip,
       exclude,
-      threshold
+      threshold,
+      waitForNetwork
     );
   } catch (error) {
     if (error.message) {

package/test-assets/contacts/history.json

@@ -1,8 +1,5 @@
 {
-  "has_older": true,
-  "recent_only": false,
-  "next_before": 1617135091567814,
-  "next_after": 1609359091567814,
+  "next": "01997d74-bf67-749a-8440-688a41c3b270",
   "events": [
     {
       "uuid": "01997d74-bf67-749a-8440-688a41c3b275",
@@ -54,7 +51,11 @@
           "name": "SMS Channel"
         }
       },
-      "_status": {"created_on": "2025-09-24T20:40:28.239437+00:00", "status": "failed", "reason": "error_limit"},
+      "_status": {
+        "created_on": "2025-09-24T20:40:28.239437+00:00",
+        "status": "failed",
+        "reason": "error_limit"
+      },
       "_logs_url": null
     },
     {
@@ -89,7 +90,10 @@
           "name": "SMS Channel"
         }
       },
-      "_status": {"created_on": "2025-09-23T20:40:28.239434+00:00", "status": "wired"},
+      "_status": {
+        "created_on": "2025-09-23T20:40:28.239434+00:00",
+        "status": "wired"
+      },
       "_logs_url": "/channels/channellog/read/1478/"
     },
     {
@@ -118,7 +122,10 @@
           "name": "SMS Channel"
         }
       },
-      "_status": {"created_on": "2025-09-23T20:40:28.239434+00:00", "status": "wired"},
+      "_status": {
+        "created_on": "2025-09-23T20:40:28.239434+00:00",
+        "status": "wired"
+      },
       "_logs_url": "/channels/channellog/read/1476/"
     },
     {
@@ -147,7 +154,10 @@
           "name": "SMS Channel"
         }
       },
-      "_status": {"created_on": "2025-09-23T20:40:28.239434+00:00", "status": "wired"},
+      "_status": {
+        "created_on": "2025-09-23T20:40:28.239434+00:00",
+        "status": "wired"
+      },
       "_logs_url": "/channels/channellog/read/1474/"
     },
     {
@@ -198,7 +208,10 @@
           "name": "SMS Channel"
         }
       },
-      "_status": {"created_on": "2025-09-23T20:40:28.239434+00:00", "status": "wired"},
+      "_status": {
+        "created_on": "2025-09-23T20:40:28.239434+00:00",
+        "status": "wired"
+      },
       "_logs_url": "/channels/channellog/read/1472/"
     },
     {

package/web-test-runner.config.mjs

@@ -145,15 +145,15 @@ const wireScreenshots = async (page, context, wait, replaceScreenshots) => {
 
   page.exposeFunction(
     'matchPageSnapshot',
-    (filename, clip, excluded, threshold) => {
+    (filename, clip, excluded, threshold, waitForNetwork = false) => {
       return new Promise(async (resolve, reject) => {
         // const start = Date.now();
         const testFile = await getPath(TEST, filename);
         const truthFile = await getPath(TRUTH, filename);
 
-        // Only wait for network idle if explicitly requested
+        // Wait for network idle - use per-call parameter or fall back to global wait flag
         try{
-          if (wait) {
+          if (waitForNetwork || wait) {
             await page.waitForNetworkIdle({idleTime: 500, timeout: 2000});
           } else {
             await page.waitForNetworkIdle({ idleTime: 100, timeout: 1000 });