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

package/src/plugins.ts

@@ -1,5 +1,11 @@
-import { Input, PluginConfig, Session } from './index'
-import { BotonicEvent } from './models/events'
+import {
+  BotonicEvent,
+  BotState,
+  Input,
+  PluginConfig,
+  RoutePath,
+  Session,
+} from './models'
 
 type PluginMode = 'pre' | 'post'
 
@@ -26,21 +32,25 @@ export async function runPlugins(
   mode: PluginMode,
   input: Input,
   session: Session,
-  lastRoutePath: string,
+  botState: BotState,
   response: string | null = null,
-  parsedResponse: Partial<BotonicEvent>[] | 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)
+  }
+}

package/src/utils.ts

@@ -42,10 +42,16 @@ export const isMobile = (mobileBreakpoint = 460): boolean => {
   }
   return false
 }
+
 export function isFunction(o: any): boolean {
   return typeof o === 'function'
 }
 
+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]: any) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`)

package/lib/cjs/errors.d.ts

@@ -1,5 +0,0 @@
-import { Input } from './index';
-export declare class NoMatchingRouteError extends Error {
-    input: Input;
-    constructor(input: Input);
-}

package/lib/cjs/errors.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NoMatchingRouteError = void 0;
-class NoMatchingRouteError extends Error {
-    constructor(input) {
-        super(`No route found for input '${String(input)}' and no 404 route defined`);
-        this.input = input;
-    }
-}
-exports.NoMatchingRouteError = NoMatchingRouteError;
-//# sourceMappingURL=errors.js.map

package/lib/cjs/errors.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"errors.js","sourceRoot":"","sources":["../../src/errors.ts"],"names":[],"mappings":";;;AAEA,MAAa,oBAAqB,SAAQ,KAAK;IAE7C,YAAY,KAAY;QACtB,KAAK,CACH,6BAA6B,MAAM,CAAC,KAAK,CAAC,4BAA4B,CACvE,CAAA;QACD,IAAI,CAAC,KAAK,GAAG,KAAK,CAAA;IACpB,CAAC;CACF;AARD,oDAQC"}

package/lib/cjs/models/events/connections/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../src/models/events/connections/index.ts"],"names":[],"mappings":";;;AAEA,IAAY,uBAGX;AAHD,WAAY,uBAAuB;IACjC,kDAAuB,CAAA;IACvB,wDAA6B,CAAA;AAC/B,CAAC,EAHW,uBAAuB,GAAvB,+BAAuB,KAAvB,+BAAuB,QAGlC"}

package/lib/cjs/output-parser/util.d.ts

@@ -1,2 +0,0 @@
-export declare function parseNumber(strNumber: string): number;
-export declare function parseBoolean(strNumber: string): boolean;

package/lib/cjs/output-parser/util.js

@@ -1,14 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseBoolean = exports.parseNumber = void 0;
-function parseNumber(strNumber) {
-    return parseInt(strNumber);
-}
-exports.parseNumber = parseNumber;
-function parseBoolean(strNumber) {
-    if (strNumber === '0')
-        return false;
-    return true;
-}
-exports.parseBoolean = parseBoolean;
-//# sourceMappingURL=util.js.map

package/lib/cjs/output-parser/util.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"util.js","sourceRoot":"","sources":["../../../src/output-parser/util.ts"],"names":[],"mappings":";;;AAAA,SAAgB,WAAW,CAAC,SAAiB;IAC3C,OAAO,QAAQ,CAAC,SAAS,CAAC,CAAA;AAC5B,CAAC;AAFD,kCAEC;AAED,SAAgB,YAAY,CAAC,SAAiB;IAC5C,IAAI,SAAS,KAAK,GAAG;QAAE,OAAO,KAAK,CAAA;IACnC,OAAO,IAAI,CAAA;AACb,CAAC;AAHD,oCAGC"}

package/lib/cjs/router.d.ts

@@ -1,35 +0,0 @@
-import { RouteInspector } from './debug/inspector';
-import { Input, Route, Routes, Session } from './index';
-interface RouteParams {
-    route: Route;
-    params: any;
-}
-declare type MatchingProp = 'text' | 'payload' | 'intent' | 'type' | 'input' | 'session' | 'request';
-declare type Matcher = string | RegExp | ((args: any) => boolean);
-export declare class Router {
-    routes: Routes;
-    routeInspector: RouteInspector;
-    lastRoutePath: string | null;
-    /**
-     * @param {Route[]} routes
-     * @param routeInspector
-     */
-    constructor(routes: Routes, routeInspector?: RouteInspector | undefined);
-    processInput(input: Input, session?: Partial<Session>, lastRoutePath?: string | null): any;
-    getOnFinishParams(input: Input): string | undefined;
-    /**
-     * @return {null|RouteParams}
-     */
-    getRoute(input: Input | Partial<Input>, routes: Routes, session: Session, lastRoutePath: string | null): RouteParams | null;
-    getRouteByPath(path: string | null, routeList?: Routes | null): Route | null;
-    /**
-     * @return {Params|boolean}
-     */
-    matchRoute(route: Route, prop: MatchingProp, matcher: Matcher, input: Input, session: Session, lastRoutePath: string | null): any;
-    /**
-     *
-     * @return {*|boolean|Params}
-     */
-    matchValue(matcher: string | RegExp | ((args: any) => boolean), value: any): boolean;
-}
-export {};