@botonic/plugin-flow-builder 0.46.2 → 2.23.1

package/src/flow-factory.ts

@@ -1,134 +0,0 @@
-import type { ActionRequest } from '@botonic/react'
-
-import type { FlowBuilderApi } from './api'
-import {
-  FlowAiAgent,
-  FlowBotAction,
-  FlowCarousel,
-  FlowChannelConditional,
-  type FlowContent,
-  FlowCountryConditional,
-  FlowCustomConditional,
-  FlowGoToFlow,
-  FlowHandoff,
-  FlowImage,
-  FlowKnowledgeBase,
-  FlowQueueStatusConditional,
-  FlowRating,
-  FlowText,
-  FlowVideo,
-  FlowWhatsappButtonList,
-  FlowWhatsappCtaUrlButtonNode,
-  FlowWhatsappTemplate,
-} from './content-fields'
-import { FlowCaptureUserInput } from './content-fields/flow-capture-user-input'
-import {
-  type HtFunctionNode,
-  type HtNodeComponent,
-  HtNodeWithContentType,
-} from './content-fields/hubtype-fields'
-
-export class FlowFactory {
-  public currentRequest: ActionRequest
-  public cmsApi: FlowBuilderApi
-  public locale: string
-
-  constructor(request: ActionRequest, cmsApi: FlowBuilderApi, locale: string) {
-    this.currentRequest = request
-    this.cmsApi = cmsApi
-    this.locale = locale
-  }
-
-  async getFlowContent(
-    hubtypeContent: HtNodeComponent
-  ): Promise<FlowContent | undefined> {
-    switch (hubtypeContent.type) {
-      case HtNodeWithContentType.TEXT:
-        return FlowText.fromHubtypeCMS(hubtypeContent, this.locale, this.cmsApi)
-      case HtNodeWithContentType.IMAGE:
-        return FlowImage.fromHubtypeCMS(hubtypeContent, this.locale)
-      case HtNodeWithContentType.CAROUSEL:
-        return FlowCarousel.fromHubtypeCMS(
-          hubtypeContent,
-          this.locale,
-          this.cmsApi
-        )
-      case HtNodeWithContentType.VIDEO:
-        return FlowVideo.fromHubtypeCMS(hubtypeContent, this.locale)
-      case HtNodeWithContentType.WHATSAPP_BUTTON_LIST:
-        return FlowWhatsappButtonList.fromHubtypeCMS(
-          hubtypeContent,
-          this.locale,
-          this.cmsApi
-        )
-      case HtNodeWithContentType.WHATSAPP_CTA_URL_BUTTON:
-        return FlowWhatsappCtaUrlButtonNode.fromHubtypeCMS(
-          hubtypeContent,
-          this.locale,
-          this.cmsApi
-        )
-      case HtNodeWithContentType.HANDOFF:
-        return FlowHandoff.fromHubtypeCMS(
-          hubtypeContent,
-          this.locale,
-          this.cmsApi
-        )
-
-      case HtNodeWithContentType.KNOWLEDGE_BASE:
-        return FlowKnowledgeBase.fromHubtypeCMS(hubtypeContent)
-
-      case HtNodeWithContentType.AI_AGENT:
-        return FlowAiAgent.fromHubtypeCMS(hubtypeContent)
-
-      case HtNodeWithContentType.RATING:
-        return FlowRating.fromHubtypeCMS(hubtypeContent, this.locale)
-
-      case HtNodeWithContentType.BOT_ACTION:
-        return FlowBotAction.fromHubtypeCMS(hubtypeContent, this.cmsApi)
-
-      case HtNodeWithContentType.FUNCTION:
-        return this.resolveFlowFunctionContent(hubtypeContent)
-
-      case HtNodeWithContentType.GO_TO_FLOW:
-        return FlowGoToFlow.fromHubtypeCMS(hubtypeContent, this.cmsApi)
-
-      case HtNodeWithContentType.WHATSAPP_TEMPLATE:
-        return FlowWhatsappTemplate.fromHubtypeCMS(hubtypeContent, this.locale)
-
-      case HtNodeWithContentType.CAPTURE_USER_INPUT:
-        return FlowCaptureUserInput.fromHubtypeCMS(hubtypeContent)
-
-      default:
-        return undefined
-    }
-  }
-
-  private async resolveFlowFunctionContent(
-    hubtypeContent: HtFunctionNode
-  ): Promise<FlowContent | undefined> {
-    switch (hubtypeContent.content.action) {
-      case 'check-country':
-        return FlowCountryConditional.fromHubtypeCMS(
-          hubtypeContent,
-          this.currentRequest
-        )
-      case 'get-channel-type':
-        return FlowChannelConditional.fromHubtypeCMS(
-          hubtypeContent,
-          this.currentRequest
-        )
-      case 'check-queue-status':
-        return FlowQueueStatusConditional.fromHubtypeCMS(
-          hubtypeContent,
-          this.locale
-        )
-      case 'check-bot-variable':
-        return FlowCustomConditional.fromHubtypeCMS(
-          hubtypeContent,
-          this.currentRequest
-        )
-      default:
-        return undefined
-    }
-  }
-}

package/src/functions/index.ts

@@ -1,78 +0,0 @@
-import type { ActionRequest } from '@botonic/react'
-
-import type {
-  HtFunctionArgument,
-  HtFunctionArguments,
-  HtFunctionNode,
-} from '../content-fields/hubtype-fields'
-
-export const DEFAULT_FUNCTION_NAMES = [
-  'check-queue-status',
-  'get-channel-type',
-  'check-country',
-  'check-bot-variable',
-]
-
-export class CustomFunction {
-  public functions: Record<any, any>
-  public currentRequest: ActionRequest
-  public locale: string
-
-  constructor(
-    functions: Record<any, any>,
-    currentRequest: ActionRequest,
-    locale: string
-  ) {
-    this.functions = functions
-    this.currentRequest = currentRequest
-    this.locale = locale
-  }
-
-  async call(functionNode: HtFunctionNode): Promise<string> {
-    const functionNodeId = functionNode.id
-    const functionArguments = getArgumentsByLocale(
-      functionNode.content.arguments,
-      this.locale
-    )
-    const nameValues = functionArguments.map(arg => {
-      return { [arg.name]: arg.value }
-    })
-
-    const args = Object.assign(
-      {
-        request: this.currentRequest,
-        results: functionNode.content.result_mapping.map(r => r.result),
-      },
-      ...nameValues
-    )
-    const functionResult =
-      await this.functions[functionNode.content.action](args)
-    // TODO define result_mapping per locale??
-    const result = functionNode.content.result_mapping.find(
-      r => r.result === functionResult
-    )
-    if (!result?.target) {
-      throw new Error(
-        `No result found for result_mapping for node with id: ${functionNodeId}`
-      )
-    }
-    return result.target.id
-  }
-}
-
-export function getArgumentsByLocale(
-  args: HtFunctionArguments[],
-  locale: string
-): HtFunctionArgument[] {
-  let resultArguments: HtFunctionArgument[] = []
-  for (const arg of args) {
-    if ('locale' in arg && arg.locale === locale) {
-      resultArguments = [...resultArguments, ...arg.values]
-    }
-    if ('type' in arg) {
-      resultArguments = [...resultArguments, arg]
-    }
-  }
-
-  return resultArguments
-}

package/src/helpers.ts

@@ -1,25 +0,0 @@
-import type { ResolvedPlugins } from '@botonic/core'
-
-import type BotonicPluginFlowBuilder from './index'
-
-const FLOW_BUILDER_PLUGIN_NAME = 'BotonicPluginFlowBuilder'
-
-export function getFlowBuilderPlugin(
-  plugins: ResolvedPlugins
-): BotonicPluginFlowBuilder {
-  const ERROR_MESSAGE = `You must include '@botonic/plugin-flow-builder' in your plugins file.`
-
-  if (Object.values(plugins).length === 0) {
-    throw new Error(ERROR_MESSAGE)
-  }
-
-  const flowBuilderPlugin = Object.values(plugins).find(
-    plugin => plugin.constructor.name === FLOW_BUILDER_PLUGIN_NAME
-  ) as unknown as BotonicPluginFlowBuilder
-
-  if (!flowBuilderPlugin) {
-    throw new Error(ERROR_MESSAGE)
-  }
-
-  return flowBuilderPlugin
-}

package/src/index.ts

@@ -1,301 +0,0 @@
-import {
-  INPUT,
-  type Plugin,
-  type PluginPreRequest,
-  PROVIDER,
-  type ResolvedPlugins,
-  type Session,
-} from '@botonic/core'
-import type { ActionRequest } from '@botonic/react'
-import { v7 as uuidv7 } from 'uuid'
-
-import { FlowBuilderApi } from './api'
-import {
-  EMPTY_PAYLOAD,
-  FLOW_BUILDER_API_URL_PROD,
-  SEPARATOR,
-  SOURCE_INFO_SEPARATOR,
-} from './constants'
-import { type FlowContent, FlowGoToFlow } from './content-fields'
-import {
-  type HtBotActionNode,
-  type HtFlowBuilderData,
-  type HtGoToFlow,
-  type HtNodeWithContent,
-  HtNodeWithContentType,
-} from './content-fields/hubtype-fields'
-import { FlowFactory } from './flow-factory'
-import { CustomFunction, DEFAULT_FUNCTION_NAMES } from './functions'
-import {
-  type AiAgentFunction,
-  type BotonicPluginFlowBuilderOptions,
-  type ContentFilter,
-  FlowBuilderJSONVersion,
-  type InShadowingConfig,
-  type KnowledgeBaseFunction,
-  type PayloadParamsBase,
-  type RatingSubmittedInfo,
-  type TrackEventFunction,
-} from './types'
-import { getNextPayloadByUserInput } from './user-input'
-import type { SmartIntentsInferenceConfig } from './user-input/smart-intent'
-import { inputHasTextOrTranscript, resolveGetAccessToken } from './utils'
-
-// TODO: Create a proper service to wrap all calls and allow api versioning
-
-export default class BotonicPluginFlowBuilder implements Plugin {
-  public cmsApi: FlowBuilderApi
-  private flow?: HtFlowBuilderData
-  private functions: Record<any, any>
-  private currentRequest: PluginPreRequest
-  public getAccessToken: (session: Session) => string
-  public trackEvent?: TrackEventFunction
-  public getKnowledgeBaseResponse?: KnowledgeBaseFunction
-  public getAiAgentResponse?: AiAgentFunction
-  public smartIntentsConfig: SmartIntentsInferenceConfig
-  public inShadowing: InShadowingConfig
-  public contentFilters: ContentFilter[]
-
-  // TODO: Rethink how we construct FlowBuilderApi to be simpler
-  public jsonVersion: FlowBuilderJSONVersion
-  public apiUrl: string
-  public customRatingMessageEnabled: boolean
-  public disableAIAgentInFirstInteraction: boolean
-
-  constructor(options: BotonicPluginFlowBuilderOptions<ResolvedPlugins, any>) {
-    this.apiUrl = options.apiUrl || FLOW_BUILDER_API_URL_PROD
-    this.jsonVersion = options.jsonVersion || FlowBuilderJSONVersion.LATEST
-    this.flow = options.flow
-    this.getAccessToken = resolveGetAccessToken(options.getAccessToken)
-    this.trackEvent = options.trackEvent
-    this.getKnowledgeBaseResponse = options.getKnowledgeBaseResponse
-    this.getAiAgentResponse = options.getAiAgentResponse
-    this.smartIntentsConfig = {
-      ...options?.smartIntentsConfig,
-      useLatest: this.jsonVersion === FlowBuilderJSONVersion.LATEST,
-    }
-    const customFunctions = options.customFunctions || {}
-    this.functions = customFunctions
-    this.inShadowing = {
-      allowKeywords: options.inShadowing?.allowKeywords || false,
-      allowSmartIntents: options.inShadowing?.allowSmartIntents || false,
-      allowKnowledgeBases: options.inShadowing?.allowKnowledgeBases || false,
-      allowAiAgents: options.inShadowing?.allowAiAgents || false,
-    }
-    this.contentFilters = options.contentFilters || []
-    this.customRatingMessageEnabled =
-      options.customRatingMessageEnabled || false
-    this.disableAIAgentInFirstInteraction =
-      options.disableAIAgentInFirstInteraction || false
-  }
-
-  resolveFlowUrl(request: PluginPreRequest): string {
-    if (request.session.is_test_integration) {
-      return `${this.apiUrl}/v1/bot_flows/{bot_id}/versions/${FlowBuilderJSONVersion.DRAFT}/`
-    }
-    return `${this.apiUrl}/v1/bot_flows/{bot_id}/versions/${this.jsonVersion}/`
-  }
-
-  async pre(request: PluginPreRequest): Promise<void> {
-    // When AI Agent is executed in Whatsapp, button payloads come as referral and must be converted to text being processed by the agent.
-    this.convertWhatsappAiAgentEmptyPayloads(request)
-
-    this.currentRequest = request
-    this.cmsApi = await FlowBuilderApi.create({
-      flowUrl: this.resolveFlowUrl(request),
-      url: this.apiUrl,
-      flow: this.flow,
-      accessToken: this.getAccessToken(request.session),
-      request: this.currentRequest,
-    })
-
-    const checkUserTextInput =
-      inputHasTextOrTranscript(request.input) && !request.input.payload
-
-    if (checkUserTextInput) {
-      const resolvedLocale = this.cmsApi.getResolvedLocale()
-      const nextPayload = await getNextPayloadByUserInput(
-        this.cmsApi,
-        resolvedLocale,
-        request as unknown as ActionRequest,
-        this.smartIntentsConfig
-      )
-      request.input.payload = nextPayload
-    }
-
-    await this.updateRequestBeforeRoutes(request)
-  }
-
-  private convertWhatsappAiAgentEmptyPayloads(request: PluginPreRequest): void {
-    if (request.session.user.provider === PROVIDER.WHATSAPP) {
-      const shouldUseReferral =
-        request.input.referral &&
-        request.input.payload?.startsWith(EMPTY_PAYLOAD)
-
-      if (shouldUseReferral) {
-        request.input.type = INPUT.TEXT
-        request.input.data = request.input.referral
-      }
-    }
-  }
-
-  private async updateRequestBeforeRoutes(
-    request: PluginPreRequest
-  ): Promise<void> {
-    this.cmsApi.removeCaptureUserInputId()
-    if (request.input.payload) {
-      request.input.payload = this.removeSourceSuffix(request.input.payload)
-
-      if (this.cmsApi.isBotAction(request.input.payload)) {
-        const cmsBotAction = this.cmsApi.getNodeById<HtBotActionNode>(
-          request.input.payload
-        )
-
-        request.input.payload =
-          this.cmsApi.createPayloadWithParams(cmsBotAction)
-
-        // Re-execute convertWhatsappAiAgentEmptyPayloads function to handle
-        // the case that a BotAction has a payload equals to EMPTY_PAYLOAD
-        this.convertWhatsappAiAgentEmptyPayloads(request)
-      }
-
-      if (this.cmsApi.isGoToFlow(request.input.payload)) {
-        const cmsGoToFlow = this.cmsApi.getNodeById<HtGoToFlow>(
-          request.input.payload
-        )
-        await FlowGoToFlow.resolveToAiAgentsFlow(
-          request,
-          cmsGoToFlow,
-          this.cmsApi
-        )
-      }
-    }
-  }
-
-  private removeSourceSuffix(payload: string): string {
-    return payload.split(SOURCE_INFO_SEPARATOR)[0]
-  }
-
-  post(request: PluginPreRequest): void {
-    request.input.nluResolution = undefined
-  }
-
-  async getContentsByContentID(
-    contentID: string,
-    prevContents?: FlowContent[]
-  ): Promise<FlowContent[]> {
-    const node = this.cmsApi.getNodeByContentID(contentID) as HtNodeWithContent
-    return await this.getContentsByNode(node, prevContents)
-  }
-
-  getUUIDByContentID(contentID: string): string {
-    const node = this.cmsApi.getNodeByContentID(contentID)
-    return node.id
-  }
-
-  private async getContentsById(
-    id: string,
-    prevContents?: FlowContent[]
-  ): Promise<FlowContent[]> {
-    const node = this.cmsApi.getNodeById(id) as HtNodeWithContent
-    return await this.getContentsByNode(node, prevContents)
-  }
-
-  async getStartContents(): Promise<FlowContent[]> {
-    const startNode = this.cmsApi.getStartNode()
-    this.currentRequest.session.flow_thread_id = uuidv7()
-    return await this.getContentsByNode(startNode)
-  }
-
-  async getContentsByNode(
-    node: HtNodeWithContent,
-    prevContents?: FlowContent[]
-  ): Promise<FlowContent[]> {
-    const contents = prevContents || []
-    const resolvedLocale = this.cmsApi.getResolvedLocale()
-
-    if (
-      node.type === HtNodeWithContentType.FUNCTION &&
-      !DEFAULT_FUNCTION_NAMES.includes(node.content.action)
-    ) {
-      const customFunctionResolver = new CustomFunction(
-        this.functions,
-        this.currentRequest,
-        resolvedLocale
-      )
-      const targetId = await customFunctionResolver.call(node)
-      return this.getContentsById(targetId, contents)
-    }
-
-    const flowFactory = new FlowFactory(
-      this.currentRequest,
-      this.cmsApi,
-      resolvedLocale
-    )
-    const content = await flowFactory.getFlowContent(node)
-    if (content) {
-      contents.push(content)
-    }
-
-    // If node is BOT_ACTION not add more contents to render, next nodes render after execute action
-    if (node.type === HtNodeWithContentType.BOT_ACTION) {
-      return contents
-    }
-
-    // TODO: prevent infinite recursive calls
-    if (content?.followUp) {
-      return this.getContentsById(content.followUp.id, contents)
-    } else if (node.follow_up) {
-      console.log('FOLLOWUP FROM NODE-------> OLD SYSTEM')
-      return this.getContentsById(node.follow_up.id, contents)
-    }
-
-    return contents
-  }
-
-  getPayloadParams<T extends PayloadParamsBase>(payload: string): T {
-    const payloadParams = JSON.parse(payload.split(SEPARATOR)[1] || '{}')
-    return payloadParams
-  }
-
-  getFlowName(flowId: string): string {
-    return this.cmsApi.getFlowName(flowId)
-  }
-
-  getRatingSubmittedInfo(payload: string): RatingSubmittedInfo {
-    const buttonId = payload?.split(SEPARATOR)[1]
-    const ratingNode = this.cmsApi.getRatingNodeByButtonId(buttonId)
-
-    const ratingButton = this.cmsApi.getRatingButtonById(ratingNode, buttonId)
-    const possibleOptions = ratingNode.content.buttons.map(
-      button => button.text
-    )
-    const possibleValues = ratingNode.content.buttons.map(
-      button => button.value
-    )
-
-    return {
-      ...ratingButton,
-      possibleOptions,
-      possibleValues,
-    }
-  }
-
-  setInShadowing(inShadowing: InShadowingConfig): void {
-    this.inShadowing = inShadowing
-  }
-}
-
-export * from './action'
-export { AGENT_RATING_PAYLOAD, EMPTY_PAYLOAD } from './constants'
-export * from './content-fields'
-export { HtBotActionNode } from './content-fields/hubtype-fields'
-export { trackFlowContent } from './tracking'
-export {
-  BotonicPluginFlowBuilderOptions,
-  ContentFilter,
-  FlowBuilderJSONVersion,
-  PayloadParamsBase,
-  RatingSubmittedInfo,
-} from './types'
-export * from './webview'

package/src/services/hubtype-queues-api.ts

@@ -1,36 +0,0 @@
-import axios from 'axios'
-
-const HUBTYPE_API_URL = process.env.HUBTYPE_API_URL || 'https://api.hubtype.com'
-
-export interface AvailabilityData {
-  available: boolean
-  waiting_cases: number
-  availability_threshold_waiting_cases: number
-  open: boolean
-  name: string
-  available_agents: number
-}
-export class HubtypeQueuesApi {
-  public queueId: string
-  public checkAvailableAgents: boolean
-
-  constructor(queueId: string, checkAvailableAgents?: boolean) {
-    this.queueId = queueId
-    this.checkAvailableAgents = checkAvailableAgents || false
-  }
-
-  async getAvailability(): Promise<AvailabilityData> {
-    const response = await axios.get(
-      `${HUBTYPE_API_URL}/external/v1/queues/${this.queueId}/availability/`,
-      // TODO: Make it configurable in the future
-      {
-        params: {
-          check_queue_schedule: true,
-          check_waiting_cases: false,
-          check_available_agents: this.checkAvailableAgents,
-        },
-      }
-    )
-    return response.data
-  }
-}

package/src/tracking.ts

@@ -1,118 +0,0 @@
-import { EventAction, type EventFlow } from '@botonic/core'
-import type { ActionRequest } from '@botonic/react'
-import { v7 as uuidv7 } from 'uuid'
-
-import type { FlowBuilderApi } from './api'
-import type { FlowContent } from './content-fields'
-import {
-  type HtNodeWithContent,
-  HtNodeWithContentType,
-} from './content-fields/hubtype-fields'
-import { getFlowBuilderPlugin } from './helpers'
-
-export async function trackEvent(
-  request: ActionRequest,
-  eventAction: EventAction,
-  args?: Record<string, any>
-): Promise<void> {
-  const flowBuilderPlugin = getFlowBuilderPlugin(request.plugins)
-  if (flowBuilderPlugin.trackEvent) {
-    await flowBuilderPlugin.trackEvent(request, eventAction, args)
-  }
-  return
-}
-
-export async function trackFlowContent(
-  request: ActionRequest,
-  contents: FlowContent[]
-) {
-  const flowBuilderPlugin = getFlowBuilderPlugin(request.plugins)
-  const cmsApi = flowBuilderPlugin.cmsApi
-  for (const content of contents) {
-    await trackOneContent(request, content, cmsApi)
-  }
-}
-
-export async function trackOneContent(
-  request: ActionRequest,
-  content: FlowContent,
-  cmsApi?: FlowBuilderApi
-) {
-  if (!cmsApi) {
-    const flowBuilderPlugin = getFlowBuilderPlugin(request.plugins)
-    cmsApi = flowBuilderPlugin.cmsApi
-  }
-
-  const nodeContent = cmsApi.getNodeById<HtNodeWithContent>(content.id)
-  if (
-    nodeContent.type !== HtNodeWithContentType.KNOWLEDGE_BASE &&
-    nodeContent.type !== HtNodeWithContentType.AI_AGENT
-  ) {
-    const event = getContentEventArgs(request, nodeContent)
-    const { action, ...eventArgs } = event
-    await trackEvent(request, action, eventArgs)
-  }
-}
-
-function setSessionFlowThreadId(
-  request: ActionRequest,
-  flowThreadId: string
-): void {
-  request.session.flow_thread_id = flowThreadId
-}
-
-function getContentEventArgs(
-  request: ActionRequest,
-  nodeContent: HtNodeWithContent
-): EventFlow {
-  const { flowThreadId, flowId, flowName, flowNodeId, flowNodeContentId } =
-    getCommonFlowContentEventArgs(request, nodeContent)
-
-  setSessionFlowThreadId(request, flowThreadId)
-
-  return {
-    action: EventAction.FlowNode,
-    flowId,
-    flowName,
-    flowNodeId,
-    flowNodeContentId,
-    flowThreadId,
-    flowNodeIsMeaningful: nodeContent.is_meaningful ?? false,
-  }
-}
-
-type CommonFlowContentEventArgs = {
-  flowThreadId: string
-  flowId: string
-  flowName: string
-  flowNodeId: string
-  flowNodeContentId: string
-}
-
-function getCommonFlowContentEventArgs(
-  request: ActionRequest,
-  nodeContent: HtNodeWithContent
-): CommonFlowContentEventArgs {
-  const flowBuilderPlugin = getFlowBuilderPlugin(request.plugins)
-  const flowName = flowBuilderPlugin.getFlowName(nodeContent.flow_id)
-  const flowThreadId = request.session.flow_thread_id ?? uuidv7()
-
-  return {
-    flowThreadId,
-    flowId: nodeContent.flow_id,
-    flowName,
-    flowNodeId: nodeContent.id,
-    flowNodeContentId: nodeContent.code ?? '',
-  }
-}
-
-export function getCommonFlowContentEventArgsForContentId(
-  request: ActionRequest,
-  id: string
-): CommonFlowContentEventArgs {
-  const flowBuilderPlugin = getFlowBuilderPlugin(request.plugins)
-  const cmsApi = flowBuilderPlugin.cmsApi
-  const nodeContent = cmsApi.getNodeById<HtNodeWithContent>(id)
-
-  return getCommonFlowContentEventArgs(request, nodeContent)
-}