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

package/src/cache/api/wipeCache.ts

@@ -0,0 +1,34 @@
+import AsyncStorage from '@react-native-async-storage/async-storage';
+
+import { getActiveClient } from '~/client/api/activeClient';
+
+/**
+ * ```js
+ * import { wipeCache } from '@amityco/ts-sdk'
+ * const success = await wipeCache()
+ * ```
+ *
+ * Wipes a persistent storage for the current {@link Amity.Cache} instance.
+ *
+ * The strategy for persistent storage will depend on the runtime,
+ * which is supported by @react-native-async-storage/async-storage.
+ *
+ * The current userId will be appended to the given storageKey to avoid
+ * collision between multiple client instances over time.
+ *
+ * @param storageKey the name of the persistent storage
+ * @returns a success boolean if the persistent cache was wiped.
+ *
+ * @category Cache API
+ */
+export const wipeCache = async (storageKey = 'amitySdk') => {
+  const { log, cache, userId } = getActiveClient();
+
+  if (!cache) return false;
+  log('cache/api/wipeCache', { storageKey });
+
+  cache.data = {};
+  await AsyncStorage.setItem(`${storageKey}#${userId}`, '{}');
+
+  return true;
+};

package/src/cache/utils/index.ts

@@ -0,0 +1,96 @@
+// cache constants
+export const CACHE_KEY_GET = 'get';
+export const CACHE_KEY_QUERY = 'query';
+export const CACHE_KEY_TOMBSTONE = 'dead';
+export const CACHE_KEY_COLLECTION = 'collection';
+
+export const CACHE_LIFESPAN = 1 * 60 * 1000; // 1 minute
+export const CACHE_LIFESPAN_TOMBSTONE = 3 * 60 * 1000; // 3 minutes
+
+/**
+ * Shallow-clones an object and sort its keys
+ *
+ * @param source a plain object to clone
+ * @returns a clone of source, with keys sorted with default javascript sorting
+ *
+ * @category Cache
+ * @hidden
+ */
+const normalize = (
+  source: Record<string, Amity.Serializable>,
+): Record<string, Amity.Serializable> =>
+  Object.keys(source)
+    .sort()
+    .reduce((acc, key) => ({ ...acc, [key]: source[key] }), {});
+
+/**
+ * Encodes a given {@link Amity.CacheKey} to a plain string
+ *
+ * @param key the key to encode
+ * @returns an encoded string
+ *
+ * @category Cache
+ * @hidden
+ */
+export const encodeKey = (key: Amity.CacheKey): string =>
+  JSON.stringify(key, (_, val) => (typeof val === 'object' ? normalize(val) : val));
+
+/**
+ * Decodes a string back into a {@link Amity.CacheKey}
+
+ *
+ * @param key the string key to decode
+ * @returns a plain Amity.CacheKey object.
+ *
+ * @category Cache
+ * @hidden
+ */
+export const decodeKey = (key: string): Amity.CacheKey => JSON.parse(key);
+
+/**
+ * Performs a recursive partial deep equal check on two objects.
+ *
+ * @param predicate the reference object containing the partial information
+ * @param candidate the object to check against
+ * @returns true if the candidate contains all the values of the predicate
+ *
+ * @category Cache
+ */
+export const partialMatch = (predicate: any, candidate: any): boolean => {
+  if (predicate === candidate) return true;
+
+  // if one or the other is nullish, there can't be equality
+  if (!predicate || !candidate) return false;
+
+  // we only perform recursive check on objects
+  if (typeof predicate !== 'object') {
+    return false;
+  }
+
+  // recursively call for partial match based on the predicate
+  return Object.keys(predicate).every(key => partialMatch(predicate[key], candidate[key]));
+};
+
+/**
+ * Type guard to check and cast that a given predicate matched {@link Amity.Cached} shape
+ *
+ * @param obj any {@link Amity.Cached}-like object
+ * @returns success boolean if the given object is of {@link Amity.Cached} shape
+ *
+ * @category Cache
+ */
+export const isCached = <T extends unknown>(obj?: any): obj is Amity.Cached<T> =>
+  ['data', 'cachedAt'].every(prop => obj?.hasOwnProperty(prop));
+
+/**
+ * checks if passed error code is included in
+ * Tombstone errors list
+ *
+ * @param errorCode as {@link Amity.ServerError}
+ * @returns success boolean if the given errorCode
+ * is included in Tombstone errors list
+ *
+ * @category Cache
+ */
+export const checkIfShouldGoesToTombstone = (errorCode: Amity.ServerError): boolean =>
+  [Amity.ServerError.ITEM_NOT_FOUND, Amity.ServerError.FORBIDDEN].includes(errorCode);

package/src/category/api/getCategory.ts

@@ -0,0 +1,70 @@
+import { getActiveClient } from '~/client/api/activeClient';
+
+import { pullFromCache, dropFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/**
+ * ```js
+ * import { getCategory } from '@amityco/ts-sdk'
+ * const { data: category } = await getCategory('foo')
+ * ```
+ *
+ * Fetches a {@link Amity.Category} object
+ *
+ * @param categoryId the ID of the {@link Amity.Category} to fetch
+ * @returns the associated {@link Amity.Category} object
+ *
+ * @category Category API
+ * @async
+ */
+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/${encodeURIComponent(categoryId)}`,
+  );
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  const { categories } = data;
+
+  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/index.ts

@@ -0,0 +1,2 @@
+export * from './queryCategories';
+export * from './getCategory';

package/src/category/api/queryCategories.ts

@@ -0,0 +1,109 @@
+import { getActiveClient } from '~/client/api/activeClient';
+
+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 { data: categories, prevPage, nextPage } = await queryCategories()
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.Category} objects
+ *
+ * @param query The query parameters
+ * @returns A page of {@link Amity.Category} objects
+ *
+ * @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 = { limit: 10 }, ...params } = query ?? {};
+
+  const { data } = await client.http.get<Amity.CategoryPayload & Amity.Pagination>(
+    `/api/v3/community-categories`,
+    {
+      params: {
+        ...params,
+        options: {
+          token: toToken(page, 'skiplimit'),
+        },
+      },
+    },
+  );
+
+  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;
+
+  const categories: Amity.Category[] = data.categories
+    .map(categoryId => pullFromCache<Amity.Category>(['category', 'get', categoryId])!)
+    .filter(Boolean)
+    .map(({ data }) => data);
+
+  const prevPage = toPage(data?.paging.previous);
+  const nextPage = toPage(data?.paging.next);
+
+  return categories.length === data?.categories?.length
+    ? { data: categories, cachedAt, prevPage, nextPage }
+    : undefined;
+};

package/src/channel/api/addChannelMembers.ts

@@ -0,0 +1,53 @@
+import { getActiveClient } from '~/client/api';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { fireEvent } from '~/core/events';
+
+import { prepareChannelPayload } from '../utils';
+
+/**
+ * ```js
+ * import { addChannelMembers } from '@amityco/ts-sdk'
+ * const updated = await addChannelMembers(channelId, ['foo', 'bar'])
+ * ```
+ *
+ * Adds a list of {@link Amity.User} to a {@link Amity.Channel}
+ *
+ * @param channelId The ID of the {@link Amity.Channel} 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.Channel}
+ *
+ * @category Channel API
+ * @async
+ */
+export const addChannelMembers = async (
+  channelId: Amity.Channel['channelId'],
+  userIds: Amity.User['userId'][],
+): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('channel/addChannelMembers', channelId, userIds);
+
+  const { data: payload } = await client.http.post<Amity.ChannelMembershipPayload>(
+    `/api/v3/channels/${encodeURIComponent(channelId)}/users`,
+    { channelId, userIds },
+  );
+
+  const data = prepareChannelPayload(payload);
+
+  if (client.cache) ingestInCache(data);
+
+  /*
+   * should fire event for each user that was added
+   */
+  userIds.forEach(id =>
+    fireEvent('channel.membersAdded', {
+      ...data,
+      channelUsers: data.channelUsers.filter(u => u.userId === id),
+    }),
+  );
+
+  const { channelUsers } = data;
+  return !!channelUsers.find(
+    channelUser => channelUser.channelId === channelId && channelUser.membership === 'member',
+  );
+};

package/src/channel/api/addChannelMembersRole.ts

@@ -0,0 +1,44 @@
+import { getActiveClient } from '~/client/api';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+import { prepareChannelPayload } from '../utils';
+
+/**
+ * ```js
+ * import { addChannelMembersRole } from '@amityco/ts-sdk'
+ * const updated = await addChannelMembersRole(channelId, 'foo', ['bar'])
+ * ```
+ *
+ * Adds an {@link Amity.Role} to a list of {@link Amity.User} on a {@link Amity.Channel}
+ *
+ * @param channelId The ID of the {@link Amity.Channel} to perform
+ * @param roleId The ID 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.Channel}
+ *
+ * @category Channel API
+ * @async
+ */
+export const addChannelMembersRole = async (
+  channelId: Amity.Channel['channelId'],
+  roleId: Amity.Role['roleId'],
+  userIds: Amity.User['userId'][],
+): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('channel/addChannelMembersRole', channelId, roleId, userIds);
+
+  const { data: payload } = await client.http.post<Amity.ChannelMembershipPayload>(
+    `/api/v3/channels/${encodeURIComponent(channelId)}/users/roles`,
+    { channelId, role: roleId, userIds },
+  );
+
+  const data = prepareChannelPayload(payload);
+
+  if (client.cache) ingestInCache(data);
+
+  const { channelUsers } = data;
+  return !!channelUsers.find(
+    channelUser => channelUser.channelId === channelId && channelUser.roles.includes(roleId),
+  );
+};

package/src/channel/api/banChannelMembers.ts

@@ -0,0 +1,45 @@
+import { getActiveClient } from '~/client/api/activeClient';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+import { prepareChannelPayload } from '../utils';
+
+/**
+ * ```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 { data: payload } = await client.http.put<Amity.ChannelPayload>(
+    `/api/v3/channels/${channelId}/users/ban`,
+    {
+      userIds,
+    },
+  );
+
+  const data = prepareChannelPayload(payload);
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  const { channelUsers } = data;
+  return {
+    data: channelUsers?.filter(user => user.membership === 'banned')!,
+    cachedAt,
+  };
+};

package/src/channel/api/createChannel.ts

@@ -0,0 +1,51 @@
+import { getActiveClient } from '~/client/api';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+import { prepareChannelPayload } from '../utils';
+
+/**
+ * ```js
+ * import { createChannel } from '@amityco/ts-sdk'
+ * const created = await createChannel({ channelId: 'foobar', displayName: 'foobar' })
+ * ```
+ *
+ * Creates an {@link Amity.Channel}
+ *
+ * @param bundle The data necessary to create a new {@link Amity.Channel}
+ * @returns The newly created {@link Amity.Channel}
+ *
+ * @category Channel API
+ * @async
+ */
+export const createChannel = async <T extends Amity.ChannelType>(
+  bundle: { type: T; userIds?: Amity.User['userId'][] } & Pick<
+    Amity.Channel<T>,
+    'displayName' | 'avatarFileId' | 'tags' | 'metadata'
+  >,
+): Promise<Amity.Cached<Amity.Channel>> => {
+  const client = getActiveClient();
+  client.log('user/createChannel', bundle);
+
+  let payload;
+
+  if (bundle?.type === 'conversation') {
+    payload = await client.http.post<Amity.ChannelPayload>('/api/v3/channels/conversation', {
+      ...bundle,
+      isDistinct: true,
+    });
+  } else {
+    payload = await client.http.post<Amity.ChannelPayload>('/api/v3/channels', bundle);
+  }
+
+  const data = prepareChannelPayload(payload.data);
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  const { channels } = data;
+  return {
+    data: channels[0],
+    cachedAt,
+  };
+};

package/src/channel/api/deleteChannel.ts

@@ -0,0 +1,33 @@
+import { getActiveClient } from '~/client/api';
+
+import { getChannel } from './getChannel';
+
+/**
+ * ```js
+ * import { deleteChannel } from '@amityco/ts-sdk'
+ * const success = await deleteChannel('foobar')
+ * ```
+ *
+ * Deletes a {@link Amity.Channel}
+ *
+ * @param channelId The {@link Amity.Channel} ID to delete
+ * @return A success boolean if the {@link Amity.Channel} was deleted
+ *
+ * @category Channel API
+ * @async
+ */
+export const deleteChannel = async (
+  channelId: Amity.Channel['channelId'],
+): Promise<Amity.Channel> => {
+  const client = getActiveClient();
+  client.log('channel/deleteChannel', channelId);
+
+  await client.http.delete<{ success: boolean }>(
+    `/api/v3/channels/${encodeURIComponent(channelId)}`,
+  );
+
+  const deleted = await getChannel(channelId);
+  // no need for event, fired by server
+
+  return deleted.data;
+};

package/src/channel/api/getChannel.ts

@@ -0,0 +1,90 @@
+import { getActiveClient } from '~/client/api';
+
+import { pullFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+import { isInTombstone } from '~/cache/api/isInTombstone';
+import { checkIfShouldGoesToTombstone } from '~/cache/utils';
+import { pushToTombstone } from '~/cache/api/pushToTombstone';
+
+import { prepareChannelPayload } from '../utils';
+
+/**
+ * ```js
+ * import { getChannel } from '@amityco/ts-sdk'
+ * const channel = await getChannel('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.Channel} object
+ *
+ * @param channelId the ID of the {@link Amity.Channel} to fetch
+ * @returns the associated {@link Amity.Channel} object
+ *
+ * @category Channel API
+ * @async
+ */
+export const getChannel = async (
+  channelId: Amity.Channel['channelId'],
+): Promise<Amity.Cached<Amity.Channel>> => {
+  const client = getActiveClient();
+  client.log('channel/getChannel', channelId);
+
+  isInTombstone('channel', channelId);
+
+  let data: Amity.ChannelPayload<any, Amity.Channel>;
+
+  try {
+    const { data: payload } = await client.http.get<Amity.ChannelPayload>(
+      `/api/v3/channels/${encodeURIComponent(channelId)}`,
+    );
+
+    data = prepareChannelPayload(payload);
+  } catch (error) {
+    if (checkIfShouldGoesToTombstone((error as Amity.ErrorResponse)?.code)) {
+      pushToTombstone('channel', channelId);
+    }
+
+    throw error;
+  }
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  const { channels } = data;
+
+  return {
+    data: channels.find(channel => channel.channelId === channelId)!,
+    cachedAt,
+  };
+};
+
+/**
+ * ```js
+ * import { getChannel } from '@amityco/ts-sdk'
+ * const channel = getChannel.locally('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.Channel} object from cache
+ *
+ * @param channelId the ID of the {@link Amity.Channel} to fetch
+ * @returns the associated {@link Amity.Channel} object
+ *
+ * @category Channel API
+ */
+getChannel.locally = (
+  channelId: Amity.Channel['channelId'],
+): Amity.Cached<Amity.Channel> | undefined => {
+  const client = getActiveClient();
+  client.log('channel/getChannel.locally', channelId);
+
+  if (!client.cache) return;
+
+  const cached = pullFromCache<Amity.Channel>(['channel', 'get', channelId]);
+
+  if (!cached) return;
+
+  return {
+    data: cached.data,
+    cachedAt: cached.cachedAt,
+  };
+};