@botonic/core 0.19.0-beta.1 → 0.20.1

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

@@ -1,4 +1,9 @@
-export function loadPlugins(plugins) {
+import { DataProvider } from './data-provider'
+import { BotonicEvent, 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 +22,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,
+  lastRoutePath: RoutePath,
+  response: string | null = null,
+  messageEvents: Partial<BotonicEvent>[] | null = null,
+  dataProvider?: 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, lastRoutePath, dataProvider, plugins })
+      if (mode === 'post')
         await p.post({
           input,
           session,
           lastRoutePath,
           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,409 @@
+import { NOT_FOUND_PATH } from '../constants'
+import { RouteInspector } from '../debug/inspector'
+import {
+  Input,
+  MatchedValue,
+  Matcher,
+  MatchingProp,
+  Nullable,
+  ProcessInputResult,
+  Route,
+  RouteParams,
+  RoutePath,
+  RoutingState,
+  Session,
+} from '../models'
+import { cloneObject } from '../utils'
+import {
+  getEmptyAction,
+  getNotFoundAction,
+  getPathParamsFromPathPayload,
+  isPathPayload,
+  pathParamsToParams,
+} 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,
+    lastRoutePath: RoutePath = null
+  ): ProcessInputResult {
+    session.__retries = session?.__retries ?? 0
+
+    // 1. Getting the current routing state.
+    const {
+      currentRoute,
+      matchedRoute,
+      params,
+      isFlowBroken,
+    } = this.getRoutingState(input, session, lastRoutePath)
+
+    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) {
+      session.__retries = 0
+      const redirectionRoute = this.getRouteByPath(matchedRoute.redirect)
+      if (redirectionRoute) {
+        return {
+          action: redirectionRoute.action,
+          emptyAction: getEmptyAction(redirectionRoute.childRoutes),
+          fallbackAction: null,
+          lastRoutePath: matchedRoute.redirect,
+          params,
+        }
+      }
+      return {
+        action: null,
+        emptyAction: null,
+        fallbackAction: getNotFoundAction(input, this.routes),
+        lastRoutePath: null,
+        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) {
+      session.__retries = 0
+      return {
+        action: matchedRoute.action,
+        emptyAction: getEmptyAction(matchedRoute.childRoutes),
+        fallbackAction: null,
+        lastRoutePath: matchedRoutePath,
+        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 &&
+      session.__retries < currentRoute.retry
+    ) {
+      session.__retries = session.__retries !== 0 ? session.__retries + 1 : 1
+      if (matchedRoute && matchedRoutePath !== NOT_FOUND_PATH) {
+        return {
+          action: currentRoute.action,
+          emptyAction: getEmptyAction(matchedRoute.childRoutes),
+          fallbackAction: matchedRoute.action,
+          lastRoutePath: currentRoutePath,
+          params,
+        }
+      }
+      return {
+        action: currentRoute.action ?? null,
+        emptyAction: getEmptyAction(currentRoute.childRoutes),
+        fallbackAction: getNotFoundAction(input, this.routes),
+        lastRoutePath: currentRoutePath,
+        params,
+      }
+    }
+
+    /**
+     * Default Scenario:
+     * We have matched a route or not, but we don't need to execute retries logic, so retries stay to 0.
+     */
+    session.__retries = 0
+
+    /**
+     * Matching Route Scenario:
+     * We have matched a route, so we return the new bot state.
+     */
+    if (matchedRoute && matchedRoutePath !== NOT_FOUND_PATH) {
+      return {
+        action: matchedRoute.action ?? null,
+        emptyAction: getEmptyAction(matchedRoute.childRoutes),
+        fallbackAction: null,
+        lastRoutePath: matchedRoutePath,
+        params,
+      }
+    }
+
+    /**
+     * 404 Scenario (No Route Found):
+     * We have not matched any route, so we return the new bot state.
+     */
+    return {
+      action: null,
+      emptyAction: null,
+      fallbackAction: getNotFoundAction(input, this.routes),
+      params,
+      lastRoutePath: currentRoutePath,
+    }
+  }
+
+  /**
+   * 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 === 'text') value = input.data
+    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,
+    lastRoutePath: RoutePath
+  ): RoutingState {
+    const currentRoute = this.getRouteByPath(lastRoutePath)
+    if (currentRoute && lastRoutePath) currentRoute.path = 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)
+  }
+}

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

@@ -1,22 +1,28 @@
-export const isNode = () => {
+export const isNode = (): boolean => {
+  // @ts-ignore
   return typeof IS_NODE !== 'undefined'
-    ? // eslint-disable-next-line no-undef
+    ? // @ts-ignore
       IS_NODE
     : typeof process !== 'undefined' &&
         process.versions !== null &&
         process.versions.node !== null
 }
 
-export const isBrowser = () => {
+export const isBrowser = (): boolean => {
+  // @ts-ignore
   return typeof IS_BROWSER !== 'undefined'
-    ? // eslint-disable-next-line no-undef
+    ? // @ts-ignore
       IS_BROWSER
     : typeof window !== 'undefined' &&
         typeof window.document !== 'undefined' &&
         !window.process
 }
 
-export function getWebpackEnvVar(webpackEnvVar, name, defaultValue) {
+export function getWebpackEnvVar(
+  webpackEnvVar: string | false,
+  name: string,
+  defaultValue: string
+): string {
   return (
     webpackEnvVar ||
     (typeof process !== 'undefined' && process.env[name]) ||
@@ -24,7 +30,7 @@ export function getWebpackEnvVar(webpackEnvVar, name, defaultValue) {
   )
 }
 
-export const isMobile = (mobileBreakpoint = 460) => {
+export const isMobile = (mobileBreakpoint = 460): boolean => {
   if (isBrowser()) {
     const w = Math.max(
       document.documentElement.clientWidth,
@@ -36,26 +42,32 @@ export const isMobile = (mobileBreakpoint = 460) => {
   }
   return false
 }
-export function isFunction(o) {
+
+export function isFunction(o: any): boolean {
   return typeof o === 'function'
 }
 
-export const params2queryString = params =>
+export function cloneObject(object: any): any {
+  if (!object) return {}
+  return { ...object }
+}
+
+export const params2queryString = (params: { [key: string]: string }): string =>
   Object.entries(params)
-    .map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`)
+    .map(([k, v]: any) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`)
     .join('&')
 
 // Joins path segments.  Preserves initial "/" and resolves ".." and "."
 // Does not support using ".." to go above/outside the root.
 // This means that join("foo", "../../bar") will not resolve to "../bar"
-export const join = (...segments) => {
+export const join = (...segments: string[]): string => {
   // Split the inputs into a list of path commands.
-  let parts = []
+  let parts: string[] = []
   for (let i = 0, l = segments.length; i < l; i++) {
     parts = parts.concat(segments[i].split('/'))
   }
   // Interpret the path commands to get the new resolved path.
-  const newParts = []
+  const newParts: string[] = []
   for (let i = 0, l = parts.length; i < l; i++) {
     const part = parts[i]
     // Remove leading and trailing slashes
@@ -67,6 +79,7 @@ export const join = (...segments) => {
     else newParts.push(part)
   }
   // Preserve the initial slash if there was one.
+  // @ts-ignore
   if (parts[0] === '') newParts.unshift('')
   // Turn back into a single string path.
   return newParts.join('/') || (newParts.length ? '/' : '.')
@@ -74,4 +87,4 @@ export const join = (...segments) => {
 
 // A simple function to get the dirname of a path
 // Trailing slashes are ignored. Leading slash is preserved.
-export const dirname = path => join(path, '..')
+export const dirname = (path: string): string => join(path, '..')

package/index.d.ts

@@ -1 +0,0 @@
-export * from './src'

package/lib/constants.d.ts

@@ -1,15 +0,0 @@
-export const Providers: Readonly<{
-    Messaging: {
-        TELEGRAM: string;
-        WECHAT: string;
-        FACEBOOK: string;
-        INTERCOM: string;
-        GENERIC: string;
-        TWITTER: string;
-        WHATSAPP: string;
-        SMOOCH: string;
-        SMOOCH_WEB: string;
-        IMBEE: string;
-        WEBCHAT: string;
-    };
-}>;

package/lib/constants.js

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Providers = void 0;
-exports.Providers = Object.freeze({
-    Messaging: {
-        TELEGRAM: 'telegram',
-        WECHAT: 'wechat',
-        FACEBOOK: 'facebook',
-        INTERCOM: 'intercom',
-        GENERIC: 'generic',
-        TWITTER: 'twitter',
-        WHATSAPP: 'whatsapp',
-        SMOOCH: 'smooch',
-        SMOOCH_WEB: 'smooch_web',
-        IMBEE: 'imbee',
-        WEBCHAT: 'webchat',
-    },
-});
-//# sourceMappingURL=constants.js.map