@amityco/ts-sdk 0.0.1-e26de88.0 → 0.0.1-e556efe.0

package/src/@types/domains/reaction.ts

@@ -4,17 +4,15 @@ declare global {
   namespace Amity {
     type ReactableType = 'message' | 'post' | 'comment';
 
-    type Reaction = {
+    type ReactionActionType = 'onAdded' | 'onRemoved';
+
+    type Reactor = {
       reactionId: string;
-      userId: string;
       reactionName: string;
-    } & Amity.CreatedAt &
-      Amity.Relationship<ReactableType>;
+      userId: Amity.User['userId'];
+    } & Amity.CreatedAt;
 
-    type Reactions = {
-      reactions: Record<string, number>;
-      count: number;
-    };
+    type Reaction = Amity.Reactor & Amity.Relationship<ReactableType>;
 
     type Reactable = {
       reactionsCount: number;
@@ -22,8 +20,27 @@ declare global {
       myReactions?: string[];
 
       latestReaction?: Amity.Reaction & {
-        eventName: 'added' | 'removed';
+        eventName: 'add' | 'remove';
+        userDisplayName: string;
       };
     };
+
+    type ReactionQuery = {
+      reactors: Reactor[];
+    } & Amity.Relationship<ReactableType>;
+
+    type QueryReactions = {
+      referenceId: Amity.Reaction['referenceId'];
+      referenceType: Amity.Reaction['referenceType'];
+      reactionName?: Amity.Reaction['reactionName'];
+      page?: Amity.Page<string>;
+    };
+
+    type ReactionLiveCollection = Amity.LiveCollectionParams<Omit<QueryReactions, 'page'>>;
+
+    type ReactionLiveCollectionCache = Amity.LiveCollectionCache<
+      Amity.Reactor['reactionId'],
+      Pick<QueryReactions, 'page'>
+    >;
   }
 }

package/src/@types/domains/user.ts

@@ -7,12 +7,14 @@ declare global {
       userId: string;
       displayName?: string;
       avatarFileId?: Amity.File<'image'>['fileId'];
+      avatarCustomUrl?: string;
       description?: string;
     } & Amity.Metadata &
       Amity.Taggable &
       Amity.Flaggable &
       Amity.Accredited &
       Amity.Timestamps &
+      Amity.SoftDelete &
       Amity.Subscribable;
   }
 }

package/src/@types/index.ts

@@ -8,6 +8,7 @@ import './core/events'; // sdk events definitions
 import './core/paging'; // createQuery, runQuery
 import './core/query'; // createQuery, runQuery
 import './core/cache'; // cache.pull('user', ...)
+import './core/live';
 
 // domains
 import './domains/client'; // client definition
@@ -32,3 +33,5 @@ import './domains/comment';
 import './domains/stream';
 
 import './domains/mention';
+
+import './domains/poll';

package/src/category/api/getCategory.ts

@@ -1,11 +1,12 @@
 import { getActiveClient } from '~/client/api/activeClient';
 
-// import { ingestInCache } from '~/cache/api/ingestInCache'
+import { pullFromCache, dropFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
 
 /**
  * ```js
  * import { getCategory } from '@amityco/ts-sdk'
- * const category = await getCategory('foo')
+ * const { data: category } = await getCategory('foo')
  * ```
  *
  * Fetches a {@link Amity.Category} object
@@ -16,17 +17,54 @@ import { getActiveClient } from '~/client/api/activeClient';
  * @category Category API
  * @async
  */
-export const getCategory = async (categoryId: Amity.Category['categoryId']) => {
+export const getCategory = async (
+  categoryId: Amity.Category['categoryId'],
+): Promise<Amity.Cached<Amity.Category>> => {
   const client = getActiveClient();
   client.log('category/getCategory', categoryId);
 
   const { data } = await client.http.get<Amity.CategoryPayload>(
-    `/api/v3/community-categories/${categoryId}`,
+    `/api/v3/community-categories/${encodeURIComponent(categoryId)}`,
   );
 
-  // decoratePayload(data)
-  // ingestInCache(data)
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
 
   const { categories } = data;
-  return categories[0];
+
+  return {
+    data: categories.find(category => category.categoryId === categoryId)!,
+    cachedAt,
+  };
+};
+
+/**
+ * ```js
+ * import { getCategory } from '@amityco/ts-sdk'
+ * const { data: category } = getCategory.locally('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.Category} object from cache
+ *
+ * @param categoryId the ID of the {@link Amity.Category} to fetch
+ * @returns the associated {@link Amity.Category} object
+ *
+ * @category Category API
+ */
+getCategory.locally = (
+  categoryId: Amity.Category['categoryId'],
+): Amity.Cached<Amity.Category> | undefined => {
+  const client = getActiveClient();
+  client.log('category/getCategory.locally', categoryId);
+
+  if (!client.cache) return;
+
+  const cached = pullFromCache<Amity.Category>(['category', 'get', categoryId]);
+
+  if (!cached) return;
+
+  return {
+    data: cached.data,
+    cachedAt: cached.cachedAt,
+  };
 };

package/src/category/api/queryCategories.ts

@@ -1,12 +1,15 @@
 import { getActiveClient } from '~/client/api/activeClient';
 
-import { toPage, toToken } from '~/core/query';
-// import { ingestInCache } from '~/cache/api/ingestInCache'
+import { toToken, toPage } from '~/core/query';
+
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { getResolver } from '~/core/model';
 
 /**
  * ```js
  * import { queryCategories } from '@amityco/ts-sdk'
- * const categories = await queryCategories()
+ * const { data: categories, prevPage, nextPage } = await queryCategories()
  * ```
  *
  * Queries a paginable list of {@link Amity.Category} objects
@@ -14,18 +17,18 @@ import { toPage, toToken } from '~/core/query';
  * @param query The query parameters
  * @returns A page of {@link Amity.Category} objects
  *
- * @category Community API
+ * @category Category API
  * @async
  * */
 export const queryCategories = async (query?: {
   sortBy?: 'lastCreated' | 'firstCreated' | 'name';
   isDeleted?: Amity.Category['isDeleted'];
   page?: Amity.Page;
-}) => {
+}): Promise<Amity.Cached<Amity.Paged<Amity.Category, Amity.Page>>> => {
   const client = getActiveClient();
   client.log('category/queryCategories', query);
 
-  const { page, ...params } = query ?? {};
+  const { page = { limit: 10 }, ...params } = query ?? {};
 
   const { data } = await client.http.get<Amity.CategoryPayload & Amity.Pagination>(
     `/api/v3/community-categories`,
@@ -39,14 +42,68 @@ export const queryCategories = async (query?: {
     },
   );
 
-  const { paging, ...response } = data;
+  const { paging, ...payload } = data;
+  const { categories } = payload;
+
+  const cachedAt = client.cache && Date.now();
+
+  if (client.cache) {
+    ingestInCache(payload as Amity.CategoryPayload, { cachedAt });
+
+    const cacheKey = [
+      'category',
+      'query',
+      { ...params, options: { ...page } } as Amity.Serializable,
+    ];
+    pushToCache(cacheKey, { categories: categories.map(getResolver('category')), paging });
+  }
+
+  const nextPage = toPage(paging.next);
+  const prevPage = toPage(paging.previous);
+
+  return { data: categories, cachedAt, prevPage, nextPage };
+};
+
+/**
+ * ```js
+ * import { queryCategories } from '@amityco/ts-sdk'
+ * const { data: categories, prevPage, nextPage } = queryCategories.locally()
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.Category} objects from cache
+ *
+ * @param query The query parameters
+ * @returns categories
+ *
+ * @category category API
+ */
+queryCategories.locally = (
+  query: Parameters<typeof queryCategories>[0],
+): Amity.Cached<Amity.Paged<Amity.Category, Amity.Page>> | undefined => {
+  const client = getActiveClient();
+  client.log('category/queryCategories.locally', query);
+
+  if (!client.cache) return;
+
+  const { page = { limit: 10 }, ...params } = query ?? {};
+
+  const queryKey = ['category', 'query', { ...params, options: { ...page } } as Amity.Serializable];
+  const { data, cachedAt } =
+    pullFromCache<{ categories: Pick<Amity.Category, 'categoryId'>[] } & Amity.Pagination>(
+      queryKey,
+    ) ?? {};
+
+  if (!data?.categories.length) return;
 
-  // decoratePayload(response as unknown as Record<string, any[]>)
-  // ingestInCache(response as unknown as Record<string, any[]>)
+  const categories: Amity.Category[] = data.categories
+    .map(categoryId => pullFromCache<Amity.Category>(['category', 'get', categoryId])!)
+    .filter(Boolean)
+    .map(({ data }) => data);
 
-  const prevPage = toPage(paging?.previous);
-  const nextPage = toPage(paging?.next);
+  const prevPage = toPage(data?.paging.previous);
+  const nextPage = toPage(data?.paging.next);
 
-  const { categories } = response;
-  return { data: categories, prevPage, nextPage };
+  return categories.length === data?.categories?.length
+    ? { data: categories, cachedAt, prevPage, nextPage }
+    : undefined;
 };

package/src/channel/api/addChannelMembers.ts

@@ -33,7 +33,8 @@ export const addChannelMembers = async (
   if (client.cache) ingestInCache(data);
 
   fireEvent('v3.channel.didAddUsers', {
-    channels: data.channels!,
+    channels: data.channels,
+    channelUsers: data.channelUsers,
   });
 
   const { channelUsers } = data;

package/src/channel/api/banChannelMembers.ts

@@ -0,0 +1,41 @@
+import { getActiveClient } from '~/client/api/activeClient';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/**
+ * ```js
+ * import { banChannelMembers } from '@amityco/ts-sdk'
+ *
+ * await banChannelMembers('channel-id-1', ['userId1', 'userId2'])
+ * ```
+ *
+ * @param channelId of {@link Amity.Channel} from which the users should be banned
+ * @param userIds of the {@link Amity.User}'s to be banned
+ * @returns the updated {@link Amity.Membership}'s object
+ *
+ * @category Channel API
+ * @async
+ * */
+export const banChannelMembers = async (
+  channelId: Amity.Channel['channelId'],
+  userIds: Amity.User['userId'][],
+): Promise<Amity.Cached<Amity.Membership<'channel'>[]>> => {
+  const client = getActiveClient();
+  client.log('channel/banChannelMembers', { userIds, channelId });
+
+  const payload = await client.http.put<Amity.ChannelPayload>(
+    `/api/v3/channels/${channelId}/users/ban`,
+    {
+      userIds,
+    },
+  );
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(payload.data, { cachedAt });
+
+  const { channelUsers } = payload.data;
+  return {
+    data: channelUsers?.filter(user => user.membership === 'banned')!,
+    cachedAt,
+  };
+};

package/src/channel/api/deleteChannel.ts

@@ -22,7 +22,6 @@ export const deleteChannel = async (
   const client = getActiveClient();
   client.log('channel/deleteChannel', channelId);
 
-  // API-FIX: This endpoint has not been implemented yet.
   await client.http.delete<{ success: boolean }>(
     `/api/v3/channels/${encodeURIComponent(channelId)}`,
   );

package/src/channel/api/index.ts

@@ -16,3 +16,6 @@ export * from './removeChannelMembers';
 
 export * from './addChannelMembersRole';
 export * from './removeChannelMembersRole';
+
+export * from './banChannelMembers';
+export * from './unbanChannelMembers';

package/src/channel/api/queryChannelMembers.ts

@@ -19,22 +19,22 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
  * */
 export const queryChannelMembers = async (query: {
   channelId: string;
-  membership?: 'all' | 'muted' | 'banned' | 'member&banned';
+  memberships?: ('muted' | 'banned' | 'member')[];
   roles?: string[];
   sortBy?: 'firstCreated' | 'lastCreated';
+  search?: string;
   page?: Amity.Page;
 }): Promise<Amity.Cached<Amity.Paged<Amity.Membership<'channel'>>>> => {
   const client = getActiveClient();
   client.log('channel/queryChannelMembers', query);
 
-  const { page, channelId, membership, ...params } = query ?? {};
+  const { page, channelId, ...params } = query ?? {};
 
   const { data } = await client.http.get<Amity.ChannelMembershipPayload & Amity.Pagination>(
-    `/api/v3/channels/${encodeURIComponent(channelId)}/users`,
+    `/api/v4/channels/${encodeURIComponent(channelId)}/users`,
     {
       params: {
         ...params,
-        filter: membership,
         options: {
           token: toToken(page, 'skiplimit'),
         },

package/src/channel/api/queryChannels.ts

@@ -25,6 +25,9 @@ export const queryChannels = async (query?: {
   membership?: 'all' | 'member' | 'notMember';
   sortBy?: 'displayName' | 'firstCreated' | 'lastCreated';
   types?: Amity.ChannelType;
+  isDeleted?: Amity.Channel['isDeleted'];
+  tags?: Amity.Taggable['tags'];
+  excludeTags?: Amity.Taggable['tags'];
   page?: Amity.Page;
 }): Promise<Amity.Cached<Amity.Paged<Amity.Channel>>> => {
   const client = getActiveClient();

package/src/channel/api/removeChannelMembers.ts

@@ -33,7 +33,8 @@ export const removeChannelMembers = async (
   if (client.cache) ingestInCache(data);
 
   fireEvent('v3.channel.didRemoveUsers', {
-    channels: data.channels!,
+    channels: data.channels,
+    channelUsers: data.channelUsers,
   });
 
   const { channelUsers } = data;

package/src/channel/api/unbanChannelMembers.ts

@@ -0,0 +1,41 @@
+import { getActiveClient } from '~/client/api/activeClient';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/**
+ * ```js
+ * import { unbanChannelMembers } from '@amityco/ts-sdk'
+ *
+ * await unbanChannelMembers('channel-id-1', ['userId1', 'userId2'])
+ * ```
+ *
+ * @param channelId of {@link Amity.Channel} where the users should be unbanned
+ * @param userIds of the {@link Amity.User}'s to be unbanned
+ * @returns the updated {@link Amity.Membership}'s object
+ *
+ * @category Channel API
+ * @async
+ * */
+export const unbanChannelMembers = async (
+  channelId: Amity.Channel['channelId'],
+  userIds: Amity.User['userId'][],
+): Promise<Amity.Cached<Amity.Membership<'channel'>[]>> => {
+  const client = getActiveClient();
+  client.log('channel/unbanChannelMembers', { userIds, channelId });
+
+  const payload = await client.http.put<Amity.ChannelPayload>(
+    `/api/v3/channels/${encodeURIComponent(channelId)}/users/unban`,
+    {
+      userIds,
+    },
+  );
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(payload.data, { cachedAt });
+
+  const { channelUsers } = payload.data;
+  return {
+    data: channelUsers?.filter(user => user.membership === 'member')!,
+    cachedAt,
+  };
+};

package/src/channel/api/updateChannel.ts

@@ -19,7 +19,7 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
  */
 export const updateChannel = async (
   channelId: Amity.Channel['channelId'],
-  patch: Patch<Amity.Channel, 'displayName' | 'description' | 'avatarFileId' | 'metadata'>,
+  patch: Patch<Amity.Channel, 'displayName' | 'avatarFileId' | 'tags' | 'metadata'>,
 ): Promise<Amity.Cached<Amity.Channel>> => {
   const client = getActiveClient();
   client.log('channel/updateChannel', channelId, patch);

package/src/channel/events/index.ts

@@ -2,5 +2,5 @@ export * from './onChannelUpdated';
 export * from './onChannelDeleted';
 export * from './onChannelJoined';
 export * from './onChannelLeft';
-export * from './onMemberAdded';
-export * from './onMemberRemoved';
+export * from './onChannelMemberAdded';
+export * from './onChannelMemberRemoved';

package/src/channel/events/{onMemberAdded.ts → onChannelMemberAdded.ts}

@@ -5,8 +5,8 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
 
 /**
  * ```js
- * import { onMemberAdded } from '@amityco/ts-sdk'
- * const dispose = onMemberAdded(channel => {
+ * import { onChannelMemberAdded } from '@amityco/ts-sdk'
+ * const dispose = onChannelMemberAdded((channel, member) => {
  *   // ...
  * })
  * ```
@@ -18,13 +18,15 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
  *
  * @category Channel Events
  */
-export const onMemberAdded = (callback: Amity.Listener<Amity.Channel>) => {
+export const onChannelMemberAdded = (
+  callback: (channel: Amity.Channel, member: Amity.Membership<'channel'>) => void,
+) => {
   const client = getActiveClient();
 
-  const filter = (payload: Amity.ChannelPayload) => {
+  const filter = (payload: Amity.ChannelMembershipPayload) => {
     ingestInCache(payload);
-    callback(payload.channels[0]);
+    callback(payload.channels[0], payload.channelUsers[0]);
   };
 
-  return createEventSubscriber(client, 'onMemberAdded', 'v3.channel.didAddUsers', filter);
+  return createEventSubscriber(client, 'onChannelMemberAdded', 'v3.channel.didAddUsers', filter);
 };

package/src/channel/events/{onMemberRemoved.ts → onChannelMemberRemoved.ts}

@@ -5,8 +5,8 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
 
 /**
  * ```js
- * import { onMemberRemoved } from '@amityco/ts-sdk'
- * const dispose = onMemberRemoved(channel => {
+ * import { onChannelMemberRemoved } from '@amityco/ts-sdk'
+ * const dispose = onChannelMemberRemoved((channel, member) => {
  *   // ...
  * })
  * ```
@@ -18,13 +18,20 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
  *
  * @category Channel Events
  */
-export const onMemberRemoved = (callback: Amity.Listener<Amity.Channel>) => {
+export const onChannelMemberRemoved = (
+  callback: (channel: Amity.Channel, member: Amity.Membership<'channel'>) => void,
+) => {
   const client = getActiveClient();
 
-  const filter = (payload: Amity.ChannelPayload) => {
+  const filter = (payload: Amity.ChannelMembershipPayload) => {
     ingestInCache(payload);
-    callback(payload.channels[0]);
+    callback(payload.channels[0], payload.channelUsers[0]);
   };
 
-  return createEventSubscriber(client, 'onMemberRemoved', 'v3.channel.didRemoveUsers', filter);
+  return createEventSubscriber(
+    client,
+    'onChannelMemberRemoved',
+    'v3.channel.didRemoveUsers',
+    filter,
+  );
 };

package/src/channel/observers/observeChannel.ts

@@ -9,8 +9,8 @@ import {
   onChannelDeleted,
   onChannelJoined,
   onChannelLeft,
-  onMemberAdded,
-  onMemberRemoved,
+  onChannelMemberAdded,
+  onChannelMemberRemoved,
 } from '../events';
 
 /**
@@ -67,8 +67,12 @@ export const observeChannel = <
     onChannelDeleted(data => router({ data, loading: false, origin: 'event' }, 'onDelete')),
     onChannelJoined(data => router({ data, loading: false, origin: 'event' }, 'onJoin')),
     onChannelLeft(data => router({ data, loading: false, origin: 'event' }, 'onLeft')),
-    onMemberAdded(data => router({ data, loading: false, origin: 'event' }, 'onMemberAdded')),
-    onMemberRemoved(data => router({ data, loading: false, origin: 'event' }, 'onMemberRemoved')),
+    onChannelMemberAdded(data =>
+      router({ data, loading: false, origin: 'event' }, 'onMemberAdded'),
+    ),
+    onChannelMemberRemoved(data =>
+      router({ data, loading: false, origin: 'event' }, 'onMemberRemoved'),
+    ),
   );
 
   runQuery(createQuery(getChannel, channelId), result => result.data && router(result, 'onFetch'));

package/src/client/api/connectClient.ts

@@ -9,6 +9,8 @@ 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
@@ -20,26 +22,29 @@ import { onClientBanned } from '../events';
  *
  * Connects an {@link Amity.Client} instance to ASC servers
  *
- * @param userId the user ID for the current session
- * @param displayName the user's displayName for the current session
- * @param deviceId Manual override of the user's device id (for device management)
- * @param authToken The authentication token - necessary when network option is set to secure
+ * @param params the connect parameters
+ * @param params.userId the user ID for the current session
+ * @param params.displayName the user's displayName for the current session
+ * @param params.deviceId Manual override of the user's device id (for device management)
+ * @param params.authToken The authentication token - necessary when network option is set to secure
  * @returns a success boolean if connected
  *
  * @category Client API
  * @async
  */
-export const connectClient = async (params: {
-  userId: Amity.User['userId'];
-  displayName?: Amity.User['displayName'];
-  authToken?: string;
-  deviceId?: Amity.Device['deviceId'];
-}): Promise<boolean> => {
+export const connectClient = async (
+  params: {
+    userId: Amity.User['userId'];
+    displayName?: Amity.User['displayName'];
+    authToken?: string;
+    deviceId?: Amity.Device['deviceId'];
+  },
+  config?: { disableRTE: boolean },
+): Promise<boolean> => {
   const client = getActiveClient();
   client.log('client/api/connectClient', { apiKey: client.apiKey, ...params });
 
   // default values
-  params.displayName ??= params.userId;
   params.deviceId ??= getDeviceId();
 
   // @ts-ignore: in that particular case, typing can be
@@ -63,15 +68,22 @@ export const connectClient = async (params: {
     client.ws.open();
   });
 
-  const unsubscribe = onClientBanned(() => {
-    disconnectClient();
-    unsubscribe();
-  });
-
   client.userId = params.userId;
   client.accessToken = accessToken;
 
   setActiveUser(users[0]);
 
+  if (config?.disableRTE !== true) {
+    subscribeTopic(getNetworkTopic());
+  }
+
+  const subscriptions = [
+    onClientBanned(() => {
+      disconnectClient();
+      subscriptions.forEach(fn => fn());
+    }),
+    onUserDeleted(() => null),
+  ];
+
   return client.ws.connected;
 };

package/src/comment/api/queryComments.ts

@@ -19,19 +19,18 @@ import { getResolver } from '~/core/model';
  * @category Comment API
  * @async
  */
-export const queryComments = async (query: {
-  referenceType: Amity.Comment['referenceType'];
-  referenceId: Amity.Comment['referenceId'];
-  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);
 
   const { page = { limit: 10 }, ...params } = query;
 
+  const options = {
+    type: params.sortBy ? 'pagination' : undefined,
+    token: toToken(page, params.sortBy ? 'skiplimit' : 'afterbefore'),
+  };
   // const filterByParentId = query.parentId !== undefined
 
   // API-FIX: parameters should be querystring. (1)
@@ -43,9 +42,7 @@ export const queryComments = async (query: {
       params: {
         ...params,
         //      filterByParentId, API-FIX: backend does not support this boolean LOL. what the hell seriously.
-        options: {
-          token: toToken(page, 'afterbefore'),
-        },
+        options,
       },
     },
   );