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

package/src/router.js

@@ -1,273 +0,0 @@
-import { RouteInspector } from './debug/inspector'
-import { NoMatchingRouteError } from './errors'
-import { isFunction } from './utils'
-
-export class Router {
-  /**
-   * @param {Route[]} routes
-   * @param routeInspector
-   */
-  constructor(routes, routeInspector = undefined) {
-    this.routes = routes
-    this.routeInspector = routeInspector || new RouteInspector()
-  }
-
-  // eslint-disable-next-line complexity
-  processInput(input, session = {}, lastRoutePath = null) {
-    let routeParams = {}
-    if (input.payload && input.payload.includes('__PATH_PAYLOAD__')) {
-      const pathParam = input.payload.split('__PATH_PAYLOAD__')
-      routeParams.route = this.getRouteByPath(pathParam[1], this.routes)
-    }
-    const pathParams = this.getOnFinishParams(input)
-    let brokenFlow = false
-    const lastRoute = this.getRouteByPath(lastRoutePath, this.routes)
-    if (!lastRoute && input.path)
-      routeParams.route = this.getRouteByPath(input.path, this.routes)
-    if (lastRoute && lastRoute.childRoutes && !routeParams.route)
-      //get route depending of current ChildRoute
-      routeParams = this.getRoute(
-        input,
-        lastRoute.childRoutes,
-        session,
-        lastRoutePath
-      )
-    if (!routeParams || !Object.keys(routeParams).length) {
-      /*
-          we couldn't find a route in the state of the lastRoute, so let's find in
-          the general conf.route
-        */
-      brokenFlow = Boolean(lastRoutePath)
-      routeParams = this.getRoute(input, this.routes, session, lastRoutePath)
-    }
-    try {
-      if (pathParams) {
-        const searchParams = new URLSearchParams(pathParams)
-        for (const [key, value] of searchParams) {
-          routeParams.params
-            ? (routeParams.params[key] = value)
-            : (routeParams.params = { [key]: value })
-        }
-      }
-    } catch (e) {}
-    if (routeParams && Object.keys(routeParams).length) {
-      //get in childRoute if one has path ''
-      let defaultAction
-      if (routeParams.route) {
-        if (
-          !routeParams.route.path &&
-          routeParams.route.childRoutes &&
-          routeParams.route.childRoutes.length
-        ) {
-          defaultAction = this.getRoute(
-            { path: '' },
-            routeParams.route.childRoutes,
-            session,
-            lastRoutePath
-          )
-        }
-        if ('action' in routeParams.route) {
-          if (
-            brokenFlow &&
-            routeParams.route.ignoreRetry != true &&
-            lastRoute &&
-            (session.__retries || 0) < (lastRoute.retry || 0) &&
-            routeParams.route.path != lastRoute.action
-          ) {
-            session.__retries = session.__retries ? session.__retries + 1 : 1
-            // The flow was broken, but we want to recover it
-            return {
-              action: routeParams.route.action,
-              params: routeParams.params,
-              retryAction: lastRoute ? lastRoute.action : null,
-              defaultAction: defaultAction ? defaultAction.route.action : null,
-              lastRoutePath: lastRoutePath,
-            }
-          } else {
-            session.__retries = 0
-            if (lastRoutePath && !brokenFlow)
-              lastRoutePath = `${lastRoutePath}/${routeParams.route.path}`
-            else lastRoutePath = routeParams.route.path
-            return {
-              action: routeParams.route.action,
-              params: routeParams.params,
-              retryAction: null,
-              defaultAction: defaultAction ? defaultAction.route.action : null,
-              lastRoutePath: lastRoutePath,
-            }
-          }
-        } else if (defaultAction) {
-          return {
-            action: defaultAction.route.action,
-            params: defaultAction.params,
-            lastRoutePath: lastRoutePath,
-          }
-        } else if ('redirect' in routeParams.route) {
-          lastRoutePath = routeParams.route.redirect
-          const redirectRoute = this.getRouteByPath(lastRoutePath, this.routes)
-          if (redirectRoute) {
-            return {
-              action: redirectRoute.action,
-              params: redirectRoute.params,
-              lastRoutePath: lastRoutePath,
-            }
-          }
-        }
-      }
-    }
-    const notFound = this.getRouteByPath('404', this.routes)
-    if (!notFound) throw new NoMatchingRouteError(input)
-    if (lastRoute && (session.__retries || 0) < (lastRoute.retry || 0)) {
-      session.__retries = session.__retries ? session.__retries + 1 : 1
-      return {
-        action: notFound.action,
-        params: {},
-        retryAction: lastRoute.action,
-        lastRoutePath: lastRoutePath,
-      }
-    } else {
-      this.lastRoutePath = null
-      session.__retries = 0
-      return {
-        action: notFound.action,
-        params: {},
-        retryAction: null,
-        lastRoutePath: lastRoutePath,
-      }
-    }
-  }
-
-  /**
-   * @param {Input} input
-   * @return {string|undefined}
-   */
-  getOnFinishParams(input) {
-    try {
-      if (!input.payload) {
-        return undefined
-      }
-      const params = input.payload.split('__PATH_PAYLOAD__')
-      if (params.length < 2) {
-        return undefined
-      }
-      const pathParams = params[1].split('?')
-      if (pathParams.length > 0) {
-        input.path = pathParams[0]
-        delete input.payload
-      }
-      if (pathParams.length > 1) {
-        return pathParams[1]
-      }
-    } catch (e) {
-      console.error('ERROR getOnFinishParams', e)
-    }
-    return undefined
-  }
-
-  /**
-   * @return {null|RouteParams}
-   */
-  getRoute(input, routes, session, lastRoutePath) {
-    const computedRoutes = isFunction(routes)
-      ? routes({ input, session, lastRoutePath })
-      : routes
-    /* 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 */
-    /** @type {{ [key: string]: string }}*/
-    let params = {}
-    const route = computedRoutes.find(r =>
-      Object.entries(r)
-        .filter(([key, {}]) => key != 'action' && key != 'childRoutes')
-        .some(([key, value]) => {
-          const match = this.matchRoute(
-            r,
-            key,
-            value,
-            input,
-            session,
-            lastRoutePath
-          )
-          try {
-            params = match.groups
-          } catch (e) {}
-          return Boolean(match)
-        })
-    )
-    if (route) {
-      return { route, params }
-    }
-    return null
-  }
-
-  /**
-   * @param {string|null} path
-   * @param {Route[]?} routeList
-   * @return {null|Route}
-   */
-  getRouteByPath(path, routeList = null) {
-    if (!path) return null
-    let route = null
-    routeList = routeList || this.routes
-    const [currentPath, ...childPath] = path.split('/')
-    for (const r of routeList) {
-      //iterate over all routeList
-      if (r.path == currentPath) {
-        route = r
-        if (r.childRoutes && r.childRoutes.length && childPath.length > 0) {
-          //evaluate childroute over next actions
-          route = this.getRouteByPath(childPath.join('/'), r.childRoutes)
-          if (route) return route
-        } else if (childPath.length === 0) return route //last action and found route
-      }
-    }
-    return null
-  }
-
-  /**
-   * @return {Params|boolean}
-   */
-  matchRoute(route, prop, matcher, input, session, lastRoutePath) {
-    /*
-        prop: ('text' | 'payload' | 'intent' | 'type' | 'input' | 'session' | 'request' ...)
-        matcher: (string: exact match | regex: regular expression match | function: return true)
-        input: user input object, ex: {type: 'text', data: 'Hi'}
-      */
-    /** @type {any} */
-    let value = ''
-    if (Object.keys(input).indexOf(prop) > -1) value = input[prop]
-    if (prop === 'text') {
-      if (input.type === '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
-  }
-
-  /**
-   *
-   * @return {*|boolean|Params}
-   */
-  matchValue(matcher, value) {
-    if (typeof matcher === 'string') {
-      // TODO should this be === to avoid matching '' with undefined?
-      return value == matcher
-    }
-    if (matcher instanceof RegExp) {
-      // check if undefined to avoid conversion to 'undefined'
-      if (value === undefined) {
-        return false
-      }
-      return matcher.exec(value)
-    }
-    if (typeof matcher === 'function') {
-      return matcher(value)
-    }
-    return false
-  }
-}

package/src/router.test.js

@@ -1,347 +0,0 @@
-import { NoMatchingRouteError } from './errors'
-import { PROVIDER } from './index'
-import { Router } from './router'
-
-/** @type Input */
-const textInput = { type: 'text', data: 'hi' }
-/** @type Input */
-const textInputComplex = { type: 'text', data: 'Cömplêx input &% 🚀' }
-/** @type Input */
-const textPayloadInput = { type: 'text', data: 'hi', payload: 'foo' }
-/** @type Input */
-const postbackInput = { type: 'postback', payload: 'foo' }
-
-const requestInput = {
-  input: textInput,
-  session: { organization: 'myOrg' },
-  lastRoutePath: 'initial',
-}
-
-/**
- * @return {Route}
- */
-function testRoute() {
-  return {}
-}
-
-/**
- * @return {Session}
- */
-function testSession() {
-  return {
-    user: { id: 'userid', provider: PROVIDER.DEV },
-    bot: { id: 'bot_id' },
-    is_first_interaction: true,
-  }
-}
-
-describe('Bad router initialization', () => {
-  test('empty routes throw TypeError', () => {
-    const router = new Router([])
-    expect(() => router.processInput(textInput, testSession())).toThrow(
-      NoMatchingRouteError
-    )
-  })
-  test('null routes throw TypeError', () => {
-    // @ts-ignore
-    const router = new Router()
-    expect(() => router.processInput(textInput, testSession())).toThrow(
-      TypeError
-    )
-  })
-})
-
-test('Router returns 404', () => {
-  const router = new Router([{ path: '404', action: '404Action' }])
-  const { action } = router.processInput(textInput, testSession())
-  expect(action).toBe('404Action')
-})
-
-describe('Match route by MATCHER <> INPUT', () => {
-  const router = new Router([])
-  const matchTextProp = (matcher, textInput) =>
-    router.matchRoute(testRoute(), 'text', matcher, textInput, testSession())
-  const matchPayloadProp = (matcher, payload) =>
-    router.matchRoute(testRoute(), 'payload', matcher, payload, testSession())
-  const matchRequestProp = (matcher, request) =>
-    router.matchRoute(
-      testRoute(),
-      'request',
-      matcher,
-      request.input,
-      request.session,
-      request.lastRoutePath
-    )
-  test('text <> text', () => {
-    expect(matchTextProp('hi', textInput)).toBeTruthy()
-    expect(matchTextProp('hii', textInput)).toBeFalsy()
-    expect(matchTextProp('bye', textInput)).toBeFalsy()
-    expect(matchTextProp('', textInput)).toBeFalsy()
-    expect(matchTextProp(null, textInput)).toBeFalsy()
-    expect(matchTextProp('Cömplêx input &% 🚀', textInputComplex)).toBeTruthy()
-    expect(matchTextProp(' Cömplêx input &% 🚀', textInputComplex)).toBeFalsy() // has a space at the beginning
-  })
-  test('regex <> text', () => {
-    expect(matchTextProp(/hi/, textInput)).toBeTruthy()
-    expect(matchTextProp(/bye/, textInput)).toBeFalsy()
-    expect(matchTextProp(/🚀/, textInputComplex)).toBeTruthy()
-    expect(matchTextProp(/complex/, textInputComplex)).toBeFalsy()
-  })
-  test('function <> text', () => {
-    expect(matchTextProp(v => v.startsWith('hi'), textInput)).toBeTruthy()
-    expect(matchTextProp(v => !v.startsWith('hi'), textInput)).toBeFalsy()
-  })
-  test('input <> text', () => {
-    expect(
-      router.matchRoute(
-        testRoute(),
-        'input',
-        i => i.data.startsWith('hi'),
-        textInput,
-        testSession()
-      )
-    ).toBeTruthy()
-    expect(
-      router.matchRoute(
-        testRoute(),
-        'input',
-        i => !i.data.startsWith('hi'),
-        textInput,
-        testSession()
-      )
-    ).toBeFalsy()
-  })
-  test('text <> text payload', () => {
-    expect(matchPayloadProp('foo', textPayloadInput)).toBeTruthy()
-    expect(matchPayloadProp('fooo', textPayloadInput)).toBeFalsy()
-    expect(matchPayloadProp('bar', textPayloadInput)).toBeFalsy()
-    expect(matchPayloadProp('', textPayloadInput)).toBeFalsy()
-    expect(matchPayloadProp(null, textPayloadInput)).toBeFalsy()
-  })
-  test('regex <> text payload', () => {
-    expect(matchPayloadProp(/foo/, textPayloadInput)).toBeTruthy()
-    expect(matchPayloadProp(/bar/, textPayloadInput)).toBeFalsy()
-  })
-  test('function <> text payload', () => {
-    expect(
-      matchPayloadProp(v => v.startsWith('fo'), textPayloadInput)
-    ).toBeTruthy()
-    expect(
-      matchPayloadProp(v => !v.startsWith('fo'), textPayloadInput)
-    ).toBeFalsy()
-  })
-  test('text <> postback', () => {
-    expect(matchPayloadProp('foo', postbackInput)).toBeTruthy()
-    expect(matchPayloadProp('fooo', postbackInput)).toBeFalsy()
-    expect(matchPayloadProp('bar', postbackInput)).toBeFalsy()
-    expect(matchPayloadProp('', postbackInput)).toBeFalsy()
-    expect(matchPayloadProp(null, postbackInput)).toBeFalsy()
-  })
-  test('regex <> postback', () => {
-    expect(matchPayloadProp(/foo/, postbackInput)).toBeTruthy()
-    expect(matchPayloadProp(/bar/, postbackInput)).toBeFalsy()
-  })
-  test('function <> postback', () => {
-    expect(
-      matchPayloadProp(v => v.startsWith('fo'), postbackInput)
-    ).toBeTruthy()
-    expect(
-      matchPayloadProp(v => !v.startsWith('fo'), postbackInput)
-    ).toBeFalsy()
-  })
-  test('function <> request', () => {
-    expect(
-      matchRequestProp(
-        request =>
-          request.input.data === 'hi' &&
-          request.session.organization === 'myOrg' &&
-          request.lastRoutePath === 'initial',
-        requestInput
-      )
-    ).toBeTruthy()
-    expect(
-      matchRequestProp(
-        request =>
-          request.input.data === 'hello' &&
-          request.session.organization === 'myOrg' &&
-          request.lastRoutePath === 'initial',
-        requestInput
-      )
-    ).toBeFalsy()
-  })
-})
-
-describe('Get route by path', () => {
-  const externalRoutes = [
-    { path: '', action: 'DefaultAction' },
-    { path: 'child', action: 'ChildAction' },
-  ]
-  const router = new Router([
-    { path: 'initial', action: 'Initial' },
-    {
-      path: 'flow-1',
-      action: 'Flow1',
-      childRoutes: [
-        {
-          path: '1',
-          action: 'Flow1.1',
-          childRoutes: [
-            { path: '1', action: 'Flow1.1.1' },
-            { path: '2', action: 'Flow1.1.2' },
-            { path: '3', action: 'Flow1.1.3' },
-          ],
-        },
-        { path: '2', action: 'Flow1.2', childRoutes: externalRoutes },
-        {
-          path: '3',
-          action: 'Flow1.3',
-          childRoutes: [
-            { path: '1', action: 'Flow1.3.1' },
-            { path: '2', action: 'Flow1.3.2' },
-            { path: '3', action: 'Flow1.3.3' },
-          ],
-        },
-      ],
-    },
-    { path: '404', action: '404Action' },
-  ])
-  function getRouteActionByPath(path) {
-    // @ts-ignore
-    return router.getRouteByPath(path).action
-  }
-  test('path exists', () => {
-    expect(getRouteActionByPath('initial')).toBe('Initial')
-    expect(getRouteActionByPath('flow-1/1')).toBe('Flow1.1')
-    expect(getRouteActionByPath('flow-1/3/2')).toBe('Flow1.3.2')
-  })
-  test('path exists in composed child routes', () => {
-    expect(getRouteActionByPath('flow-1/2')).toBe('Flow1.2')
-    expect(getRouteActionByPath('flow-1/2/child')).toBe('ChildAction')
-  })
-  test('path does not exist', () => {
-    expect(router.getRouteByPath('')).toBeNull()
-    expect(router.getRouteByPath('foo')).toBeNull()
-    expect(router.getRouteByPath('flow-1/3/2/6')).toBeNull()
-  })
-})
-
-describe('Process input (v<0.9)', () => {
-  const externalRoutes = [
-    { path: '', action: 'DefaultAction' },
-    { path: 'child', action: 'ChildAction' },
-  ]
-  const router = new Router([
-    { path: 'help', payload: 'help', action: 'Help' },
-    {
-      path: 'initial',
-      intent: /greeting/,
-      action: 'Flow1',
-      childRoutes: [
-        {
-          path: '1',
-          payload: '1',
-          action: 'Flow1.1',
-          childRoutes: [
-            { path: '1', payload: '1', action: 'Flow1.1.1' },
-            { path: '2', payload: '2', action: 'Flow1.1.2' },
-            { path: '3', payload: '3', action: 'Flow1.1.3' },
-          ],
-        },
-        {
-          path: '2',
-          payload: '2',
-          action: 'Flow1.2',
-          childRoutes: externalRoutes,
-        },
-        {
-          path: '3',
-          payload: '3',
-          action: 'Flow1.3',
-          childRoutes: [
-            { path: '1', payload: '1', action: 'Flow1.3.1' },
-            { path: '2', payload: '2', action: 'Flow1.3.2' },
-            { path: '3', payload: '3', action: 'Flow1.3.3' },
-          ],
-        },
-      ],
-    },
-    { path: '404', action: '404Action' },
-  ])
-  test('text input, root level route', () => {
-    /** @type Input */
-    const input = { type: 'text', data: 'hi', intent: 'greeting' }
-    const lastRoutePath = null
-    expect(
-      router.processInput(input, testSession(), lastRoutePath).action
-    ).toBe('Flow1')
-  })
-  test('payload input, 2nd level route', () => {
-    /** @type Input */
-    const input = { type: 'postback', payload: '2' }
-    const lastRoutePath = 'initial'
-    expect(
-      router.processInput(input, testSession(), lastRoutePath).action
-    ).toBe('Flow1.2')
-  })
-  test('old protocol:path payload input, root level route', () => {
-    /** @type Input */
-    const input = { type: 'postback', payload: '__PATH_PAYLOAD__initial' }
-    const lastRoutePath = ''
-    expect(
-      router.processInput(input, testSession(), lastRoutePath).action
-    ).toBe('Flow1')
-  })
-  test('old protocol:path payload input, root level route with composed path', () => {
-    /** @type Input */
-    const input = { type: 'postback', path: 'initial/2' }
-    const lastRoutePath = ''
-    expect(
-      router.processInput(input, testSession(), lastRoutePath).action
-    ).toBe('Flow1.2')
-  })
-  test('old protocol: path payload input, 2nd level route with lastRoutePath', () => {
-    /** @type Input */
-    const input = { type: 'postback', payload: '__PATH_PAYLOAD__2' }
-    const lastRoutePath = 'initial'
-    expect(
-      router.processInput(input, testSession(), lastRoutePath).action
-    ).toBe('Flow1.2')
-  })
-  test('path payload input with deprecated protocol, root level route', () => {
-    /** @type Input */
-    const input = { type: 'postback', payload: '__PATH_PAYLOAD__initial/2' }
-    const lastRoutePath = ''
-    expect(
-      router.processInput(input, testSession(), lastRoutePath).action
-    ).toBe('Flow1.2')
-  })
-  test('old protocol:path payload input with deprecated protocol, 2nd level route', () => {
-    /** @type Input */
-    const input = { type: 'postback', payload: '__PATH_PAYLOAD__initial/2' }
-    const lastRoutePath = 'initial'
-    expect(
-      router.processInput(input, testSession(), lastRoutePath).action
-    ).toBe('Flow1.2')
-  })
-})
-
-test.each([
-  [undefined, undefined, undefined],
-  ['', undefined, undefined],
-  ['bad_input', undefined, undefined],
-  ['__PATH_PAYLOAD__', '', undefined],
-  ['xx__PATH_PAYLOAD__path1', 'path1', undefined],
-  ['xx__PATH_PAYLOAD__path1?path1', 'path1', 'path1'],
-])(
-  'getOnFinishParams(%s)=>%s',
-  (inputPayload, expectedPath, expectedParams) => {
-    const router = new Router([])
-    /** @type Input */
-    const input = { type: 'postback', payload: inputPayload }
-    expect(router.getOnFinishParams(input)).toEqual(expectedParams)
-    expect(input.path).toEqual(expectedPath)
-    if (input.path) {
-      expect(input.payload).toBeUndefined()
-    }
-  }
-)

package/src/types/constants.d.ts

@@ -1,14 +0,0 @@
-export const Providers: Readonly<{
-  Messaging: {
-    FACEBOOK: 'facebook'
-    GENERIC: 'generic'
-    IMBEE: 'imbee'
-    INTERCOM: 'intercom'
-    SMOOCH: 'smooch'
-    TELEGRAM: 'telegram'
-    TWITTER: 'twitter'
-    WEBCHAT: 'webchat'
-    WECHAT: 'wechat'
-    WHATSAPP: 'whatsapp'
-  }
-}>

package/src/types/core-bot.d.ts

@@ -1,45 +0,0 @@
-import {
-  BotRequest,
-  BotResponse,
-  Locales,
-  PluginConfig,
-  Routes,
-  Session,
-} from '.'
-import { Inspector } from './debug'
-import { Router } from './router'
-
-export interface BotOptions {
-  /** The plugin configurations */
-  appId?: string
-  defaultDelay?: number
-  defaultRoutes?: Routes
-  defaultTyping?: number
-  inspector?: Inspector
-  locales: Locales
-  plugins?: PluginConfig<any>
-  renderer: any
-  routes: Routes
-  theme?: any
-}
-
-export declare class CoreBot {
-  constructor(options: BotOptions)
-
-  appId?: string
-  defaultDelay?: number
-  defaultRoutes?: Routes
-  defaultTyping?: number
-  inspector?: Inspector
-  locales: Locales
-  plugins?: PluginConfig<any>
-  renderer: any
-  rootElement: any
-  router: Router
-  routes: Routes
-  theme?: any
-
-  getString(stringID: string, session: Session): string
-  setLocale(locale: string, session: Session): void
-  input(request: BotRequest): Promise<BotResponse>
-}