@botonic/core 1.0.0-alpha.0 → 1.0.0-dev.2

package/src/output-parser/parsers.ts

@@ -1,22 +1,31 @@
-import { EventTypes } from '../models/events'
-import { BotonicMessageEvent } from '../models/events/message'
-import { Button, WithButtons } from '../models/events/message/buttons'
 import {
+  AudioMessageEvent,
+  BotonicMessageEvent,
+  Button,
   CarouselElement,
   CarouselMessageEvent,
-} from '../models/events/message/carousel'
-import { CustomMessageEvent } from '../models/events/message/custom'
-import { LocationMessageEvent } from '../models/events/message/location'
-import {
-  AudioMessageEvent,
+  CustomMessageEvent,
   DocumentMessageEvent,
+  EventTypes,
   ImageMessageEvent,
+  LocationMessageEvent,
+  PostbackMessageEvent,
+  Reply,
+  TextMessageEvent,
   VideoMessageEvent,
-} from '../models/events/message/media'
-import { Reply, WithReplies } from '../models/events/message/replies'
-import { TextMessageEvent } from '../models/events/message/text'
-import { TEXT_NODE_NAME } from '.'
-import { parseBoolean, parseNumber } from './util'
+  WithButtons,
+  WithReplies,
+} from '../models'
+import { TEXT_NODE_NAME } from './botonic-output-parser'
+
+export function parseNumber(strNumber: string): number {
+  return parseInt(strNumber)
+}
+
+export function parseBoolean(strNumber: string): boolean {
+  if (strNumber === '0') return false
+  return true
+}
 
 export type ParseFunction<Out> = (args: {
   toParse: any
@@ -41,6 +50,10 @@ export const parseMessage: ParseFunction<BotonicMessageEvent> = args => {
       // Following properties added later before saving event: eventId, userId, createdAt, from, ack
       eventType: EventTypes.MESSAGE,
       type: args.toParse.type,
+      ack: args.toParse.ack,
+      from: args.toParse.from,
+      channel: args.toParse.channel,
+      idFromChannel: args.toParse.idFromChannel,
       ...typingAndDelay,
     },
   }
@@ -109,12 +122,24 @@ export const parseText: ParseFunction<TextMessageEvent> = args => {
     toParse: args.toParse,
     parsed: {
       ...args.parsed,
-      text: args.toParse[TEXT_NODE_NAME] || args.toParse.data,
+      text: args.toParse[TEXT_NODE_NAME],
       markdown: parseBoolean(args.toParse.markdown),
     },
   }
 }
 
+// POSTBACK
+
+export const parsePostback: ParseFunction<PostbackMessageEvent> = args => {
+  return {
+    toParse: args.toParse,
+    parsed: {
+      ...args.parsed,
+      payload: args.toParse.payload,
+    },
+  }
+}
+
 // MEDIA
 export const parseMedia: ParseFunction<
   | AudioMessageEvent
@@ -126,7 +151,7 @@ export const parseMedia: ParseFunction<
     toParse: args.toParse,
     parsed: {
       ...args.parsed,
-      src: args.toParse.src || args.toParse.data,
+      src: args.toParse.src,
     },
   }
 }
@@ -145,12 +170,14 @@ export const parseLocation: ParseFunction<LocationMessageEvent> = args => {
 
 // CAROUSEL
 export const parseElement = (element: any): CarouselElement => {
-  return {
+  const e: CarouselElement = {
     pic: element.pic,
     title: element.title,
     subtitle: element.desc,
-    buttons: element.button.map(b => parseButton(b)),
   }
+  const hasButtons = element.button !== undefined
+  if (hasButtons) e.buttons = element.button.map(b => parseButton(b))
+  return e
 }
 
 export const parseCarousel: ParseFunction<CarouselMessageEvent> = args => {
@@ -169,7 +196,7 @@ export const parseCustom: ParseFunction<CustomMessageEvent> = args => {
     toParse: args.toParse,
     parsed: {
       ...args.parsed,
-      customTypeName: JSON.parse(args.toParse.json).customTypeName,
+      json: JSON.parse(args.toParse.json),
     },
   }
 }

package/src/{plugins.js → plugins.ts}

@@ -1,4 +1,15 @@
-export function loadPlugins(plugins) {
+import {
+  BotonicEvent,
+  BotState,
+  Input,
+  PluginConfig,
+  RoutePath,
+  Session,
+} from './models'
+
+type PluginMode = 'pre' | 'post'
+
+export function loadPlugins(plugins: PluginConfig<any>[]): any {
   if (!plugins) return []
   const _plugins = {}
   const pluginsLength = plugins.length
@@ -17,25 +28,29 @@ export function loadPlugins(plugins) {
 }
 
 export async function runPlugins(
-  plugins,
-  mode,
-  input,
-  session,
-  lastRoutePath,
-  response = null,
-  parsedResponse = null
-) {
+  plugins: any, // // TODO: Add type for resolvedPlugins, they differ from loaded plugins
+  mode: PluginMode,
+  input: Input,
+  session: Session,
+  botState: BotState,
+  response: string | null = null,
+  messageEvents: Partial<BotonicEvent>[] | null = null,
+  dataProvider?: any // TODO: type as dataProvider
+): Promise<void> {
   for (const key in plugins) {
     const p = await plugins[key]
     try {
-      if (mode == 'pre') await p.pre({ input, session, lastRoutePath })
-      if (mode == 'post')
+      if (mode === 'pre')
+        await p.pre({ input, session, botState, dataProvider, plugins })
+      if (mode === 'post')
         await p.post({
           input,
           session,
-          lastRoutePath,
+          botState,
           response,
-          parsedResponse,
+          messageEvents,
+          dataProvider,
+          plugins,
         })
     } catch (e) {
       console.log(e)

package/src/routing/index.ts

@@ -0,0 +1,2 @@
+export * from './router'
+export * from './router-utils'

package/src/routing/router-utils.ts

@@ -0,0 +1,100 @@
+import {
+  EMPTY_ACTION_PATH,
+  NOT_FOUND_PATH,
+  PATH_PAYLOAD_IDENTIFIER,
+  PATH_PAYLOAD_REGEXP,
+} from '../constants'
+import {
+  Action,
+  BotRequest,
+  Input,
+  Params,
+  PathParams,
+  Route,
+  Routes,
+} from '../models'
+
+export class NoMatchingRouteError extends Error {
+  input: Input
+  constructor(input: Input) {
+    super(
+      `No route found for input '${JSON.stringify(
+        input
+      )}' and no ${NOT_FOUND_PATH} route defined`
+    )
+    this.input = input
+  }
+}
+
+export function isPathPayload(payload?: string): boolean {
+  if (!payload) return false
+  const isPathPayload = PATH_PAYLOAD_REGEXP.exec(payload)
+  return Boolean(isPathPayload)
+}
+
+export function getPathParamsFromPathPayload(payload?: string): PathParams {
+  const defaultPathParams = {
+    path: null,
+    params: {},
+  }
+  if (!payload) return defaultPathParams
+  if (!isPathPayload(payload)) return defaultPathParams
+  try {
+    const pathWithParams = payload.split(PATH_PAYLOAD_IDENTIFIER)[1]
+    if (!pathWithParams) {
+      throw `${PATH_PAYLOAD_IDENTIFIER} is empty`
+    }
+    const [path, params] = pathWithParams.split('?')
+    return { path: path ?? null, params: pathParamsToParams(params) }
+  } catch (e) {
+    console.error('Error getting path and params from input.payload:', e)
+    return defaultPathParams
+  }
+}
+
+export function pathParamsToParams(pathParams?: string): Params {
+  if (!pathParams) return {}
+  try {
+    const params = {}
+    const searchParams = new URLSearchParams(pathParams)
+    for (const [key, value] of searchParams) {
+      params[key] = value
+    }
+    return params
+  } catch (e) {
+    return {}
+  }
+}
+
+export function getEmptyAction(childRoutes?: Route[]): Action {
+  if (!childRoutes) return null
+  const emptyActionRoute = childRoutes.find(r => r.path === EMPTY_ACTION_PATH)
+  if (!emptyActionRoute) return null
+  return emptyActionRoute.action
+}
+
+export function getNotFoundAction(input: Input, routes: Route[]): Action {
+  const notFoundActionRoute = routes.find(r => r.path === NOT_FOUND_PATH)
+  if (!notFoundActionRoute) throw new NoMatchingRouteError(input)
+  return notFoundActionRoute.action
+}
+
+export async function getComputedRoutes(
+  routes: Routes,
+  request: BotRequest
+): Promise<Route[]> {
+  if (routes instanceof Function) {
+    return await getComputedRoutes(await routes(request), request)
+  }
+  for (const [key, route] of Object.entries(routes) as any) {
+    if (route.childRoutes && route.childRoutes instanceof Function) {
+      routes[key].childRoutes = await getComputedRoutes(
+        await route.childRoutes(request),
+        request
+      )
+    } else {
+      routes[key] = route
+    }
+  }
+  return routes
+}

package/src/routing/router.ts

@@ -0,0 +1,415 @@
+import { NOT_FOUND_PATH } from '../constants'
+import { RouteInspector } from '../debug/inspector'
+import {
+  BotState,
+  Input,
+  MatchedValue,
+  Matcher,
+  MatchingProp,
+  Nullable,
+  ProcessInputResult,
+  Route,
+  RouteParams,
+  RoutePath,
+  RoutingState,
+  Session,
+} from '../models'
+import { cloneObject } from '../utils'
+import {
+  getEmptyAction,
+  getNotFoundAction,
+  getPathParamsFromPathPayload,
+  isPathPayload,
+} from './router-utils'
+
+export class Router {
+  routes: Route[]
+  routeInspector: RouteInspector
+
+  constructor(
+    routes: Route[],
+    routeInspector: RouteInspector | undefined = undefined
+  ) {
+    this.routes = routes
+    this.routeInspector = routeInspector || new RouteInspector()
+  }
+
+  /**
+   * Processes an input and return a representation of the new bot state.
+   * The algorithm is splitted in two main parts:
+   * 1. Getting the current routing state.
+   * 2. Given a routing state, resolve the different possible scenarios and return the new bot state.
+   * The new bot state can return three type of actions:
+   * - action: an action directly resolved from a matching route
+   * - emptyAction: optional action that can exists or not only within childRoutes
+   * - fallbackAction: any other action that acts as a fallback (404, )
+   */
+
+  // eslint-disable-next-line complexity
+  processInput(
+    input: Input,
+    session: Session,
+    botState: BotState
+  ): ProcessInputResult {
+    botState.retries = botState.retries ?? 0
+
+    // 1. Getting the current routing state.
+    const {
+      currentRoute,
+      matchedRoute,
+      params,
+      isFlowBroken,
+    } = this.getRoutingState(input, session, botState)
+
+    const currentRoutePath = currentRoute?.path ?? null
+    const matchedRoutePath = matchedRoute?.path ?? null
+
+    // 2. Given a routing state, resolve the different possible scenarios and return the new bot state.
+
+    /**
+     * Redirect Scenario:
+     * We have matched a redirect route with a given redirection path, so we try to obtain the redirectionRoute with getRouteByPath.
+     * Independently of whether the redirectionRoute is found or not, the intent is to trigger a redirection which by definition breaks the flow, so retries are set to 0.
+     * It has preference over ignoring retries.
+     */
+    if (matchedRoute && matchedRoute.redirect) {
+      botState.retries = 0
+      const redirectionRoute = this.getRouteByPath(matchedRoute.redirect)
+      if (redirectionRoute) {
+        botState.lastRoutePath = matchedRoute.redirect
+        return {
+          action: redirectionRoute.action,
+          emptyAction: getEmptyAction(redirectionRoute.childRoutes),
+          fallbackAction: null,
+          botState,
+          params,
+        }
+      }
+      botState.lastRoutePath = null
+      return {
+        action: null,
+        emptyAction: null,
+        fallbackAction: getNotFoundAction(input, this.routes),
+        botState,
+        params,
+      }
+    }
+
+    /**
+     * Ignore Retry Scenario:
+     * We have matched a route with an ignore retry, so we return directly the new bot state. The intent is to break the flow, so retries are set to 0.
+     */
+    if (matchedRoute && matchedRoute.ignoreRetry) {
+      botState.retries = 0
+      botState.lastRoutePath = matchedRoutePath
+      return {
+        action: matchedRoute.action,
+        emptyAction: getEmptyAction(matchedRoute.childRoutes),
+        fallbackAction: null,
+        botState,
+        params,
+      }
+    }
+
+    /**
+     * Retry Scenario:
+     * We were in a route which had retries enabled, so we check if the number of retries is exceeded.
+     * If we have not surpassed the limit of retries and we haven't matched an ignoreRetry route, update them, and then return the new bot state.
+     */
+    if (
+      isFlowBroken &&
+      currentRoute &&
+      currentRoute.retry &&
+      botState.retries < currentRoute.retry
+    ) {
+      botState.retries = botState.retries !== 0 ? botState.retries + 1 : 1
+      botState.lastRoutePath = currentRoutePath
+      if (matchedRoute && matchedRoutePath !== NOT_FOUND_PATH) {
+        return {
+          action: currentRoute.action,
+          emptyAction: getEmptyAction(matchedRoute.childRoutes),
+          fallbackAction: matchedRoute.action,
+          botState,
+          params,
+        }
+      }
+      return {
+        action: currentRoute.action ?? null,
+        emptyAction: getEmptyAction(currentRoute.childRoutes),
+        fallbackAction: getNotFoundAction(input, this.routes),
+        botState,
+        params,
+      }
+    }
+
+    /**
+     * Default Scenario:
+     * We have matched a route or not, but we don't need to execute retries logic, so retries stay to 0.
+     */
+    botState.retries = 0
+
+    /**
+     * Matching Route Scenario:
+     * We have matched a route, so we return the new bot state.
+     */
+    if (matchedRoute && matchedRoutePath !== NOT_FOUND_PATH) {
+      botState.lastRoutePath = matchedRoutePath
+      return {
+        action: matchedRoute.action ?? null,
+        emptyAction: getEmptyAction(matchedRoute.childRoutes),
+        fallbackAction: null,
+        botState,
+        params,
+      }
+    }
+
+    /**
+     * 404 Scenario (No Route Found):
+     * We have not matched any route, so we return the new bot state.
+     */
+    botState.lastRoutePath = currentRoutePath
+    return {
+      action: null,
+      emptyAction: null,
+      fallbackAction: getNotFoundAction(input, this.routes),
+      params,
+      botState,
+    }
+  }
+
+  /**
+   * Find the route that matches the given input, if it match with some of the entries, return the whole Route of the entry with optional params captured if matcher was a regex.
+   * IMPORTANT: It returns a cloned route instead of the route itself to avoid modifying original routes and introduce side effects
+   * */
+  getRoute(
+    input: Input | Partial<Input>,
+    routes: Route[],
+    session: Session,
+    lastRoutePath: RoutePath
+  ): RouteParams | null {
+    let params = {}
+    const route = routes.find(r =>
+      Object.entries(r)
+        .filter(
+          ([key, _]) =>
+            key !== 'action' && key !== 'childRoutes' && key !== 'path'
+        )
+        .some(([key, value]) => {
+          const match = this.matchRoute(
+            r,
+            key as MatchingProp,
+            value as Matcher,
+            input as Input,
+            session,
+            lastRoutePath
+          )
+          try {
+            if (match !== null && typeof match !== 'boolean' && match.groups) {
+              // Strip '[Object: null prototype]' from groups result: https://stackoverflow.com/a/62945609/6237608
+              params = { ...match.groups }
+            }
+          } catch (e) {}
+          return Boolean(match)
+        })
+    )
+    if (route) return { route: cloneObject(route), params }
+    return null
+  }
+
+  /**
+   * Find the route that matches the given path. Path can include concatenations, e.g: 'Flow1/Subflow1.1'.
+   * IMPORTANT: It returns a cloned route instead of the route itself to avoid modifying original routes and introduce side effects
+   * */
+  getRouteByPath(
+    path: RoutePath,
+    routeList: Route[] = this.routes
+  ): Nullable<Route> {
+    if (!path) return null
+    const [currentPath, ...childPath] = path.split('/')
+    for (const route of routeList) {
+      // iterate over all routeList
+      if (route.path === currentPath) {
+        if (
+          route.childRoutes &&
+          route.childRoutes.length &&
+          childPath.length > 0
+        ) {
+          // evaluate childroute over next actions
+          const computedRoute = this.getRouteByPath(
+            childPath.join('/'),
+            route.childRoutes
+          )
+          // IMPORTANT: Returning a new object to avoid modifying dev routes and introduce side effects
+          if (computedRoute) return cloneObject(computedRoute)
+        } else if (childPath.length === 0) {
+          return cloneObject(route) // last action and found route
+        }
+      }
+    }
+    return null
+  }
+
+  /**
+   * Returns the matched value for a specific route.
+   * Matching Props: ('text' | 'payload' | 'intent' | 'type' | 'input' | 'session' | 'request' ...)
+   * Matchers: (string: exact match | regex: regular expression match | function: return true)
+   * input: user input object, e.g.: {type: 'text', data: 'Hi'}
+   * */
+  matchRoute(
+    route: Route,
+    prop: MatchingProp,
+    matcher: Matcher,
+    input: Input,
+    session: Session,
+    lastRoutePath: RoutePath
+  ): MatchedValue {
+    let value: any = null
+    if (Object.keys(input).indexOf(prop) > -1) value = input[prop]
+    else if (prop === 'input') value = input
+    else if (prop === 'session') value = session
+    else if (prop === 'request') value = { input, session, lastRoutePath }
+    const matched = this.matchValue(matcher, value)
+    if (matched) {
+      this.routeInspector.routeMatched(route, prop, matcher, value)
+    } else {
+      this.routeInspector.routeNotMatched(route, prop, matcher, value)
+    }
+    return matched
+  }
+
+  /**
+   * Runs the matcher against the given value.
+   * If there is a match, it will return a truthy value (true, RegExp result), o.w., it will return a falsy value.
+   * */
+  matchValue(matcher: Matcher, value: any): MatchedValue {
+    if (typeof matcher === 'string') return value === matcher
+    if (matcher instanceof RegExp) {
+      if (value === undefined || value === null) return false
+      return matcher.exec(value)
+    }
+    if (typeof matcher === 'function') return matcher(value)
+    return false
+  }
+
+  /**
+   * It resolves the current state of navigation. Two scenarios:
+   * 1. Given a path payload input (__PATH_PAYLOAD__somePath?someParam=someValue), we can resolve the routing state directly from it (using getRouteByPath).
+   * 2. Given any other type of input, we resolve the routing state with normal resolution (using getRoute).
+   * */
+  getRoutingState(
+    input: Input,
+    session: Session,
+    botState: BotState
+  ): RoutingState {
+    const currentRoute = this.getRouteByPath(botState.lastRoutePath)
+    if (currentRoute && botState.lastRoutePath)
+      currentRoute.path = botState.lastRoutePath
+    if (typeof input.payload === 'string' && isPathPayload(input.payload)) {
+      return this.getRoutingStateFromPathPayload(currentRoute, input.payload)
+    }
+    return this.getRoutingStateFromInput(currentRoute, input, session)
+  }
+
+  /**
+   * Given a non path payload input, try to run it against the routes, update matching routes information in consequence and dictamine if the flow has been broken.
+   * */
+  getRoutingStateFromInput(
+    currentRoute: Nullable<Route>,
+    input: Input,
+    session: Session
+  ): RoutingState {
+    // get route depending of current ChildRoutes
+    if (currentRoute && currentRoute.childRoutes) {
+      const routeParams = this.getRoute(
+        input,
+        currentRoute.childRoutes,
+        session,
+        currentRoute.path
+      )
+      if (routeParams) {
+        return {
+          currentRoute,
+          matchedRoute: {
+            ...routeParams.route,
+            path:
+              routeParams.route && currentRoute.path
+                ? `${currentRoute.path}/${routeParams.route.path}`
+                : currentRoute.path,
+          },
+          params: routeParams.params,
+          isFlowBroken: false,
+        }
+      }
+    }
+    /**
+     * we couldn't find a route in the state of the currentRoute childRoutes,
+     * so let's find in the general routes
+     */
+    const routeParams = this.getRoute(
+      input,
+      this.routes,
+      session,
+      currentRoute?.path ?? null
+    )
+    const isFlowBroken = Boolean(currentRoute?.path)
+    if (routeParams?.route) {
+      return {
+        currentRoute,
+        matchedRoute: {
+          ...routeParams.route,
+          path: routeParams.route?.path ?? null,
+        },
+        params: routeParams.params,
+        isFlowBroken,
+      }
+    }
+    return {
+      currentRoute,
+      matchedRoute: null,
+      params: {},
+      isFlowBroken,
+    }
+  }
+
+  /**
+   * Given a path payload input, try to run the path against the routes, update matching routes information in consequence and dictamine if the flow has been broken.
+   * */
+  getRoutingStateFromPathPayload(
+    currentRoute: Nullable<Route>,
+    pathPayload: string
+  ): RoutingState {
+    const { path, params } = getPathParamsFromPathPayload(pathPayload)
+    /**
+     * shorthand function to update the matching information given a path
+     */
+    const getRoutingStateFromPath = (seekPath: string): RoutingState => {
+      const matchedRoute = this.getRouteByPath(seekPath)
+      if (!matchedRoute) {
+        return {
+          currentRoute,
+          matchedRoute: null,
+          params: {},
+          isFlowBroken: true,
+        }
+      }
+      return {
+        currentRoute,
+        matchedRoute: { ...matchedRoute, path: seekPath },
+        params,
+        isFlowBroken: false,
+      }
+    }
+    /**
+     * Given a valid path: 'Flow1/Subflow1' we are in one of the two scenarios below.
+     */
+    //  1. Received __PATH_PAYLOAD__Subflow2, so we need to first try to concatenate it with Flow1 (lastRoutePath)
+    if (currentRoute?.path) {
+      const routingState = getRoutingStateFromPath(
+        `${currentRoute.path}/${path}`
+      )
+      if (routingState.matchedRoute) return routingState
+    }
+    // 2. Received __PATH_PAYLOAD__Flow1/Subflow1, so we can resolve it directly
+    return getRoutingStateFromPath(path as string)
+  }
+}