Migration Guide: JavaScript 0.11.0

AccessManager is no longer a required, direct dependency. This changes the way you init your Chat client:

The old way:

1
    let accessManager = new Twilio.Common.AccessManager(token);
2
    let chatClient = new Twilio.Chat.Client(accessManager);

The new way just requires the token to be passed:

    let chatClient = new Twilio.Chat.Client(token);

This does also mean that you have to call the chatClient.updateToken(token) method when needed, rather than using the old AccessManager.

If you still wish to use the convenience AccessManager to help track token lifecycle events, you can use an AccessManager to track a token lifetime if needed. The AccessManager is still found in the Twilio Common library.

The new version of AccessManager would be used as follows:

• client.identity : Now you can access this with client.userInfo.identity. Note that you may access any properties only after the client.initialize() call has succeeded
• channel.messages : In previous versions you could access the list of fetched messages for the channel through the synchronous property channel.messages .
• With the new version you will need to always call channel.getMessages() . Don't worry, we will cache messages for you, so it won't make the performance of your app any worse.

In the previous version to get a user channels list, you had to do something like the following:

1
    chatClient.getChannels()
2
      .filter(channel => (channel.status === 'joined' || channel.status === 'invited'))
3
      .then(result => doSomething);

That approach had multiple issues related to client initialization latency, consumed traffic, etc., so we made a couple of changes:

• User channels (ones which you joined, invited, and your private channels), and public channels lists are separated
• Public channels list consists of special "channelDescriptor" objects, which are much more lightweight so handling a huge catalogue of public channels will be much easier
• We have added a pagination to load channels bit-by-bit

Let's see how it works:

Just populate a list of my channels:

1
    // Function accepts a channels page, which has an array of items and a method `nextPage` to proceed
2
    // to next page, if it exists
3
    function populateChannels(channelsPage) {
4
      channelsPage.items.forEach(channel => drawChannelSomehow);
5
      if(channelsPage.hasNextPage) {
6
        channelsPage.nextPage().then(populateChannels);
7
      }
8
    }
9

10
    chatClient.getUserChannels().then(populateChannels);

Get a public channels list:

1
    chatClient.getPublicChannels().then(channelDescriptorPage => {
2
      // First page of channel descriptor
3
      // Paging works the same way as for user channels
4
      channelDescriptorPage.items.forEach(descriptor => {
5
        console.log('Descriptor for a channel:', descriptor.friendlyName, descriptor.sid);
6
      })
7
    });

Join to the channel from public list

1
    channelDescriptor.getChannel()
2
      .then(channel => channel.join())
3
      .then(channel => { console.log('Joined to the channel', channel.friendlyName);

Also note, that "channelAdded" and "channelRemoved" will be fired only for channels from "User channels" list, not for the public one

We have standardized paging and as such paged resource (currently Message) lists will return a Paginator, not an array as previously.

This now looks as follows:

The anchor argument for getMessages has changed from a String representing a Message sid, to an integer representing the Message index

A set of counter methods is added: channel.getMembersCount(), channel.getMessagesCount(), and channel.getUnconsumedMessagesCount().

Note: These methods are semi-realtime. The data is eventually correct, but may be incorrect for a few seconds, because the Chat system does not provide real-time events for counter value changes.

So this is quite useful for any "unread messages count" badges, but we would not recommend any core application logic based on these counters being accurate in real time.