@amityco/ts-sdk 0.0.1-beta.25 → 0.0.1-beta.28

package/src/channel/utils/prepareChannelPayload.ts

@@ -0,0 +1,31 @@
+import { getActiveClient } from '~/client/api';
+
+/** @hidden */
+export const prepareChannelPayload = (
+  payload: Amity.ChannelPayload,
+): Amity.ChannelPayload<any, Amity.Channel> => {
+  const client = getActiveClient();
+
+  const channels: Amity.Channel[] = payload.channels.map(channel => {
+    const channelUser = payload.channelUsers.find(
+      channelUser =>
+        channelUser.userId === client.userId && channel.channelId === channelUser.channelId,
+    )!;
+
+    const hasMention = channelUser
+      ? channelUser.readToSegment < channelUser.lastMentionedSegment
+      : false;
+    const unreadCount =
+      channelUser && channelUser.membership === 'member' && channel.messageCount
+        ? Math.max(0, channel.messageCount - channelUser.readToSegment)
+        : 0;
+
+    return {
+      ...channel,
+      hasMention,
+      unreadCount,
+    };
+  });
+
+  return { ...payload, channels };
+};

package/src/client/api/connectClient.ts

@@ -3,14 +3,14 @@
 import { disconnectClient } from '~/client/api/disconnectClient';
 import { getDeviceId } from '~/core/device';
 import { proxyWebsocketEvents } from '~/core/events';
+import { getNetworkTopic, subscribeTopic } from '~/core/subscription';
+import { onUserDeleted } from '~/user/events/onUserDeleted';
 
 import { getActiveClient } from './activeClient';
 import { setActiveUser } from './activeUser';
 
 import { getToken } from './getToken';
 import { onClientBanned } from '../events';
-import { getNetworkTopic, subscribeTopic } from '~/core/subscription';
-import { onUserDeleted } from '~/user/events/onUserDeleted';
 
 /**
  * ```js
@@ -33,13 +33,8 @@ import { onUserDeleted } from '~/user/events/onUserDeleted';
  * @async
  */
 export const connectClient = async (
-  params: {
-    userId: Amity.User['userId'];
-    displayName?: Amity.User['displayName'];
-    authToken?: string;
-    deviceId?: Amity.Device['deviceId'];
-  },
-  config?: { disableRTE: boolean },
+  params: Amity.ConnectClientParams,
+  config?: Amity.ConnectClientConfig,
 ): Promise<boolean> => {
   const client = getActiveClient();
   client.log('client/api/connectClient', { apiKey: client.apiKey, ...params });

package/src/client/api/createClient.ts

@@ -12,6 +12,9 @@ import {
 import { createEventEmitter } from '~/core/events';
 
 import { getActiveClient, setActiveClient } from './activeClient';
+import { getFeedSettings } from './getFeedSettings';
+
+const DEFAULT_DEBUG_SESSION = 'amity';
 
 /**
  * ```js
@@ -23,6 +26,7 @@ import { getActiveClient, setActiveClient } from './activeClient';
  *
  * @param apiKey for the {@link Amity.Client} instance
  * @param apiRegion endpoint to connect to
+ * @param apiEndpoint custom endpoint in case you don't want to use a preset endpoint
  * @param debugSession session's identifier for the client's logger instance
  * @returns A {@link Amity.Client} instance
  *
@@ -31,7 +35,13 @@ import { getActiveClient, setActiveClient } from './activeClient';
 export const createClient = (
   apiKey: string,
   apiRegion: typeof API_REGIONS[keyof typeof API_REGIONS] = API_REGIONS.SG,
-  debugSession = 'amity',
+  {
+    debugSession = DEFAULT_DEBUG_SESSION,
+    apiEndpoint,
+  }: {
+    debugSession?: string;
+    apiEndpoint?: { http?: string; mqtt?: string };
+  } = {},
 ): Amity.Client => {
   const log = createLogger(debugSession);
 
@@ -40,9 +50,12 @@ export const createClient = (
     apiRegion,
   });
 
-  const http = createHttpTransport(computeUrl('http', apiRegion));
-  const ws = createWebsocketTransport(computeUrl('http', apiRegion));
-  const mqtt = createMqttTransport(computeUrl('mqtt', apiRegion));
+  const httpEndpoint = apiEndpoint?.http ?? computeUrl('http', apiRegion);
+  const mqttEndpoint = apiEndpoint?.mqtt ?? computeUrl('mqtt', apiRegion);
+
+  const http = createHttpTransport(httpEndpoint);
+  const ws = createWebsocketTransport(httpEndpoint);
+  const mqtt = createMqttTransport(mqttEndpoint);
 
   const emitter = createEventEmitter();
 
@@ -56,6 +69,8 @@ export const createClient = (
     mqtt,
     emitter,
     use: () => setActiveClient(client),
+
+    getFeedSettings,
   };
 
   try {

package/src/client/api/getFeedSettings.ts

@@ -0,0 +1,29 @@
+import { getActiveClient } from './activeClient';
+
+/**
+ * ```js
+ * import { getFeedSettings } from '@amityco/ts-sdk'
+ * const feedSettings = await getFeedSettings()
+ * const postFeedSetting = feedSettings.post
+ * ```
+ *
+ * Fetches a {@link Amity.FeedSettings} object
+ *
+ * @returns A Promise of {@link Amity.FeedSettings} object
+ *
+ * @category Client API
+ * @async
+ */
+export const getFeedSettings = async (): Promise<Amity.FeedSettings> => {
+  const client = getActiveClient();
+
+  const { data } = await client.http.get<Amity.FeedSettingPayload>(
+    `/api/v3/network-settings/feed-setting`,
+  );
+
+  return Object.fromEntries(
+    data.feedSettings.map(({ feedType, contentSettings }) => {
+      return [feedType, contentSettings];
+    }),
+  );
+};

package/src/client/api/index.ts

@@ -6,3 +6,5 @@ export * from './connectClient';
 export * from './disconnectClient';
 
 export * from './isConnected';
+
+export * from './getFeedSettings';

package/src/comment/api/queryComments.ts

@@ -19,15 +19,9 @@ import { getResolver } from '~/core/model';
  * @category Comment API
  * @async
  */
-export const queryComments = async (query: {
-  referenceType: Amity.Comment['referenceType'];
-  referenceId: Amity.Comment['referenceId'];
-  sortBy?: 'lastCreated' | 'firstCreated' | 'lastUpdated' | 'firstUpdated';
-  parentId?: Amity.Comment['commentId'] | null;
-  hasFlag?: boolean;
-  isDeleted?: Amity.Comment['isDeleted'];
-  page?: Amity.Page;
-}): Promise<Amity.Cached<Amity.Paged<Amity.Comment>>> => {
+export const queryComments = async (
+  query: Amity.QueryComments,
+): Promise<Amity.Cached<Amity.Paged<Amity.Comment>>> => {
   const client = getActiveClient();
   client.log('comment/queryComments', query);
 

package/src/comment/observers/index.ts

@@ -1,2 +1,3 @@
 export * from './observeComments';
 export * from './observeComment';
+export * from './liveComments';

package/src/comment/observers/liveComments.ts

@@ -0,0 +1,172 @@
+/* eslint-disable no-use-before-define */
+import { getResolver } from '~/core/model';
+import { getActiveClient } from '~/client/api';
+import { pushToCache, pullFromCache } from '~/cache/api';
+import {
+  createQuery,
+  runQuery,
+  queryOptions,
+  filterByPropEquality,
+  sortByFirstCreated,
+  sortByLastCreated,
+} from '~/core/query';
+
+import {
+  COLLECTION_DEFAULT_CACHING_POLICY,
+  COLLECTION_DEFAULT_PAGINATION_LIMIT,
+} from '~/utils/constants';
+
+import {
+  onCommentCreated,
+  onCommentUpdated,
+  onCommentDeleted,
+  onCommentFlagged,
+  onCommentUnflagged,
+  onCommentReactionAdded,
+  onCommentReactionRemoved,
+} from '../events';
+import { queryComments } from '../api';
+
+/**
+ * ```js
+ * import { liveComments } from '@amityco/ts-sdk'
+ *
+ * let comments = []
+ * const unsub = liveComments({
+ *   referenceType: Amity.Comment['referenceType'];
+ *   referenceId: Amity.Comment['referenceId'];
+ * }, response => merge(comments, response.data))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.Comment} for a given target object
+ *
+ * @param referenceType the type of the target
+ * @param referenceId the ID of the target
+ * @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 messages
+ *
+ * @category Comments Live Collection
+ */
+export const liveComments = (
+  params: Amity.CommentLiveCollection,
+  callback: Amity.LiveCollectionCallback<Amity.Comment>,
+  config?: Amity.LiveCollectionConfig,
+): Amity.Unsubscriber => {
+  const { log, cache } = getActiveClient();
+
+  if (!cache) {
+    console.log('For using Live Collection feature you need to enable Cache!');
+  }
+
+  const timestamp = Date.now();
+  log(`liveComments(tmpid: ${timestamp}) > listen`);
+
+  const { limit: queryLimit, ...queryParams } = params;
+
+  const limit = queryLimit ?? COLLECTION_DEFAULT_PAGINATION_LIMIT;
+  const { policy = COLLECTION_DEFAULT_CACHING_POLICY } = config ?? {};
+
+  const disposers: Amity.Unsubscriber[] = [];
+  const cacheKey = [
+    'comment',
+    'collection',
+    { referenceId: params.referenceType, referenceType: params.referenceId },
+  ];
+
+  const responder = (data: Amity.CommentLiveCollectionCache) => {
+    let comments: Amity.Comment[] =
+      data.data
+        .map(commentId => pullFromCache<Amity.Comment>(['comment', 'get', commentId])!)
+        .filter(Boolean)
+        .map(({ data }) => data) ?? [];
+
+    comments = filterByPropEquality(comments, 'isDeleted', params.isDeleted);
+
+    const sortBy = params.sortBy ? params.sortBy : 'lastCreated';
+
+    comments = comments.sort(sortBy === 'lastCreated' ? sortByLastCreated : sortByFirstCreated);
+
+    callback({
+      onNextPage: onFetch,
+      data: comments,
+      hasNextPage: !!data.params?.page,
+      loading: data.loading,
+      error: data.error,
+    });
+  };
+
+  const realtimeRouter = (comment: Amity.Comment, action: Amity.CommentActionType) => {
+    const collection = pullFromCache<Amity.CommentLiveCollectionCache>(cacheKey)?.data;
+
+    if (
+      params.referenceId !== comment.referenceId ||
+      params.referenceType !== comment.referenceType ||
+      !collection
+    )
+      return;
+
+    if (action === 'onCreate') {
+      collection.data = [...new Set([comment.commentId, ...collection.data])];
+    } else if (action === 'onDelete') {
+      collection.data = collection.data.filter(p => p !== comment.commentId);
+    }
+
+    pushToCache(cacheKey, collection);
+
+    responder(collection);
+  };
+
+  const onFetch = () => {
+    const collection = pullFromCache<Amity.CommentLiveCollectionCache>(cacheKey)?.data;
+
+    const comments = collection?.data ?? [];
+
+    if (comments.length > 0 && !collection?.params?.page) return;
+
+    const query = createQuery(queryComments, {
+      ...queryParams,
+      page: collection?.params?.page ?? { limit },
+    });
+
+    runQuery(
+      query,
+      ({ data: result, error, loading, prevPage, nextPage }) => {
+        // depend on sortBy value we have two different pagination type
+        const page = queryParams.sortBy ? nextPage : prevPage;
+
+        const data = {
+          loading,
+          error,
+          params: { page },
+          data: comments,
+        };
+
+        if (result) {
+          data.data = [...new Set([...comments, ...result.map(getResolver('comment'))])];
+        }
+
+        pushToCache(cacheKey, data);
+
+        responder(data);
+      },
+      queryOptions(policy),
+    );
+  };
+
+  disposers.push(
+    onCommentCreated(comment => realtimeRouter(comment, 'onCreate')),
+    onCommentUpdated(comment => realtimeRouter(comment, 'onUpdate')),
+    onCommentDeleted(comment => realtimeRouter(comment, 'onDelete')),
+    onCommentFlagged(comment => realtimeRouter(comment, 'onFlagged')),
+    onCommentUnflagged(comment => realtimeRouter(comment, 'onUnflagged')),
+    onCommentReactionAdded(comment => realtimeRouter(comment, 'onReactionAdded')),
+    onCommentReactionRemoved(comment => realtimeRouter(comment, 'onReactionRemoved')),
+  );
+
+  onFetch();
+
+  return () => {
+    log(`liveComments(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/comment/observers/observeComments.ts

@@ -48,17 +48,7 @@ export const observeComments = (
 
   const disposers: Amity.Unsubscriber[] = [];
 
-  const router = (
-    comment: Amity.Comment,
-    action:
-      | 'onCreate'
-      | 'onUpdate'
-      | 'onDelete'
-      | 'onFlagged'
-      | 'onUnflagged'
-      | 'onReactionAdded'
-      | 'onReactionRemoved',
-  ) => {
+  const router = (comment: Amity.Comment, action: Exclude<Amity.CommentActionType, 'onFetch'>) => {
     if (comment.referenceId !== postId) return;
 
     if (callback instanceof Function) return callback(comment);

package/src/core/events.ts

@@ -13,8 +13,9 @@ const WS_EVENTS = [
   'reconnect_error',
   'reconnect_failed',
 
+  'v3.channel.didCreate',
   'v3.channel.didUpdate',
-  'v3.channel.didUpdate',
+  'v3.channel.didDelete',
   'v3.channel.didJoin',
   'v3.channel.didLeave',
   'v3.channel.didAddUsers',

package/src/core/query/query.ts

@@ -85,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
  *
@@ -215,8 +215,21 @@ export const runQuery = <Args extends any[], Returned extends any>(
   if (isMutator(func)) {
     // @ts-ignore
     const modelKey = local && local.data && identifyModelKey(local.data);
-    // @ts-ignore
-    optimisticArgs = modelKey ? [...args, { [modelKey]: local.data[modelKey] }] : args;
+    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)

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([]);
+  });
+});

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

@@ -0,0 +1,182 @@
+import { ASCApiError } from '~/core/errors';
+import { disableCache, enableCache, pushToCache } from '~/cache/api';
+import { runQuery, createQuery } from '~/core/query';
+import { createPost, getPost } from '~/post/api';
+import { deleteMessage } from '~/message/api';
+
+import { posts, client } from '~/utils/tests';
+
+const createPostArgs: Parameters<typeof createPost> = [
+  {
+    tags: ['a', 'b'],
+    data: {
+      text: 'hello!',
+    },
+    targetType: 'user',
+    targetId: 'userId1',
+  },
+];
+const post = { postId: posts.page1[0] };
+const deletingMsgId = 'deletingId';
+
+describe('Core/Query/runQuery', () => {
+  test('should call query with arguments', () => {
+    const createPostMock = jest.fn().mockResolvedValue('test');
+
+    const query = createQuery(createPostMock, createPostArgs);
+    runQuery(query);
+
+    expect(createPostMock).toBeCalledTimes(1);
+  });
+
+  test('should call callback with cache when valid', () => {
+    enableCache();
+
+    const callback = jest.fn();
+
+    const cachedAt = Date.now();
+    pushToCache(['post', 'get', post.postId], post, { cachedAt });
+
+    const query = createQuery(getPost, post.postId);
+    runQuery(query, callback);
+
+    expect(callback).toBeCalled();
+    expect(callback).toBeCalledTimes(1);
+    expect(callback).toHaveBeenCalledWith({
+      cachedAt,
+      origin: 'local',
+      loading: false,
+      data: post,
+    });
+
+    disableCache();
+  });
+
+  test('should call callback with server data for invalid cache', async () => {
+    enableCache();
+
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue({ data: { posts: [post] } });
+
+    // at the time of writing this test, cache is valid for 2 minutes
+    const expiredDate = Date.parse('04 Dec 1995 00:12:00 GMT');
+    pushToCache(['post', 'get', post.postId], post, { cachedAt: expiredDate });
+
+    const query = createQuery(getPost, post.postId);
+    runQuery(query, callback);
+
+    expect(callback).toHaveBeenCalledWith({
+      cachedAt: expiredDate,
+      origin: 'local',
+      loading: true,
+      data: post,
+    });
+
+    await expect(getPost(post.postId)).resolves.toBeTruthy();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+    // checking object containing as expiredAt cannot be predicted :D
+    expect(callback).toHaveBeenCalledWith(
+      expect.objectContaining({
+        origin: 'server',
+        loading: false,
+        data: post,
+      }),
+    );
+
+    disableCache();
+  });
+
+  test('should execute mutators optimistically', () => {
+    enableCache();
+
+    const createMessage: any = jest.fn().mockResolvedValue('test');
+    // mutators are defined as having a property called optimistically
+    createMessage.optimistically = jest.fn();
+
+    const query = createQuery(createMessage);
+    runQuery(query);
+
+    expect(createMessage.optimistically).toHaveBeenCalled();
+    // should call server right after
+    expect(createMessage).toHaveBeenCalled();
+
+    disableCache();
+  });
+
+  /*
+   * NOTE: del not tested as the args are exactly the same as update
+   *
+   * Tested due to bug where optimistic args was modifying args for del &
+   * update when it does not need to
+   */
+  test('should not change args optimistically for update', () => {
+    enableCache();
+
+    client.http.delete = jest.fn().mockResolvedValue(true);
+    // 'get', gets called after delete to verify delete
+    client.http.get = jest.fn();
+
+    const query = createQuery(deleteMessage, deletingMsgId);
+    runQuery(query);
+
+    expect(client.http.delete).toHaveBeenCalledWith(`/api/v3/messages/${deletingMsgId}`);
+
+    disableCache();
+  });
+
+  test('should throw error if optimistic execution fails', async () => {
+    enableCache();
+
+    const callback = jest.fn();
+    const createMessage: any = jest.fn().mockResolvedValue('test');
+    // mutators are defined as having a property called optimistically
+    createMessage.optimistically = jest.fn().mockImplementation(() => {
+      throw new Error();
+    });
+
+    const query = createQuery(createMessage);
+    runQuery(query, callback);
+
+    expect(createMessage.optimistically).toThrow();
+    expect(callback).toBeCalledWith({
+      origin: 'local',
+      loading: true,
+      data: undefined,
+    });
+
+    disableCache();
+  });
+
+  test('should return error if call to server fails', async () => {
+    enableCache();
+
+    client.http.delete = jest
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCApiError('not found!', Amity.ServerError.ITEM_NOT_FOUND, Amity.ErrorLevel.ERROR),
+      );
+    const callback = jest.fn();
+
+    const query = createQuery(deleteMessage, deletingMsgId);
+    runQuery(query, callback);
+
+    expect(callback).toHaveBeenCalledWith({
+      origin: 'local',
+      loading: true,
+      data: undefined,
+    });
+
+    await expect(deleteMessage(deletingMsgId)).rejects.toThrow();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+    expect(callback).toHaveBeenCalledWith(
+      expect.objectContaining({
+        origin: 'server',
+        loading: false,
+      }),
+    );
+
+    disableCache();
+  });
+});

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

@@ -0,0 +1,19 @@
+import { isFetcher } from '~/core/query';
+
+type isFetcherMockType = jest.Mock<any, any> & {
+  locally?: jest.Mock<any, any>;
+};
+
+describe('Core/Query/Query', () => {
+  const isFetcherMock: isFetcherMockType = jest.fn();
+
+  test('isFetcher without locally', () => {
+    expect(isFetcher(isFetcherMock)).toBe(false);
+  });
+
+  test('isFetcher with locally', () => {
+    isFetcherMock.locally = jest.fn();
+
+    expect(isFetcher(isFetcherMock)).toBe(true);
+  });
+});

package/src/file/api/createVideo.ts

@@ -11,6 +11,7 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
  * Creates an {@link Amity.File<'video'>}
  *
  * @param formData The data necessary to create a new {@link Amity.File<'video'>}
+ * @param feedType The {@link Amity.File<'video'>} feed type
  * @param onProgress The callback to track the upload progress
  * @returns The newly created {@link Amity.File<'video'>}
  *
@@ -19,6 +20,7 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
  */
 export const createVideo = async (
   formData: FormData,
+  feedType?: Amity.ContentFeedType,
   onProgress?: (percent: number) => void,
 ): Promise<Amity.Cached<Amity.File<'video'>[]>> => {
   const client = getActiveClient();
@@ -27,6 +29,10 @@ export const createVideo = async (
   if (!formData.getAll('files').length)
     throw new Error('The formData object must have a `files` key.');
 
+  if (feedType) {
+    formData.append('feedType', feedType);
+  }
+
   const headers =
     'getHeaders' in formData
       ? (formData as any).getHeaders()

package/src/follow/api/acceptFollower.ts

@@ -28,7 +28,7 @@ export const acceptFollower = async (userId: Amity.User['userId']): Promise<bool
     ingestInCache(data);
   }
 
-  fireEvent('follow.accepted', data.follows[0]);
+  fireEvent('follow.accepted', data);
 
   return true;
 };

package/src/follow/api/declineFollower.ts

@@ -28,7 +28,7 @@ export const declineFollower = async (userId: Amity.User['userId']): Promise<boo
     ingestInCache(data);
   }
 
-  fireEvent('follow.requestDeclined', data.follows[0]);
+  fireEvent('follow.requestDeclined', data);
 
   return true;
 };