@amityco/ts-sdk 0.0.1-beta.2 → 0.0.1-beta.22

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,84 @@
+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:
+      | 'onCreate'
+      | 'onUpdate'
+      | 'onDelete'
+      | 'onFlagged'
+      | 'onUnflagged'
+      | 'onReactionAdded'
+      | 'onReactionRemoved',
+  ) => {
+    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,53 @@
+import { getActiveClient } from '~/client/api';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { fireEvent } from '~/core/events';
+
+/**
+ * ```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'
+    | 'onlyAdminCanPost'
+    | 'needApprovalOnPostCreation'
+    | 'tags'
+    | 'metadata'
+  > & {
+    userIds?: string[];
+    categoryIds?: string[];
+    isUniqueDisplayName?: boolean;
+  },
+): Promise<Amity.Cached<Amity.Community>> => {
+  const client = getActiveClient();
+  client.log('user/createCommunity', bundle);
+
+  const { data } = await client.http.post<Amity.CommunityPayload>('/api/v3/communities/', bundle);
+
+  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,74 @@
+import { getActiveClient } from '~/client/api';
+
+import { pullFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/**
+ * ```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 } = await client.http.get<Amity.CommunityPayload>(`/api/v3/communities/list`, {
+    params: { communityIds },
+  });
+
+  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,71 @@
+import { getActiveClient } from '~/client/api';
+
+import { pullFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/**
+ * ```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 } = await client.http.get<Amity.CommunityPayload>(
+    `/api/v3/communities/${communityId}`,
+  );
+
+  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,
+  };
+};

package/src/community/api/getRecommendedCommunities.ts

@@ -0,0 +1,87 @@
+import { getActiveClient } from '~/client/api';
+
+import { getResolver } from '~/core/model';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/**
+ * ```js
+ * import { getRecommendedCommunities } from '@amityco/ts-sdk'
+ * const communities = await getRecommendedCommunities()
+ * ```
+ *
+ * Gets a list of recommended {@link Amity.Community} objects
+ *
+ * @param query The query parameters
+ * @returns A list of {@link Amity.Community} objects
+ *
+ * @category Community API
+ * @async
+ */
+export const getRecommendedCommunities = async (
+  query?: Partial<Amity.PageLimit>,
+): Promise<Amity.Cached<Amity.Community[]>> => {
+  const client = getActiveClient();
+  client.log('channel/getRecommendedCommunities', query);
+
+  const { limit = 5 } = query ?? {};
+
+  // API-FIX: backend doesnt answer Amity.Response
+  // const { data } = await client.http.get<Amity.Response<CommunityPayload>>(
+  const { data } = await client.http.get<Amity.CommunityPayload>(
+    `/api/v3/communities/recommended`,
+    { params: { options: { limit } } },
+  );
+
+  const { communities } = data;
+
+  const cachedAt = client.cache && Date.now();
+
+  if (client.cache) {
+    ingestInCache(data, { cachedAt });
+
+    const cacheKey = ['community', 'recommended', { params: { options: { limit } } }];
+    pushToCache(cacheKey, { communities: communities.map(getResolver('community')) });
+  }
+
+  return { data: communities, cachedAt };
+};
+
+/**
+ * ```js
+ * import { getRecommendedCommunities } from '@amityco/ts-sdk'
+ * const communities = getRecommendedCommunities.locally()
+ * ```
+ *
+ * Gets a list of recommended {@link Amity.Community} objects from cache
+ *
+ * @param query The query parameters
+ * @returns communities
+ *
+ * @category Community API
+ */
+getRecommendedCommunities.locally = (
+  query: Parameters<typeof getRecommendedCommunities>[0],
+): Amity.Cached<Amity.Community[]> | undefined => {
+  const client = getActiveClient();
+  client.log('community/getRecommendedCommunities.locally', query);
+
+  if (!client.cache) return;
+
+  const { limit = 5 } = query ?? {};
+
+  const queryKey = ['community', 'recommended', { params: { options: { limit } } }];
+  const { data, cachedAt } =
+    pullFromCache<{ communities: Pick<Amity.Community, 'communityId'>[] }>(queryKey) ?? {};
+
+  if (!data?.communities.length) return;
+
+  const communities: Amity.Community[] = data.communities
+    .map(communityId => pullFromCache<Amity.Community>(['community', 'get', communityId])!)
+    .filter(Boolean)
+    .map(({ data }) => data);
+
+  return communities.length === data?.communities?.length
+    ? { data: communities, cachedAt }
+    : undefined;
+};

package/src/community/api/getTopTrendingCommunities.ts

@@ -0,0 +1,87 @@
+import { getActiveClient } from '~/client/api';
+
+import { getResolver } from '~/core/model';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/**
+ * ```js
+ * import { getTopTrendingCommunities } from '@amityco/ts-sdk'
+ * const trendingCommunities = await getTopTrendingCommunities()
+ * ```
+ *
+ * Gets a list of top trending {@link Amity.Community} objects
+ *
+ * @param query The query parameters
+ * @returns A list of {@link Amity.Community} objects
+ *
+ * @category Community API
+ * @async
+ */
+export const getTopTrendingCommunities = async (
+  query?: Partial<Amity.PageLimit>,
+): Promise<Amity.Cached<Amity.Community[]>> => {
+  const client = getActiveClient();
+  client.log('channel/getTopTrendingCommunities', query);
+
+  const { limit = 5 } = query ?? {};
+
+  // API-FIX: backend doesnt answer Amity.Response
+  // const { data } = await client.http.get<Amity.Response<CommunityPayload>>(
+  const { data } = await client.http.get<Amity.CommunityPayload>(
+    `/api/v3/communities/top-trending`,
+    { params: { options: { limit } } },
+  );
+
+  const { communities } = data;
+
+  const cachedAt = client.cache && Date.now();
+
+  if (client.cache) {
+    ingestInCache(data, { cachedAt });
+
+    const cacheKey = ['community', 'top-trending', { params: { options: { limit } } }];
+    pushToCache(cacheKey, { communities: communities.map(getResolver('community')) });
+  }
+
+  return { data: communities, cachedAt };
+};
+
+/**
+ * ```js
+ * import { getTopTrendingCommunities } from '@amityco/ts-sdk'
+ * const communities = getTopTrendingCommunities.locally()
+ * ```
+ *
+ * Gets a list of top trending {@link Amity.Community} objects from cache
+ *
+ * @param query The query parameters
+ * @returns communities
+ *
+ * @category Community API
+ */
+getTopTrendingCommunities.locally = (
+  query: Parameters<typeof getTopTrendingCommunities>[0],
+): Amity.Cached<Amity.Community[]> | undefined => {
+  const client = getActiveClient();
+  client.log('community/getTopTrendingCommunities.locally', query);
+
+  if (!client.cache) return;
+
+  const { limit = 5 } = query ?? {};
+
+  const queryKey = ['community', 'top-trending', { params: { options: { limit } } }];
+  const { data, cachedAt } =
+    pullFromCache<{ communities: Pick<Amity.Community, 'communityId'>[] }>(queryKey) ?? {};
+
+  if (!data?.communities.length) return;
+
+  const communities: Amity.Community[] = data.communities
+    .map(communityId => pullFromCache<Amity.Community>(['community', 'get', communityId])!)
+    .filter(Boolean)
+    .map(({ data }) => data);
+
+  return communities.length === data?.communities?.length
+    ? { data: communities, cachedAt }
+    : undefined;
+};

package/src/community/api/index.ts

@@ -0,0 +1,19 @@
+export * from './queryCommunities';
+export * from './getCommunities';
+export * from './getCommunity';
+
+export * from './createCommunity';
+export * from './updateCommunity';
+export * from './deleteCommunity';
+
+export * from './joinCommunity';
+export * from './leaveCommunity';
+
+export * from './queryCommunityMembers';
+export * from './addCommunityMembers';
+export * from './removeCommunityMembers';
+export * from './addCommunityMembersRoles';
+export * from './removeCommunityMembersRoles';
+
+export * from './getTopTrendingCommunities';
+export * from './getRecommendedCommunities';