@botonic/plugin-flow-builder 0.58.0-alpha.1 → 0.58.0-alpha.3

package/src/action/index.tsx

@@ -1,5 +1,6 @@
 import { type BotContext, isDev, isWebchat } from '@botonic/core'
 import {
+  CampaignMessageAttributesProvider,
   Multichannel,
   RequestContext,
   WebchatSettings,
@@ -46,31 +47,38 @@ export class FlowBuilderAction extends React.Component<FlowBuilderActionProps> {
     botContext: BotContext,
     contentID?: string
   ): Promise<FlowBuilderActionProps> {
-    const contents = await getContents(botContext, contentID)
+    const { contents } = await getContents(botContext, contentID)
 
     const contentsToRender = await FlowBuilderAction.prepareContentsToRender(
       botContext,
       contents
     )
 
-    return { contents: contentsToRender }
+    return {
+      contents: contentsToRender,
+    }
   }
 
   static async prepareContentsToRender(
     botContext: BotContext,
     contents: FlowContent[]
   ) {
+    const flowBuilderPlugin = getFlowBuilderPlugin(botContext.plugins)
+    const { campaignExecution, cmsApi } = flowBuilderPlugin
+
     for (const content of contents) {
       if (FlowBuilderAction.isAiAgentContent(content)) {
         await FlowBuilderAction.processAiAgentContent(botContext, contents)
+        campaignExecution.updateHasBotResponse(content)
         continue
       }
 
       await content.processContent(botContext)
 
+      campaignExecution.updateHasBotResponse(content)
+
       if (content instanceof FlowWhatsappRequestContactInfoNode) {
-        const flowBuilderPlugin = getFlowBuilderPlugin(botContext.plugins)
-        flowBuilderPlugin.cmsApi.setWhatsappRequestContactId(content.id)
+        cmsApi.setWhatsappRequestContactId(content.id)
       }
     }
 
@@ -147,10 +155,32 @@ export class FlowBuilderAction extends React.Component<FlowBuilderActionProps> {
         {shouldSendWebchatSettings && (
           <WebchatSettings {...webchatSettingsParams} />
         )}
-        {contents.map(content => content.toBotonic(botContext))}
+        {FlowBuilderAction.renderContents(contents, botContext)}
       </>
     )
   }
+
+  protected static renderContents(
+    contents: FlowContent[],
+    botContext: BotContext
+  ): JSX.Element | JSX.Element[] {
+    const flowBuilderPlugin = getFlowBuilderPlugin(botContext.plugins)
+    const { campaignExecution } = flowBuilderPlugin
+
+    const rendered = contents.map(content => content.toBotonic(botContext))
+
+    if (!campaignExecution.isActive() || !campaignExecution.campaignId) {
+      return rendered
+    }
+
+    return (
+      <CampaignMessageAttributesProvider
+        campaignId={campaignExecution.campaignId}
+      >
+        {rendered}
+      </CampaignMessageAttributesProvider>
+    )
+  }
 }
 
 export class FlowBuilderMultichannelAction extends FlowBuilderAction {
@@ -165,7 +195,7 @@ export class FlowBuilderMultichannelAction extends FlowBuilderAction {
         {shouldSendWebchatSettings && (
           <WebchatSettings {...webchatSettingsParams} />
         )}
-        {contents.map(content => content.toBotonic(botContext))}
+        {FlowBuilderAction.renderContents(contents, botContext)}
       </Multichannel>
     )
   }

package/src/action/payload.ts

@@ -1,25 +1,22 @@
 import { EventAction, type EventFeedback, storeCaseRating } from '@botonic/core'
 import { v7 as uuid } from 'uuid'
-
-import {
-  AGENT_RATING_PAYLOAD,
-  PUSH_FLOW_PAYLOAD,
-  SEPARATOR,
-} from '../constants'
-import type { FlowContent } from '../content-fields'
+import { AGENT_RATING_PAYLOAD, PUSH_FLOW_PAYLOAD } from '../constants'
 import type { HtNodeWithContent } from '../content-fields/hubtype-fields'
 import { trackEvent } from '../tracking'
+import type { FlowBuilderContentsResult } from './contents-result'
 import type { FlowBuilderContext } from './context'
+import { PushFlowResolver } from './push-flow-resolver'
 
 export async function getContentsByPayload(
   context: FlowBuilderContext
-): Promise<FlowContent[]> {
+): Promise<FlowBuilderContentsResult> {
   const { cmsApi, flowBuilderPlugin, request, contentID } = context
   if (request.input.payload?.startsWith(AGENT_RATING_PAYLOAD)) {
     return await resolveRatingPayload(context)
   }
   if (request.input.payload?.startsWith(PUSH_FLOW_PAYLOAD)) {
-    return await resolvePushFlowPayload(context)
+    const pushFlow = new PushFlowResolver(context)
+    return await pushFlow.getContents()
   }
 
   const id = contentID
@@ -28,19 +25,21 @@ export async function getContentsByPayload(
   const targetNode = id ? cmsApi.getNodeById<HtNodeWithContent>(id) : undefined
 
   if (targetNode) {
-    return await flowBuilderPlugin.getContentsByNode(targetNode)
+    return {
+      contents: await flowBuilderPlugin.getContentsByNode(targetNode),
+    }
   }
 
-  return []
+  return { contents: [] }
 }
 
 async function resolveRatingPayload(
   context: FlowBuilderContext
-): Promise<FlowContent[]> {
+): Promise<FlowBuilderContentsResult> {
   const { cmsApi, flowBuilderPlugin, request } = context
 
   if (!request.input.payload) {
-    return []
+    return { contents: [] }
   }
 
   const { target, text, value, possibleOptions, possibleValues } =
@@ -66,39 +65,10 @@ async function resolveRatingPayload(
     : undefined
 
   if (targetNode) {
-    return await flowBuilderPlugin.getContentsByNode(targetNode)
-  }
-
-  return []
-}
-
-async function resolvePushFlowPayload(
-  context: FlowBuilderContext
-): Promise<FlowContent[]> {
-  const { cmsApi, flowBuilderPlugin, request } = context
-
-  if (!request.input.payload) {
-    return []
-  }
-
-  const parts = request.input.payload.split(SEPARATOR)
-  const pushFlowId = parts.length > 1 ? parts[1] : ''
-
-  if (!pushFlowId) {
-    return []
-  }
-
-  try {
-    const pushFlowNode =
-      cmsApi.getNodeByCampaignId<HtNodeWithContent>(pushFlowId)
-
-    if (!pushFlowNode) {
-      return []
+    return {
+      contents: await flowBuilderPlugin.getContentsByNode(targetNode),
     }
-
-    return await flowBuilderPlugin.getContentsByNode(pushFlowNode)
-  } catch {
-    // Campaign not found - return empty to trigger fallback
-    return []
   }
+
+  return { contents: [] }
 }

package/src/action/push-flow-resolver.ts

@@ -0,0 +1,89 @@
+import {
+  type BotContext,
+  BotonicInputContextType,
+  getInputContextOfType,
+} from '@botonic/core'
+import type { FlowBuilderApi } from '../api'
+import type { HtNodeWithContent } from '../content-fields/hubtype-fields'
+import type BotonicPluginFlowBuilder from '../index'
+import type { FlowBuilderContentsResult } from './contents-result'
+import type { FlowBuilderContext } from './context'
+
+export enum PushFlowErrorCode {
+  NoCampaignContext = 'NoCampaignContext',
+  NoCampaignStartNode = 'NoCampaignStartNode',
+  NoCampaignFollowUpNode = 'NoCampaignFollowUpNode',
+}
+
+export class PushFlowError extends Error {
+  readonly code: PushFlowErrorCode
+
+  constructor(code: PushFlowErrorCode, reason: string) {
+    super(`push-flow failed: ${reason}`)
+    this.code = code
+    this.name = 'PushFlowError'
+  }
+}
+
+export class PushFlowResolver {
+  private botContext: BotContext
+  private cmsApi: FlowBuilderApi
+  private flowBuilderPlugin: BotonicPluginFlowBuilder
+
+  constructor(context: FlowBuilderContext) {
+    this.botContext = context.request
+    this.cmsApi = context.cmsApi
+    this.flowBuilderPlugin = context.flowBuilderPlugin
+  }
+
+  async getContents(): Promise<FlowBuilderContentsResult> {
+    const campaignContext = getInputContextOfType(
+      this.botContext.input.context,
+      BotonicInputContextType.PushFlow
+    )
+
+    if (!campaignContext) {
+      throw new PushFlowError(
+        PushFlowErrorCode.NoCampaignContext,
+        'No campaign context found in input context'
+      )
+    }
+
+    const {
+      campaign_flow_id: campaignFlowId,
+      campaign_follow_up_id: campaignFollowUpId,
+    } = campaignContext
+
+    const campaignStartNode = this.getCampaignStartNode(campaignFlowId)
+    const followUpNode = campaignFollowUpId
+      ? this.cmsApi.getNodeById<HtNodeWithContent>(campaignFollowUpId)
+      : undefined
+
+    if (campaignFollowUpId && !followUpNode) {
+      throw new PushFlowError(
+        PushFlowErrorCode.NoCampaignFollowUpNode,
+        'No campaign follow up node found'
+      )
+    }
+
+    return {
+      contents: await this.flowBuilderPlugin.getContentsByNode(
+        followUpNode ?? campaignStartNode
+      ),
+    }
+  }
+
+  private getCampaignStartNode(campaignId: string): HtNodeWithContent {
+    const campaignStartNode =
+      this.cmsApi.getNodeByCampaignId<HtNodeWithContent>(campaignId)
+
+    if (!campaignStartNode) {
+      throw new PushFlowError(
+        PushFlowErrorCode.NoCampaignStartNode,
+        'No campaign start node found'
+      )
+    }
+
+    return campaignStartNode
+  }
+}

package/src/api.ts

@@ -1,12 +1,7 @@
 import type { BotContext } from '@botonic/core'
 import axios from 'axios'
 
-import {
-  AI_AGENTS_FLOW_NAME,
-  PUSH_FLOW_PAYLOAD,
-  SEPARATOR,
-  UUID_REGEXP,
-} from './constants'
+import { AI_AGENTS_FLOW_NAME, SEPARATOR, UUID_REGEXP } from './constants'
 import {
   type HtBotActionNode,
   type HtCaptureUserInputNode,
@@ -82,12 +77,22 @@ export class FlowBuilderApi {
     return this.getNodeById<HtNodeWithContent>(subFlow.start_node_id)
   }
 
-  getNodeByCampaignId<T extends HtNodeComponent>(id: string): T {
+  getNodeByCampaignId<T extends HtNodeComponent>(id: string): T | undefined {
     const campaign = this.flow.campaigns.find(campaign => campaign.id === id)
     if (!campaign) {
-      throw Error(`Campaign with id: '${id}' not found`)
+      return undefined
+    }
+
+    const node = this.flow.nodes.find(
+      flowNode => flowNode.id === campaign.start_node_id
+    )
+
+    if (!node) {
+      console.error(`Node with id: '${campaign.start_node_id}' not found`)
+      return undefined
     }
-    return this.getNodeById<T>(campaign.start_node_id)
+
+    return node as T
   }
 
   getNodeById<T extends HtNodeComponent>(id: string): T {
@@ -330,8 +335,4 @@ export class FlowBuilderApi {
       defaultLocaleCode
     ).resolve()
   }
-
-  isPushFlowPayload(payload?: string): boolean {
-    return payload?.startsWith(PUSH_FLOW_PAYLOAD) ?? false
-  }
 }

package/src/bot-context-manager.ts

@@ -6,6 +6,7 @@ import {
 } from '@botonic/core'
 
 import type { FlowBuilderApi } from './api'
+import type { CampaignExecution } from './campaign-execution'
 import {
   EMPTY_PAYLOAD,
   ON_CLOSE_HANDOFF_PAYLOAD,
@@ -24,6 +25,7 @@ import { inputHasTextOrTranscript } from './utils/input'
 
 export class BotContextManager {
   constructor(
+    private readonly campaignExecution: CampaignExecution,
     private readonly cmsApi: FlowBuilderApi,
     private readonly smartIntentsConfig: SmartIntentsInferenceConfig
   ) {}
@@ -48,7 +50,8 @@ export class BotContextManager {
   private async updateFirstInteractionOnPushFlowPayload(
     botContext: BotContext
   ): Promise<void> {
-    if (this.cmsApi.isPushFlowPayload(botContext.input.payload)) {
+    const campaignExecution = this.campaignExecution
+    if (campaignExecution.isPushFlowPayload()) {
       botContext.session.is_first_interaction = false
     }
   }

package/src/campaign-execution.ts

@@ -0,0 +1,51 @@
+import {
+  type BotContext,
+  BotonicInputContextType,
+  getInputContextOfType,
+  type PushFlowContext,
+} from '@botonic/core'
+
+import { PUSH_FLOW_PAYLOAD } from './constants'
+import type { FlowContent } from './content-fields'
+
+export class CampaignExecution {
+  public hasBotResponse = false
+  private botContext: BotContext
+
+  constructor(botContext: BotContext) {
+    this.botContext = botContext
+  }
+
+  isActive(): boolean {
+    if (!this.isPushFlowPayload()) {
+      return false
+    }
+
+    return this.getPushFlowContext() !== undefined
+  }
+
+  get campaignId(): string | undefined {
+    return this.getPushFlowContext()?.campaign_id
+  }
+
+  updateHasBotResponse(content: FlowContent): void {
+    if (!this.isActive() || this.hasBotResponse) {
+      return
+    }
+    if (content.producesBotResponse()) {
+      this.hasBotResponse = true
+    }
+  }
+
+  isPushFlowPayload(): boolean {
+    const payload = this.botContext.input.payload
+    return payload?.startsWith(PUSH_FLOW_PAYLOAD) ?? false
+  }
+
+  private getPushFlowContext(): PushFlowContext | undefined {
+    return getInputContextOfType(
+      this.botContext.input.context,
+      BotonicInputContextType.PushFlow
+    )
+  }
+}

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

@@ -22,6 +22,8 @@ export abstract class ContentFieldsBase {
 
   abstract trackFlow(botContext: BotContext): Promise<void>
 
+  abstract producesBotResponse(): boolean
+
   abstract processContent(botContext: BotContext): Promise<void>
 
   async filterContent(

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

@@ -124,6 +124,10 @@ export class FlowCustomConditionalV2 extends ContentFieldsBase {
     await trackEvent(botContext, action, eventArgs)
   }
 
+  producesBotResponse(): boolean {
+    return false
+  }
+
   async processContent(botContext: BotContext): Promise<void> {
     await this.filterContent(botContext, this)
     await this.trackFlow(botContext)

package/src/content-fields/flow-ai-agent-base.tsx

@@ -114,6 +114,10 @@ export abstract class FlowAiAgentBase extends ContentFieldsBase {
     return
   }
 
+  producesBotResponse(): boolean {
+    return this.jsxElements.length > 0
+  }
+
   async processContent(
     botContext: BotContext,
     previousContents?: FlowContent[]

package/src/content-fields/flow-bot-action.tsx

@@ -51,6 +51,10 @@ export class FlowBotAction extends ContentFieldsBase {
     botContext.session._botonic_action = `${BotonicAction.Redirect}:${this.payload}`
   }
 
+  producesBotResponse(): boolean {
+    return false
+  }
+
   async processContent(botContext: BotContext): Promise<void> {
     await this.filterContent(botContext, this)
     this.doBotAction(botContext)

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

@@ -98,6 +98,10 @@ export class FlowButton extends ContentFieldsBase {
     }
   }
 
+  producesBotResponse(): boolean {
+    return false
+  }
+
   async processContent(): Promise<void> {
     return
   }

package/src/content-fields/flow-capture-user-input.tsx

@@ -34,6 +34,10 @@ export class FlowCaptureUserInput extends ContentFieldsBase {
     return
   }
 
+  producesBotResponse(): boolean {
+    return false
+  }
+
   async processContent(): Promise<void> {
     return
   }

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

@@ -203,6 +203,10 @@ export class FlowCarousel extends ContentFieldsBase {
     }
   }
 
+  producesBotResponse(): boolean {
+    return true
+  }
+
   async processContent(botContext: BotContext): Promise<void> {
     await this.filterContent(botContext, this)
     await this.trackFlow(botContext)

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

@@ -62,6 +62,10 @@ export class FlowChannelConditional extends ContentFieldsBase {
     await trackEvent(botContext, action, eventArgs)
   }
 
+  producesBotResponse(): boolean {
+    return false
+  }
+
   async processContent(botContext: BotContext): Promise<void> {
     await this.filterContent(botContext, this)
     await this.trackFlow(botContext)

package/src/content-fields/flow-contact-reasons-conditional.tsx

@@ -107,6 +107,10 @@ export class FlowContactReasonsConditional extends ContentFieldsBase {
     return
   }
 
+  producesBotResponse(): boolean {
+    return false
+  }
+
   async processContent(botContext: BotContext): Promise<void> {
     await this.filterContent(botContext, this)
     await this.trackFlow(botContext)

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

@@ -64,6 +64,10 @@ export class FlowCountryConditional extends ContentFieldsBase {
     await trackEvent(botContext, action, eventArgs)
   }
 
+  producesBotResponse(): boolean {
+    return false
+  }
+
   async processContent(botContext: BotContext): Promise<void> {
     await this.filterContent(botContext, this)
     await this.trackFlow(botContext)

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

@@ -115,6 +115,10 @@ export class FlowCustomConditional extends ContentFieldsBase {
     )
   }
 
+  producesBotResponse(): boolean {
+    return false
+  }
+
   async processContent(botContext: BotContext): Promise<void> {
     await this.filterContent(botContext, this)
     await this.trackFlow(botContext)

package/src/content-fields/flow-do-nothing.tsx

@@ -1,6 +1,8 @@
 import type { BotContext } from '@botonic/core'
 
+import { CampaignsV2Api } from '../services/campaigns-v2-api'
 import { trackOneContent } from '../tracking'
+import { getFlowBuilderPlugin } from '../utils/get-flow-builder-plugin'
 import { ContentFieldsBase } from './content-fields-base'
 import type { HtDoNothingNode } from './hubtype-fields'
 
@@ -8,18 +10,40 @@ export class FlowDoNothing extends ContentFieldsBase {
   static fromHubtypeCMS(cmsDoNothing: HtDoNothingNode): FlowDoNothing {
     const newDoNothing = new FlowDoNothing(cmsDoNothing.id)
     newDoNothing.code = cmsDoNothing.code
-    newDoNothing.followUp = cmsDoNothing.follow_up
+    newDoNothing.followUp = undefined
 
     return newDoNothing
   }
 
+  private async skipCampaignIfNoBotResponse(
+    botContext: BotContext
+  ): Promise<void> {
+    const flowBuilderPlugin = getFlowBuilderPlugin(botContext.plugins)
+    const campaignExecution = flowBuilderPlugin.campaignExecution
+    if (!campaignExecution.isActive() || campaignExecution.hasBotResponse) {
+      return
+    }
+    const campaignId = campaignExecution.campaignId
+    if (!campaignId) {
+      return
+    }
+
+    const campaignsV2Api = new CampaignsV2Api(botContext)
+    await campaignsV2Api.skipEmptyBotResponse(campaignId)
+  }
+
   async trackFlow(botContext: BotContext): Promise<void> {
     await trackOneContent(botContext, this)
   }
 
+  producesBotResponse(): boolean {
+    return false
+  }
+
   async processContent(botContext: BotContext): Promise<void> {
     await this.filterContent(botContext, this)
     await this.trackFlow(botContext)
+    await this.skipCampaignIfNoBotResponse(botContext)
     return
   }
 

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

@@ -62,6 +62,10 @@ export class FlowElement extends ContentFieldsBase {
     }
   }
 
+  producesBotResponse(): boolean {
+    return false
+  }
+
   async processContent(botContext: BotContext): Promise<void> {
     await this.trackFlow(botContext)
     return

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

@@ -50,6 +50,10 @@ export class FlowGoToFlow extends ContentFieldsBase {
     await trackEvent(botContext, action, eventArgs)
   }
 
+  producesBotResponse(): boolean {
+    return false
+  }
+
   async processContent(botContext: BotContext): Promise<void> {
     await this.filterContent(botContext, this)
     await this.trackFlow(botContext)

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

@@ -142,6 +142,10 @@ export class FlowHandoff extends ContentFieldsBase {
     // TODO: Not apply for this content because backend track handoff success event
   }
 
+  producesBotResponse(): boolean {
+    return false
+  }
+
   async processContent(botContext: BotContext): Promise<void> {
     await this.filterContent(botContext, this)
     await this.doHandoff(botContext)

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

@@ -21,6 +21,10 @@ export class FlowImage extends ContentFieldsBase {
     await trackOneContent(botContext, this)
   }
 
+  producesBotResponse(): boolean {
+    return true
+  }
+
   async processContent(botContext: BotContext): Promise<void> {
     await this.filterContent(botContext, this)
     await this.trackFlow(botContext)

package/src/content-fields/flow-queue-status-conditional.tsx

@@ -127,6 +127,10 @@ export class FlowQueueStatusConditional extends ContentFieldsBase {
     await trackEvent(botContext, action, eventArgs)
   }
 
+  producesBotResponse(): boolean {
+    return false
+  }
+
   async processContent(botContext: BotContext): Promise<void> {
     await this.filterContent(botContext, this)
     await this.trackFlow(botContext)

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

@@ -39,6 +39,10 @@ export class FlowRating extends ContentFieldsBase {
     await trackOneContent(botContext, this)
   }
 
+  producesBotResponse(): boolean {
+    return true
+  }
+
   async processContent(botContext: BotContext): Promise<void> {
     await this.filterContent(botContext, this)
     await this.trackFlow(botContext)

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

@@ -70,6 +70,10 @@ export class FlowText extends ContentFieldsBase {
     )
   }
 
+  producesBotResponse(): boolean {
+    return true
+  }
+
   async processContent(botContext: BotContext): Promise<void> {
     await this.filterContent(botContext, this)
     await this.trackFlow(botContext)