@amityco/ts-sdk 0.0.1-003998f.0

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/observeComment.ts

@@ -0,0 +1,96 @@
+import { getActiveClient } from '~/client/api';
+
+import { createQuery, runQuery, queryOptions } from '~/core/query';
+
+import { getComment } from '../api';
+
+import {
+  onCommentUpdated,
+  onCommentDeleted,
+  onCommentFlagged,
+  onCommentUnflagged,
+  onCommentReactionAdded,
+  onCommentReactionRemoved,
+} from '../events';
+
+/**
+ * ```js
+ * import { observeComment } from '@amityco/ts-sdk'
+ *
+ * let comment = {}
+ * const dispose = observeComment(commentId, ({ data }) => comment = data)
+ * ```
+ *
+ * Observe all mutation on a given {@link Amity.Comment}
+ *
+ * @param commentId the ID of the comment 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 comment
+ *
+ * @category Comment Observer
+ */
+export const observeComment = <
+  Events extends [
+    'onFetch',
+    'onUpdate',
+    'onDelete',
+    'onFlagged',
+    'onUnflagged',
+    'onReactionAdded',
+    'onReactionRemoved',
+  ],
+>(
+  commentId: string,
+  callback: Amity.ObjectListener<Amity.Snapshot<Amity.Comment | undefined>, Events>,
+  policy: Amity.QueryPolicy = 'cache_then_server',
+): Amity.Unsubscriber => {
+  const { log } = getActiveClient();
+
+  const timestamp = Date.now();
+  log(`observeComment(tmpid: ${timestamp}) > listen`);
+
+  // wrapper function to make sure
+  const router = (result: Amity.Snapshot<Amity.Comment | undefined>, action: Events[number]) => {
+    if (callback instanceof Function) return callback(result);
+
+    if (action !== 'onFetch') callback.onEvent?.(action, result);
+
+    callback[action]?.(result);
+  };
+
+  const realtimeRouter = (result: Amity.Snapshot<Amity.Comment>, action: Events[number]) => {
+    if (result.data?.commentId !== commentId) return;
+
+    router(result, action);
+  };
+
+  const disposers: Amity.Unsubscriber[] = [];
+
+  disposers.push(
+    onCommentUpdated(data => realtimeRouter({ data, loading: false, origin: 'event' }, 'onUpdate')),
+    onCommentDeleted(data => realtimeRouter({ data, loading: false, origin: 'event' }, 'onDelete')),
+    onCommentFlagged(data =>
+      realtimeRouter({ data, loading: false, origin: 'event' }, 'onFlagged'),
+    ),
+    onCommentUnflagged(data =>
+      realtimeRouter({ data, loading: false, origin: 'event' }, 'onUnflagged'),
+    ),
+    onCommentReactionAdded(data =>
+      realtimeRouter({ data, loading: false, origin: 'event' }, 'onReactionAdded'),
+    ),
+    onCommentReactionRemoved(data =>
+      realtimeRouter({ data, loading: false, origin: 'event' }, 'onReactionRemoved'),
+    ),
+  );
+
+  runQuery(
+    createQuery(getComment, commentId),
+    result => (result.data || result.error) && router(result, 'onFetch'),
+    queryOptions(policy),
+  );
+
+  return () => {
+    log(`observeComment(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/comment/observers/observeComments.ts

@@ -0,0 +1,74 @@
+import { getActiveClient } from '~/client/api';
+
+import {
+  onCommentCreated,
+  onCommentUpdated,
+  onCommentDeleted,
+  onCommentFlagged,
+  onCommentUnflagged,
+  onCommentReactionAdded,
+  onCommentReactionRemoved,
+} from '../events';
+
+/**
+ * ```js
+ * import { observeComments } from '@amityco/ts-sdk'
+ *
+ * let comments = []
+ * const unsub = observeComments(postId, comment => merge(comments, comment))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.Comment} for a given {@link Amity.Post} object
+ *
+ * @param postId the ID of the post where to observe the comments
+ * @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 comments
+ *
+ * @category Comment Observer
+ */
+export const observeComments = (
+  postId: Amity.Post['postId'],
+  callback: Amity.ObjectListener<
+    Amity.Comment,
+    [
+      'onCreate',
+      'onUpdate',
+      'onDelete',
+      'onFlagged',
+      'onUnflagged',
+      'onReactionAdded',
+      'onReactionRemoved',
+    ]
+  >,
+): Amity.Unsubscriber => {
+  const { log } = getActiveClient();
+
+  const timestamp = Date.now();
+  log(`observeComments(tmpid: ${timestamp}) > listen`);
+
+  const disposers: Amity.Unsubscriber[] = [];
+
+  const router = (comment: Amity.Comment, action: Exclude<Amity.CommentActionType, 'onFetch'>) => {
+    if (comment.referenceId !== postId) return;
+
+    if (callback instanceof Function) return callback(comment);
+
+    callback.onEvent?.(action, comment);
+    callback[action]?.(comment);
+  };
+
+  disposers.push(
+    onCommentCreated(comment => router(comment, 'onCreate')),
+    onCommentUpdated(comment => router(comment, 'onUpdate')),
+    onCommentDeleted(comment => router(comment, 'onDelete')),
+    onCommentFlagged(comment => router(comment, 'onFlagged')),
+    onCommentUnflagged(comment => router(comment, 'onUnflagged')),
+    onCommentReactionAdded(comment => router(comment, 'onReactionAdded')),
+    onCommentReactionRemoved(comment => router(comment, 'onReactionRemoved')),
+  );
+
+  return () => {
+    log(`observeComments(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/community/api/addCommunityMembers.ts

@@ -0,0 +1,42 @@
+import { getActiveClient } from '~/client/api';
+
+import { fireEvent } from '~/core/events';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/**
+ * ```js
+ * import { addCommunityMembers } from '@amityco/ts-sdk'
+ * const updated = await addCommunityMembers(communityId, ['foo', 'bar'])
+ * ```
+ *
+ * Adds a list of {@link Amity.User} to a {@link Amity.Community} to add users to
+ *
+ * @param communityId The ID of the {@link Amity.Community} to perform
+ * @param userIds The list of IDs {@link Amity.User} to add
+ * @returns A success boolean if the {@link Amity.User} were added to the {@link Amity.Community}
+ *
+ * @category Community API
+ * @async
+ */
+export const addCommunityMembers = async (
+  communityId: Amity.Community['communityId'],
+  userIds: Amity.User['userId'][],
+): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('community/addCommunityMembers', communityId, userIds);
+
+  const { data } = await client.http.post<Amity.CommunityMembershipPayload>(
+    `/api/v3/communities/${communityId}/users`,
+    { communityId, userIds },
+  );
+
+  if (client.cache) ingestInCache(data);
+
+  fireEvent('community.userAdded', data);
+
+  const { communityUsers } = data;
+  return !!communityUsers.find(
+    communityUser =>
+      communityUser.communityId === communityId && communityUser.communityMembership === 'member',
+  );
+};

package/src/community/api/addCommunityMembersRoles.ts

@@ -0,0 +1,42 @@
+import { getActiveClient } from '~/client/api';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/**
+ * ```js
+ * import { addCommunityMembersRoles } from '@amityco/ts-sdk'
+ * const updated = await addCommunityMembersRoles(communityId, ['foo'], ['bar'])
+ * ```
+ *
+ * Adds a list of {@link Amity.Role} to a list of {@link Amity.User} on a {@link Amity.Community}
+ *
+ * @param communityId The ID of the {@link Amity.Community} to perform
+ * @param roleIds Array of IDs of the {@link Amity.Role} to apply
+ * @param userId Array of IDs of the {@link Amity.User} to perform
+ * @returns A success boolean if the {@link Amity.Role} were added to list of {@link Amity.User} in the {@link Amity.Community}
+ *
+ * @category Community API
+ * @async
+ */
+export const addCommunityMembersRoles = async (
+  communityId: Amity.Community['communityId'],
+  roleIds: Amity.Role['roleId'][],
+  userIds: Amity.User['userId'][],
+): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('community/addCommunityMembersRoles', communityId, roleIds, userIds);
+
+  const { data } = await client.http.post<Amity.CommunityMembershipPayload>(
+    `/api/v4/communities/${communityId}/users/roles`,
+    { communityId, roles: roleIds, userIds },
+  );
+
+  if (client.cache) ingestInCache(data);
+
+  const { communityUsers } = data;
+  return !!communityUsers.find(
+    communityUser =>
+      communityUser.communityId === communityId &&
+      roleIds.some(role => communityUser.roles.includes(role)),
+  );
+};

package/src/community/api/createCommunity.ts

@@ -0,0 +1,59 @@
+import { getActiveClient } from '~/client/api';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { fireEvent } from '~/core/events';
+
+import { packCommunityPayload, unpackCommunityPayload } from '../utils';
+
+/**
+ * ```js
+ * import { createCommunity } from '@amityco/ts-sdk'
+ * const created = await createCommunity({ communityId: 'foobar', displayName: 'foobar' })
+ * ```
+ *
+ * Creates an {@link Amity.Community}
+ *
+ * @param bundle The data necessary to create a new {@link Amity.Community}
+ * @returns The newly created {@link Amity.Community}
+ *
+ * @category Community API
+ * @async
+ */
+export const createCommunity = async (
+  bundle: Pick<
+    Amity.Community,
+    | 'displayName'
+    | 'avatarFileId'
+    | 'description'
+    | 'isPublic'
+    | 'isOfficial'
+    | 'postSetting'
+    | 'tags'
+    | 'metadata'
+  > & {
+    userIds?: string[];
+    categoryIds?: string[];
+    isUniqueDisplayName?: boolean;
+  },
+): Promise<Amity.Cached<Amity.Community>> => {
+  const client = getActiveClient();
+  client.log('user/createCommunity', bundle);
+
+  const { data: payload } = await client.http.post<Amity.CommunityPayload>(
+    '/api/v3/communities/',
+    packCommunityPayload(bundle),
+  );
+
+  const data = unpackCommunityPayload(payload);
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  fireEvent('community.created', data);
+
+  const { communities } = data;
+  return {
+    data: communities[0],
+    cachedAt,
+  };
+};

package/src/community/api/deleteCommunity.ts

@@ -0,0 +1,33 @@
+import { getActiveClient } from '~/client/api';
+
+import { fireEvent } from '~/core/events';
+import { getCommunity } from './getCommunity';
+
+/**
+ * ```js
+ * import { deleteCommunity } from '@amityco/ts-sdk'
+ * const success = await deleteCommunity('foobar')
+ * ```
+ *
+ * Deletes a {@link Amity.Community}
+ *
+ * @param communityId The {@link Amity.Community} ID to delete
+ * @return A success boolean if the {@link Amity.Community} was deleted
+ *
+ * @category Community API
+ * @async
+ */
+export const deleteCommunity = async (
+  communityId: Amity.Community['communityId'],
+): Promise<Amity.Community> => {
+  const client = getActiveClient();
+  client.log('community/deleteCommunity', communityId);
+
+  // API-FIX: This endpoint has not been implemented yet.
+  await client.http.delete<{ success: boolean }>(`/api/v3/communities/${communityId}`);
+
+  const deleted = await getCommunity(communityId);
+  fireEvent('community.deleted', { communities: [deleted.data] });
+
+  return deleted.data;
+};

package/src/community/api/getCommunities.ts

@@ -0,0 +1,81 @@
+import { getActiveClient } from '~/client/api';
+
+import { pullFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+import { unpackCommunityPayload } from '../utils';
+
+/**
+ * ```js
+ * import { getCommunities } from '@amityco/ts-sdk'
+ * const communities = await getCommunities(['foo', 'bar'])
+ * ```
+ *
+ * Fetches a collection of {@link Amity.Community} objects
+ *
+ * @param communityIds the IDs of the {@link Amity.Community} to fetch
+ * @returns the associated collection of {@link Amity.Community} objects
+ *
+ * @category Community API
+ * @async
+ */
+export const getCommunities = async (
+  communityIds: Amity.Community['communityId'][],
+): Promise<Amity.Cached<Amity.Community[]>> => {
+  const client = getActiveClient();
+  client.log('community/getCommunities', communityIds);
+
+  // API-FIX: endpoint should not be /list, parameters should be querystring.
+  const { data: payload } = await client.http.get<Amity.CommunityPayload>(
+    `/api/v3/communities/list`,
+    {
+      params: { communityIds },
+    },
+  );
+
+  const data = unpackCommunityPayload(payload);
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  return {
+    data: data.communities,
+    cachedAt,
+  };
+};
+
+/**
+ * ```js
+ * import { getCommunities } from '@amityco/ts-sdk'
+ * const communities = getCommunities.locally(['foo', 'bar']) ?? []
+ * ```
+ *
+ * Fetches a collection of {@link Amity.Community} objects from cache
+ *
+ * @param communityIds the IDs of the {@link Amity.Community} to fetch
+ * @returns the associated collection of {@link Amity.Community} objects
+ *
+ * @category Community API
+ */
+getCommunities.locally = (
+  communityIds: Amity.Community['communityId'][],
+): Amity.Cached<Amity.Community[]> | undefined => {
+  const client = getActiveClient();
+  client.log('community/getCommunities.locally', communityIds);
+
+  if (!client.cache) return;
+
+  const cached = communityIds
+    .map(communityId => pullFromCache<Amity.Community>(['community', 'get', communityId])!)
+    .filter(Boolean);
+
+  const communities = cached.map(({ data }) => data);
+  const oldest = cached.sort((a, b) => (a.cachedAt! < b.cachedAt! ? -1 : 1))?.[0];
+
+  if (cached?.length < communityIds.length) return;
+
+  return {
+    data: communities,
+    cachedAt: oldest.cachedAt,
+  };
+};

package/src/community/api/getCommunity.ts

@@ -0,0 +1,75 @@
+import { getActiveClient } from '~/client/api';
+
+import { pullFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+import { unpackCommunityPayload } from '../utils';
+
+/**
+ * ```js
+ * import { getCommunity } from '@amityco/ts-sdk'
+ * const community = await getCommunity('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.Community} object
+ *
+ * @param communityId the ID of the {@link Amity.Community} to fetch
+ * @returns the associated {@link Amity.Community} object
+ *
+ * @category Community API
+ * @async
+ */
+export const getCommunity = async (
+  communityId: Amity.Community['communityId'],
+): Promise<Amity.Cached<Amity.Community>> => {
+  const client = getActiveClient();
+  client.log('community/getCommunity', communityId);
+
+  // API-FIX: endpoint should not be /list, parameters should be querystring.
+  const { data: payload } = await client.http.get<Amity.CommunityPayload>(
+    `/api/v3/communities/${communityId}`,
+  );
+
+  const data = unpackCommunityPayload(payload);
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  const { communities } = data;
+
+  return {
+    data: communities.find(community => community.communityId === communityId)!,
+    cachedAt,
+  };
+};
+
+/**
+ * ```js
+ * import { getCommunity } from '@amityco/ts-sdk'
+ * const community = getCommunity.locally('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.Community} object from cache
+ *
+ * @param communityId the ID of the {@link Amity.Community} to fetch
+ * @returns the associated {@link Amity.Community} object
+ *
+ * @category Community API
+ */
+getCommunity.locally = (
+  communityId: Amity.Community['communityId'],
+): Amity.Cached<Amity.Community> | undefined => {
+  const client = getActiveClient();
+  client.log('community/getCommunity.locally', communityId);
+
+  if (!client.cache) return;
+
+  const cached = pullFromCache<Amity.Community>(['community', 'get', communityId]);
+
+  if (!cached) return;
+
+  return {
+    data: cached.data,
+    cachedAt: cached.cachedAt,
+  };
+};