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

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

@@ -6,6 +6,7 @@ import {
   channelUser1,
   channelUser4,
   channelUserQueryResponse,
+  channelUserQueryResponsePage3,
   channelUserQueryResponsePage2,
   channel11,
   pause,
@@ -57,24 +58,34 @@ describe('liveChannelMembers', () => {
   const filters: [string, Amity.ChannelMembersLiveCollection, Amity.Membership<'channel'>[]][] = [
     [
       'roles',
-      { channelId, roles: channelUserQueryResponse.data.channelUsers[1].roles },
-      [channelUserQueryResponse.data.channelUsers[1]],
+      { channelId, roles: channelUserQueryResponsePage3.data.channelUsers[0].roles },
+      [channelUserQueryResponsePage3.data.channelUsers[0]],
     ],
     [
       'searched term',
       { channelId, search: 'use' },
-      [channelUserQueryResponse.data.channelUsers[1]],
+      [channelUserQueryResponsePage3.data.channelUsers[0]],
     ],
     [
-      'memberships',
+      'member',
       { channelId, memberships: ['member'] },
-      [channelUserQueryResponse.data.channelUsers[0]],
+      [channelUserQueryResponsePage3.data.channelUsers[0]],
+    ],
+    [
+      'muted members',
+      { channelId, memberships: ['muted'] },
+      [channelUserQueryResponsePage3.data.channelUsers[1]],
+    ],
+    [
+      'banned members',
+      { channelId, memberships: ['banned'] },
+      [channelUserQueryResponsePage3.data.channelUsers[1]],
     ],
   ];
 
   test.each(filters)('it should filter channelUsers by %s', async (filter, params, expected) => {
     const callback = jest.fn();
-    client.http.get = jest.fn().mockResolvedValue(channelUserQueryResponse);
+    client.http.get = jest.fn().mockResolvedValue(channelUserQueryResponsePage3);
 
     liveChannelMembers(params, callback);
     await pause();
@@ -131,6 +142,16 @@ describe('liveChannelMembers', () => {
       'v3.channel.didRemoveUsers',
       channelUser1,
     ],
+    [
+      'it should update channel memeber membership on onChannelMemberBanned',
+      'v3.channel.didBan',
+      { ...channelUser1, membership: 'banned', isBanned: true },
+    ],
+    [
+      'it should update channel memeber membership on onChannelMemberUnbanned',
+      'v3.channel.didUnban',
+      { ...channelUser1, membership: 'none', isBanned: false },
+    ],
   ];
 
   test.each(events)('%s', async (test, event, channelUser) => {
@@ -153,11 +174,32 @@ describe('liveChannelMembers', () => {
 
     snapshot.loading = false;
     // get data based on event
-    if (event === 'v3.channel.didAddUsers') {
-      snapshot.data = [channelUser, ...payload.channelUsers];
-    } else {
-      const deletePayload = payload.channelUsers.filter(u => u.userId !== channelUser.userId);
-      snapshot.data = deletePayload;
+    switch (event) {
+      case 'v3.channel.didAddUsers':
+        snapshot.data = [channelUser, ...payload.channelUsers];
+        break;
+
+      case 'v3.channel.didBan': {
+        const bannedUserIdx = payload.channelUsers.findIndex(u => u.userId === channelUser.userId);
+        payload.channelUsers[bannedUserIdx] = channelUser;
+
+        snapshot.data = payload.channelUsers;
+        break;
+      }
+
+      case 'v3.channel.didUnban': {
+        const unbannedUserIdx = payload.channelUsers.findIndex(
+          u => u.userId === channelUser.userId,
+        );
+        payload.channelUsers[unbannedUserIdx] = channelUser;
+
+        snapshot.data = payload.channelUsers;
+        break;
+      }
+
+      default:
+        // delete payload
+        snapshot.data = payload.channelUsers.filter(u => u.userId !== channelUser.userId);
     }
 
     expect(callback).toHaveBeenNthCalledWith(3, expect.objectContaining(snapshot));

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

@@ -1,11 +1,12 @@
-import { disableCache, enableCache } from '~/cache/api';
+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 {
   client,
+  pause,
   connectClient,
   disconnectClient,
   channel11,
@@ -49,7 +50,7 @@ describe('liveChannels', () => {
     // check if cache data returned (should be empty)
     expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
 
-    await expect(queryChannels()).resolves.toBeTruthy();
+    await pause();
 
     expect(callback).toHaveBeenCalledTimes(2);
 
@@ -63,33 +64,61 @@ describe('liveChannels', () => {
   });
 
   // table for channel filters
-  const filters: [string, Amity.ChannelLiveCollection][] = [
+  const filters: [string, Amity.ChannelLiveCollection, number?][] = [
     ['deleted', { isDeleted: false }],
     ['tagged', { tags: ['tag2'] }],
     ['out excluded tags', { excludeTags: ['tag1'] }],
+    ['member', { membership: 'member' }],
+    ['not member', { membership: 'notMember' }, 1],
+    ['all membership', { membership: 'all' }],
   ];
 
-  test.each(filters)('it should filter %s channels', async (filter, params) => {
-    const callback = jest.fn();
-    client.http.get = jest.fn().mockResolvedValue(channelQueryResponse);
+  test.each(filters)(
+    'it should filter by %s channels',
+    async (filter, params, expectedChannelIdx = 0) => {
+      const callback = jest.fn();
+      client.http.get = jest.fn().mockResolvedValue(channelQueryResponse);
 
-    liveChannels(params, callback);
+      const payload = prepareChannelPayload(channelQueryResponse.data);
+      let snapshotData = [payload.channels[expectedChannelIdx]];
 
-    expect(callback).toHaveBeenCalledTimes(1);
+      // add channel users to cache for testing membership filter
+      if (params.membership) {
+        pushToCache(
+          [
+            'channelUsers',
+            'get',
+            getResolver('channelUsers')({
+              channelId: channelQueryResponse.data.channels[0].channelId,
+              userId: channelUser1.userId,
+            }),
+          ],
+          channelUser1,
+        );
 
-    const snapshot = getSnapshot();
-    // check if cache data returned (should be empty)
-    expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
+        if (params.membership === 'all') {
+          snapshotData = payload.channels;
+        }
+      }
 
-    await expect(queryChannels()).resolves.toBeTruthy();
+      liveChannels(params, callback);
 
-    expect(callback).toHaveBeenCalledTimes(2);
+      expect(callback).toHaveBeenCalledTimes(1);
 
-    snapshot.loading = false;
-    snapshot.data = [channelQueryResponse.data.channels[0]];
+      const snapshot = getSnapshot();
+      // check if cache data returned (should be empty)
+      expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
 
-    expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
-  });
+      await pause();
+
+      expect(callback).toHaveBeenCalledTimes(2);
+
+      snapshot.loading = false;
+      snapshot.data = snapshotData;
+
+      expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
+    },
+  );
 
   test('it should return method to fetch next page', async () => {
     const callback = jest.fn();
@@ -102,7 +131,7 @@ describe('liveChannels', () => {
 
     expect(callback).toHaveBeenCalled();
 
-    await expect(queryChannels()).resolves.toBeTruthy();
+    await pause();
 
     expect(callback.mock.lastCall).toHaveLength(1);
 
@@ -113,7 +142,7 @@ describe('liveChannels', () => {
 
     onNextPage();
 
-    await expect(queryChannels()).resolves.toBeTruthy();
+    await pause();
 
     // 4 -> becuase 1 local & server call each per call (2)
     expect(callback).toHaveBeenCalledTimes(4);
@@ -146,7 +175,7 @@ describe('liveChannels', () => {
 
     liveChannels({}, callback);
 
-    await expect(queryChannels()).resolves.toBeTruthy();
+    await pause();
     expect(callback).toHaveBeenCalledTimes(2);
 
     client.emitter.emit(event, {

package/src/channel/{tests/utils → utils/tests}/prepareChannelPayload.test.ts

@@ -9,7 +9,7 @@ import {
   channelUser2,
 } from '~/utils/tests';
 
-import { prepareChannelPayload } from '../../utils';
+import { prepareChannelPayload } from '../prepareChannelPayload';
 
 beforeAll(async () => {
   await connectClient();

package/src/core/events.ts

@@ -23,6 +23,7 @@ const WS_EVENTS = [
   'v3.channel.didBan',
   'v3.channel.didUnban',
 
+  'v3.message.didFetch',
   'v3.message.didCreate',
   'v3.message.didUpdate',
   'v3.message.didDelete',
@@ -116,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/query/filtering.ts

@@ -1,3 +1,5 @@
+import { getResolver } from '~/core/model';
+import { pullFromCache } from '~/cache/api';
 // Note:
 // this file should contain a suite of filtering utilities to help the
 // local version of the query functions.
@@ -23,3 +25,50 @@ export const filterByPropInclusion = <T = Record<string, unknown>>(
   key: keyof T,
   value: any[] | undefined,
 ) => (value !== undefined ? collection.filter(item => value.includes(item[key])) : collection);
+
+/**
+ * Filter a channel collection by membership of the userId
+ *
+ * @param collection the channel collection to filter
+ * @param membership the membership to be filtered by
+ * @param userId user id to be filtered by
+ * @returns a filtered collection with items only matching the criteria
+ *
+ * @hidden
+ */
+export const filterByChannelMembership = (
+  collection: Amity.Channel[],
+  membership: Amity.ChannelLiveCollection['membership'],
+  userId: Amity.Membership<'channel'>['userId'],
+): Amity.Channel[] => {
+  if (membership === 'all') {
+    return collection;
+  }
+
+  return collection.filter(c => {
+    // get resolver for the channel by user
+    const channelUserCacheKey = getResolver('channelUsers')({
+      channelId: c.channelId,
+      userId,
+    });
+
+    const channelUser = pullFromCache<Amity.Membership<'channel'>>([
+      'channelUsers',
+      'get',
+      channelUserCacheKey,
+    ])?.data;
+
+    // if channel user is defined for user, user is a member
+    if (membership === 'member' && channelUser) {
+      return true;
+    }
+
+    // if channel user by user id not found, user is not a member of that
+    // channel
+    if (membership === 'notMember' && !channelUser) {
+      return true;
+    }
+
+    return false;
+  });
+};

package/src/core/query/query.ts

@@ -2,6 +2,8 @@
 import { isPaged } from './paging';
 import { identifyModelKey } from '~/core/model';
 
+import { CACHE_LIFESPAN } from '~/cache/utils';
+
 /**
  * Type guard to check and cast that a given async function is has the ".locally" property
  *
@@ -71,7 +73,7 @@ export const isLocal = (model?: any): model is Amity.Local => {
  *
  * @hidden
  */
-export const isFresh = (model?: Amity.Cachable, lifeSpan = 0) => {
+export const isFresh = (model?: Amity.Cachable, lifeSpan = CACHE_LIFESPAN) => {
   return Date.now() - (model?.cachedAt ?? 0) <= lifeSpan;
 };
 
@@ -111,12 +113,11 @@ export const createQuery = <Args extends any[], Returned extends any>(
  */
 export const queryOptions = (
   policy: Amity.QueryPolicy,
-  lifeSpan: number = 2 * 60 * 1000, // 2mn
+  lifeSpan: number = CACHE_LIFESPAN, // 1mn
 ): Amity.QueryOptions => {
   if (policy === 'cache_only') return { lifeSpan: Infinity };
-  if (policy === 'server_only') return { lifeSpan: 0 };
 
-  return { lifeSpan };
+  return { lifeSpan: lifeSpan < CACHE_LIFESPAN ? CACHE_LIFESPAN : lifeSpan };
 };
 
 /**
@@ -168,8 +169,10 @@ export const runQuery = <Args extends any[], Returned extends any>(
 ) => {
   let local: Returned | undefined;
 
+  const { lifeSpan } = queryOptions('cache_then_server', options.lifeSpan);
+
   // offline first
-  if (isOffline(func) && options.lifeSpan !== 0) {
+  if (isOffline(func)) {
     try {
       local = isMutator(func) ? func.optimistically(...args) : func.locally(...args);
     } catch (error) {
@@ -182,7 +185,7 @@ export const runQuery = <Args extends any[], Returned extends any>(
       );
     }
 
-    const shouldAbort = isCachable(local) && isFresh(local, options.lifeSpan);
+    const shouldAbort = isCachable(local) && isFresh(local, lifeSpan);
 
     callback?.(
       createSnapshot<Returned>(local, {

package/src/core/tests/query/query.test.ts

@@ -7,6 +7,7 @@ import {
   isFresh,
   queryOptions,
 } from '~/core/query';
+import { CACHE_LIFESPAN } from '~/cache/utils';
 
 describe('Core/Query', () => {
   type isFetcherMockType = jest.Mock<any, any> & {
@@ -90,8 +91,17 @@ describe('Core/Query', () => {
   });
 
   describe('queryOptions', () => {
-    test('should return lifespan 0 if server only', () => {
-      expect(queryOptions('server_only').lifeSpan).toBe(0);
+    test('should return minimum lifeSpan', () => {
+      expect(queryOptions('cache_then_server').lifeSpan).toBe(CACHE_LIFESPAN);
+    });
+
+    test('should return minimum lifeSpan if provided lifeSpan is less than cache lifeSpan', () => {
+      expect(queryOptions('cache_then_server', 0).lifeSpan).toBe(CACHE_LIFESPAN);
+    });
+
+    test('should return provided lifeSpan if provided lifeSpan is more than cache lifeSpan', () => {
+      const value = CACHE_LIFESPAN * 2;
+      expect(queryOptions('cache_then_server', value).lifeSpan).toBe(value);
     });
 
     test('should return lifespan Infinity if cache only', () => {

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/createMessage.ts

@@ -1,9 +1,9 @@
+import { uuid } from '~/core/uuid';
+import { fireEvent } from '~/core/events';
 import { getActiveClient } from '~/client/api';
-
-import { upsertInCache, pullFromCache, pushToCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
-import { fireEvent } from '~/core/events';
-import { uuid } from '~/core/uuid';
+import { UNSYNCED_OBJECT_CACHED_AT_VALUE } from '~/utils/constants';
+import { upsertInCache, pullFromCache, pushToCache } from '~/cache/api';
 
 /**
  * ```js
@@ -25,8 +25,11 @@ import { uuid } from '~/core/uuid';
 export const createMessage = async <T extends Amity.MessageContentType>(
   bundle: Pick<
     Amity.Message<T>,
-    'channelId' | 'parentId' | 'type' | 'data' | 'tags' | 'metadata' | 'mentionees'
-  >,
+    'channelId' | 'parentId' | 'type' | 'tags' | 'metadata' | 'mentionees'
+  > & {
+    data?: Amity.Message<T>['data'];
+    fileId?: Amity.Message<T>['fileId'];
+  },
 ): Promise<Amity.Cached<Amity.Message>> => {
   const client = getActiveClient();
 
@@ -36,10 +39,11 @@ export const createMessage = async <T extends Amity.MessageContentType>(
 
   const cachedAt = client.cache && Date.now();
   if (client.cache) ingestInCache(data, { cachedAt });
-  // no need for event, fired by server
 
   const { messages } = data;
 
+  fireEvent('v3.message.didCreate', { messages });
+
   return {
     data: messages[0],
     cachedAt,
@@ -102,11 +106,13 @@ createMessage.optimistically = (
     ...bundleWithMessageId,
   } as Amity.Message;
 
-  pushToCache(['message', 'get', message.messageId], message, { cachedAt: -1 });
+  const cachedAt = UNSYNCED_OBJECT_CACHED_AT_VALUE;
+
+  pushToCache(['message', 'get', message.messageId], message, { cachedAt });
   fireEvent('v3.message.didCreate', { messages: [message] });
 
   return {
+    cachedAt,
     data: message,
-    cachedAt: -1,
   };
 };

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'
@@ -31,7 +30,8 @@ export const deleteMessage = async (
   );
 
   const deleted = await getMessage(messageId);
-  // no need for event, fired by server
+
+  fireEvent('v3.message.didDelete', { messages: [deleted.data] });
 
   return deleted.data;
 };

package/src/message/api/getMessage.ts

@@ -1,8 +1,13 @@
 import { getActiveClient } from '~/client/api';
 
+import { fireEvent } from '~/core/events';
 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';
+
 /**
  * ```js
  * import { getMessage } from '@amityco/ts-sdk'
@@ -19,20 +24,43 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
  */
 export const getMessage = async (
   messageId: Amity.Message['messageId'],
+  isLive = false,
 ): Promise<Amity.Cached<Amity.Message>> => {
   const client = getActiveClient();
   client.log('message/getMessage', messageId);
 
-  // API-FIX: endpoint should not be /list, parameters should be querystring.
-  const { data } = await client.http.get<Amity.MessagePayload>(
-    `/api/v3/messages/${encodeURIComponent(messageId)}`,
-  );
+  if (!isLive) {
+    console.log(
+      'getMessage will be deprecated on 15th November 2022, please use liveMessage instead.',
+    );
+  }
+
+  isInTombstone('message', messageId);
+
+  let data: Amity.MessagePayload;
+
+  try {
+    // API-FIX: endpoint should not be /list, parameters should be querystring.
+    const response = await client.http.get<Amity.MessagePayload>(
+      `/api/v3/messages/${encodeURIComponent(messageId)}`,
+    );
+
+    data = response.data;
+  } catch (error) {
+    if (checkIfShouldGoesToTombstone((error as Amity.ErrorResponse)?.code)) {
+      pushToTombstone('message', messageId);
+    }
+
+    throw error;
+  }
 
   const cachedAt = client.cache && Date.now();
   if (client.cache) ingestInCache(data, { cachedAt });
 
   const { messages } = data;
 
+  fireEvent('v3.message.didFetch', { messages });
+
   return {
     data: messages.find(message => message.messageId === messageId)!,
     cachedAt,

package/src/message/api/getMessages.ts

@@ -1,5 +1,6 @@
 import { getActiveClient } from '~/client/api';
 
+import { fireEvent } from '~/core/events';
 import { pullFromCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
@@ -31,8 +32,12 @@ export const getMessages = async (
   const cachedAt = client.cache && Date.now();
   if (client.cache) ingestInCache(data, { cachedAt });
 
+  const { messages } = data;
+
+  fireEvent('v3.message.didFetch', { messages });
+
   return {
-    data: data.messages,
+    data: messages,
     cachedAt,
   };
 };