@amityco/ts-sdk 0.0.1-ce7eebc.0 → 0.0.1-ce96c83.0

package/dist/post/events/tests/onPostFlagged.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=onPostFlagged.test.d.ts.map

package/dist/post/events/tests/onPostFlagged.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"onPostFlagged.test.d.ts","sourceRoot":"","sources":["../../../../src/post/events/tests/onPostFlagged.test.ts"],"names":[],"mappings":""}

package/dist/post/events/tests/onPostReactionAdded.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=onPostReactionAdded.test.d.ts.map

package/dist/post/events/tests/onPostReactionAdded.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"onPostReactionAdded.test.d.ts","sourceRoot":"","sources":["../../../../src/post/events/tests/onPostReactionAdded.test.ts"],"names":[],"mappings":""}

package/dist/post/events/tests/onPostReactionRemoved.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=onPostReactionRemoved.test.d.ts.map

package/dist/post/events/tests/onPostReactionRemoved.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"onPostReactionRemoved.test.d.ts","sourceRoot":"","sources":["../../../../src/post/events/tests/onPostReactionRemoved.test.ts"],"names":[],"mappings":""}

package/dist/post/events/tests/onPostUnflagged.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=onPostUnflagged.test.d.ts.map

package/dist/post/events/tests/onPostUnflagged.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"onPostUnflagged.test.d.ts","sourceRoot":"","sources":["../../../../src/post/events/tests/onPostUnflagged.test.ts"],"names":[],"mappings":""}

package/dist/post/events/tests/onPostUpdated.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=onPostUpdated.test.d.ts.map

package/dist/post/events/tests/onPostUpdated.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"onPostUpdated.test.d.ts","sourceRoot":"","sources":["../../../../src/post/events/tests/onPostUpdated.test.ts"],"names":[],"mappings":""}

package/dist/post/observers/livePosts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"livePosts.d.ts","sourceRoot":"","sources":["../../../src/post/observers/livePosts.ts"],"names":[],"mappings":"AAgCA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,SAAS,WACZ,MAAM,kBAAkB,YACtB,MAAM,sBAAsB,CAAC,MAAM,IAAI,CAAC,WACzC,MAAM,oBAAoB,KAClC,MAAM,YA4HR,CAAC"}
+{"version":3,"file":"livePosts.d.ts","sourceRoot":"","sources":["../../../src/post/observers/livePosts.ts"],"names":[],"mappings":"AAgCA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,SAAS,WACZ,MAAM,kBAAkB,YACtB,MAAM,sBAAsB,CAAC,MAAM,IAAI,CAAC,WACzC,MAAM,oBAAoB,KAClC,MAAM,YA+HR,CAAC"}

package/dist/utils/tests/dummy/community.d.ts

@@ -1,7 +1,9 @@
 export declare const baseCommunity: Amity.Community;
 export declare const community11: Amity.Community;
+export declare const community21: Amity.Community;
 export declare const communityUser11: Amity.MembershipRaw<'community'>;
 export declare const communityUser12: Amity.MembershipRaw<'community'>;
+export declare const communityUser21: Amity.MembershipRaw<'community'>;
 export declare const communityPayload: Amity.CommunityPayload;
 export declare const communityUserQueryResponse: {
     data: {

package/dist/utils/tests/dummy/community.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"community.d.ts","sourceRoot":"","sources":["../../../../src/utils/tests/dummy/community.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,aAAa,EAAE,KAAK,CAAC,SAYjC,CAAC;AAEF,eAAO,MAAM,WAAW,EAAE,KAAK,CAAC,SAoB/B,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,KAAK,CAAC,aAAa,CAAC,WAAW,CAa5D,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,KAAK,CAAC,aAAa,CAAC,WAAW,CAO5D,CAAC;AAEF,eAAO,MAAM,gBAAgB,EAAE,KAAK,CAAC,gBAKpC,CAAC;AAEF,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;CAUtC,CAAC;AAEF,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;GAG9B,CAAC"}
+{"version":3,"file":"community.d.ts","sourceRoot":"","sources":["../../../../src/utils/tests/dummy/community.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,aAAa,EAAE,KAAK,CAAC,SAajC,CAAC;AAEF,eAAO,MAAM,WAAW,EAAE,KAAK,CAAC,SAoB/B,CAAC;AAEF,eAAO,MAAM,WAAW,EAAE,KAAK,CAAC,SAI/B,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,KAAK,CAAC,aAAa,CAAC,WAAW,CAa5D,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,KAAK,CAAC,aAAa,CAAC,WAAW,CAO5D,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,KAAK,CAAC,aAAa,CAAC,WAAW,CAK5D,CAAC;AAEF,eAAO,MAAM,gBAAgB,EAAE,KAAK,CAAC,gBAKpC,CAAC;AAEF,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;CAUtC,CAAC;AAEF,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;GAG9B,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amityco/ts-sdk",
-  "version": "0.0.1-ce7eebc.0",
+  "version": "0.0.1-ce96c83.0",
   "license": "CC-BY-ND-4.0",
   "author": "amity.co <developers@amity.co> (https://amity.co)",
   "description": "Amity Social Cloud Typescript SDK",

package/src/cache/api/tests/enableCache.test.ts

@@ -0,0 +1,15 @@
+import { connectClient, client, disconnectClient } from '~/utils/tests';
+
+import { enableCache } from '../enableCache';
+
+describe('enableCache', () => {
+  test('it should enable cache', async () => {
+    await connectClient();
+
+    enableCache();
+
+    expect(client.cache).toBeDefined();
+
+    disconnectClient();
+  });
+});

package/src/channel/events/tests/onChannelCreated.test.ts

@@ -0,0 +1,60 @@
+import { disableCache, enableCache } from '~/cache/api';
+
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  channel11,
+  channelUser1,
+  channelUser5,
+  user11,
+  user13,
+} from '~/utils/tests';
+
+import { onChannelCreated } from '../onChannelCreated';
+
+describe('onChannelCreated event', () => {
+  beforeAll(async () => {
+    await connectClient();
+  });
+
+  afterAll(async () => {
+    await disconnectClient();
+  });
+
+  beforeEach(async () => {
+    enableCache();
+  });
+
+  afterEach(disableCache);
+
+  const channelPayload: Amity.ChannelMembershipPayload = {
+    channelUsers: [channelUser1, channelUser5],
+    channels: [channel11],
+    files: [],
+    users: [user11, user13],
+  };
+
+  test('it should call callback when channel have created', () => {
+    const callback = jest.fn();
+
+    const unsub = onChannelCreated(callback);
+    client.emitter.emit('v3.channel.didCreate', channelPayload);
+
+    unsub();
+
+    expect(callback).toHaveBeenCalled();
+    expect(callback).toHaveBeenCalledWith(channel11);
+  });
+
+  test('it should return an unsubscriber', () => {
+    const callback = jest.fn();
+
+    const unsub = onChannelCreated(callback);
+    unsub();
+
+    client.emitter.emit('v3.channel.didCreate', channelPayload);
+
+    expect(callback).not.toHaveBeenCalled();
+  });
+});

package/src/channel/events/tests/onChannelJoined.test.ts

@@ -0,0 +1,60 @@
+import { disableCache, enableCache } from '~/cache/api';
+
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  channel11,
+  channelUser1,
+  channelUser5,
+  user11,
+  user13,
+} from '~/utils/tests';
+
+import { onChannelJoined } from '../onChannelJoined';
+
+describe('onChannelJoined event', () => {
+  beforeAll(async () => {
+    await connectClient();
+  });
+
+  afterAll(async () => {
+    await disconnectClient();
+  });
+
+  beforeEach(async () => {
+    enableCache();
+  });
+
+  afterEach(disableCache);
+
+  const channelPayload: Amity.ChannelMembershipPayload = {
+    channelUsers: [channelUser1, channelUser5],
+    channels: [channel11],
+    files: [],
+    users: [user11, user13],
+  };
+
+  test('it should call callback when have someone joined channel', () => {
+    const callback = jest.fn();
+
+    const unsub = onChannelJoined(callback);
+    client.emitter.emit('v3.channel.didJoin', channelPayload);
+
+    unsub();
+
+    expect(callback).toHaveBeenCalled();
+    expect(callback).toHaveBeenCalledWith(channel11);
+  });
+
+  test('it should return an unsubscriber', () => {
+    const callback = jest.fn();
+
+    const unsub = onChannelJoined(callback);
+    unsub();
+
+    client.emitter.emit('v3.channel.didJoin', channelPayload);
+
+    expect(callback).not.toHaveBeenCalled();
+  });
+});

package/src/channel/events/tests/onChannelMemberAdded.test.ts

@@ -0,0 +1,59 @@
+import { disableCache, enableCache } from '~/cache/api';
+
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  channel11,
+  channelUser1,
+  user11,
+  user13,
+} from '~/utils/tests';
+
+import { onChannelMemberAdded } from '../onChannelMemberAdded';
+
+describe('onChannelMemberAdded event', () => {
+  beforeAll(async () => {
+    await connectClient();
+  });
+
+  afterAll(async () => {
+    await disconnectClient();
+  });
+
+  beforeEach(async () => {
+    enableCache();
+  });
+
+  afterEach(disableCache);
+
+  const channelPayload: Amity.ChannelMembershipPayload = {
+    channelUsers: [channelUser1],
+    channels: [channel11],
+    files: [],
+    users: [user11],
+  };
+
+  test('it should call callback when have someone add member to channel', () => {
+    const callback = jest.fn();
+
+    const unsub = onChannelMemberAdded(callback);
+    client.emitter.emit('v3.channel.didAddUsers', channelPayload);
+
+    unsub();
+
+    expect(callback).toHaveBeenCalled();
+    expect(callback).toHaveBeenCalledWith(channel11, { ...channelUser1, user: user11 });
+  });
+
+  test('it should return an unsubscriber', () => {
+    const callback = jest.fn();
+
+    const unsub = onChannelMemberAdded(callback);
+    unsub();
+
+    client.emitter.emit('v3.channel.didAddUsers', channelPayload);
+
+    expect(callback).not.toHaveBeenCalled();
+  });
+});

package/src/channel/events/tests/onChannelMemberRemoved.test.ts

@@ -0,0 +1,59 @@
+import { disableCache, enableCache } from '~/cache/api';
+
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  channel11,
+  channelUser1,
+  user11,
+  user13,
+} from '~/utils/tests';
+
+import { onChannelMemberRemoved } from '../onChannelMemberRemoved';
+
+describe('onChannelMemberRemoved event', () => {
+  beforeAll(async () => {
+    await connectClient();
+  });
+
+  afterAll(async () => {
+    await disconnectClient();
+  });
+
+  beforeEach(async () => {
+    enableCache();
+  });
+
+  afterEach(disableCache);
+
+  const channelPayload: Amity.ChannelMembershipPayload = {
+    channelUsers: [channelUser1],
+    channels: [channel11],
+    files: [],
+    users: [user11],
+  };
+
+  test('it should call callback when have someone remove member from channel', () => {
+    const callback = jest.fn();
+
+    const unsub = onChannelMemberRemoved(callback);
+    client.emitter.emit('v3.channel.didRemoveUsers', channelPayload);
+
+    unsub();
+
+    expect(callback).toHaveBeenCalled();
+    expect(callback).toHaveBeenCalledWith(channel11, { ...channelUser1, user: user11 });
+  });
+
+  test('it should return an unsubscriber', () => {
+    const callback = jest.fn();
+
+    const unsub = onChannelMemberRemoved(callback);
+    unsub();
+
+    client.emitter.emit('v3.channel.didRemoveUsers', channelPayload);
+
+    expect(callback).not.toHaveBeenCalled();
+  });
+});

package/src/channel/events/tests/onChannelUpdated.test.ts

@@ -0,0 +1,58 @@
+import { disableCache, enableCache } from '~/cache/api';
+
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  channel11,
+  channelUser1,
+  user11,
+} from '~/utils/tests';
+
+import { onChannelUpdated } from '../onChannelUpdated';
+
+describe('onChannelUpdated event', () => {
+  beforeAll(async () => {
+    await connectClient();
+  });
+
+  afterAll(async () => {
+    await disconnectClient();
+  });
+
+  beforeEach(async () => {
+    enableCache();
+  });
+
+  afterEach(disableCache);
+
+  const channelPayload: Amity.ChannelMembershipPayload = {
+    channelUsers: [channelUser1],
+    channels: [channel11],
+    files: [],
+    users: [user11],
+  };
+
+  test('it should call callback when channel have updated', () => {
+    const callback = jest.fn();
+
+    const unsub = onChannelUpdated(callback);
+    client.emitter.emit('v3.channel.didUpdate', channelPayload);
+
+    unsub();
+
+    expect(callback).toHaveBeenCalled();
+    expect(callback).toHaveBeenCalledWith(channel11);
+  });
+
+  test('it should return an unsubscriber', () => {
+    const callback = jest.fn();
+
+    const unsub = onChannelUpdated(callback);
+    unsub();
+
+    client.emitter.emit('v3.channel.didUpdate', channelPayload);
+
+    expect(callback).not.toHaveBeenCalled();
+  });
+});

package/src/client/api/createClient.ts

@@ -74,7 +74,7 @@ export const createClient = (
   };
 
   try {
-    getActiveClient();
+    return getActiveClient();
   } catch {
     setActiveClient(client);
   }

package/src/client/api/tests/createClient.test.ts

@@ -0,0 +1,40 @@
+import { createClient } from '../createClient';
+
+describe('createClient', () => {
+  test('it should create client', () => {
+    const client = createClient('test-api-key');
+
+    expect(client).toBeDefined();
+  });
+
+  test('it should define http transport', () => {
+    const client = createClient('test-api-key');
+
+    expect(client.http).toBeDefined();
+  });
+
+  test('it should define ws transport', () => {
+    const client = createClient('test-api-key');
+
+    expect(client.ws).toBeDefined();
+  });
+
+  test('it should define mqtt transport', () => {
+    const client = createClient('test-api-key');
+
+    expect(client.mqtt).toBeDefined();
+  });
+
+  test('it should define event emitter', () => {
+    const client = createClient('test-api-key');
+
+    expect(client.emitter).toBeDefined();
+  });
+
+  test('it should return existing client if there is one', () => {
+    const expected = createClient('test-api-key');
+    const recieved = createClient('test-api-key');
+
+    expect(recieved).toStrictEqual(expected);
+  });
+});

package/src/community/api/queryCommunities.ts

@@ -36,7 +36,8 @@ export const queryCommunities = async (query?: {
   client.log('channel/queryCommunities', query);
 
   // safe decapsulation
-  const { page, displayName, membership, ...params } = query ?? {};
+  const { page, ...params } = query ?? {};
+  const { displayName, membership, ...restParams } = params ?? {};
 
   // API-FIX: parameters should be querystring.
   // API-FIX: backend doesnt answer Amity.Response
@@ -45,7 +46,7 @@ export const queryCommunities = async (query?: {
     `/api/v3/communities`,
     {
       params: {
-        ...params,
+        ...restParams,
         keyword: displayName,
         filter: membership,
         options: {

package/src/community/api/test/addCommunityMember.test.ts

@@ -0,0 +1,71 @@
+import { disableCache, enableCache, pullFromCache } from '~/cache/api';
+import { getResolver } from '~/core/model';
+
+import { client, community11, communityUser11, user11 } from '~/utils/tests';
+
+import { onCommunityUserAdded } from '../../events';
+import { addCommunityMembers } from '../addCommunityMembers';
+
+const communityToAddUserTo = community11;
+const userToAdd = communityUser11;
+
+const resolvedPostValue = {
+  data: {
+    communities: [communityToAddUserTo],
+    communityUsers: [userToAdd],
+    files: [],
+    users: [user11],
+    categories: [],
+    feeds: [],
+  },
+};
+
+describe('addCommunityMembers', () => {
+  test('should return true value', async () => {
+    client.http.post = jest.fn().mockResolvedValue(resolvedPostValue);
+
+    const recieved = addCommunityMembers(communityToAddUserTo.communityId, [userToAdd.userId]);
+
+    await expect(recieved).resolves.toBe(true);
+  });
+
+  test('should throw an error if request fails', async () => {
+    client.http.post = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(
+      addCommunityMembers(communityToAddUserTo.communityId, [userToAdd.userId]),
+    ).rejects.toThrow('error');
+  });
+
+  test('should create cache after added user', async () => {
+    enableCache();
+    client.http.post = jest.fn().mockResolvedValue(resolvedPostValue);
+
+    await addCommunityMembers(communityToAddUserTo.communityId, [userToAdd.userId]);
+    const recieved = pullFromCache([
+      'communityUsers',
+      'get',
+      getResolver('communityUsers')({
+        communityId: communityToAddUserTo.communityId,
+        userId: userToAdd.userId,
+      }),
+    ])?.data;
+
+    expect(recieved).toEqual(expect.objectContaining(userToAdd));
+
+    disableCache();
+  });
+
+  test('should fire event `onCommunityUserAdded`', async () => {
+    let dispose;
+    client.http.post = jest.fn().mockResolvedValueOnce(resolvedPostValue);
+
+    const callback = new Promise(resolve => {
+      dispose = onCommunityUserAdded(resolve);
+    }).finally(dispose);
+
+    await addCommunityMembers(communityToAddUserTo.communityId, [userToAdd.userId]);
+
+    await expect(callback).resolves.toEqual(expect.objectContaining(communityToAddUserTo));
+  });
+});

package/src/community/api/test/addCommunityMemberRole.test.ts

@@ -0,0 +1,67 @@
+import { disableCache, enableCache, pullFromCache } from '~/cache/api';
+import { getResolver } from '~/core/model';
+
+import { client, community11, communityUser11, user11 } from '~/utils/tests';
+
+import { addCommunityMembersRoles } from '../addCommunityMembersRoles';
+
+const roleToAdd = 'some-new-sole';
+const userCommunity = community11;
+const userToAddRole = communityUser11;
+
+const addedRoleUser = {
+  ...userToAddRole,
+  roles: [...userToAddRole.roles, roleToAdd],
+};
+
+const resolvedPostValue = {
+  data: {
+    communities: [userCommunity],
+    communityUsers: [addedRoleUser],
+    files: [],
+    users: [user11],
+    categories: [],
+    feeds: [],
+  },
+};
+
+describe('addCommunityMembersRoles', () => {
+  test('should return true', async () => {
+    client.http.post = jest.fn().mockResolvedValue(resolvedPostValue);
+
+    const recieved = addCommunityMembersRoles(
+      userCommunity.communityId,
+      [roleToAdd],
+      [userToAddRole.userId],
+    );
+
+    await expect(recieved).resolves.toBe(true);
+  });
+
+  test('should throw an error if request fails', async () => {
+    client.http.post = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(
+      addCommunityMembersRoles(userCommunity.communityId, [roleToAdd], [userToAddRole.userId]),
+    ).rejects.toThrow('error');
+  });
+
+  test('should create cache after added user', async () => {
+    enableCache();
+    client.http.post = jest.fn().mockResolvedValue(resolvedPostValue);
+
+    await addCommunityMembersRoles(userCommunity.communityId, [roleToAdd], [userToAddRole.userId]);
+    const recieved = pullFromCache([
+      'communityUsers',
+      'get',
+      getResolver('communityUsers')({
+        communityId: userCommunity.communityId,
+        userId: userToAddRole.userId,
+      }),
+    ])?.data;
+
+    expect(recieved).toEqual(expect.objectContaining(addedRoleUser));
+
+    disableCache();
+  });
+});

package/src/community/api/test/createCommunity.test.ts

@@ -0,0 +1,61 @@
+import { disableCache, enableCache, pullFromCache } from '~/cache/api';
+
+import { client, community11, communityUser11 } from '~/utils/tests';
+
+import { onCommunityCreated } from '../../events';
+import { createCommunity } from '../createCommunity';
+
+const communityToCreate = community11;
+const { communityId: createId, ...payload } = communityToCreate;
+
+const resolvedPostValue = {
+  data: {
+    communities: [communityToCreate],
+    communityUsers: [communityUser11],
+    files: [],
+    users: [],
+    categories: [],
+    feeds: [],
+  },
+};
+
+describe('createCommunity', () => {
+  test('should return created community', async () => {
+    client.http.post = jest.fn().mockResolvedValue(resolvedPostValue);
+
+    const recieved = createCommunity(payload);
+
+    await expect(recieved).resolves.toEqual(expect.objectContaining({ data: communityToCreate }));
+  });
+
+  test('should throw an error if request fails', async () => {
+    client.http.post = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(createCommunity(payload)).rejects.toThrow('error');
+  });
+
+  test('should create cache after created community', async () => {
+    enableCache();
+    client.http.post = jest.fn().mockResolvedValue(resolvedPostValue);
+
+    await createCommunity(payload);
+    const recieved = pullFromCache(['community', 'get', createId])?.data;
+
+    expect(recieved).toEqual(expect.objectContaining(communityToCreate));
+
+    disableCache();
+  });
+
+  test('should fire event `onCommunityCreated`', async () => {
+    let dispose;
+    client.http.post = jest.fn().mockResolvedValueOnce(resolvedPostValue);
+
+    const callbackPromise = new Promise(resolve => {
+      dispose = onCommunityCreated(resolve);
+    }).finally(dispose);
+
+    await createCommunity(payload);
+
+    await expect(callbackPromise).resolves.toEqual(expect.objectContaining(communityToCreate));
+  });
+});