@amityco/ts-sdk 0.0.1-beta.31 → 0.0.1-beta.32

package/dist/message/api/deleteMessage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"deleteMessage.d.ts","sourceRoot":"","sources":["../../../src/message/api/deleteMessage.ts"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,aAAa;gBACb,MAAM,OAAO,CAAC,WAAW,CAAC,GACpC,QAAQ,MAAM,OAAO,CAAC;IAgBzB;;;;;;;;;;;;OAYG;8BAEU,MAAM,OAAO,CAAC,WAAW,CAAC,GACpC,MAAM,MAAM,CAAC,MAAM,OAAO,CAAC,GAAG,SAAS;CAjBzC,CAAC"}
+{"version":3,"file":"deleteMessage.d.ts","sourceRoot":"","sources":["../../../src/message/api/deleteMessage.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,aAAa;gBACb,MAAM,OAAO,CAAC,WAAW,CAAC,GACpC,QAAQ,MAAM,OAAO,CAAC;IAgBzB;;;;;;;;;;;;OAYG;8BAEU,MAAM,OAAO,CAAC,WAAW,CAAC,GACpC,MAAM,MAAM,CAAC,MAAM,OAAO,CAAC,GAAG,SAAS;CAjBzC,CAAC"}

package/dist/message/api/tests/deleteMessage.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=deleteMessage.test.d.ts.map

package/dist/message/api/tests/deleteMessage.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deleteMessage.test.d.ts","sourceRoot":"","sources":["../../../../src/message/api/tests/deleteMessage.test.ts"],"names":[],"mappings":""}

package/dist/message/api/tests/getMessage.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getMessage.test.d.ts","sourceRoot":"","sources":["../../../../src/message/api/tests/getMessage.test.ts"],"names":[],"mappings":""}

package/dist/message/api/tests/getMessages.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=getMessages.test.d.ts.map

package/dist/message/api/tests/getMessages.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getMessages.test.d.ts","sourceRoot":"","sources":["../../../../src/message/api/tests/getMessages.test.ts"],"names":[],"mappings":""}

package/dist/message/api/tests/queryMessages.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=queryMessages.test.d.ts.map

package/dist/message/api/tests/queryMessages.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queryMessages.test.d.ts","sourceRoot":"","sources":["../../../../src/message/api/tests/queryMessages.test.ts"],"names":[],"mappings":""}

package/dist/message/api/tests/updateMessage.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=updateMessage.test.d.ts.map

package/dist/message/api/tests/updateMessage.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"updateMessage.test.d.ts","sourceRoot":"","sources":["../../../../src/message/api/tests/updateMessage.test.ts"],"names":[],"mappings":""}

package/dist/reaction/api/addReaction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"addReaction.d.ts","sourceRoot":"","sources":["../../../src/reaction/api/addReaction.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;KAeK;AACL,eAAO,MAAM,WAAW;oBACP,MAAM,QAAQ,CAAC,eAAe,CAAC,eACjC,MAAM,QAAQ,CAAC,aAAa,CAAC,gBAC5B,MAAM,QAAQ,CAAC,cAAc,CAAC,GAC3C,QAAQ,OAAO,CAAC;IAoBnB;;;;;;;;;;;;;;SAcK;kCAEY,MAAM,aAAa,eACrB,MAAM,QAAQ,CAAC,aAAa,CAAC,gBAC5B,MAAM,QAAQ,CAAC,cAAc,CAAC,GAC3C,OAAO,GAAG,SAAS;CArBrB,CAAC"}
+{"version":3,"file":"addReaction.d.ts","sourceRoot":"","sources":["../../../src/reaction/api/addReaction.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;KAeK;AACL,eAAO,MAAM,WAAW;oBACP,MAAM,QAAQ,CAAC,eAAe,CAAC,eACjC,MAAM,QAAQ,CAAC,aAAa,CAAC,gBAC5B,MAAM,QAAQ,CAAC,cAAc,CAAC,GAC3C,QAAQ,OAAO,CAAC;IAiBnB;;;;;;;;;;;;;;SAcK;kCAEY,MAAM,aAAa,eACrB,MAAM,QAAQ,CAAC,aAAa,CAAC,gBAC5B,MAAM,QAAQ,CAAC,cAAc,CAAC,GAC3C,OAAO,GAAG,SAAS;CArBrB,CAAC"}

package/dist/reaction/api/removeReaction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"removeReaction.d.ts","sourceRoot":"","sources":["../../../src/reaction/api/removeReaction.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;KAeK;AACL,eAAO,MAAM,cAAc;oBACV,MAAM,QAAQ,CAAC,eAAe,CAAC,eACjC,MAAM,QAAQ,CAAC,aAAa,CAAC,gBAC5B,MAAM,QAAQ,CAAC,cAAc,CAAC,GAC3C,QAAQ,OAAO,CAAC;IAkBnB;;;;;;;;;;;;;;SAcK;kCAEY,MAAM,aAAa,eACrB,MAAM,QAAQ,CAAC,aAAa,CAAC,gBAC5B,MAAM,QAAQ,CAAC,cAAc,CAAC,GAC3C,OAAO,GAAG,SAAS;CArBrB,CAAC"}
+{"version":3,"file":"removeReaction.d.ts","sourceRoot":"","sources":["../../../src/reaction/api/removeReaction.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;KAeK;AACL,eAAO,MAAM,cAAc;oBACV,MAAM,QAAQ,CAAC,eAAe,CAAC,eACjC,MAAM,QAAQ,CAAC,aAAa,CAAC,gBAC5B,MAAM,QAAQ,CAAC,cAAc,CAAC,GAC3C,QAAQ,OAAO,CAAC;IAenB;;;;;;;;;;;;;;SAcK;kCAEY,MAAM,aAAa,eACrB,MAAM,QAAQ,CAAC,aAAa,CAAC,gBAC5B,MAAM,QAAQ,CAAC,cAAc,CAAC,GAC3C,OAAO,GAAG,SAAS;CArBrB,CAAC"}

package/dist/reaction/api/tests/addReaction.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=addReaction.test.d.ts.map

package/dist/reaction/api/tests/addReaction.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"addReaction.test.d.ts","sourceRoot":"","sources":["../../../../src/reaction/api/tests/addReaction.test.ts"],"names":[],"mappings":""}

package/dist/reaction/api/tests/removeReaction.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=removeReaction.test.d.ts.map

package/dist/reaction/api/tests/removeReaction.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"removeReaction.test.d.ts","sourceRoot":"","sources":["../../../../src/reaction/api/tests/removeReaction.test.ts"],"names":[],"mappings":""}

package/dist/user/api/getUser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getUser.d.ts","sourceRoot":"","sources":["../../../src/user/api/getUser.ts"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,OAAO;aACV,MAAM,IAAI,CAAC,QAAQ,CAAC,qBAE3B,QAAQ,MAAM,MAAM,CAAC,MAAM,IAAI,CAAC,CAAC;IAwCpC;;;;;;;;;;;;OAYG;oBACwB,MAAM,IAAI,CAAC,QAAQ,CAAC,GAAG,MAAM,MAAM,CAAC,MAAM,IAAI,CAAC,GAAG,SAAS;CAfrF,CAAC"}
+{"version":3,"file":"getUser.d.ts","sourceRoot":"","sources":["../../../src/user/api/getUser.ts"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,OAAO;aACV,MAAM,IAAI,CAAC,QAAQ,CAAC,qBAE3B,QAAQ,MAAM,MAAM,CAAC,MAAM,IAAI,CAAC,CAAC;IAuCpC;;;;;;;;;;;;OAYG;oBACwB,MAAM,IAAI,CAAC,QAAQ,CAAC,GAAG,MAAM,MAAM,CAAC,MAAM,IAAI,CAAC,GAAG,SAAS;CAfrF,CAAC"}

package/dist/user/api/queryUsers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"queryUsers.d.ts","sourceRoot":"","sources":["../../../src/user/api/queryUsers.ts"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,UAAU;aACd;QACL,WAAW,CAAC,EAAE,MAAM,IAAI,CAAC,aAAa,CAAC,CAAC;QACxC,MAAM,CAAC,EAAE,KAAK,GAAG,SAAS,CAAC;QAC3B,MAAM,CAAC,EAAE,aAAa,GAAG,cAAc,GAAG,aAAa,CAAC;QACxD,IAAI,CAAC,EAAE,MAAM,IAAI,CAAC;KACnB,GACA,QAAQ,MAAM,MAAM,CAAC,MAAM,KAAK,CAAC,MAAM,IAAI,CAAC,CAAC,CAAC;IAwCjD;;;;;;;;;;;;;OAaG;oBAEM,WAAW,iBAAiB,CAAC,CAAC,CAAC,CAAC,GACtC,MAAM,MAAM,CAAC,MAAM,KAAK,CAAC,MAAM,IAAI,CAAC,CAAC,GAAG,SAAS;CAlBnD,CAAC"}
+{"version":3,"file":"queryUsers.d.ts","sourceRoot":"","sources":["../../../src/user/api/queryUsers.ts"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,UAAU;aACd;QACL,WAAW,CAAC,EAAE,MAAM,IAAI,CAAC,aAAa,CAAC,CAAC;QACxC,MAAM,CAAC,EAAE,KAAK,GAAG,SAAS,CAAC;QAC3B,MAAM,CAAC,EAAE,aAAa,GAAG,cAAc,GAAG,aAAa,CAAC;QACxD,IAAI,CAAC,EAAE,MAAM,IAAI,CAAC;KACnB,GACA,QAAQ,MAAM,MAAM,CAAC,MAAM,KAAK,CAAC,MAAM,IAAI,CAAC,CAAC,CAAC;IAiDjD;;;;;;;;;;;;;OAaG;oBAEM,WAAW,iBAAiB,CAAC,CAAC,CAAC,CAAC,GACtC,MAAM,MAAM,CAAC,MAAM,KAAK,CAAC,MAAM,IAAI,CAAC,CAAC,GAAG,SAAS;CAlBnD,CAAC"}

package/dist/user/api/tests/queryUsers.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=queryUsers.test.d.ts.map

package/dist/user/api/tests/queryUsers.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queryUsers.test.d.ts","sourceRoot":"","sources":["../../../../src/user/api/tests/queryUsers.test.ts"],"names":[],"mappings":""}

package/dist/utils/tests/dummy/post.d.ts

@@ -1,4 +1,6 @@
-export declare const post1: Amity.Post;
+export declare const post11: Amity.Post;
+export declare const post12: Amity.Post;
+export declare const post13: Amity.Post;
 export declare const posts: {
     targetId: string;
     targetType: Amity.PostTargetType;
@@ -6,4 +8,13 @@ export declare const posts: {
     page2: string[];
     page3: string[];
 };
+export declare const postQueryResponse: {
+    data: {
+        posts: Amity.Post<any>[];
+        files: never[];
+        paging: {
+            next: string;
+        };
+    };
+};
 //# sourceMappingURL=post.d.ts.map

package/dist/utils/tests/dummy/post.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"post.d.ts","sourceRoot":"","sources":["../../../../src/utils/tests/dummy/post.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,KAAK,EAAE,KAAK,CAAC,IAoBzB,CAAC;AAEF,eAAO,MAAM,KAAK;;;;;;CAMjB,CAAC"}
+{"version":3,"file":"post.d.ts","sourceRoot":"","sources":["../../../../src/utils/tests/dummy/post.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,MAAM,EAAE,KAAK,CAAC,IAoB1B,CAAC;AAEF,eAAO,MAAM,MAAM,EAAE,KAAK,CAAC,IAG1B,CAAC;AAEF,eAAO,MAAM,MAAM,EAAE,KAAK,CAAC,IAG1B,CAAC;AAEF,eAAO,MAAM,KAAK;;;;;;CAMjB,CAAC;AAIF,eAAO,MAAM,iBAAiB;;;;;;;;CAQ7B,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amityco/ts-sdk",
-  "version": "0.0.1-beta.31",
+  "version": "0.0.1-beta.32",
   "license": "CC-BY-ND-4.0",
   "author": "amity.co <developers@amity.co> (https://amity.co)",
   "description": "Amity Social Cloud Typescript SDK",
@@ -59,6 +59,7 @@
     "js-base64": "^3.7.2",
     "mitt": "^3.0.0",
     "mqtt": "^4.3.7",
+    "qs": "^6.11.0",
     "react-native-uuid": "^2.0.1",
     "socket.io-client": "2.2.0",
     "ts-jest": "^28.0.3"

package/src/cache/api/backupCache.ts

@@ -1,4 +1,3 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
 import AsyncStorage from '@react-native-async-storage/async-storage';
 
 import { getActiveClient } from '~/client/api/activeClient';

package/src/cache/api/tests/pushToCache.test.ts

@@ -0,0 +1,57 @@
+import { getActiveClient } from '~/client/api';
+import { connectClient, disconnectClient, user11 } from '~/utils/tests';
+
+import { pushToCache, enableCache, disableCache, pullFromCache } from '..';
+import { encodeKey } from '../../utils';
+
+describe('pushToCache', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  describe('- cache enabled', () => {
+    beforeEach(enableCache);
+    afterEach(disableCache);
+
+    const cacheKey = ['user', 'get', user11.userId];
+
+    test('it should return true if data added to cache', () => {
+      const recieved = pushToCache(cacheKey, user11);
+
+      expect(recieved).toBe(true);
+    });
+
+    test('it should add data to cache', () => {
+      const returned = pushToCache(cacheKey, user11);
+      const recieved = pullFromCache(cacheKey)?.data;
+
+      expect(returned).toBe(true);
+      expect(recieved).toBe(user11);
+    });
+
+    test('it should persist data offline', () => {
+      const { cache } = getActiveClient();
+      const encodedKey = encodeKey(cacheKey);
+      const options = { offline: true, cachedAt: Date.now() };
+
+      const addedUser = pushToCache(cacheKey, user11, options);
+
+      const expected = {
+        key: cacheKey,
+        data: user11,
+        ...options,
+      };
+      const recieved = cache?.data[encodedKey];
+
+      expect(addedUser).toBe(true);
+      expect(recieved).toStrictEqual(expected);
+    });
+  });
+
+  describe('- no cache', () => {
+    test('it should return false if no cache', () => {
+      const recieved = pushToCache(['model', 'key', 'modleId'], {});
+
+      expect(recieved).toBe(false);
+    });
+  });
+});

package/src/channel/api/addChannelMembers.ts

@@ -36,7 +36,15 @@ export const addChannelMembers = async (
 
   if (client.cache) ingestInCache(data);
 
-  fireEvent('v3.channel.didAddUsers', data);
+  /*
+   * should fire event for each user that was added
+   */
+  userIds.forEach(id =>
+    fireEvent('v3.channel.didAddUsers', {
+      ...data,
+      channelUsers: data.channelUsers.filter(u => u.userId === id),
+    }),
+  );
 
   const { channelUsers } = data;
   return !!channelUsers.find(

package/src/channel/api/getChannel.ts

@@ -3,6 +3,10 @@ import { getActiveClient } from '~/client/api';
 import { pullFromCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
+import { isInTombstone } from '~/cache/api/isInTombstone';
+import { checkIfShouldGoesToTombstone } from '~/cache/utils';
+import { pushToTombstone } from '~/cache/api/pushToTombstone';
+
 import { prepareChannelPayload } from '../utils';
 
 /**
@@ -25,12 +29,23 @@ export const getChannel = async (
   const client = getActiveClient();
   client.log('channel/getChannel', channelId);
 
-  // API-FIX: endpoint should not be /list, parameters should be querystring.
-  const { data: payload } = await client.http.get<Amity.ChannelPayload>(
-    `/api/v3/channels/${encodeURIComponent(channelId)}`,
-  );
+  isInTombstone('channel', channelId);
+
+  let data: Amity.ChannelPayload<any, Amity.Channel>;
+
+  try {
+    const { data: payload } = await client.http.get<Amity.ChannelPayload>(
+      `/api/v3/channels/${encodeURIComponent(channelId)}`,
+    );
+
+    data = prepareChannelPayload(payload);
+  } catch (error) {
+    if (checkIfShouldGoesToTombstone((error as Amity.ErrorResponse)?.code)) {
+      pushToTombstone('channel', channelId);
+    }
 
-  const data = prepareChannelPayload(payload);
+    throw error;
+  }
 
   const cachedAt = client.cache && Date.now();
   if (client.cache) ingestInCache(data, { cachedAt });

package/src/channel/api/tests/addChannelMembers.test.ts

@@ -0,0 +1,95 @@
+import { getResolver } from '~/core/model';
+import { pullFromCache, enableCache, disableCache } from '~/cache/api';
+
+import {
+  client,
+  pause,
+  channelUserQueryResponse,
+  channelUser1,
+  channelUser3,
+  channel11,
+} from '~/utils/tests';
+
+import { onChannelMemberAdded } from '~/channel/events';
+import { addChannelMembers } from '../addChannelMembers';
+
+describe('addChannelMembers', () => {
+  const { channelId } = channelUserQueryResponse.data.channels[0];
+  const { userId } = channelUser1;
+
+  test('it should add channel members in channel', async () => {
+    client.http.post = jest.fn().mockResolvedValueOnce(channelUserQueryResponse);
+
+    const recieved = await addChannelMembers(channelId, [userId]);
+
+    expect(recieved).toBe(true);
+  });
+
+  test('it should update cache with channel members', async () => {
+    enableCache();
+
+    client.http.post = jest.fn().mockResolvedValueOnce(channelUserQueryResponse);
+
+    const channelUserCacheKey = getResolver('channelUsers')({
+      channelId,
+      userId,
+    });
+
+    const recieved = await addChannelMembers(channelId, [userId]);
+    const channelUser = pullFromCache<Amity.Membership<'channel'>>([
+      'channelUsers',
+      'get',
+      channelUserCacheKey,
+    ])?.data;
+
+    expect(recieved).toBe(true);
+    expect(channelUser).toBeDefined();
+    expect(channelUser).toBe(channelUser1);
+
+    disableCache();
+  });
+
+  test('it should fire event when new members added', async () => {
+    expect.assertions(1);
+
+    client.http.post = jest.fn().mockResolvedValueOnce(channelUserQueryResponse);
+    let dispose;
+
+    const callback = new Promise(resolve => {
+      dispose = onChannelMemberAdded(resolve);
+    }).finally(dispose);
+
+    await addChannelMembers(channelId, [userId]);
+
+    return expect(callback).resolves.not.toThrow();
+  });
+
+  test('it should fire event with all new members', async () => {
+    client.http.post = jest.fn().mockResolvedValueOnce(channelUserQueryResponse);
+
+    const callback = jest.fn();
+    const { userId: userId2 } = channelUser3;
+    const unsub = onChannelMemberAdded(callback);
+
+    const recieved = await addChannelMembers(channelId, [userId, userId2]);
+
+    expect(recieved).toBe(true);
+
+    await pause();
+
+    /*
+     * Assertion below is required to check if the event handler is called with the right
+     * params. It's not enough to check if the handler does not throw
+     */
+    expect(callback).toHaveBeenNthCalledWith(1, { ...channel11 }, { ...channelUser1 });
+    expect(callback).toHaveBeenNthCalledWith(2, { ...channel11 }, { ...channelUser3 });
+
+    unsub();
+  });
+
+  test('it should return an error', async () => {
+    client.http.post = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(addChannelMembers('channelId', [])).rejects.toThrow('error');
+  });
+});

package/src/channel/api/tests/getChannel.test.ts

@@ -0,0 +1,108 @@
+import { ASCApiError } from '~/core/errors';
+import { disableCache, enableCache, pushToCache } from '~/cache/api';
+import { client, channelQueryResponse } from '~/utils/tests';
+
+import { pushToTombstone } from '~/cache/api/pushToTombstone';
+import { isInTombstone } from '~/cache/api/isInTombstone';
+
+import { getChannel } from '../getChannel';
+
+const { channelId } = channelQueryResponse.data.channels[0];
+const channel = channelQueryResponse.data.channels[0];
+
+describe('getChannel', () => {
+  test('it should return a channel', async () => {
+    client.http.get = jest.fn().mockResolvedValueOnce(channelQueryResponse);
+
+    const expected = channel;
+    const { data: received } = await getChannel(channelId);
+
+    expect(received).toStrictEqual(expected);
+  });
+
+  test('it should update cache after fetch from server', async () => {
+    enableCache();
+    client.http.get = jest.fn().mockResolvedValue(channelQueryResponse);
+    await getChannel(channelId);
+
+    expect(getChannel.locally(channelId)).toBeDefined();
+
+    disableCache();
+  });
+
+  test('it should return an error', async () => {
+    client.http.get = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(getChannel(channelId)).rejects.toThrow('error');
+  });
+
+  test('it should return an error if channel in cache but api throws not found', async () => {
+    enableCache();
+    pushToCache(['channel', 'get', channelId], channel, { cachedAt: Date.now() });
+
+    client.http.get = jest
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCApiError('not found!', Amity.ServerError.ITEM_NOT_FOUND, Amity.ErrorLevel.ERROR),
+      );
+
+    await expect(getChannel(channelId)).rejects.toThrow();
+    expect(getChannel.locally(channelId)).toBeUndefined();
+
+    disableCache();
+  });
+});
+
+describe('getChannel locally', () => {
+  test('it should return data from cache', () => {
+    enableCache();
+
+    const cachedAt = Date.now();
+
+    pushToCache(['channel', 'get', channelId], channel, { cachedAt });
+
+    const data = getChannel.locally(channelId);
+
+    expect(data).toBeDefined();
+    expect(data?.data).toEqual(channel);
+    expect(data?.cachedAt).toEqual(cachedAt);
+
+    disableCache();
+  });
+
+  test('should return undefined if channel not in cache', () => {
+    expect(getChannel.locally('non-existent-channel')).toBeUndefined();
+  });
+
+  test('should return undefined if cache not enabled', () => {
+    expect(getChannel.locally(channelId)).toBeUndefined();
+  });
+});
+
+describe('getChannel tombostone', () => {
+  test('it should add channel to tombostone if 404', async () => {
+    enableCache();
+    
+    client.http.get = jest
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCApiError('not found!', Amity.ServerError.ITEM_NOT_FOUND, Amity.ErrorLevel.ERROR),
+      );
+
+    await expect(getChannel(channelId)).rejects.toThrow();
+    expect(() => {
+      isInTombstone('channel', channelId);
+    }).toThrow();
+
+    disableCache();
+  });
+
+  test('it should throw error if channel not found in tombostone', async () => {
+    enableCache();
+
+    pushToTombstone('channel', channelId);
+    await expect(getChannel(channelId)).rejects.toThrow();
+
+    disableCache();
+  });
+});

package/src/channel/api/tests/queryChannels.test.ts

@@ -85,6 +85,26 @@ describe('queryChannels.locally', () => {
     disableCache();
   });
 
+  test('it should return undefined if params do not match', () => {
+    enableCache();
+
+    const { data } = channelQueryResponse;
+    const { channels: expected, paging } = data;
+
+    ingestInCache(data as Amity.ChannelPayload);
+
+    pushToCache(cacheKey, { channels: expected.map(getResolver('channel')), paging });
+
+    const { data: received } = queryChannels.locally()!;
+    const received2 = queryChannels.locally({ displayName: 'test' })!;
+
+    expect(received).toBeDefined();
+    expect(received).toEqual(expected);
+    expect(received2).toBeUndefined();
+
+    disableCache();
+  });
+
   test('it should return undefined if data not in cache', () => {
     enableCache();
 

package/src/channel/events/onChannelMemberAdded.ts

@@ -22,7 +22,7 @@ import { prepareChannelPayload } from '../utils';
  */
 export const onChannelMemberAdded = (
   callback: (channel: Amity.Channel, member: Amity.Membership<'channel'>) => void,
-) => {
+): Amity.Unsubscriber => {
   const client = getActiveClient();
 
   const filter = (payload: Amity.ChannelMembershipPayload) => {

package/src/channel/observers/tests/liveChannels.test.ts

@@ -2,7 +2,6 @@ import { disableCache, enableCache, pushToCache } from '~/cache/api';
 import { getResolver } from '~/core/model';
 
 import { liveChannels } from '../liveChannels';
-import { queryChannels } from '~/channel/api';
 import { prepareChannelPayload } from '../../utils/prepareChannelPayload';
 
 import {

package/src/core/events.ts

@@ -117,7 +117,7 @@ export const createEventSubscriber = <T extends keyof Amity.Events>(
 export const createMqttMessageSubscriber = <T extends keyof Amity.Events>(
   client: Amity.Client,
   namespace: string,
-  event: string,
+  event: T,
   fn: (params: Record<string, unknown>) => void,
 ): Amity.Unsubscriber => {
   return createEventSubscriber(client, namespace, 'message', ([topic, message]) => {

package/src/core/transports/http.ts

@@ -1,4 +1,5 @@
 import axios from 'axios';
+import qs from 'qs';
 import HttpAgent, { HttpsAgent } from 'agentkeepalive';
 
 import { unwrapPayload } from './utils';
@@ -7,23 +8,8 @@ import { unwrapPayload } from './utils';
  * Axios param serializer (for querystring)
  * @hidden
  */
-const stringify = (params: Record<string, unknown>, prefix?: string): string => {
-  return Object.entries(params)
-    .filter(([, value]) => value !== undefined)
-    .map(([name, value]) => {
-      const key = prefix ? `${prefix}[${name}]` : name;
-
-      if (Array.isArray(value)) {
-        return value.map(item => `${key}[]=${item}`).join('&');
-      }
-      if (typeof value !== 'object') {
-        return `${key}=${value}`;
-      }
-
-      // @ts-ignore
-      return stringify(value, prefix ?? name);
-    })
-    .join('&');
+export const stringify = (params: Record<string, unknown>): string => {
+  return qs.stringify(params, { arrayFormat: 'brackets' });
 };
 
 /**

package/src/core/transports/test/http.test.ts

@@ -0,0 +1,83 @@
+import { createHttpTransport, stringify } from '../http';
+
+describe('core/transports', () => {
+  describe('stringify', () => {
+    test('should serializer simple string', () => {
+      const params = { a: 'c' };
+      const url = stringify(params);
+      expect(url).toBe('a=c');
+    });
+
+    test('should serializer empty string', () => {
+      const params = { a: '' };
+      const url = stringify(params);
+      expect(url).toBe('a=');
+    });
+
+    test('should serializer special character', () => {
+      const params = { a: '✓', b: 'ø' };
+      const url = stringify(params);
+      expect(url).toBe('a=%E2%9C%93&b=%C3%B8');
+    });
+
+    test('should serializer boolean', () => {
+      const params = { a: true, b: false };
+      const url = stringify(params);
+      expect(url).toBe('a=true&b=false');
+    });
+
+    test('should serializer null ', () => {
+      const params = { a: null };
+      const url = stringify(params);
+      expect(url).toBe('a=');
+    });
+
+    test('should serializer undefined', () => {
+      const params = { a: undefined };
+      const url = stringify(params);
+      expect(url).toBe('');
+    });
+
+    test('should serializer NaN', () => {
+      const params = { a: NaN };
+      const url = stringify(params);
+      expect(url).toBe('a=NaN');
+    });
+
+    test('should serializer simple array', () => {
+      const params = { a: ['b', 'c', 'd'] };
+      const url = stringify(params);
+      expect(url).toBe('a%5B%5D=b&a%5B%5D=c&a%5B%5D=d');
+    });
+
+    test('should serializer complex array', () => {
+      const params = { a: ['b', { c: 'd' }] };
+      const url = stringify(params);
+      expect(url).toBe('a%5B%5D=b&a%5B%5D%5Bc%5D=d');
+    });
+
+    test('should serializer nested object', () => {
+      const params = { a: { b: 'c' } };
+      const url = stringify(params);
+      expect(url).toBe('a%5Bb%5D=c');
+    });
+
+    test('should serializer deep nested object', () => {
+      const params = { a: { b: { c: { d: { e: { f: { g: { h: { i: 'j' } } } } } } } } };
+      const url = stringify(params);
+      expect(url).toBe('a%5Bb%5D%5Bc%5D%5Bd%5D%5Be%5D%5Bf%5D%5Bg%5D%5Bh%5D%5Bi%5D=j');
+    });
+
+    test('should serializer empty object', () => {
+      const params = { a: { b: [] } };
+      const url = stringify(params);
+      expect(url).toBe('');
+    });
+  });
+
+  describe('createHttpTransport', () => {
+    test('should create axios instance with out error', () => {
+      expect(createHttpTransport('/')).not.toThrow();
+    });
+  });
+});

package/src/message/api/deleteMessage.ts

@@ -1,10 +1,9 @@
 import { getActiveClient } from '~/client/api';
-
-import { getMessage } from './getMessage';
-
 import { pullFromCache, upsertInCache } from '~/cache/api';
 import { fireEvent } from '~/core/events';
 
+import { getMessage } from './getMessage';
+
 /**
  * ```js
  * import { deleteMessage } from '@amityco/ts-sdk'