@botonic/core 0.26.0 → 0.27.0-alpha.0

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

@@ -1,149 +0,0 @@
-import DynamoDB from 'aws-sdk/clients/dynamodb'
-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

@@ -1,60 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,154 +0,0 @@
-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)
-  }
-}

package/src/output-parser/botonic-output-parser.ts

@@ -1,38 +0,0 @@
-// eslint-disable-next-line import/named
-import { parse, X2jOptions } from 'fast-xml-parser'
-import { decode } from 'html-entities'
-
-import { BotonicEvent } from '../models'
-import { MessageParsingFactory } from './factory'
-
-export const TEXT_NODE_NAME = 'text'
-
-export class BotonicOutputParser {
-  private static OPTIONS: Partial<X2jOptions> = {
-    ignoreAttributes: false,
-    attributeNamePrefix: '',
-    textNodeName: TEXT_NODE_NAME,
-    arrayMode: true,
-    attrValueProcessor: a => decode(a),
-  }
-
-  constructor(private readonly factory = new MessageParsingFactory()) {}
-
-  xmlToMessageEvents(html: string): Partial<BotonicEvent>[] {
-    const jsonMessages = this.xmlToJSONMessages(html)
-    return jsonMessages.map(msgToParse => this.factory.parse(msgToParse))
-  }
-
-  /**
-   * Right now, when saving BotonicEvents to DataProvider, we need the standarized Botonic event
-   * to be saved. This is, converting a botonic input like: '{id: 'msgId', data: 'rawData', payload: 'somePayload'}'
-   * into a BotonicEvent with the expected properties.
-   */
-  parseFromUserInput(input: any): Partial<BotonicEvent> {
-    return this.factory.parse(input)
-  }
-
-  private xmlToJSONMessages(html: any): any {
-    return parse(html, BotonicOutputParser.OPTIONS).message
-  }
-}

package/src/output-parser/factory.ts

@@ -1,45 +0,0 @@
-import { BotonicEvent, MEDIA_TYPES, MessageEventTypes } from '../models'
-import {
-  parseButtons,
-  parseCarousel,
-  parseContact,
-  parseCustom,
-  parseForm,
-  parseLocation,
-  parseMedia,
-  parseMessage,
-  parseMissed,
-  parsePostback,
-  parseReplies,
-  parseText,
-} from './parsers'
-
-export class MessageParsingFactory {
-  parse(msgToParse: any): Partial<BotonicEvent> {
-    const type = msgToParse.type
-    const parsedMessage = parseMessage({ toParse: msgToParse })
-    if (MEDIA_TYPES.includes(type)) {
-      return parseMedia(parseButtons(parsedMessage)).parsed
-    }
-    switch (type) {
-      case MessageEventTypes.TEXT:
-        // statement 1
-        return parseText(parseReplies(parseButtons(parsedMessage))).parsed
-      case MessageEventTypes.POSTBACK:
-        return parsePostback(parsedMessage).parsed
-      case MessageEventTypes.LOCATION:
-        return parseLocation(parsedMessage).parsed
-      case MessageEventTypes.CAROUSEL:
-        return parseCarousel(parsedMessage).parsed
-      case MessageEventTypes.CUSTOM:
-        return parseCustom(parseReplies(parsedMessage)).parsed
-      case MessageEventTypes.FORM:
-        return parseForm(parsedMessage).parsed
-      case MessageEventTypes.CONTACT:
-        return parseContact(parsedMessage).parsed
-      case MessageEventTypes.MISSED:
-        return parseMissed(parsedMessage).parsed
-    }
-    throw new Error(`Parsing for type: '${type}' not implemented.`)
-  }
-}

package/src/output-parser/index.ts

@@ -1,3 +0,0 @@
-export * from './botonic-output-parser'
-export * from './factory'
-export * from './parsers'

package/src/output-parser/parsers.ts

@@ -1,237 +0,0 @@
-import {
-  AudioMessageEvent,
-  BotonicMessageEvent,
-  Button,
-  CarouselElement,
-  CarouselMessageEvent,
-  CustomMessageEvent,
-  DocumentMessageEvent,
-  EventTypes,
-  FormMessageEvent,
-  ImageMessageEvent,
-  LocationMessageEvent,
-  MissedMessageEvent,
-  PostbackMessageEvent,
-  Reply,
-  TextMessageEvent,
-  VideoMessageEvent,
-  WithButtons,
-  WithReplies,
-} from '../models'
-import { ContactMessageEvent } from '../models/events/message/contact'
-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; parsed?: any }) => {
-  toParse: any
-  parsed: Partial<Out>
-}
-
-// COMMON
-export const parseMessage: ParseFunction<BotonicMessageEvent> = args => {
-  const typingAndDelay = {}
-  if (args.toParse.delay !== undefined) {
-    typingAndDelay['delay'] = parseNumber(args.toParse.delay)
-  }
-  if (args.toParse.typing !== undefined) {
-    typingAndDelay['typing'] = parseNumber(args.toParse.typing)
-  }
-  return {
-    toParse: args.toParse,
-    parsed: {
-      // 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,
-      ...typingAndDelay,
-    },
-  }
-}
-
-// BUTTONS
-export const parseButton = (button: any): Button => {
-  const title = button[TEXT_NODE_NAME]
-  if ('payload' in button) {
-    return { title, payload: button.payload }
-  }
-  if ('url' in button) {
-    const b = { title, url: button.url, target: button.target }
-    if (button.target) b.target = button.target
-    return b
-  }
-  if ('webview' in button) {
-    return {
-      title,
-      webview: button.webview,
-      params: button.params,
-    }
-  }
-  throw new Error('Invalid parsed Button')
-}
-
-export const parseButtons: ParseFunction<WithButtons> = args => {
-  const hasButtons = args.toParse?.button?.length > 0
-  let buttons: Button[] = []
-  if (hasButtons) {
-    buttons = args.toParse.button.map(button => parseButton(button))
-  }
-  return {
-    toParse: args.toParse,
-    parsed: {
-      ...args.parsed,
-      buttons,
-    },
-  }
-}
-
-// REPLIES
-export const parseReply = (reply: any): Reply => ({
-  title: reply[TEXT_NODE_NAME],
-  payload: reply.payload,
-})
-
-export const parseReplies: ParseFunction<WithReplies> = args => {
-  const hasReplies = args.toParse?.reply?.length > 0
-  let replies: Reply[] = []
-  if (hasReplies) {
-    replies = args.toParse.reply.map(reply => parseReply(reply))
-  }
-  return {
-    toParse: args.toParse,
-    parsed: {
-      ...args.parsed,
-      replies,
-    },
-  }
-}
-
-// TEXT
-export const parseText: ParseFunction<TextMessageEvent> = args => {
-  return {
-    toParse: args.toParse,
-    parsed: {
-      ...args.parsed,
-      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
-  | DocumentMessageEvent
-  | ImageMessageEvent
-  | VideoMessageEvent
-> = args => {
-  return {
-    toParse: args.toParse,
-    parsed: {
-      ...args.parsed,
-      src: args.toParse.src,
-    },
-  }
-}
-
-// LOCATION
-export const parseLocation: ParseFunction<LocationMessageEvent> = args => {
-  return {
-    toParse: args.toParse,
-    parsed: {
-      ...args.parsed,
-      lat: args.toParse.lat,
-      long: args.toParse.long,
-    },
-  }
-}
-
-// CAROUSEL
-export const parseElement = (element: any): CarouselElement => {
-  const e: CarouselElement = {
-    pic: element.pic,
-    title: element.title,
-    subtitle: element.desc,
-  }
-  const hasButtons = element.button !== undefined
-  if (hasButtons) e.buttons = element.button.map(b => parseButton(b))
-  return e
-}
-
-export const parseCarousel: ParseFunction<CarouselMessageEvent> = args => {
-  return {
-    toParse: args.toParse,
-    parsed: {
-      ...args.parsed,
-      elements: args.toParse.element.map(element => parseElement(element)),
-    },
-  }
-}
-
-// CUSTOM
-export const parseCustom: ParseFunction<CustomMessageEvent> = args => {
-  return {
-    toParse: args.toParse,
-    parsed: {
-      ...args.parsed,
-      json: JSON.parse(args.toParse.json),
-    },
-  }
-}
-
-// MISSED
-export const parseMissed: ParseFunction<MissedMessageEvent> = args => {
-  return {
-    toParse: args.toParse,
-    parsed: {
-      ...args.parsed,
-      reason: args.toParse.reason,
-      media_type: args.toParse.media_type,
-    },
-  }
-}
-
-// FORM
-export const parseForm: ParseFunction<FormMessageEvent> = args => {
-  return {
-    toParse: args.toParse,
-    parsed: {
-      ...args.parsed,
-      form_title: args.toParse.form_title,
-      form_answers: args.toParse.form_answers,
-    },
-  }
-}
-
-// CONTACT
-export const parseContact: ParseFunction<ContactMessageEvent> = args => {
-  return {
-    toParse: args.toParse,
-    parsed: {
-      ...args.parsed,
-      phone_number: args.toParse.phone_number,
-      first_name: args.toParse.first_name,
-      last_name: args.toParse.last_name,
-      vcard: args.toParse.vcard,
-    },
-  }
-}