@amityco/ts-sdk 0.0.1-be4fc2f.0 → 0.0.1-bef76fa.0

package/src/channel/api/queryChannels.ts

@@ -1,8 +1,12 @@
-import { getActiveClient } from '~/client/api'
+import { getActiveClient } from '~/client/api';
 
-import { decoratePayload, toPage, toToken } from '~/core/query'
-import { ingestInCache } from '~/core/cache'
-import { toRecord } from '~/core/model'
+import { toPage, toToken } from '~/core/query';
+import { getResolver } from '~/core/model';
+
+import { pushToCache, pullFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+import { prepareChannelPayload } from '../utils';
 
 /**
  * ```js
@@ -20,50 +24,55 @@ import { toRecord } from '~/core/model'
  * @async
  */
 export const queryChannels = async (
-  query?: {
-    displayName?: string
-    membership?: 'all' | 'member' | 'notMember'
-    sortBy?: ('displayName' | 'firstCreated' | 'lastCreated')
-    types?: Amity.ChannelType
-    page?: Amity.Page
-  }
-) => {
-  const client = getActiveClient()
-  client.log('channel/queryChannels', query)
+  query?: Amity.QueryChannels,
+): Promise<Amity.Cached<Amity.Paged<Amity.Channel>>> => {
+  const client = getActiveClient();
+  client.log('channel/queryChannels', query);
 
   // safe decapsulation
-  const {
-    page,
-    displayName,
-    membership,
-    ...params
-  } = query ?? {}
+  const { page = { limit: 10 }, displayName, membership, ...params } = query ?? {};
 
   // API-FIX: parameters should be querystring.
   // API-FIX: backend doesnt answer Amity.Response
   // const { data } = await client.http.get<Amity.Response<Amity.Paged<ChannelPayload>>>(
-  const { data } = await client.http.get<Amity.ChannelPayload & Amity.Pagination>(
-    `/api/v3/channels`, { params: {
-      ...params,
-      keyword: displayName,
-      filter: membership,
-      options: {
-        token: toToken(page, 'skiplimit'),
+  const { data: queryPayload } = await client.http.get<Amity.ChannelPayload & Amity.Pagination>(
+    `/api/v3/channels`,
+    {
+      params: {
+        ...params,
+        keyword: displayName,
+        filter: membership,
+        options: {
+          token: toToken(page, 'skiplimit'),
+        },
       },
-    } }
-  )
+    },
+  );
+
+  const { paging, ...payload } = queryPayload;
 
-  const { paging, ...response } = data
+  const data = prepareChannelPayload(payload);
 
-  decoratePayload(response as unknown as Record<string, any[]>)
-  ingestInCache(response as unknown as Record<string, any[]>)
+  const { channels } = data;
 
-  const prevPage = toPage(paging?.previous)
-  const nextPage = toPage(paging?.next)
+  const cachedAt = client.cache && Date.now();
+
+  if (client.cache) {
+    ingestInCache(data as Amity.ChannelPayload, { cachedAt });
+
+    const cacheKey = [
+      'channel',
+      'query',
+      { ...params, options: { ...page } } as Amity.Serializable,
+    ];
+    pushToCache(cacheKey, { channels: channels.map(getResolver('channel')), paging });
+  }
 
-  const { channels } = response
-  return { data: toRecord(channels), prevPage, nextPage }
-}
+  const nextPage = toPage(paging.next);
+  const prevPage = toPage(paging.previous);
+
+  return { data: channels, cachedAt, prevPage, nextPage };
+};
 
 /**
  * ```js
@@ -79,11 +88,34 @@ export const queryChannels = async (
  * @category Channel API
  */
 queryChannels.locally = (
-  query: Parameters<typeof queryChannels>[0],
-) => {
-  const client = getActiveClient()
-  client.log('channel/queryChannels.locally', query)
+  query?: Parameters<typeof queryChannels>[0],
+): Amity.Cached<Amity.Paged<Amity.Channel>> | undefined => {
+  const client = getActiveClient();
+  client.log('channel/queryChannels.locally', query);
+
+  const { page = { limit: 10 }, ...params } = query ?? {};
+
+  const cacheKey = ['channel', 'query', { ...params, options: { ...page } } as Amity.Serializable];
+
+  const { data, cachedAt } =
+    pullFromCache<
+      {
+        channels: Pick<Amity.Channel, 'channelId'>[];
+      } & Amity.Pagination
+    >(cacheKey) ?? {};
+
+  if (!data?.channels.length) return;
+
+  const channels: Amity.Channel[] = data.channels
+    // ck -> cacheKey, abbrevated to avoid confusion from the above cache key
+    .map(ck => pullFromCache<Amity.Channel>(['channel', 'get', ck])!)
+    .filter(Boolean)
+    .map(({ data }) => data);
 
-  // TODO
+  const prevPage = toPage(data?.paging.previous);
+  const nextPage = toPage(data?.paging.next);
 
-}
+  return channels.length === data?.channels?.length
+    ? { data: channels, cachedAt, prevPage, nextPage }
+    : undefined;
+};

package/src/channel/api/removeChannelMembers.ts

@@ -1,8 +1,9 @@
-import { getActiveClient } from '~/client/api'
+import { getActiveClient } from '~/client/api';
 
-import { decoratePayload } from '~/core/query'
-import { ingestInCache } from '~/core/cache'
-import { fireEvent } from '~/core/events'
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { fireEvent } from '~/core/events';
+
+import { prepareChannelPayload } from '../utils';
 
 /**
  * ```js
@@ -21,25 +22,32 @@ import { fireEvent } from '~/core/events'
  */
 export const removeChannelMembers = async (
   channelId: Amity.Channel['channelId'],
-  userIds: Amity.User['userId'][]
-) => {
-  const client = getActiveClient()
-  client.log('channel/removeChannelMembers', channelId, userIds)
-
-  const { data } = await client.http.delete<Amity.ChannelMembershipPayload>(
-    `/api/v3/channels/${channelId}/users`,
-    { data: { channelId, userIds } }
-  )
-
-  decoratePayload(data)
-  ingestInCache(data)
-  fireEvent('v3.channel.didRemoveUsers', {
-    channels: data.channels!,
-  })
-
-  const { channelUsers } = data
+  userIds: Amity.User['userId'][],
+): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('channel/removeChannelMembers', channelId, userIds);
+
+  const { data: payload } = await client.http.delete<Amity.ChannelMembershipPayload>(
+    `/api/v3/channels/${encodeURIComponent(channelId)}/users`,
+    { data: { channelId, userIds } },
+  );
+
+  const data = prepareChannelPayload(payload);
+
+  if (client.cache) ingestInCache(data);
+
+  /*
+   * should fire event for each user that was removed
+   */
+  userIds.forEach(id =>
+    fireEvent('v3.channel.didRemoveUsers', {
+      ...data,
+      channelUsers: data.channelUsers.filter(u => u.userId === id),
+    }),
+  );
+
+  const { channelUsers } = data;
   return !!channelUsers.find(
-    channelUser =>
-      channelUser.channelId === channelId && channelUser.membership !== 'member'
-  )
-}
+    channelUser => channelUser.channelId === channelId && channelUser.membership !== 'member',
+  );
+};

package/src/channel/api/removeChannelMembersRole.ts

@@ -1,7 +1,8 @@
-import { getActiveClient } from '~/client/api'
+import { getActiveClient } from '~/client/api';
 
-import { decoratePayload } from '~/core/query'
-import { ingestInCache } from '~/core/cache'
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+import { prepareChannelPayload } from '../utils';
 
 /**
  * ```js
@@ -22,22 +23,22 @@ import { ingestInCache } from '~/core/cache'
 export const removeChannelMembersRole = async (
   channelId: Amity.Channel['channelId'],
   roleId: Amity.Role['roleId'],
-  userIds: Amity.User['userId'][]
-) => {
-  const client = getActiveClient()
-  client.log('channel/removeChannelMembersRole', channelId, roleId, userIds)
+  userIds: Amity.User['userId'][],
+): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('channel/removeChannelMembersRole', channelId, roleId, userIds);
+
+  const { data: payload } = await client.http.delete<Amity.ChannelMembershipPayload>(
+    `/api/v3/channels/${encodeURIComponent(channelId)}/users/roles`,
+    { data: { channelId, role: roleId, userIds } },
+  );
 
-  const { data } = await client.http.delete<Amity.ChannelMembershipPayload>(
-    `/api/v3/channels/${channelId}/users/roles`,
-    { data: { channelId, role: roleId, userIds } }
-  )
+  const data = prepareChannelPayload(payload);
 
-  decoratePayload(data)
-  ingestInCache(data)
+  if (client.cache) ingestInCache(data);
 
-  const { channelUsers } = data
+  const { channelUsers } = data;
   return !!channelUsers.find(
-    channelUser =>
-      channelUser.channelId === channelId && !channelUser.roles.includes(roleId)
-  )
-}
+    channelUser => channelUser.channelId === channelId && !channelUser.roles.includes(roleId),
+  );
+};

package/src/channel/api/startReading.ts

@@ -0,0 +1,46 @@
+import { getActiveClient } from '~/client/api';
+import { synchronousWSCall } from '~/core/transports';
+
+/**
+ * ```js
+ * import { startReading } from '@amityco/ts-sdk'
+ * const success = await startReading('foo')
+ * ```
+ *
+ * Mark all messages as read and start reading message inside channel
+ *
+ * @param {string} channelId - The channel ID to start reading.
+ * @param {string} userId - The user ID of channel member.
+ * @return {Promise<boolean>>} A success boolean if the channel reading of the channel had begun.
+ *
+ * @category Message API
+ * @async
+ */
+export const startReading = async (channelId: string, userId = getActiveClient().userId) => {
+  const client = getActiveClient();
+  client.log('message/startReading', { channelId });
+
+  const result = await synchronousWSCall<Record<never, never>>(client, 'channel.startReading', {
+    channelId,
+  });
+
+  // TODO: Implement optimistic update for `readyToSegment`
+  // const cachedChannel = pullFromCache<Amity.Channel>(['channel', 'get', channelId]);
+  // const cachedMember = pullFromCache<Amity.Membership<'channel'>>(['channelUsers', 'get', userId]);
+  //
+  // if (cachedChannel && cachedMember) {
+  //   fireEvent('v3.channel.didMarkSeen', {
+  //     channelUsers: [
+  //       {
+  //         ...cachedMember.data,
+  //         readToSegment: cachedChannel.data.messageCount ?? 0,
+  //       },
+  //     ],
+  //     channels: [],
+  //     users: [],
+  //     files: [],
+  //   });
+  // }
+
+  return !!result;
+};

package/src/channel/api/stopReading.ts

@@ -0,0 +1,27 @@
+import { getActiveClient } from '~/client/api';
+import { synchronousWSCall } from '~/core/transports';
+
+/**
+ * ```js
+ * import { stopReading } from '@amityco/ts-sdk'
+ * const success = await stopReading('foo')
+ * ```
+ *
+ * Stop reading message inside channel
+ *
+ * @param {string} channelId - The channel ID to stop reading.
+ * @return {Promise<boolean>>} A success boolean if the channel reading was halted.
+ *
+ * @category Message API
+ * @async
+ */
+export const stopReading = async (channelId: string) => {
+  const client = getActiveClient();
+  client.log('message/stopReading', { channelId });
+
+  const result = await synchronousWSCall<Record<never, never>>(client, 'channel.stopReading', {
+    channelId,
+  });
+
+  return !!result;
+};

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

@@ -0,0 +1,123 @@
+import { getResolver } from '~/core/model';
+import { pullFromCache, enableCache, disableCache } from '~/cache/api';
+
+import {
+  client,
+  pause,
+  channelUserQueryResponse,
+  channelUser1,
+  channelUser3,
+  channel11,
+  user11,
+} 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 });
+
+    unsub();
+  });
+
+  test('it should fire event with all new members by attaching a user', async () => {
+    enableCache();
+    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, user: user11 },
+    );
+
+    unsub();
+    disableCache();
+  });
+
+  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/createChannel.test.ts

@@ -0,0 +1,52 @@
+import { pullFromCache, enableCache, disableCache } from '~/cache/api';
+
+import { client, channelPayload } from '~/utils/tests';
+
+import { createChannel } from '../createChannel';
+
+const resPayload = { data: channelPayload };
+
+describe('createChannel', () => {
+  test('it should create a channel', async () => {
+    client.http.post = jest.fn().mockResolvedValueOnce(resPayload);
+
+    const res = await createChannel({ type: 'community' });
+
+    expect(res).toBeDefined();
+    expect(res.data).toStrictEqual(channelPayload.channels[0]);
+  });
+
+  test('it should add channel to cache', async () => {
+    enableCache();
+
+    client.http.post = jest.fn().mockResolvedValueOnce(resPayload);
+    const { channelId } = channelPayload.channels[0];
+
+    await createChannel({ type: 'community' });
+    const data = pullFromCache(['channel', 'get', channelId]);
+
+    expect(data).toBeDefined();
+    expect(data?.data).toStrictEqual(channelPayload.channels[0]);
+
+    disableCache();
+  });
+
+  test('it should call conversation channel with /conversation api', async () => {
+    const mockFn = jest.fn();
+    client.http.post = mockFn.mockResolvedValueOnce(resPayload);
+    const expected = '/api/v3/channels/conversation';
+    const expectedPayload = { type: 'conversation', isDistinct: true };
+
+    await createChannel({ type: 'conversation' });
+    const [recieved, recievedPayload] = mockFn.mock.lastCall;
+
+    expect(recieved).toBe(expected);
+    expect(recievedPayload).toStrictEqual(expectedPayload);
+  });
+
+  test('it should return an error', async () => {
+    client.http.post = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(createChannel({ type: 'conversation' })).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/joinChannel.test.ts

@@ -0,0 +1,52 @@
+import { pullFromCache, enableCache, disableCache } from '~/cache/api';
+import { getResolver } from '~/core/model';
+
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  channel11,
+  user11,
+  channelUser1,
+  channelUserQueryResponse,
+} from '~/utils/tests';
+
+import { joinChannel } from '../joinChannel';
+
+describe('joinChannel', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  const { channelId } = channel11;
+
+  test('it should return channelUser', async () => {
+    client.http.post = jest.fn().mockResolvedValueOnce(channelUserQueryResponse);
+
+    const recieved = await joinChannel(channelId);
+
+    expect(recieved).toBe(true);
+  });
+
+  test('it should update cache', async () => {
+    enableCache();
+
+    const expected = channelUser1;
+    client.http.post = jest.fn().mockResolvedValueOnce(channelUserQueryResponse);
+
+    const didJoinChannel = await joinChannel(channelId);
+
+    const resolverId = getResolver('channelUsers')({ channelId, userId: user11.userId });
+    const recieved = pullFromCache(['channelUsers', 'get', resolverId]);
+
+    expect(didJoinChannel).toBe(true);
+    expect(recieved?.data).toStrictEqual(expected);
+
+    disableCache();
+  });
+
+  test('it should throw error', async () => {
+    client.http.post = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(joinChannel(channelId)).rejects.toThrow('error');
+  });
+});