@nyaruka/temba-components 0.156.8 → 0.156.10

package/src/flow/nodes/split_by_contact_field.ts

@@ -10,16 +10,14 @@ import {
   resultNameField,
   localizeRulesField,
   localizeCategoriesField,
-  nodeOptionsAccordion,
-  categoriesToLocalizationFormData,
-  localizationFormDataToCategories
+  nodeOptionsAccordion
 } from './shared';
 import {
   createRulesArrayConfig,
   extractUserRules,
   casesToFormRules
 } from './shared-rules';
-import { SCHEMES } from '../utils';
+import { SCHEMES, validateWith } from '../utils';
 import { html } from 'lit';
 
 // System contact properties that can be split on
@@ -89,18 +87,11 @@ export const split_by_contact_field: NodeConfig = {
     localizeCategories: localizeCategoriesField
   },
   layout: ['field', 'rules', nodeOptionsAccordion],
-  validate: (formData: FormData) => {
-    const errors: { [key: string]: string } = {};
-
+  validate: validateWith((formData, errors) => {
     if (!formData.field || formData.field.length === 0) {
       errors.field = 'A field is required';
     }
-
-    return {
-      valid: Object.keys(errors).length === 0,
-      errors
-    };
-  },
+  }),
   toFormData: (node: Node, nodeUI?: any) => {
     // Get the field from the UI config operand (source of truth)
     const operand = nodeUI?.config?.operand || CONTACT_PROPERTIES.name;
@@ -206,7 +197,9 @@ export const split_by_contact_field: NodeConfig = {
       }
     };
     config.localizeRules = !!formData.localizeRules;
-    config.localizeCategories = formData.result_name ? !!formData.localizeCategories : false;
+    config.localizeCategories = formData.result_name
+      ? !!formData.localizeCategories
+      : false;
     return config;
   },
   renderTitle: (node: Node, nodeUI?: any) => {
@@ -214,7 +207,5 @@ export const split_by_contact_field: NodeConfig = {
   },
 
   // Localization support for categories
-  localizable: 'categories',
-  toLocalizationFormData: categoriesToLocalizationFormData,
-  fromLocalizationFormData: localizationFormDataToCategories
+  localizable: 'categories'
 };

package/src/flow/nodes/split_by_expression.ts

@@ -10,15 +10,14 @@ import {
   resultNameField,
   localizeRulesField,
   localizeCategoriesField,
-  nodeOptionsAccordion,
-  categoriesToLocalizationFormData,
-  localizationFormDataToCategories
+  nodeOptionsAccordion
 } from './shared';
 import {
   createRulesArrayConfig,
   extractUserRules,
   casesToFormRules
 } from './shared-rules';
+import { validateWith } from '../utils';
 
 export const split_by_expression: NodeConfig = {
   type: 'split_by_expression',
@@ -44,19 +43,11 @@ export const split_by_expression: NodeConfig = {
     localizeCategories: localizeCategoriesField
   },
   layout: ['operand', 'rules', nodeOptionsAccordion],
-  validate: (formData: FormData) => {
-    const errors: { [key: string]: string } = {};
-
-    // Validate operand is provided
+  validate: validateWith((formData, errors) => {
     if (!formData.operand || formData.operand.trim() === '') {
       errors.operand = 'Expression is required';
     }
-
-    return {
-      valid: Object.keys(errors).length === 0,
-      errors
-    };
-  },
+  }),
   toFormData: (node: Node, nodeUI?: any) => {
     // Extract rules from router cases using shared function
     const rules = casesToFormRules(node);
@@ -73,7 +64,9 @@ export const split_by_expression: NodeConfig = {
   toUIConfig: (formData: FormData) => {
     const config: Record<string, any> = {};
     config.localizeRules = !!formData.localizeRules;
-    config.localizeCategories = formData.result_name ? !!formData.localizeCategories : false;
+    config.localizeCategories = formData.result_name
+      ? !!formData.localizeCategories
+      : false;
     return config;
   },
   fromFormData: (formData: FormData, originalNode: Node): Node => {
@@ -116,7 +109,5 @@ export const split_by_expression: NodeConfig = {
   },
 
   // Localization support for categories
-  localizable: 'categories',
-  toLocalizationFormData: categoriesToLocalizationFormData,
-  fromLocalizationFormData: localizationFormDataToCategories
+  localizable: 'categories'
 };

package/src/flow/nodes/split_by_groups.ts

@@ -1,100 +1,14 @@
 import { SPLIT_GROUPS, FormData, NodeConfig, FlowTypes } from '../types';
-import { Node, Category, Exit, Case } from '../../store/flow-definition.d';
+import { Node, Case } from '../../store/flow-definition.d';
 import { generateUUID } from '../../utils';
+import { validateWith } from '../utils';
 import {
   resultNameField,
   nodeOptionsAccordionSimple,
-  categoriesToLocalizationFormData,
-  localizationFormDataToCategories
+  buildCategoriesExitsCases,
+  appendOtherCategory
 } from './shared';
 
-// Helper function to create a switch router with group cases
-const createGroupRouter = (
-  userGroups: { uuid: string; name: string }[],
-  existingCategories: Category[] = [],
-  existingExits: Exit[] = [],
-  existingCases: Case[] = [],
-  resultName: string = ''
-) => {
-  const categories: Category[] = [];
-  const exits: Exit[] = [];
-  const cases: Case[] = [];
-
-  // Create categories, exits, and cases for each selected group
-  userGroups.forEach((group) => {
-    // Try to find existing category by group name
-    const existingCategory = existingCategories.find(
-      (cat) => cat.name === group.name
-    );
-    const existingExit = existingCategory
-      ? existingExits.find((exit) => exit.uuid === existingCategory.exit_uuid)
-      : null;
-    const existingCase = existingCases.find(
-      (c) => c.arguments?.[0] === group.uuid
-    );
-
-    const exitUuid = existingExit?.uuid || generateUUID();
-    const categoryUuid = existingCategory?.uuid || generateUUID();
-    const caseUuid = existingCase?.uuid || generateUUID();
-
-    categories.push({
-      uuid: categoryUuid,
-      name: group.name,
-      exit_uuid: exitUuid
-    });
-
-    exits.push({
-      uuid: exitUuid,
-      destination_uuid: existingExit?.destination_uuid || null
-    });
-
-    cases.push({
-      uuid: caseUuid,
-      type: 'has_group',
-      arguments: [group.uuid, group.name],
-      category_uuid: categoryUuid
-    });
-  });
-
-  // Add default "Other" category for contacts not in any selected group
-  const existingOtherCategory = existingCategories.find(
-    (cat) =>
-      cat.name === 'Other' &&
-      !userGroups.some((group) => group.name === cat.name)
-  );
-  const existingOtherExit = existingOtherCategory
-    ? existingExits.find(
-        (exit) => exit.uuid === existingOtherCategory.exit_uuid
-      )
-    : null;
-
-  const otherExitUuid = existingOtherExit?.uuid || generateUUID();
-  const otherCategoryUuid = existingOtherCategory?.uuid || generateUUID();
-
-  categories.push({
-    uuid: otherCategoryUuid,
-    name: 'Other',
-    exit_uuid: otherExitUuid
-  });
-
-  exits.push({
-    uuid: otherExitUuid,
-    destination_uuid: existingOtherExit?.destination_uuid || null
-  });
-
-  return {
-    router: {
-      type: 'switch' as const,
-      cases: cases,
-      categories: categories,
-      default_category_uuid: otherCategoryUuid,
-      operand: '@contact.groups',
-      result_name: resultName
-    },
-    exits: exits
-  };
-};
-
 export const split_by_groups: NodeConfig = {
   type: 'split_by_groups',
   name: 'Split by Group',
@@ -133,9 +47,7 @@ export const split_by_groups: NodeConfig = {
     result_name: resultNameField
   },
   layout: ['groups', nodeOptionsAccordionSimple],
-  validate: (formData: FormData) => {
-    const errors: { [key: string]: string } = {};
-
+  validate: validateWith((formData, errors) => {
     if (
       !formData.groups ||
       !Array.isArray(formData.groups) ||
@@ -143,12 +55,7 @@ export const split_by_groups: NodeConfig = {
     ) {
       errors.groups = 'At least one group is required';
     }
-
-    return {
-      valid: Object.keys(errors).length === 0,
-      errors
-    };
-  },
+  }),
   toFormData: (node: Node) => {
     // Extract groups from the existing node structure
     const groups: { uuid: string; name: string }[] = [];
@@ -171,33 +78,50 @@ export const split_by_groups: NodeConfig = {
     };
   },
   fromFormData: (formData: FormData, originalNode: Node): Node => {
-    // Get selected groups
     const selectedGroups = (formData.groups || [])
       .filter((group: any) => group?.uuid || group?.arbitrary)
       .map((group: any) => ({
-        uuid: group.uuid || generateUUID(), // Generate UUID for arbitrary groups
+        uuid: group.uuid || generateUUID(),
         name: group.name
       }));
 
-    // Create router and exits using existing data when possible
     const existingCategories = originalNode.router?.categories || [];
     const existingExits = originalNode.exits || [];
     const existingCases = originalNode.router?.cases || [];
 
-    const { router, exits } = createGroupRouter(
-      selectedGroups,
+    const { categories, exits, cases } = buildCategoriesExitsCases(
+      selectedGroups.map((group) => ({
+        name: group.name,
+        case: {
+          type: 'has_group',
+          arguments: [group.uuid, group.name]
+        }
+      })),
+      existingCategories,
+      existingExits,
+      existingCases
+    );
+
+    const defaultCategoryUuid = appendOtherCategory(
+      categories,
+      exits,
       existingCategories,
       existingExits,
-      existingCases,
-      formData.result_name || ''
+      selectedGroups.map((g) => g.name)
     );
 
-    // Return the complete node
     return {
       uuid: originalNode.uuid,
       actions: originalNode.actions || [],
-      router: router,
-      exits: exits
+      router: {
+        type: 'switch',
+        cases,
+        categories,
+        default_category_uuid: defaultCategoryUuid,
+        operand: '@contact.groups',
+        result_name: formData.result_name || ''
+      },
+      exits
     };
   },
   router: {
@@ -206,7 +130,5 @@ export const split_by_groups: NodeConfig = {
   },
 
   // Localization support for categories
-  localizable: 'categories',
-  toLocalizationFormData: categoriesToLocalizationFormData,
-  fromLocalizationFormData: localizationFormDataToCategories
+  localizable: 'categories'
 };

package/src/flow/nodes/split_by_llm.ts

@@ -2,10 +2,6 @@ import { ACTION_GROUPS, FormData, NodeConfig, FlowTypes } from '../types';
 import { CallLLM, Node } from '../../store/flow-definition';
 import { generateUUID, createSuccessFailureRouter } from '../../utils';
 import { html } from 'lit';
-import {
-  categoriesToLocalizationFormData,
-  localizationFormDataToCategories
-} from './shared';
 import {
   renderClamped,
   renderHighlightedText,
@@ -141,7 +137,5 @@ export const split_by_llm: NodeConfig = {
 
   // Localization support for categories
   localizable: 'categories',
-  nonTranslatableCategories: 'all',
-  toLocalizationFormData: categoriesToLocalizationFormData,
-  fromLocalizationFormData: localizationFormDataToCategories
+  nonTranslatableCategories: 'all'
 };

package/src/flow/nodes/split_by_llm_categorize.ts

@@ -2,10 +2,7 @@ import { FormData, NodeConfig, ACTION_GROUPS, Features } from '../types';
 import { CallLLM, Node } from '../../store/flow-definition';
 import { generateUUID, createMultiCategoryRouter } from '../../utils';
 import { html } from 'lit';
-import {
-  categoriesToLocalizationFormData,
-  localizationFormDataToCategories
-} from './shared';
+import { validateWith } from '../utils';
 
 export const split_by_llm_categorize: NodeConfig = {
   type: 'split_by_llm_categorize',
@@ -53,48 +50,37 @@ export const split_by_llm_categorize: NodeConfig = {
     }
   },
   layout: ['llm', 'input', 'categories'],
-  validate: (formData: FormData) => {
-    const errors: { [key: string]: string } = {};
+  validate: validateWith((formData, errors) => {
+    if (!formData.categories || !Array.isArray(formData.categories)) return;
 
-    // Check for duplicate category names
-    if (formData.categories && Array.isArray(formData.categories)) {
-      const categories = formData.categories.filter(
-        (item: any) => item?.name && item.name.trim() !== ''
-      );
-
-      // Find all categories that have duplicates (case-insensitive)
-      const duplicateCategories = [];
-      const lowerCaseMap = new Map();
+    const categories = formData.categories.filter(
+      (item: any) => item?.name && item.name.trim() !== ''
+    );
 
-      // First pass: map lowercase names to all original cases
-      categories.forEach((category) => {
-        const lowerName = category.name.trim().toLowerCase();
-        if (!lowerCaseMap.has(lowerName)) {
-          lowerCaseMap.set(lowerName, []);
-        }
-        lowerCaseMap.get(lowerName).push(category.name.trim());
-      });
+    const duplicateCategories: string[] = [];
+    const lowerCaseMap = new Map<string, string[]>();
 
-      // Second pass: collect all names that appear more than once
-      lowerCaseMap.forEach((originalNames) => {
-        if (originalNames.length > 1) {
-          duplicateCategories.push(...originalNames);
-        }
-      });
+    categories.forEach((category) => {
+      const lowerName = category.name.trim().toLowerCase();
+      if (!lowerCaseMap.has(lowerName)) {
+        lowerCaseMap.set(lowerName, []);
+      }
+      lowerCaseMap.get(lowerName).push(category.name.trim());
+    });
 
-      if (duplicateCategories.length > 0) {
-        const uniqueDuplicates = [...new Set(duplicateCategories)];
-        errors.categories = `Duplicate category names found: ${uniqueDuplicates.join(
-          ', '
-        )}`;
+    lowerCaseMap.forEach((originalNames) => {
+      if (originalNames.length > 1) {
+        duplicateCategories.push(...originalNames);
       }
-    }
+    });
 
-    return {
-      valid: Object.keys(errors).length === 0,
-      errors
-    };
-  },
+    if (duplicateCategories.length > 0) {
+      const uniqueDuplicates = [...new Set(duplicateCategories)];
+      errors.categories = `Duplicate category names found: ${uniqueDuplicates.join(
+        ', '
+      )}`;
+    }
+  }),
   render: (node: Node) => {
     const callLlmAction = node.actions?.find(
       (action) => action.type === 'call_llm'
@@ -181,7 +167,5 @@ export const split_by_llm_categorize: NodeConfig = {
 
   // Localization support for categories
   localizable: 'categories',
-  nonTranslatableCategories: ['Failure'],
-  toLocalizationFormData: categoriesToLocalizationFormData,
-  fromLocalizationFormData: localizationFormDataToCategories
+  nonTranslatableCategories: ['Failure']
 };

package/src/flow/nodes/split_by_random.ts

@@ -1,53 +1,7 @@
 import { SPLIT_GROUPS, FormData, NodeConfig, FlowTypes } from '../types';
-import { Node, Category, Exit } from '../../store/flow-definition.d';
-import { generateUUID } from '../../utils';
-import {
-  categoriesToLocalizationFormData,
-  localizationFormDataToCategories
-} from './shared';
-
-// Helper function to create a random router with categories
-const createRandomRouter = (
-  userCategories: string[],
-  existingCategories: Category[] = [],
-  existingExits: Exit[] = []
-) => {
-  const categories: Category[] = [];
-  const exits: Exit[] = [];
-
-  // Create categories and exits for user-defined buckets
-  userCategories.forEach((categoryName) => {
-    // Try to find existing category by name
-    const existingCategory = existingCategories.find(
-      (cat) => cat.name === categoryName
-    );
-    const existingExit = existingCategory
-      ? existingExits.find((exit) => exit.uuid === existingCategory.exit_uuid)
-      : null;
-
-    const exitUuid = existingExit?.uuid || generateUUID();
-    const categoryUuid = existingCategory?.uuid || generateUUID();
-
-    categories.push({
-      uuid: categoryUuid,
-      name: categoryName,
-      exit_uuid: exitUuid
-    });
-
-    exits.push({
-      uuid: exitUuid,
-      destination_uuid: existingExit?.destination_uuid || null
-    });
-  });
-
-  return {
-    router: {
-      type: 'random' as const,
-      categories: categories
-    },
-    exits: exits
-  };
-};
+import { Node } from '../../store/flow-definition.d';
+import { validateWith } from '../utils';
+import { buildCategoriesExitsCases } from './shared';
 
 export const split_by_random: NodeConfig = {
   type: 'split_by_random',
@@ -76,53 +30,41 @@ export const split_by_random: NodeConfig = {
     }
   },
   layout: ['categories'],
-  validate: (formData: FormData) => {
-    const errors: { [key: string]: string } = {};
-
-    // Check for duplicate category names
-    if (formData.categories && Array.isArray(formData.categories)) {
-      const categories = formData.categories.filter(
-        (item: any) => item?.name && item.name.trim() !== ''
-      );
+  validate: validateWith((formData, errors) => {
+    if (!formData.categories || !Array.isArray(formData.categories)) return;
 
-      // Ensure minimum buckets
-      if (categories.length < 2) {
-        errors.categories = 'At least 2 buckets are required for random split';
-      }
+    const categories = formData.categories.filter(
+      (item: any) => item?.name && item.name.trim() !== ''
+    );
 
-      // Find all categories that have duplicates (case-insensitive)
-      const duplicateCategories = [];
-      const lowerCaseMap = new Map();
+    if (categories.length < 2) {
+      errors.categories = 'At least 2 buckets are required for random split';
+    }
 
-      // First pass: map lowercase names to all original cases
-      categories.forEach((category) => {
-        const lowerName = category.name.trim().toLowerCase();
-        if (!lowerCaseMap.has(lowerName)) {
-          lowerCaseMap.set(lowerName, []);
-        }
-        lowerCaseMap.get(lowerName).push(category.name.trim());
-      });
+    const duplicateCategories: string[] = [];
+    const lowerCaseMap = new Map<string, string[]>();
 
-      // Second pass: collect all names that appear more than once
-      lowerCaseMap.forEach((originalNames) => {
-        if (originalNames.length > 1) {
-          duplicateCategories.push(...originalNames);
-        }
-      });
+    categories.forEach((category) => {
+      const lowerName = category.name.trim().toLowerCase();
+      if (!lowerCaseMap.has(lowerName)) {
+        lowerCaseMap.set(lowerName, []);
+      }
+      lowerCaseMap.get(lowerName).push(category.name.trim());
+    });
 
-      if (duplicateCategories.length > 0) {
-        const uniqueDuplicates = [...new Set(duplicateCategories)];
-        errors.categories = `Duplicate bucket names found: ${uniqueDuplicates.join(
-          ', '
-        )}`;
+    lowerCaseMap.forEach((originalNames) => {
+      if (originalNames.length > 1) {
+        duplicateCategories.push(...originalNames);
       }
-    }
+    });
 
-    return {
-      valid: Object.keys(errors).length === 0,
-      errors
-    };
-  },
+    if (duplicateCategories.length > 0) {
+      const uniqueDuplicates = [...new Set(duplicateCategories)];
+      errors.categories = `Duplicate bucket names found: ${uniqueDuplicates.join(
+        ', '
+      )}`;
+    }
+  }),
   toFormData: (node: Node) => {
     // Extract categories from the existing node structure
     const categories =
@@ -134,27 +76,27 @@ export const split_by_random: NodeConfig = {
     };
   },
   fromFormData: (formData: FormData, originalNode: Node): Node => {
-    // Get user categories
     const userCategories = (formData.categories || [])
       .filter((item: any) => item?.name?.trim())
       .map((item: any) => item.name.trim());
 
-    // Create router and exits using existing data when possible
     const existingCategories = originalNode.router?.categories || [];
     const existingExits = originalNode.exits || [];
 
-    const { router, exits } = createRandomRouter(
-      userCategories,
+    const { categories, exits } = buildCategoriesExitsCases(
+      userCategories.map((name) => ({ name })),
       existingCategories,
       existingExits
     );
 
-    // Return the complete node
     return {
       uuid: originalNode.uuid,
       actions: originalNode.actions || [],
-      router: router,
-      exits: exits
+      router: {
+        type: 'random',
+        categories
+      },
+      exits
     };
   },
   router: {
@@ -162,7 +104,5 @@ export const split_by_random: NodeConfig = {
   },
 
   // Localization support for categories
-  localizable: 'categories',
-  toLocalizationFormData: categoriesToLocalizationFormData,
-  fromLocalizationFormData: localizationFormDataToCategories
+  localizable: 'categories'
 };

package/src/flow/nodes/split_by_resthook.ts

@@ -2,12 +2,8 @@ import { ACTION_GROUPS, FormData, NodeConfig, FlowTypes } from '../types';
 import { CallResthook, Node } from '../../store/flow-definition';
 import { generateUUID, createSuccessFailureRouter } from '../../utils';
 import { html } from 'lit';
-import {
-  resultNameField,
-  categoriesToLocalizationFormData,
-  localizationFormDataToCategories
-} from './shared';
-import { renderClamped } from '../utils';
+import { resultNameField } from './shared';
+import { renderClamped, validateWith } from '../utils';
 
 export const split_by_resthook: NodeConfig = {
   type: 'split_by_resthook',
@@ -31,19 +27,11 @@ export const split_by_resthook: NodeConfig = {
     result_name: resultNameField
   },
   layout: ['resthook', 'result_name'],
-  validate: (formData: FormData) => {
-    const errors: { [key: string]: string } = {};
-
-    // validate resthook is provided
+  validate: validateWith((formData, errors) => {
     if (!formData.resthook || formData.resthook.length === 0) {
       errors.resthook = 'A resthook is required';
     }
-
-    return {
-      valid: Object.keys(errors).length === 0,
-      errors
-    };
-  },
+  }),
   render: (node: Node) => {
     const callResthookAction = node.actions?.find(
       (action) => action.type === 'call_resthook'
@@ -130,7 +118,5 @@ export const split_by_resthook: NodeConfig = {
 
   // Localization support for categories
   localizable: 'categories',
-  nonTranslatableCategories: 'all',
-  toLocalizationFormData: categoriesToLocalizationFormData,
-  fromLocalizationFormData: localizationFormDataToCategories
+  nonTranslatableCategories: 'all'
 };