@signalwire/js 3.29.2 → 4.0.0-beta.1

package/src/fabric/HTTPClient.ts

@@ -1,154 +0,0 @@
-import jwtDecode from 'jwt-decode'
-import { getLogger, HttpError } from '@signalwire/core'
-import type {
-  GetAddressResponse,
-  GetAddressesParams,
-  RegisterDeviceParams,
-  UnregisterDeviceParams,
-  RegisterDeviceResponse,
-  GetAddressParams,
-  GetAddressResult,
-  GetAddressesResponse,
-  GetAddressesResult,
-  RegisterDeviceResult,
-  GetSubscriberInfoResponse,
-  GetSubscriberInfoResult,
-  FabricUserOptions,
-} from './interfaces'
-import { CreateHttpClient, createHttpClient } from './createHttpClient'
-import { buildPaginatedResult } from '../utils/paginatedResult'
-import { makeQueryParamsUrls } from '../utils/makeQueryParamsUrl'
-import {
-  isGetAddressByIdParams,
-  isGetAddressByNameParams,
-  isGetAddressesResponse,
-} from './utils/typeGuard'
-import { HTTPClientContract } from './interfaces/httpClient'
-
-type JWTHeader = { ch?: string; typ?: string }
-
-// TODO: extends from a Base class to share from core
-export class HTTPClient implements HTTPClientContract {
-  private httpClient: CreateHttpClient
-
-  constructor(public options: FabricUserOptions) {
-    this.httpClient = createHttpClient({
-      baseUrl: `https://${this.httpHost}`,
-      headers: {
-        Authorization: `Bearer ${this.options.token}`,
-      },
-      maxApiRequestRetries: this.options.maxApiRequestRetries,
-      apiRequestRetriesDelay: this.options.apiRequestRetriesDelay,
-      apiRequestRetriesDelayIncrement: this.options.apiRequestRetriesDelayIncrement
-    })
-  }
-
-  get fetch(): CreateHttpClient {
-    return this.httpClient
-  }
-
-  get httpHost() {
-    let decodedJwt: JWTHeader = {}
-    try {
-      decodedJwt = jwtDecode<JWTHeader>(this.options.token, {
-        header: true,
-      })
-    } catch (e) {
-      if (process.env.NODE_ENV !== 'production') {
-        getLogger().debug('[JWTSession] error decoding the JWT')
-      }
-    }
-    // Shouldn't this be other way around?
-    const host = this.options.host || decodedJwt?.ch
-    if (!host) {
-      return 'fabric.signalwire.com'
-    }
-    return `fabric.${host.split('.').splice(1).join('.')}`
-  }
-
-  public async getAddress(params: GetAddressParams): Promise<GetAddressResult> {
-    let path = '/api/fabric/addresses'
-    if (isGetAddressByNameParams(params)) {
-      path = `${path}?name=${params.name}`
-    } else if (isGetAddressByIdParams(params)) {
-      path = `${path}/${params.id}`
-    }
-
-    const { body } = await this.httpClient<
-      GetAddressResponse | GetAddressesResponse
-    >(path)
-    if (isGetAddressesResponse(body)) {
-      // FIXME until the server handles a index lookup by name we need to handle it as a search result
-      if (!body.data[0]) throw new HttpError(404, 'Not Found')
-      return body.data[0]
-    }
-    return body
-  }
-
-  public async getAddresses(
-    params?: GetAddressesParams
-  ): Promise<GetAddressesResult> {
-    const { type, displayName, pageSize, sortBy, sortOrder } = params || {}
-
-    let path = '/api/fabric/addresses'
-
-    const queryParams = new URLSearchParams()
-    if (type) {
-      queryParams.append('type', type)
-    }
-    if (displayName) {
-      queryParams.append('display_name', displayName)
-    }
-    if (pageSize) {
-      queryParams.append('page_size', pageSize.toString())
-    }
-
-    if (sortBy) {
-      queryParams.append('sort_by', sortBy)
-    }
-
-    if (sortOrder) {
-      queryParams.append('sort_order', sortOrder)
-    }
-
-    const queryUrl = makeQueryParamsUrls(path, queryParams)
-    getLogger().debug(`[getAddresses] query URL ${queryUrl}`)
-    const { body } = await this.httpClient<GetAddressesResponse>(queryUrl)
-
-    return buildPaginatedResult(body, this.httpClient)
-  }
-
-  public async registerDevice(
-    params: RegisterDeviceParams
-  ): Promise<RegisterDeviceResult> {
-    const { deviceType, deviceToken } = params
-
-    const path = '/subscriber/devices' as const
-    const { body } = await this.httpClient<RegisterDeviceResponse>(path, {
-      method: 'POST',
-      body: {
-        device_type: deviceType,
-        device_token: deviceToken,
-      },
-    })
-
-    return body
-  }
-
-  public async unregisterDevice(params: UnregisterDeviceParams) {
-    const { id } = params
-
-    const path = `/subscriber/devices/${id}` as const
-    await this.httpClient<void>(path, {
-      method: 'DELETE',
-    })
-  }
-
-  public async getSubscriberInfo(): Promise<GetSubscriberInfoResult> {
-    let path = '/api/fabric/subscriber/info'
-
-    const { body } = await this.httpClient<GetSubscriberInfoResponse>(path)
-
-    return body
-  }
-}

package/src/fabric/IncomingCallManager.test.ts

@@ -1,295 +0,0 @@
-import { IncomingCallManager } from './IncomingCallManager'
-import {
-  CallParams,
-  IncomingCallNotification,
-  IncomingInvite,
-} from './interfaces'
-import { WSClient } from './WSClient'
-
-describe('IncomingCallManager', () => {
-  const mockAnswer = jest.fn()
-  const buildInboundCall = jest
-    .fn()
-    .mockImplementation((_invite: IncomingInvite, _params: CallParams) => ({
-      answer: mockAnswer,
-    }))
-  const executeVertoBye = jest.fn()
-  const client = {
-    logger: {
-      debug: jest.fn(),
-      warn: jest.fn(),
-    },
-  } as unknown as WSClient
-
-  beforeEach(() => {
-    jest.clearAllMocks()
-  })
-
-  const allNotificationListerner = jest.fn()
-  const pnNotificationListerner = jest.fn()
-  const wsNotificationListerner = jest.fn()
-
-  test('it should invoke the proper listeners', () => {
-    const manager = new IncomingCallManager({
-      client,
-      buildInboundCall,
-      executeVertoBye,
-    })
-
-    manager.setNotificationHandlers({
-      all: allNotificationListerner,
-      websocket: wsNotificationListerner,
-      pushNotification: pnNotificationListerner,
-    })
-
-    manager.handleIncomingInvite({
-      source: 'websocket',
-      callID: 'foo1',
-      callee_id_name: 'foo',
-      callee_id_number: 'foo',
-      caller_id_name: 'foo',
-      caller_id_number: 'foo',
-      sdp: 'foo',
-      display_direction: 'foo',
-      nodeId: 'foo',
-    })
-
-    expect(allNotificationListerner).toHaveBeenCalledTimes(1)
-    expect(wsNotificationListerner).toHaveBeenCalledTimes(1)
-    expect(pnNotificationListerner).toHaveBeenCalledTimes(0)
-
-    manager.handleIncomingInvite({
-      source: 'pushNotification',
-      callID: 'foo2',
-      callee_id_name: 'foo',
-      callee_id_number: 'foo',
-      caller_id_name: 'foo',
-      caller_id_number: 'foo',
-      sdp: 'foo',
-      display_direction: 'foo',
-      nodeId: 'foo',
-    })
-
-    expect(allNotificationListerner).toHaveBeenCalledTimes(2)
-    expect(wsNotificationListerner).toHaveBeenCalledTimes(1)
-    expect(pnNotificationListerner).toHaveBeenCalledTimes(1)
-  })
-
-  test('it should not answer the call when the invite is rejected', () => {
-    const manager = new IncomingCallManager({
-      client,
-      buildInboundCall,
-      executeVertoBye,
-    })
-
-    const allNotificationListerner = jest.fn(
-      (notification: IncomingCallNotification) => {
-        notification.invite.reject()
-      }
-    )
-
-    manager.setNotificationHandlers({
-      all: allNotificationListerner,
-    })
-
-    manager.handleIncomingInvite({
-      source: 'websocket',
-      callID: 'foo1',
-      callee_id_name: 'foo',
-      callee_id_number: 'foo',
-      caller_id_name: 'foo',
-      caller_id_number: 'foo',
-      sdp: 'foo',
-      display_direction: 'foo',
-      nodeId: 'foo',
-    })
-
-    expect(allNotificationListerner).toHaveBeenCalledTimes(1)
-    expect(mockAnswer).toBeCalledTimes(0)
-  })
-
-  test('it should answer the call when the invite is accepted', () => {
-    const manager = new IncomingCallManager({
-      client,
-      buildInboundCall,
-      executeVertoBye,
-    })
-
-    const allNotificationListerner = jest.fn(
-      (notification: IncomingCallNotification) => {
-        notification.invite.accept({})
-      }
-    )
-
-    manager.setNotificationHandlers({
-      all: allNotificationListerner,
-    })
-
-    manager.handleIncomingInvite({
-      source: 'websocket',
-      callID: 'foo1',
-      callee_id_name: 'foo',
-      callee_id_number: 'foo',
-      caller_id_name: 'foo',
-      caller_id_number: 'foo',
-      sdp: 'foo',
-      display_direction: 'foo',
-      nodeId: 'foo',
-    })
-
-    expect(allNotificationListerner).toHaveBeenCalledTimes(1)
-  })
-
-  test('it should dedupe overlaping listeners', () => {
-    const manager = new IncomingCallManager({
-      client,
-      buildInboundCall,
-      executeVertoBye,
-    })
-
-    const notificationListerner = jest.fn()
-    manager.setNotificationHandlers({
-      all: notificationListerner,
-      websocket: notificationListerner,
-      pushNotification: notificationListerner,
-    })
-
-    manager.handleIncomingInvite({
-      source: 'websocket',
-      callID: 'foo',
-      callee_id_name: 'foo',
-      callee_id_number: 'foo',
-      caller_id_name: 'foo',
-      caller_id_number: 'foo',
-      sdp: 'foo',
-      display_direction: 'foo',
-      nodeId: 'foo',
-    })
-
-    expect(notificationListerner).toHaveBeenCalledTimes(1)
-  })
-
-  test('it should dedupe invites', () => {
-    const manager = new IncomingCallManager({
-      client,
-      buildInboundCall,
-      executeVertoBye,
-    })
-
-    manager.setNotificationHandlers({
-      all: allNotificationListerner,
-    })
-
-    manager.handleIncomingInvite({
-      source: 'websocket',
-      callID: 'same-id',
-      callee_id_name: 'foo',
-      callee_id_number: 'foo',
-      caller_id_name: 'foo',
-      caller_id_number: 'foo',
-      sdp: 'foo',
-      display_direction: 'foo',
-      nodeId: 'foo',
-    })
-
-    manager.handleIncomingInvite({
-      source: 'websocket',
-      callID: 'same-id',
-      callee_id_name: 'foo',
-      callee_id_number: 'foo',
-      caller_id_name: 'foo',
-      caller_id_number: 'foo',
-      sdp: 'foo',
-      display_direction: 'foo',
-      nodeId: 'foo',
-    })
-
-    expect(allNotificationListerner).toHaveBeenCalledTimes(1)
-  })
-
-  test('it should clean up invites after reject', () => {
-    const manager = new IncomingCallManager({
-      client,
-      buildInboundCall,
-      executeVertoBye,
-    })
-
-    const notificationListerner = jest.fn(
-      (notification: IncomingCallNotification) => {
-        notification.invite.reject()
-      }
-    )
-    manager.setNotificationHandlers({
-      all: notificationListerner,
-    })
-
-    manager.handleIncomingInvite({
-      source: 'websocket',
-      callID: 'same-id',
-      callee_id_name: 'foo',
-      callee_id_number: 'foo',
-      caller_id_name: 'foo',
-      caller_id_number: 'foo',
-      sdp: 'foo',
-      display_direction: 'foo',
-      nodeId: 'foo',
-    })
-
-    manager.handleIncomingInvite({
-      source: 'websocket',
-      callID: 'same-id',
-      callee_id_name: 'foo',
-      callee_id_number: 'foo',
-      caller_id_name: 'foo',
-      caller_id_number: 'foo',
-      sdp: 'foo',
-      display_direction: 'foo',
-      nodeId: 'foo',
-    })
-
-    expect(notificationListerner).toHaveBeenCalledTimes(2)
-  })
-
-  test('it should clean up invites after accept', () => {
-    const manager = new IncomingCallManager({
-      client,
-      buildInboundCall,
-      executeVertoBye,
-    })
-
-    const notificationListerner = jest.fn(
-      (notification: IncomingCallNotification) => {
-        notification.invite.accept({})
-      }
-    )
-    manager.setNotificationHandlers({
-      all: notificationListerner,
-    })
-
-    manager.handleIncomingInvite({
-      source: 'websocket',
-      callID: 'same-id',
-      callee_id_name: 'foo',
-      callee_id_number: 'foo',
-      caller_id_name: 'foo',
-      caller_id_number: 'foo',
-      sdp: 'foo',
-      display_direction: 'foo',
-      nodeId: 'foo',
-    })
-
-    manager.handleIncomingInvite({
-      source: 'websocket',
-      callID: 'same-id',
-      callee_id_name: 'foo',
-      callee_id_number: 'foo',
-      caller_id_name: 'foo',
-      caller_id_number: 'foo',
-      sdp: 'foo',
-      display_direction: 'foo',
-      nodeId: 'foo',
-    })
-
-    expect(notificationListerner).toHaveBeenCalledTimes(2)
-  })
-})

package/src/fabric/IncomingCallManager.ts

@@ -1,92 +0,0 @@
-import { FabricRoomSession } from './FabricRoomSession'
-import {
-  CallParams,
-  IncomingCallHandlers,
-  IncomingCallNotification,
-  IncomingInvite,
-  IncomingInviteWithSource,
-} from './interfaces'
-import { WSClient } from './WSClient'
-
-interface IncomingCallManagerOptions {
-  client: WSClient
-  buildInboundCall: WSClient['buildInboundCall']
-  executeVertoBye: WSClient['executeVertoBye']
-}
-
-export class IncomingCallManager {
-  private _client: WSClient
-  private _pendingInvites: Record<string, IncomingInvite> = {}
-  private _handlers: IncomingCallHandlers = {}
-
-  constructor(private options: IncomingCallManagerOptions) {
-    this._client = options.client
-  }
-
-  private _buildNotification(invite: IncomingInvite): IncomingCallNotification {
-    const accept = async (params: CallParams) => {
-      return new Promise<FabricRoomSession>((resolve, reject) => {
-        delete this._pendingInvites[invite.callID]
-        try {
-          const call = this.options.buildInboundCall(invite, params)
-          call.answer()
-
-          resolve(call)
-        } catch (e) {
-          reject(e)
-        }
-      })
-    }
-
-    const reject = () => {
-      delete this._pendingInvites[invite.callID]
-      return this.options.executeVertoBye(invite.callID, invite.nodeId)
-    }
-
-    return {
-      invite: {
-        details: invite,
-        accept: (params) => accept(params),
-        reject: () => reject(),
-      },
-    }
-  }
-
-  setNotificationHandlers(handlers: IncomingCallHandlers) {
-    this._handlers.all = handlers.all
-    if (
-      (handlers.pushNotification &&
-        this._handlers.all != handlers.pushNotification) ||
-      !handlers.pushNotification
-    ) {
-      this._handlers.pushNotification = handlers.pushNotification
-    }
-    if (
-      (handlers.websocket && this._handlers.all != handlers.websocket) ||
-      !handlers.websocket
-    ) {
-      this._handlers.websocket = handlers.websocket
-    }
-  }
-
-  handleIncomingInvite(incomingInvite: IncomingInviteWithSource) {
-    if (incomingInvite.callID in this._pendingInvites) {
-      this._client.logger.debug(
-        `skiping nottification for pending invite to callID: ${incomingInvite.callID}`
-      )
-      return
-    }
-    this._pendingInvites[incomingInvite.callID] = incomingInvite
-
-    if (!(this._handlers.all || this._handlers[incomingInvite.source])) {
-      this._client.logger.warn('Skiping nottification due to no listeners')
-      return
-    }
-
-    const notification = this._buildNotification(incomingInvite)
-
-    this._handlers.all?.(notification)
-    const handler = this._handlers[incomingInvite.source]
-    handler?.(notification)
-  }
-}

package/src/fabric/SATSession.test.ts

@@ -1,65 +0,0 @@
-import WS from 'jest-websocket-mock'
-import { SATSession } from './SATSession'
-import { SWCloseEvent, UNIFIED_CONNECT_VERSION } from '@signalwire/core'
-
-jest.mock('uuid', () => {
-  return {
-    v4: jest.fn(() => 'mocked-uuid'),
-  }
-})
-
-describe('SATSession', () => {
-  const host = 'ws://localhost:8080'
-  const project = '2506edbc-35c4-4d9f-a5f0-45a03d82dab1'
-  const token = 'PT1234abc'
-
-  let ws: WS
-  let session: SATSession
-  beforeEach(() => {
-    ws = new WS(host)
-    // Respond to RPCs
-    ws.on('connection', (socket: any) => {
-      socket.on('message', (data: any) => {
-        const parsedData = JSON.parse(data)
-        if (parsedData.params) {
-          socket.send(
-            JSON.stringify({
-              jsonrpc: '2.0',
-              id: parsedData.id,
-              result: {},
-            })
-          )
-        }
-      })
-    })
-
-    session = new SATSession({
-      host,
-      project,
-      token,
-    })
-    session.WebSocketConstructor = WebSocket
-    session.CloseEventConstructor = SWCloseEvent
-    session.dispatch = jest.fn()
-  })
-
-  afterEach(() => {
-    WS.clean()
-  })
-
-  it('should subscribe with the latest version', async () => {
-    session.connect()
-    await ws.connected
-
-    expect(session.connected).toBe(true)
-
-    await expect(ws).toReceiveMessage(
-      expect.stringContaining(JSON.stringify(UNIFIED_CONNECT_VERSION))
-    )
-
-    session.disconnect()
-
-    expect(session.connected).toBe(false)
-    expect(session.closed).toBe(true)
-  })
-})

package/src/fabric/SATSession.ts

@@ -1,102 +0,0 @@
-import {
-  asyncRetry,
-  increasingDelay,
-  JSONRPCRequest,
-  JSONRPCResponse,
-  RPCReauthenticate,
-  RPCReauthenticateParams,
-  SATAuthorization,
-  UNIFIED_CONNECT_VERSION,
-  isConnectRequest,
-  getLogger,
-  isVertoInvite,
-  SYMBOL_EXECUTE_CONNECTION_CLOSED,
-  SYMBOL_EXECUTE_TIMEOUT,
-} from '@signalwire/core'
-import { JWTSession } from '../JWTSession'
-import { SATSessionOptions } from './interfaces'
-/**
- * SAT Session is for the Call Fabric SDK
- */
-export class SATSession extends JWTSession {
-  public connectVersion = UNIFIED_CONNECT_VERSION
-
-  constructor(public options: SATSessionOptions) {
-    super(options)
-  }
-
-  override get signature() {
-    if (this._rpcConnectResult) {
-      const { authorization } = this._rpcConnectResult
-      return (authorization as SATAuthorization).jti
-    }
-    return undefined
-  }
-
-  override async _checkTokenExpiration() {
-    /**
-     * noop
-     *
-     * The Call Fabric SDK does not attach any timer and
-     * does not emit any events to inform the user about the token expiry.
-     */
-  }
-
-  /**
-   * Reauthenticate with the SignalWire Network using a newer SAT.
-   * If the session has expired, this will reconnect it.
-   * @return Promise<void>
-   */
-  override async reauthenticate() {
-    this.logger.debug('Session Reauthenticate', {
-      ready: this.ready,
-      expired: this.expired,
-    })
-    if (!this.ready || this.expired) {
-      return this.connect()
-    }
-
-    const params: RPCReauthenticateParams = {
-      project: this._rpcConnectResult.authorization.project_id,
-      jwt_token: this.options.token,
-    }
-
-    try {
-      const reauthResponse = await this.execute(RPCReauthenticate(params))
-
-      this._rpcConnectResult = {
-        ...this._rpcConnectResult,
-        ...reauthResponse,
-      }
-    } catch (error) {
-      throw error
-    }
-  }
-
-  override async execute(msg: JSONRPCRequest | JSONRPCResponse): Promise<any> {
-    return asyncRetry({
-      asyncCallable: async () => {
-        await this._waitConnected() // avoid queuing a retry
-        return super.execute(msg)
-      },
-      maxRetries: this.options.maxApiRequestRetries,
-      delayFn: increasingDelay({
-        initialDelay: this.options.apiRequestRetriesDelay,
-        variation: this.options.apiRequestRetriesDelayIncrement,
-      }),
-      expectedErrorHandler: (error) => {
-        getLogger().warn(error)
-        if (isConnectRequest(msg)) {
-          // `signalwire.connect` retries are handle by the connection
-          return true
-        }
-        if (isVertoInvite(msg) && ![SYMBOL_EXECUTE_CONNECTION_CLOSED, SYMBOL_EXECUTE_TIMEOUT].includes(error)) {
-          // we can't retry verto.invites after errors on the transport layer
-          getLogger().debug('skip verto.invite retry on error:', error)
-          return true
-        }
-        return false
-      },
-    })
-  }
-}