@amityco/ts-sdk 0.0.1-beta.37 → 0.0.1-beta.39

package/src/core/transports/http.ts

@@ -1,5 +1,4 @@
 import axios from 'axios';
-import qs from 'qs';
 import HttpAgent, { HttpsAgent } from 'agentkeepalive';
 
 import { ASCError } from '~/core/errors';
@@ -7,14 +6,6 @@ import { ASCError } from '~/core/errors';
 import { fireEvent } from '../events';
 import { unwrapPayload } from './utils';
 
-/**
- * Axios param serializer (for querystring)
- * @hidden
- */
-export const stringify = (params: Record<string, unknown>): string => {
-  return qs.stringify(params, { arrayFormat: 'brackets' });
-};
-
 /**
  * Creates a pre-configured axios instance
  *
@@ -36,7 +27,14 @@ export const createHttpTransport = (endpoint: string) => {
     baseURL: endpoint,
     httpAgent: new HttpAgent(options),
     httpsAgent: new HttpsAgent(options),
-    paramsSerializer: stringify,
+    /*
+     * If paramSerializer is required, use the serialize option to stringify
+     * params. The encode option will pass complex params as string only whereas
+     * the serialize option will pass params in the format Record<string, any>
+     *
+     * For more details:
+     * https://github.com/axios/axios#request-config
+     */
   });
 
   instance.interceptors.request.use(config => {
@@ -59,8 +57,6 @@ export const createHttpTransport = (endpoint: string) => {
     response => response,
     error => {
       const { response } = error;
-      // eslint-disable-next-line no-console
-      console.error(response?.data ?? error);
 
       // handle unauthorized request
       if (response.data.code === Amity.ServerError.UNAUTHORIZED) {
@@ -78,7 +74,15 @@ export const createHttpTransport = (endpoint: string) => {
         );
       }
 
-      if (response?.data) unwrapPayload(response.data);
+      // if it's an error with status in the response payload,
+      // then it's an expected error.
+      if (response?.data?.status) {
+        unwrapPayload(response?.data);
+      }
+      // unexpected error.
+      else {
+        throw new Error(response?.data ?? error);
+      }
     },
   );
 

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

@@ -1,83 +1,72 @@
-import { createHttpTransport, stringify } from '../http';
+import nock from 'nock';
+
+import { ASCApiError, ASCUnknownError } from '~/core/errors';
+import { createFileFormData } from '~/utils/tests';
+
+import { createHttpTransport } from '../http';
+
+const baseUrl = 'https://non-exist.domain';
 
 describe('core/transports', () => {
-  describe('stringify', () => {
-    test('should serializer simple string', () => {
-      const params = { a: 'c' };
-      const url = stringify(params);
-      expect(url).toBe('a=c');
-    });
+  describe('createHttpTransport', () => {
+    beforeAll(nock.disableNetConnect);
+    beforeEach(nock.cleanAll);
 
-    test('should serializer empty string', () => {
-      const params = { a: '' };
-      const url = stringify(params);
-      expect(url).toBe('a=');
-    });
+    test('should create axios instance with out error', () => {
+      nock(baseUrl).get(/./).reply(200);
 
-    test('should serializer special character', () => {
-      const params = { a: '✓', b: 'ø' };
-      const url = stringify(params);
-      expect(url).toBe('a=%E2%9C%93&b=%C3%B8');
+      expect(createHttpTransport(baseUrl)).not.toThrow();
     });
 
-    test('should serializer boolean', () => {
-      const params = { a: true, b: false };
-      const url = stringify(params);
-      expect(url).toBe('a=true&b=false');
-    });
+    test('instance should resolved http request', async () => {
+      const expectedResolveValue = { foo: 'bar' };
+      nock(baseUrl).get('/foo').reply(200, expectedResolveValue);
 
-    test('should serializer null ', () => {
-      const params = { a: null };
-      const url = stringify(params);
-      expect(url).toBe('a=');
-    });
+      const instance = createHttpTransport(baseUrl);
 
-    test('should serializer undefined', () => {
-      const params = { a: undefined };
-      const url = stringify(params);
-      expect(url).toBe('');
+      const expected = expect.objectContaining({ data: expectedResolveValue });
+      await expect(instance.get('/foo')).resolves.toEqual(expected);
     });
 
-    test('should serializer NaN', () => {
-      const params = { a: NaN };
-      const url = stringify(params);
-      expect(url).toBe('a=NaN');
-    });
+    test('instance should throw Error when got 400 response code', async () => {
+      nock(baseUrl).get('/foo').reply(400);
 
-    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');
-    });
+      const instance = createHttpTransport(baseUrl);
 
-    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');
+      await expect(instance.get('/foo')).rejects.toThrow(Error);
     });
 
-    test('should serializer nested object', () => {
-      const params = { a: { b: 'c' } };
-      const url = stringify(params);
-      expect(url).toBe('a%5Bb%5D=c');
+    test('instance should throw Error when got 500 response code', async () => {
+      nock(baseUrl).get('/foo').reply(500);
+
+      const instance = createHttpTransport(baseUrl);
+
+      await expect(instance.get('/foo')).rejects.toThrow(Error);
     });
 
-    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('instance should throw `ASCUnknownError` when got `fail` status in payload', async () => {
+      nock(baseUrl).get('/foo').reply(500, { status: 'fail', message: 'something fail' });
+
+      const instance = createHttpTransport(baseUrl);
+
+      await expect(instance.get('/foo')).rejects.toThrow(ASCUnknownError);
     });
 
-    test('should serializer empty object', () => {
-      const params = { a: { b: [] } };
-      const url = stringify(params);
-      expect(url).toBe('');
+    test('instance should throw `ASCApiError` when got `error` status in payload', async () => {
+      nock(baseUrl).get('/foo').reply(500, { status: 'error', message: 'something error' });
+
+      const instance = createHttpTransport(baseUrl);
+
+      await expect(instance.get('/foo')).rejects.toThrow(ASCApiError);
     });
-  });
 
-  describe('createHttpTransport', () => {
-    test('should create axios instance with out error', () => {
-      expect(createHttpTransport('/')).not.toThrow();
+    test('instance should receive formData', async () => {
+      const formData = createFileFormData();
+      nock(baseUrl).post('/foo').reply(200);
+
+      const instance = createHttpTransport(baseUrl);
+
+      await expect(instance.post('/foo', formData)).resolves.not.toThrow();
     });
   });
 });

package/src/file/api/createFile.ts

@@ -34,7 +34,7 @@ export const createFile = async <T extends Amity.FileType = any>(
 
   const { data } = await client.http.post<Amity.CreateFilePayload<T>>('/api/v4/files', formData, {
     headers,
-    onUploadProgress({ loaded, total }) {
+    onUploadProgress({ loaded, total = 100 }) {
       onProgress && onProgress(Math.round((loaded * 100) / total));
     },
   });

package/src/file/api/createImage.ts

@@ -37,7 +37,7 @@ export const createImage = async (
     formData,
     {
       headers,
-      onUploadProgress({ loaded, total }) {
+      onUploadProgress({ loaded, total = 100 }) {
         onProgress && onProgress(Math.round((loaded * 100) / total));
       },
     },

package/src/file/api/createVideo.ts

@@ -43,7 +43,7 @@ export const createVideo = async (
     formData,
     {
       headers,
-      onUploadProgress({ loaded, total }) {
+      onUploadProgress({ loaded, total = 100 }) {
         onProgress && onProgress(Math.round((loaded * 100) / total));
       },
     },

package/src/file/api/test/createImage.test.ts

@@ -0,0 +1,69 @@
+import { disableCache, enableCache, pullFromCache } from '~/cache/api';
+import { client, file11, createEmptyFormData, createFileFormData } from '~/utils/tests';
+
+import { createImage } from '../createImage';
+
+const imageToCreate = [file11];
+const createIds = imageToCreate.map(({ fileId }) => fileId);
+const resolvedPayloadValue = { data: imageToCreate };
+
+describe('createImage', () => {
+  test('should return created image', async () => {
+    const formData = createFileFormData();
+    client.http.post = jest.fn().mockResolvedValue(resolvedPayloadValue);
+
+    const received = createImage(formData);
+
+    await expect(received).resolves.toEqual(expect.objectContaining({ data: imageToCreate }));
+  });
+
+  test('should throw an error if request fails', async () => {
+    const formData = createFileFormData();
+    client.http.post = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(createImage(formData)).rejects.toThrow('error');
+  });
+
+  test('should throw an error if formData is empty', async () => {
+    const emptyFormData = createEmptyFormData();
+
+    await expect(createImage(emptyFormData)).rejects.toThrow(
+      'The formData object must have a `files` key.',
+    );
+  });
+
+  test('should call onProgress params on upload progress updated', async () => {
+    expect.assertions(3);
+    const formData = createFileFormData();
+    const onProgress = jest.fn();
+
+    jest.spyOn(client.http, 'post').mockImplementationOnce(
+      (url, data, config) =>
+        new Promise((resolve, _reject) => {
+          config?.onUploadProgress?.({ loaded: 0, bytes: 0, total: 100 });
+          config?.onUploadProgress?.({ loaded: 40, bytes: 40, total: 100 });
+          config?.onUploadProgress?.({ loaded: 100, bytes: 100, total: 100 });
+          resolve(resolvedPayloadValue);
+        }),
+    );
+
+    await createImage(formData, onProgress);
+
+    expect(onProgress).toHaveBeenNthCalledWith(1, 0);
+    expect(onProgress).toHaveBeenNthCalledWith(2, 40);
+    expect(onProgress).toHaveBeenNthCalledWith(3, 100);
+  });
+
+  test('should create cache after created image', async () => {
+    enableCache();
+    const formData = createFileFormData();
+    client.http.post = jest.fn().mockResolvedValue(resolvedPayloadValue);
+
+    await createImage(formData);
+    const received = createIds.map(id => pullFromCache(['file', 'get', id])?.data);
+
+    expect(received).toEqual(expect.objectContaining(imageToCreate));
+
+    disableCache();
+  });
+});

package/src/file/api/test/createVideo.test.ts

@@ -0,0 +1,81 @@
+import { ContentFeedType } from '~/@types';
+import { disableCache, enableCache, pullFromCache } from '~/cache/api';
+import { client, file12, createEmptyFormData, createFileFormData } from '~/utils/tests';
+
+import { createVideo } from '../createVideo';
+
+const videoToCreate = [file12];
+const createIds = videoToCreate.map(({ fileId }) => fileId);
+const resolvedPayloadValue = { data: videoToCreate };
+
+describe('createVideo', () => {
+  test('should return created video', async () => {
+    const formData = createFileFormData();
+    client.http.post = jest.fn().mockResolvedValue(resolvedPayloadValue);
+
+    const received = createVideo(formData);
+
+    await expect(received).resolves.toEqual(expect.objectContaining({ data: videoToCreate }));
+  });
+
+  test('should throw an error if request fails', async () => {
+    const formData = createFileFormData();
+    client.http.post = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(createVideo(formData)).rejects.toThrow('error');
+  });
+
+  test('should throw an error if formData is empty', async () => {
+    const emptyFormData = createEmptyFormData();
+
+    await expect(createVideo(emptyFormData)).rejects.toThrow(
+      'The formData object must have a `files` key.',
+    );
+  });
+
+  // There is currently no polyfill or native API for generating complete formData
+  // in Node.js, so I'll skip this until 100% browser-compatible formData can be created.
+  test.skip('should append feedType to formData when define feedType param', async () => {
+    const formData = createFileFormData();
+    client.http.post = jest.fn().mockResolvedValue(resolvedPayloadValue);
+
+    await createVideo(formData, ContentFeedType.POST);
+
+    expect(formData.get('feedType')).toEqual(ContentFeedType.POST);
+  });
+
+  test('should call onProgress params on upload progress updated', async () => {
+    expect.assertions(3);
+    const formData = createFileFormData();
+    const onProgress = jest.fn();
+
+    jest.spyOn(client.http, 'post').mockImplementationOnce(
+      (url, data, config) =>
+        new Promise((resolve, _reject) => {
+          config?.onUploadProgress?.({ loaded: 0, bytes: 0, total: 100 });
+          config?.onUploadProgress?.({ loaded: 40, bytes: 40, total: 100 });
+          config?.onUploadProgress?.({ loaded: 100, bytes: 100, total: 100 });
+          resolve(resolvedPayloadValue);
+        }),
+    );
+
+    await createVideo(formData, undefined, onProgress);
+
+    expect(onProgress).toHaveBeenNthCalledWith(1, 0);
+    expect(onProgress).toHaveBeenNthCalledWith(2, 40);
+    expect(onProgress).toHaveBeenNthCalledWith(3, 100);
+  });
+
+  test('should create cache after created video', async () => {
+    enableCache();
+    const formData = createFileFormData();
+    client.http.post = jest.fn().mockResolvedValue(resolvedPayloadValue);
+
+    await createVideo(formData);
+    const received = createIds.map(id => pullFromCache(['file', 'get', id])?.data);
+
+    expect(received).toEqual(expect.objectContaining(videoToCreate));
+
+    disableCache();
+  });
+});

package/src/index.ts

@@ -48,6 +48,7 @@ export * from './community/events';
 export * from './community/observers';
 
 export * from './category/api';
+export * from './category/observers';
 
 export * from './feed/api';
 

package/src/message/api/queryMessages.ts

@@ -1,7 +1,7 @@
 import { getActiveClient } from '~/client/api';
 
 import { fireEvent } from '~/core/events';
-import { toPage } from '~/core/query';
+import { toPageRaw } from '~/core/query';
 import { pullFromCache, pushToCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { getResolver } from '~/core/model';
@@ -23,7 +23,7 @@ import { convertQueryParams, convertResponseFromRaw } from '../utils';
  */
 export const queryMessages = async (
   query: Amity.QueryMessages,
-): Promise<Amity.Cached<Amity.Paged<Amity.Message>>> => {
+): Promise<Amity.Cached<Amity.Paged<Amity.Message, Amity.Page<string>>>> => {
   const client = getActiveClient();
   client.log('message/queryMessages', query);
 
@@ -53,8 +53,8 @@ export const queryMessages = async (
 
   fireEvent('local.message.fetched', { messages });
 
-  const nextPage = toPage(paging.next);
-  const prevPage = toPage(paging.previous);
+  const nextPage = toPageRaw(paging.next);
+  const prevPage = toPageRaw(paging.previous);
 
   return { data: messages, cachedAt, prevPage, nextPage };
 };
@@ -74,7 +74,7 @@ export const queryMessages = async (
  */
 queryMessages.locally = (
   query: Parameters<typeof queryMessages>[0],
-): Amity.Cached<Amity.Paged<Amity.Message>> | undefined => {
+): Amity.Cached<Amity.Paged<Amity.Message, Amity.Page<string>>> | undefined => {
   const client = getActiveClient();
   client.log('message/queryMessages.locally', query);
 
@@ -94,8 +94,8 @@ queryMessages.locally = (
     .filter(Boolean)
     .map(({ data }) => data);
 
-  const prevPage = toPage(data?.paging.previous);
-  const nextPage = toPage(data?.paging.next);
+  const prevPage = toPageRaw(data?.paging.previous);
+  const nextPage = toPageRaw(data?.paging.next);
 
   return messages.length === data?.messages?.length
     ? { data: messages, cachedAt, prevPage, nextPage }

package/src/message/api/tests/queryMessages.test.ts

@@ -14,9 +14,9 @@ const messageIds = messagesToQuery.map(x => x.messageId);
 const queryCriteriaWithoutPage = { subChannelId: messagesToQuery[0].subChannelId };
 const queryCriteria = { ...queryCriteriaWithoutPage, page: { limit: 10 } };
 const paging = {
-  previous: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
-  next: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+  next: 'eyJsaW1pdCI6MiwiYmVmb3JlIjo2MzQ3MTYxNDM5MTExMTAwMDAwMH0',
 };
+const nextPage = { before: 63471614391111000000, limit: 2 };
 
 const getResolvedMessageValue = () => ({
   data: {
@@ -34,8 +34,8 @@ describe('queryMessages', () => {
     await expect(queryMessages(queryCriteria)).resolves.toEqual(
       expect.objectContaining({
         data: messagesToQuery,
-        prevPage: { before: 55, limit: 10 },
-        nextPage: { before: 55, limit: 10 },
+        nextPage,
+        prevPage: undefined,
       }),
     );
   });
@@ -91,8 +91,8 @@ describe('queryMessages.locally', () => {
     expect(queryMessages.locally(queryCriteria)).toEqual(
       expect.objectContaining({
         data: messagesToQuery,
-        prevPage: { before: 55, limit: 10 },
-        nextPage: { before: 55, limit: 10 },
+        prevPage: undefined,
+        nextPage,
       }),
     );
   });

package/src/message/observers/liveMessage.ts

@@ -1,12 +1,4 @@
-import { ASCApiError } from '~/core/errors';
-import { getActiveClient } from '~/client/api';
-import { createQuery, runQuery } from '~/core/query';
-import {
-  LIVE_OBJECT_ENABLE_CACHE_MESSAGE,
-  UNSYNCED_OBJECT_CACHED_AT_MESSAGE,
-  UNSYNCED_OBJECT_CACHED_AT_VALUE,
-} from '~/utils/constants';
-import { hasUpdates } from '~/core/model';
+import { liveObject } from '~/utils/liveObject';
 import { getMessage } from '../api';
 import {
   onMessageUpdated,
@@ -42,78 +34,14 @@ export const liveMessage = (
   messageId: Amity.Message['messageId'],
   callback: Amity.LiveObjectCallback<Amity.Message>,
 ): Amity.Unsubscriber => {
-  const { log, cache } = getActiveClient();
-  const timestamp = Date.now();
-  log(`liveMessage(tmpid: ${timestamp}) > listen`);
-
-  if (!cache) {
-    console.log(LIVE_OBJECT_ENABLE_CACHE_MESSAGE);
-  }
-
-  let message: Amity.Message;
-  let isUnsyncedObject = false;
-  const disposers: Amity.Unsubscriber[] = [];
-
-  const dispatcher = (data: Amity.LiveObject<Amity.Message>) => {
-    message = data.data;
-    callback(data);
-  };
-
-  const realtimeRouter = (eventMessage: Amity.Message) => {
-    if (messageId !== eventMessage.messageId) {
-      return;
-    }
-
-    if (message && !hasUpdates(message, eventMessage)) {
-      return;
-    }
-
-    dispatcher({ loading: false, data: eventMessage, origin: 'event' });
-  };
-
-  const onFetch = () => {
-    const query = createQuery(getMessage, messageId, true);
-
-    runQuery(query, ({ loading, data, error, origin, cachedAt }) => {
-      if (cachedAt === UNSYNCED_OBJECT_CACHED_AT_VALUE) {
-        dispatcher({
-          data,
-          origin,
-          loading: false,
-          error: new ASCApiError(
-            UNSYNCED_OBJECT_CACHED_AT_MESSAGE,
-            Amity.ClientError.DISALOOW_UNSYNCED_OBJECT,
-            Amity.ErrorLevel.ERROR,
-          ),
-        });
-
-        isUnsyncedObject = true;
-        disposers.forEach(fn => fn());
-      } else if (!isUnsyncedObject) {
-        dispatcher({ loading, data, origin, error });
-      }
-
-      if (error) {
-        disposers.forEach(fn => fn());
-      }
-    });
-  };
-
-  disposers.push(
-    onMessageFetched(realtimeRouter),
-    onMessageUpdated(realtimeRouter),
-    onMessageDeleted(realtimeRouter),
-    onMessageFlagged(realtimeRouter),
-    onMessageUnflagged(realtimeRouter),
-    onMessageFlagCleared(realtimeRouter),
-    onMessageReactionAdded(realtimeRouter),
-    onMessageReactionRemoved(realtimeRouter),
-  );
-
-  onFetch();
-
-  return () => {
-    log(`liveMessage(tmpid: ${timestamp}) > dispose`);
-    disposers.forEach(fn => fn());
-  };
+  return liveObject(messageId, callback, 'messageId', getMessage, [
+    onMessageFetched,
+    onMessageUpdated,
+    onMessageDeleted,
+    onMessageFlagged,
+    onMessageUnflagged,
+    onMessageFlagCleared,
+    onMessageReactionAdded,
+    onMessageReactionRemoved,
+  ]);
 };