@amityco/ts-sdk 0.0.1-beta.31 → 0.0.1-beta.33

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/queryChannels.test.ts

@@ -85,6 +85,26 @@ describe('queryChannels.locally', () => {
     disableCache();
   });
 
+  test('it should return undefined if params do not match', () => {
+    enableCache();
+
+    const { data } = channelQueryResponse;
+    const { channels: expected, paging } = data;
+
+    ingestInCache(data as Amity.ChannelPayload);
+
+    pushToCache(cacheKey, { channels: expected.map(getResolver('channel')), paging });
+
+    const { data: received } = queryChannels.locally()!;
+    const received2 = queryChannels.locally({ displayName: 'test' })!;
+
+    expect(received).toBeDefined();
+    expect(received).toEqual(expected);
+    expect(received2).toBeUndefined();
+
+    disableCache();
+  });
+
   test('it should return undefined if data not in cache', () => {
     enableCache();
 

package/src/channel/events/onChannelMemberAdded.ts

@@ -22,7 +22,7 @@ import { prepareChannelPayload } from '../utils';
  */
 export const onChannelMemberAdded = (
   callback: (channel: Amity.Channel, member: Amity.Membership<'channel'>) => void,
-) => {
+): Amity.Unsubscriber => {
   const client = getActiveClient();
 
   const filter = (payload: Amity.ChannelMembershipPayload) => {

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

@@ -2,7 +2,6 @@ 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 {

package/src/core/events.ts

@@ -117,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/model/idResolvers.ts

@@ -38,4 +38,4 @@ const idResolvers: Resolvers = {
  * @param name the domain name for the resolve
  * @returns an idResolver function for the given domain name
  */
-export const getResolver = <T extends Amity.Domain>(name: T) => idResolvers[name];
+export const getResolver = <T extends Amity.Domain>(name: T): Resolvers[T] => idResolvers[name];

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/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'

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

@@ -1,76 +1,99 @@
 import { UNSYNCED_OBJECT_CACHED_AT_VALUE } from '~/utils/constants';
-import { disableCache, enableCache, pullFromCache } from '~/cache/api';
+import { disableCache, enableCache, pullFromCache, pushToCache } from '~/cache/api';
 
 import { client, message11 } from '~/utils/tests';
 
 import { onMessageCreated } from '../../events';
 import { createMessage } from '../createMessage';
 
-describe('message/api', () => {
-  const message = message11;
-  const { messageId, ...messageBundle } = message11;
+const messageToCreate = message11;
+const { messageId, ...messageWithoutId } = message11;
 
-  const getResolvedMessageValue = () => ({
-    data: {
-      messages: [message],
-      users: [],
-      files: [],
-    },
+const getResolvedMessageValue = () => ({
+  data: {
+    messages: [messageToCreate],
+    users: [],
+    files: [],
+  },
+});
+
+describe('createMessage', () => {
+  test('should return created message', async () => {
+    client.http.post = jest.fn().mockResolvedValue(getResolvedMessageValue());
+
+    const recieved = createMessage(messageWithoutId);
+
+    await expect(recieved).resolves.toEqual(expect.objectContaining({ data: messageToCreate }));
   });
 
-  describe('createMessage', () => {
-    test('should return message', async () => {
-      client.http.post = jest.fn().mockResolvedValue(getResolvedMessageValue());
-      const { data } = await createMessage(messageBundle);
-      expect(data).toStrictEqual(message);
-    });
-
-    test('should throw an error if request fails', async () => {
-      client.http.post = jest.fn().mockRejectedValueOnce(new Error('error'));
-      await expect(createMessage(messageBundle)).rejects.toThrow('error');
-    });
+  test('should throw an error if request fails', async () => {
+    client.http.post = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(createMessage(messageWithoutId)).rejects.toThrow('error');
+  });
+
+  test('should create cache after created messages', async () => {
+    enableCache();
+    client.http.post = jest.fn().mockResolvedValue(getResolvedMessageValue());
+
+    const created = await createMessage(messageWithoutId);
+    const recieved = pullFromCache(['message', 'get', created.data.messageId])?.data;
+
+    expect(recieved).toEqual(expect.objectContaining(messageWithoutId));
+
+    disableCache();
   });
 
-  describe('createMessage.optimistically', () => {
-    beforeEach(() => enableCache());
-    afterEach(() => disableCache());
+  test('should fire event `onMessageCreated`', async () => {
+    let dispose;
+    client.http.post = jest.fn().mockResolvedValueOnce(getResolvedMessageValue());
 
-    test('should create cache after created message', () => {
-      const optimisticId = createMessage.optimistically(messageBundle)?.data?.messageId;
-      expect(pullFromCache(['message', 'get', optimisticId])?.data).toBeDefined();
-    });
+    const callbackPromise = new Promise(resolve => {
+      dispose = onMessageCreated(resolve);
+    }).finally(dispose);
 
-    test('should increase message count after created message', () => {
-      const { channelId } = messageBundle;
+    await createMessage(messageWithoutId);
 
-      const currentCount =
-        pullFromCache<Amity.Channel>(['channel', 'get', channelId])?.data?.messageCount ?? 0;
+    await expect(callbackPromise).resolves.toEqual(expect.objectContaining(messageWithoutId));
+  });
+});
 
-      createMessage.optimistically(messageBundle);
+describe('createMessage.optimistically', () => {
+  beforeEach(() => enableCache());
+  afterEach(() => disableCache());
 
-      expect(
-        pullFromCache<Amity.Channel>(['channel', 'get', channelId])?.data?.messageCount,
-      ).toEqual(currentCount + 1);
-    });
+  test('should create cache after created message', () => {
+    const optimisticId = createMessage.optimistically(messageWithoutId)?.data?.messageId;
+    const recieved = pullFromCache(['message', 'get', optimisticId])?.data;
 
-    test('should fire event `onMessageCreated`', () => {
-      expect.assertions(1);
-      let dispose;
+    expect(recieved).toEqual(expect.objectContaining(messageWithoutId));
+  });
 
-      const callback = new Promise(resolve => {
-        dispose = onMessageCreated(resolve);
-      }).finally(dispose);
+  test('should increase message count after created message', () => {
+    const { channelId } = messageWithoutId;
+    pushToCache(['channel', 'get', channelId], { channelId, messageCount: 2 });
 
-      createMessage.optimistically(messageBundle);
-      return expect(callback).resolves.not.toThrow();
-    });
+    createMessage.optimistically(messageWithoutId);
+    const recieved = pullFromCache<Amity.Channel>(['channel', 'get', channelId])?.data;
 
-    test('should define object as unsynced object', async () => {
-      const data = { channelId: 'test', data: { text: 'text' } };
+    expect(recieved?.messageCount).toBe(3);
+  });
 
-      const message = createMessage.optimistically(data);
+  test('should fire event `onMessageCreated`', async () => {
+    let dispose;
+
+    const callbackPromise = new Promise(resolve => {
+      dispose = onMessageCreated(resolve);
+    }).finally(dispose);
+
+    createMessage.optimistically(messageWithoutId);
+
+    await expect(callbackPromise).resolves.toEqual(expect.objectContaining(messageWithoutId));
+  });
 
-      expect(message?.cachedAt).toEqual(UNSYNCED_OBJECT_CACHED_AT_VALUE);
-    });
+  test('should define object as unsynced object', async () => {
+    expect(createMessage.optimistically(messageWithoutId)?.cachedAt).toEqual(
+      UNSYNCED_OBJECT_CACHED_AT_VALUE,
+    );
   });
 });

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

@@ -0,0 +1,110 @@
+import { disableCache, enableCache, pullFromCache, pushToCache } from '~/cache/api';
+import { client, message11 } from '~/utils/tests';
+
+import { deleteMessage } from '../deleteMessage';
+import { onMessageDeleted } from '../../events';
+
+const messageToDelete = { ...message11, isDeleted: false };
+const { messageId: deleteId } = messageToDelete;
+const deletedMessage = { ...messageToDelete, isDeleted: true };
+const { updatedAt, ...deletedMessageWithoutTS } = deletedMessage;
+
+const getResolvedMessageValue = () => ({
+  data: {
+    messages: [deletedMessage],
+    users: [],
+    files: [],
+  },
+});
+
+describe('deleteMessage', () => {
+  test('should return deleted message', async () => {
+    client.http.delete = jest.fn();
+    client.http.get = jest.fn().mockResolvedValueOnce(getResolvedMessageValue());
+
+    await expect(deleteMessage(deleteId)).resolves.toEqual(deletedMessageWithoutTS);
+  });
+
+  test('should throw an error if request fails', async () => {
+    client.http.delete = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(deleteMessage(deleteId)).rejects.toThrow('error');
+  });
+
+  test('should update cache after deleted messages', async () => {
+    enableCache();
+    client.http.delete = jest.fn();
+    client.http.get = jest.fn().mockResolvedValueOnce(getResolvedMessageValue());
+    pushToCache(['message', 'get', deleteId], messageToDelete);
+
+    await deleteMessage(deleteId);
+    const recieved = pullFromCache<Amity.Message>(['message', 'get', deleteId])?.data;
+
+    expect(recieved).toEqual(deletedMessageWithoutTS);
+
+    disableCache();
+  });
+
+  test('should fire event `onMessageDeleted`', async () => {
+    let dispose;
+    client.http.delete = jest.fn();
+    client.http.get = jest.fn().mockResolvedValueOnce(getResolvedMessageValue());
+
+    const callbackPromise = new Promise(resolve => {
+      dispose = onMessageDeleted(resolve);
+    }).finally(dispose);
+
+    await deleteMessage(deleteId);
+
+    await expect(callbackPromise).resolves.toEqual(deletedMessageWithoutTS);
+  });
+});
+
+describe('deleteMessage.optimistically', () => {
+  beforeEach(() => enableCache());
+  afterEach(() => disableCache());
+
+  test('should update `isDeleted` in cache after deleted message', () => {
+    pushToCache(['message', 'get', deleteId], messageToDelete);
+
+    deleteMessage.optimistically(deleteId);
+    const recieved = pullFromCache<Amity.Message>(['message', 'get', deleteId])?.data;
+
+    expect(recieved).toEqual(expect.objectContaining(deletedMessageWithoutTS));
+  });
+
+  /* TODO: re-enable this after fixed channel message count calculation */
+  test.skip('should decrease message count after deleted message', () => {
+    const { channelId } = messageToDelete;
+    pushToCache(['channel', 'get', channelId], { channelId, messageCount: 2 });
+    pushToCache(['message', 'get', deleteId], { ...messageToDelete, channelId });
+
+    deleteMessage.optimistically(deleteId);
+    const recieved = pullFromCache<Amity.Channel>(['channel', 'get', channelId])?.data;
+
+    expect(recieved?.messageCount).toBe(1);
+  });
+
+  test('should fire event `onMessageDeleted`', async () => {
+    pushToCache(['message', 'get', deleteId], messageToDelete);
+    let dispose;
+
+    const callbackPromise = new Promise(resolve => {
+      dispose = onMessageDeleted(data => {
+        resolve(data);
+      });
+    }).finally(dispose);
+
+    await deleteMessage.optimistically(deleteId);
+
+    await expect(callbackPromise).resolves.toEqual(
+      expect.objectContaining(deletedMessageWithoutTS),
+    );
+  });
+
+  test('should define object as unsynced object', () => {
+    pushToCache(['message', 'get', deleteId], messageToDelete);
+
+    expect(deleteMessage.optimistically(deleteId)?.cachedAt).toBe(-1);
+  });
+});