@amityco/ts-sdk-react-native 7.8.3-e4f1111.0 → 7.8.3

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,qBAuBzB,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,qBAiBzB,CAAC;AAEF,eAAO,MAAM,gBAAgB,qBAE5B,CAAC;;AAEF,wBAAkB"}

package/package.json

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

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

@@ -55,7 +55,6 @@ 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

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

package/src/client/api/isConnected.ts

@@ -16,12 +16,5 @@ export const isConnected = (): boolean => {
   const client = getActiveClient();
   client.log('client/api/isConnected', client);
 
-  // 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
-  );
+  return !!(client.userId && String(client.http.defaults.headers.common?.Authorization)?.length);
 };

package/src/client/api/login.ts

@@ -122,12 +122,6 @@ 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,10 +26,6 @@ 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
@@ -46,8 +42,7 @@ 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;
@@ -59,8 +54,6 @@ 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,9 +97,6 @@ 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);
@@ -152,9 +149,6 @@ 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());
@@ -190,12 +184,6 @@ 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,12 +13,6 @@ 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,71 +12,62 @@ const sessionHandler: Amity.SessionHandler = {
 };
 
 const onConnect = () =>
-  setTimeout(() => {
-    const CONNECT_PACKET = { type: 0, nsp: client.ws.nsp };
+  describe('login', () => {
+    beforeEach(() => {
+      client = createClient('key', 'sg');
+      client.mqtt.connect = jest.fn();
+      client.mqtt.subscribe = jest.fn();
+      client.http.post = jest.fn().mockResolvedValueOnce(sessionResponse);
 
-    client.ws.emit('connect');
+      setActiveClient(client);
+    });
 
-    // simulate a connection ack packet from server
-    client.ws.io.emit('packet', CONNECT_PACKET);
-  }, 50);
+    afterEach(async () => {
+      if (client.sessionState === Amity.SessionStates.ESTABLISHED) await disconnectClient();
+    });
 
-describe('login', () => {
-  beforeEach(() => {
-    client = createClient('key', 'sg');
-    client.mqtt.connect = jest.fn();
-    client.mqtt.subscribe = jest.fn();
-    client.http.post = jest.fn().mockResolvedValueOnce(sessionResponse);
+    test('it should connect client', async () => {
+      onConnect().unref();
 
-    setActiveClient(client);
-  });
+      const recieved = await login({ userId: user11.userId }, sessionHandler);
 
-  afterEach(async () => {
-    if (client.sessionState === Amity.SessionStates.ESTABLISHED) await disconnectClient();
-  });
+      expect(recieved).toBe(true);
+    });
 
-  test('it should connect client', async () => {
-    onConnect().unref();
+    test('it should establish connection', async () => {
+      onConnect().unref();
 
-    const recieved = await login({ userId: user11.userId }, sessionHandler);
+      await login({ userId: user11.userId }, sessionHandler);
+      const { sessionState } = client;
 
-    expect(recieved).toBe(true);
-  });
+      expect(sessionState).toBe(Amity.SessionStates.ESTABLISHED);
+    });
 
-  test('it should establish connection', async () => {
-    onConnect().unref();
+    test('it should have session state establishing while connecting client', () => {
+      login({ userId: user11.userId }, sessionHandler);
 
-    await login({ userId: user11.userId }, sessionHandler);
-    const { sessionState } = client;
-
-    expect(sessionState).toBe(Amity.SessionStates.ESTABLISHED);
-  });
+      expect(client.sessionState).toBe(Amity.SessionStates.ESTABLISHING);
+    });
 
-  test('it should have session state establishing while connecting client', () => {
-    login({ userId: user11.userId }, sessionHandler);
+    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),
+        );
 
-    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);
-  });
+      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,23 +3,18 @@ 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);
@@ -27,7 +22,6 @@ describe('logout', () => {
 
   test('it should not update sesion state if session state terminated', async () => {
     client.sessionState = Amity.SessionStates.TERMINATED;
-    disconnect().unref();
 
     await logout();
 
@@ -35,8 +29,6 @@ describe('logout', () => {
   });
 
   test('it should clear userId and accessToken on disconnect', async () => {
-    disconnect().unref();
-
     await logout();
 
     expect(client.userId).toBeUndefined();
@@ -44,15 +36,12 @@ 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];
@@ -65,7 +54,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,150 +24,141 @@ const mockUserResponse = {
 };
 
 const onConnect = () =>
-  setTimeout(() => {
-    const CONNECT_PACKET = { type: 0, nsp: client.ws?.nsp };
-
-    client.ws?.emit('connect');
+  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);
+    });
 
-    // simulate a connection ack packet from server
-    client.ws?.io.emit('packet', CONNECT_PACKET);
-  }, 50);
+    afterEach(async () => {
+      if (client.sessionState === Amity.SessionStates.ESTABLISHED) await disconnectClient();
+    });
 
-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);
+    test('it should connect client with access token', async () => {
+      onConnect().unref();
 
-    setActiveClient(client);
-  });
+      const received = await resumeSession(
+        { userId: user11.userId, token: mockToken },
+        sessionHandler,
+      );
 
-  afterEach(async () => {
-    if (client.sessionState === Amity.SessionStates.ESTABLISHED) await disconnectClient();
-  });
+      expect(received).toBe(true);
+    });
 
-  test('it should connect client with access token', async () => {
-    onConnect().unref();
+    test('it should establish connection', async () => {
+      onConnect().unref();
 
-    const received = await resumeSession(
-      { userId: user11.userId, token: mockToken },
-      sessionHandler,
-    );
+      await resumeSession({ userId: user11.userId, token: mockToken }, sessionHandler);
+      const { sessionState } = client;
 
-    expect(received).toBe(true);
-  });
+      expect(sessionState).toBe(Amity.SessionStates.ESTABLISHED);
+    });
 
-  test('it should establish connection', async () => {
-    onConnect().unref();
+    test('it should have session state establishing while connecting client', () => {
+      resumeSession({ userId: user11.userId, token: mockToken }, sessionHandler);
 
-    await resumeSession({ userId: user11.userId, token: mockToken }, sessionHandler);
-    const { sessionState } = client;
+      expect(client.sessionState).toBe(Amity.SessionStates.ESTABLISHING);
+    });
 
-    expect(sessionState).toBe(Amity.SessionStates.ESTABLISHED);
-  });
+    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);
+    });
 
-  test('it should have session state establishing while connecting client', () => {
-    resumeSession({ userId: user11.userId, token: mockToken }, sessionHandler);
+    test('it should set authorization header with token', async () => {
+      onConnect().unref();
 
-    expect(client.sessionState).toBe(Amity.SessionStates.ESTABLISHING);
-  });
+      await resumeSession({ userId: user11.userId, token: mockToken }, sessionHandler);
 
-  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),
+      expect(client.http.defaults.headers.common.Authorization).toBe(
+        `Bearer ${mockToken.accessToken}`,
       );
+      expect(client.upload.defaults.headers.common.Authorization).toBe(
+        `Bearer ${mockToken.accessToken}`,
+      );
+    });
 
-    await expect(
-      resumeSession({ userId: user11.userId, token: mockToken }, sessionHandler),
-    ).rejects.toThrow('unauthorized');
-    expect(client.sessionState).toBe(Amity.SessionStates.NOT_LOGGED_IN);
-  });
-
-  test('it should set authorization header with token', async () => {
-    onConnect().unref();
-
-    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 set token metadata', 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.token).toEqual(mockToken);
-    expect(client.http.defaults.metadata).toEqual({
-      tokenExpiry: mockToken.expiresAt,
-      isGlobalBanned: false,
-      isUserDeleted: false,
+      expect(client.token).toEqual(mockToken);
+      expect(client.http.defaults.metadata).toEqual({
+        tokenExpiry: mockToken.expiresAt,
+        isGlobalBanned: false,
+        isUserDeleted: false,
+      });
     });
-  });
 
-  test('it should call user endpoint to validate token', 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);
 
-    expect(client.http.get).toHaveBeenCalledWith(`/api/v3/users/${user11.userId}`);
-  });
+      expect(client.http.get).toHaveBeenCalledWith(`/api/v3/users/${user11.userId}`);
+    });
 
-  test('it should terminate session on ban', async () => {
-    onConnect().unref();
+    test('it should terminate session on ban', 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);
+      // ban user
+      client.emitter.emit('user.didGlobalBan', {} as Amity.UserPayload);
 
-    expect(client.sessionState).toBe(Amity.SessionStates.TERMINATED);
-  });
+      expect(client.sessionState).toBe(Amity.SessionStates.TERMINATED);
+    });
 
-  test('it should reset client state when user is already connected with same userId', async () => {
-    onConnect().unref();
+    test('it should reset client state when user is already connected with same userId', async () => {
+      onConnect().unref();
 
-    // First connection
-    await resumeSession({ userId: user11.userId, token: mockToken }, sessionHandler);
-    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);
 
-    // Mock the HTTP call for second connection
-    client.http.get = jest.fn().mockResolvedValueOnce(mockUserResponse);
+      // Mock the HTTP call for second connection
+      client.http.get = jest.fn().mockResolvedValueOnce(mockUserResponse);
 
-    // Second connection with same userId should treat as token expiry (preserve cache)
-    onConnect().unref();
-    await resumeSession({ userId: user11.userId, token: mockToken }, sessionHandler);
+      // Second connection with same userId should treat as token expiry (preserve cache)
+      onConnect().unref();
+      await resumeSession({ userId: user11.userId, token: mockToken }, sessionHandler);
 
-    // Verify that the client is properly reset and reconnected
-    expect(client.sessionState).toBe(Amity.SessionStates.ESTABLISHED);
-    expect(client.userId).toBe(user11.userId);
-  });
+      // Verify that the client is properly reset and reconnected
+      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();
+    test('it should preserve cache when resuming session with same userId', async () => {
+      onConnect().unref();
 
-    // First connection - set some cache data
-    await resumeSession({ userId: user11.userId, token: mockToken }, sessionHandler);
-    if (client.cache) {
-      client.cache.data = { 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);
+      // 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);
+      // 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' });
+      // 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,16 +2,12 @@ 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();
@@ -20,8 +16,6 @@ describe('terminateClient', () => {
   });
 
   test('it should clear sessionHandler', async () => {
-    disconnect().unref();
-
     terminateClient();
 
     expect(client.sessionHandler).toBeUndefined();

package/src/client/utils/setClientToken.ts

@@ -38,9 +38,6 @@ 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,24 +43,6 @@ 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,3 +1,2 @@
 export * from './http';
-export * from './ws';
 export * from './mqtt';