@amityco/ts-sdk 0.0.1-beta.16 → 0.0.1-beta.19

package/src/core/model/idResolvers.ts

@@ -4,9 +4,9 @@
  * to avoid using any and give some typing security at the
  * resolver's level.
  */
- type Resolvers<T extends Amity.Domain[] = Amity.Domain[]> = {
-  [K in T[number]]: (model: Amity.Minimal[K]) => string
-}
+type Resolvers<T extends Amity.Domain[] = Amity.Domain[]> = {
+  [K in T[number]]: (model: Amity.Minimal[K]) => string;
+};
 
 /** @hidden */
 const idResolvers: Resolvers = {
@@ -19,15 +19,17 @@ const idResolvers: Resolvers = {
   message: ({ messageId }) => messageId,
 
   community: ({ communityId }) => communityId,
+  category: ({ categoryId }) => categoryId,
   communityUsers: ({ communityId, userId }) => `${communityId}#${userId}`,
   post: ({ postId }) => postId,
   comment: ({ commentId }) => commentId,
+  poll: ({ pollId }) => pollId,
 
   stream: ({ streamId }) => streamId,
 
   follow: ({ from, to }) => `${from}#${to}`,
   followCount: ({ userId }) => userId,
-}
+};
 
 /**
  * Retrieve the id resolver matching a domain name
@@ -35,6 +37,4 @@ const idResolvers: Resolvers = {
  * @param name the domain name for the resolve
  * @returns an idResolver function for the given domain name
  */
- export const getResolver = <T extends Amity.Domain>(name: T) => (
-  idResolvers[name]
-)
+export const getResolver = <T extends Amity.Domain>(name: T) => idResolvers[name];

package/src/core/model/identifyModel.ts

@@ -5,9 +5,9 @@
  * adding new models.
  * @hidden
  */
- type Criterias<T extends Amity.Domain[] = Amity.Domain[]> = {
-  [K in T[number]]: (keyof Amity.Model[K])[]
-}
+type Criterias<T extends Amity.Domain[] = Amity.Domain[]> = {
+  [K in T[number]]: (keyof Amity.Model[K])[];
+};
 
 /**
  * Identification criterias
@@ -19,7 +19,7 @@
  *
  * @hidden
  */
-const CRITERIAS: Criterias  = {
+const CRITERIAS: Criterias = {
   file: ['fileId', 'attributes'],
   user: ['userId', 'avatarFileId'],
   role: ['roleId'],
@@ -27,19 +27,21 @@ const CRITERIAS: Criterias  = {
   channelUsers: ['channelId', 'userId', 'membership'],
   message: ['messageId'],
   community: ['communityId', 'onlyAdminCanPost'],
+  category: ['categoryId'],
   communityUsers: ['userId', 'communityId', 'communityMembership'],
   post: ['postId', 'feedId'],
   comment: ['commentId', 'referenceId'],
+  poll: ['pollId'],
   stream: ['streamId'],
   follow: ['from', 'to'],
-  followCount: ['userId', 'followerCount']
-}
+  followCount: ['userId', 'followerCount'],
+};
 
 /** @hidden */
 const hasKeys = (object: Record<string, unknown>, needles: string[]) => {
-  const haystack = Object.keys(object)
-  return needles.every(needle => haystack.includes(needle))
-}
+  const haystack = Object.keys(object);
+  return needles.every(needle => haystack.includes(needle));
+};
 
 /**
  * Finds the name of the store for a given unknown model
@@ -50,6 +52,7 @@ const hasKeys = (object: Record<string, unknown>, needles: string[]) => {
 export const identifyModel = (model: Record<string, unknown>) => {
   // we cannot avoid "as" in here because Object.entries does not
   // allow anything else than "string" as key in the iterator type
-  const criterias = Object.entries(CRITERIAS) as [Amity.Domain, string[]][]
-  return criterias.find(([_, keys]) => hasKeys(model, keys))?.[0]
-}
+  const criterias = Object.entries(CRITERIAS) as [Amity.Domain, string[]][];
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  return criterias.find(([_, keys]) => hasKeys(model, keys))?.[0];
+};

package/src/core/model/index.ts

@@ -1,11 +1,11 @@
-export * from './idResolvers'
-export * from './identifyModel'
+export * from './idResolvers';
+export * from './identifyModel';
 
 /**
  * A map of v3 response keys to a store name.
  * @hidden
  */
- export const PAYLOAD2MODEL: Record<string, Amity.Domain> = {
+export const PAYLOAD2MODEL: Record<string, Amity.Domain> = {
   users: 'user',
   files: 'file',
   roles: 'role',
@@ -15,12 +15,14 @@ export * from './identifyModel'
   messages: 'message',
 
   communities: 'community',
+  categories: 'category',
   communityUsers: 'communityUsers',
   posts: 'post',
   postChildren: 'post',
   comments: 'comment',
+  polls: 'poll',
   videoStreamings: 'stream',
 
   follows: 'follow',
-  followCounts: 'followCount'
-}
+  followCounts: 'followCount',
+};

package/src/core/query/filtering.ts

@@ -12,6 +12,8 @@
  *
  * @hidden
  */
-export const filterByPropEquality = <T = {}>(collection: T[], key: keyof T, value: any) => (
-  value !== undefined ? collection.filter(item => item[key] === value) : collection
-)
+export const filterByPropEquality = <T = Record<string, unknown>>(
+  collection: T[],
+  key: keyof T,
+  value: any,
+) => (value !== undefined ? collection.filter(item => item[key] === value) : collection);

package/src/core/query/index.ts

@@ -1,4 +1,4 @@
-export * from './query'
-export * from './filtering'
-export * from './sorting'
-export * from './paging'
+export * from './query';
+export * from './filtering';
+export * from './sorting';
+export * from './paging';

package/src/core/query/paging.ts

@@ -1,4 +1,4 @@
-import { encode, decode } from 'js-base64'
+import { encode, decode } from 'js-base64';
 
 /**
  * Type guard to find if the a given decoded backend token uses "skip/limit" pagination style
@@ -8,9 +8,8 @@ import { encode, decode } from 'js-base64'
  *
  * @hidden
  */
-export const isSkipLimit = (json: Object): json is Amity.SkipLimitPagination => (
-  ['skip', 'limit'].some(prop => prop in json)
-)
+export const isSkipLimit = (json: Record<string, unknown>): json is Amity.SkipLimitPagination =>
+  ['skip', 'limit'].some(prop => prop in json);
 
 /**
  * Type guard to find if the a given decoded backend token uses "after/before" pagination style
@@ -20,9 +19,8 @@ export const isSkipLimit = (json: Object): json is Amity.SkipLimitPagination =>
  *
  * @hidden
  */
-export const isAfterBefore = (json: Object): json is Amity.AfterBeforePagination => (
-  ['after', 'before', 'first', 'last', 'limit'].some(prop => prop in json)
-)
+export const isAfterBefore = (json: Record<string, unknown>): json is Amity.AfterBeforePagination =>
+  ['after', 'before', 'first', 'last', 'limit'].some(prop => prop in json);
 
 /**
  * Type guard to find if the a given decoded backend token uses v4 or newer "after/before" pagination style
@@ -32,9 +30,9 @@ export const isAfterBefore = (json: Object): json is Amity.AfterBeforePagination
  *
  * @hidden
  */
-export const isAfterBeforeRaw = (json: Object): json is Amity.AfterBeforeRawPagination => (
-  'limit' in json
-)
+export const isAfterBeforeRaw = (
+  json: Record<string, unknown>,
+): json is Amity.AfterBeforeRawPagination => 'limit' in json;
 
 /**
  * Type guard to find if the a given object is wrapped around Amity.Paged<>
@@ -46,11 +44,11 @@ export const isAfterBeforeRaw = (json: Object): json is Amity.AfterBeforeRawPagi
  */
 export const isPaged = <T extends unknown>(payload: any): payload is Amity.Paged<T, any> => {
   return (
-     payload?.hasOwnProperty('data')
-  && payload?.hasOwnProperty('nextPage')
-  && payload?.hasOwnProperty('prevPage')
-  )
-}
+    payload?.hasOwnProperty('data') &&
+    payload?.hasOwnProperty('nextPage') &&
+    payload?.hasOwnProperty('prevPage')
+  );
+};
 
 /**
  * Converts a paging object into a b64 string token
@@ -65,53 +63,48 @@ export const toToken = (
   paging: Amity.Page | Amity.PageRaw | undefined,
   style: Amity.PaginationStyles,
 ): Amity.Token | undefined => {
-  if (!paging || !Object.keys(paging).length)
-    return
+  if (!paging || !Object.keys(paging).length) return;
 
-  let payload = {}
+  let payload = {};
 
   // TODO: refactor this clean
   if (style === 'skiplimit') {
     payload = {
       skip: paging.after ?? 0,
       limit: paging.limit,
-    }
-  }
-  else if (style === 'afterbefore' && isAfterBefore(paging)) {
+    };
+  } else if (style === 'afterbefore' && isAfterBefore(paging)) {
     /*
       Caution: this testing style is only valid because
       our backend expects nothing else than a number as
       "before" or "after" value. if that would change,
       we'd need to move toward a more simple: `!paging.before`
     */
-    if (!isNaN(paging?.before!)) {
+    if (!Number.isNaN(paging?.before!)) {
       payload = {
         before: paging.before,
         last: paging.limit,
-      }
-    } else if (!isNaN(paging?.after!)) {
+      };
+    } else if (!Number.isNaN(paging?.after!)) {
       payload = {
         after: paging.after,
         first: paging.limit,
-      }
-    } else if (!isNaN(paging?.limit!)) {
+      };
+    } else if (!Number.isNaN(paging?.limit!)) {
       payload = {
         last: paging.limit,
-      }
+      };
     }
-  }
-  else if (style === 'afterbeforeraw') {
-    payload = paging
+  } else if (style === 'afterbeforeraw') {
+    payload = paging;
   }
 
   // avoid sending {} as it seems backend flips when we do
-  if (!Object.keys(payload).length)
-    return
+  if (!Object.keys(payload).length) return;
 
   // don't try catch, let it throw
-  return encode(JSON.stringify(payload))
-}
-
+  return encode(JSON.stringify(payload));
+};
 
 /**
  * Converts a b64 string token into a paging object
@@ -122,32 +115,34 @@ export const toToken = (
  * @hidden
  */
 export const toPage = (token?: Amity.Token): Amity.Page | undefined => {
-  if (!token) return undefined
+  if (!token) return undefined;
 
   // don't try catch, let it throw
-  const json = JSON.parse(decode(token))
+  const json = JSON.parse(decode(token));
 
   if (isSkipLimit(json)) {
     return {
       after: json.skip,
       limit: json.limit!,
-    } as Amity.NextPage<number>
-  } else if (isAfterBefore(json)) {
+    } as Amity.NextPage<number>;
+  }
+  if (isAfterBefore(json)) {
     if ('before' in json) {
       return {
         before: json.before,
         limit: json.last,
-      } as Amity.PrevPage<number>
-    } else if ('after' in json) {
+      } as Amity.PrevPage<number>;
+    }
+    if ('after' in json) {
       return {
         after: json.after,
         limit: json.first,
-      } as Amity.NextPage<number>
+      } as Amity.NextPage<number>;
     }
   }
 
-  return undefined
-}
+  return undefined;
+};
 
 /**
  * Converts a b64 string token into a paging object
@@ -158,14 +153,14 @@ export const toPage = (token?: Amity.Token): Amity.Page | undefined => {
  * @hidden
  */
 export const toPageRaw = (token?: Amity.Token): Amity.PageRaw | undefined => {
-  if (!token) return undefined
+  if (!token) return undefined;
 
   // don't try catch, let it throw
-  const json = JSON.parse(decode(token))
+  const json = JSON.parse(decode(token));
 
   if (isAfterBeforeRaw(json)) {
-    return json as Amity.PageRaw
+    return json as Amity.PageRaw;
   }
 
-  return undefined
-}
+  return undefined;
+};

package/src/core/query/query.ts

@@ -1,4 +1,5 @@
-import { isPaged } from './paging'
+/* eslint-disable no-use-before-define */
+import { isPaged } from './paging';
 
 /**
  * Type guard to check and cast that a given async function is has the ".locally" property
@@ -9,10 +10,8 @@ import { isPaged } from './paging'
  * @hidden
  */
 export const isFetcher = <Args extends any[], Returned extends any>(
-  func: Amity.AsyncFunc<Args, Returned>
-): func is Amity.FetcherFunc<Args, Returned> => (
-  'locally' in func
-)
+  func: Amity.AsyncFunc<Args, Returned>,
+): func is Amity.FetcherFunc<Args, Returned> => 'locally' in func;
 
 /**
  * Type guard to check and cast that a given async function is has the ".optimistically" property
@@ -23,10 +22,8 @@ export const isFetcher = <Args extends any[], Returned extends any>(
  * @hidden
  */
 export const isMutator = <Args extends any[], Returned extends any>(
-  func: Amity.AsyncFunc<Args, Returned>
-): func is Amity.MutatorFunc<Args, Returned> => (
-  'optimistically' in func
-)
+  func: Amity.AsyncFunc<Args, Returned>,
+): func is Amity.MutatorFunc<Args, Returned> => 'optimistically' in func;
 
 /**
  * Type guard to check and cast that a given async function is has
@@ -38,8 +35,8 @@ export const isMutator = <Args extends any[], Returned extends any>(
  * @hidden
  */
 export const isOffline = <Args extends any[], Returned extends any>(
-  func: Amity.AsyncFunc<Args, Returned>
-): func is Amity.OfflineFunc<Args, Returned> => isFetcher(func) || isMutator(func)
+  func: Amity.AsyncFunc<Args, Returned>,
+): func is Amity.OfflineFunc<Args, Returned> => isFetcher(func) || isMutator(func);
 
 /**
  * Type guard to check and cast that a given object has the "cachedAt" property
@@ -49,9 +46,8 @@ export const isOffline = <Args extends any[], Returned extends any>(
  *
  * @hidden
  */
-export const isCachable = (model: any): model is Amity.Cachable => (
-  model?.hasOwnProperty('cachedAt')
-)
+export const isCachable = (model: any): model is Amity.Cachable =>
+  model?.hasOwnProperty('cachedAt');
 
 /**
  * Checks if a model is considered local (cachedAt === -1)
@@ -62,8 +58,8 @@ export const isCachable = (model: any): model is Amity.Cachable => (
  * @hidden
  */
 export const isLocal = (model?: any): model is Amity.Local => {
-  return isCachable(model) && model?.cachedAt === -1
-}
+  return isCachable(model) && model?.cachedAt === -1;
+};
 
 /**
  * Checks if a model is considered fresh
@@ -74,9 +70,9 @@ export const isLocal = (model?: any): model is Amity.Local => {
  *
  * @hidden
  */
-export const isFresh = (model?: Amity.Cachable, lifeSpan: number = 0) => {
-  return Date.now() - (model?.cachedAt ?? 0) <= lifeSpan
-}
+export const isFresh = (model?: Amity.Cachable, lifeSpan = 0) => {
+  return Date.now() - (model?.cachedAt ?? 0) <= lifeSpan;
+};
 
 /**
  * ```js
@@ -97,8 +93,7 @@ export const isFresh = (model?: Amity.Cachable, lifeSpan: number = 0) => {
 export const createQuery = <Args extends any[], Returned extends any>(
   func: Amity.AsyncFunc<Args, Returned> | Amity.OfflineFunc<Args, Returned>,
   ...args: Args
-) => ({ func, args })
-
+) => ({ func, args });
 
 /**
  * ```js
@@ -114,15 +109,14 @@ export const createQuery = <Args extends any[], Returned extends any>(
  * @category Query
  */
 export const queryOptions = (
-  policy: Amity.QueryPolicy, lifeSpan: number = 2 * 60 * 1000, // 2mn
+  policy: Amity.QueryPolicy,
+  lifeSpan: number = 2 * 60 * 1000, // 2mn
 ): Amity.QueryOptions => {
-  if (policy === 'cache_only')
-    return { lifeSpan: Infinity }
-  else if (policy === 'server_only')
-    return { lifeSpan: 0 }
+  if (policy === 'cache_only') return { lifeSpan: Infinity };
+  if (policy === 'server_only') return { lifeSpan: 0 };
 
-  return { lifeSpan }
-}
+  return { lifeSpan };
+};
 
 /**
  * Checks if an unknown shaped payload is considered empty or not.
@@ -136,20 +130,19 @@ export const queryOptions = (
  */
 const isEmpty = (local: any) => {
   // if it's supposed to be a single object, it'd be undefined
-  if (!local)
-    return true
+  if (!local) return true;
 
   // it's a paged query, the 1st cell of the array would be empty
-  else if (isPaged(local) && isEmpty(local.data)) {
-    return true
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  if (isPaged(local) && isEmpty(local.data)) {
+    return true;
   }
 
   // if it's a item collection, it'd have no keys
-  else if (!Object.keys(local).length)
-    return true
+  if (!Object.keys(local).length) return true;
 
-  return false
-}
+  return false;
+};
 
 /**
  * ```js
@@ -171,53 +164,54 @@ const isEmpty = (local: any) => {
 export const runQuery = <Args extends any[], Returned extends any>(
   { func, args }: Amity.Query<Args, Returned>,
   callback?: (args: Amity.Snapshot<Returned>) => void,
-  options: Amity.QueryOptions = queryOptions('cache_then_server')
+  options: Amity.QueryOptions = queryOptions('cache_then_server'),
 ) => {
-  let local: Returned | undefined
+  let local: Returned | undefined;
 
   // offline first
   if (isOffline(func) && options.lifeSpan !== 0) {
     try {
-      local = isMutator(func)
-        ? func.optimistically(...args)
-        : func.locally(...args)
+      local = isMutator(func) ? func.optimistically(...args) : func.locally(...args);
     } catch (error) {
       callback?.(
         createSnapshot<Returned>(undefined, {
           origin: 'local',
           loading: false,
           error,
-        })
-      )
+        }),
+      );
     }
 
-    const shouldAbort = isCachable(local) && isFresh(local, options.lifeSpan)
+    const shouldAbort = isCachable(local) && isFresh(local, options.lifeSpan);
 
-    callback?.(createSnapshot<Returned>(local , {
-      origin: 'local',
-      loading: !(isFetcher(func) && shouldAbort)
-    }))
+    callback?.(
+      createSnapshot<Returned>(local, {
+        origin: 'local',
+        loading: !(isFetcher(func) && shouldAbort),
+      }),
+    );
 
-    if (shouldAbort)
-      return
+    if (shouldAbort) return;
   } else {
-    callback?.(createSnapshot<Returned>(undefined, {
-      origin: 'local',
-      loading: true
-    }))
+    callback?.(
+      createSnapshot<Returned>(undefined, {
+        origin: 'local',
+        loading: true,
+      }),
+    );
   }
 
   func(...args)
     .then(fresh => {
       // @ts-ignore i know.
-//      isLocal(local) && syncInCache(local, fresh)
+      // isLocal(local) && syncInCache(local, fresh)
 
       callback?.(
         createSnapshot<Returned>(fresh, {
           origin: 'server',
           loading: false,
-        })
-      )
+        }),
+      );
     })
     .catch(error => {
       callback?.(
@@ -225,10 +219,10 @@ export const runQuery = <Args extends any[], Returned extends any>(
           origin: 'server',
           loading: false,
           error,
-        })
-      )
-    })
-}
+        }),
+      );
+    });
+};
 
 /**
  * This is a TS hack around types
@@ -240,9 +234,9 @@ export const runQuery = <Args extends any[], Returned extends any>(
  * @hidden
  */
 function createSnapshot<T>(data: T | undefined, options?: Amity.SnapshotOptions): Amity.Snapshot<T>;
+// eslint-disable-next-line no-redeclare
 function createSnapshot(data: unknown, options?: Amity.SnapshotOptions): unknown {
-  if (isPaged(data) || isCachable(data))
-    return { ...options, ...data }
+  if (isPaged(data) || isCachable(data)) return { ...options, ...data };
 
-  return { ...options, data }
+  return { ...options, data };
 }

package/src/core/query/sorting.ts

@@ -2,49 +2,55 @@
 // this file should contain a suite of sorting utilities to help the
 // local version of the query functions.
 
-type SortingFunc<T = Object> = (a: T, b: T) => number
+type SortingFunc<T = Record<string, unknown>> = (a: T, b: T) => number;
 
 /**
  * Alphabetic sorting of objects having a displayName
  */
 export const sortByDisplayName: SortingFunc<{ displayName: string }> = (
-  { displayName: a }, { displayName: b }
+  { displayName: a },
+  { displayName: b },
 ) => {
-  if (a === b) return 0
-  return a < b ? -1 : 1
-}
+  if (a === b) return 0;
+  return a < b ? -1 : 1;
+};
 
 /**
  * Sorting a collection by their apparition order (oldest first)
  */
 export const sortByChannelSegment: SortingFunc<{ channelSegment: number }> = (
-  { channelSegment: a }, { channelSegment: b }
-) => a - b
+  { channelSegment: a },
+  { channelSegment: b },
+) => a - b;
 
 /**
  * Sorting a collection by their apparition order (oldest first)
  */
 export const sortBySegmentNumber: SortingFunc<{ segmentNumber: number }> = (
-  { segmentNumber: a }, { segmentNumber: b }
-) => a - b
+  { segmentNumber: a },
+  { segmentNumber: b },
+) => a - b;
 
 /**
  * Sorting a collection by its oldest items
  */
 export const sortByFirstCreated: SortingFunc<{ createdAt: Date | number | string }> = (
-  { createdAt: a }, { createdAt: b }
-) => new Date(a).valueOf() - new Date(b).valueOf()
+  { createdAt: a },
+  { createdAt: b },
+) => new Date(a).valueOf() - new Date(b).valueOf();
 
 /**
  * Sorting a collection by its newest items
  */
 export const sortByLastCreated: SortingFunc<{ createdAt: Date | number | string }> = (
-  { createdAt: a }, { createdAt: b }
-) => new Date(b).valueOf() - new Date(a).valueOf()
+  { createdAt: a },
+  { createdAt: b },
+) => new Date(b).valueOf() - new Date(a).valueOf();
 
 /**
  * Sorting a collection by the items with most recent activity
  */
 export const sortByLastActivity: SortingFunc<{ lastActivity: Date | number | string }> = (
-  { lastActivity: a }, { lastActivity: b }
-) => new Date(b).valueOf() - new Date(a).valueOf()
+  { lastActivity: a },
+  { lastActivity: b },
+) => new Date(b).valueOf() - new Date(a).valueOf();