@botonic/plugin-flow-builder 0.21.1 → 0.21.3

package/src/index.ts

@@ -22,47 +22,41 @@ import {
   IntentNode,
   KeywordNode,
   NodeComponent,
-  NodeLink,
   NodeType,
   StartNode,
 } from './flow-builder-models'
 import { DEFAULT_FUNCTIONS } from './functions'
-
-export type BotonicPluginFlowBuilderOptions = {
-  flowUrl: string
-  flow?: FlowBuilderData
-  customFunctions?: Record<any, any>
-  getLocale: (session: Session) => string
-  getAccessToken: () => string
-}
+import { BotonicPluginFlowBuilderOptions } from './types'
+import { resolveGetAccessToken } from './utils'
+import { updateButtonUrls } from './helpers'
 
 export default class BotonicPluginFlowBuilder implements Plugin {
   private flowUrl: string
   private flow: Promise<FlowBuilderData> | FlowBuilderData
   private functions: Record<any, any>
   private currentRequest: PluginPreRequest
-  private getAccessToken: () => string
+  private getAccessToken: (session: Session) => string
   public getLocale: (session: Session) => string
 
   constructor(readonly options: BotonicPluginFlowBuilderOptions) {
     this.getLocale = options.getLocale
-    this.getAccessToken = options.getAccessToken
+    this.getAccessToken = resolveGetAccessToken(options)
     this.flowUrl = options.flowUrl
-    this.flow = options.flow || this.readFlowContent()
+    if (options.flow) this.flow = options.flow
     const customFunctions = options.customFunctions || {}
     this.functions = { ...DEFAULT_FUNCTIONS, ...customFunctions }
   }
 
-  async readFlowContent(): Promise<FlowBuilderData> {
+  async readFlowContent(session: Session): Promise<FlowBuilderData> {
     const { data } = await axios.get(this.flowUrl, {
-      headers: { Authorization: `Bearer ${this.getAccessToken()}` },
+      headers: { Authorization: `Bearer ${this.getAccessToken(session)}` },
     })
     return data
   }
 
   async pre(request: PluginPreRequest): Promise<void> {
     this.currentRequest = request
-    this.flow = this.readFlowContent()
+    this.flow = await this.readFlowContent(this.currentRequest.session)
   }
 
   async post(_request: PluginPostRequest): Promise<void> {}
@@ -112,7 +106,7 @@ export default class BotonicPluginFlowBuilder implements Plugin {
     return startNode.target.id
   }
 
-  async getFallbackId(): Promise<string> {
+  async getFallbackId(alternate: boolean): Promise<string> {
     const flow = await this.flow
     const fallbackNode = flow.nodes.find(
       node => node.type === NodeType.FALLBACK
@@ -121,8 +115,7 @@ export default class BotonicPluginFlowBuilder implements Plugin {
     const fallbackFirstMessage = fallbackNode.content.first_message
     const fallbackSecondMessage = fallbackNode.content.second_message
     if (!fallbackSecondMessage) return fallbackFirstMessage.id
-    const fallbackIds = [fallbackFirstMessage.id, fallbackSecondMessage.id]
-    return fallbackIds[Math.floor(Math.random() * fallbackIds.length)]
+    return alternate ? fallbackFirstMessage.id : fallbackSecondMessage.id
   }
   async getContents(
     id: string,
@@ -132,33 +125,9 @@ export default class BotonicPluginFlowBuilder implements Plugin {
     const contents = prevContents || []
     const hubtypeContent: any = await this.getContent(id)
     const isHandoff = hubtypeContent.type === NodeType.HANDOFF
-
-    if (hubtypeContent.content.elements) {
-      for (const i in hubtypeContent.content.elements) {
-        const button = hubtypeContent.content.elements[i].button
-        if (button.url) {
-          for (const j in button.url) {
-            button.url[j] = {
-              ...button.url[j],
-              ...(await this.getContent(button.url[j].id)),
-            }
-          }
-        }
-      }
-    }
-    if (hubtypeContent.content.buttons) {
-      for (const i in hubtypeContent.content.buttons) {
-        const button = hubtypeContent.content.buttons[i]
-        if (button.url) {
-          for (const j in button.url) {
-            button.url[j] = {
-              ...button.url[j],
-              ...(await this.getContent(button.url[j].id)),
-            }
-          }
-        }
-      }
-    }
+    // TODO: Create function to populate these buttons
+    await updateButtonUrls(hubtypeContent, 'elements', this.getContent)
+    await updateButtonUrls(hubtypeContent, 'buttons', this.getContent)
     const content = await this.getFlowContent(hubtypeContent, locale)
     if (hubtypeContent.type === NodeType.FUNCTION) {
       const targetId = await this.callFunction(hubtypeContent, locale)

package/src/types.ts

@@ -0,0 +1,16 @@
+import { Session } from '@botonic/core'
+
+import { FlowBuilderData } from './flow-builder-models'
+
+export interface BotonicPluginFlowBuilderOptions {
+  flowUrl: string
+  flow?: FlowBuilderData
+  customFunctions?: Record<any, any>
+  getLocale: (session: Session) => string
+  getAccessToken: () => string
+}
+
+export enum ProcessEnvNodeEnvs {
+  PRODUCTION = 'production',
+  DEVELOPMENT = 'development',
+}

package/src/utils.ts

@@ -1,3 +1,7 @@
+import { Session } from '@botonic/core'
+
+import { BotonicPluginFlowBuilderOptions, ProcessEnvNodeEnvs } from './types'
+
 export function getWebpackEnvVar(
   webpackEnvVar: string | false,
   name: string,
@@ -9,3 +13,23 @@ export function getWebpackEnvVar(
     defaultValue
   )
 }
+
+function getAccessTokenFromSession(session: Session): string {
+  if (!session._access_token) {
+    throw new Error('No access token found in session')
+  }
+  return session._access_token
+}
+
+export function resolveGetAccessToken(
+  options: BotonicPluginFlowBuilderOptions
+): (session: Session) => string {
+  switch (process.env.NODE_ENV) {
+    case ProcessEnvNodeEnvs.PRODUCTION:
+      return getAccessTokenFromSession
+    case ProcessEnvNodeEnvs.DEVELOPMENT:
+      return options.getAccessToken
+    default:
+      throw new Error('No method defined for getting access token')
+  }
+}