@botonic/core 1.0.0-dev.0 → 2.23.0

package/src/handoff.ts

@@ -1,268 +0,0 @@
-import axios from 'axios'
-
-import { Session } from './index'
-
-const HUBTYPE_API_URL = 'https://api.hubtype.com'
-
-export interface HubtypeAgentsInfo {
-  attending_count: number
-  email: string
-  idle_count: number
-  last_message_sent: string
-  status: string
-}
-export interface HubtypeSession extends Session {
-  _hubtype_api?: string
-  _access_token: string
-}
-
-export interface SessionWithBotonicAction extends Session {
-  _botonic_action: string
-}
-export interface BackendContext {
-  timeoutMs: number
-}
-
-export interface VacationRange {
-  end_date: number // timestamp
-  id: number
-  start_date: number // timestamp
-}
-
-function contextDefaults(context: any): BackendContext {
-  return {
-    timeoutMs: context.timeoutMs || 10000,
-  }
-}
-
-export async function getOpenQueues(
-  session: HubtypeSession,
-  context = {}
-): Promise<{ queues: string[] }> {
-  //be aware of https://github.com/axios/axios/issues/1543
-  const baseUrl = session._hubtype_api || HUBTYPE_API_URL
-  const endpointUrl = `${baseUrl}/v1/queues/get_open_queues/`
-  context = contextDefaults(context)
-  const resp = await axios({
-    headers: {
-      Authorization: `Bearer ${session._access_token}`,
-    },
-    method: 'post',
-    url: endpointUrl,
-    data: { bot_id: session.bot.id },
-    timeout: (context as BackendContext).timeoutMs,
-  })
-  return resp.data
-}
-
-export class HandOffBuilder {
-  _session: SessionWithBotonicAction
-  _queue: string
-  _onFinish: string
-  _email: string
-  _agentId: string
-  _note: string
-  _caseInfo: string
-  _shadowing: boolean
-
-  constructor(session: SessionWithBotonicAction) {
-    this._session = session
-  }
-
-  withQueue(queueNameOrId: string): this {
-    this._queue = queueNameOrId
-    return this
-  }
-
-  withOnFinishPayload(payload: string): this {
-    this._onFinish = payload
-    return this
-  }
-
-  withOnFinishPath(path: string): this {
-    this._onFinish = `__PATH_PAYLOAD__${path}`
-    return this
-  }
-
-  withAgentEmail(email: string): this {
-    this._email = email
-    return this
-  }
-
-  withAgentId(agentId: string): this {
-    this._agentId = agentId
-    return this
-  }
-
-  withNote(note: string): this {
-    this._note = note
-    return this
-  }
-
-  withCaseInfo(caseInfo: string): this {
-    this._caseInfo = caseInfo
-    return this
-  }
-
-  withShadowing(shadowing = true): this {
-    this._shadowing = shadowing
-    return this
-  }
-
-  async handOff(): Promise<void> {
-    return _humanHandOff(
-      this._session,
-      this._queue,
-      this._onFinish,
-      this._email,
-      this._agentId,
-      this._caseInfo,
-      this._note,
-      this._shadowing
-    )
-  }
-}
-
-/**
- * @deprecated use {@link HandOffBuilder} class instead
- */
-export async function humanHandOff(session, queueNameOrId = '', onFinish) {
-  const builder = new HandOffBuilder(session)
-  if (queueNameOrId) {
-    builder.withQueue(queueNameOrId)
-  }
-  if (onFinish) {
-    if (onFinish.path) {
-      builder.withOnFinishPath(onFinish.path)
-    } else if (onFinish.payload) {
-      builder.withOnFinishPayload(onFinish.payload)
-    } else {
-      throw new Error('onFinish requires payload or path field')
-    }
-  }
-  return builder.handOff()
-}
-
-interface HubtypeHandoffParams {
-  queue?: string
-  agent_email?: string
-  agent_id?: string
-  case_info?: string
-  note?: string
-  shadowing?: boolean
-  on_finish?: string
-}
-async function _humanHandOff(
-  session: SessionWithBotonicAction,
-  queueNameOrId = '',
-  onFinish: string,
-  agentEmail = '',
-  agentId = '',
-  caseInfo = '',
-  note = '',
-  shadowing = false
-) {
-  const params: HubtypeHandoffParams = {}
-  if (queueNameOrId) {
-    params.queue = queueNameOrId
-  }
-  if (agentEmail) {
-    params.agent_email = agentEmail
-  }
-  if (agentId) {
-    params.agent_id = agentId
-  }
-  if (caseInfo) {
-    params.case_info = caseInfo
-  }
-  if (note) {
-    params.note = note
-  }
-  if (shadowing) {
-    params.shadowing = shadowing
-  }
-  if (onFinish) {
-    params.on_finish = onFinish
-  }
-  session._botonic_action = `create_case:${JSON.stringify(params)}`
-}
-
-export async function storeCaseRating(
-  session: HubtypeSession,
-  rating: number,
-  context: any = {}
-): Promise<{ status: string }> {
-  const baseUrl = session._hubtype_api || HUBTYPE_API_URL
-  const chatId = session.user.id
-  context = contextDefaults(context)
-  const resp = await axios({
-    headers: {
-      Authorization: `Bearer ${session._access_token}`,
-    },
-    method: 'post',
-    url: `${baseUrl}/v1/chats/${chatId}/store_case_rating/`,
-    data: { chat_id: chatId, rating },
-    timeout: (context as BackendContext).timeoutMs,
-  })
-  return resp.data
-}
-
-export async function getAvailableAgentsByQueue(
-  session: HubtypeSession,
-  queueId: string
-): Promise<{ agents: string[] }> {
-  const baseUrl = session._hubtype_api || HUBTYPE_API_URL
-  const resp = await axios({
-    headers: {
-      Authorization: `Bearer ${session._access_token}`,
-    },
-    method: 'post',
-    url: `${baseUrl}/v1/queues/${queueId}/get_available_agents/`,
-  })
-  return resp.data
-}
-
-export async function getAvailableAgents(
-  session: HubtypeSession
-): Promise<{ agents: HubtypeAgentsInfo[] }> {
-  const baseUrl = session._hubtype_api || HUBTYPE_API_URL
-  const botId = session.bot.id
-  const resp = await axios({
-    headers: {
-      Authorization: `Bearer ${session._access_token}`,
-    },
-    method: 'post',
-    url: `${baseUrl}/v1/bots/${botId}/get_agents/`,
-  })
-  return resp.data
-}
-
-export async function getAgentVacationRanges(
-  session: HubtypeSession,
-  { agentId, agentEmail }: { agentId?: string; agentEmail?: string }
-): Promise<{ vacation_ranges: VacationRange[] }> {
-  const baseUrl = session._hubtype_api || HUBTYPE_API_URL
-  const botId = session.bot.id
-  const resp = await axios({
-    headers: {
-      Authorization: `Bearer ${session._access_token}`,
-    },
-    method: 'get',
-    url: `${baseUrl}/v1/bots/${botId}/get_agent_vacation_ranges/`,
-    params: { agent_id: agentId, agent_email: agentEmail },
-  })
-  return resp.data
-}
-
-export function cancelHandoff(
-  session: SessionWithBotonicAction,
-  typification: string | null = null
-): void {
-  let action = 'discard_case'
-  if (typification) action = `${action}:${JSON.stringify({ typification })}`
-  session._botonic_action = action
-}
-
-export function deleteUser(session: SessionWithBotonicAction): void {
-  session._botonic_action = `delete_user`
-}

package/src/hubtype-service.ts

@@ -1,266 +0,0 @@
-import axios, { AxiosResponse } from 'axios'
-import Pusher, { AuthOptions, Channel } from 'pusher-js'
-import Channels from 'pusher-js/types/src/core/channels/channels'
-
-import { Input, SessionUser } from './index'
-import { getWebpackEnvVar } from './utils'
-
-interface UnsentInput {
-  id: string
-  ack: number
-  unsentInput: Input
-}
-interface BotonicHeaders {
-  'X-BOTONIC-USER-ID': string
-  'X-BOTONIC-LAST-MESSAGE-ID': string
-  'X-BOTONIC-LAST-MESSAGE-UPDATE-DATE': string
-}
-interface ServerConfig {
-  activityTimeout?: number
-  pongTimeout?: number
-}
-interface HubtypeServiceArgs {
-  appId: string
-  user: SessionUser
-  lastMessageId: string
-  lastMessageUpdateDate: string
-  onEvent: any
-  unsentInputs: () => UnsentInput[]
-  server: ServerConfig
-}
-
-const _WEBCHAT_PUSHER_KEY_ = getWebpackEnvVar(
-  // @ts-ignore
-  typeof WEBCHAT_PUSHER_KEY !== 'undefined' && WEBCHAT_PUSHER_KEY,
-  'WEBCHAT_PUSHER_KEY',
-  '434ca667c8e6cb3f641c'
-)
-const _HUBTYPE_API_URL_ = getWebpackEnvVar(
-  // @ts-ignore
-  typeof HUBTYPE_API_URL !== 'undefined' && HUBTYPE_API_URL,
-  'HUBTYPE_API_URL',
-  'https://api.hubtype.com'
-)
-
-const ACTIVITY_TIMEOUT = 20 * 1000 // https://pusher.com/docs/channels/using_channels/connection#activitytimeout-integer-
-const PONG_TIMEOUT = 5 * 1000 // https://pusher.com/docs/channels/using_channels/connection#pongtimeout-integer-
-
-/**
- * Calls Hubtype APIs from Webchat
- */
-export class HubtypeService {
-  appId: string
-  user: SessionUser
-  lastMessageId: string
-  lastMessageUpdateDate: string
-  onEvent: any
-  unsentInputs: () => UnsentInput[]
-  pusher: Pusher | null
-  channel: Channel
-  server: ServerConfig
-  PUSHER_CONNECT_TIMEOUT_MS = 10000
-  constructor({
-    appId,
-    user,
-    lastMessageId,
-    lastMessageUpdateDate,
-    onEvent,
-    unsentInputs,
-    server,
-  }: HubtypeServiceArgs) {
-    this.appId = appId
-    this.user = user || {}
-    this.lastMessageId = lastMessageId
-    this.lastMessageUpdateDate = lastMessageUpdateDate
-    this.onEvent = onEvent
-    this.unsentInputs = unsentInputs
-    this.server = server
-    if (this.user.id && (lastMessageId || lastMessageUpdateDate)) {
-      // It's safe not awaiting Promise because:
-      // * it will never be called from AWS lambda
-      // * though init() is called again from postMesage, it does nothing if Pusher already created
-      // @ts-ignore
-      this.init()
-    }
-  }
-
-  /**
-   * @returns {Promise<void>}
-   */
-  init(user, lastMessageId, lastMessageUpdateDate): Promise<void> {
-    if (user) this.user = user
-    if (lastMessageId) this.lastMessageId = lastMessageId
-    if (lastMessageUpdateDate)
-      this.lastMessageUpdateDate = lastMessageUpdateDate
-    return this._initPusher()
-  }
-
-  /**
-   * @returns {Promise<void>}
-   */
-  _initPusher(): Promise<void> {
-    if (this.pusher) return Promise.resolve()
-    if (!this.user.id || !this.appId) {
-      // TODO recover user & appId somehow
-      return Promise.reject('No User or appId. Clear cache and reload')
-    }
-    this.pusher = new Pusher(_WEBCHAT_PUSHER_KEY_, {
-      cluster: 'eu',
-      authEndpoint: `${_HUBTYPE_API_URL_}/v1/provider_accounts/webhooks/webchat/${this.appId}/auth/`,
-      forceTLS: true,
-      auth: {
-        headers: this.constructHeaders(),
-      } as AuthOptions,
-      ...this.resolveServerConfig(),
-    })
-    this.channel = this.pusher.subscribe(this.pusherChannel)
-    const connectionPromise = new Promise<void>((resolve, reject) => {
-      const cleanAndReject = msg => {
-        // eslint-disable-next-line @typescript-eslint/no-use-before-define
-        clearTimeout(connectTimeout)
-        this.destroyPusher()
-        reject(msg)
-      }
-      const connectTimeout = setTimeout(
-        () => cleanAndReject('Connection Timeout'),
-        this.PUSHER_CONNECT_TIMEOUT_MS
-      )
-      this.channel.bind('pusher:subscription_succeeded', () => {
-        // Once subscribed, we know that authentication has been done: https://pusher.com/docs/channels/server_api/authenticating-users
-        this.onConnectionRegained()
-        clearTimeout(connectTimeout)
-        resolve()
-      })
-      this.channel.bind('botonic_response', data => this.onPusherEvent(data))
-      this.channel.bind('update_message_info', data => this.onPusherEvent(data))
-
-      this.pusher &&
-        this.pusher.connection.bind('error', event => {
-          if (event.type == 'WebSocketError') this.handleConnectionChange(false)
-          else {
-            const errorMsg =
-              event.error && event.error.data
-                ? event.error.data.code || event.error.data.message
-                : 'Connection error'
-            cleanAndReject(`Pusher error (${errorMsg})`)
-          }
-        })
-    })
-    this.pusher.connection.bind('state_change', states => {
-      if (states.current === 'connecting') this.updateAuthHeaders()
-      if (states.current === 'connected') this.handleConnectionChange(true)
-      if (states.current === 'unavailable') this.handleConnectionChange(false)
-    })
-
-    return connectionPromise
-  }
-
-  constructHeaders(): BotonicHeaders {
-    const headers = {}
-    if (this.user && this.user.id) headers['X-BOTONIC-USER-ID'] = this.user.id
-    if (this.lastMessageId)
-      headers['X-BOTONIC-LAST-MESSAGE-ID'] = this.lastMessageId
-    if (this.lastMessageUpdateDate)
-      headers['X-BOTONIC-LAST-MESSAGE-UPDATE-DATE'] = this.lastMessageUpdateDate
-    return headers as BotonicHeaders
-  }
-
-  resolveServerConfig(): ServerConfig {
-    if (!this.server) {
-      return { activityTimeout: ACTIVITY_TIMEOUT, pongTimeout: PONG_TIMEOUT }
-    }
-    return {
-      activityTimeout: this.server.activityTimeout || ACTIVITY_TIMEOUT,
-      pongTimeout: this.server.pongTimeout || PONG_TIMEOUT,
-    }
-  }
-
-  updateAuthHeaders(): void {
-    if (this.pusher) {
-      this.pusher.config.auth.headers = {
-        ...this.pusher.config.auth.headers,
-        ...this.constructHeaders(),
-      }
-    }
-  }
-
-  handleConnectionChange(online: boolean): void {
-    this.onPusherEvent({ action: 'connectionChange', online })
-  }
-
-  onPusherEvent(event: any): void {
-    if (this.onEvent && typeof this.onEvent === 'function') this.onEvent(event)
-  }
-
-  get pusherChannel(): string {
-    return `private-encrypted-${this.appId}-${this.user.id}`
-  }
-
-  handleSentInput(message: any): void {
-    this.onEvent({
-      action: 'update_message_info',
-      message: { id: message.id, ack: 1 },
-    })
-  }
-
-  handleUnsentInput(message: any): void {
-    this.onEvent({
-      action: 'update_message_info',
-      message: { id: message.id, ack: 0, unsentInput: message },
-    })
-  }
-
-  /**
-   * @return {Promise<void>}
-   */
-  async postMessage(user: SessionUser, message: any): Promise<void> {
-    try {
-      // @ts-ignore
-      await this.init(user)
-      await axios.post(
-        `${_HUBTYPE_API_URL_}/v1/provider_accounts/webhooks/webchat/${this.appId}/`,
-        {
-          sender: this.user,
-          message: message,
-        },
-        {
-          validateStatus: status => status === 200,
-        }
-      )
-      this.handleSentInput(message)
-    } catch (e) {
-      this.handleUnsentInput(message)
-    }
-    return Promise.resolve()
-  }
-
-  static async getWebchatVisibility({
-    appId,
-  }: {
-    appId: string
-  }): Promise<AxiosResponse<any>> {
-    return axios.get(
-      `${_HUBTYPE_API_URL_}/v1/provider_accounts/${appId}/visibility/`
-    )
-  }
-
-  destroyPusher(): void {
-    if (!this.pusher) return
-    this.pusher.disconnect()
-    this.pusher.unsubscribe(this.pusherChannel)
-    this.pusher.unbind_all()
-    this.pusher.channels = {} as Channels
-    this.pusher = null
-  }
-
-  async onConnectionRegained(): Promise<void> {
-    await this.resendUnsentInputs()
-  }
-
-  async resendUnsentInputs(): Promise<void> {
-    for (const message of this.unsentInputs()) {
-      message.unsentInput &&
-        (await this.postMessage(this.user, message.unsentInput))
-    }
-  }
-}

package/src/i18n.ts

@@ -1,12 +0,0 @@
-// eslint-disable-next-line filenames/match-regex
-import { Locales } from './index'
-
-export const getString = (
-  locales: Locales,
-  locale: string,
-  stringID: string
-): string => {
-  let l = stringID.split('.').reduce((o, i) => o[i], locales[locale])
-  if (l instanceof Array) l = l[Math.floor(Math.random() * l.length)]
-  return String(l)
-}