@botonic/core 0.19.0 → 0.20.2-alpha.0

package/src/core-bot.ts

@@ -0,0 +1,213 @@
+import { ulid } from 'ulid'
+
+import { Inspector } from './debug'
+import { getString } from './i18n'
+import {
+  BotonicEvent,
+  BotRequest,
+  BotResponse,
+  Locales,
+  MessageEventAck,
+  MessageEventFrom,
+  Route,
+  Routes,
+  Session,
+} from './models'
+import { BotonicOutputParser } from './output-parser'
+import { loadPlugins, runPlugins } from './plugins'
+import { getComputedRoutes, Router } from './routing'
+
+interface CoreBotConfig {
+  appId?: string
+  defaultDelay?: number
+  defaultRoutes?: Route[]
+  defaultTyping?: number
+  inspector?: Inspector
+  locales: Locales
+  plugins?: any
+  renderer: any
+  routes: Routes
+  theme?: any
+}
+export class CoreBot {
+  appId?: string
+  defaultDelay?: number
+  defaultRoutes: Route[]
+  defaultTyping?: number
+  inspector: Inspector
+  locales: Locales
+  plugins?: Record<string, Plugin>
+  renderer: any
+  rootElement: any
+  router: Router | null
+  routes: Routes
+  theme?: any
+  botonicOutputParser = new BotonicOutputParser()
+
+  constructor({
+    // TODO: Receives dataProvider
+    renderer,
+    routes,
+    locales,
+    theme,
+    plugins,
+    appId,
+    defaultTyping,
+    defaultDelay,
+    defaultRoutes,
+    inspector,
+  }: CoreBotConfig) {
+    this.renderer = renderer
+    this.plugins = loadPlugins(plugins)
+    this.theme = theme || {}
+    this.defaultTyping =
+      typeof defaultTyping !== 'undefined' ? defaultTyping : 0.6
+    this.defaultDelay = typeof defaultDelay !== 'undefined' ? defaultDelay : 0.4
+    this.locales = locales
+    if (appId) {
+      this.appId = appId
+      return
+    }
+    this.rootElement = null
+    this.inspector = inspector || new Inspector()
+    this.routes = routes
+    this.defaultRoutes = defaultRoutes || []
+    this.router =
+      this.routes instanceof Function
+        ? null
+        : new Router(
+            [...this.routes, ...this.defaultRoutes],
+            this.inspector.routeInspector
+          )
+  }
+
+  getString(id: string, session: Session): string {
+    // @ts-ignore
+    return getString(this.locales, session.__locale, id)
+  }
+
+  setLocale(locale: string, session: Session): void {
+    session.__locale = locale
+  }
+
+  async input({
+    input,
+    session,
+    lastRoutePath,
+    dataProvider,
+  }: BotRequest): Promise<BotResponse> {
+    session = session || {}
+    if (!session.__locale) session.__locale = 'en'
+
+    const parsedUserEvent = this.botonicOutputParser.parseFromUserInput(input)
+    const userId = session.user.id
+    if (dataProvider) {
+      // TODO: Next iterations. Review cycle of commited events to DB when messages change their ACK
+      // @ts-ignore
+      const userEvent = await dataProvider.saveEvent({
+        ...parsedUserEvent,
+        userId,
+        eventId: ulid(),
+        createdAt: new Date().toISOString(),
+        from: MessageEventFrom.USER,
+        ack: MessageEventAck.RECEIVED,
+      })
+    }
+
+    if (this.plugins) {
+      await runPlugins(
+        this.plugins,
+        'pre',
+        input,
+        session,
+        lastRoutePath,
+        undefined,
+        undefined,
+        dataProvider
+      )
+    }
+
+    if (this.routes instanceof Function) {
+      this.router = new Router(
+        [
+          ...(await getComputedRoutes(this.routes, {
+            input,
+            session,
+            lastRoutePath,
+          })),
+          ...this.defaultRoutes,
+        ],
+        this.inspector.routeInspector
+      )
+    }
+
+    const output = (this.router as Router).processInput(
+      input,
+      session,
+      lastRoutePath
+    )
+    const request = {
+      getString: stringId => this.getString(stringId, session),
+      setLocale: locale => this.setLocale(locale, session),
+      session: session || {},
+      params: output.params || {},
+      input: input,
+      plugins: this.plugins,
+      defaultTyping: this.defaultTyping,
+      defaultDelay: this.defaultDelay,
+      lastRoutePath,
+      dataProvider,
+    }
+
+    const response = await this.renderer({
+      request,
+      actions: [output.fallbackAction, output.action, output.emptyAction],
+    })
+    let messageEvents: Partial<BotonicEvent>[] = []
+    try {
+      messageEvents = this.botonicOutputParser.xmlToMessageEvents(response)
+    } catch (e) {
+      // Disabling Botonic 1.0 error log for LTS version:
+      // console.error(e)
+    }
+
+    lastRoutePath = output.lastRoutePath
+    if (this.plugins) {
+      await runPlugins(
+        this.plugins,
+        'post',
+        input,
+        session,
+        lastRoutePath,
+        response,
+        messageEvents,
+        dataProvider
+      )
+    }
+
+    if (dataProvider) {
+      // TODO: save bot responses to db and update user with new session and new params
+      for (const messageEvent of messageEvents) {
+        // @ts-ignore
+        const botEvent = await dataProvider.saveEvent({
+          ...messageEvent,
+          userId,
+          eventId: ulid(),
+          createdAt: new Date().toISOString(),
+          from: MessageEventFrom.BOT,
+          ack: MessageEventAck.SENT,
+        })
+      }
+    }
+
+    session.is_first_interaction = false
+    return {
+      input,
+      response,
+      messageEvents,
+      session,
+      lastRoutePath,
+      dataProvider,
+    }
+  }
+}

package/src/data-provider/dynamodb-data-provider.ts

@@ -0,0 +1,103 @@
+import { Entity, Table } from 'dynamodb-toolbox'
+
+import { BotonicEvent, EventTypes, User } from '../models'
+import {
+  getConnectionEventEntity,
+  getMessageEventEntities,
+  getUserEntity,
+  getUserEventsTable,
+  GLOBAL_SECONDARY_INDEX_NAME,
+  SORT_KEY_NAME,
+  USER_PREFIX,
+} from './dynamodb-utils'
+import { DataProvider } from './factory'
+
+export class DynamoDBDataProvider implements DataProvider {
+  region: string
+  tableName: string
+  userEventsTable: Table
+  userEntity: Entity<any>
+  eventEntity: Entity<any>
+  messageEventEntities: Record<string, Entity<any>>
+  textMessageEventEntity: Entity<any>
+  connectionEventEntity: Entity<any>
+  constructor(url: string) {
+    try {
+      ;[this.tableName, this.region] = url.split('://')[1].split('.')
+      this.userEventsTable = getUserEventsTable(this.tableName, this.region)
+      this.userEntity = getUserEntity(this.userEventsTable)
+      this.connectionEventEntity = getConnectionEventEntity(
+        this.userEventsTable
+      )
+      this.messageEventEntities = getMessageEventEntities(this.userEventsTable)
+    } catch (e) {
+      console.log({ e })
+    }
+  }
+
+  // @ts-ignore
+  async getUsers(limit = 10, offset = 0): Promise<User[]> {
+    // TODO: finish to implement with offset
+    const result = await this.userEventsTable.scan({
+      filters: { attr: SORT_KEY_NAME, beginsWith: USER_PREFIX },
+      limit,
+    })
+    return result.Items
+  }
+
+  async getUser(id: string): Promise<User | undefined> {
+    const userById = {
+      id: id,
+      SK: id,
+    }
+    const result = await this.userEntity.get(userById)
+    if (Object.keys(result).length === 0) return undefined
+    return result.Item
+  }
+
+  async getUserByWebsocketId(websocketId: string): Promise<User | undefined> {
+    const result = await this.userEventsTable.query(websocketId, {
+      index: GLOBAL_SECONDARY_INDEX_NAME,
+    })
+    if (result.Count === 0) return undefined
+    return result.Items[0]
+  }
+  // @ts-ignore
+  async getUserByField(field: string, value: any): Promise<User | undefined> {} //TODO: Implement
+
+  async saveUser(user: User): Promise<User> {
+    const putUser = { ...user, id: user.id, userId: user.id }
+    await this.userEntity.put(putUser)
+    return user
+  }
+  async updateUser(user: User): Promise<User> {
+    const updateUser = { ...user, id: user.id, userId: user.id }
+    const res = await this.userEntity.update(updateUser)
+    return user
+  }
+  // @ts-ignore
+  async deleteUser(id: string): Promise<User | undefined> {} // TODO: Implement
+
+  // @ts-ignore
+  async getEvents(limit = 10, offset = 0): Promise<BotonicEvent[]> {} // TODO: Implement
+
+  // @ts-ignore
+  async getEvent(id: string): Promise<BotonicEvent | undefined> {} // TODO: Implement
+
+  async saveEvent(event: BotonicEvent): Promise<BotonicEvent> {
+    if (event.eventType === EventTypes.CONNECTION) {
+      await this.connectionEventEntity.put(event)
+    }
+    if (event.eventType === EventTypes.MESSAGE) {
+      await this.messageEventEntities[event.type].put(event)
+    }
+    // TODO: Implementation of other event types
+    return event
+  }
+
+  // @ts-ignore
+  async updateEvent(event: BotonicEvent): Promise<BotonicEvent> {} // TODO: Implement
+
+  // @ts-ignore
+  async deleteEvent(id: string): Promise<BotonicEvent | undefined> {} // TODO: Implement
+}

package/src/data-provider/dynamodb-utils.ts

@@ -0,0 +1,149 @@
+import { DynamoDB } from 'aws-sdk'
+import { Entity, Table } from 'dynamodb-toolbox'
+import { EntityAttributes } from 'dynamodb-toolbox/dist/classes/Entity'
+
+import { MessageEventTypes } from '../models'
+
+// Table Definitions
+export const GLOBAL_SECONDARY_INDEX_NAME = 'GSI1'
+export const GLOBAL_SECONDARY_INDEX_ATTR = 'websocketId'
+export const PARTITION_KEY_NAME = 'PK'
+export const SORT_KEY_NAME = 'SK'
+
+// Entities Definitions
+export const USER_PREFIX = 'USR#'
+export const EVENT_PREFIX = 'EVT#'
+
+function capitalize(string: string) {
+  return string.charAt(0).toUpperCase() + string.slice(1)
+}
+
+export function getUserEventsTable(tableName: string, region: string): Table {
+  const documentClient = new DynamoDB.DocumentClient({
+    apiVersion: '2012-08-10',
+    region: region,
+  })
+  return new Table({
+    name: tableName,
+    partitionKey: PARTITION_KEY_NAME,
+    sortKey: SORT_KEY_NAME,
+    entityField: true,
+    indexes: {
+      GSI1: {
+        partitionKey: GLOBAL_SECONDARY_INDEX_ATTR,
+      },
+    },
+    DocumentClient: documentClient,
+  })
+}
+
+export function getUserEntity(table: Table): Entity<any> {
+  return new Entity({
+    name: 'User',
+    attributes: {
+      id: { partitionKey: true, prefix: USER_PREFIX },
+      [`${SORT_KEY_NAME}`]: {
+        hidden: true,
+        sortKey: true,
+        prefix: USER_PREFIX,
+      },
+      userId: [SORT_KEY_NAME, 0],
+      websocketId: 'string',
+      isOnline: 'boolean',
+      route: 'string',
+      session: 'string',
+    },
+    table,
+  })
+}
+
+export function getConnectionEventEntity(table: Table): Entity<any> {
+  return new Entity({
+    name: 'Connection Event',
+    attributes: {
+      userId: { partitionKey: true, prefix: USER_PREFIX },
+      [`${SORT_KEY_NAME}`]: {
+        hidden: true,
+        sortKey: true,
+        prefix: EVENT_PREFIX,
+      },
+      eventId: [SORT_KEY_NAME, 0],
+      eventType: 'string',
+      createdAt: 'string',
+      modifiedAt: 'string',
+      status: 'string',
+    },
+    table,
+  })
+}
+
+export function getMessageEventEntities(
+  table: Table
+): Record<string, Entity<any>> {
+  const textAttributes: EntityAttributes = {
+    text: 'string',
+    markdown: 'boolean',
+    buttons: 'list',
+    replies: 'list',
+  }
+
+  const mediaAttributes: EntityAttributes = {
+    src: 'string',
+    buttons: 'list',
+  }
+
+  const locationAttributes: EntityAttributes = {
+    lat: 'number',
+    long: 'number',
+  }
+
+  const carouselAttributes: EntityAttributes = {
+    elements: 'list',
+  }
+
+  const customAttributes: EntityAttributes = {
+    json: 'map',
+    replies: 'list',
+  }
+
+  const entityWithAttributes = (type: string, attributes: EntityAttributes) =>
+    new Entity({
+      name: `${capitalize(type)} Message Event`, // Entity Names must be unique
+      attributes: {
+        userId: { partitionKey: true, prefix: USER_PREFIX },
+        [`${SORT_KEY_NAME}`]: {
+          hidden: true,
+          sortKey: true,
+          prefix: EVENT_PREFIX,
+        },
+        eventId: [SORT_KEY_NAME, 0],
+        eventType: 'string',
+        createdAt: 'string',
+        modifiedAt: 'string',
+        from: 'string',
+        ack: 'string',
+        typing: 'number',
+        delay: 'number',
+        type: 'string',
+        ...attributes,
+      },
+      table,
+    })
+
+  return {
+    text: entityWithAttributes(MessageEventTypes.TEXT, textAttributes),
+    audio: entityWithAttributes(MessageEventTypes.AUDIO, mediaAttributes),
+    image: entityWithAttributes(MessageEventTypes.IMAGE, mediaAttributes),
+    document: entityWithAttributes(MessageEventTypes.DOCUMENT, mediaAttributes),
+    video: entityWithAttributes(MessageEventTypes.VIDEO, mediaAttributes),
+    location: entityWithAttributes(
+      MessageEventTypes.LOCATION,
+      locationAttributes
+    ),
+    carousel: entityWithAttributes(
+      MessageEventTypes.CAROUSEL,
+      carouselAttributes
+    ),
+    custom: entityWithAttributes(MessageEventTypes.CUSTOM, customAttributes),
+  }
+}

package/src/data-provider/factory.ts

@@ -0,0 +1,60 @@
+import { BotonicEvent, User } from '../models'
+import { DynamoDBDataProvider } from './dynamodb-data-provider'
+import { LocalDevDataProvider } from './local-data-provider'
+
+export const dataProviderProtocols = {
+  DYNAMO_DB: 'dynamodb',
+  FILE: 'file',
+}
+
+export interface DataProvider {
+  getUsers(limit?: number, offset?: number): User[] | Promise<User[]>
+  getUser(id: string): User | Promise<User | undefined> | undefined
+  //TODO: replace getUserByWebsocketId to getUserByField?
+  getUserByWebsocketId(
+    websocketId: string
+  ): User | Promise<User | undefined> | undefined
+  getUserByField(
+    field: string,
+    value: any
+  ): User | Promise<User | undefined> | undefined
+  saveUser(user: User): User | Promise<User>
+  updateUser(user: User): User | Promise<User>
+  deleteUser(id: string): User | Promise<User | undefined> | undefined
+  getEvents(
+    limit?: number,
+    offset?: number
+  ): BotonicEvent[] | Promise<BotonicEvent[]>
+  getEvent(
+    id: string
+  ): BotonicEvent | Promise<BotonicEvent | undefined> | undefined
+  saveEvent(event: BotonicEvent): BotonicEvent | Promise<BotonicEvent>
+  updateEvent(event: BotonicEvent): BotonicEvent | Promise<BotonicEvent>
+  deleteEvent(
+    id: string
+  ): BotonicEvent | Promise<BotonicEvent | undefined> | undefined
+}
+
+/** URL examples:
+ * dynamodb://my-table.my-region.aws.com
+ * postgresql://my-database.my-db-provider.com
+ * file://path/to/local/db.json
+ */
+export function dataProviderFactory(url?: string): DataProvider {
+  if (!url) {
+    return new LocalDevDataProvider()
+  }
+
+  const protocol = url.split('://')[0]
+  switch (protocol) {
+    case dataProviderProtocols.DYNAMO_DB:
+      return new DynamoDBDataProvider(url)
+    case dataProviderProtocols.FILE:
+      return new LocalDevDataProvider(url)
+    default:
+      console.error(
+        `Protocol ${protocol} not implemented, using local DB instead.`
+      )
+      return new LocalDevDataProvider()
+  }
+}

package/src/data-provider/index.ts

@@ -0,0 +1,4 @@
+export * from './dynamodb-data-provider'
+export * from './dynamodb-utils'
+export * from './factory'
+export * from './local-data-provider'

package/src/data-provider/local-data-provider.ts

@@ -0,0 +1,154 @@
+import { JsonDB } from 'node-json-db'
+import { Config } from 'node-json-db/dist/lib/JsonDBConfig'
+
+import { BotonicEvent, User } from '../models'
+import { DataProvider } from './factory'
+
+export class LocalDevDataProvider implements DataProvider {
+  private readonly DB_PATH = 'tmp/localDb'
+  private readonly SEPARATOR = '/'
+  private readonly paths = {
+    USERS: '/users',
+    EVENTS: '/events',
+    CONNECTIONS: '/connections',
+  }
+  db: JsonDB
+
+  constructor(url?: string) {
+    const dbPath = url ? url.split('://')[1] : this.DB_PATH
+    this.db = new JsonDB(new Config(dbPath, true, false, this.SEPARATOR))
+  }
+
+  getUsers(limit = 10, offset = 0): User[] {
+    const path = this.paths.USERS
+    this.db.reload()
+    const userList = this.db.getObject<Record<string, User>>(path)
+    const users = Object.values(userList)
+    const to = limit !== 0 ? offset + limit : undefined
+    return users.slice(offset, to)
+  }
+
+  getUser(userId: string): User | undefined {
+    const path = this.createPath([this.paths.USERS, userId])
+    this.db.reload()
+    return this.db.exists(path) ? this.db.getObject<User>(path) : undefined
+  }
+
+  getUserByWebsocketId(websocketId: string): User | undefined {
+    return this.getUserByField('websocketId', websocketId)
+  }
+
+  getUserByField(field: string, value: any): User | undefined {
+    const path = this.paths.USERS
+    this.db.reload()
+    const dbUser = this.db.exists(path)
+      ? this.db.find<User>(path, (user: User) => user[field] === value)
+      : undefined
+    return dbUser
+  }
+
+  saveUser(user: User): User {
+    const path = this.createPath([this.paths.USERS, user.id])
+    this.db.reload()
+    if (!this.db.exists(path)) {
+      this.db.push(path, user)
+    }
+    return user
+  }
+
+  updateUser(user: User): User {
+    const path = this.createPath([this.paths.USERS, user.id])
+    this.db.reload()
+    if (this.db.exists(path)) {
+      this.db.push(path, user, true)
+    }
+    return user
+  }
+
+  deleteUser(id: string): User | undefined {
+    const path = this.createPath([this.paths.USERS, id])
+    this.db.reload()
+    const user = this.db.exists(path)
+      ? this.db.getObject<User>(path)
+      : undefined
+    if (user) {
+      this.db.delete(path)
+      return user
+    }
+    return undefined
+  }
+
+  getEvents(limit = 10, offset = 0): BotonicEvent[] {
+    const path = this.paths.EVENTS
+    this.db.reload()
+    const eventList = this.db.getObject<Record<string, BotonicEvent>>(path)
+    const events = Object.values(eventList)
+    const to = limit !== 0 ? offset + limit : undefined
+    return events.slice(offset, to)
+  }
+
+  getEvent(id: string): BotonicEvent | undefined {
+    const path = this.createPath([this.paths.EVENTS, id])
+    this.db.reload()
+    return this.db.exists(path)
+      ? this.db.getObject<BotonicEvent>(path)
+      : undefined
+  }
+
+  saveEvent(event: BotonicEvent): BotonicEvent {
+    const path = this.createPath([this.paths.EVENTS, event.eventId])
+    this.db.reload()
+    if (!this.db.exists(path)) {
+      this.db.push(path, event)
+    }
+    return event
+  }
+
+  updateEvent(event: BotonicEvent): BotonicEvent {
+    const path = this.createPath([this.paths.EVENTS, event.eventId])
+    this.db.reload()
+    if (this.db.exists(path)) {
+      this.db.push(path, event, true)
+    }
+    return event
+  }
+
+  deleteEvent(id: string): BotonicEvent | undefined {
+    const path = this.createPath([this.paths.EVENTS, id])
+    this.db.reload()
+    const event = this.db.exists(path)
+      ? this.db.getObject<BotonicEvent>(path)
+      : undefined
+    if (event) {
+      this.db.delete(path)
+      return event
+    }
+    return undefined
+  }
+
+  addConnection(websocketId: string) {
+    const path = this.createPath([this.paths.CONNECTIONS, websocketId])
+    this.db.reload()
+    if (!this.db.exists(path)) {
+      this.db.push(path, '', false)
+    }
+  }
+
+  updateConnection(websocketId: string, userId: string) {
+    const path = this.createPath([this.paths.CONNECTIONS, websocketId])
+    this.db.reload()
+    if (this.db.exists(path)) {
+      this.db.push(path, userId, true)
+    }
+  }
+
+  deleteConnection(websocketId: string) {
+    const path = this.createPath([this.paths.CONNECTIONS, websocketId])
+    this.db.reload()
+    this.db.delete(path)
+  }
+
+  private createPath(urlChunks: string[]): string {
+    return urlChunks.join(this.SEPARATOR)
+  }
+}