@botonic/plugin-flow-builder 0.46.2 → 0.47.0

package/src/action/context.ts

@@ -0,0 +1,29 @@
+import type { BotContext } from '@botonic/core'
+
+import type { FlowBuilderApi } from '../api'
+import type BotonicPluginFlowBuilder from '../index'
+import { getFlowBuilderPlugin } from '../utils/get-flow-builder-plugin'
+
+export interface FlowBuilderContext {
+  cmsApi: FlowBuilderApi
+  flowBuilderPlugin: BotonicPluginFlowBuilder
+  request: BotContext
+  resolvedLocale: string
+  contentID?: string
+}
+
+export function getFlowBuilderActionContext(
+  request: BotContext,
+  contentID?: string
+): FlowBuilderContext {
+  const flowBuilderPlugin = getFlowBuilderPlugin(request.plugins)
+  const cmsApi = flowBuilderPlugin.cmsApi
+  const resolvedLocale = flowBuilderPlugin.cmsApi.getResolvedLocale()
+  return {
+    cmsApi,
+    flowBuilderPlugin,
+    request,
+    resolvedLocale,
+    contentID,
+  }
+}

package/src/action/fallback.ts

@@ -7,7 +7,7 @@ import {
   getCommonFlowContentEventArgsForContentId,
   trackEvent,
 } from '../tracking'
-import type { FlowBuilderContext } from './index'
+import type { FlowBuilderContext } from './context'
 
 export async function getContentsByFallback({
   cmsApi,

package/src/action/first-interaction.ts

@@ -2,9 +2,9 @@ import type { FlowBuilderApi } from '../api'
 import { MAIN_FLOW_NAME } from '../constants'
 import { FlowBotAction, type FlowContent } from '../content-fields'
 import type BotonicPluginFlowBuilder from '../index'
-import { inputHasTextOrTranscript } from '../utils'
-import { getContentsByAiAgent } from './ai-agent'
-import type { FlowBuilderContext } from './index'
+import { inputHasTextOrTranscript } from '../utils/input'
+import { getContentsByAiAgentFromUserInput } from './ai-agent-from-user-input'
+import type { FlowBuilderContext } from './context'
 import { getContentsByKnowledgeBase } from './knowledge-bases'
 import { getContentsByPayload } from './payload'
 
@@ -100,7 +100,7 @@ async function getContentsByUserInput(
   }
 
   if (!flowBuilderPlugin.disableAIAgentInFirstInteraction) {
-    const contentsByAiAgent = await getContentsByAiAgent(context)
+    const contentsByAiAgent = await getContentsByAiAgentFromUserInput(context)
     return contentsByAiAgent
   }
 

package/src/action/get-contents.ts

@@ -0,0 +1,51 @@
+import { type BotContext, INPUT } from '@botonic/core'
+import { EMPTY_PAYLOAD } from '../constants'
+import type { FlowContent } from '../content-fields'
+import { inputHasTextOrTranscript } from '../utils/input'
+import { getContentsByAiAgentFromUserInput } from './ai-agent-from-user-input'
+import { getFlowBuilderActionContext } from './context'
+import { getContentsByFallback } from './fallback'
+import { getContentsByFirstInteraction } from './first-interaction'
+import { getContentsByKnowledgeBase } from './knowledge-bases'
+import { getContentsByPayload } from './payload'
+
+export async function getContents(
+  botContext: BotContext,
+  contentID?: string
+): Promise<FlowContent[]> {
+  const context = getFlowBuilderActionContext(botContext, contentID)
+
+  if (botContext.session.is_first_interaction) {
+    return await getContentsByFirstInteraction(context)
+  }
+  // TODO: Add needed logic when we can define contents for multi locale queue position message
+  if (botContext.input.type === INPUT.EVENT_QUEUE_POSITION_CHANGED) {
+    return []
+  }
+
+  if (botContext.input.payload?.startsWith(EMPTY_PAYLOAD)) {
+    botContext.input.payload = undefined
+  }
+
+  if (botContext.input.payload || contentID) {
+    const contentsByPayload = await getContentsByPayload(context)
+    if (contentsByPayload.length > 0) {
+      return contentsByPayload
+    }
+
+    return await getContentsByFallback(context)
+  }
+
+  if (inputHasTextOrTranscript(botContext.input)) {
+    const aiAgentContents = await getContentsByAiAgentFromUserInput(context)
+    if (aiAgentContents.length > 0) {
+      return aiAgentContents
+    }
+    const knowledgeBaseContents = await getContentsByKnowledgeBase(context)
+    if (knowledgeBaseContents.length > 0) {
+      return knowledgeBaseContents
+    }
+  }
+
+  return await getContentsByFallback(context)
+}

package/src/action/index.tsx

@@ -1,6 +1,5 @@
-import { type BotContext, INPUT, isDev, isWebchat } from '@botonic/core'
+import { type BotContext, isDev, isWebchat } from '@botonic/core'
 import {
-  type ActionRequest,
   Multichannel,
   RequestContext,
   WebchatSettings,
@@ -8,19 +7,12 @@ import {
 } from '@botonic/react'
 import React from 'react'
 
-import type { FlowBuilderApi } from '../api'
-import { EMPTY_PAYLOAD } from '../constants'
-import { type FlowContent, FlowHandoff } from '../content-fields'
-import { FlowBotAction } from '../content-fields/flow-bot-action'
-import { ContentFilterExecutor } from '../filters'
-import { getFlowBuilderPlugin } from '../helpers'
-import type BotonicPluginFlowBuilder from '../index'
-import { inputHasTextOrTranscript } from '../utils'
-import { getContentsByAiAgent } from './ai-agent'
-import { getContentsByFallback } from './fallback'
+import { FlowAiAgent, type FlowContent } from '../content-fields'
+import { filterContents } from '../filters'
+import { splitAiAgentContents } from '../utils/ai-agent'
+import { getFlowBuilderActionContext } from './context'
 import { getContentsByFirstInteraction } from './first-interaction'
-import { getContentsByKnowledgeBase } from './knowledge-bases'
-import { getContentsByPayload } from './payload'
+import { getContents } from './get-contents'
 
 export type FlowBuilderActionProps = {
   contents: FlowContent[]
@@ -32,62 +24,60 @@ export class FlowBuilderAction extends React.Component<FlowBuilderActionProps> {
   declare context: React.ContextType<typeof RequestContext>
 
   static async executeConversationStart(
-    request: ActionRequest
+    botContext: BotContext
   ): Promise<FlowBuilderActionProps> {
-    const context = getContext(request)
+    const context = getFlowBuilderActionContext(botContext)
     const contents = await getContentsByFirstInteraction(context)
-    const filteredContents = await filterContents(request, contents)
-    await FlowBuilderAction.trackAllContents(request, filteredContents)
-    await FlowBuilderAction.doHandoffAndBotActions(request, filteredContents)
+
+    const filteredContents = await FlowBuilderAction.prepareContentsToRender(
+      botContext,
+      contents
+    )
 
     return { contents: filteredContents }
   }
 
   static async botonicInit(
-    request: ActionRequest,
+    botContext: BotContext,
     contentID?: string
   ): Promise<FlowBuilderActionProps> {
-    const contents = await getContents(request, contentID)
-    const filteredContents = await filterContents(request, contents)
-    await FlowBuilderAction.trackAllContents(request, filteredContents)
-    await FlowBuilderAction.doHandoffAndBotActions(request, filteredContents)
+    const contents = await getContents(botContext, contentID)
 
-    return { contents: filteredContents }
-  }
+    const contentsToRender = await FlowBuilderAction.prepareContentsToRender(
+      botContext,
+      contents
+    )
 
-  static async trackAllContents(
-    request: ActionRequest,
-    contents: FlowContent[]
-  ) {
-    for (const content of contents) {
-      await content.trackFlow(request)
-    }
+    return { contents: contentsToRender }
   }
 
-  static async doHandoffAndBotActions(
-    request: ActionRequest,
+  static async prepareContentsToRender(
+    botContext: BotContext,
     contents: FlowContent[]
   ) {
-    const handoffContent = contents.find(
-      content => content instanceof FlowHandoff
-    ) as FlowHandoff
-    if (handoffContent) {
-      await handoffContent.doHandoff(request)
+    const filteredContents = await filterContents(botContext, contents)
+
+    for (const content of filteredContents) {
+      if (content instanceof FlowAiAgent) {
+        const splitContents = splitAiAgentContents(filteredContents)
+        if (!splitContents) {
+          continue
+        }
+        const { contentsBeforeAiAgent } = splitContents
+        await content.processContent(botContext, contentsBeforeAiAgent)
+      } else {
+        await content.processContent(botContext)
+      }
     }
 
-    const botActionContent = contents.find(
-      content => content instanceof FlowBotAction
-    ) as FlowBotAction
-    if (botActionContent) {
-      botActionContent.doBotAction(request)
-    }
+    return filteredContents
   }
 
   render(): JSX.Element | JSX.Element[] {
     const { contents, webchatSettingsParams } = this.props
-    const request = this.context as ActionRequest
+    const botContext = this.context as BotContext
     const shouldSendWebchatSettings =
-      (isWebchat(request.session) || isDev(request.session)) &&
+      (isWebchat(botContext.session) || isDev(botContext.session)) &&
       !!webchatSettingsParams
 
     return (
@@ -95,7 +85,7 @@ export class FlowBuilderAction extends React.Component<FlowBuilderActionProps> {
         {shouldSendWebchatSettings && (
           <WebchatSettings {...webchatSettingsParams} />
         )}
-        {contents.map(content => content.toBotonic(content.id, request))}
+        {contents.map(content => content.toBotonic(botContext))}
       </>
     )
   }
@@ -104,9 +94,9 @@ export class FlowBuilderAction extends React.Component<FlowBuilderActionProps> {
 export class FlowBuilderMultichannelAction extends FlowBuilderAction {
   render(): JSX.Element | JSX.Element[] {
     const { contents, webchatSettingsParams } = this.props
-    const request = this.context as ActionRequest
+    const botContext = this.context as BotContext
     const shouldSendWebchatSettings =
-      (isWebchat(request.session) || isDev(request.session)) &&
+      (isWebchat(botContext.session) || isDev(botContext.session)) &&
       !!webchatSettingsParams
 
     return (
@@ -114,92 +104,8 @@ export class FlowBuilderMultichannelAction extends FlowBuilderAction {
         {shouldSendWebchatSettings && (
           <WebchatSettings {...webchatSettingsParams} />
         )}
-        {contents.map(content => content.toBotonic(content.id, request))}
+        {contents.map(content => content.toBotonic(botContext))}
       </Multichannel>
     )
   }
 }
-
-async function getContents(
-  request: ActionRequest,
-  contentID?: string
-): Promise<FlowContent[]> {
-  const context = getContext(request, contentID)
-
-  if (request.session.is_first_interaction) {
-    return await getContentsByFirstInteraction(context)
-  }
-  // TODO: Add needed logic when we can define contents for multi locale queue position message
-  if (request.input.type === INPUT.EVENT_QUEUE_POSITION_CHANGED) {
-    return []
-  }
-
-  if (request.input.payload?.startsWith(EMPTY_PAYLOAD)) {
-    request.input.payload = undefined
-  }
-
-  if (request.input.payload || contentID) {
-    const contentsByPayload = await getContentsByPayload(context)
-    if (contentsByPayload.length > 0) {
-      return contentsByPayload
-    }
-
-    return await getContentsByFallback(context)
-  }
-
-  if (inputHasTextOrTranscript(request.input)) {
-    const aiAgentContents = await getContentsByAiAgent(context)
-    if (aiAgentContents.length > 0) {
-      return aiAgentContents
-    }
-    const knowledgeBaseContents = await getContentsByKnowledgeBase(context)
-    if (knowledgeBaseContents.length > 0) {
-      return knowledgeBaseContents
-    }
-  }
-
-  return await getContentsByFallback(context)
-}
-
-async function filterContents(
-  request: BotContext,
-  contents: FlowContent[]
-): Promise<FlowContent[]> {
-  const flowBuilderPlugin = getFlowBuilderPlugin(request.plugins)
-  const contentFilters = flowBuilderPlugin.contentFilters
-  const contentFilterExecutor = new ContentFilterExecutor({
-    filters: contentFilters,
-  })
-
-  const filteredContents: FlowContent[] = []
-  for (const content of contents) {
-    const filteredContent = await contentFilterExecutor.filter(request, content)
-    filteredContents.push(filteredContent)
-  }
-
-  return filteredContents
-}
-
-export interface FlowBuilderContext {
-  cmsApi: FlowBuilderApi
-  flowBuilderPlugin: BotonicPluginFlowBuilder
-  request: ActionRequest
-  resolvedLocale: string
-  contentID?: string
-}
-
-function getContext(
-  request: ActionRequest,
-  contentID?: string
-): FlowBuilderContext {
-  const flowBuilderPlugin = getFlowBuilderPlugin(request.plugins)
-  const cmsApi = flowBuilderPlugin.cmsApi
-  const resolvedLocale = flowBuilderPlugin.cmsApi.getResolvedLocale()
-  return {
-    cmsApi,
-    flowBuilderPlugin,
-    request,
-    resolvedLocale,
-    contentID,
-  }
-}

package/src/action/knowledge-bases.ts

@@ -17,8 +17,11 @@ import {
   trackEvent,
 } from '../tracking'
 import type { KnowledgeBaseFunction } from '../types'
-import { inputHasTextOrTranscript, isKnowledgeBasesAllowed } from '../utils'
-import type { FlowBuilderContext } from './index'
+import {
+  inputHasTextOrTranscript,
+  isKnowledgeBasesAllowed,
+} from '../utils/input'
+import type { FlowBuilderContext } from './context'
 
 export async function getContentsByKnowledgeBase({
   cmsApi,

package/src/action/payload.ts

@@ -9,7 +9,7 @@ import {
 import type { FlowContent } from '../content-fields'
 import type { HtNodeWithContent } from '../content-fields/hubtype-fields'
 import { trackEvent } from '../tracking'
-import type { FlowBuilderContext } from './index'
+import type { FlowBuilderContext } from './context'
 
 export async function getContentsByPayload(
   context: FlowBuilderContext

package/src/api.ts

@@ -204,14 +204,6 @@ export class FlowBuilderApi {
     return UUID_REGEXP.test(str)
   }
 
-  isGoToFlow(id: string): boolean {
-    if (!this.isUUID(id)) {
-      return false
-    }
-    const node = this.getNodeById(id)
-    return node?.type === HtNodeWithContentType.GO_TO_FLOW
-  }
-
   createPayloadWithParams(botActionNode: HtBotActionNode): string {
     const payloadId = botActionNode.content.payload_id
     const payloadNode = this.getNodeById<HtPayloadNode>(payloadId)

package/src/content-fields/content-fields-base.ts

@@ -1,4 +1,4 @@
-import type { ActionRequest } from '@botonic/react'
+import type { BotContext } from '@botonic/core'
 
 import {
   ACCESS_TOKEN_VARIABLE_KEY,
@@ -18,7 +18,9 @@ export abstract class ContentFieldsBase {
 
   constructor(public readonly id: string) {}
 
-  abstract trackFlow(request: ActionRequest): Promise<void>
+  abstract trackFlow(botContext: BotContext): Promise<void>
+
+  abstract processContent(botContext: BotContext): Promise<void>
 
   static getTextByLocale(locale: string, text: HtTextLocale[]): string {
     const result = text.find(t => t.locale === locale)
@@ -42,17 +44,17 @@ export abstract class ContentFieldsBase {
     return queues.find(queue => queue.locale === locale)
   }
 
-  replaceVariables(text: string, request: ActionRequest): string {
+  replaceVariables(text: string, botContext: BotContext): string {
     const matches = text.match(VARIABLE_PATTERN_GLOBAL)
 
     let replacedText = text
-    if (matches && request) {
+    if (matches && botContext) {
       matches.forEach(match => {
         // remove \\ ( escape for _ ) added by text node with markdown
         const keyPath = match.slice(1, -1).replaceAll('\\', '')
         const botVariable = keyPath.endsWith(ACCESS_TOKEN_VARIABLE_KEY)
           ? match
-          : this.getValueFromKeyPath(request, keyPath)
+          : this.getValueFromKeyPath(botContext, keyPath)
         // TODO In local if change variable and render multiple times the value is always the last update
         replacedText = replacedText.replace(
           match,
@@ -64,10 +66,10 @@ export abstract class ContentFieldsBase {
     return replacedText
   }
 
-  getValueFromKeyPath(request: ActionRequest, keyPath: string): any {
+  getValueFromKeyPath(botContext: BotContext, keyPath: string): any {
     if (keyPath.startsWith('session.user.contact_info.')) {
       const name = keyPath.split('.').at(-1)
-      return request.session.user.contact_info?.find(
+      return botContext.session.user.contact_info?.find(
         contact => contact.name === name
       )?.value
     }
@@ -75,14 +77,14 @@ export abstract class ContentFieldsBase {
     if (keyPath.startsWith('input.') || keyPath.startsWith('session.')) {
       return keyPath
         .split('.')
-        .reduce((object, key) => this.resolveObjectKey(object, key), request)
+        .reduce((object, key) => this.resolveObjectKey(object, key), botContext)
     }
 
     return keyPath
       .split('.')
       .reduce(
         (object, key) => this.resolveObjectKey(object, key),
-        request.session.user.extra_data
+        botContext.session.user.extra_data
       )
   }