Chat.Client

You can use instances of this class to control the chat and subscribe to its events. Please see ChatClientApiEvents for the full list of events you can subscribe to.

Example

const chatClient = new Chat.Client({
  project: '<project-id>',
  token: '<api-token>'
})

await chatClient.subscribe([ 'mychannel1', 'mychannel2' ])

chatClient.on('message', (message) => {
  console.log("Received", message.content,
              "on", message.channel,
              "at", message.publishedAt)
})

await chatClient.publish({
  channel: 'mychannel1',
  content: 'hello world'
})

Constructors

constructor

new Client(chatOptions)

Creates a new Chat client.

Parameters

NameTypeDescription
chatOptionsObject-
chatOptions.projectstring

SignalWire project id, e.g. a10d8a9f-2166-4e82-56ff-118bc3a4840f

chatOptions.tokenstring

SignalWire API token

Example

import { Chat } from '@signalwire/realtime-api'

const chatClient = new Chat.Client({
  project: '<project-id>',
  token: '<api-token>'
})

Methods

getMemberState

getMemberState(params): Promise<{ channels: Record<string, ChatChannelState> }>

Returns the states of a member in the specified channels.

Parameters

NameTypeDescription
paramsObject-
params.channels?string | string[]

Channels for which to get the state.

params.memberIdstring

Id of the member for which to get the state.

Returns

Promise<{ channels: Record<string, ChatChannelState> }>

Example

const s = await chatClient.getMemberState({
  channels: ['chan1', 'chan2'],
  memberId: 'my-member-id'
})

s.channels.length;  // 2
s.channels.chan1.state;  // the state object for chan1

getMembers

getMembers(params): Promise<{ members: ChatMemberEntity[] }>

Returns the list of members in the given channel.

Parameters

NameTypeDescription
paramsObject-
params.channelstring

The channel for which to get the list of members.

Returns

Promise<{ members: ChatMemberEntity[] }>

Example

const m = await chatClient.getMembers({ channel: 'my-channel' })

m.members.length;  // 7
m.members[0];  // { id: ..., channel: ..., state: ... }

getMessages

getMessages(params): Promise<{ cursor: PaginationCursor ; messages: ChatMessageEntity[] }>

Returns the list of messages that were sent to the specified channel.

Parameters

NameTypeDescription
paramsObject-
params.channelstring

Channel for which to retrieve the messages.

params.cursor?PaginationCursor

Cursor for pagination.

Returns

Promise<{ cursor: PaginationCursor ; messages: ChatMessageEntity[] }>

Example

const m = await chatClient.getMessages({ channel: 'chan1' })

m.messages.length;  // 23
m.messages[0];  // the most recent message
m.messages[0].member;  // the sender
m.messages[0].content;  // the content
m.messages[0].meta;  // the metadata (if any)

m.cursor.next;  // if not null, there are more messages.

// Get the next page using the cursor
const next = await chatClient.getMessages({
  channel: 'chan1',
  cursor: {
    after: m.cursor.after
  }
})

off

off<T>(event, fn?): EmitterContract<ChatClientApiEvents>

Type parameters

NameType
Textends keyof ChatClientApiEvents

Parameters

NameType
eventT
fn?(...args: ArgumentMap<ChatClientApiEvents>[Extract<T, keyof ChatClientApiEvents>]) => void

Returns

EmitterContract<ChatClientApiEvents>


on

on<T>(event, fn): EmitterContract<ChatClientApiEvents>

Type parameters

NameType
Textends keyof ChatClientApiEvents

Parameters

NameType
eventT
fn(...args: ArgumentMap<ChatClientApiEvents>[Extract<T, keyof ChatClientApiEvents>]) => void

Returns

EmitterContract<ChatClientApiEvents>


once

once<T>(event, fn): EmitterContract<ChatClientApiEvents>

Type parameters

NameType
Textends keyof ChatClientApiEvents

Parameters

NameType
eventT
fn(...args: ArgumentMap<ChatClientApiEvents>[Extract<T, keyof ChatClientApiEvents>]) => void

Returns

EmitterContract<ChatClientApiEvents>


publish

publish(params): Promise<void>

Publish a message into the specified channel.

Parameters

NameTypeDescription
paramsObject-
params.channelstring

Channel in which to send the message.

params.contentany

The message to send. This can be any JSON-serializable object.

params.meta?Record<any, any>

Metadata associated with the message. There are no requirements on the content of metadata.

Returns

Promise<void>

Examples

Publishing a message as a string:

await chatClient.publish({
  channel: 'my-channel',
  content: 'Hello, world.'
})

Publishing a message as an object:

await chatClient.publish({
  channel: 'my-channel',
  content: {
    field_one: 'value_one',
    field_two: 'value_two',
  }
})

removeAllListeners

removeAllListeners<T>(event?): EmitterContract<ChatClientApiEvents>

Type parameters

NameType
Textends keyof ChatClientApiEvents

Parameters

NameType
event?T

Returns

EmitterContract<ChatClientApiEvents>


setMemberState

setMemberState(params): Promise<void>

Sets a state object for a member, for the specified channels. The previous state object will be completely replaced.

Parameters

NameTypeDescription
paramsObject-
params.channelsstring | string[]

Channels for which to set the state.

params.memberIdstring

Id of the member to affect.

params.stateRecord<any, any>

The state to set. There are no requirements on the content of the state.

Returns

Promise<void>

Example

await chatClient.setMemberState({
  channels: ['chan1', 'chan2'],
  state: {
    online: true,
    typing: false
  }
})

subscribe

subscribe(channels): Promise<void>

List of channels for which you want to receive messages.

Note that the subscribe function is idempotent, and calling it again with a different set of channels will not unsubscribe you from the old ones. To unsubscribe, use unsubscribe.

Parameters

NameTypeDescription
channelsstring | string[]

the channels to subscribe to, either in the form of a string (for one channel) or an array of strings.

Returns

Promise<void>

Example

const chatClient = new Chat.Client({
  project: '<project-id>',
  token: '<api-token>'
})

chatClient.on('message', m => console.log(m))

await chatClient.subscribe("my-channel")
await chatClient.subscribe(["chan-2", "chan-3"])

unsubscribe

unsubscribe(channels): Promise<void>

List of channels from which you want to unsubscribe.

Parameters

NameTypeDescription
channelsstring | string[]

the channels to unsubscribe from, either in the form of a string (for one channel) or an array of strings.

Returns

Promise<void>

Example

await chatClient.unsubscribe("my-channel")
await chatClient.unsubscribe(["chan-2", "chan-3"])