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

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();

package/src/core/subscription.ts

@@ -1,7 +1,7 @@
-import { getActiveClient } from '~/client/api'
-import { ASCError } from '~/core/errors'
-import { proxyMqttEvents } from '~/core/events'
-import { getActiveUser } from '~/client/api/activeUser'
+import { getActiveClient } from '~/client/api';
+import { ASCError } from '~/core/errors';
+import { proxyMqttEvents } from '~/core/events';
+import { getActiveUser } from '~/client/api/activeUser';
 
 export enum SubscriptionLevels {
   COMMUNITY = 'community',
@@ -12,7 +12,7 @@ export enum SubscriptionLevels {
 }
 
 const getCommunityUserTopic = (
-  { path }: Amity.Subscribable,
+  path: Amity.Subscribable['path'],
   level?: SubscriptionLevels,
 ): string => {
   switch (level) {
@@ -30,18 +30,22 @@ const getCommunityUserTopic = (
 export const getCommunityTopic = (
   { path }: Amity.Subscribable,
   level: Exclude<SubscriptionLevels, SubscriptionLevels.USER> = SubscriptionLevels.COMMUNITY,
-): string =>
-  getCommunityUserTopic({ path }, level)
+): string => getCommunityUserTopic(path, level);
 
 export const getUserTopic = (
   { path }: Amity.Subscribable,
   level: Exclude<SubscriptionLevels, SubscriptionLevels.COMMUNITY> = SubscriptionLevels.USER,
 ): string =>
-  getCommunityUserTopic({ path }, level)
+  getCommunityUserTopic(
+    level === SubscriptionLevels.USER
+      ? path
+      : path.replace(/^(?<networkId>\w*)/, '$<networkId>/social'),
+    level,
+  );
 
 export const getPostTopic = (
   { path }: Amity.Subscribable,
-  level: SubscriptionLevels.POST | SubscriptionLevels.COMMENT = SubscriptionLevels.POST
+  level: SubscriptionLevels.POST | SubscriptionLevels.COMMENT = SubscriptionLevels.POST,
 ): string => {
   switch (level) {
     case 'comment':
@@ -56,38 +60,38 @@ export const getCommentTopic = ({ path }: Amity.Subscribable): string => {
 };
 
 export const getMyFollowersTopic = (): string => {
-  const user = getActiveUser()
+  const user = getActiveUser();
 
   const [networkId] = user.path.split('/user/');
 
   return `${networkId}/membership/${user._id}/+/+`;
-}
+};
 
 export const getMyFollowingsTopic = (): string => {
-  const user = getActiveUser()
+  const user = getActiveUser();
 
   const [networkId] = user.path.split('/user/');
 
   return `${networkId}/membership/+/${user._id}/+`;
-}
+};
 
 let mqttAccessToken: string;
 let mqttUserId: string;
 
 export function subscribeTopic(
   topic: string,
-  callback?: Amity.Listener<ASCError | void>
+  callback?: Amity.Listener<ASCError | void>,
 ): Amity.Unsubscriber {
-  const { mqtt, emitter, accessToken } = getActiveClient()
+  const { mqtt, emitter, accessToken } = getActiveClient();
   const user = getActiveUser();
 
   if (mqttAccessToken !== accessToken || mqttUserId !== user._id) {
-    mqttAccessToken = accessToken!
-    mqttUserId = user._id!
+    mqttAccessToken = accessToken!;
+    mqttUserId = user._id!;
 
-    mqtt.connect({ accessToken: mqttAccessToken, userId: mqttUserId })
-    proxyMqttEvents(mqtt, emitter)
+    mqtt.connect({ accessToken: mqttAccessToken, userId: mqttUserId });
+    proxyMqttEvents(mqtt, emitter);
   }
 
-  return mqtt.subscribe(topic, callback)
+  return mqtt.subscribe(topic, callback);
 }

package/src/core/transports/http.ts

@@ -1,28 +1,30 @@
-import axios from 'axios'
-import HttpAgent, { HttpsAgent } from 'agentkeepalive'
+import axios from 'axios';
+import HttpAgent, { HttpsAgent } from 'agentkeepalive';
 
-import { unwrapPayload } from './utils'
+import { unwrapPayload } from './utils';
 
 /**
  * Axios param serializer (for querystring)
  * @hidden
  */
-const stringify = (params: object, prefix?: string): string => {
+const stringify = (params: Record<string, unknown>, prefix?: string): string => {
   return Object.entries(params)
     .filter(([, value]) => value !== undefined)
     .map(([name, value]) => {
-      const key = prefix ? `${prefix}[${name}]` : name
+      const key = prefix ? `${prefix}[${name}]` : name;
 
       if (Array.isArray(value)) {
-        return value.map(item => `${key}[]=${item}`).join('&')
-      } else if (typeof value !== 'object') {
-        return `${key}=${value}`
+        return value.map(item => `${key}[]=${item}`).join('&');
+      }
+      if (typeof value !== 'object') {
+        return `${key}=${value}`;
       }
 
-      return stringify(value, prefix ?? name)
+      // @ts-ignore
+      return stringify(value, prefix ?? name);
     })
-    .join('&')
-}
+    .join('&');
+};
 
 /**
  * Creates a pre-configured axios instance
@@ -39,25 +41,25 @@ export const createHttpTransport = (endpoint: string) => {
     maxFreeSockets: 10,
     timeout: 60000,
     freeSocketTimeout: 30000,
-  }
+  };
 
   const instance = axios.create({
     baseURL: endpoint,
     httpAgent: new HttpAgent(options),
     httpsAgent: new HttpsAgent(options),
     paramsSerializer: stringify,
-  })
+  });
 
   instance.interceptors.response.use(
-    (response) => response,
-    (error) => {
-      const { response } = error
-      console.error(response?.data ?? error)
-
-      if (response)
-        unwrapPayload(response.data)
-    }
-  )
-
-  return instance
-}
+    response => response,
+    error => {
+      const { response } = error;
+      // eslint-disable-next-line no-console
+      console.error(response?.data ?? error);
+
+      if (response) unwrapPayload(response.data);
+    },
+  );
+
+  return instance;
+};