@amityco/ts-sdk 0.0.1-e5fb0d2.0 → 0.0.1-e643f6f.0

package/src/subChannel/observers/liveSubChannel.ts

@@ -0,0 +1,34 @@
+import { liveObject } from '~/utils/liveObject';
+import { getSubChannel } from '../api';
+import { onSubChannelDeleted, onSubChannelUpdated } from '../events';
+import { onSubChannelFetched } from '../events/onSubChannelFetched';
+
+/**
+ * ```js
+ * import { liveSubChannel } from '@amityco/ts-sdk';
+ *
+ * let subChannel;
+ *
+ * const unsubscribe = liveSubChannel(subChannelId, response => {
+ *   subChannel = response.data;
+ * });
+ * ```
+ *
+ * Observe all mutation on a given {@link Amity.SubChannel}
+ *
+ * @param subChannelId the ID of the message to observe
+ * @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 sub channel
+ *
+ * @category SubChannel Live Object
+ */
+export const liveSubChannel = (
+  subChannelId: Amity.SubChannel['subChannelId'],
+  callback: Amity.LiveObjectCallback<Amity.SubChannel>,
+): Amity.Unsubscriber => {
+  return liveObject(subChannelId, callback, 'subChannelId', getSubChannel, [
+    onSubChannelFetched,
+    onSubChannelUpdated,
+    onSubChannelDeleted,
+  ]);
+};

package/src/subChannel/observers/liveSubChannels.ts

@@ -0,0 +1,137 @@
+/* eslint-disable no-use-before-define */
+import { getActiveClient } from '~/client/api';
+import {
+  createQuery,
+  runQuery,
+  queryOptions,
+  filterByPropEquality,
+  sortByLastActivity,
+} from '~/core/query';
+import {
+  COLLECTION_DEFAULT_CACHING_POLICY,
+  COLLECTION_DEFAULT_PAGINATION_LIMIT,
+  ENABLE_CACHE_MESSAGE,
+} from '~/utils/constants';
+import { onSubChannelFetched } from '~/subChannel/events/onSubChannelFetched';
+import { isCollectionOutdated, merge } from '~/utils';
+import { onSubChannelCreated, onSubChannelDeleted, onSubChannelUpdated } from '../events';
+import { querySubChannels } from '../api';
+
+/**
+ * ```js
+ * import { liveSubChannels } from '@amityco/ts-sdk';
+ *
+ * let subChannels = [];
+ *
+ * const unsubscribe = liveSubChannels({ channelId }, response => {
+ *   merge(subChannels, response.data);
+ * });
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.SubChannel}s
+ *
+ * @param params for querying sub channels
+ * @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 sub channels
+ *
+ * @category SubChannel Live Collection
+ */
+export const liveSubChannels = (
+  params: Amity.SubChannelLiveCollection,
+  callback: Amity.LiveCollectionCallback<Amity.SubChannel>,
+  config?: Amity.LiveCollectionConfig,
+) => {
+  const { log, cache } = getActiveClient();
+  const timestamp = Date.now();
+  log(`liveSubChannels(tmpid: ${timestamp}) > listen`);
+
+  if (!cache) {
+    console.log(ENABLE_CACHE_MESSAGE);
+  }
+
+  const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT, ...queryParams } = params;
+  const { policy = COLLECTION_DEFAULT_CACHING_POLICY } = config ?? {};
+
+  let snapshot: Amity.SubChannelLiveCollectionCache;
+  const disposers: Amity.Unsubscriber[] = [];
+
+  const responder = (data: Amity.SubChannelLiveCollectionCache) => {
+    let subChannels: Amity.SubChannel[] = data.data;
+
+    if (params.includeDeleted === false) {
+      subChannels = filterByPropEquality(subChannels, 'isDeleted', false);
+    }
+
+    subChannels.sort(sortByLastActivity);
+
+    callback({
+      onNextPage: onFetch,
+      data: subChannels,
+      hasNextPage: !!data.params?.page,
+      loading: data.loading,
+      error: data.error,
+    });
+  };
+
+  const realtimeRouter = (action: Amity.ChannelActionType) => (subChannel: Amity.SubChannel) => {
+    if (
+      params.channelId !== subChannel.channelId ||
+      !snapshot ||
+      !isCollectionOutdated(snapshot.data, subChannel, action)
+    ) {
+      return;
+    }
+
+    if (action === 'onCreate') {
+      snapshot.data = [subChannel, ...snapshot.data];
+    } else {
+      snapshot.data = snapshot.data.map(x =>
+        x.subChannelId === subChannel.subChannelId ? subChannel : x,
+      );
+    }
+
+    responder(snapshot);
+  };
+
+  const onFetch = () => {
+    const subChannels = snapshot ? snapshot.data : [];
+
+    if (subChannels.length > 0 && !snapshot?.params.page) {
+      return;
+    }
+
+    const query = createQuery(querySubChannels, {
+      ...queryParams,
+      page: snapshot?.params.page ?? { limit },
+    });
+
+    runQuery(
+      query,
+      ({ data: result, error, loading, nextPage: page }) => {
+        snapshot = {
+          loading,
+          error,
+          params: { page },
+          data: result ? merge(subChannels, result) : subChannels,
+        };
+
+        responder(snapshot);
+      },
+      queryOptions(policy),
+    );
+  };
+
+  disposers.push(
+    onSubChannelCreated(realtimeRouter('onCreate')),
+    onSubChannelDeleted(realtimeRouter('onDelete')),
+    onSubChannelFetched(realtimeRouter('onFetch')),
+    onSubChannelUpdated(realtimeRouter('onUpdate')),
+  );
+
+  onFetch();
+
+  return () => {
+    log(`liveSubChannels(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/subChannel/observers/tests/liveSubChannel.test.ts

@@ -0,0 +1,130 @@
+import { disableCache, enableCache } from '~/cache/api';
+import {
+  pause,
+  client,
+  connectClient,
+  disconnectClient,
+  generateRawSubChannel,
+} from '~/utils/tests';
+import { createQuery, runQuery } from '~/core/query';
+import { deleteSubChannel, getSubChannel, updateSubChannel } from '~/subChannel/api';
+import { getFutureDate } from '~/core/model';
+import { liveSubChannel } from '../liveSubChannel';
+import { convertFromRaw } from '../../utils';
+
+describe('liveSubChannel', () => {
+  const rawSubChannel = generateRawSubChannel();
+  const subChannel = convertFromRaw(rawSubChannel);
+  const response = { data: { messageFeeds: [rawSubChannel] } };
+
+  beforeAll(async () => {
+    await connectClient();
+  });
+
+  afterAll(async () => {
+    await disconnectClient();
+  });
+
+  beforeEach(enableCache);
+
+  afterEach(disableCache);
+
+  const events: [string, keyof Amity.Events][] = [
+    ['should get update on message-feed.updated event', 'message-feed.updated'],
+    ['should get update on message-feed.deleted event', 'message-feed.deleted'],
+  ];
+
+  test.each(events)('%s', async (test, event) => {
+    const update = {
+      ...rawSubChannel,
+      name: event,
+      updatedAt: getFutureDate(rawSubChannel.updatedAt),
+    };
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(response);
+
+    liveSubChannel(subChannel.subChannelId, callback);
+    await pause();
+    client.emitter.emit(event, { messageFeeds: [update] });
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(3);
+    expect(callback).toHaveBeenNthCalledWith(
+      3,
+      expect.objectContaining({
+        data: convertFromRaw(update),
+        loading: false,
+      }),
+    );
+  });
+
+  describe('should get an update without rte subscription', () => {
+    const update = {
+      ...rawSubChannel,
+      name: 'new name',
+      updatedAt: getFutureDate(rawSubChannel.updatedAt),
+    };
+
+    test('if getSubChannel is called', async () => {
+      const callback = jest.fn();
+      client.http.get = jest
+        .fn()
+        .mockResolvedValueOnce(response)
+        .mockResolvedValueOnce({ data: { messageFeeds: [update] } });
+
+      liveSubChannel(subChannel.subChannelId, callback);
+      await pause();
+      await getSubChannel(subChannel.subChannelId);
+      await pause();
+
+      expect(callback).toHaveBeenCalledTimes(3);
+      expect(callback).toHaveBeenNthCalledWith(
+        3,
+        expect.objectContaining({
+          data: convertFromRaw(update),
+          loading: false,
+        }),
+      );
+    });
+
+    test('if updateSubChannel is called', async () => {
+      const callback = jest.fn();
+      client.http.get = jest.fn().mockResolvedValue(response);
+      client.http.put = jest.fn().mockResolvedValue({ data: { messageFeeds: [update] } });
+
+      liveSubChannel(subChannel.subChannelId, callback);
+      await pause();
+      await updateSubChannel(subChannel.subChannelId, { displayName: update.name });
+      await pause();
+
+      expect(callback).toHaveBeenCalledTimes(3);
+      expect(callback).toHaveBeenNthCalledWith(
+        3,
+        expect.objectContaining({
+          data: convertFromRaw(update),
+          loading: false,
+        }),
+      );
+    });
+
+    test('if deleteSubChannel is called', async () => {
+      const callback = jest.fn();
+      client.http.get = jest.fn().mockResolvedValue(response);
+      client.http.delete = jest.fn().mockResolvedValue({ data: { success: true } });
+
+      liveSubChannel(subChannel.subChannelId, callback);
+      await pause();
+      runQuery(createQuery(deleteSubChannel, subChannel.subChannelId));
+      await pause();
+
+      expect(callback).toHaveBeenCalledTimes(3);
+      expect(callback).toHaveBeenNthCalledWith(
+        3,
+        expect.objectContaining({
+          data: { ...subChannel, isDeleted: true, updatedAt: expect.anything() },
+          loading: false,
+        }),
+      );
+    });
+  });
+});

package/src/subChannel/observers/tests/liveSubChannels.test.ts

@@ -0,0 +1,209 @@
+import { disableCache, enableCache, pushToCache } from '~/cache/api';
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  pause,
+  generateRawSubChannel,
+} from '~/utils/tests';
+import { convertFromRaw } from '~/subChannel/utils';
+import { getFutureDate, getPastDate } from '~/core/model';
+import { liveSubChannels } from '../liveSubChannels';
+
+describe('liveSubChannels', () => {
+  const rawSubChannel = generateRawSubChannel();
+  const response = {
+    data: {
+      messageFeeds: [rawSubChannel],
+      paging: {},
+    },
+  };
+
+  beforeAll(async () => {
+    await connectClient();
+  });
+
+  afterAll(async () => {
+    await disconnectClient();
+  });
+
+  beforeEach(enableCache);
+
+  afterEach(disableCache);
+
+  test('should get sub channels', async () => {
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(response);
+
+    liveSubChannels({ channelId: rawSubChannel.channelPublicId }, callback);
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+    expect(callback).toHaveBeenNthCalledWith(
+      1,
+      expect.objectContaining({
+        data: [],
+        loading: true,
+      }),
+    );
+    expect(callback).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining({
+        data: [convertFromRaw(rawSubChannel)],
+        loading: false,
+      }),
+    );
+  });
+
+  test('should filter deleted sub channels based on params', async () => {
+    const rawSubChannels = [
+      generateRawSubChannel({ isDeleted: true }),
+      generateRawSubChannel({ messageFeedId: 'sub-channel-id-2' }),
+    ];
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue({
+      data: {
+        messageFeeds: rawSubChannels,
+        paging: {},
+      },
+    });
+
+    liveSubChannels({ channelId: rawSubChannel.channelPublicId, includeDeleted: false }, callback);
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+    expect(callback).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining({
+        data: [convertFromRaw(rawSubChannels[1])],
+        loading: false,
+      }),
+    );
+  });
+
+  test('should fetch next page', async () => {
+    const rawSubChannel2 = generateRawSubChannel({
+      messageFeedId: 'sub-channel-id-2',
+      lastMessageTimestamp: getPastDate(rawSubChannel.lastMessageTimestamp),
+    });
+    const callback = jest.fn();
+    client.http.get = jest
+      .fn()
+      .mockResolvedValueOnce({
+        data: {
+          messageFeeds: [rawSubChannel],
+          paging: {
+            previous: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+            next: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+          },
+        },
+      })
+      .mockResolvedValueOnce({
+        data: {
+          messageFeeds: [rawSubChannel2],
+          paging: {
+            previous: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+            next: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+          },
+        },
+      });
+
+    liveSubChannels({ channelId: rawSubChannel.channelPublicId }, callback);
+    await pause();
+    callback.mock.lastCall[0].onNextPage();
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(4);
+    expect(callback).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining({
+        hasNextPage: true,
+        onNextPage: expect.anything(),
+      }),
+    );
+    expect(callback).toHaveBeenNthCalledWith(
+      4,
+      expect.objectContaining({
+        data: [rawSubChannel, rawSubChannel2].map(convertFromRaw),
+        loading: false,
+      }),
+    );
+  });
+
+  describe('events', () => {
+    const newRawSubChannel = generateRawSubChannel({
+      messageFeedId: 'sub-channel-id-2',
+      lastMessageTimestamp: getFutureDate(rawSubChannel.lastMessageTimestamp),
+    });
+    const updatedRawSubChannel = {
+      ...rawSubChannel,
+      name: 'new name',
+      updatedAt: getFutureDate(rawSubChannel.updatedAt),
+    };
+    const deletedRawSubChannel = {
+      ...rawSubChannel,
+      isDeleted: true,
+      updatedAt: getFutureDate(rawSubChannel.updatedAt),
+    };
+
+    const cases: [string, keyof Amity.Events, Amity.RawSubChannel, Amity.SubChannel[]][] = [
+      [
+        'should add new sub channel to collection onCreate',
+        'message-feed.created',
+        newRawSubChannel,
+        [newRawSubChannel, rawSubChannel].map(convertFromRaw),
+      ],
+      [
+        'should remove sub channel from collection onDelete',
+        'message-feed.deleted',
+        deletedRawSubChannel,
+        [],
+      ],
+      [
+        'should update sub channel in collection onUpdate',
+        'message-feed.updated',
+        updatedRawSubChannel,
+        [updatedRawSubChannel].map(convertFromRaw),
+      ],
+      [
+        'should update sub channel in collection onFetch',
+        'local.message-feed.fetched',
+        updatedRawSubChannel,
+        [updatedRawSubChannel].map(convertFromRaw),
+      ],
+    ];
+
+    type testHandlerType = (...args: typeof cases[number]) => Promise<void>;
+    const testHandler: testHandlerType = async (test, event, rawEventSubChannel, expected) => {
+      const callback = jest.fn();
+      client.http.get = jest.fn().mockResolvedValue(response);
+
+      liveSubChannels(
+        { channelId: rawSubChannel.channelPublicId, includeDeleted: false },
+        callback,
+      );
+      await pause();
+      if (event === 'local.message-feed.fetched') {
+        pushToCache(
+          ['subChannel', 'get', rawEventSubChannel.messageFeedId],
+          convertFromRaw(rawEventSubChannel),
+        );
+        client.emitter.emit(event, { messageFeeds: [convertFromRaw(rawEventSubChannel)] });
+      } else {
+        client.emitter.emit(event, { messageFeeds: [rawEventSubChannel] });
+      }
+      await pause();
+
+      expect(callback).toHaveBeenCalledTimes(3);
+      expect(callback).toHaveBeenNthCalledWith(
+        3,
+        expect.objectContaining({
+          data: expected,
+          loading: false,
+        }),
+      );
+    };
+
+    test.each(cases)('%s', testHandler);
+  });
+});

package/src/subChannel/utils/index.ts

@@ -0,0 +1,50 @@
+export function convertFromRaw({
+  channelId,
+  channelPublicId,
+  channelType,
+  childCount,
+  creatorId,
+  creatorPublicId,
+  lastMessageId,
+  lastMessageTimestamp,
+  messageFeedId,
+  name,
+  ...rest
+}: Amity.RawSubChannel): Amity.SubChannel {
+  return {
+    ...rest,
+    channelId: channelPublicId,
+    creatorId: creatorPublicId,
+    displayName: name,
+    lastActivity: lastMessageTimestamp,
+    latestMessageId: lastMessageId,
+    messageCount: childCount,
+    subChannelId: messageFeedId,
+  };
+}
+
+export const prepareSubChannelPayload = (
+  payload: Amity.SubChannelPayload,
+): Amity.ProcessedSubChannelPayload => {
+  return {
+    ...payload,
+    messageFeeds: payload.messageFeeds.map(convertFromRaw),
+  };
+};
+
+type RawQuerySubChannels = Omit<Amity.QuerySubChannels, 'excludeDefaultSubChannel'> & {
+  excludeDefaultMessageFeed?: Amity.QuerySubChannels['excludeDefaultSubChannel'];
+};
+
+export function convertQueryParams({
+  excludeDefaultSubChannel,
+  ...rest
+}: Amity.QuerySubChannels): RawQuerySubChannels {
+  const out: RawQuerySubChannels = { ...rest };
+
+  if (excludeDefaultSubChannel !== undefined) {
+    out.excludeDefaultMessageFeed = excludeDefaultSubChannel;
+  }
+
+  return out;
+}

package/src/user/api/getUser.ts

@@ -1,12 +1,20 @@
-import { getActiveClient } from '~/client/api'
+import { getActiveClient } from '~/client/api';
 
-import { ingestInCache, pullFromCache } from '~/core/cache'
-import { decoratePayload } from '~/core/query'
+import { pullFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { fireEvent } from '~/core/events';
 
+import { isInTombstone } from '~/cache/api/isInTombstone';
+import { checkIfShouldGoesToTombstone } from '~/cache/utils';
+import { pushToTombstone } from '~/cache/api/pushToTombstone';
+
+/* begin_public_function
+  id: user.get
+*/
 /**
  * ```js
  * import { getUser } from '@amityco/ts-sdk'
- * const user = await getUser('foobar')
+ * const { data: user } = await getUser('foobar')
  * ```
  *
  * Fetches a {@link Amity.User} object
@@ -19,26 +27,51 @@ import { decoratePayload } from '~/core/query'
  */
 export const getUser = async (
   userId: Amity.User['userId'],
-) => {
-  const client = getActiveClient()
-  client.log('user/getUser', userId)
+  isLive = false,
+): Promise<Amity.Cached<Amity.User>> => {
+  const client = getActiveClient();
+  client.log('user/getUser', userId);
+
+  if (!isLive) {
+    console.log('getUser will be deprecated on 25th November 2022, please use liveUser instead.');
+  }
+
+  isInTombstone('user', userId);
+
+  let data: Amity.UserPayload;
+
+  try {
+    const response = await client.http.get<Amity.UserPayload>(
+      `/api/v3/users/${encodeURIComponent(userId)}`,
+    );
 
-  // API-FIX: endpoint should not be /list, parameters should be querystring.
-  const { data } = await client.http.get<Amity.UserPayload>(
-    `/api/v3/users/${userId}`,
-  )
+    data = response.data;
+  } catch (error) {
+    if (checkIfShouldGoesToTombstone((error as Amity.ErrorResponse)?.code)) {
+      pushToTombstone('user', userId);
+    }
 
-  decoratePayload(data)
-  ingestInCache(data)
+    throw error;
+  }
 
-  const { users } = data
-  return users.find(user => user.userId === userId)!
-}
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  const { users } = data;
+
+  fireEvent('user.fetched', data);
+
+  return {
+    data: users.find(user => user.userId === userId)!,
+    cachedAt,
+  };
+};
+/* end_public_function */
 
 /**
  * ```js
  * import { getUser } from '@amityco/ts-sdk'
- * const user = getUser.locally('foobar')
+ * const { data: user } = getUser.locally('foobar')
  * ```
  *
  * Fetches a {@link Amity.User} object from cache
@@ -48,12 +81,9 @@ export const getUser = async (
  *
  * @category User API
  */
-getUser.locally = (
-  userId: Amity.User['userId'],
-) => {
-  const client = getActiveClient()
-  client.log('user/getUser.locally', userId)
+getUser.locally = (userId: Amity.User['userId']): Amity.Cached<Amity.User> | undefined => {
+  const client = getActiveClient();
+  client.log('user/getUser.locally', userId);
 
-  const [user] = pullFromCache('user', userId) ?? []
-  return user
-}
+  return client.cache && pullFromCache<Amity.User>(['user', 'get', userId]);
+};