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

package/src/message/tests/observers/liveMessages.test.ts

@@ -1,17 +1,16 @@
 import { ASCApiError } from '~/core/errors';
 import { disableCache, enableCache } from '~/cache/api';
 import { ENABLE_CACHE_MESSAGE } from '~/utils/constants';
-
-import { queryMessages } from '../../api';
-import { liveMessages } from '../../observers';
-
 import {
   client,
   connectClient,
   disconnectClient,
   messages,
-  message11 as defaultMessage,
+  generateRawMessage,
 } from '~/utils/tests';
+import { convertFromRaw } from '../../utils';
+import { queryMessages } from '../../api';
+import { liveMessages } from '../../observers';
 
 describe('liveMessages', () => {
   beforeAll(async () => {
@@ -28,9 +27,13 @@ describe('liveMessages', () => {
 
   afterEach(disableCache);
 
-  const { channelId } = messages;
+  const { subChannelId } = messages;
   const returnValue = [{ messageId: messages.page1[0] }];
-  const message = { ...defaultMessage, messageId: returnValue[0].messageId, channelId };
+  const rawMessage = generateRawMessage({
+    messageId: returnValue[0].messageId,
+    messageFeedId: subChannelId,
+  });
+  const message = convertFromRaw(rawMessage);
 
   test('it should show message if cache not enabled', () => {
     /*
@@ -47,7 +50,7 @@ describe('liveMessages', () => {
     // call liveMessages check if mocked console get's called with the correct
     // message
     client.use();
-    liveMessages({ channelId }, callback);
+    liveMessages({ subChannelId }, callback);
 
     expect(console.log).toBeCalledWith(ENABLE_CACHE_MESSAGE);
   });
@@ -62,7 +65,7 @@ describe('liveMessages', () => {
       },
     });
 
-    liveMessages({ channelId }, callback);
+    liveMessages({ subChannelId }, callback);
 
     expect(callback).toHaveBeenCalledTimes(1);
 
@@ -75,13 +78,14 @@ describe('liveMessages', () => {
       }),
     );
 
-    await expect(queryMessages({ channelId })).resolves.toBeTruthy();
+    await expect(queryMessages({ subChannelId })).resolves.toBeTruthy();
 
     expect(callback).toHaveBeenCalledTimes(2);
 
     expect(callback).toHaveBeenCalledWith(
       expect.objectContaining({
-        data: returnValue,
+        // @ts-ignore
+        data: returnValue.map(convertFromRaw),
         error: undefined,
         loading: false,
       }),
@@ -99,7 +103,7 @@ describe('liveMessages', () => {
     const callback = jest.fn();
     client.http.get = jest.fn().mockRejectedValue(error);
 
-    liveMessages({ channelId }, callback);
+    liveMessages({ subChannelId }, callback);
 
     expect(callback).toHaveBeenCalledTimes(1);
 
@@ -112,7 +116,7 @@ describe('liveMessages', () => {
       }),
     );
 
-    await expect(queryMessages({ channelId })).rejects.toThrow();
+    await expect(queryMessages({ subChannelId })).rejects.toThrow();
 
     expect(callback).toHaveBeenCalledTimes(2);
 
@@ -141,7 +145,7 @@ describe('liveMessages', () => {
       },
     });
 
-    liveMessages({ channelId, isDeleted: false }, callback);
+    liveMessages({ subChannelId, isDeleted: false }, callback);
 
     expect(callback).toHaveBeenCalledTimes(1);
 
@@ -154,13 +158,14 @@ describe('liveMessages', () => {
       }),
     );
 
-    await expect(queryMessages({ channelId })).resolves.toBeTruthy();
+    await expect(queryMessages({ subChannelId })).resolves.toBeTruthy();
 
     expect(callback).toHaveBeenCalledTimes(2);
 
     expect(callback).toHaveBeenCalledWith(
       expect.objectContaining({
-        data: [returnValue[1]],
+        // @ts-ignore
+        data: [returnValue[1]].map(convertFromRaw),
         error: undefined,
         loading: false,
       }),
@@ -192,11 +197,11 @@ describe('liveMessages', () => {
         },
       });
 
-    liveMessages({ channelId }, callback);
+    liveMessages({ subChannelId }, callback);
 
     expect(callback).toHaveBeenCalled();
 
-    await expect(queryMessages({ channelId })).resolves.toBeTruthy();
+    await expect(queryMessages({ subChannelId })).resolves.toBeTruthy();
 
     expect(callback.mock.lastCall).toHaveLength(1);
 
@@ -207,7 +212,7 @@ describe('liveMessages', () => {
 
     onNextPage();
 
-    await expect(queryMessages({ channelId })).resolves.toBeTruthy();
+    await expect(queryMessages({ subChannelId })).resolves.toBeTruthy();
 
     // 4 -> becuase 1 local & server call each per call (2)
     expect(callback).toHaveBeenCalledTimes(4);
@@ -215,7 +220,8 @@ describe('liveMessages', () => {
     expect(callback).toHaveBeenNthCalledWith(
       4,
       expect.objectContaining({
-        data: [...returnValue2, ...returnValue],
+        // @ts-ignore
+        data: [...returnValue2, ...returnValue].map(convertFromRaw),
         error: undefined,
         loading: false,
       }),
@@ -231,12 +237,12 @@ describe('liveMessages', () => {
       },
     });
 
-    liveMessages({ channelId }, callback);
+    liveMessages({ subChannelId }, callback);
 
-    await expect(queryMessages({ channelId })).resolves.toBeTruthy();
+    await expect(queryMessages({ subChannelId })).resolves.toBeTruthy();
     expect(callback).toHaveBeenCalledTimes(2);
 
-    client.emitter.emit('v3.message.didFetch', { messages: [message] });
+    client.emitter.emit('local.message.fetched', { messages: [message] });
 
     expect(callback).toHaveBeenNthCalledWith(
       3,
@@ -249,10 +255,11 @@ describe('liveMessages', () => {
   });
 
   test('it should add new message to collection onCreate', async () => {
-    const newMessage = {
-      ...message,
-      messageId: 'new-messageId',
-    };
+    const rawNewMessage = generateRawMessage({
+      messageId: 'new-message-id',
+      messageFeedId: message.subChannelId,
+    });
+    const newMessage = convertFromRaw(rawNewMessage);
 
     // mock response of queryMessages and validate
     const callback = jest.fn();
@@ -263,22 +270,23 @@ describe('liveMessages', () => {
       },
     });
 
-    liveMessages({ channelId }, callback);
+    liveMessages({ subChannelId }, callback);
 
-    await expect(queryMessages({ channelId })).resolves.toBeTruthy();
+    await expect(queryMessages({ subChannelId })).resolves.toBeTruthy();
     expect(callback).toHaveBeenCalledTimes(2);
 
     // fire new message creation event
-    client.emitter.emit('v3.message.didCreate', { messages: [newMessage] });
+    client.emitter.emit('message.created', { messages: [rawNewMessage] });
 
     expect(callback).toHaveBeenNthCalledWith(
       3,
       expect.objectContaining({
-        data: [newMessage, ...returnValue],
         error: undefined,
         loading: false,
       }),
     );
+    expect(callback.mock.calls[2][0].data[0]).toMatchObject(newMessage);
+    expect(callback.mock.calls[2][0].data[1]).toMatchObject(returnValue[0]);
   });
 
   test('it should add new message to collection onUpdate', async () => {
@@ -291,13 +299,13 @@ describe('liveMessages', () => {
       },
     });
 
-    liveMessages({ channelId }, callback);
+    liveMessages({ subChannelId }, callback);
 
-    await expect(queryMessages({ channelId })).resolves.toBeTruthy();
+    await expect(queryMessages({ subChannelId })).resolves.toBeTruthy();
     expect(callback).toHaveBeenCalledTimes(2);
 
     // fire new message creation event
-    client.emitter.emit('v3.message.didUpdate', { messages: [message] });
+    client.emitter.emit('message.updated', { messages: [rawMessage] });
 
     expect(callback).toHaveBeenNthCalledWith(
       3,
@@ -319,13 +327,13 @@ describe('liveMessages', () => {
       },
     });
 
-    liveMessages({ channelId }, callback);
+    liveMessages({ subChannelId }, callback);
 
-    await expect(queryMessages({ channelId })).resolves.toBeTruthy();
+    await expect(queryMessages({ subChannelId })).resolves.toBeTruthy();
     expect(callback).toHaveBeenCalledTimes(2);
 
     // fire new message creation event
-    client.emitter.emit('v3.message.didDelete', { messages: [message] });
+    client.emitter.emit('message.deleted', { messages: [rawMessage] });
 
     expect(callback).toHaveBeenNthCalledWith(
       3,

package/src/message/utils/index.ts

@@ -0,0 +1,129 @@
+import { AxiosResponse } from 'axios';
+import { toToken } from '~/core/query';
+import { pullFromCache } from '~/cache/api';
+import { prepareMessagePayloadForCache } from '~/reaction/utils/prepareMessagePayloadForCache';
+
+export function convertFromRaw({
+  channelPublicId,
+  childCount,
+  creatorPublicId,
+  mentionedUsers,
+  messageFeedId,
+  myReactions,
+  reactionCount,
+  reactions,
+  referenceId,
+  segment,
+  ...rest
+}: Amity.RawMessage): Amity.Message {
+  let cache: Amity.CacheEntry<Amity.Message> | undefined;
+
+  if (referenceId) {
+    try {
+      cache = pullFromCache(['message', 'get', referenceId]);
+      // eslint-disable-next-line no-empty
+    } catch {}
+  }
+
+  if (!cache) {
+    try {
+      cache = pullFromCache(['message', 'get', rest.messageId]);
+      // eslint-disable-next-line no-empty
+    } catch {}
+  }
+
+  const out: Amity.Message = {
+    ...rest,
+    channelId: channelPublicId,
+    channelSegment: segment,
+    childrenNumber: childCount,
+    creatorId: creatorPublicId,
+    reactions: reactions ?? {},
+    reactionsCount: reactionCount,
+    subChannelId: messageFeedId,
+    uniqueId: cache ? cache.data.uniqueId : rest.messageId,
+  };
+
+  if (mentionedUsers) {
+    out.mentionees = mentionedUsers.map(mention => {
+      if (mention.type === 'channel') {
+        return mention;
+      }
+
+      return { type: 'user', userIds: mention.userPublicIds };
+    });
+  }
+
+  if (myReactions) {
+    // http response
+    out.myReactions = myReactions;
+  } else {
+    // mqtt event
+    try {
+      prepareMessagePayloadForCache(out);
+      // eslint-disable-next-line no-empty
+    } catch {}
+  }
+
+  return out;
+}
+
+export const prepareMessagePayload = (payload: Amity.RawMessagePayload): Amity.MessagePayload => {
+  return {
+    ...payload,
+    messages: payload.messages.map(convertFromRaw),
+  };
+};
+
+export const convertResponseFromRaw = <T extends Amity.RawMessagePayload>(
+  response: AxiosResponse<T>,
+): AxiosResponse<Omit<T, 'messages'> & { messages: Amity.MessagePayload['messages'] }> => {
+  return {
+    ...response,
+    data: {
+      ...response.data,
+      messages: response.data.messages.map(convertFromRaw),
+    },
+  };
+};
+
+type RawQueryMessages = Omit<Amity.QueryMessages, 'page' | 'sortBy' | 'subChannelId' | 'tags'> & {
+  includeTags?: Amity.QueryMessages['tags'];
+  messageFeedId: Amity.QueryMessages['subChannelId'];
+  options: {
+    sortBy?: Amity.QueryMessages['sortBy'];
+    token: string;
+  };
+};
+
+export function convertParams({
+  subChannelId,
+  mentionees,
+  ...rest
+}: Partial<Amity.Message>): Record<string, any> {
+  return { messageFeedId: subChannelId, mentionedUsers: mentionees, ...rest };
+}
+
+export function convertQueryParams({
+  page,
+  sortBy,
+  subChannelId,
+  tags,
+  ...rest
+}: Amity.QueryMessages): RawQueryMessages {
+  const out: RawQueryMessages = {
+    ...rest,
+    messageFeedId: subChannelId,
+    options: { token: toToken(page || { limit: 10 }, 'afterbeforeraw')! },
+  };
+
+  if (sortBy !== undefined) {
+    out.options.sortBy = sortBy;
+  }
+
+  if (tags) {
+    out.includeTags = tags;
+  }
+
+  return out;
+}

package/src/post/api/queryPosts.ts

@@ -27,6 +27,7 @@ export const queryPosts = async (
   client.log('post/queryPosts', query);
 
   const { page = { limit: 10 }, ...params } = query;
+  const { dataTypes, matchingOnlyParentPost } = params;
 
   // API-FIX: parameters should be querystring. (1)
   // API-FIX: backend should answer Amity.Response (2)
@@ -34,6 +35,14 @@ export const queryPosts = async (
   const { data } = await client.http.get<Amity.PostPayload & Amity.Pagination>(`/api/v4/posts`, {
     params: {
       ...params,
+      /*
+       * when creating post like image, file, video BE will create 2 posts
+       * 1. parent post to store text with dataType=text
+       * 2. child post to store dataTypes post data
+       *
+       * By default BE queries only parent post
+       */
+      matchingOnlyParentPost: matchingOnlyParentPost ?? !dataTypes?.length,
       options: {
         token: toToken(page, 'afterbeforeraw'),
       },

package/src/post/api/tests/queryPosts.test.ts

@@ -0,0 +1,149 @@
+import { getResolver } from '~/core/model';
+
+import { disableCache, enableCache, pushToCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+import { client, postQueryResponse, post11 } from '~/utils/tests';
+
+import { queryPosts } from '../queryPosts';
+
+const { targetId, targetType } = post11;
+const params = { targetId, targetType };
+
+describe('queryPosts', () => {
+  test('it should return posts', async () => {
+    const { posts: expected } = postQueryResponse.data;
+    client.http.get = jest.fn().mockResolvedValue(postQueryResponse);
+
+    const { data } = await queryPosts(params);
+
+    expect(data).toEqual(expected);
+  });
+
+  test('it should throw error', async () => {
+    client.http.get = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(queryPosts(params)).rejects.toThrow('error');
+  });
+
+  test('it should send matchingOnlyParentPost as true if there are no dataTypes', async () => {
+    const mockFn = jest.fn();
+    client.http.get = mockFn.mockResolvedValue(postQueryResponse);
+
+    await queryPosts(params);
+
+    const mockFnParams = mockFn.mock.lastCall;
+
+    expect(mockFnParams).toBeDefined();
+    expect(mockFnParams).toHaveLength(2);
+    expect(mockFnParams[1].params.matchingOnlyParentPost).toBe(true);
+  });
+
+  test('it should send matchingOnlyParentPost as false if there are dataTypes', async () => {
+    const mockFn = jest.fn();
+    client.http.get = mockFn.mockResolvedValue(postQueryResponse);
+
+    await queryPosts({ ...params, dataTypes: ['image'] });
+
+    const mockFnParams = mockFn.mock.lastCall;
+
+    expect(mockFnParams).toBeDefined();
+    expect(mockFnParams).toHaveLength(2);
+    expect(mockFnParams[1].params.matchingOnlyParentPost).toBe(false);
+  });
+
+  test('it should update cache upon fetching data from server', async () => {
+    enableCache();
+
+    client.http.get = jest.fn().mockResolvedValue(postQueryResponse);
+
+    const { data: expected } = await queryPosts(params);
+    const { data: received } = queryPosts.locally(params)!;
+
+    expect(received).toBeDefined();
+    expect(received).toEqual(expected);
+
+    disableCache();
+  });
+});
+
+describe('queryPosts.locally', () => {
+  const cacheKey = ['post', 'query', { ...params, options: { limit: 10 } } as Amity.Serializable];
+
+  test('it should fetch query locally if present in cache', () => {
+    enableCache();
+
+    const { data } = postQueryResponse;
+    const { posts: expected, paging } = data;
+
+    ingestInCache(data as Amity.PostPayload);
+
+    pushToCache(cacheKey, { posts: expected.map(getResolver('post')), paging });
+
+    const { data: received } = queryPosts.locally(params)!;
+
+    expect(received).toBeDefined();
+    expect(received).toEqual(expected);
+
+    disableCache();
+  });
+
+  test('it should return undefined if only partial data in cache', () => {
+    enableCache();
+
+    const { data } = postQueryResponse;
+    const { posts, paging } = data;
+
+    // ingest incomplete data
+    ingestInCache({
+      ...data,
+      posts: [data.posts[0]],
+    } as Amity.PostPayload);
+
+    pushToCache(cacheKey, {
+      posts: posts.map(getResolver('post')),
+      paging,
+    });
+
+    const received = queryPosts.locally(params)!;
+
+    expect(received).toBeUndefined();
+
+    disableCache();
+  });
+
+  // added because of comment above cache key in queryPosts
+  test('it should return undefined if params do not match', () => {
+    enableCache();
+
+    const { data } = postQueryResponse;
+    const { posts: expected, paging } = data;
+
+    ingestInCache(data as Amity.PostPayload);
+
+    pushToCache(cacheKey, { posts: expected.map(getResolver('post')), paging });
+
+    const { data: received } = queryPosts.locally(params)!;
+    const received2 = queryPosts.locally({ ...params, targetId: 'does-not-exist' })!;
+
+    expect(received).toBeDefined();
+    expect(received).toEqual(expected);
+    expect(received2).toBeUndefined();
+
+    disableCache();
+  });
+
+  test('it should return undefined if data not in cache', () => {
+    enableCache();
+
+    const received = queryPosts.locally(params);
+
+    expect(received).toBeUndefined();
+
+    disableCache();
+  });
+
+  test('it should return undefined if cache disabled', () => {
+    expect(queryPosts.locally(params)).toBeUndefined();
+  });
+});

package/src/post/events/tests/onPostApproved.test.ts

@@ -0,0 +1,33 @@
+import { onPostApproved } from '../onPostApproved';
+import { client, connectClient, disconnectClient, postPayload, post11 } from '~/utils/tests';
+
+describe('onPostApproved', () => {
+  beforeAll(async () => {
+    await connectClient();
+  });
+
+  afterAll(async () => {
+    await disconnectClient();
+  });
+
+  test('it should got event after post approved', () => {
+    const callback = jest.fn();
+    const unsub = onPostApproved(callback);
+    client.emitter.emit('post.approved', postPayload);
+
+    unsub();
+
+    expect(callback).toHaveBeenCalled();
+    expect(callback).toHaveBeenCalledWith(post11);
+  });
+
+  test('it should got nothing if we did unsubscribe before got event', () => {
+    const callback = jest.fn();
+    const unsub = onPostApproved(callback);
+
+    unsub();
+
+    client.emitter.emit('post.approved', postPayload);
+    expect(callback).not.toHaveBeenCalled();
+  });
+});

package/src/post/events/tests/onPostCreated.test.ts

@@ -0,0 +1,33 @@
+import { onPostCreated } from '../onPostCreated';
+import { client, connectClient, disconnectClient, postPayload, post11 } from '~/utils/tests';
+
+describe('onPostCreated', () => {
+  beforeAll(async () => {
+    await connectClient();
+  });
+
+  afterAll(async () => {
+    await disconnectClient();
+  });
+
+  test('it should got event after post created', () => {
+    const callback = jest.fn();
+    const unsub = onPostCreated(callback);
+    client.emitter.emit('post.created', postPayload);
+
+    unsub();
+
+    expect(callback).toHaveBeenCalled();
+    expect(callback).toHaveBeenCalledWith(post11);
+  });
+
+  test('it should got nothing if we did unsubscribe before got event', () => {
+    const callback = jest.fn();
+    const unsub = onPostCreated(callback);
+
+    unsub();
+
+    client.emitter.emit('post.created', postPayload);
+    expect(callback).not.toHaveBeenCalled();
+  });
+});

package/src/post/events/tests/onPostDeclined.test.ts

@@ -0,0 +1,33 @@
+import { onPostDeclined } from '../onPostDeclined';
+import { client, connectClient, disconnectClient, postPayload, post11 } from '~/utils/tests';
+
+describe('onPostDeclined', () => {
+  beforeAll(async () => {
+    await connectClient();
+  });
+
+  afterAll(async () => {
+    await disconnectClient();
+  });
+
+  test('it should got event after post declined', () => {
+    const callback = jest.fn();
+    const unsub = onPostDeclined(callback);
+    client.emitter.emit('post.declined', postPayload);
+
+    unsub();
+
+    expect(callback).toHaveBeenCalled();
+    expect(callback).toHaveBeenCalledWith(post11);
+  });
+
+  test('it should got nothing if we did unsubscribe before got event', () => {
+    const callback = jest.fn();
+    const unsub = onPostDeclined(callback);
+
+    unsub();
+
+    client.emitter.emit('post.declined', postPayload);
+    expect(callback).not.toHaveBeenCalled();
+  });
+});

package/src/post/events/tests/onPostDeleted.test.ts

@@ -0,0 +1,33 @@
+import { onPostDeleted } from '../onPostDeleted';
+import { client, connectClient, disconnectClient, postPayload, post11 } from '~/utils/tests';
+
+describe('onPostDeleted', () => {
+  beforeAll(async () => {
+    await connectClient();
+  });
+
+  afterAll(async () => {
+    await disconnectClient();
+  });
+
+  test('it should got event after post deleted', () => {
+    const callback = jest.fn();
+    const unsub = onPostDeleted(callback);
+    client.emitter.emit('post.deleted', postPayload);
+
+    unsub();
+
+    expect(callback).toHaveBeenCalled();
+    expect(callback).toHaveBeenCalledWith(post11);
+  });
+
+  test('it should got nothing if we did unsubscribe before got event', () => {
+    const callback = jest.fn();
+    const unsub = onPostDeleted(callback);
+
+    unsub();
+
+    client.emitter.emit('post.deleted', postPayload);
+    expect(callback).not.toHaveBeenCalled();
+  });
+});