@botonic/plugin-flow-builder 0.50.2 → 0.51.0

package/src/content-fields/custom-conditional/custom-conditional-v2-evaluators.ts

@@ -0,0 +1,124 @@
+import {
+  BooleanConditionOperator,
+  type HtBooleanCondition,
+  type HtNumberCondition,
+  type HtStringCondition,
+  NumberConditionOperator,
+  StringConditionOperator,
+} from '../hubtype-fields'
+
+type StringEvaluator = (variable: string, value: string) => boolean
+
+type NumberEvaluator = (
+  variable: number,
+  value: number,
+  condition: HtNumberCondition
+) => boolean
+
+type BooleanEvaluator = (variable: boolean) => boolean
+
+export function getMinAndMax(condition: HtNumberCondition): {
+  min: number
+  max: number
+} {
+  if (condition.min !== undefined && condition.max !== undefined) {
+    return { min: condition.min, max: condition.max }
+  }
+  throw new Error(
+    `Min or max not found for number condition ${condition.operator}`
+  )
+}
+
+export const STRING_CONDITION_EVALUATORS: Record<
+  StringConditionOperator,
+  StringEvaluator
+> = {
+  [StringConditionOperator.Contains]: (variable, value) =>
+    variable.includes(value),
+  [StringConditionOperator.NotContains]: (variable, value) =>
+    !variable.includes(value),
+  [StringConditionOperator.EqualsTo]: (variable, value) => variable === value,
+  [StringConditionOperator.NotEqualsTo]: (variable, value) =>
+    variable !== value,
+  [StringConditionOperator.StartsWith]: (variable, value) =>
+    variable.startsWith(value),
+  [StringConditionOperator.NotStartsWith]: (variable, value) =>
+    !variable.startsWith(value),
+  [StringConditionOperator.EndsWith]: (variable, value) =>
+    variable.endsWith(value),
+  [StringConditionOperator.NotEndsWith]: (variable, value) =>
+    !variable.endsWith(value),
+}
+
+export const NUMBER_CONDITION_EVALUATORS: Record<
+  NumberConditionOperator,
+  NumberEvaluator
+> = {
+  [NumberConditionOperator.EqualsTo]: (variable, value) => variable === value,
+  [NumberConditionOperator.NotEqualsTo]: (variable, value) =>
+    variable !== value,
+  [NumberConditionOperator.GreaterThan]: (variable, value) => variable > value,
+  [NumberConditionOperator.LessThan]: (variable, value) => variable < value,
+  [NumberConditionOperator.GreaterThanOrEqualTo]: (variable, value) =>
+    variable >= value,
+  [NumberConditionOperator.LessThanOrEqualTo]: (variable, value) =>
+    variable <= value,
+  [NumberConditionOperator.Between]: (variable, _value, condition) => {
+    const { min, max } = getMinAndMax(condition)
+    return variable >= min && variable <= max
+  },
+  [NumberConditionOperator.NotBetween]: (variable, _value, condition) => {
+    const { min, max } = getMinAndMax(condition)
+    return variable < min || variable > max
+  },
+}
+
+export const BOOLEAN_CONDITION_EVALUATORS: Record<
+  BooleanConditionOperator,
+  BooleanEvaluator
+> = {
+  [BooleanConditionOperator.IsTruthy]: variable => !!variable,
+}
+
+export function evaluateStringCondition(
+  variable: string,
+  condition: HtStringCondition
+): boolean {
+  if (condition.value === undefined) {
+    throw new Error(
+      `Value not found for string condition ${condition.operator}`
+    )
+  }
+  const evaluator = STRING_CONDITION_EVALUATORS[condition.operator]
+  if (!evaluator) {
+    throw new Error(`Invalid string condition operator ${condition.operator}`)
+  }
+  return evaluator(variable, condition.value)
+}
+
+export function evaluateNumberCondition(
+  variable: number,
+  condition: HtNumberCondition
+): boolean {
+  if (condition.value === undefined) {
+    throw new Error(
+      `Value not found for number condition ${condition.operator}`
+    )
+  }
+  const evaluator = NUMBER_CONDITION_EVALUATORS[condition.operator]
+  if (!evaluator) {
+    throw new Error(`Invalid number condition operator ${condition.operator}`)
+  }
+  return evaluator(variable, condition.value, condition)
+}
+
+export function evaluateBooleanCondition(
+  variable: boolean,
+  condition: HtBooleanCondition
+): boolean {
+  const evaluator = BOOLEAN_CONDITION_EVALUATORS[condition.operator]
+  if (!evaluator) {
+    throw new Error(`Invalid boolean condition operator ${condition.operator}`)
+  }
+  return evaluator(variable)
+}

package/src/content-fields/custom-conditional/custom-conditional-v2-resolver.ts

@@ -0,0 +1,92 @@
+import {
+  type HtCondition,
+  type HtNodeLink,
+  type HtNumberCondition,
+  type HtStringCondition,
+  NumberConditionOperator,
+  VariableFormat,
+} from '../hubtype-fields'
+
+export type ConditionMatch = {
+  customResult: string
+  target: HtNodeLink
+  operator: string
+}
+
+export function getConditionCustomResult(
+  condition: HtCondition,
+  variableFormat: VariableFormat
+): string {
+  switch (variableFormat) {
+    case VariableFormat.String:
+      return String((condition as HtStringCondition).value)
+    case VariableFormat.Number:
+      return getNumberConditionCustomResult(condition as HtNumberCondition)
+    case VariableFormat.Boolean:
+      // Only reached after evaluateBooleanCondition succeeds; today that is isTruthy → 'true'
+      return 'true'
+    default:
+      throw new Error(`Invalid variable format ${variableFormat}`)
+  }
+}
+
+function getNumberConditionCustomResult(condition: HtNumberCondition): string {
+  const numberCondition = condition as HtNumberCondition
+  if (
+    numberCondition.operator === NumberConditionOperator.Between ||
+    numberCondition.operator === NumberConditionOperator.NotBetween
+  ) {
+    return `min: ${numberCondition.min} - max: ${numberCondition.max}`
+  }
+  return String(numberCondition.value)
+}
+
+export function findLastMatchingCondition<T extends HtCondition>(
+  conditions: T[],
+  variable: unknown,
+  variableFormat: VariableFormat,
+  evaluate: (variable: unknown, condition: T) => boolean
+): ConditionMatch | undefined {
+  let lastMatch: ConditionMatch | undefined
+
+  for (const condition of conditions) {
+    if (!evaluate(variable, condition)) {
+      continue
+    }
+
+    if (!condition.target) {
+      continue
+    }
+
+    lastMatch = {
+      customResult: getConditionCustomResult(condition, variableFormat),
+      target: condition.target,
+      operator: condition.operator,
+    }
+  }
+
+  return lastMatch
+}
+
+export function resolveWithDefaultTarget(
+  match: ConditionMatch | undefined,
+  defaultTarget: HtNodeLink,
+  nodeCode: string,
+  defaultCustomResult: string = 'default'
+): ConditionMatch {
+  if (match) {
+    return match
+  }
+
+  if (!defaultTarget) {
+    throw new Error(
+      `Default target not found for custom condition node ${nodeCode}`
+    )
+  }
+
+  return {
+    customResult: defaultCustomResult,
+    target: defaultTarget,
+    operator: '',
+  }
+}

package/src/content-fields/custom-conditional/flow-custom-condition-v2.tsx

@@ -0,0 +1,136 @@
+import {
+  type BotContext,
+  EventAction,
+  type EventConditionalCustom,
+} from '@botonic/core'
+import {
+  getCommonFlowContentEventArgsForContentId,
+  trackEvent,
+} from '../../tracking'
+import { ContentFieldsBase } from '../content-fields-base'
+import {
+  type HtBooleanCondition,
+  type HtCondition,
+  type HtCustomConditionalV2Node,
+  type HtNodeLink,
+  type HtNumberCondition,
+  type HtStringCondition,
+  VariableFormat,
+} from '../hubtype-fields'
+import {
+  evaluateBooleanCondition,
+  evaluateNumberCondition,
+  evaluateStringCondition,
+} from './custom-conditional-v2-evaluators'
+import {
+  type ConditionMatch,
+  findLastMatchingCondition,
+  resolveWithDefaultTarget,
+} from './custom-conditional-v2-resolver'
+
+export class FlowCustomConditionalV2 extends ContentFieldsBase {
+  public variableFormat: VariableFormat
+  public keyPath: string
+  public conditions: HtCondition[]
+  public defaultTarget: HtNodeLink
+  public customResult = ''
+  public resolvedOperator = ''
+
+  static fromHubtypeCMS(
+    component: HtCustomConditionalV2Node,
+    botContext: BotContext
+  ): FlowCustomConditionalV2 {
+    const newCustomConditionalV2 = new FlowCustomConditionalV2(component.id)
+    newCustomConditionalV2.code = component.code
+    newCustomConditionalV2.variableFormat = component.content.type
+    newCustomConditionalV2.keyPath = component.content.key_path
+    newCustomConditionalV2.conditions = component.content.conditions
+    newCustomConditionalV2.defaultTarget = component.content.default_target
+    newCustomConditionalV2.setFollowUp(botContext)
+
+    return newCustomConditionalV2
+  }
+
+  private setFollowUp(botContext: BotContext): void {
+    const botVariable = this.getValueFromKeyPath(botContext, this.keyPath)
+    const resolved = this.evaluateConditions(botVariable)
+
+    this.customResult = resolved.customResult
+    this.resolvedOperator = resolved.operator
+    this.followUp = resolved.target
+  }
+
+  private evaluateConditions(botVariable: unknown): ConditionMatch {
+    switch (this.variableFormat) {
+      case VariableFormat.String: {
+        const match = findLastMatchingCondition(
+          this.conditions as HtStringCondition[],
+          botVariable,
+          this.variableFormat,
+          (variable, condition) =>
+            evaluateStringCondition(variable as string, condition)
+        )
+        return resolveWithDefaultTarget(match, this.defaultTarget, this.code)
+      }
+      case VariableFormat.Number: {
+        const match = findLastMatchingCondition(
+          this.conditions as HtNumberCondition[],
+          botVariable,
+          this.variableFormat,
+          (variable, condition) =>
+            evaluateNumberCondition(variable as number, condition)
+        )
+        return resolveWithDefaultTarget(match, this.defaultTarget, this.code)
+      }
+      case VariableFormat.Boolean: {
+        const match = findLastMatchingCondition(
+          this.conditions as HtBooleanCondition[],
+          botVariable,
+          this.variableFormat,
+          (variable, condition) =>
+            evaluateBooleanCondition(variable as boolean, condition)
+        )
+        return resolveWithDefaultTarget(
+          match,
+          this.defaultTarget,
+          this.code,
+          'false'
+        )
+      }
+      default:
+        throw new Error(
+          `Invalid variable format ${this.variableFormat} for custom condition node ${this.code}`
+        )
+    }
+  }
+
+  async trackFlow(botContext: BotContext): Promise<void> {
+    const { flowThreadId, flowId, flowName, flowNodeId, flowNodeContentId } =
+      getCommonFlowContentEventArgsForContentId(botContext, this.id)
+
+    const eventCustomConditional: EventConditionalCustom = {
+      action: EventAction.ConditionalCustom,
+      flowThreadId,
+      flowId,
+      flowName,
+      flowNodeId,
+      flowNodeContentId,
+      flowNodeIsMeaningful: false,
+      conditionalVariable: this.customResult,
+      variableFormat: this.variableFormat,
+      operator: this.resolvedOperator,
+    }
+    const { action, ...eventArgs } = eventCustomConditional
+    await trackEvent(botContext, action, eventArgs)
+  }
+
+  async processContent(botContext: BotContext): Promise<void> {
+    await this.filterContent(botContext, this)
+    await this.trackFlow(botContext)
+    return
+  }
+
+  toBotonic() {
+    return <></>
+  }
+}

package/src/content-fields/flow-custom-conditional.tsx

@@ -101,6 +101,7 @@ export class FlowCustomConditional extends ContentFieldsBase {
       flowNodeIsMeaningful: false,
       conditionalVariable: this.customResult.toString(),
       variableFormat: this.variableFormat,
+      operator: '',
     }
     const { action, ...eventArgs } = eventCustomConditional
     await trackEvent(botContext, action, eventArgs)

package/src/content-fields/hubtype-fields/custom-conditional-v2.ts

@@ -0,0 +1,68 @@
+import type { HtBaseNode, HtNodeLink } from './common'
+import type { HtNodeWithContentType } from './node-types'
+
+export enum VariableFormat {
+  Boolean = 'boolean',
+  Number = 'number',
+  String = 'string',
+}
+
+export enum StringConditionOperator {
+  Contains = 'contains',
+  NotContains = 'notContains',
+  EqualsTo = 'equalsTo',
+  NotEqualsTo = 'notEqualsTo',
+  StartsWith = 'startsWith',
+  NotStartsWith = 'notStartsWith',
+  EndsWith = 'endsWith',
+  NotEndsWith = 'notEndsWith',
+}
+
+export interface HtStringCondition {
+  operator: StringConditionOperator
+  value?: string
+  target?: HtNodeLink
+}
+
+export enum NumberConditionOperator {
+  EqualsTo = 'equalsTo',
+  NotEqualsTo = 'notEqualsTo',
+  GreaterThan = 'greaterThan',
+  LessThan = 'lessThan',
+  GreaterThanOrEqualTo = 'greaterThanOrEqualTo',
+  LessThanOrEqualTo = 'lessThanOrEqualTo',
+  Between = 'between',
+  NotBetween = 'notBetween',
+}
+
+export interface HtNumberCondition {
+  operator: NumberConditionOperator
+  value?: number
+  min?: number
+  max?: number
+  target?: HtNodeLink
+}
+
+export enum BooleanConditionOperator {
+  IsTruthy = 'isTruthy',
+}
+
+export interface HtBooleanCondition {
+  operator: BooleanConditionOperator
+  target?: HtNodeLink
+}
+
+export type HtCondition =
+  | HtStringCondition
+  | HtNumberCondition
+  | HtBooleanCondition
+
+export interface HtCustomConditionalV2Node extends HtBaseNode {
+  type: HtNodeWithContentType.CUSTOM_CONDITION
+  content: {
+    type: VariableFormat
+    key_path: string
+    conditions: HtCondition[]
+    default_target: HtNodeLink
+  }
+}

package/src/content-fields/hubtype-fields/index.ts

@@ -5,6 +5,7 @@ export * from './button'
 export * from './capture-user-input'
 export * from './carousel'
 export * from './common'
+export * from './custom-conditional-v2'
 export * from './fallback'
 export * from './function'
 export * from './go-to-flow'

package/src/content-fields/hubtype-fields/node-types.ts

@@ -19,6 +19,7 @@ export enum HtNodeWithContentType {
   WEBVIEW = 'webview',
   GO_TO_FLOW = 'go-to-flow',
   CAPTURE_USER_INPUT = 'capture-user-input',
+  CUSTOM_CONDITION = 'custom-condition',
 }
 
 export enum HtNodeWithoutContentType {

package/src/content-fields/hubtype-fields/nodes.ts

@@ -3,6 +3,7 @@ import type { HtAiAgentRouterNode } from './ai-agent-router'
 import type { HtBotActionNode } from './bot-action'
 import type { HtCaptureUserInputNode } from './capture-user-input'
 import type { HtCarouselNode } from './carousel'
+import type { HtCustomConditionalV2Node } from './custom-conditional-v2'
 // import { HtChannelConditionalNode } from './channel-conditional'
 // import { HtCountryConditionalNode } from './country-conditional'
 // import { HtCustomConditionalNode } from './custom-conditional'
@@ -46,6 +47,7 @@ export type HtNodeWithContent =
   | HtGoToFlow
   | HtWhatsappTemplateNode
   | HtCaptureUserInputNode
+  | HtCustomConditionalV2Node
 // | HtChannelConditionalNode
 // | HtCountryConditionalNode
 // | HtCustomConditionalNode

package/src/content-fields/index.ts

@@ -1,3 +1,4 @@
+import { FlowCustomConditionalV2 } from './custom-conditional/flow-custom-condition-v2'
 import { FlowAiAgent } from './flow-ai-agent'
 import { FlowAiAgentRouter } from './flow-ai-agent-router'
 import { FlowBotAction } from './flow-bot-action'
@@ -44,6 +45,7 @@ export {
   FlowWhatsappButtonList,
   FlowWhatsappCtaUrlButtonNode,
   FlowWhatsappTemplate,
+  FlowCustomConditionalV2,
 }
 
 export type FlowContent =
@@ -66,5 +68,6 @@ export type FlowContent =
   | FlowGoToFlow
   | FlowCaptureUserInput
   | FlowAiAgentRouter
+  | FlowCustomConditionalV2
 
 export { DISABLED_MEMORY_LENGTH }

package/src/flow-factory.ts

@@ -10,6 +10,7 @@ import {
   type FlowContent,
   FlowCountryConditional,
   FlowCustomConditional,
+  FlowCustomConditionalV2,
   FlowGoToFlow,
   FlowHandoff,
   FlowImage,
@@ -102,6 +103,12 @@ export class FlowFactory {
       case HtNodeWithContentType.CAPTURE_USER_INPUT:
         return FlowCaptureUserInput.fromHubtypeCMS(hubtypeContent)
 
+      case HtNodeWithContentType.CUSTOM_CONDITION:
+        return FlowCustomConditionalV2.fromHubtypeCMS(
+          hubtypeContent,
+          this.botContext
+        )
+
       default:
         return undefined
     }