@amityco/ts-sdk 0.0.1-beta.14 → 0.0.1-beta.17

package/src/cache/api/snipeIdFromCollection.ts

@@ -1,9 +1,7 @@
-import { getActiveClient } from '~/client/api/activeClient'
+import { getActiveClient } from '~/client/api/activeClient';
 
 import { queryCache, mergeInCache, dropFromCache } from '.';
 
-import { decodeKey, partialMatch } from '../utils'
-
 /**
  * ```js
  * import { snipeFromCollection } from '@amityco/ts-sdk'
@@ -20,34 +18,31 @@ import { decodeKey, partialMatch } from '../utils'
  *
  * @category Cache API
  */
- export const snipeIdFromCollections = (
-  domain: Amity.Domain,
-  id: string,
-) => {
-  const { log, cache } = getActiveClient()
+export const snipeIdFromCollections = (domain: Amity.Domain, id: string) => {
+  const { log, cache } = getActiveClient();
 
-  if (!cache) return false
-  log('cache/api/snipeFromCollections', { domain, id })
+  if (!cache) return false;
+  log('cache/api/snipeFromCollections', { domain, id });
 
-  const entries = (queryCache<unknown[]>([domain, 'query']) ?? [])
-    .filter(entry => entry?.data.includes(id))
+  const entries = (queryCache<unknown[]>([domain, 'query']) ?? []).filter(entry =>
+    entry?.data.includes(id),
+  );
 
-  if (!entries.length)
-    return false
+  if (!entries.length) return false;
 
-  const toBeDeleted: Amity.CacheKey[] = []
+  const toBeDeleted: Amity.CacheKey[] = [];
 
   entries.forEach(({ key }) => {
-    mergeInCache<unknown[]>(key, (oldVal) => {
-      const newVal = oldVal.filter(itemId => itemId !== id)
+    // @ts-ignore
+    mergeInCache<unknown[]>(key, oldVal => {
+      const newVal = oldVal.filter(itemId => itemId !== id);
 
-      if (!newVal.length)
-        toBeDeleted.push(key)
+      if (!newVal.length) toBeDeleted.push(key);
 
-      return newVal
-    })
-  })
+      return newVal;
+    });
+  });
 
-  toBeDeleted.forEach(key => dropFromCache(key, true))
-  return true
+  toBeDeleted.forEach(key => dropFromCache(key, true));
+  return true;
 };

package/src/cache/api/upsertInCache.ts

@@ -1,8 +1,8 @@
-import { getActiveClient } from '~/client/api/activeClient'
+import { getActiveClient } from '~/client/api/activeClient';
 
-import { pullFromCache } from './pullFromCache'
-import { pushToCache } from './pushToCache'
-import { mergeInCache } from './mergeInCache'
+import { pullFromCache } from './pullFromCache';
+import { pushToCache } from './pushToCache';
+import { mergeInCache } from './mergeInCache';
 
 /**
  * ```js
@@ -21,19 +21,17 @@ import { mergeInCache } from './mergeInCache'
  * @category Cache API
  * @hidden
  */
- export const upsertInCache = <T extends {}>(
+export const upsertInCache = <T extends Record<string, unknown>>(
   key: Amity.CacheKey,
   data: T,
   options: Amity.CacheOptions = { cachedAt: Date.now() },
 ): boolean => {
-  const { log, cache } = getActiveClient()
+  const { log, cache } = getActiveClient();
 
-  if (!cache) return false
-  log('cache/api/upsertInCache', { key, data, options })
+  if (!cache) return false;
+  log('cache/api/upsertInCache', { key, data, options });
 
-  const cached = pullFromCache<T>(key)
+  const cached = pullFromCache<T>(key);
 
-  return cached
-    ? mergeInCache<T>(key, data, options)
-    : pushToCache(key, data, options)
-}
+  return cached ? mergeInCache<T>(key, data, options) : pushToCache(key, data, options);
+};

package/src/cache/api/wipeCache.ts

@@ -1,6 +1,6 @@
-import AsyncStorage from '@react-native-async-storage/async-storage'
+import AsyncStorage from '@react-native-async-storage/async-storage';
 
-import { getActiveClient } from '~/client/api/activeClient'
+import { getActiveClient } from '~/client/api/activeClient';
 
 /**
  * ```js
@@ -21,16 +21,14 @@ import { getActiveClient } from '~/client/api/activeClient'
  *
  * @category Cache API
  */
-export const wipeCache = async (
-  storageKey: string = 'amitySdk'
-) => {
-  const { log, cache, userId } = getActiveClient()
+export const wipeCache = async (storageKey = 'amitySdk') => {
+  const { log, cache, userId } = getActiveClient();
 
-  if (!cache) return false
-  log('cache/api/wipeCache', { storageKey })
+  if (!cache) return false;
+  log('cache/api/wipeCache', { storageKey });
 
-  cache.data = {}
-  await AsyncStorage.setItem(`${storageKey}#${userId}`, '{}')
+  cache.data = {};
+  await AsyncStorage.setItem(`${storageKey}#${userId}`, '{}');
 
-  return true
-}
+  return true;
+};

package/src/cache/utils/index.ts

@@ -8,12 +8,11 @@
  * @hidden
  */
 const normalize = (
-  source: Record<string, Amity.Serializable>
-): Record<string, Amity.Serializable> => (
+  source: Record<string, Amity.Serializable>,
+): Record<string, Amity.Serializable> =>
   Object.keys(source)
     .sort()
-    .reduce((acc, key) => ({ ...acc, [key]: source[key] }), {})
-)
+    .reduce((acc, key) => ({ ...acc, [key]: source[key] }), {});
 
 /**
  * Encodes a given {@link Amity.CacheKey} to a plain string
@@ -24,11 +23,8 @@ const normalize = (
  * @category Cache
  * @hidden
  */
-export const encodeKey = (key: Amity.CacheKey): string => (
- JSON.stringify(key, (_, val) =>
-   typeof val === "object" ? normalize(val) : val
- )
-);
+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}
@@ -42,7 +38,6 @@ export const encodeKey = (key: Amity.CacheKey): string => (
  */
 export const decodeKey = (key: string): Amity.CacheKey => JSON.parse(key);
 
-
 /**
  * Performs a recursive partial deep equal check on two objects.
  *
@@ -56,18 +51,16 @@ 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
-  else if (!predicate || !candidate) return false;
+  if (!predicate || !candidate) return false;
 
- // we only perform recursive check on objects
- else if (typeof predicate !== "object") {
-   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])
- );
-}
+  // 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
@@ -77,8 +70,5 @@ export const partialMatch = (predicate: any, candidate: any): boolean => {
  *
  * @category Cache
  */
-export const isCached = <T extends unknown>(
-  obj?: any
-): obj is Amity.Cached<T> => (
-  ['data', 'cachedAt'].every(prop => obj?.hasOwnProperty(prop))
-)
+export const isCached = <T extends unknown>(obj?: any): obj is Amity.Cached<T> =>
+  ['data', 'cachedAt'].every(prop => obj?.hasOwnProperty(prop));

package/src/category/api/getCategory.ts

@@ -1,11 +1,12 @@
-import { getActiveClient } from '~/client/api/activeClient'
+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
@@ -17,18 +18,53 @@ import { getActiveClient } from '~/client/api/activeClient'
  * @async
  */
 export const getCategory = async (
-  categoryId: Amity.Category['categoryId']
-) => {
-  const client = getActiveClient()
-  client.log('category/getCategory', categoryId)
+  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]
-}
+  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

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

package/src/category/api/queryCategories.ts

@@ -1,12 +1,15 @@
-import { getActiveClient } from '~/client/api/activeClient'
+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,35 +17,93 @@ 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
-}) => {
-  const client = getActiveClient()
-  client.log('category/queryCategories', 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`, { params : {
-      ...params,
-      options: {
-        token: toToken(page, 'skiplimit')
-      }
-    } })
+    `/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,
+    ) ?? {};
 
-  const { paging, ...response } = data
+  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

@@ -1,7 +1,7 @@
-import { getActiveClient } from '~/client/api'
+import { getActiveClient } from '~/client/api';
 
-import { ingestInCache } from '~/cache/api/ingestInCache'
-import { fireEvent } from '~/core/events'
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { fireEvent } from '~/core/events';
 
 /**
  * ```js
@@ -20,25 +20,24 @@ import { fireEvent } from '~/core/events'
  */
 export const addChannelMembers = async (
   channelId: Amity.Channel['channelId'],
-  userIds: Amity.User['userId'][]
+  userIds: Amity.User['userId'][],
 ): Promise<boolean> => {
-  const client = getActiveClient()
-  client.log('channel/addChannelMembers', channelId, userIds)
+  const client = getActiveClient();
+  client.log('channel/addChannelMembers', channelId, userIds);
 
   const { data } = await client.http.post<Amity.ChannelMembershipPayload>(
     `/api/v3/channels/${encodeURIComponent(channelId)}/users`,
-    { channelId, userIds }
-  )
+    { channelId, userIds },
+  );
 
-  if (client.cache) ingestInCache(data)
+  if (client.cache) ingestInCache(data);
 
   fireEvent('v3.channel.didAddUsers', {
     channels: data.channels!,
-  })
+  });
 
-  const { channelUsers } = data
+  const { channelUsers } = data;
   return !!channelUsers.find(
-    channelUser =>
-      channelUser.channelId === channelId && channelUser.membership === 'member'
-  )
-}
+    channelUser => channelUser.channelId === channelId && channelUser.membership === 'member',
+  );
+};

package/src/channel/api/addChannelMembersRole.ts

@@ -1,6 +1,6 @@
-import { getActiveClient } from '~/client/api'
+import { getActiveClient } from '~/client/api';
 
-import { ingestInCache } from '~/cache/api/ingestInCache'
+import { ingestInCache } from '~/cache/api/ingestInCache';
 
 /**
  * ```js
@@ -21,21 +21,20 @@ import { ingestInCache } from '~/cache/api/ingestInCache'
 export const addChannelMembersRole = async (
   channelId: Amity.Channel['channelId'],
   roleId: Amity.Role['roleId'],
-  userIds: Amity.User['userId'][]
+  userIds: Amity.User['userId'][],
 ): Promise<boolean> => {
-  const client = getActiveClient()
-  client.log('channel/addChannelMembersRole', channelId, roleId, userIds)
+  const client = getActiveClient();
+  client.log('channel/addChannelMembersRole', channelId, roleId, userIds);
 
   const { data } = await client.http.post<Amity.ChannelMembershipPayload>(
     `/api/v3/channels/${encodeURIComponent(channelId)}/users/roles`,
-    { channelId, role: roleId, userIds }
-  )
+    { channelId, role: roleId, userIds },
+  );
 
-  if (client.cache) ingestInCache(data)
+  if (client.cache) ingestInCache(data);
 
-  const { channelUsers } = data
+  const { channelUsers } = data;
   return !!channelUsers.find(
-    channelUser =>
-      channelUser.channelId === channelId && channelUser.roles.includes(roleId)
-  )
-}
+    channelUser => channelUser.channelId === channelId && channelUser.roles.includes(roleId),
+  );
+};

package/src/channel/api/createChannel.ts

@@ -1,6 +1,6 @@
-import { getActiveClient } from '~/client/api'
+import { getActiveClient } from '~/client/api';
 
-import { ingestInCache } from '~/cache/api/ingestInCache'
+import { ingestInCache } from '~/cache/api/ingestInCache';
 
 /**
  * ```js
@@ -17,26 +17,31 @@ import { ingestInCache } from '~/cache/api/ingestInCache'
  * @async
  */
 export const createChannel = async <T extends Amity.ChannelType>(
-  bundle: { type: T, userIds?: Amity.User['userId'] }
-  & Pick<Amity.Channel<T>, 'displayName' | 'avatarFileId' | 'tags' | 'metadata'>
+  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)
+  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 })
+    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)
+    payload = await client.http.post<Amity.ChannelPayload>('/api/v3/channels', bundle);
   }
 
-  const cachedAt = client.cache && Date.now()
-  if (client.cache) ingestInCache(payload.data, { cachedAt })
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(payload.data, { cachedAt });
 
-  const { channels } = payload.data
+  const { channels } = payload.data;
   return {
     data: channels[0],
     cachedAt,
-  }
-}
+  };
+};

package/src/channel/api/deleteChannel.ts

@@ -1,6 +1,6 @@
-import { getActiveClient } from '~/client/api'
+import { getActiveClient } from '~/client/api';
 
-import { getChannel } from './getChannel'
+import { getChannel } from './getChannel';
 
 /**
  * ```js
@@ -19,16 +19,16 @@ import { getChannel } from './getChannel'
 export const deleteChannel = async (
   channelId: Amity.Channel['channelId'],
 ): Promise<Amity.Channel> => {
-  const client = getActiveClient()
-  client.log('channel/deleteChannel', channelId)
+  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)}`
-  )
+    `/api/v3/channels/${encodeURIComponent(channelId)}`,
+  );
 
-  const deleted = await getChannel(channelId)
+  const deleted = await getChannel(channelId);
   // no need for event, fired by server
 
-  return deleted.data
-}
+  return deleted.data;
+};