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

package/src/community/api/getRecommendedCommunities.ts

@@ -0,0 +1,90 @@
+import { getActiveClient } from '~/client/api';
+
+import { getResolver } from '~/core/model';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+import { unpackCommunityPayload } from '../utils';
+
+/**
+ * ```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: payload } = await client.http.get<Amity.Response<CommunityPayload>>(
+  const { data: payload } = await client.http.get<Amity.CommunityPayload>(
+    `/api/v3/communities/recommended`,
+    { params: { options: { limit } } },
+  );
+
+  const data = unpackCommunityPayload(payload);
+  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,90 @@
+import { getActiveClient } from '~/client/api';
+
+import { getResolver } from '~/core/model';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+import { unpackCommunityPayload } from '../utils';
+
+/**
+ * ```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: payload } = await client.http.get<Amity.CommunityPayload>(
+    `/api/v3/communities/top-trending`,
+    { params: { options: { limit } } },
+  );
+
+  const data = unpackCommunityPayload(payload);
+  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';

package/src/community/api/joinCommunity.ts

@@ -0,0 +1,41 @@
+import { getActiveClient } from '~/client/api';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { fireEvent } from '~/core/events';
+
+/**
+ * ```js
+ * import { joinCommunity } from '@amityco/ts-sdk'
+ * const isJoined = await joinCommunity('foobar')
+ * ```
+ *
+ * Joins a {@link Amity.Community} object
+ *
+ * @param communityId the {@link Amity.Community} to join
+ * @returns A success boolean if the {@link Amity.Community} was joined
+ *
+ * @category Community API
+ * @async
+ */
+export const joinCommunity = async (
+  communityId: Amity.Community['communityId'],
+): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('community/joinCommunity', communityId);
+
+  const { data } = await client.http.post<Amity.CommunityMembershipPayload>(
+    `/api/v3/communities/${communityId}/join`,
+  );
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  fireEvent('community.joined', data);
+
+  const { communityUsers } = data;
+
+  return !!communityUsers.find(
+    communityUser =>
+      communityUser.communityId === communityId && communityUser.communityMembership === 'member',
+  );
+};

package/src/community/api/leaveCommunity.ts

@@ -0,0 +1,41 @@
+import { getActiveClient } from '~/client/api';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { fireEvent } from '~/core/events';
+
+/**
+ * ```js
+ * import { leaveCommunity } from '@amityco/ts-sdk'
+ * const isLeft = await leaveCommunity('foobar')
+ * ```
+ *
+ * Leaves a {@link Amity.Community} object
+ *
+ * @param communityId the {@link Amity.Community} to leave
+ * @returns A success boolean if {@link Amity.Community} was left
+ *
+ * @category Community API
+ * @async
+ */
+export const leaveCommunity = async (
+  communityId: Amity.Community['communityId'],
+): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('community/leaveCommunity', communityId);
+
+  const { data } = await client.http.delete<Amity.CommunityMembershipPayload>(
+    `/api/v3/communities/${communityId}/leave`,
+  );
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  fireEvent('community.left', data);
+
+  const { communityUsers } = data;
+
+  return !!communityUsers.find(
+    communityUser =>
+      communityUser.communityId === communityId && communityUser.communityMembership !== 'member',
+  );
+};

package/src/community/api/queryCommunities.ts

@@ -0,0 +1,99 @@
+import { getActiveClient } from '~/client/api';
+
+import { toPage, toToken } from '~/core/query';
+import { pushToCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { getResolver } from '~/core/model';
+
+import { unpackCommunityPayload } from '../utils';
+
+/**
+ * ```js
+ * import { queryCommunities } from '@amityco/ts-sdk'
+ * const communities = await queryCommunities()
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.Community} objects
+ * Search is performed by displayName such as `.startsWith(search)`
+ *
+ * @param query The query parameters
+ * @returns A page of {@link Amity.Community} objects
+ *
+ * @category Community API
+ * @async
+ */
+export const queryCommunities = async (query?: {
+  displayName?: string;
+  membership?: 'all' | 'member' | 'notMember';
+  categoryId?: Amity.Category['categoryId'];
+  isDeleted?: Amity.Community['isDeleted'];
+  hasFlag?: boolean;
+  tags?: Amity.Taggable['tags'];
+  sortBy?: 'displayName' | 'firstCreated' | 'lastCreated';
+  page?: Amity.Page;
+}): Promise<Amity.Cached<Amity.Paged<Amity.Community>>> => {
+  const client = getActiveClient();
+  client.log('channel/queryCommunities', query);
+
+  // safe decapsulation
+  const { page, displayName, membership, ...params } = query ?? {};
+
+  // API-FIX: parameters should be querystring.
+  // API-FIX: backend doesnt answer Amity.Response
+  // const { data } = await client.http.get<Amity.Response<Amity.PagedResponse<CommunityPayload>>>(
+  const { data } = await client.http.get<Amity.CommunityPayload & Amity.Pagination>(
+    `/api/v3/communities`,
+    {
+      params: {
+        ...params,
+        keyword: displayName,
+        filter: membership,
+        options: {
+          token: toToken(page, 'skiplimit'),
+        },
+      },
+    },
+  );
+
+  const { paging, ...payload } = data;
+  const unpackedPayload = unpackCommunityPayload(payload);
+  const { communities } = unpackedPayload;
+
+  const cachedAt = client.cache && Date.now();
+
+  if (client.cache) {
+    ingestInCache(unpackedPayload as Amity.CommunityPayload, { cachedAt });
+
+    const cacheKey = [
+      'community',
+      'query',
+      { ...params, options: { ...page } } as Amity.Serializable,
+    ];
+    pushToCache(cacheKey, { communities: communities.map(getResolver('community')), paging });
+  }
+
+  const nextPage = toPage(paging.next);
+  const prevPage = toPage(paging.previous);
+
+  return { data: communities, cachedAt, prevPage, nextPage };
+};
+
+/**
+ * ```js
+ * import { queryCommunities } from '@amityco/ts-sdk'
+ * const communities = queryCommunities.locally()
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.Community} objects from cache
+ *
+ * @param query The query parameters
+ * @returns communities
+ *
+ * @category Community API
+ */
+queryCommunities.locally = (query: Parameters<typeof queryCommunities>[0]) => {
+  const client = getActiveClient();
+  client.log('community/queryCommunities.locally', query);
+
+  // TODO
+};

package/src/community/api/queryCommunityMembers.ts

@@ -0,0 +1,76 @@
+import { getActiveClient } from '~/client/api';
+
+import { toPage, toToken } from '~/core/query';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/**
+ * ```js
+ * import { queryCommunityMembers } from '@amityco/ts-sdk'
+ * const communityMembers = await queryCommunityMembers({ communityId: 'foo' })
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.CommunityUser} objects
+ *
+ * @param query The query parameters
+ * @returns A page of {@link Amity.CommunityUser} objects
+ *
+ * @category Community API
+ * @async
+ * */
+export const queryCommunityMembers = async (query: {
+  communityId: string;
+  membership?: ('banned' | 'member')[];
+  roles?: string[];
+  sortBy?: 'firstCreated' | 'lastCreated';
+  page?: Amity.Page;
+}): Promise<Amity.Cached<Amity.Paged<Amity.Membership<'community'>>>> => {
+  const client = getActiveClient();
+  client.log('community/queryCommunityMembers', query);
+
+  const { page, communityId, ...params } = query ?? {};
+
+  const { data } = await client.http.get<Amity.CommunityMembershipPayload & Amity.Pagination>(
+    `/api/v3/communities/${communityId}/users`,
+    {
+      params: {
+        ...params,
+        options: {
+          token: toToken(page, 'skiplimit'),
+        },
+      },
+    },
+  );
+
+  const { paging, ...payload } = data;
+  const { communityUsers } = payload;
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) {
+    ingestInCache(payload as Amity.CommunityMembershipPayload, { cachedAt });
+  }
+
+  const nextPage = toPage(paging.next);
+  const prevPage = toPage(paging.previous);
+
+  return { data: communityUsers, cachedAt, nextPage, prevPage };
+};
+
+/**
+ * ```js
+ * import { queryCommunityMembers } from '@amityco/ts-sdk'
+ * const communityMembers = await queryCommunityMembers(query)
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.Post} objects from cache
+ *
+ * @param query The query parameters
+ * @returns posts
+ *
+ * @category Post API
+ */
+queryCommunityMembers.locally = (query: Parameters<typeof queryCommunityMembers>[0]) => {
+  const client = getActiveClient();
+  client.log('community/queryCommunityMembers', query);
+
+  // TODO
+};

package/src/community/api/removeCommunityMembers.ts

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

package/src/community/api/removeCommunityMembersRoles.ts

@@ -0,0 +1,42 @@
+import { getActiveClient } from '~/client/api';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/**
+ * ```js
+ * import { removeCommunityMembersRoles } from '@amityco/ts-sdk'
+ * const updated = await removeCommunityMembersRoles(communityId,  ['foo'], ['bar'])
+ * ```
+ *
+ * Removes a list of {@link Amity.Role} from 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 removed from list of {@link Amity.User} in the {@link Amity.Community}
+ *
+ * @category Community API
+ * @async
+ */
+export const removeCommunityMembersRoles = async (
+  communityId: Amity.Community['communityId'],
+  roleIds: Amity.Role['roleId'][],
+  userIds: Amity.User['userId'][],
+): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('community/removeCommunityMembersRoles', communityId, roleIds, userIds);
+
+  const { data } = await client.http.delete<Amity.CommunityMembershipPayload>(
+    `/api/v4/communities/${communityId}/users/roles`,
+    { data: { 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/updateCommunity.ts

@@ -0,0 +1,51 @@
+import { getActiveClient } from '~/client/api';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { fireEvent } from '~/core/events';
+
+import { packCommunityPayload, unpackCommunityPayload } from '../utils';
+
+/**
+ * ```js
+ * import { updateCommunity } from '@amityco/ts-sdk'
+ * const updated = await updateCommunity(communityId, { displayName: 'foobar' })
+ * ```
+ *
+ * Updates an {@link Amity.Community}
+ *
+ * @param communityId The ID of the {@link Amity.Community} to edit
+ * @param patch The patch data to apply
+ * @returns the updated {@link Amity.Community} object
+ *
+ * @category Community API
+ * @async
+ */
+export const updateCommunity = async (
+  communityId: Amity.Community['communityId'],
+  patch: Patch<
+    Amity.Community,
+    'displayName' | 'description' | 'avatarFileId' | 'postSetting' | 'tags' | 'metadata'
+  >,
+): Promise<Amity.Cached<Amity.Community>> => {
+  const client = getActiveClient();
+  client.log('community/updateCommunity', communityId, patch);
+
+  const { data: payload } = await client.http.put<Amity.CommunityPayload>(
+    `/api/v3/communities/${communityId}`,
+    packCommunityPayload(patch),
+  );
+
+  const data = unpackCommunityPayload(payload);
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  fireEvent('community.updated', data);
+
+  const { communities } = data;
+
+  return {
+    data: communities.find(community => community.communityId === communityId)!,
+    cachedAt,
+  };
+};

package/src/community/events/index.ts

@@ -0,0 +1,11 @@
+export * from './onCommunityCreated';
+export * from './onCommunityUpdated';
+export * from './onCommunityDeleted';
+
+export * from './onCommunityJoined';
+export * from './onCommunityLeft';
+
+export * from './onCommunityUserAdded';
+export * from './onCommunityUserRemoved';
+export * from './onCommunityUserBanned';
+export * from './onCommunityUserUnbanned';

package/src/community/events/onCommunityCreated.ts

@@ -0,0 +1,19 @@
+import { createCommunityEventSubscriber } from './utils';
+
+/**
+ * ```js
+ * import { onCommunityCreated } from '@amityco/ts-sdk'
+ * const dispose = onCommunityCreated(community => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.Community} have been created
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Community Events
+ */
+export const onCommunityCreated = (callback: Amity.Listener<Amity.Community>) =>
+  createCommunityEventSubscriber('community.created', callback);

package/src/community/events/onCommunityDeleted.ts

@@ -0,0 +1,19 @@
+import { createCommunityEventSubscriber } from './utils';
+
+/**
+ * ```js
+ * import { onCommunityDeleted } from '@amityco/ts-sdk'
+ * const dispose = onCommunityDeleted(community => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.Community} has been deleted
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Community Events
+ */
+export const onCommunityDeleted = (callback: Amity.Listener<Amity.Community>) =>
+  createCommunityEventSubscriber('community.deleted', callback);

package/src/community/events/onCommunityJoined.ts

@@ -0,0 +1,20 @@
+import { createCommunityMemberEventSubscriber } from './utils';
+
+/**
+ * ```js
+ * import { onCommunityJoined } from '@amityco/ts-sdk'
+ * const dispose = onCommunityJoined((community, member) => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.Community} has been joined
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Community Events
+ */
+export const onCommunityJoined = (
+  callback: (community: Amity.Community, member: Amity.Membership<'community'>) => void,
+) => createCommunityMemberEventSubscriber('community.joined', callback);