@botonic/plugin-flow-builder 0.46.2 → 2.23.0

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

@@ -1,65 +0,0 @@
-import { EventAction, type EventConditionalChannel } from '@botonic/core'
-import type { ActionRequest } from '@botonic/react'
-
-import {
-  getCommonFlowContentEventArgsForContentId,
-  trackEvent,
-} from '../tracking'
-import { ContentFieldsBase } from './content-fields-base'
-import type { HtChannelConditionalNode } from './hubtype-fields/channel-conditional'
-import type { HtFunctionResult } from './hubtype-fields/function'
-
-export class FlowChannelConditional extends ContentFieldsBase {
-  public resultMapping: HtFunctionResult[] = []
-  public conditionalResult?: HtFunctionResult = undefined
-  public channelResult: string = ''
-
-  static fromHubtypeCMS(
-    component: HtChannelConditionalNode,
-    request: ActionRequest
-  ): FlowChannelConditional {
-    const newChannelConditional = new FlowChannelConditional(component.id)
-    newChannelConditional.code = component.code
-    newChannelConditional.resultMapping = component.content.result_mapping
-    newChannelConditional.setConditionalResult(request)
-
-    return newChannelConditional
-  }
-
-  setConditionalResult(request: ActionRequest): void {
-    const provider = request.session.user.provider
-    const conditionalResult =
-      this.resultMapping.find(rMap => rMap.result === provider) ||
-      this.resultMapping.find(rMap => rMap.result === 'default')
-    if (!conditionalResult) {
-      throw new Error(
-        `No conditional result found for node ${this.code} with channel: ${provider}`
-      )
-    }
-    this.conditionalResult = conditionalResult
-    this.channelResult = conditionalResult.result as string
-    this.followUp = conditionalResult.target
-  }
-
-  async trackFlow(request: ActionRequest): Promise<void> {
-    const { flowThreadId, flowId, flowName, flowNodeId, flowNodeContentId } =
-      getCommonFlowContentEventArgsForContentId(request, this.id)
-
-    const eventChannelConditional: EventConditionalChannel = {
-      action: EventAction.ConditionalChannel,
-      flowThreadId,
-      flowId,
-      flowName,
-      flowNodeId,
-      flowNodeContentId,
-      flowNodeIsMeaningful: false,
-      channel: this.channelResult,
-    }
-    const { action, ...eventArgs } = eventChannelConditional
-    await trackEvent(request, action, eventArgs)
-  }
-
-  toBotonic(): JSX.Element {
-    return <></>
-  }
-}

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

@@ -1,67 +0,0 @@
-import { EventAction, type EventConditionalCountry } from '@botonic/core'
-import type { ActionRequest } from '@botonic/react'
-
-import {
-  getCommonFlowContentEventArgsForContentId,
-  trackEvent,
-} from '../tracking'
-import { ContentFieldsBase } from './content-fields-base'
-import type { HtFunctionResult } from './hubtype-fields'
-import type { HtCountryConditionalNode } from './hubtype-fields/country-conditional'
-
-export class FlowCountryConditional extends ContentFieldsBase {
-  public resultMapping: HtFunctionResult[] = []
-  public conditionalResult?: HtFunctionResult = undefined
-
-  static fromHubtypeCMS(
-    component: HtCountryConditionalNode,
-    request: ActionRequest
-  ): FlowCountryConditional {
-    const newCountryConditional = new FlowCountryConditional(component.id)
-    newCountryConditional.code = component.code
-    newCountryConditional.resultMapping = component.content.result_mapping
-    newCountryConditional.setConditionalResult(request)
-
-    return newCountryConditional
-  }
-
-  setConditionalResult(request: ActionRequest): void {
-    const country = request.getUserCountry()
-    const conditionalResult =
-      this.resultMapping.find(rMap => rMap.result === country) ||
-      this.resultMapping.find(rMap => rMap.result === 'default')
-    if (!conditionalResult) {
-      throw new Error(
-        `No conditional result found for node ${this.code} with country: ${country}`
-      )
-    }
-    this.conditionalResult = conditionalResult
-    this.followUp = conditionalResult.target
-  }
-
-  async trackFlow(request: ActionRequest): Promise<void> {
-    const { flowThreadId, flowId, flowName, flowNodeId, flowNodeContentId } =
-      getCommonFlowContentEventArgsForContentId(request, this.id)
-    if (!this.conditionalResult?.result) {
-      console.warn(
-        `Tracking event for node ${this.code} but no conditional result found`
-      )
-    }
-    const eventCountryConditional: EventConditionalCountry = {
-      action: EventAction.ConditionalCountry,
-      flowThreadId,
-      flowId,
-      flowName,
-      flowNodeId,
-      flowNodeContentId,
-      flowNodeIsMeaningful: false,
-      country: (this.conditionalResult?.result as string) ?? '',
-    }
-    const { action, ...eventArgs } = eventCountryConditional
-    await trackEvent(request, action, eventArgs)
-  }
-
-  toBotonic(): JSX.Element {
-    return <></>
-  }
-}

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

@@ -1,117 +0,0 @@
-import { EventAction, type EventConditionalCustom } from '@botonic/core'
-import type { ActionRequest } from '@botonic/react'
-
-import {
-  getCommonFlowContentEventArgsForContentId,
-  trackEvent,
-} from '../tracking'
-import { ContentFieldsBase } from './content-fields-base'
-import type { HtCustomConditionalNode } from './hubtype-fields/custom-conditional'
-import type {
-  HtFunctionArgument,
-  HtFunctionArguments,
-  HtFunctionResult,
-} from './hubtype-fields/function'
-
-export class FlowCustomConditional extends ContentFieldsBase {
-  public arguments: HtFunctionArguments[] = []
-  public resultMapping: HtFunctionResult[]
-  public conditionalResult?: HtFunctionResult = undefined
-  public customResult: boolean = false
-  public variableFormat: string = ''
-
-  static fromHubtypeCMS(
-    component: HtCustomConditionalNode,
-    request: ActionRequest
-  ): FlowCustomConditional {
-    const newCustomConditional = new FlowCustomConditional(component.id)
-    newCustomConditional.code = component.code
-    newCustomConditional.arguments = component.content.arguments
-    newCustomConditional.resultMapping = component.content.result_mapping
-    newCustomConditional.setConditionalResult(request)
-    newCustomConditional.variableFormat = (
-      component.content.arguments as HtFunctionArgument[]
-    )[0].type
-
-    return newCustomConditional
-  }
-
-  setConditionalResult(request: ActionRequest): void {
-    const functionArgument = this.arguments.find(arg => {
-      if ('name' in arg) {
-        return arg.name === 'keyPath'
-      }
-      return false
-    })
-
-    let keyPath = ''
-
-    if (functionArgument && 'value' in functionArgument) {
-      keyPath = functionArgument.value
-    } else {
-      throw new Error(`Key path not found for node ${this.code}`)
-    }
-
-    const botVariable = this.getValueFromKeyPath(request, keyPath)
-
-    let conditionalResult =
-      this.resultMapping.find(rMap => rMap.result === botVariable) ||
-      this.resultMapping.find(rMap => rMap.result === 'default')
-
-    if (
-      this.isBooleanConditional(this.resultMapping) &&
-      typeof botVariable !== 'boolean'
-    ) {
-      conditionalResult =
-        this.resultMapping.find(
-          rMap =>
-            rMap.result === (botVariable !== undefined && botVariable !== null)
-        ) || this.resultMapping.find(rMap => rMap.result === 'default')
-    }
-
-    if (!conditionalResult) {
-      throw new Error(
-        `No conditional result found for node ${this.code} with key path: ${keyPath}`
-      )
-    }
-
-    this.conditionalResult = conditionalResult
-    this.customResult = conditionalResult.result as unknown as boolean
-    this.followUp = conditionalResult.target
-  }
-
-  async trackFlow(request: ActionRequest): Promise<void> {
-    const { flowThreadId, flowId, flowName, flowNodeId, flowNodeContentId } =
-      getCommonFlowContentEventArgsForContentId(request, this.id)
-    if (!this.conditionalResult?.result) {
-      console.warn(
-        `Tracking event for node ${this.code} but no conditional result found`
-      )
-    }
-    const eventCustomConditional: EventConditionalCustom = {
-      action: EventAction.ConditionalCustom,
-      flowThreadId,
-      flowId,
-      flowName,
-      flowNodeId,
-      flowNodeContentId,
-      flowNodeIsMeaningful: false,
-      conditionalVariable: this.customResult.toString(),
-      variableFormat: this.variableFormat,
-    }
-    const { action, ...eventArgs } = eventCustomConditional
-    await trackEvent(request, action, eventArgs)
-  }
-
-  private isBooleanConditional(resultMapping: HtFunctionResult[]): boolean {
-    return (
-      resultMapping.some(rMap => rMap.result === true) &&
-      resultMapping.some(rMap => rMap.result === false) &&
-      resultMapping.some(rMap => rMap.result === 'default')
-    )
-  }
-
-  toBotonic() {
-    return <></>
-  }
-}

package/src/content-fields/flow-element.tsx

@@ -1,79 +0,0 @@
-import type { Button } from '@botonic/core'
-import {
-  type ActionRequest,
-  Element,
-  Pic,
-  Subtitle,
-  Title,
-} from '@botonic/react'
-
-import type { FlowBuilderApi } from '../api'
-import { ContentFieldsBase } from './content-fields-base'
-import { FlowButton } from './flow-button'
-import type { HtCarouselElement } from './hubtype-fields'
-
-export class FlowElement extends ContentFieldsBase {
-  public title = ''
-  public subtitle = ''
-  public button: FlowButton | undefined
-  public image = ''
-  public hidden = false
-
-  static fromHubtypeCMS(
-    component: HtCarouselElement,
-    locale: string,
-    cmsApi: FlowBuilderApi
-  ): FlowElement {
-    const newElement = new FlowElement(component.id)
-    newElement.title = FlowElement.getTextByLocale(locale, component.title)
-    newElement.subtitle = FlowElement.getTextByLocale(
-      locale,
-      component.subtitle
-    )
-    newElement.image = FlowElement.getAssetByLocale(locale, component.image)
-    newElement.button = FlowButton.fromHubtypeCMS(
-      component.button,
-      locale,
-      cmsApi
-    )
-    return newElement
-  }
-
-  static fromAIAgent(
-    id: string,
-    element: {
-      title: string
-      subtitle: string
-      image: string
-      button: Button
-    }
-  ) {
-    const newElement = new FlowElement(id)
-    newElement.title = element.title
-    newElement.subtitle = element.subtitle
-    newElement.image = element.image
-    newElement.button = FlowButton.fromAIAgent({
-      id: `${id}-button`,
-      text: element.button.text,
-      url: element.button.url,
-    })
-    return newElement
-  }
-
-  async trackFlow(request: ActionRequest): Promise<void> {
-    if (this.button) {
-      await this.button.trackFlow(request)
-    }
-  }
-
-  toBotonic(parentId: string): JSX.Element {
-    return (
-      <Element key={`${parentId}-${this.id}`}>
-        <Pic src={this.image} />
-        <Title>{this.title}</Title>
-        <Subtitle>{this.subtitle}</Subtitle>
-        {this.button?.renderButton(0)}
-      </Element>
-    )
-  }
-}

package/src/content-fields/flow-go-to-flow.tsx

@@ -1,75 +0,0 @@
-import {
-  EventAction,
-  type EventRedirectFlow,
-  INPUT,
-  PROVIDER,
-} from '@botonic/core'
-import type { ActionRequest } from '@botonic/react'
-import type { FlowBuilderApi } from '../api'
-import { AI_AGENTS_FLOW_NAME } from '../constants'
-import {
-  getCommonFlowContentEventArgsForContentId,
-  trackEvent,
-} from '../tracking'
-import { ContentFieldsBase } from './content-fields-base'
-import type { HtGoToFlow, HtNodeWithContent } from './hubtype-fields'
-
-export class FlowGoToFlow extends ContentFieldsBase {
-  public flowTargetId: string = ''
-  public flowTargetName: string = ''
-  public targetId: string = ''
-
-  static fromHubtypeCMS(
-    component: HtGoToFlow,
-    cmsApi: FlowBuilderApi
-  ): FlowGoToFlow {
-    const newGoToFlow = new FlowGoToFlow(component.id)
-    newGoToFlow.code = component.code
-    newGoToFlow.flowTargetId = component.content.flow_id
-    const targetId = cmsApi.getNodeByFlowId(component.content.flow_id).id
-    newGoToFlow.targetId = targetId
-    newGoToFlow.flowTargetName = cmsApi.getFlowName(component.content.flow_id)
-    newGoToFlow.followUp = cmsApi.getNodeById<HtNodeWithContent>(targetId)
-
-    return newGoToFlow
-  }
-
-  static async resolveToAiAgentsFlow(
-    botContext: ActionRequest,
-    component: HtGoToFlow,
-    cmsApi: FlowBuilderApi
-  ): Promise<void> {
-    const goToFlowContent = FlowGoToFlow.fromHubtypeCMS(component, cmsApi)
-    if (goToFlowContent.flowTargetName === AI_AGENTS_FLOW_NAME) {
-      await goToFlowContent.trackFlow(botContext)
-
-      botContext.input.payload = undefined
-      if (botContext.session.user.provider === PROVIDER.WHATSAPP) {
-        botContext.input.type = INPUT.TEXT
-        botContext.input.data = botContext.input.referral
-      }
-    }
-  }
-
-  async trackFlow(request: ActionRequest): Promise<void> {
-    const { flowThreadId, flowId, flowName, flowNodeId, flowNodeContentId } =
-      getCommonFlowContentEventArgsForContentId(request, this.id)
-    const eventGoToFlow: EventRedirectFlow = {
-      action: EventAction.RedirectFlow,
-      flowThreadId,
-      flowId,
-      flowName,
-      flowNodeId,
-      flowNodeContentId: flowNodeContentId || 'Go to flow',
-      flowTargetId: this.flowTargetId,
-      flowTargetName: this.flowTargetName,
-      flowNodeIsMeaningful: false,
-    }
-    const { action, ...eventArgs } = eventGoToFlow
-    await trackEvent(request, action, eventArgs)
-  }
-
-  toBotonic(): JSX.Element {
-    return <></>
-  }
-}

package/src/content-fields/flow-handoff.tsx

@@ -1,99 +0,0 @@
-import { HandOffBuilder, HelpdeskEvent, isDev, isWebchat } from '@botonic/core'
-import { type ActionRequest, WebchatSettings } from '@botonic/react'
-
-import type { FlowBuilderApi } from '../api'
-import { getCommonFlowContentEventArgsForContentId } from '../tracking'
-import { ContentFieldsBase } from './content-fields-base'
-import type { HtHandoffNode, HtQueueLocale } from './hubtype-fields'
-
-export class FlowHandoff extends ContentFieldsBase {
-  public queue?: HtQueueLocale
-  public onFinishPayload?: string
-  public handoffAutoAssign: boolean
-  public hasQueuePositionChangedNotificationsEnabled: boolean
-  public isTestIntegration: boolean
-
-  static fromHubtypeCMS(
-    cmsHandoff: HtHandoffNode,
-    locale: string,
-    cmsApi: FlowBuilderApi
-  ): FlowHandoff {
-    const newHandoff = new FlowHandoff(cmsHandoff.id)
-    newHandoff.code = cmsHandoff.code
-    newHandoff.queue = FlowHandoff.getQueueByLocale(
-      locale,
-      cmsHandoff.content.queue
-    )
-    newHandoff.onFinishPayload = FlowHandoff.getOnFinishPayload(
-      cmsHandoff,
-      cmsApi
-    )
-    newHandoff.handoffAutoAssign = cmsHandoff.content.has_auto_assign
-    newHandoff.hasQueuePositionChangedNotificationsEnabled =
-      cmsHandoff.content.has_queue_position_changed_notifications_enabled
-    newHandoff.followUp = cmsHandoff.follow_up
-
-    return newHandoff
-  }
-
-  private static getOnFinishPayload(
-    cmsHandoff: HtHandoffNode,
-    cmsApi: FlowBuilderApi
-  ): string | undefined {
-    if (cmsHandoff.target?.id) {
-      return cmsApi.getPayload(cmsHandoff.target)
-    }
-
-    return undefined
-  }
-
-  async doHandoff(request: ActionRequest): Promise<void> {
-    const handOffBuilder = new HandOffBuilder(request.session)
-    handOffBuilder.withAutoAssignOnWaiting(this.handoffAutoAssign)
-
-    if (this.hasQueuePositionChangedNotificationsEnabled) {
-      handOffBuilder.withSubscribeHelpdeskEvents([
-        HelpdeskEvent.QueuePositionChanged,
-      ])
-    }
-
-    if (this.onFinishPayload) {
-      handOffBuilder.withOnFinishPayload(this.onFinishPayload)
-    }
-
-    if (this.queue) {
-      const language = request.getSystemLocale()
-
-      handOffBuilder.withQueue(this.queue.id)
-
-      const { flowId, flowName, flowNodeId, flowNodeContentId } =
-        getCommonFlowContentEventArgsForContentId(request, this.id)
-
-      handOffBuilder.withBotEvent({
-        flowId,
-        flowName,
-        flowNodeId,
-        flowNodeContentId,
-      })
-
-      handOffBuilder.withExtraData({
-        language,
-      })
-
-      await handOffBuilder.handOff()
-    }
-  }
-
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  async trackFlow(_request: ActionRequest): Promise<void> {
-    // TODO: Not apply for this content because backend track handoff success event
-  }
-
-  toBotonic(id: string, request: ActionRequest): JSX.Element {
-    return isDev(request.session) || isWebchat(request.session) ? (
-      <WebchatSettings key={id} enableUserInput={true} />
-    ) : (
-      <></>
-    )
-  }
-}

package/src/content-fields/flow-image.tsx

@@ -1,26 +0,0 @@
-import { type ActionRequest, Image } from '@botonic/react'
-
-import { trackOneContent } from '../tracking'
-import { ContentFieldsBase } from './content-fields-base'
-import type { HtImageNode } from './hubtype-fields'
-
-export class FlowImage extends ContentFieldsBase {
-  public src = ''
-
-  static fromHubtypeCMS(component: HtImageNode, locale: string): FlowImage {
-    const newImage = new FlowImage(component.id)
-    newImage.code = component.code
-    newImage.src = FlowImage.getAssetByLocale(locale, component.content.image)
-    newImage.followUp = component.follow_up
-
-    return newImage
-  }
-
-  async trackFlow(request: ActionRequest): Promise<void> {
-    await trackOneContent(request, this)
-  }
-
-  toBotonic(id: string): JSX.Element {
-    return <Image key={id} src={this.src} />
-  }
-}

package/src/content-fields/flow-knowledge-base.tsx

@@ -1,51 +0,0 @@
-import { type ActionRequest, Text } from '@botonic/react'
-
-import { ContentFieldsBase } from './content-fields-base'
-import type { HtKnowledgeBaseNode } from './hubtype-fields'
-
-export const DISABLED_MEMORY_LENGTH = 1
-
-export class FlowKnowledgeBase extends ContentFieldsBase {
-  public feedbackEnabled: boolean = false
-  public sources: string[] = []
-  public text: string = ''
-  public inferenceId?: string
-  public sourcesData: { id: string; name: string }[] = []
-  public instructions: string
-  public hasMemory: boolean
-  public memoryLength: number
-
-  static fromHubtypeCMS(component: HtKnowledgeBaseNode): FlowKnowledgeBase {
-    const newKnowledgeBase = new FlowKnowledgeBase(component.id)
-    newKnowledgeBase.code = component.code
-    newKnowledgeBase.feedbackEnabled = component.content.feedback_enabled
-    newKnowledgeBase.sourcesData = component.content.sources_data
-    newKnowledgeBase.instructions = component.content.instructions
-    newKnowledgeBase.hasMemory = component.content.has_memory || false
-    newKnowledgeBase.memoryLength =
-      component.content.memory_length || DISABLED_MEMORY_LENGTH
-    newKnowledgeBase.followUp = component.follow_up
-
-    return newKnowledgeBase
-  }
-
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  async trackFlow(_request: ActionRequest): Promise<void> {
-    // TODO: Review how we can track here the knowledge base event here.
-    // We should store event args in an attribute of FlowKnowledgeBase
-    // when knowledge base is resolved inside the flow builder action
-  }
-
-  toBotonic(id: string, request: ActionRequest): JSX.Element {
-    return (
-      <Text
-        key={id}
-        feedbackEnabled={this.feedbackEnabled}
-        inferenceId={this.inferenceId}
-        botInteractionId={request.input.bot_interaction_id}
-      >
-        {this.text}
-      </Text>
-    )
-  }
-}