@amityco/ts-sdk 0.0.1-cb052d5.0 → 0.0.1-cb5cdb1.0

package/src/core/device.ts

@@ -1,9 +1,7 @@
 // TODO: find a way to uniquely identify the device
 // import { getStorage } from './storage'
 import { safeProcess } from '~/utils/env';
-
-/** @hidden */
-const VERSION = '11.0.0';
+import { VERSION } from '~/version';
 
 /** @hidden */
 export const getDeviceId = () => {
@@ -30,9 +28,9 @@ export const getDeviceInfo = (): Amity.Device['deviceInfo'] => {
   const model = getDeviceModel();
 
   return {
-    version: VERSION,
     // TODO: replace with: kind: process.versions ? 'node' : 'web', when backend has fixed this
     kind: 'web',
     model,
+    sdkVersion: VERSION,
   };
 };

package/src/core/events.ts

@@ -12,19 +12,9 @@ const WS_EVENTS = [
   'connect_error',
   'reconnect_error',
   'reconnect_failed',
-
-  'v3.channel.didUpdate',
-  'v3.channel.didUpdate',
-  'v3.channel.didJoin',
-  'v3.channel.didLeave',
-  'v3.channel.didAddUsers',
-  'v3.channel.didRemoveUsers',
-  'v3.channel.didBan',
-  'v3.channel.didUnban',
-
-  'v3.message.didCreate',
-  'v3.message.didUpdate',
-  'v3.message.didDelete',
+  'sessionStateChange',
+  // for internal use by accessTokenExpiryWatcher
+  'tokenExpired',
 ] as const;
 
 const MQTT_EVENTS = [
@@ -35,6 +25,8 @@ const MQTT_EVENTS = [
   'close',
   'end',
   'reconnect',
+
+  'user.didGlobalBan',
 ] as const;
 
 /** @hidden */
@@ -54,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);
+    });
   });
 };
 
@@ -63,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);
   });
 };
@@ -115,7 +108,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

@@ -4,8 +4,9 @@
  * to avoid using any and give some typing security at the
  * resolver's level.
  */
-type Resolvers<T extends Amity.Domain[] = Amity.Domain[]> = {
-  [K in T[number]]: (model: Amity.Minimal[K]) => string;
+type Resolver<T extends Amity.Domain> = (model: Amity.Minimal[T]) => string;
+type Resolvers<T extends Amity.Domain = Amity.Domain> = {
+  [K in T]: Resolver<K>;
 };
 
 /** @hidden */
@@ -15,6 +16,7 @@ const idResolvers: Resolvers = {
   role: ({ roleId }) => roleId,
 
   channel: ({ channelId }) => channelId,
+  subChannel: ({ subChannelId }) => subChannelId,
   channelUsers: ({ channelId, userId }) => `${channelId}#${userId}`,
   message: ({ messageId }) => messageId,
 
@@ -24,11 +26,15 @@ const idResolvers: Resolvers = {
   post: ({ postId }) => postId,
   comment: ({ commentId }) => commentId,
   poll: ({ pollId }) => pollId,
+  reaction: ({ reactionId }) => reactionId,
 
   stream: ({ streamId }) => streamId,
 
   follow: ({ from, to }) => `${from}#${to}`,
+  followInfo: ({ userId }) => userId,
   followCount: ({ userId }) => userId,
+
+  feed: ({ targetId, feedId }) => `${targetId}#${feedId}`,
 };
 
 /**
@@ -37,4 +43,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): Resolver<T> => idResolvers[name];

package/src/core/model/identifyModel.ts

@@ -5,8 +5,8 @@
  * adding new models.
  * @hidden
  */
-type Criterias<T extends Amity.Domain[] = Amity.Domain[]> = {
-  [K in T[number]]: (keyof Amity.Model[K])[];
+type Criterias<T extends Amity.Domain = Amity.Domain> = {
+  [K in T]: (keyof Amity.Models[K])[];
 };
 
 /**
@@ -24,16 +24,20 @@ const CRITERIAS: Criterias = {
   user: ['userId', 'avatarFileId'],
   role: ['roleId'],
   channel: ['channelId', 'rateLimit'],
+  subChannel: ['subChannelId'],
   channelUsers: ['channelId', 'userId', 'membership'],
   message: ['messageId'],
-  community: ['communityId', 'onlyAdminCanPost'],
+  community: ['communityId', 'postSetting'],
   category: ['categoryId'],
   communityUsers: ['userId', 'communityId', 'communityMembership'],
   post: ['postId', 'feedId'],
   comment: ['commentId', 'referenceId'],
   poll: ['pollId'],
+  reaction: ['reactionId'],
   stream: ['streamId'],
   follow: ['from', 'to'],
+  feed: ['feedId', 'feedType'],
+  followInfo: ['userId', 'status'],
   followCount: ['userId', 'followerCount'],
 };
 
@@ -46,7 +50,7 @@ const hasKeys = (object: Record<string, unknown>, needles: string[]) => {
 /**
  * Finds the name of the store for a given unknown model
  *
- * @param model one of the {@link Amity.Model} to identify
+ * @param model one of the {@link Amity.Models} to identify
  * @returns the name of the corresponding store
  */
 export const identifyModel = (model: Record<string, unknown>) => {
@@ -56,3 +60,21 @@ export const identifyModel = (model: Record<string, unknown>) => {
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
   return criterias.find(([_, keys]) => hasKeys(model, keys))?.[0];
 };
+
+/*
+ * Identify the modal key for a model
+ * Used to get args for optimistic updates
+ * Example: createMessage: get messageId on optimistic message creation
+ *
+ * @param model to be recognized
+ * @returns model key array if one if found or undefined
+ */
+export const identifyModelKey = (model: Record<string, unknown>): string | undefined => {
+  const modalKey = identifyModel(model);
+
+  if (!modalKey) {
+    return undefined;
+  }
+
+  return CRITERIAS[modalKey]?.[0];
+};

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',
 
@@ -21,8 +22,35 @@ export const PAYLOAD2MODEL: Record<string, Amity.Domain> = {
   postChildren: 'post',
   comments: 'comment',
   polls: 'poll',
+  reactions: 'reaction',
+
   videoStreamings: 'stream',
 
   follows: 'follow',
   followCounts: 'followCount',
+
+  feeds: 'feed',
 };
+
+/** hidden */
+export const hasUpdates = <T extends Amity.Model>(prevData: T, nextData: T): boolean => {
+  if ('updatedAt' in prevData && 'updatedAt' in nextData) {
+    return new Date(prevData.updatedAt!) < new Date(nextData.updatedAt!);
+  }
+
+  /*
+   * hasUpdates is used to identify the latest object among many. If the object
+   * does not extend ${Amity.UpdatedAt}, then there is no way to differentiate.
+   * So it is considered by default that the object hasUpdates
+   */
+  return true;
+};
+
+/** 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

@@ -1,3 +1,5 @@
+import { getResolver } from '~/core/model';
+import { pullFromCache } from '~/cache/api';
 // Note:
 // this file should contain a suite of filtering utilities to help the
 // local version of the query functions.
@@ -17,3 +19,79 @@ export const filterByPropEquality = <T = Record<string, unknown>>(
   key: keyof T,
   value: any,
 ) => (value !== undefined ? collection.filter(item => item[key] === value) : collection);
+
+export const filterByPropInclusion = <T = Record<string, unknown>>(
+  collection: T[],
+  key: keyof T,
+  value: any[] | undefined,
+) => (value !== undefined ? collection.filter(item => value.includes(item[key])) : collection);
+
+/**
+ * Filter a channel collection by membership of the userId
+ *
+ * @param collection the channel collection to filter
+ * @param membership the membership to be filtered by
+ * @param userId user id to be filtered by
+ * @returns a filtered collection with items only matching the criteria
+ *
+ * @hidden
+ */
+export const filterByChannelMembership = (
+  collection: Amity.Channel[],
+  membership: Amity.ChannelLiveCollection['membership'],
+  userId: Amity.Membership<'channel'>['userId'],
+): Amity.Channel[] => {
+  if (membership === 'all') {
+    return collection;
+  }
+
+  return collection.filter(c => {
+    // get resolver for the channel by user
+    const channelUserCacheKey = getResolver('channelUsers')({
+      channelId: c.channelId,
+      userId,
+    });
+
+    const channelUser = pullFromCache<Amity.Membership<'channel'>>([
+      'channelUsers',
+      'get',
+      channelUserCacheKey,
+    ])?.data;
+
+    if (membership === 'member') {
+      return channelUser && channelUser.membership !== 'none';
+    }
+
+    // only membership value remainging is 'notMember'
+    return !channelUser || channelUser.membership === 'none';
+  });
+};
+
+/**
+ * Filter a channel collection by membership of the userId
+ *
+ * @param collection the channel collection to filter
+ * @param feedType to be filtered by
+ * @returns a filtered collection with items only matching the criteria
+ *
+ * @hidden
+ */
+export const filterByFeedType = <T extends Amity.Post>(
+  collection: T[],
+  feedType: Amity.Feed['feedType'],
+): T[] => {
+  /*
+   * It is possible that the targetId & feedId are the same for most of the posts
+   * But since cache is in-memory, i've avoided memoizing, to avoid premature
+   * optimization. Can be revisited if performance issues arise
+   */
+  return collection.filter(({ targetId, feedId }) => {
+    const feed = pullFromCache<Amity.Feed>([
+      'feed',
+      'get',
+      getResolver('feed')({ targetId, feedId }),
+    ])?.data!;
+
+    return feed && feed.feedType === feedType;
+  });
+};

package/src/core/query/paging.ts

@@ -1,15 +1,15 @@
 import { encode, decode } from 'js-base64';
 
 /**
- * Type guard to find if the a given decoded backend token uses "skip/limit" pagination style
+ * Type guard to find if the a given decoded backend token uses "skip" pagination style
  *
  * @param json any json object as extracted from the backend
  * @returns success boolean if the token has either "skip" or "limit" props
  *
  * @hidden
  */
-export const isSkipLimit = (json: Record<string, unknown>): json is Amity.SkipLimitPagination =>
-  ['skip', 'limit'].some(prop => prop in json);
+export const isSkip = (json: Record<string, unknown>): json is Amity.SkipLimitPagination =>
+  ['skip'].some(prop => prop in json);
 
 /**
  * Type guard to find if the a given decoded backend token uses "after/before" pagination style
@@ -80,17 +80,17 @@ export const toToken = (
       "before" or "after" value. if that would change,
       we'd need to move toward a more simple: `!paging.before`
     */
-    if (!Number.isNaN(paging?.before!)) {
+    if (!Number.isNaN(Number(paging?.before!))) {
       payload = {
         before: paging.before,
         last: paging.limit,
       };
-    } else if (!Number.isNaN(paging?.after!)) {
+    } else if (!Number.isNaN(Number(paging?.after!))) {
       payload = {
         after: paging.after,
         first: paging.limit,
       };
-    } else if (!Number.isNaN(paging?.limit!)) {
+    } else if (!Number.isNaN(Number(paging?.limit!))) {
       payload = {
         last: paging.limit,
       };
@@ -120,7 +120,7 @@ export const toPage = (token?: Amity.Token): Amity.Page | undefined => {
   // don't try catch, let it throw
   const json = JSON.parse(decode(token));
 
-  if (isSkipLimit(json)) {
+  if (isSkip(json)) {
     return {
       after: json.skip,
       limit: json.limit!,
@@ -133,6 +133,7 @@ export const toPage = (token?: Amity.Token): Amity.Page | undefined => {
         limit: json.last,
       } as Amity.PrevPage<number>;
     }
+
     if ('after' in json) {
       return {
         after: json.after,

package/src/core/query/query.ts

@@ -1,4 +1,5 @@
 /* eslint-disable no-use-before-define */
+import { CACHE_LIFESPAN } from '~/cache/utils';
 import { isPaged } from './paging';
 
 /**
@@ -70,7 +71,7 @@ export const isLocal = (model?: any): model is Amity.Local => {
  *
  * @hidden
  */
-export const isFresh = (model?: Amity.Cachable, lifeSpan = 0) => {
+export const isFresh = (model?: Amity.Cachable, lifeSpan = CACHE_LIFESPAN) => {
   return Date.now() - (model?.cachedAt ?? 0) <= lifeSpan;
 };
 
@@ -84,7 +85,7 @@ export const isFresh = (model?: Amity.Cachable, lifeSpan = 0) => {
  * This wrapper is necessary to create for optimistically calls
  *
  *
- * @param fn A compatible API function from the ts sdk
+ * @param func A compatible API function from the ts sdk
  * @param args The arguments to pass to the function passed as `fn`
  * @returns A wrapper containing both the function and its future arguments
  *
@@ -110,12 +111,11 @@ export const createQuery = <Args extends any[], Returned extends any>(
  */
 export const queryOptions = (
   policy: Amity.QueryPolicy,
-  lifeSpan: number = 2 * 60 * 1000, // 2mn
+  lifeSpan: number = CACHE_LIFESPAN, // 1mn
 ): Amity.QueryOptions => {
   if (policy === 'cache_only') return { lifeSpan: Infinity };
-  if (policy === 'server_only') return { lifeSpan: 0 };
 
-  return { lifeSpan };
+  return { lifeSpan: lifeSpan < CACHE_LIFESPAN ? CACHE_LIFESPAN : lifeSpan };
 };
 
 /**
@@ -128,18 +128,17 @@ export const queryOptions = (
  *
  * @hidden
  */
-const isEmpty = (local: any) => {
+const isEmpty = (local: unknown) => {
   // if it's supposed to be a single object, it'd be undefined
   if (!local) return true;
 
   // it's a paged query, the 1st cell of the array would be empty
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   if (isPaged(local) && isEmpty(local.data)) {
     return true;
   }
 
   // if it's a item collection, it'd have no keys
-  if (!Object.keys(local).length) return true;
+  if (typeof local === 'object' && !Object.keys(local).length) return true;
 
   return false;
 };
@@ -166,10 +165,19 @@ export const runQuery = <Args extends any[], Returned extends any>(
   callback?: (args: Amity.Snapshot<Returned>) => void,
   options: Amity.QueryOptions = queryOptions('cache_then_server'),
 ) => {
+  console.warn(
+    'Deprecation Notice: After 1 April 2023, CreateQuery/RunQuery will no longer be supported. You will be able to use the API without either methods. Check https://docs.amity.co/ for details',
+  );
+  console.warn(
+    'Deprecation Notice: After 1 March 2023, individual module imoprts will no longer be supported. All public APIs will need to be imported from their respective repositories. Ex: CommunityRepository, UserRepository, etc. Check https://docs.amity.co/ for detailed info.',
+  );
+
   let local: Returned | undefined;
 
+  const { lifeSpan } = queryOptions('cache_then_server', options.lifeSpan);
+
   // offline first
-  if (isOffline(func) && options.lifeSpan !== 0) {
+  if (isOffline(func)) {
     try {
       local = isMutator(func) ? func.optimistically(...args) : func.locally(...args);
     } catch (error) {
@@ -182,7 +190,7 @@ export const runQuery = <Args extends any[], Returned extends any>(
       );
     }
 
-    const shouldAbort = isCachable(local) && isFresh(local, options.lifeSpan);
+    const shouldAbort = isCachable(local) && isFresh(local, lifeSpan);
 
     callback?.(
       createSnapshot<Returned>(local, {

package/src/core/query/sorting.ts

@@ -15,6 +15,14 @@ export const sortByDisplayName: SortingFunc<{ displayName: string }> = (
   return a < b ? -1 : 1;
 };
 
+/**
+ * Alphabetic sorting of objects having a name
+ */
+export const sortByName: SortingFunc<{ name: string }> = ({ name: a }, { name: b }) => {
+  if (a === b) return 0;
+  return a < b ? -1 : 1;
+};
+
 /**
  * Sorting a collection by their apparition order (oldest first)
  */

package/src/core/query/tests/paging.test.ts

@@ -0,0 +1,66 @@
+import { toPage, isSkip, isAfterBefore } from '../paging';
+
+describe('paging', () => {
+  const skipToken = 'eyJza2lwIjoiMTAiLCJsaW1pdCI6IjEwIn0=';
+  const afterToken = 'eyJhZnRlciI6InRlc3QtdG9rZW4iLCJsaW1pdCI6Mn0=';
+  const beforeToken =
+    'eyJiZWZvcmUiOiI2M2Y0NzFjZmI2MTQzOTExZjFkMWUwNmYiLCJsaW1pdCI6Miwic2VnbWVudCI6Nn0=';
+
+  describe('toPage', () => {
+    test('it should return expected response for skip paging token', () => {
+      const expected = { after: '10', limit: '10' };
+
+      expect(toPage(skipToken)).toStrictEqual(expected);
+    });
+
+    test('it should return appropriate response for "before" paging token', () => {
+      const expected = {
+        before: '63f471cfb6143911f1d1e06f',
+        limit: undefined,
+      };
+
+      expect(toPage(beforeToken)).toStrictEqual(expected);
+    });
+
+    test('it should return appropriate response for "after" paging token', () => {
+      const expected = {
+        after: 'test-token',
+        limit: undefined,
+      };
+
+      expect(toPage(afterToken)).toStrictEqual(expected);
+    });
+  });
+
+  describe('isSkip', () => {
+    test('it should return true if skip prop in object', () => {
+      expect(isSkip({ skip: 10 })).toBe(true);
+    });
+
+    test('it should return true if skip prop not in object', () => {
+      expect(isSkip({ limit: 10 })).toBe(false);
+    });
+  });
+
+  describe('isAfterBefore', () => {
+    test('it should return true if after prop in object', () => {
+      expect(isAfterBefore({ after: '' })).toBe(true);
+    });
+
+    test('it should return true if before prop in object', () => {
+      expect(isAfterBefore({ before: '' })).toBe(true);
+    });
+
+    test('it should return true if first prop in object', () => {
+      expect(isAfterBefore({ first: '' })).toBe(true);
+    });
+
+    test('it should return true if last prop in object', () => {
+      expect(isAfterBefore({ last: '' })).toBe(true);
+    });
+
+    test('it should return false if skip prop in object', () => {
+      expect(isAfterBefore({ skip: '' })).toBe(false);
+    });
+  });
+});

package/src/core/subscription.ts

@@ -1,4 +1,4 @@
-import { getActiveClient } from '~/client/api';
+import { getActiveClient } from '~/client/api/activeClient';
 import { ASCError } from '~/core/errors';
 import { proxyMqttEvents } from '~/core/events';
 import { getActiveUser } from '~/client/api/activeUser';
@@ -27,6 +27,8 @@ const getCommunityUserTopic = (
   }
 };
 
+const getNetworkId = (user: { path: string }): string => user.path.split('/user/')[0];
+
 export const getCommunityTopic = (
   { path }: Amity.Subscribable,
   level: Exclude<SubscriptionLevels, SubscriptionLevels.USER> = SubscriptionLevels.COMMUNITY,
@@ -60,17 +62,62 @@ export const getCommentTopic = ({ path }: Amity.Subscribable): string => {
 export const getMyFollowersTopic = (): string => {
   const user = getActiveUser();
 
-  const [networkId] = user.path.split('/user/');
-
-  return `${networkId}/membership/${user._id}/+/+`;
+  return `${getNetworkId(user)}/membership/${user._id}/+/+`;
 };
 
 export const getMyFollowingsTopic = (): string => {
   const user = getActiveUser();
 
-  const [networkId] = user.path.split('/user/');
+  return `${getNetworkId(user)}/membership/+/${user._id}/+`;
+};
+
+export const getChannelTopic = (channel: Amity.Subscribable): string => `${channel.path}/#`;
+
+export const getSubChannelTopic = (subChannel: Amity.Subscribable): string =>
+  `${subChannel.path}/#`;
+
+export const getMessageTopic = (message: Amity.Subscribable): string => message.path;
+
+/**
+ * @hidden
+ *
+ * Create a topic to subscribe to network level events like 'user is deleted from the network'
+ */
+export const getNetworkTopic = (): string => {
+  return getNetworkId(getActiveUser());
+};
+
+/**
+ * @hidden
+ *
+ * Create a topic to subscribe to channel events for 'conversation', 'community' channel
+ */
+export const getSmartFeedChannelTopic = (): string => {
+  const user = getActiveUser();
 
-  return `${networkId}/membership/+/${user._id}/+`;
+  return `${getNetworkId(user)}/smartfeed/${user._id}/channels`;
+};
+
+/**
+ * @hidden
+ *
+ * Create a topic to subscribe to sub channel events for 'conversation', 'community' channel
+ */
+export const getSmartFeedSubChannelTopic = (): string => {
+  const user = getActiveUser();
+
+  return `${getNetworkId(user)}/smartfeed/${user._id}/messagefeeds`;
+};
+
+/**
+ * @hidden
+ *
+ * Create a topic to subscribe to message events for 'conversation', 'community' channel
+ */
+export const getSmartFeedMessageTopic = (): string => {
+  const user = getActiveUser();
+
+  return `${getNetworkId(user)}/smartfeed/${user._id}/messages`;
 };
 
 let mqttAccessToken: string;
@@ -80,7 +127,9 @@ export function subscribeTopic(
   topic: string,
   callback?: Amity.Listener<ASCError | void>,
 ): Amity.Unsubscriber {
-  const { mqtt, emitter, accessToken } = getActiveClient();
+  const { mqtt, emitter, token } = getActiveClient();
+  const accessToken = token?.accessToken ?? '';
+
   const user = getActiveUser();
 
   if (mqttAccessToken !== accessToken || mqttUserId !== user._id) {

package/src/core/tests/query/filtering.test.ts

@@ -0,0 +1,11 @@
+import { filterByPropEquality } from '~/core/query';
+
+describe('Core/Query/Filtering', () => {
+  test('check filterByPropEquality', () => {
+    const prop = 'prop';
+    const collection = [{ [prop]: 'value' }];
+
+    expect(filterByPropEquality(collection, prop, 'value')).toStrictEqual(collection);
+    expect(filterByPropEquality(collection, prop, 'otherValue')).toStrictEqual([]);
+  });
+});