@signalwire/js 3.29.2 → 4.0.0-beta.0

package/src/pubSub/Client.test.ts

@@ -1,245 +0,0 @@
-/**
- * @jest-environment jsdom
- */
-
-import WS from 'jest-websocket-mock'
-import { Client } from './Client'
-
-describe('PubSubClient Object', () => {
-  const host = 'ws://localhost:1234'
-  const token = '<jwt>'
-
-  let server: WS
-  beforeEach(async () => {
-    server = new WS(host)
-    server.on('connection', (socket) => {
-      socket.on('message', (data: any) => {
-        const parsedData = JSON.parse(data)
-
-        // The error message is not important for the test.
-        // The idea is just to document what's the expected
-        // behavior (reject) or not (resolve).
-        if (
-          parsedData.method === 'chat.unsubscribe' &&
-          (parsedData.params.channels.length === 0 ||
-            parsedData.params.channels.some((ch: any) =>
-              ch.name.endsWith('_error')
-            ))
-        ) {
-          socket.send(
-            JSON.stringify({
-              jsonrpc: '2.0',
-              id: parsedData.id,
-              error: { code: -32600, message: 'Invalid Request' },
-            })
-          )
-        } else {
-          socket.send(
-            JSON.stringify({
-              jsonrpc: '2.0',
-              id: parsedData.id,
-              result: {},
-            })
-          )
-        }
-      })
-    })
-  })
-
-  afterEach(() => {
-    WS.clean()
-  })
-
-  it('should automatically connect when calling either .subscribe() or .publish()', async () => {
-    const pubSub = new Client({
-      host,
-      token,
-    })
-
-    pubSub.on('message', () => {})
-    await pubSub.subscribe(['test'])
-    await pubSub.publish({
-      channel: 'test',
-      content: 'test',
-    })
-
-    const connectMsg = JSON.parse(server.messages[0].toString())
-    expect(connectMsg.method).toBe('signalwire.connect')
-
-    expect(server.messages.length).toBe(3)
-    pubSub.disconnect()
-  })
-
-  it('should emit a single "signalwire.connect" at most when subscribing/publishing at the same time', async () => {
-    const pubSub = new Client({
-      host,
-      token,
-    })
-
-    pubSub.on('message', () => {})
-    await Promise.all([
-      pubSub.subscribe(['test']),
-      pubSub.publish({
-        channel: 'test',
-        content: 'test',
-      }),
-    ])
-
-    const connectMsg = JSON.parse(server.messages[0].toString())
-    expect(connectMsg.method).toBe('signalwire.connect')
-    expect(
-      server.messages.filter((message) => {
-        const parsedMessage = JSON.parse(message.toString())
-
-        return parsedMessage.method === 'signalwire.connect'
-      }).length
-    ).toBe(1)
-    pubSub.disconnect()
-  })
-
-  describe('Subscribe', () => {
-    it('should convert channels into the internal channel notation when calling .subscribe()', async () => {
-      const pubSub = new Client({
-        host,
-        token,
-      })
-
-      pubSub.on('message', () => {})
-      await pubSub.subscribe(['test1', 'test2', 'test3'])
-
-      const subscribeMsg = JSON.parse(server.messages[1].toString())
-      expect(subscribeMsg.params.channels).toStrictEqual([
-        { name: 'test1' },
-        { name: 'test2' },
-        { name: 'test3' },
-      ])
-      pubSub.disconnect()
-    })
-  })
-
-  describe('Publish', () => {
-    it('should support publishing-only mode', async () => {
-      const pubSub = new Client({
-        host,
-        token,
-      })
-
-      const params = {
-        channel: 'test',
-        content: 'test',
-      }
-
-      await pubSub.publish(params)
-
-      server.messages.forEach((message, i) => {
-        const parsedMessage = JSON.parse(message.toString())
-
-        if (i === 0) {
-          expect(parsedMessage.method).toBe('signalwire.connect')
-        } else {
-          expect(parsedMessage.method).toBe('chat.publish')
-          expect(parsedMessage.params).toStrictEqual(params)
-        }
-      })
-
-      pubSub.disconnect()
-    })
-  })
-
-  describe('Unsubscribe', () => {
-    it('should convert channels into the internal channel notation', async () => {
-      const pubSub = new Client({
-        host,
-        token,
-      })
-
-      pubSub.on('message', () => {})
-      await pubSub.subscribe(['test1', 'test2', 'test3'])
-      await pubSub.unsubscribe(['test1', 'test2', 'test3'])
-
-      const unsubscribeMsg = JSON.parse(server.messages[1].toString())
-      expect(unsubscribeMsg.params.channels).toStrictEqual([
-        { name: 'test1' },
-        { name: 'test2' },
-        { name: 'test3' },
-      ])
-      pubSub.disconnect()
-    })
-
-    it('should allow the user to .unsubscribe() from any subgroup of subscribed channels', async () => {
-      expect.assertions(4)
-      const pubSub = new Client({
-        host,
-        token,
-      })
-
-      pubSub.on('message', () => {})
-
-      await pubSub.subscribe(['test1', 'test2', 'test3'])
-      expect(await pubSub.unsubscribe(['test1', 'test3'])).toBeUndefined()
-      expect(await pubSub.unsubscribe(['test1', 'test2'])).toBeUndefined()
-      expect(await pubSub.unsubscribe(['test2', 'test3'])).toBeUndefined()
-      expect(
-        await pubSub.unsubscribe(['test1', 'test2', 'test3'])
-      ).toBeUndefined()
-      pubSub.disconnect()
-    })
-
-    it('should reject if its called before the session is authorized', async () => {
-      expect.assertions(1)
-      const pubSub = new Client({
-        host,
-        token,
-      })
-
-      pubSub.on('message', () => {})
-
-      try {
-        await pubSub.unsubscribe(['test1'])
-      } catch (err) {
-        expect(err.message).toBe(
-          'You must be authenticated to unsubscribe from a channel'
-        )
-      }
-      pubSub.disconnect()
-    })
-
-    it("should reject if it's called without channels", async () => {
-      expect.assertions(1)
-      const pubSub = new Client({
-        host,
-        token,
-      })
-
-      pubSub.on('message', () => {})
-
-      // This is to force the session to be connected when
-      // calling unsubscribe()
-      await pubSub.publish({
-        channel: 'test',
-        content: 'test',
-      })
-
-      await expect(() =>
-        pubSub.unsubscribe(['test1_error'])
-      ).rejects.toBeTruthy()
-      pubSub.disconnect()
-    })
-
-    it('should reject if the user calls .unsubscribe() with channels different than the ones they are subscribed to', async () => {
-      expect.assertions(1)
-      const pubSub = new Client({
-        host,
-        token,
-      })
-
-      pubSub.on('message', () => {})
-
-      await pubSub.subscribe(['test1', 'test2', 'test3', 'test4'])
-      await expect(() =>
-        pubSub.unsubscribe(['test1', 'test5_error'])
-      ).rejects.toBeTruthy()
-      pubSub.disconnect()
-    })
-  })
-})

package/src/pubSub/Client.ts

@@ -1,90 +0,0 @@
-import type {
-  PubSubContract,
-  ConsumerContract,
-  UserOptions,
-  PubSub as PubSubNamespace,
-} from '@signalwire/core'
-import { createClient } from '../createClient'
-
-export interface ClientApiEvents extends PubSubNamespace.BasePubSubApiEvents {}
-
-/** @ignore */
-export interface ClientFullState extends Client {}
-export interface Client
-  extends PubSubContract,
-    Omit<ConsumerContract<ClientApiEvents, ClientFullState>, 'subscribe'> {}
-
-/** @ignore */
-export interface ClientOptions extends UserOptions {}
-
-type ClientMethods = keyof Client
-const INTERCEPTED_METHODS: ClientMethods[] = [
-  'getAllowedChannels',
-  'subscribe',
-  'publish',
-]
-
-/**
- * You can use the Client object to build a messaging system into the browser.
- *
- * Example usage:
- *
- * ```js
- * import { PubSub } from '@signalwire/js'
- *
- * const pubSubClient = new PubSub.Client({
- *   token: '<your pubSub token>', // get this from the REST APIs
- * })
- *
- * await pubSubClient.subscribe([ 'mychannel1', 'mychannel2' ])
- *
- * pubSubClient.on('message', (message) => {
- *   console.log("Received", message.content,
- *               "on", message.channel,
- *               "at", message.publishedAt)
- * })
- *
- * await pubSubClient.publish({
- *   channel: 'mychannel1',
- *   content: 'hello world'
- * })
- * ```
- *
- * ## Events
- *
- * Please see {@link ClientApiEvents} for the list of events emitted by a pubSub
- * Client object.
- */
-export const Client = function (pubSubOptions: ClientOptions) {
-  const client = createClient(pubSubOptions)
-
-  const createInterceptor = <K extends keyof Client>(prop: K) => {
-    return async (...params: Parameters<Client[K]>) => {
-      await client.connect()
-
-      // @ts-expect-error
-      return client.pubSub[prop](...params)
-    }
-  }
-
-  const interceptors = {
-    _session: client,
-    disconnect: () => client.disconnect(),
-  } as const
-
-  return new Proxy<Client>(client.pubSub, {
-    get(target: Client, prop: keyof Client, receiver: any) {
-      if (prop in interceptors) {
-        // @ts-expect-error
-        return interceptors[prop]
-      }
-
-      if (INTERCEPTED_METHODS.includes(prop)) {
-        return createInterceptor(prop)
-      }
-
-      return Reflect.get(target, prop, receiver)
-    },
-  })
-  // For consistency with other constructors we'll make TS force the use of `new`
-} as unknown as { new (pubSubOptions: ClientOptions): Client }

package/src/pubSub/index.ts

@@ -1,10 +0,0 @@
-import { PubSub } from '@signalwire/core'
-import { PagingCursor } from '../utils/interfaces'
-import PubSubMessage = PubSub.PubSubMessage
-
-export * from './Client'
-
-export {
-  PubSubMessage,
-  PagingCursor
-}

package/src/setupTests.ts

@@ -1,122 +0,0 @@
-import { WebSocket } from 'mock-socket'
-
-// Define a mock MediaStreamTrack
-class MockMediaStreamTrack {
-  kind: string
-  private listeners: { [key: string]: Array<() => void> } = {}
-
-  constructor(kind: string) {
-    this.kind = kind
-  }
-
-  addEventListener(event: string, handler: () => void) {
-    if (!this.listeners[event]) {
-      this.listeners[event] = []
-    }
-    this.listeners[event].push(handler)
-  }
-
-  removeEventListener(event: string, handler: () => void) {
-    if (!this.listeners[event]) return
-    this.listeners[event] = this.listeners[event].filter((h) => h !== handler)
-  }
-
-  // Simulate event trigger for testing purposes
-  trigger(event: string) {
-    if (this.listeners[event]) {
-      this.listeners[event].forEach((handler) => handler())
-    }
-  }
-}
-
-global.MediaStreamTrack = MockMediaStreamTrack as any
-
-// Define a mock MediaStream
-class MockMediaStream {
-  tracks: MediaStreamTrack[]
-  constructor(tracks: MediaStreamTrack[]) {
-    this.tracks = tracks
-  }
-  getTracks() {
-    return this.tracks
-  }
-  getVideoTracks() {
-    return this.tracks.filter((track) => track.kind === 'video')
-  }
-}
-
-// Mock MediaStream globally
-global.MediaStream = MockMediaStream as any
-
-class MockHTMLMediaElement {
-  static HAVE_NOTHING = 0
-  readyState: number = MockHTMLMediaElement.HAVE_NOTHING
-}
-
-// Mock global HTMLMediaElement
-;(global as any).HTMLMediaElement = MockHTMLMediaElement
-
-// Define a mock ResizeObserver
-class MockResizeObserver {
-  private callback: ResizeObserverCallback
-  private observedElements = new Map<
-    Element,
-    {
-      contentRect: DOMRectReadOnly
-      contentBoxSize: readonly { inlineSize: number; blockSize: number }[]
-      target: Element
-      borderBoxSize?: readonly { inlineSize: number; blockSize: number }[]
-      devicePixelContentBoxSize?: readonly {
-        inlineSize: number
-        blockSize: number
-      }[]
-    }
-  >()
-
-  constructor(callback: ResizeObserverCallback) {
-    this.callback = callback
-  }
-
-  observe(target: Element) {
-    const entry: ResizeObserverEntry = {
-      contentRect: target.getBoundingClientRect(),
-      contentBoxSize: [
-        { inlineSize: target.clientWidth, blockSize: target.clientHeight },
-      ],
-      target,
-      borderBoxSize: [],
-      devicePixelContentBoxSize: [],
-    }
-
-    this.observedElements.set(target, entry)
-
-    // Trigger callback immediately to simulate initial observation
-    this.callback([entry], this)
-  }
-
-  unobserve(target: Element) {
-    this.observedElements.delete(target)
-  }
-
-  disconnect() {
-    this.observedElements.clear()
-  }
-}
-
-// Mock global ResizeObserver
-global.ResizeObserver = MockResizeObserver
-
-// Define a mock Audio
-class MockAudio {
-  src: string
-  constructor(src: string) {
-    this.src = src
-  }
-  play() {}
-  pause() {}
-}
-
-// Mock global Audio
-global.Audio = MockAudio as any
-
-global.WebSocket = WebSocket