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

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/external/api/createUserToken.ts

@@ -26,11 +26,11 @@ export const createUserToken = async (
   },
 ) => {
   const deviceId = getDeviceId();
-  const deviceInfo = await getDeviceInfo();
+  const deviceInfo = getDeviceInfo();
   const http = createHttpTransport(computeUrl('http', apiRegion));
 
   const { data } = await http.post<Amity.Tokens>(
-    '/api/v3/sessions',
+    '/api/v4/sessions',
     {
       ...params,
       deviceId,

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/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,
+  ]);
 };

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

@@ -1,9 +1,6 @@
 import { ASCApiError } from '~/core/errors';
 import { disableCache, enableCache } from '~/cache/api';
-import {
-  LIVE_OBJECT_ENABLE_CACHE_MESSAGE,
-  UNSYNCED_OBJECT_CACHED_AT_MESSAGE,
-} from '~/utils/constants';
+import { UNSYNCED_OBJECT_CACHED_AT_MESSAGE } from '~/utils/constants';
 import { pause, client, connectClient, disconnectClient, generateRawMessage } from '~/utils/tests';
 import { getFutureDate } from '~/core/model';
 import { convertFromRaw } from '../../utils';
@@ -37,145 +34,6 @@ describe('liveMessage', () => {
 
   afterEach(disableCache);
 
-  test('it should show message if cache not enabled', () => {
-    /*
-     * NOTE: at the time of writing this test cache is diabled by default, but
-     * there is a proposal to enable cache by default. So I'm disabling cache
-     * here to ensure cache is disabled
-     */
-    disableCache();
-
-    const callback = jest.fn();
-    jest.spyOn(global.console, 'log');
-    client.http.get = jest.fn();
-
-    // call liveMessage check if mocked console get's called with the correct
-    // message
-    client.use();
-    liveMessage(message.messageId, callback);
-
-    expect(console.log).toBeCalledWith(LIVE_OBJECT_ENABLE_CACHE_MESSAGE);
-  });
-
-  test('it should return message live object', async () => {
-    const snapshot = getSnapshot();
-
-    // mock response of queryMessages and validate
-    const callback = jest.fn();
-    client.http.get = jest.fn().mockResolvedValue(messageQueryResponseRaw);
-
-    liveMessage(message.messageId, callback);
-
-    expect(callback).toHaveBeenCalledTimes(1);
-
-    // check if cache data returned (should be empty)
-    expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
-
-    await pause();
-
-    expect(callback).toHaveBeenCalledTimes(2);
-
-    snapshot.loading = false;
-    snapshot.data = message;
-
-    expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
-  });
-
-  test('it should return error on api failure', async () => {
-    const snapshot = getSnapshot();
-    const error = new ASCApiError(
-      'server error!',
-      Amity.ServerError.ITEM_NOT_FOUND,
-      Amity.ErrorLevel.ERROR,
-    );
-
-    // mock response of queryMessages and validate
-    const callback = jest.fn();
-    client.http.get = jest.fn().mockRejectedValue(error);
-
-    liveMessage(message.messageId, callback);
-
-    expect(callback).toHaveBeenCalledTimes(1);
-
-    // check if cache data returned (should be empty)
-    expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
-
-    await pause();
-
-    expect(callback).toHaveBeenCalledTimes(2);
-
-    snapshot.error = error;
-    snapshot.loading = false;
-    expect(callback).toHaveBeenLastCalledWith(expect.objectContaining(snapshot));
-  });
-
-  test('it should terminate updates on api failure', async () => {
-    const snapshot = getSnapshot();
-    const error = new ASCApiError(
-      'server error!',
-      Amity.ServerError.ITEM_NOT_FOUND,
-      Amity.ErrorLevel.ERROR,
-    );
-
-    // mock response of queryMessages and validate
-    const callback = jest.fn();
-    client.http.get = jest.fn().mockRejectedValue(error);
-
-    liveMessage(message.messageId, callback);
-
-    expect(callback).toHaveBeenCalledTimes(1);
-
-    // check if cache data returned (should be empty)
-    expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
-
-    await pause();
-
-    expect(callback).toHaveBeenCalledTimes(2);
-
-    snapshot.error = error;
-    snapshot.loading = false;
-    expect(callback).toHaveBeenLastCalledWith(expect.objectContaining(snapshot));
-
-    const rawUpdatedMessage = { ...rawMessage, updatedAt: getFutureDate(rawMessage.updatedAt) };
-    const updatedMessage = convertFromRaw(rawUpdatedMessage);
-    client.emitter.emit('message.updated', { messages: [rawUpdatedMessage] });
-
-    delete snapshot.error;
-    snapshot.loading = false;
-    snapshot.data = updatedMessage;
-    expect(callback).not.toHaveBeenNthCalledWith(3, expect.objectContaining(snapshot));
-  });
-
-  test('it should not return updates on obtain once!', async () => {
-    const snapshot = getSnapshot();
-
-    // mock response of queryMessages and validate
-    const callback = jest.fn();
-    client.http.get = jest.fn().mockResolvedValue(messageQueryResponseRaw);
-
-    const unsub = liveMessage(message.messageId, callback);
-
-    expect(callback).toHaveBeenCalledTimes(1);
-
-    // check if cache data returned (should be empty)
-    expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
-
-    await pause();
-
-    expect(callback).toHaveBeenCalledTimes(2);
-
-    unsub();
-
-    const rawUpdatedMessage = { ...rawMessage, updatedAt: getFutureDate(rawMessage.updatedAt) };
-    const updatedMessage = convertFromRaw(rawUpdatedMessage);
-    client.emitter.emit('message.updated', { messages: [rawUpdatedMessage] });
-
-    delete snapshot.error;
-    snapshot.loading = false;
-    snapshot.data = updatedMessage;
-    expect(callback).not.toHaveBeenNthCalledWith(3, expect.objectContaining(snapshot));
-  });
-
   const events: [string, keyof Amity.Events][] = [
     ['it should return updated message on onFetch', 'local.message.fetched'],
     ['it should return updated message on onUpdate', 'message.updated'],

package/src/post/observers/index.ts

@@ -1,3 +1,4 @@
 export * from './observePosts';
 export * from './observePost';
+export * from './livePost';
 export * from './livePosts';

package/src/post/observers/livePost.ts

@@ -0,0 +1,47 @@
+import { liveObject } from '~/utils/liveObject';
+import { getPost } from '../api';
+import {
+  onPostApproved,
+  onPostDeclined,
+  onPostDeleted,
+  onPostFlagged,
+  onPostReactionAdded,
+  onPostReactionRemoved,
+  onPostUnflagged,
+  onPostUpdated,
+} from '../events';
+
+/**
+ * ```js
+ * import { livePost } from '@amityco/ts-sdk';
+ *
+ * let post;
+ *
+ * const unsubscribe = livePost(postId, response => {
+ *   post = response.data;
+ * });
+ * ```
+ *
+ * Observe all mutation on a given {@link Amity.Post}
+ *
+ * @param postId the ID of the message to observe
+ * @param callback the function to call when new data are available
+ * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the sub channel
+ *
+ * @category Post Live Object
+ */
+export const livePost = (
+  postId: Amity.Post['postId'],
+  callback: Amity.LiveObjectCallback<Amity.Post>,
+): Amity.Unsubscriber => {
+  return liveObject(postId, callback, 'postId', getPost, [
+    onPostApproved,
+    onPostDeclined,
+    onPostDeleted,
+    onPostFlagged,
+    onPostReactionAdded,
+    onPostReactionRemoved,
+    onPostUnflagged,
+    onPostUpdated,
+  ]);
+};