@nyaruka/temba-components 0.130.1 → 0.130.3

package/out-tsc/test/nodes/wait_for_response.test.js

@@ -1,6 +1,7 @@
 import { expect } from '@open-wc/testing';
 import { wait_for_response } from '../../src/flow/nodes/wait_for_response';
 import { NodeTest } from '../NodeHelper';
+import { createOperatorOption } from '../../src/flow/operators';
 /**
  * Test suite for the wait_for_response node configuration.
  */
@@ -20,96 +21,101 @@ describe('wait_for_response node config', () => {
         });
         it('has layout configuration', () => {
             expect(wait_for_response.layout).to.exist;
-            expect(wait_for_response.layout).to.deep.equal([
-                'timeout',
-                'result_name'
-            ]);
+            expect(wait_for_response.layout).to.deep.equal(['rules', 'result_name']);
         });
     });
     describe('node scenarios', () => {
-        helper.testNode({
-            uuid: 'test-wait-node-1',
-            actions: [],
-            router: {
-                type: 'switch',
-                wait: {
-                    type: 'msg',
-                    timeout: {
-                        category_uuid: 'timeout-cat-1',
-                        seconds: 300
-                    }
+        it('renders basic wait', async () => {
+            await helper.testNode({
+                uuid: 'test-wait-node-1',
+                actions: [],
+                router: {
+                    type: 'switch',
+                    wait: {
+                        type: 'msg',
+                        timeout: {
+                            category_uuid: 'timeout-cat-1',
+                            seconds: 300
+                        }
+                    },
+                    result_name: 'response',
+                    categories: [
+                        {
+                            uuid: 'timeout-cat-1',
+                            name: 'No Response',
+                            exit_uuid: 'timeout-exit-1'
+                        }
+                    ]
                 },
-                result_name: 'response',
-                categories: [
-                    {
-                        uuid: 'timeout-cat-1',
-                        name: 'No Response',
-                        exit_uuid: 'timeout-exit-1'
-                    }
-                ]
-            },
-            exits: [{ uuid: 'timeout-exit-1', destination_uuid: null }]
-        }, { type: 'wait_for_response' }, 'basic-wait');
-        helper.testNode({
-            uuid: 'test-wait-node-2',
-            actions: [],
-            router: {
-                type: 'switch',
-                wait: {
-                    type: 'msg',
-                    timeout: {
-                        category_uuid: 'timeout-cat-2',
-                        seconds: 1800
-                    }
+                exits: [{ uuid: 'timeout-exit-1', destination_uuid: null }]
+            }, { type: 'wait_for_response' }, 'basic-wait');
+        });
+        it('renders custom result name', async () => {
+            await helper.testNode({
+                uuid: 'test-wait-node-2',
+                actions: [],
+                router: {
+                    type: 'switch',
+                    wait: {
+                        type: 'msg',
+                        timeout: {
+                            category_uuid: 'timeout-cat-2',
+                            seconds: 1800
+                        }
+                    },
+                    result_name: 'user_input',
+                    categories: [
+                        {
+                            uuid: 'timeout-cat-2',
+                            name: 'No Response',
+                            exit_uuid: 'timeout-exit-2'
+                        }
+                    ]
                 },
-                result_name: 'user_input',
-                categories: [
-                    {
-                        uuid: 'timeout-cat-2',
-                        name: 'No Response',
-                        exit_uuid: 'timeout-exit-2'
-                    }
-                ]
-            },
-            exits: [{ uuid: 'timeout-exit-2', destination_uuid: null }]
-        }, { type: 'wait_for_response' }, 'custom-result-name');
-        helper.testNode({
-            uuid: 'test-wait-node-3',
-            actions: [],
-            router: {
-                type: 'switch',
-                wait: {
-                    type: 'msg',
-                    timeout: {
-                        category_uuid: 'timeout-cat-3',
-                        seconds: 60
-                    }
+                exits: [{ uuid: 'timeout-exit-2', destination_uuid: null }]
+            }, { type: 'wait_for_response' }, 'custom-result-name');
+        });
+        it('renders short timeout', async () => {
+            await helper.testNode({
+                uuid: 'test-wait-node-3',
+                actions: [],
+                router: {
+                    type: 'switch',
+                    wait: {
+                        type: 'msg',
+                        timeout: {
+                            category_uuid: 'timeout-cat-3',
+                            seconds: 60
+                        }
+                    },
+                    result_name: 'quick_response',
+                    categories: [
+                        {
+                            uuid: 'timeout-cat-3',
+                            name: 'No Response',
+                            exit_uuid: 'timeout-exit-3'
+                        }
+                    ]
                 },
-                result_name: 'quick_response',
-                categories: [
-                    {
-                        uuid: 'timeout-cat-3',
-                        name: 'No Response',
-                        exit_uuid: 'timeout-exit-3'
-                    }
-                ]
-            },
-            exits: [{ uuid: 'timeout-exit-3', destination_uuid: null }]
-        }, { type: 'wait_for_response' }, 'short-timeout');
-        helper.testNode({
-            uuid: 'test-wait-node-4',
-            actions: [],
-            router: {
-                type: 'switch',
-                wait: {
-                    type: 'msg'
-                    // No timeout specified
+                exits: [{ uuid: 'timeout-exit-3', destination_uuid: null }]
+            }, { type: 'wait_for_response' }, 'short-timeout');
+        });
+        it('renders no timeout', async () => {
+            await helper.testNode({
+                uuid: 'test-wait-node-4',
+                actions: [],
+                router: {
+                    type: 'switch',
+                    wait: {
+                        type: 'msg'
+                        // No timeout specified
+                    },
+                    result_name: 'response',
+                    categories: []
                 },
-                result_name: 'response',
-                categories: []
-            },
-            exits: []
-        }, { type: 'wait_for_response' }, 'no-timeout');
+                exits: []
+            }, { type: 'wait_for_response' }, 'no-timeout');
+        });
     });
     describe('data transformation', () => {
         it('converts node to form data correctly', () => {
@@ -126,12 +132,77 @@ describe('wait_for_response node config', () => {
             const formData = wait_for_response.toFormData(node);
             expect(formData.uuid).to.equal('test-node');
             expect(formData.result_name).to.equal('user_response');
+            expect(formData.rules).to.deep.equal([]);
+        });
+        it('converts node with rules to form data correctly', () => {
+            const node = {
+                uuid: 'test-node',
+                actions: [],
+                router: {
+                    type: 'switch',
+                    result_name: 'user_response',
+                    operand: '@input.text',
+                    categories: [
+                        {
+                            uuid: 'red-cat',
+                            name: 'Red',
+                            exit_uuid: 'red-exit'
+                        },
+                        {
+                            uuid: 'green-cat',
+                            name: 'Green',
+                            exit_uuid: 'green-exit'
+                        },
+                        {
+                            uuid: 'other-cat',
+                            name: 'Other',
+                            exit_uuid: 'other-exit'
+                        }
+                    ],
+                    cases: [
+                        {
+                            uuid: 'red-case',
+                            type: 'has_any_word',
+                            arguments: ['red'],
+                            category_uuid: 'red-cat'
+                        },
+                        {
+                            uuid: 'green-case',
+                            type: 'has_phrase',
+                            arguments: ['green'],
+                            category_uuid: 'green-cat'
+                        }
+                    ]
+                },
+                exits: [
+                    { uuid: 'red-exit', destination_uuid: null },
+                    { uuid: 'green-exit', destination_uuid: null },
+                    { uuid: 'other-exit', destination_uuid: null }
+                ]
+            };
+            const formData = wait_for_response.toFormData(node);
+            expect(formData.uuid).to.equal('test-node');
+            expect(formData.result_name).to.equal('user_response');
+            expect(formData.rules).to.have.length(2);
+            expect(formData.rules[0]).to.deep.equal({
+                operator: createOperatorOption('has_any_word'),
+                value1: 'red',
+                value2: '',
+                category: 'Red'
+            });
+            expect(formData.rules[1]).to.deep.equal({
+                operator: createOperatorOption('has_phrase'),
+                value1: 'green',
+                value2: '',
+                category: 'Green'
+            });
         });
         it('converts form data to node correctly', () => {
             var _a;
             const formData = {
                 uuid: 'test-node',
-                result_name: 'custom_response'
+                result_name: 'custom_response',
+                rules: []
             };
             const originalNode = {
                 uuid: 'test-node',
@@ -147,10 +218,59 @@ describe('wait_for_response node config', () => {
             expect(result.uuid).to.equal('test-node');
             expect((_a = result.router) === null || _a === void 0 ? void 0 : _a.result_name).to.equal('custom_response');
         });
+        it('converts form data with rules to node correctly', () => {
+            var _a, _b, _c, _d;
+            const formData = {
+                uuid: 'test-node',
+                result_name: 'custom_response',
+                rules: [
+                    {
+                        operator: 'has_any_word',
+                        value1: 'red',
+                        value2: '',
+                        category: 'Red'
+                    },
+                    {
+                        operator: 'has_phrase',
+                        value1: 'blue',
+                        value2: '',
+                        category: 'Blue'
+                    }
+                ]
+            };
+            const originalNode = {
+                uuid: 'test-node',
+                actions: [],
+                exits: [],
+                router: {
+                    type: 'switch',
+                    result_name: 'response',
+                    categories: []
+                }
+            };
+            const result = wait_for_response.fromFormData(formData, originalNode);
+            expect(result.uuid).to.equal('test-node');
+            expect((_a = result.router) === null || _a === void 0 ? void 0 : _a.result_name).to.equal('custom_response');
+            expect((_b = result.router) === null || _b === void 0 ? void 0 : _b.operand).to.equal('@input.text');
+            expect((_c = result.router) === null || _c === void 0 ? void 0 : _c.categories).to.have.length(3); // Red, Blue, Other
+            expect((_d = result.router) === null || _d === void 0 ? void 0 : _d.cases).to.have.length(2);
+            expect(result.exits).to.have.length(3);
+            // Check categories
+            const categoryNames = result.router.categories.map((cat) => cat.name);
+            expect(categoryNames).to.include.members(['Red', 'Blue', 'Other']);
+            // Check cases
+            const redCase = result.router.cases.find((c) => c.type === 'has_any_word');
+            expect(redCase).to.exist;
+            expect(redCase.arguments).to.deep.equal(['red']);
+            const blueCase = result.router.cases.find((c) => c.type === 'has_phrase');
+            expect(blueCase).to.exist;
+            expect(blueCase.arguments).to.deep.equal(['blue']);
+        });
         it('handles default result name', () => {
             var _a;
             const formData = {
-                uuid: 'test-node'
+                uuid: 'test-node',
+                rules: []
                 // No result_name specified
             };
             const originalNode = {
@@ -166,6 +286,350 @@ describe('wait_for_response node config', () => {
             expect(result.uuid).to.equal('test-node');
             expect((_a = result.router) === null || _a === void 0 ? void 0 : _a.result_name).to.equal('response');
         });
+        it('handles operators with no operands correctly', () => {
+            var _a, _b, _c;
+            const formData = {
+                uuid: 'test-node',
+                result_name: 'custom_response',
+                rules: [
+                    {
+                        operator: 'has_text',
+                        value: '', // No value needed for has_text
+                        category: 'Has Text'
+                    },
+                    {
+                        operator: 'has_number',
+                        value: '', // No value needed for has_number
+                        category: 'Has Number'
+                    }
+                ]
+            };
+            const originalNode = {
+                uuid: 'test-node',
+                actions: [],
+                exits: [],
+                router: {
+                    type: 'switch',
+                    result_name: 'response',
+                    categories: []
+                }
+            };
+            const result = wait_for_response.fromFormData(formData, originalNode);
+            expect(result.uuid).to.equal('test-node');
+            expect((_a = result.router) === null || _a === void 0 ? void 0 : _a.result_name).to.equal('custom_response');
+            expect((_b = result.router) === null || _b === void 0 ? void 0 : _b.categories).to.have.length(3); // Has Text, Has Number, Other
+            expect((_c = result.router) === null || _c === void 0 ? void 0 : _c.cases).to.have.length(2);
+            expect(result.exits).to.have.length(3);
+            // Check categories
+            const categoryNames = result.router.categories.map((cat) => cat.name);
+            expect(categoryNames).to.include.members([
+                'Has Text',
+                'Has Number',
+                'Other'
+            ]);
+            // Check cases - should have empty arguments for 0-operand operators
+            const hasTextCase = result.router.cases.find((c) => c.type === 'has_text');
+            expect(hasTextCase).to.exist;
+            expect(hasTextCase.arguments).to.deep.equal([]);
+            const hasNumberCase = result.router.cases.find((c) => c.type === 'has_number');
+            expect(hasNumberCase).to.exist;
+            expect(hasNumberCase.arguments).to.deep.equal([]);
+        });
+        it('preserves timeout categories when adding rules', () => {
+            var _a, _b, _c, _d, _e;
+            const formData = {
+                uuid: 'test-node',
+                result_name: 'response',
+                timeout_enabled: true,
+                timeout_duration: [{ value: '300', name: '5 minutes' }],
+                rules: [
+                    {
+                        operator: 'has_text',
+                        value: 'yes',
+                        category: 'Positive'
+                    }
+                ]
+            };
+            const originalNode = {
+                uuid: 'test-node',
+                actions: [],
+                router: {
+                    type: 'switch',
+                    wait: {
+                        type: 'msg',
+                        timeout: {
+                            category_uuid: 'timeout-cat',
+                            seconds: 300
+                        }
+                    },
+                    result_name: 'response',
+                    categories: [
+                        {
+                            uuid: 'timeout-cat',
+                            name: 'No Response',
+                            exit_uuid: 'timeout-exit'
+                        }
+                    ]
+                },
+                exits: [{ uuid: 'timeout-exit', destination_uuid: null }]
+            };
+            const result = wait_for_response.fromFormData(formData, originalNode);
+            expect((_a = result.router) === null || _a === void 0 ? void 0 : _a.categories).to.have.length(3); // Positive, No Response, Other
+            const categoryNames = result.router.categories.map((cat) => cat.name);
+            expect(categoryNames).to.include.members([
+                'Positive',
+                'No Response',
+                'Other'
+            ]);
+            // Verify timeout configuration is preserved
+            expect((_b = result.router) === null || _b === void 0 ? void 0 : _b.wait).to.exist;
+            expect((_e = (_d = (_c = result.router) === null || _c === void 0 ? void 0 : _c.wait) === null || _d === void 0 ? void 0 : _d.timeout) === null || _e === void 0 ? void 0 : _e.category_uuid).to.equal('timeout-cat');
+        });
+    });
+    describe('validation', () => {
+        it('validates form data correctly with no errors', () => {
+            const formData = {
+                rules: [
+                    { operator: 'has_text', value: 'yes', category: 'Positive' },
+                    { operator: 'has_text', value: 'no', category: 'Negative' }
+                ]
+            };
+            const validation = wait_for_response.validate(formData);
+            expect(validation.valid).to.be.true;
+            expect(validation.errors).to.be.empty;
+        });
+        it('allows same category names for multiple rules', () => {
+            const formData = {
+                rules: [
+                    { operator: 'has_text', value: 'yes', category: 'Positive' },
+                    { operator: 'has_text', value: 'ok', category: 'positive' }, // case insensitive same category
+                    { operator: 'has_text', value: 'no', category: 'Negative' }
+                ]
+            };
+            const validation = wait_for_response.validate(formData);
+            expect(validation.valid).to.be.true;
+            expect(validation.errors).to.be.empty;
+        });
+        it('allows rules with operators that need no values', () => {
+            const formData = {
+                rules: [
+                    { operator: 'has_text', value: '', category: 'Has Text' },
+                    { operator: 'has_number', value: '', category: 'Has Number' },
+                    { operator: 'has_any_word', value: 'hello', category: 'Greeting' }
+                ]
+            };
+            const validation = wait_for_response.validate(formData);
+            expect(validation.valid).to.be.true;
+            expect(validation.errors).to.be.empty;
+        });
+        it('ignores empty rules in validation', () => {
+            const formData = {
+                rules: [
+                    { operator: 'has_phrase', value: 'yes', category: 'Positive' },
+                    { operator: '', value: '', category: '' }, // empty rule
+                    { operator: 'has_phrase', value: 'no', category: 'Negative' }
+                ]
+            };
+            const validation = wait_for_response.validate(formData);
+            expect(validation.valid).to.be.true;
+            expect(validation.errors).to.be.empty;
+        });
+        it('preserves category UUIDs when names are updated', () => {
+            var _a;
+            // Create original node with specific UUIDs
+            const originalNode = {
+                uuid: 'test-node',
+                actions: [],
+                router: {
+                    type: 'switch',
+                    result_name: 'response',
+                    categories: [
+                        {
+                            uuid: 'category-1-uuid',
+                            name: 'Old Name 1',
+                            exit_uuid: 'exit-1-uuid'
+                        },
+                        {
+                            uuid: 'category-2-uuid',
+                            name: 'Old Name 2',
+                            exit_uuid: 'exit-2-uuid'
+                        },
+                        {
+                            uuid: 'other-category-uuid',
+                            name: 'Other',
+                            exit_uuid: 'other-exit-uuid'
+                        }
+                    ],
+                    cases: [
+                        {
+                            uuid: 'case-1-uuid',
+                            type: 'has_phrase',
+                            arguments: ['yes'],
+                            category_uuid: 'category-1-uuid'
+                        },
+                        {
+                            uuid: 'case-2-uuid',
+                            type: 'has_phrase',
+                            arguments: ['no'],
+                            category_uuid: 'category-2-uuid'
+                        }
+                    ]
+                },
+                exits: [
+                    { uuid: 'exit-1-uuid', destination_uuid: null },
+                    { uuid: 'exit-2-uuid', destination_uuid: null },
+                    { uuid: 'other-exit-uuid', destination_uuid: null }
+                ]
+            };
+            // Update category names but keep same rules in same order
+            const formData = {
+                uuid: 'test-node',
+                result_name: 'response',
+                rules: [
+                    {
+                        operator: { value: 'has_phrase', name: 'contains phrase' },
+                        value1: 'yes',
+                        category: 'New Name 1' // Changed from "Old Name 1"
+                    },
+                    {
+                        operator: { value: 'has_phrase', name: 'contains phrase' },
+                        value1: 'no',
+                        category: 'New Name 2' // Changed from "Old Name 2"
+                    }
+                ]
+            };
+            const result = wait_for_response.fromFormData(formData, originalNode);
+            // Verify that UUIDs are preserved despite name changes
+            expect((_a = result.router) === null || _a === void 0 ? void 0 : _a.categories).to.have.length(3); // Two rules + Other
+            const category1 = result.router.categories.find((cat) => cat.name === 'New Name 1');
+            const category2 = result.router.categories.find((cat) => cat.name === 'New Name 2');
+            const otherCategory = result.router.categories.find((cat) => cat.name === 'Other');
+            // Verify UUIDs are preserved
+            expect(category1 === null || category1 === void 0 ? void 0 : category1.uuid).to.equal('category-1-uuid');
+            expect(category1 === null || category1 === void 0 ? void 0 : category1.exit_uuid).to.equal('exit-1-uuid');
+            expect(category2 === null || category2 === void 0 ? void 0 : category2.uuid).to.equal('category-2-uuid');
+            expect(category2 === null || category2 === void 0 ? void 0 : category2.exit_uuid).to.equal('exit-2-uuid');
+            expect(otherCategory === null || otherCategory === void 0 ? void 0 : otherCategory.uuid).to.equal('other-category-uuid');
+            expect(otherCategory === null || otherCategory === void 0 ? void 0 : otherCategory.exit_uuid).to.equal('other-exit-uuid');
+            // Verify case UUIDs are also preserved
+            const case1 = result.router.cases.find((c) => c.category_uuid === 'category-1-uuid');
+            const case2 = result.router.cases.find((c) => c.category_uuid === 'category-2-uuid');
+            expect(case1 === null || case1 === void 0 ? void 0 : case1.uuid).to.equal('case-1-uuid');
+            expect(case2 === null || case2 === void 0 ? void 0 : case2.uuid).to.equal('case-2-uuid');
+            // Verify exits are preserved
+            expect(result.exits).to.have.length(3);
+            expect(result.exits.map((e) => e.uuid)).to.include.members([
+                'exit-1-uuid',
+                'exit-2-uuid',
+                'other-exit-uuid'
+            ]);
+        });
+        it('merges rules with same category name into single category', () => {
+            var _a, _b;
+            const formData = {
+                uuid: 'test-node',
+                result_name: 'response',
+                rules: [
+                    {
+                        operator: { value: 'has_phrase', name: 'contains phrase' },
+                        value1: 'yes',
+                        category: 'Positive'
+                    },
+                    {
+                        operator: { value: 'has_phrase', name: 'contains phrase' },
+                        value1: 'ok',
+                        category: 'Positive' // Same category name
+                    },
+                    {
+                        operator: { value: 'has_phrase', name: 'contains phrase' },
+                        value1: 'no',
+                        category: 'Negative'
+                    }
+                ]
+            };
+            const originalNode = {
+                uuid: 'test-node',
+                actions: [],
+                router: {
+                    type: 'switch',
+                    result_name: 'response',
+                    categories: [],
+                    cases: []
+                },
+                exits: []
+            };
+            const result = wait_for_response.fromFormData(formData, originalNode);
+            // Should have 3 categories: Positive, Negative, Other
+            expect((_a = result.router) === null || _a === void 0 ? void 0 : _a.categories).to.have.length(3);
+            const categoryNames = result.router.categories.map((cat) => cat.name);
+            expect(categoryNames).to.include.members([
+                'Positive',
+                'Negative',
+                'Other'
+            ]);
+            // Should have 3 cases but only 2 user categories (+ Other)
+            expect((_b = result.router) === null || _b === void 0 ? void 0 : _b.cases).to.have.length(3);
+            // Both "yes" and "ok" rules should reference the same Positive category
+            const positiveCategory = result.router.categories.find((cat) => cat.name === 'Positive');
+            expect(positiveCategory).to.exist;
+            const positiveCases = result.router.cases.filter((case_) => case_.category_uuid === positiveCategory.uuid);
+            expect(positiveCases).to.have.length(2);
+            // Verify the cases have the correct arguments
+            const yesCase = positiveCases.find((case_) => case_.arguments.includes('yes'));
+            const okCase = positiveCases.find((case_) => case_.arguments.includes('ok'));
+            expect(yesCase).to.exist;
+            expect(okCase).to.exist;
+            // Should have 3 exits: Positive, Negative, Other
+            expect(result.exits).to.have.length(3);
+        });
+        it('preserves category order when merging same category names', () => {
+            var _a;
+            const formData = {
+                uuid: 'test-node',
+                result_name: 'response',
+                rules: [
+                    {
+                        operator: { value: 'has_phrase', name: 'contains phrase' },
+                        value1: 'yes',
+                        category: 'First'
+                    },
+                    {
+                        operator: { value: 'has_phrase', name: 'contains phrase' },
+                        value1: 'maybe',
+                        category: 'Second'
+                    },
+                    {
+                        operator: { value: 'has_phrase', name: 'contains phrase' },
+                        value1: 'ok',
+                        category: 'First' // Same as first rule
+                    }
+                ]
+            };
+            const originalNode = {
+                uuid: 'test-node',
+                actions: [],
+                router: {
+                    type: 'switch',
+                    result_name: 'response',
+                    categories: [],
+                    cases: []
+                },
+                exits: []
+            };
+            const result = wait_for_response.fromFormData(formData, originalNode);
+            // Should have 3 categories: First, Second, Other (in that order)
+            expect((_a = result.router) === null || _a === void 0 ? void 0 : _a.categories).to.have.length(3);
+            const categoryNames = result.router.categories.map((cat) => cat.name);
+            expect(categoryNames).to.deep.equal(['First', 'Second', 'Other']);
+            // First category should have 2 cases (yes and ok)
+            const firstCategory = result.router.categories.find((cat) => cat.name === 'First');
+            const firstCases = result.router.cases.filter((case_) => case_.category_uuid === firstCategory.uuid);
+            expect(firstCases).to.have.length(2);
+            // Second category should have 1 case (maybe)
+            const secondCategory = result.router.categories.find((cat) => cat.name === 'Second');
+            const secondCases = result.router.cases.filter((case_) => case_.category_uuid === secondCategory.uuid);
+            expect(secondCases).to.have.length(1);
+        });
     });
 });
 //# sourceMappingURL=wait_for_response.test.js.map