@amityco/ts-sdk 7.8.3-1fdb2885.0 → 7.8.3-b5109db.0

package/dist/utils/tests/client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../src/utils/tests/client.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,UAAU,YAAS,CAAC;AAYjC,eAAO,MAAM,MAAM,cAA4B,CAAC;AAMhD,eAAO,MAAM,aAAa,qBAiBzB,CAAC;AAEF,eAAO,MAAM,gBAAgB,qBAE5B,CAAC;;AAEF,wBAAkB"}
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../src/utils/tests/client.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,UAAU,YAAS,CAAC;AAYjC,eAAO,MAAM,MAAM,cAA4B,CAAC;AAMhD,eAAO,MAAM,aAAa,qBAuBzB,CAAC;AAEF,eAAO,MAAM,gBAAgB,qBAE5B,CAAC;;AAEF,wBAAkB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amityco/ts-sdk",
-  "version": "7.8.3-1fdb2885.0",
+  "version": "7.8.3-b5109db.0",
   "license": "CC-BY-ND-4.0",
   "author": "amity.co <developers@amity.co> (https://amity.co)",
   "description": "Amity Social Cloud Typescript SDK",
@@ -43,6 +43,7 @@
     "@types/jest": "^27.5.1",
     "@types/node": "^18.6.4",
     "@types/object-hash": "^3.0.6",
+    "@types/socket.io-client": "^1.4.34",
     "chalk": "^4.1.2",
     "concurrently": "^6.1.0",
     "form-data": "^4.0.0",
@@ -66,6 +67,7 @@
     "mitt": "^3.0.0",
     "mqtt": "^4.3.7",
     "object-hash": "^3.0.0",
-    "react-native-uuid": "^2.0.1"
+    "react-native-uuid": "^2.0.1",
+    "socket.io-client": "2.2.0"
   }
 }

package/src/@types/domains/client.ts

@@ -45,6 +45,7 @@ declare global {
       http: AxiosInstance;
       upload: AxiosInstance;
       mqtt?: Amity.MqttClient;
+      ws?: SocketIOClient.Socket;
       emitter: Emitter<Amity.Events>;
 
       hasPermission: (permission: string) => Amity.PermissionChecker;

package/src/client/api/createClient.ts

@@ -73,6 +73,7 @@ export const createClient = (
   let mqtt;
 
   if (rteEnabled) {
+    ws = createWebsocketTransport(httpEndpoint);
     mqtt = createMqttTransport(mqttEndpoint);
   }
 

package/src/client/api/isConnected.ts

@@ -16,5 +16,12 @@ export const isConnected = (): boolean => {
   const client = getActiveClient();
   client.log('client/api/isConnected', client);
 
-  return !!(client.userId && String(client.http.defaults.headers.common?.Authorization)?.length);
+  // if client is connected to ws, it means client is connected. If ws is undefined, it means ws is not used.
+  const isWsConnected = (client.ws && client.ws.connected) || !!client.ws;
+
+  return !!(
+    client.userId &&
+    String(client.http.defaults.headers.common?.Authorization)?.length &&
+    isWsConnected
+  );
 };

package/src/client/api/login.ts

@@ -122,6 +122,12 @@ export const login = async (
       return false;
     }
 
+    // FIXME: events are duplicated if connectClient is called few times without disconnectClient
+    // wire websocket events to our event emitter
+    proxyWebsocketEvents(client.ws, client.emitter);
+
+    client.ws?.open();
+
     client.userId = user.userId;
 
     client.sessionHandler = sessionHandler;

package/src/client/api/logout.ts

@@ -26,6 +26,10 @@ export const logout = async (): Promise<boolean> => {
     client.mqtt.disconnect();
   }
 
+  if (client.ws && client.ws.connected) {
+    client.ws.disconnect();
+  }
+
   /*
    * for cases when session state is terminated (example on ban) or token expired,
    * the terminating block will set session state to terminated or for the or
@@ -42,7 +46,8 @@ export const logout = async (): Promise<boolean> => {
     setSessionState(Amity.SessionStates.NOT_LOGGED_IN);
 
   client.emitter.all.clear();
-
+  // FIXME: it removes listener in ws.ts, it breaks global ban event
+  client.ws?.removeAllListeners();
   client.mqtt?.removeAllListeners();
   client.userId = undefined;
   client.token = undefined;
@@ -54,6 +59,8 @@ export const logout = async (): Promise<boolean> => {
     isUserDeleted: false,
   };
 
+  if (client.ws) client.ws.io.opts.query = { token: '' };
+
   if (typeof document !== 'undefined') {
     document.cookie = '_ascSession=; expires=Thu, 01 Jan 1970 00:00:00 UTC; path=/;';
   }

package/src/client/api/resumeSession.ts

@@ -97,6 +97,9 @@ const validateAccessToken = async ({ token, userId }: Params) => {
     isUserDeleted: false,
   };
 
+  // manually setup the token for ws transport
+  if (client.ws) client.ws.io.opts.query = { token: token.accessToken };
+
   client.token = token;
 
   setSessionState(Amity.SessionStates.ESTABLISHED);
@@ -149,6 +152,9 @@ export const resumeSession = async (
       if (client.mqtt && client.mqtt.connected) {
         client.mqtt.disconnect();
       }
+      if (client.ws && client.ws.connected) {
+        client.ws.disconnect();
+      }
 
       // Clear existing subscriptions
       subscriptions.forEach(fn => fn());
@@ -184,6 +190,12 @@ export const resumeSession = async (
       return false;
     }
 
+    // FIXME: events are duplicated if connectClient is called few times without disconnectClient
+    // wire websocket events to our event emitter
+    proxyWebsocketEvents(client.ws, client.emitter);
+
+    client.ws?.open();
+
     client.userId = user.userId;
 
     client.sessionHandler = sessionHandler;

package/src/client/api/tests/createClient.test.ts

@@ -13,6 +13,12 @@ describe('createClient', () => {
     expect(client.http).toBeDefined();
   });
 
+  test('it should define ws transport', () => {
+    const client = createClient('test-api-key');
+
+    expect(client.ws).toBeDefined();
+  });
+
   test('it should define mqtt transport', () => {
     const client = createClient('test-api-key');
 

package/src/client/api/tests/login.test.ts

@@ -12,62 +12,71 @@ const sessionHandler: Amity.SessionHandler = {
 };
 
 const onConnect = () =>
-  describe('login', () => {
-    beforeEach(() => {
-      client = createClient('key', 'sg');
-      client.mqtt.connect = jest.fn();
-      client.mqtt.subscribe = jest.fn();
-      client.http.post = jest.fn().mockResolvedValueOnce(sessionResponse);
+  setTimeout(() => {
+    const CONNECT_PACKET = { type: 0, nsp: client.ws.nsp };
 
-      setActiveClient(client);
-    });
+    client.ws.emit('connect');
 
-    afterEach(async () => {
-      if (client.sessionState === Amity.SessionStates.ESTABLISHED) await disconnectClient();
-    });
+    // simulate a connection ack packet from server
+    client.ws.io.emit('packet', CONNECT_PACKET);
+  }, 50);
 
-    test('it should connect client', async () => {
-      onConnect().unref();
+describe('login', () => {
+  beforeEach(() => {
+    client = createClient('key', 'sg');
+    client.mqtt.connect = jest.fn();
+    client.mqtt.subscribe = jest.fn();
+    client.http.post = jest.fn().mockResolvedValueOnce(sessionResponse);
 
-      const recieved = await login({ userId: user11.userId }, sessionHandler);
+    setActiveClient(client);
+  });
 
-      expect(recieved).toBe(true);
-    });
+  afterEach(async () => {
+    if (client.sessionState === Amity.SessionStates.ESTABLISHED) await disconnectClient();
+  });
 
-    test('it should establish connection', async () => {
-      onConnect().unref();
+  test('it should connect client', async () => {
+    onConnect().unref();
 
-      await login({ userId: user11.userId }, sessionHandler);
-      const { sessionState } = client;
+    const recieved = await login({ userId: user11.userId }, sessionHandler);
 
-      expect(sessionState).toBe(Amity.SessionStates.ESTABLISHED);
-    });
+    expect(recieved).toBe(true);
+  });
 
-    test('it should have session state establishing while connecting client', () => {
-      login({ userId: user11.userId }, sessionHandler);
+  test('it should establish connection', async () => {
+    onConnect().unref();
 
-      expect(client.sessionState).toBe(Amity.SessionStates.ESTABLISHING);
-    });
+    await login({ userId: user11.userId }, sessionHandler);
+    const { sessionState } = client;
+
+    expect(sessionState).toBe(Amity.SessionStates.ESTABLISHED);
+  });
 
-    test('it should have session state notLoggedIn on failure', async () => {
-      client.http.post = jest
-        .fn()
-        .mockRejectedValue(
-          new ASCApiError('unauthorzed', Amity.ServerError.UNAUTHORIZED, Amity.ErrorLevel.FATAL),
-        );
+  test('it should have session state establishing while connecting client', () => {
+    login({ userId: user11.userId }, sessionHandler);
 
-      await expect(login({ userId: user11.userId }, sessionHandler)).rejects.toThrow('unauthorzed');
-      expect(client.sessionState).toBe(Amity.SessionStates.NOT_LOGGED_IN);
-    });
+    expect(client.sessionState).toBe(Amity.SessionStates.ESTABLISHING);
+  });
+
+  test('it should have session state notLoggedIn on failure', async () => {
+    client.http.post = jest
+      .fn()
+      .mockRejectedValue(
+        new ASCApiError('unauthorzed', Amity.ServerError.UNAUTHORIZED, Amity.ErrorLevel.FATAL),
+      );
+
+    await expect(login({ userId: user11.userId }, sessionHandler)).rejects.toThrow('unauthorzed');
+    expect(client.sessionState).toBe(Amity.SessionStates.NOT_LOGGED_IN);
+  });
 
-    test('it should terminate session on ban', async () => {
-      onConnect().unref();
+  test('it should terminate session on ban', async () => {
+    onConnect().unref();
 
-      await login({ userId: user11.userId }, sessionHandler);
+    await login({ userId: user11.userId }, sessionHandler);
 
-      // ban user
-      client.emitter.emit('user.didGlobalBan', {} as Amity.UserPayload);
+    // ban user
+    client.emitter.emit('user.didGlobalBan', {} as Amity.UserPayload);
 
-      expect(client.sessionState).toBe(Amity.SessionStates.TERMINATED);
-    });
+    expect(client.sessionState).toBe(Amity.SessionStates.TERMINATED);
   });
+});

package/src/client/api/tests/logout.test.ts

@@ -3,18 +3,23 @@ import { client, connectClient, message11 as message } from '~/utils/tests';
 
 import { logout } from '..';
 
+const disconnect = () => setTimeout(() => client.ws.emit('disconnect'), 500);
+
 describe('logout', () => {
   beforeEach(async () => {
     await connectClient();
   });
 
   test('it should disconnect client', async () => {
+    disconnect().unref();
+
     const recieved = await logout();
 
     expect(recieved).toBe(true);
   });
 
   test('it should set sesion state to notLoggedIn after disconnect', async () => {
+    disconnect().unref();
     await logout();
 
     expect(client.sessionState).toBe(Amity.SessionStates.NOT_LOGGED_IN);
@@ -22,6 +27,7 @@ describe('logout', () => {
 
   test('it should not update sesion state if session state terminated', async () => {
     client.sessionState = Amity.SessionStates.TERMINATED;
+    disconnect().unref();
 
     await logout();
 
@@ -29,6 +35,8 @@ describe('logout', () => {
   });
 
   test('it should clear userId and accessToken on disconnect', async () => {
+    disconnect().unref();
+
     await logout();
 
     expect(client.userId).toBeUndefined();
@@ -36,12 +44,15 @@ describe('logout', () => {
   });
 
   test('it should clear auth header on disconnect', async () => {
+    disconnect().unref();
+
     await logout();
 
     expect(client.http.defaults.headers.common.Authorization).toBeFalsy();
   });
 
   test('it should clear cache on disconnect', async () => {
+    disconnect().unref();
     enableCache();
 
     const cacheKey = ['message', 'get', message.messageId];
@@ -54,7 +65,7 @@ describe('logout', () => {
 
   test('it should not clear cache if tokenExpired', async () => {
     client.sessionState = Amity.SessionStates.TOKEN_EXPIRED;
-
+    disconnect().unref();
     enableCache();
 
     const cacheKey = ['message', 'get', message.messageId];

package/src/client/api/tests/resumeSession.test.ts

@@ -24,141 +24,150 @@ const mockUserResponse = {
 };
 
 const onConnect = () =>
-  describe('resumeSession', () => {
-    beforeEach(() => {
-      client = createClient('key', 'sg');
-      client.mqtt?.connect && (client.mqtt.connect = jest.fn());
-      client.mqtt?.subscribe && (client.mqtt.subscribe = jest.fn());
-      client.http.get = jest.fn().mockResolvedValueOnce(mockUserResponse);
-
-      setActiveClient(client);
-    });
+  setTimeout(() => {
+    const CONNECT_PACKET = { type: 0, nsp: client.ws?.nsp };
 
-    afterEach(async () => {
-      if (client.sessionState === Amity.SessionStates.ESTABLISHED) await disconnectClient();
-    });
+    client.ws?.emit('connect');
 
-    test('it should connect client with access token', async () => {
-      onConnect().unref();
+    // simulate a connection ack packet from server
+    client.ws?.io.emit('packet', CONNECT_PACKET);
+  }, 50);
 
-      const received = await resumeSession(
-        { userId: user11.userId, token: mockToken },
-        sessionHandler,
-      );
+describe('resumeSession', () => {
+  beforeEach(() => {
+    client = createClient('key', 'sg');
+    client.mqtt?.connect && (client.mqtt.connect = jest.fn());
+    client.mqtt?.subscribe && (client.mqtt.subscribe = jest.fn());
+    client.http.get = jest.fn().mockResolvedValueOnce(mockUserResponse);
 
-      expect(received).toBe(true);
-    });
+    setActiveClient(client);
+  });
 
-    test('it should establish connection', async () => {
-      onConnect().unref();
+  afterEach(async () => {
+    if (client.sessionState === Amity.SessionStates.ESTABLISHED) await disconnectClient();
+  });
 
-      await resumeSession({ userId: user11.userId, token: mockToken }, sessionHandler);
-      const { sessionState } = client;
+  test('it should connect client with access token', async () => {
+    onConnect().unref();
 
-      expect(sessionState).toBe(Amity.SessionStates.ESTABLISHED);
-    });
+    const received = await resumeSession(
+      { userId: user11.userId, token: mockToken },
+      sessionHandler,
+    );
 
-    test('it should have session state establishing while connecting client', () => {
-      resumeSession({ userId: user11.userId, token: mockToken }, sessionHandler);
+    expect(received).toBe(true);
+  });
 
-      expect(client.sessionState).toBe(Amity.SessionStates.ESTABLISHING);
-    });
+  test('it should establish connection', async () => {
+    onConnect().unref();
 
-    test('it should have session state notLoggedIn on failure', async () => {
-      client.http.get = jest
-        .fn()
-        .mockRejectedValue(
-          new ASCApiError('unauthorized', Amity.ServerError.UNAUTHORIZED, Amity.ErrorLevel.FATAL),
-        );
-
-      await expect(
-        resumeSession({ userId: user11.userId, token: mockToken }, sessionHandler),
-      ).rejects.toThrow('unauthorized');
-      expect(client.sessionState).toBe(Amity.SessionStates.NOT_LOGGED_IN);
-    });
+    await resumeSession({ userId: user11.userId, token: mockToken }, sessionHandler);
+    const { sessionState } = client;
 
-    test('it should set authorization header with token', async () => {
-      onConnect().unref();
+    expect(sessionState).toBe(Amity.SessionStates.ESTABLISHED);
+  });
 
-      await resumeSession({ userId: user11.userId, token: mockToken }, sessionHandler);
+  test('it should have session state establishing while connecting client', () => {
+    resumeSession({ userId: user11.userId, token: mockToken }, sessionHandler);
 
-      expect(client.http.defaults.headers.common.Authorization).toBe(
-        `Bearer ${mockToken.accessToken}`,
-      );
-      expect(client.upload.defaults.headers.common.Authorization).toBe(
-        `Bearer ${mockToken.accessToken}`,
+    expect(client.sessionState).toBe(Amity.SessionStates.ESTABLISHING);
+  });
+
+  test('it should have session state notLoggedIn on failure', async () => {
+    client.http.get = jest
+      .fn()
+      .mockRejectedValue(
+        new ASCApiError('unauthorized', Amity.ServerError.UNAUTHORIZED, Amity.ErrorLevel.FATAL),
       );
-    });
 
-    test('it should set token metadata', async () => {
-      onConnect().unref();
+    await expect(
+      resumeSession({ userId: user11.userId, token: mockToken }, sessionHandler),
+    ).rejects.toThrow('unauthorized');
+    expect(client.sessionState).toBe(Amity.SessionStates.NOT_LOGGED_IN);
+  });
 
-      await resumeSession({ userId: user11.userId, token: mockToken }, sessionHandler);
+  test('it should set authorization header with token', async () => {
+    onConnect().unref();
 
-      expect(client.token).toEqual(mockToken);
-      expect(client.http.defaults.metadata).toEqual({
-        tokenExpiry: mockToken.expiresAt,
-        isGlobalBanned: false,
-        isUserDeleted: false,
-      });
-    });
+    await resumeSession({ userId: user11.userId, token: mockToken }, sessionHandler);
+
+    expect(client.http.defaults.headers.common.Authorization).toBe(
+      `Bearer ${mockToken.accessToken}`,
+    );
+    expect(client.upload.defaults.headers.common.Authorization).toBe(
+      `Bearer ${mockToken.accessToken}`,
+    );
+  });
 
-    test('it should call user endpoint to validate token', async () => {
-      onConnect().unref();
+  test('it should set token metadata', async () => {
+    onConnect().unref();
 
-      await resumeSession({ userId: user11.userId, token: mockToken }, sessionHandler);
+    await resumeSession({ userId: user11.userId, token: mockToken }, sessionHandler);
 
-      expect(client.http.get).toHaveBeenCalledWith(`/api/v3/users/${user11.userId}`);
+    expect(client.token).toEqual(mockToken);
+    expect(client.http.defaults.metadata).toEqual({
+      tokenExpiry: mockToken.expiresAt,
+      isGlobalBanned: false,
+      isUserDeleted: false,
     });
+  });
 
-    test('it should terminate session on ban', async () => {
-      onConnect().unref();
+  test('it should call user endpoint to validate token', async () => {
+    onConnect().unref();
 
-      await resumeSession({ userId: user11.userId, token: mockToken }, sessionHandler);
+    await resumeSession({ userId: user11.userId, token: mockToken }, sessionHandler);
 
-      // ban user
-      client.emitter.emit('user.didGlobalBan', {} as Amity.UserPayload);
+    expect(client.http.get).toHaveBeenCalledWith(`/api/v3/users/${user11.userId}`);
+  });
 
-      expect(client.sessionState).toBe(Amity.SessionStates.TERMINATED);
-    });
+  test('it should terminate session on ban', async () => {
+    onConnect().unref();
 
-    test('it should reset client state when user is already connected with same userId', async () => {
-      onConnect().unref();
+    await resumeSession({ userId: user11.userId, token: mockToken }, sessionHandler);
 
-      // First connection
-      await resumeSession({ userId: user11.userId, token: mockToken }, sessionHandler);
-      expect(client.sessionState).toBe(Amity.SessionStates.ESTABLISHED);
-      expect(client.userId).toBe(user11.userId);
+    // ban user
+    client.emitter.emit('user.didGlobalBan', {} as Amity.UserPayload);
 
-      // Mock the HTTP call for second connection
-      client.http.get = jest.fn().mockResolvedValueOnce(mockUserResponse);
+    expect(client.sessionState).toBe(Amity.SessionStates.TERMINATED);
+  });
 
-      // Second connection with same userId should treat as token expiry (preserve cache)
-      onConnect().unref();
-      await resumeSession({ userId: user11.userId, token: mockToken }, sessionHandler);
+  test('it should reset client state when user is already connected with same userId', async () => {
+    onConnect().unref();
 
-      // Verify that the client is properly reset and reconnected
-      expect(client.sessionState).toBe(Amity.SessionStates.ESTABLISHED);
-      expect(client.userId).toBe(user11.userId);
-    });
+    // First connection
+    await resumeSession({ userId: user11.userId, token: mockToken }, sessionHandler);
+    expect(client.sessionState).toBe(Amity.SessionStates.ESTABLISHED);
+    expect(client.userId).toBe(user11.userId);
 
-    test('it should preserve cache when resuming session with same userId', async () => {
-      onConnect().unref();
+    // Mock the HTTP call for second connection
+    client.http.get = jest.fn().mockResolvedValueOnce(mockUserResponse);
 
-      // First connection - set some cache data
-      await resumeSession({ userId: user11.userId, token: mockToken }, sessionHandler);
-      if (client.cache) {
-        client.cache.data = { test: 'data' };
-      }
+    // Second connection with same userId should treat as token expiry (preserve cache)
+    onConnect().unref();
+    await resumeSession({ userId: user11.userId, token: mockToken }, sessionHandler);
 
-      // Mock the HTTP call for second connection
-      client.http.get = jest.fn().mockResolvedValueOnce(mockUserResponse);
+    // Verify that the client is properly reset and reconnected
+    expect(client.sessionState).toBe(Amity.SessionStates.ESTABLISHED);
+    expect(client.userId).toBe(user11.userId);
+  });
 
-      // Second connection with same userId
-      onConnect().unref();
-      await resumeSession({ userId: user11.userId, token: mockToken }, sessionHandler);
+  test('it should preserve cache when resuming session with same userId', async () => {
+    onConnect().unref();
 
-      // Cache should be preserved when same userId is used
-      expect(client.cache?.data).toEqual({ test: 'data' });
-    });
+    // First connection - set some cache data
+    await resumeSession({ userId: user11.userId, token: mockToken }, sessionHandler);
+    if (client.cache) {
+      client.cache.data = { test: 'data' };
+    }
+
+    // Mock the HTTP call for second connection
+    client.http.get = jest.fn().mockResolvedValueOnce(mockUserResponse);
+
+    // Second connection with same userId
+    onConnect().unref();
+    await resumeSession({ userId: user11.userId, token: mockToken }, sessionHandler);
+
+    // Cache should be preserved when same userId is used
+    expect(client.cache?.data).toEqual({ test: 'data' });
   });
+});

package/src/client/api/tests/terminateClient.test.ts

@@ -2,12 +2,16 @@ import { client, connectClient } from '~/utils/tests';
 
 import { terminateClient } from '../terminateClient';
 
+const disconnect = () => setTimeout(() => client.ws.emit('disconnect'), 500);
+
 describe('terminateClient', () => {
   beforeAll(async () => {
     await connectClient();
   });
 
   test('it should terminate client session', async () => {
+    disconnect().unref();
+
     const expected = Amity.SessionStates.TERMINATED;
 
     terminateClient();
@@ -16,6 +20,8 @@ describe('terminateClient', () => {
   });
 
   test('it should clear sessionHandler', async () => {
+    disconnect().unref();
+
     terminateClient();
 
     expect(client.sessionHandler).toBeUndefined();

package/src/client/utils/setClientToken.ts

@@ -38,6 +38,9 @@ export const setClientToken = async (params: Parameters<typeof getToken>[0]) =>
     isUserDeleted: false,
   };
 
+  // manually setup the token for ws transport
+  if (client.ws) client.ws.io.opts.query = { token: accessToken };
+
   client.token = { accessToken, issuedAt, expiresAt };
 
   setSessionState(Amity.SessionStates.ESTABLISHED);

package/src/core/events.ts

@@ -43,6 +43,24 @@ export const createEventEmitter = () => {
   return mitt<Amity.Events>();
 };
 
+/**
+ * Wraps the websocket events into the client's event emitter for
+ * abstraction of transport.
+ *
+ * @param ws A websocket connection to listen from
+ * @param emitter An event emitter to wire the events to
+ *
+ * @category Transport
+ * @hidden
+ */
+export const proxyWebsocketEvents = (ws: Amity.Client['ws'], emitter: Amity.Client['emitter']) => {
+  WS_EVENTS.forEach(event => {
+    ws?.on(event, (param: Amity.Events[typeof event]) => {
+      emitter.emit(event, param);
+    });
+  });
+};
+
 export const proxyMqttEvents = (
   mqttClient: Amity.Client['mqtt'],
   emitter: Amity.Client['emitter'],

package/src/core/transports/index.ts

@@ -1,2 +1,3 @@
 export * from './http';
+export * from './ws';
 export * from './mqtt';