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

package/src/reaction/events/onReactorRemoved.ts

@@ -1,6 +1,7 @@
 import { getActiveClient } from '~/client/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { createEventSubscriber } from '~/core/events';
+import { prepareMessagePayload } from '~/message/utils';
 
 /**
  * ```js
@@ -37,7 +38,8 @@ export const onReactorRemoved = (
   };
 
   if (referenceType === 'message') {
-    const filter = (payload: Amity.MessagePayload) => {
+    const filter = (rawPayload: Amity.RawMessagePayload) => {
+      const payload = prepareMessagePayload(rawPayload);
       if (!payload.messages[0].latestReaction) return;
 
       const { eventName, referenceId, referenceType, ...reactor } =
@@ -51,12 +53,7 @@ export const onReactorRemoved = (
       callbackWrapper('message', payload.messages[0].messageId, reactor);
     };
 
-    return createEventSubscriber(
-      client,
-      'reaction/onReactorRemoved',
-      'v3.message.didUpdate',
-      filter,
-    );
+    return createEventSubscriber(client, 'reaction/onReactorRemoved', 'message.updated', filter);
   }
 
   if (referenceType === 'post') {

package/src/reaction/observers/liveReactions.ts

@@ -74,7 +74,7 @@ export const liveReactions = (
     });
   };
 
-  const realtimeRouter = (reaction: Amity.Reactor, action: Amity.ReactionActionType) => {
+  const realtimeRouter = (action: Amity.ReactionActionType) => (reaction: Amity.Reactor) => {
     const collection = pullFromCache<Amity.ReactionLiveCollectionCache>(cacheKey)?.data;
     if (!collection) return;
 
@@ -125,11 +125,11 @@ export const liveReactions = (
   };
 
   disposers.push(
-    onReactorAdded(queryParams.referenceType, queryParams.referenceId, reaction =>
-      realtimeRouter(reaction, 'onAdded'),
-    ),
-    onReactorRemoved(queryParams.referenceType, queryParams.referenceId, reaction =>
-      realtimeRouter(reaction, 'onRemoved'),
+    onReactorAdded(queryParams.referenceType, queryParams.referenceId, realtimeRouter('onAdded')),
+    onReactorRemoved(
+      queryParams.referenceType,
+      queryParams.referenceId,
+      realtimeRouter('onRemoved'),
     ),
   );
 

package/src/reaction/utils/dispatchReactable.ts

@@ -7,7 +7,7 @@ export const dispatchReactable = <T extends Amity.ReactableType>(
 ) => {
   if (referenceType === 'message')
     // @ts-ignore: refactor later
-    fireEvent('v3.message.didUpdate', { messages: [model] });
+    fireEvent('local.message.updated', { messages: [model] });
   else if (referenceType === 'post')
     // @ts-ignore: refactor later
     fireEvent('post.updated', { posts: [model] });

package/src/report/api/createReport.ts

@@ -3,6 +3,7 @@ import { getActiveClient } from '~/client/api/activeClient';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { fireEvent } from '~/core/events';
 
+import { prepareMessagePayload } from '~/message/utils';
 import REFERENCE_TYPES from '../constants/referenceTypes';
 
 /**
@@ -25,26 +26,35 @@ export const createReport = async (
   const client = getActiveClient();
   client.log('report/createReport', { referenceType, referenceId });
 
-  const { domainName } = REFERENCE_TYPES[referenceType];
+  const getAPIUrl = (): string => {
+    if (referenceType === 'user') {
+      return `/api/v4/me/flags/${encodeURIComponent(referenceId)}`;
+    }
+
+    if (referenceType === 'message') {
+      return `/api/v5/messages/${encodeURIComponent(referenceId)}/flags`;
+    }
+
+    const { domainName } = REFERENCE_TYPES[referenceType];
+
+    return `/api/v3/${domainName}/${encodeURIComponent(referenceId)}/flag`;
+  };
 
   const { data } = await client.http.post<
-    Amity.PostPayload | Amity.CommentPayload | Amity.MessagePayload | Amity.UserPayload
-  >(
-    `/api/${
-      referenceType === 'user'
-        ? `v4/me/flags/${encodeURIComponent(referenceId)}`
-        : `v3/${domainName}/${encodeURIComponent(referenceId)}/flag`
-    }`,
-  );
-
-  if (client.cache) ingestInCache(data);
-
-  const event =
-    referenceType === 'message'
-      ? ('v3.message.didUpdate' as const)
-      : (`${referenceType}.flagged` as const);
-
-  fireEvent(event, data);
+    Amity.PostPayload | Amity.CommentPayload | Amity.RawMessagePayload | Amity.UserPayload
+  >(getAPIUrl());
+
+  if (client.cache)
+    ingestInCache(
+      referenceType === 'message' ? prepareMessagePayload(data as Amity.RawMessagePayload) : data,
+    );
+
+  if (referenceType === 'message') {
+    fireEvent('message.flagged', data as Amity.RawMessagePayload);
+  } else {
+    // @ts-ignore
+    fireEvent(`${referenceType}.flagged`, data);
+  }
 
   return !!data;
 };

package/src/report/api/deleteReport.ts

@@ -2,8 +2,9 @@ import { getActiveClient } from '~/client/api/activeClient';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
-import REFERENCE_TYPES from '../constants/referenceTypes';
 import { fireEvent } from '~/core/events';
+import { prepareMessagePayload } from '~/message/utils';
+import REFERENCE_TYPES from '../constants/referenceTypes';
 
 /**
  * ```js
@@ -25,26 +26,35 @@ export const deleteReport = async (
   const client = getActiveClient();
   client.log('report/deleteReport', { referenceType, referenceId });
 
-  const { domainName } = REFERENCE_TYPES[referenceType];
+  const getAPIUrl = (): string => {
+    if (referenceType === 'user') {
+      return `/api/v4/me/flags/${encodeURIComponent(referenceId)}`;
+    }
+
+    if (referenceType === 'message') {
+      return `/api/v5/messages/${encodeURIComponent(referenceId)}/flags`;
+    }
+
+    const { domainName } = REFERENCE_TYPES[referenceType];
+
+    return `/api/v3/${domainName}/${encodeURIComponent(referenceId)}/unflag`;
+  };
 
   const { data } = await client.http.delete<
     Amity.PostPayload | Amity.CommentPayload | Amity.MessagePayload | Amity.UserPayload
-  >(
-    `/api/${
-      referenceType === 'user'
-        ? `v4/me/flags/${encodeURIComponent(referenceId)}`
-        : `v3/${domainName}/${encodeURIComponent(referenceId)}/unflag`
-    }`,
-  );
-
-  if (client.cache) ingestInCache(data);
-
-  const event =
-    referenceType === 'message'
-      ? ('v3.message.didUpdate' as const)
-      : (`${referenceType}.unflagged` as const);
-
-  fireEvent(event, data);
+  >(getAPIUrl());
+
+  if (client.cache)
+    ingestInCache(
+      referenceType === 'message' ? prepareMessagePayload(data as Amity.RawMessagePayload) : data,
+    );
+
+  if (referenceType === 'message') {
+    fireEvent('message.unflagged', data as Amity.RawMessagePayload);
+  } else {
+    // @ts-ignore
+    fireEvent(`${referenceType}.unflagged`, data);
+  }
 
   return !!data;
 };

package/src/report/api/isReportedByMe.ts

@@ -1,6 +1,5 @@
 import { getActiveClient } from '~/client/api/activeClient';
 import { synchronousWSCall } from '~/core/transports';
-
 import REFERENCE_TYPES from '../constants/referenceTypes';
 
 /**
@@ -19,12 +18,20 @@ import REFERENCE_TYPES from '../constants/referenceTypes';
 export const isReportedByMe = async (
   referenceType: keyof typeof REFERENCE_TYPES,
   referenceId: string,
-) => {
+): Promise<boolean> => {
   const client = getActiveClient();
   client.log('report/isReportedByMe', { referenceType, referenceId });
 
   const { eventName, primaryKey } = REFERENCE_TYPES[referenceType];
 
+  if (referenceType === 'message') {
+    const { data } = await client.http.get<{ result: boolean }>(
+      `/api/v5/messages/${encodeURIComponent(referenceId)}/flags`,
+    );
+
+    return data.result;
+  }
+
   const { result, isFlagByMe } =
     (await synchronousWSCall<{
       result?: boolean;

package/src/stream/api/tests/createStream.test.ts

@@ -0,0 +1,30 @@
+import { getActiveClient } from '~/client/api';
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  streamResponse,
+} from '~/utils/tests';
+import { createStream } from '../createStream';
+
+const bundle: Parameters<typeof createStream>[0] = {
+  title: 'my stream',
+  'thumbnailFileId': streamResponse.data.videoStreamings[0].thumbnailFileId,
+};
+
+describe('createStream', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  it('creates a stream and returns the new stream', async () => {
+    client.http.post = jest.fn().mockResolvedValueOnce(streamResponse);
+
+    const created = await createStream(bundle);
+
+    expect(getActiveClient().http.post).toHaveBeenCalledWith(
+      `/api/v3/video-streaming`,
+      bundle
+    );
+    expect(created.data).toEqual(streamResponse.data.videoStreamings[0]);
+  });
+});

package/src/stream/api/tests/deleteStream.test.ts

@@ -0,0 +1,48 @@
+import { disableCache, enableCache, pullFromCache, pushToCache } from '~/cache/api';
+import { client, connectClient, disconnectClient, streamResponse } from '~/utils/tests';
+
+import { deleteStream } from '~/stream/api';
+
+const STREAM_ID = streamResponse.data.videoStreamings[0].streamId;
+
+const resolvedDeleteValue = {
+  data: {
+    success: true,
+  },
+};
+
+jest.mock('~/stream/api/getStream', () => ({
+  getStream: jest.fn(() => Promise.resolve(streamResponse.data.videoStreamings[0])),
+}));
+
+describe('deleteStream', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  test('should return deleted stream', async () => {
+    client.http.delete = jest.fn().mockResolvedValueOnce(resolvedDeleteValue);
+
+    await expect(deleteStream(STREAM_ID)).resolves.toEqual(true);
+  });
+
+  test('should throw an error if request fails', async () => {
+    client.http.delete = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(deleteStream(STREAM_ID)).rejects.toThrow('error');
+  });
+
+  test('should update cache after deleted stream', async () => {
+    enableCache();
+    client.http.delete = jest.fn().mockResolvedValueOnce(resolvedDeleteValue);
+    pushToCache(['community', 'get', STREAM_ID], streamResponse.data.videoStreamings[0]);
+
+    await deleteStream(STREAM_ID);
+    const recieved = pullFromCache(['stream', 'get', STREAM_ID])?.data;
+
+    expect(recieved).toEqual(expect.objectContaining({
+      isDeleted: true
+    }));
+
+    disableCache();
+  });
+});

package/src/stream/api/tests/getStream.test.ts

@@ -0,0 +1,23 @@
+import { enableCache } from '~/cache/api';
+import { client, connectClient, disconnectClient, streamResponse } from '~/utils/tests';
+import { getStream } from '~/stream/api';
+
+const STREAM_ID = streamResponse.data.videoStreamings[0].streamId;
+
+describe('getStream', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  test('Should return the stream from backend', async () => {
+    enableCache();
+    client.http.get = jest.fn().mockResolvedValueOnce(streamResponse);
+    const { data } = await getStream(STREAM_ID);
+    expect(data).toEqual(streamResponse.data.videoStreamings[0]);
+  });
+
+  test('Should return stream from locally', () => {
+    const stream: ReturnType<typeof getStream.locally> = getStream.locally(STREAM_ID);
+
+    expect(stream?.data).toEqual(streamResponse.data.videoStreamings[0]);
+  });
+});

package/src/subChannel/api/createSubChannel.ts

@@ -0,0 +1,41 @@
+import { getActiveClient } from '~/client/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { fireEvent } from '~/core/events';
+import { prepareSubChannelPayload } from '../utils';
+
+/**
+ * ```js
+ * import { createSubChannel } from '@amityco/ts-sdk'
+ * const created = await createSubChannel({ channelId: 'foobar', name: 'foobar' })
+ * ```
+ *
+ * Creates an {@link Amity.SubChannel}
+ *
+ * @param bundle The data necessary to create a new {@link Amity.SubChannel}
+ * @returns The newly created {@link Amity.SubChannel}
+ *
+ * @category Channel API
+ * @async
+ */
+export const createSubChannel = async <T extends Amity.ChannelType>(
+  bundle: Pick<Amity.SubChannel, 'channelId' | 'displayName'>,
+): Promise<Amity.Cached<Amity.SubChannel>> => {
+  const client = getActiveClient();
+  client.log('user/createSubChannel', bundle);
+
+  const response = await client.http.post<Amity.RawSubChannelPayload>('/api/v5/message-feeds', {
+    channelId: bundle.channelId,
+    name: bundle.displayName,
+  });
+  const data = prepareSubChannelPayload(response.data);
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  fireEvent('message-feed.created', response.data);
+
+  return {
+    data: data.messageFeeds[0],
+    cachedAt,
+  };
+};

package/src/subChannel/api/deleteSubChannel.ts

@@ -0,0 +1,53 @@
+import { getActiveClient } from '~/client/api';
+import { pushToTombstone } from '~/cache/api/pushToTombstone';
+import { upsertInCache } from '~/cache/api';
+import { fireEvent } from '~/core/events';
+import { getFutureDate } from '~/core/model';
+import { getSubChannel } from './getSubChannel';
+
+/**
+ * ```js
+ * import { deleteSubChannel } from '@amityco/ts-sdk'
+ * const success = await deleteSubChannel('foobar')
+ * ```
+ *
+ * Deletes a {@link Amity.SubChannel}
+ *
+ * @param subChannelId The {@link Amity.SubChannel} ID to delete
+ * @return A success boolean if the {@link Amity.SubChannel} was deleted
+ *
+ * @category Channel API
+ * @async
+ */
+export const deleteSubChannel = async (
+  subChannelId: Amity.SubChannel['subChannelId'],
+  permanent = false,
+): Promise<Amity.SubChannel> => {
+  const client = getActiveClient();
+  client.log('channel/deleteSubChannel', subChannelId);
+
+  const subChannel = await getSubChannel(subChannelId);
+
+  await client.http.delete<{ success: boolean }>(
+    `/api/v5/message-feeds/${encodeURIComponent(subChannelId)}`,
+    { params: { permanent } },
+  );
+
+  const deleted = {
+    ...subChannel.data,
+    isDeleted: true,
+    updatedAt: getFutureDate(subChannel.data.updatedAt),
+  };
+
+  if (permanent) {
+    setTimeout(() => {
+      pushToTombstone('subChannel', subChannelId);
+    }, 0);
+  } else {
+    upsertInCache(['subChannel', 'get', subChannelId], deleted);
+  }
+
+  fireEvent('local.message-feed.deleted', { messageFeeds: [deleted] });
+
+  return deleted;
+};

package/src/subChannel/api/getSubChannel.ts

@@ -0,0 +1,85 @@
+import { pullFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { isInTombstone } from '~/cache/api/isInTombstone';
+import { pushToTombstone } from '~/cache/api/pushToTombstone';
+import { checkIfShouldGoesToTombstone } from '~/cache/utils';
+import { getActiveClient } from '~/client/api';
+import { fireEvent } from '~/core/events';
+import { prepareSubChannelPayload } from '../utils';
+
+/**
+ * ```js
+ * import { getSubChannel } from '@amityco/ts-sdk'
+ * const subChannel = await getSubChannel('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.SubChannel} object
+ *
+ * @param subChannelId the ID of the {@link Amity.SubChannel} to fetch
+ * @returns the associated {@link Amity.SubChannel} object
+ *
+ * @category Channel API
+ * @async
+ */
+export const getSubChannel = async (
+  subChannelId: Amity.SubChannel['subChannelId'],
+): Promise<Amity.Cached<Amity.SubChannel>> => {
+  const client = getActiveClient();
+  client.log('channel/getSubChannel', subChannelId);
+
+  isInTombstone('subChannel', subChannelId);
+
+  try {
+    const response = await client.http.get<Amity.RawSubChannelPayload>(
+      `/api/v5/message-feeds/${encodeURIComponent(subChannelId)}`,
+    );
+    const data = prepareSubChannelPayload(response.data);
+
+    const cachedAt = client.cache && Date.now();
+    if (client.cache) ingestInCache(data, { cachedAt });
+
+    fireEvent('local.message-feed.fetched', data);
+
+    return {
+      data: data.messageFeeds[0],
+      cachedAt,
+    };
+  } catch (error) {
+    if (checkIfShouldGoesToTombstone((error as Amity.ErrorResponse)?.code)) {
+      pushToTombstone('subChannel', subChannelId);
+    }
+
+    throw error;
+  }
+};
+
+/**
+ * ```js
+ * import { getSubChannel } from '@amityco/ts-sdk'
+ * const subChannel = getSubChannel.locally('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.SubChannel} object from cache
+ *
+ * @param subChannelId the ID of the {@link Amity.SubChannel} to fetch
+ * @returns the associated {@link Amity.SubChannel} object
+ *
+ * @category Channel API
+ */
+getSubChannel.locally = (
+  subChannelId: Amity.SubChannel['subChannelId'],
+): Amity.Cached<Amity.SubChannel> | undefined => {
+  const client = getActiveClient();
+  client.log('channel/getSubChannel.locally', subChannelId);
+
+  if (!client.cache) return;
+
+  const cached = pullFromCache<Amity.SubChannel>(['subChannel', 'get', subChannelId]);
+
+  if (!cached) return;
+
+  return {
+    data: cached.data,
+    cachedAt: cached.cachedAt,
+  };
+};

package/src/subChannel/api/getSubChannels.ts

@@ -0,0 +1,77 @@
+import { pullFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { getActiveClient } from '~/client/api';
+import { fireEvent } from '~/core/events';
+import { prepareSubChannelPayload } from '../utils';
+
+/**
+ * ```js
+ * import { getSubChannels } from '@amityco/ts-sdk'
+ * const subChannels = await getSubChannels(['foo', 'bar'])
+ * ```
+ *
+ * Fetches a collection of {@link Amity.SubChannel} objects
+ *
+ * @param subChannelIds the IDs of the {@link Amity.SubChannel} to fetch
+ * @returns the associated collection of {@link Amity.SubChannel} objects
+ *
+ * @category Channel API
+ * @async
+ */
+export const getSubChannels = async (
+  subChannelIds: Amity.SubChannel['subChannelId'][],
+): Promise<Amity.Cached<Amity.SubChannel[]>> => {
+  const client = getActiveClient();
+  client.log('channel/getSubChannels', subChannelIds);
+
+  const response = await client.http.get<Amity.RawSubChannelPayload>('/api/v5/message-feeds/list', {
+    params: { messageFeedIds: subChannelIds.map(encodeURIComponent) },
+  });
+  const data = prepareSubChannelPayload(response.data);
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  fireEvent('local.message-feed.fetched', data);
+
+  return {
+    data: data.messageFeeds,
+    cachedAt,
+  };
+};
+
+/**
+ * ```js
+ * import { getSubChannels } from '@amityco/ts-sdk'
+ * const subChannels = getSubChannels.locally(['foo', 'bar']) ?? []
+ * ```
+ *
+ * Fetches a collection of {@link Amity.SubChannel} objects from cache
+ *
+ * @param subChannelIds the IDs of the {@link Amity.SubChannel} to fetch
+ * @returns the associated collection of {@link Amity.SubChannel} objects
+ *
+ * @category Channel API
+ */
+getSubChannels.locally = (
+  subChannelIds: Amity.SubChannel['subChannelId'][],
+): Amity.Cached<Amity.SubChannel[]> | undefined => {
+  const client = getActiveClient();
+  client.log('channel/getSubChannels.locally', subChannelIds);
+
+  if (!client.cache) return;
+
+  const cached = subChannelIds
+    .map(channelId => pullFromCache<Amity.SubChannel>(['subChannel', 'get', channelId])!)
+    .filter(Boolean);
+
+  if (cached?.length < subChannelIds.length) return;
+
+  const subChannels = cached.map(({ data }) => data);
+  const oldest = cached.sort((a, b) => (a.cachedAt! < b.cachedAt! ? -1 : 1))?.[0];
+
+  return {
+    data: subChannels,
+    cachedAt: oldest.cachedAt,
+  };
+};

package/src/subChannel/api/index.ts

@@ -0,0 +1,8 @@
+export * from './querySubChannels';
+export * from './getSubChannels';
+export * from './getSubChannel';
+// export * from './getSubChannelByCreator';
+
+export * from './createSubChannel';
+export * from './updateSubChannel';
+export * from './deleteSubChannel';