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

package/src/community/events/test/onCommunityUserAdded.test.ts

@@ -0,0 +1,50 @@
+import { withUser } from '~/group/utils';
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  community11,
+  communityUser11,
+  user11,
+} from '~/utils/tests';
+
+import { onCommunityUserAdded } from '../onCommunityUserAdded';
+
+const communityToAddUserTo = community11;
+const userToAddRaw = communityUser11;
+const userToAdd = withUser(userToAddRaw);
+
+const eventPayload: Amity.CommunityMembershipPayload = {
+  communities: [communityToAddUserTo],
+  communityUsers: [userToAddRaw],
+  files: [],
+  users: [user11],
+  categories: [],
+  feeds: [],
+};
+
+describe('onCommunityUserAdded', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  test('it should got event after added community user', () => {
+    const callback = jest.fn();
+    const unsub = onCommunityUserAdded(callback);
+    client.emitter.emit('community.userAdded', eventPayload);
+
+    unsub();
+
+    expect(callback).toHaveBeenCalled();
+    expect(callback).toHaveBeenCalledWith(communityToAddUserTo, userToAdd);
+  });
+
+  test('it should got nothing if we did unsubscribe before got event', () => {
+    const callback = jest.fn();
+    const unsub = onCommunityUserAdded(callback);
+
+    unsub();
+
+    client.emitter.emit('community.userAdded', eventPayload);
+    expect(callback).not.toHaveBeenCalled();
+  });
+});

package/src/community/events/test/onCommunityUserBanned.test.ts

@@ -0,0 +1,50 @@
+import { withUser } from '~/group/utils';
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  community11,
+  communityUser11,
+  user11,
+} from '~/utils/tests';
+
+import { onCommunityUserBanned } from '../onCommunityUserBanned';
+
+const community = community11;
+const banedUserRaw = { ...communityUser11, communityMembership: 'banned' as const };
+const banedUser = withUser(banedUserRaw);
+
+const eventPayload: Amity.CommunityMembershipPayload = {
+  communities: [community],
+  communityUsers: [banedUserRaw],
+  files: [],
+  users: [user11],
+  categories: [],
+  feeds: [],
+};
+
+describe('onCommunityUserBanned', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  test('it should got event after banned community user', () => {
+    const callback = jest.fn();
+    const unsub = onCommunityUserBanned(callback);
+    client.emitter.emit('community.userBanned', eventPayload);
+
+    unsub();
+
+    expect(callback).toHaveBeenCalled();
+    expect(callback).toHaveBeenCalledWith(community, banedUser);
+  });
+
+  test('it should got nothing if we did unsubscribe before got event', () => {
+    const callback = jest.fn();
+    const unsub = onCommunityUserBanned(callback);
+
+    unsub();
+
+    client.emitter.emit('community.userBanned', eventPayload);
+    expect(callback).not.toHaveBeenCalled();
+  });
+});

package/src/community/events/test/onCommunityUserRemoved.test.ts

@@ -0,0 +1,50 @@
+import { withUser } from '~/group/utils';
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  community11,
+  communityUser11,
+  user11,
+} from '~/utils/tests';
+
+import { onCommunityUserRemoved } from '../onCommunityUserRemoved';
+
+const community = community11;
+const removedUserRaw = { ...communityUser11, communityMembership: 'none' as const };
+const removedUser = withUser(removedUserRaw);
+
+const eventPayload: Amity.CommunityMembershipPayload = {
+  communities: [community],
+  communityUsers: [removedUserRaw],
+  files: [],
+  users: [user11],
+  categories: [],
+  feeds: [],
+};
+
+describe('onCommunityUserRemoved', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  test('it should got event after removed community user', () => {
+    const callback = jest.fn();
+    const unsub = onCommunityUserRemoved(callback);
+    client.emitter.emit('community.userRemoved', eventPayload);
+
+    unsub();
+
+    expect(callback).toHaveBeenCalled();
+    expect(callback).toHaveBeenCalledWith(community, removedUser);
+  });
+
+  test('it should got nothing if we did unsubscribe before got event', () => {
+    const callback = jest.fn();
+    const unsub = onCommunityUserRemoved(callback);
+
+    unsub();
+
+    client.emitter.emit('community.userRemoved', eventPayload);
+    expect(callback).not.toHaveBeenCalled();
+  });
+});

package/src/community/events/test/onCommunityUserUnbaned.test.ts

@@ -0,0 +1,50 @@
+import { withUser } from '~/group/utils';
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  community11,
+  communityUser11,
+  user11,
+} from '~/utils/tests';
+
+import { onCommunityUserUnbanned } from '../onCommunityUserUnbanned';
+
+const community = community11;
+const unbannedUserRaw = { ...communityUser11, communityMembership: 'member' as const };
+const unbannedUser = withUser(unbannedUserRaw);
+
+const eventPayload: Amity.CommunityMembershipPayload = {
+  communities: [community],
+  communityUsers: [unbannedUserRaw],
+  files: [],
+  users: [user11],
+  categories: [],
+  feeds: [],
+};
+
+describe('onCommunityUserUnbanned', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  test('it should got event after unbanned community user', () => {
+    const callback = jest.fn();
+    const unsub = onCommunityUserUnbanned(callback);
+    client.emitter.emit('community.userUnbanned', eventPayload);
+
+    unsub();
+
+    expect(callback).toHaveBeenCalled();
+    expect(callback).toHaveBeenCalledWith(community, unbannedUser);
+  });
+
+  test('it should got nothing if we did unsubscribe before got event', () => {
+    const callback = jest.fn();
+    const unsub = onCommunityUserUnbanned(callback);
+
+    unsub();
+
+    client.emitter.emit('community.userUnbanned', eventPayload);
+    expect(callback).not.toHaveBeenCalled();
+  });
+});

package/src/community/events/test/utils.test.ts

@@ -0,0 +1,158 @@
+import { disableCache, enableCache, pullFromCache } from '~/cache/api';
+import { getResolver } from '~/core/model';
+import { withUser } from '~/group/utils';
+import {
+  client,
+  community11,
+  communityUser11,
+  connectClient,
+  disconnectClient,
+  user11,
+} from '~/utils/tests';
+
+import { createCommunityEventSubscriber, createCommunityMemberEventSubscriber } from '../utils';
+
+const event = 'community.created';
+const communityToCreate = community11;
+
+const eventPayload: Amity.CommunityPayload = {
+  communities: [communityToCreate],
+  communityUsers: [communityUser11],
+  files: [],
+  users: [],
+  categories: [],
+  feeds: [],
+};
+
+describe('createCommunityEventSubscriber', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  test('it should return event subscriber', () => {
+    const callback = jest.fn();
+    const received = createCommunityEventSubscriber(event, callback);
+
+    expect(received).toBeDefined();
+  });
+
+  test('it should trigger callback with correctly params when cache is disabled', () => {
+    disableCache();
+
+    const callback = jest.fn();
+    const unsub = createCommunityEventSubscriber(event, callback);
+    client.emitter.emit(event, eventPayload);
+
+    unsub();
+
+    expect(callback).toHaveBeenCalled();
+    expect(callback).toHaveBeenCalledWith(communityToCreate);
+  });
+
+  test('it should trigger callback with correctly params when cache is enabled', () => {
+    enableCache();
+
+    const callback = jest.fn();
+    const unsub = createCommunityEventSubscriber(event, callback);
+    client.emitter.emit(event, eventPayload);
+
+    unsub();
+
+    expect(callback).toHaveBeenCalled();
+    expect(callback).toHaveBeenCalledWith(communityToCreate);
+
+    disableCache();
+  });
+
+  test('it should ingest cache', () => {
+    enableCache();
+
+    const callback = jest.fn();
+    const unsub = createCommunityEventSubscriber(event, callback);
+    client.emitter.emit(event, eventPayload);
+
+    unsub();
+
+    const recieved = pullFromCache(['community', 'get', communityToCreate.communityId])?.data;
+
+    expect(recieved).toEqual(communityToCreate);
+
+    disableCache();
+  });
+});
+
+const event2 = 'community.userAdded';
+const communityToAddUser = community11;
+const addedUserRaw = communityUser11;
+const addedUser = withUser(addedUserRaw);
+
+const eventPayload2: Amity.CommunityMembershipPayload = {
+  communities: [communityToAddUser],
+  communityUsers: [addedUserRaw],
+  files: [],
+  users: [user11],
+  categories: [],
+  feeds: [],
+};
+
+describe('createCommunityMemberEventSubscriber', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  test('it should return event subscriber', () => {
+    const callback = jest.fn();
+    const received = createCommunityMemberEventSubscriber(event2, callback);
+
+    expect(received).toBeDefined();
+  });
+
+  test('it should trigger callback with correctly params when cache is disabled', () => {
+    disableCache();
+
+    const callback = jest.fn();
+    const unsub = createCommunityMemberEventSubscriber(event2, callback);
+    client.emitter.emit(event2, eventPayload2);
+
+    unsub();
+
+    expect(callback).toHaveBeenCalled();
+    expect(callback).toHaveBeenCalledWith(communityToAddUser, addedUser);
+  });
+
+  test('it should trigger callback with correctly params when cache is enabled', () => {
+    enableCache();
+
+    const callback = jest.fn();
+    const unsub = createCommunityMemberEventSubscriber(event2, callback);
+    client.emitter.emit(event2, eventPayload2);
+
+    unsub();
+
+    expect(callback).toHaveBeenCalled();
+    expect(callback).toHaveBeenCalledWith(communityToAddUser, addedUser);
+
+    disableCache();
+  });
+
+  test('it should ingest cache', () => {
+    enableCache();
+
+    const callback = jest.fn();
+    const unsub = createCommunityMemberEventSubscriber(event2, callback);
+    client.emitter.emit(event2, eventPayload2);
+
+    unsub();
+
+    const recieved = pullFromCache([
+      'communityUsers',
+      'get',
+      getResolver('communityUsers')({
+        communityId: communityToAddUser.communityId,
+        userId: addedUser.userId,
+      }),
+    ])?.data;
+
+    expect(recieved).toEqual(addedUser);
+
+    disableCache();
+  });
+});

package/src/community/events/utils.ts

@@ -3,11 +3,12 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
 import { createEventSubscriber } from '~/core/events';
 import { pullFromCache } from '~/cache/api';
 import { getResolver } from '~/core/model';
+import { prepareMembershipPayload } from '~/group/utils';
 
 import { unpackCommunityPayload } from '../utils';
 
 export const createCommunityEventSubscriber = (
-  event: keyof Amity.MqttCommunityMessageEvents,
+  event: keyof Amity.MqttCommunityEvents,
   callback: Amity.Listener<Amity.Community>,
 ) => {
   const client = getActiveClient();
@@ -36,7 +37,9 @@ export const createCommunityEventSubscriber = (
 
 function hasPermission(
   member: Amity.Membership<'community'>,
-  payload: Amity.CommunityMembershipPayload,
+  payload: {
+    users: Amity.User[];
+  },
   permission: string,
 ) {
   if (member.permissions.some(x => x === permission)) {
@@ -49,8 +52,11 @@ function hasPermission(
 }
 
 function getEventRelatedMember(
-  event: keyof Amity.MqttCommunityUserMessageEvents,
-  payload: Amity.CommunityMembershipPayload,
+  event: keyof Amity.MqttCommunityUserEvents,
+  payload: {
+    communityUsers: Amity.Membership<'community'>[];
+    users: Amity.User[];
+  },
 ) {
   if (event === 'community.joined' || event === 'community.left') {
     return payload.communityUsers![0];
@@ -75,29 +81,31 @@ function getEventRelatedMember(
 }
 
 export const createCommunityMemberEventSubscriber = (
-  event: keyof Amity.MqttCommunityUserMessageEvents,
+  event: keyof Amity.MqttCommunityUserEvents,
   callback: (community: Amity.Community, member: Amity.Membership<'community'>) => void,
 ) => {
   const client = getActiveClient();
 
   const filter = (payload: Amity.CommunityMembershipPayload) => {
-    const unpackedPayload = unpackCommunityPayload(payload);
+    const communityPayload = unpackCommunityPayload(payload);
+    const preparedPayload = prepareMembershipPayload(communityPayload, 'communityUsers');
 
     if (!client.cache) {
       // TODO: here we are missing specific properties here!
-      callback(unpackedPayload.communities[0], getEventRelatedMember(event, unpackedPayload));
+      callback(preparedPayload.communities[0], getEventRelatedMember(event, preparedPayload));
     } else {
-      ingestInCache(unpackedPayload);
+      ingestInCache(preparedPayload);
 
       const community = pullFromCache<Amity.Community>([
         'community',
         'get',
-        unpackedPayload.communities[0].communityId,
+        preparedPayload.communities[0].communityId,
       ])!;
+
       const member = pullFromCache<Amity.Membership<'community'>>([
         'communityUsers',
         'get',
-        getResolver('communityUsers')(getEventRelatedMember(event, unpackedPayload)),
+        getResolver('communityUsers')(getEventRelatedMember(event, preparedPayload)),
       ])!;
 
       callback(community.data, member.data);

package/src/core/events.ts

@@ -12,21 +12,9 @@ const WS_EVENTS = [
   'connect_error',
   'reconnect_error',
   'reconnect_failed',
-
-  'v3.channel.didCreate',
-  'v3.channel.didUpdate',
-  'v3.channel.didDelete',
-  'v3.channel.didJoin',
-  'v3.channel.didLeave',
-  'v3.channel.didAddUsers',
-  'v3.channel.didRemoveUsers',
-  'v3.channel.didBan',
-  'v3.channel.didUnban',
-
-  'v3.message.didFetch',
-  'v3.message.didCreate',
-  'v3.message.didUpdate',
-  'v3.message.didDelete',
+  'sessionStateChange',
+  // for internal use by accessTokenExpiryWatcher
+  'tokenExpired',
 ] as const;
 
 const MQTT_EVENTS = [
@@ -37,6 +25,8 @@ const MQTT_EVENTS = [
   'close',
   'end',
   'reconnect',
+
+  'user.didGlobalBan',
 ] as const;
 
 /** @hidden */
@@ -56,7 +46,9 @@ export const createEventEmitter = () => {
  */
 export const proxyWebsocketEvents = (ws: Amity.Client['ws'], emitter: Amity.Client['emitter']) => {
   WS_EVENTS.forEach(event => {
-    ws.on(event, (param: Amity.Events[typeof event]) => emitter.emit(event, param));
+    ws.on(event, (param: Amity.Events[typeof event]) => {
+      emitter.emit(event, param);
+    });
   });
 };
 
@@ -65,15 +57,14 @@ export const proxyMqttEvents = (
   emitter: Amity.Client['emitter'],
 ) => {
   MQTT_EVENTS.forEach(event => {
-    mqttClient.on(event, (...params: any[]) =>
-      emitter.emit(event, params.length === 1 ? params[0] : params),
-    );
+    mqttClient.on(event, (...params: any[]) => {
+      emitter.emit(event, params.length === 1 ? params[0] : params);
+    });
   });
 
   // @ts-ignore
   mqttClient.on('message', (topic: string, payload: Buffer) => {
     const message = JSON.parse(payload.toString());
-
     emitter.emit(message.eventType, message.data);
   });
 };

package/src/core/model/idResolvers.ts

@@ -15,6 +15,7 @@ const idResolvers: Resolvers = {
   role: ({ roleId }) => roleId,
 
   channel: ({ channelId }) => channelId,
+  subChannel: ({ subChannelId }) => subChannelId,
   channelUsers: ({ channelId, userId }) => `${channelId}#${userId}`,
   message: ({ messageId }) => messageId,
 

package/src/core/model/identifyModel.ts

@@ -24,6 +24,7 @@ const CRITERIAS: Criterias = {
   user: ['userId', 'avatarFileId'],
   role: ['roleId'],
   channel: ['channelId', 'rateLimit'],
+  subChannel: ['subChannelId'],
   channelUsers: ['channelId', 'userId', 'membership'],
   message: ['messageId'],
   community: ['communityId', 'postSetting'],

package/src/core/model/index.ts

@@ -11,6 +11,7 @@ export const PAYLOAD2MODEL: Record<string, Amity.Domain> = {
   roles: 'role',
 
   channels: 'channel',
+  messageFeeds: 'subChannel',
   channelUsers: 'channelUsers',
   messages: 'message',
 
@@ -27,3 +28,17 @@ export const PAYLOAD2MODEL: Record<string, Amity.Domain> = {
   follows: 'follow',
   followCounts: 'followCount',
 };
+
+/** hidden */
+export const hasUpdates = (prevData: Amity.UpdatedAt, nextData: Amity.UpdatedAt): boolean => {
+  return new Date(prevData.updatedAt!) < new Date(nextData.updatedAt!);
+};
+
+/** hidden */
+export function getFutureDate(date: string | undefined = new Date().toISOString()): string {
+  return new Date(new Date(date).getTime() + 1).toISOString();
+}
+
+export function getPastDate(date: string | undefined = new Date().toISOString()): string {
+  return new Date(new Date(date).getTime() - 1).toISOString();
+}

package/src/core/query/filtering.ts

@@ -58,17 +58,10 @@ export const filterByChannelMembership = (
       channelUserCacheKey,
     ])?.data;
 
-    // if channel user is defined for user, user is a member
-    if (membership === 'member' && channelUser) {
+    if (membership === 'member' && channelUser && channelUser.membership !== 'none') {
       return true;
     }
 
-    // if channel user by user id not found, user is not a member of that
-    // channel
-    if (membership === 'notMember' && !channelUser) {
-      return true;
-    }
-
-    return false;
+    return membership === 'notMember' && (!channelUser || channelUser.membership === 'none');
   });
 };

package/src/core/query/query.ts

@@ -1,8 +1,6 @@
 /* eslint-disable no-use-before-define */
-import { isPaged } from './paging';
-import { identifyModelKey } from '~/core/model';
-
 import { CACHE_LIFESPAN } from '~/cache/utils';
+import { isPaged } from './paging';
 
 /**
  * Type guard to check and cast that a given async function is has the ".locally" property
@@ -204,37 +202,7 @@ export const runQuery = <Args extends any[], Returned extends any>(
     );
   }
 
-  let optimisticArgs = args;
-  /* get args for optimistic method calls
-   *
-   * On optimistic updates, the modal key for the update needs to be passed to
-   * the server so as to avoid duplicate modal creation
-   *
-   * ex: on creating a new message pass the modalKey is messageId, pass this
-   * id onto the server so that a duplicate with seperate messageId is not
-   * created.
-   */
-  if (isMutator(func)) {
-    // @ts-ignore
-    const modelKey = local && local.data && identifyModelKey(local.data);
-    if (modelKey) {
-      /*
-       * modal key is only required for create as update and delete queries pass
-       * the modal key in the param itself
-       * For update & delete the first argument is always an id which is of type
-       * string, whereas for create the first and only argument is the param object
-       *
-       * When creating an AmityObject optimistically we need to pass the modal key
-       * on to the server. ex: for create message modal key will be 'messageId`
-       */
-      if (typeof args[0] !== 'string') {
-        // @ts-ignore
-        optimisticArgs = [{ ...args[0], [modelKey]: local.data[modelKey] }];
-      }
-    }
-  }
-
-  func(...optimisticArgs)
+  func(...args)
     .then(fresh => {
       // @ts-ignore i know.
       // isLocal(local) && syncInCache(local, fresh)