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

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,20 @@ 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(/^(\w*)/, '$1/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 +58,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;
+};

package/src/core/transports/mqtt.ts

@@ -1,7 +1,9 @@
-import mqtt, { MqttClient, IClientOptions, ISubscriptionGrant } from 'mqtt/dist/mqtt'
-import { ASCError, ASCUnknownError } from '~/core/errors'
+/* eslint-disable no-console */
+/* eslint-disable no-promise-executor-return */
+import mqtt, { MqttClient, IClientOptions, ISubscriptionGrant } from 'mqtt/dist/mqtt';
+import { ASCError, ASCUnknownError } from '~/core/errors';
 
-const QOS_FAILURE_CODE = 128
+const QOS_FAILURE_CODE = 128;
 
 const RETRY_BASE_TIMEOUT = 1000;
 const RETRY_COUNT_MAX = 10;
@@ -12,7 +14,11 @@ const enum MqttError {
   NOT_AUTHORIZED = 5,
 }
 
-export function getMqttOptions(params: { username: string, password: string, clientId?: string }): IClientOptions {
+export function getMqttOptions(params: {
+  username: string;
+  password: string;
+  clientId?: string;
+}): IClientOptions {
   return {
     clean: false, // keep subscriptions
     clientId: `mqttjs_ + ${Math.random().toString(16).substr(2, 8)}`,
@@ -23,11 +29,11 @@ export function getMqttOptions(params: { username: string, password: string, cli
       topic: 'WillMsg',
       payload: 'Connection Closed abnormally..!',
       qos: 0,
-      retain: false
+      retain: false,
     },
 
-    ...params
-  }
+    ...params,
+  };
 }
 
 /**
@@ -41,101 +47,114 @@ export function getMqttOptions(params: { username: string, password: string, cli
  */
 export const createMqttTransport = (endpoint: string): Amity.MqttClient => {
   let mqttClient: MqttClient | void;
-  let retryCount = 0
-  let allowReconnection = true
+  let retryCount = 0;
+  let allowReconnection = true;
+
+  const reconnect = () => {
+    setTimeout(() => {
+      retryCount += 1;
+      mqttClient!.reconnect();
+    }, RETRY_BASE_TIMEOUT * 2 ** (retryCount > RETRY_COUNT_MAX ? RETRY_COUNT_MAX : retryCount));
+  };
 
-  async function connect(params: { accessToken: string, userId: string }): Promise<void> {
+  async function connect(params: { accessToken: string; userId: string }): Promise<void> {
     if (mqttClient) {
       mqttClient.removeAllListeners();
-      mqttClient.end(true)
+      mqttClient.end(true);
     }
 
-    mqttClient = mqtt.connect(endpoint, getMqttOptions({ username: params.userId, password: params.accessToken }))
+    mqttClient = mqtt.connect(
+      endpoint,
+      getMqttOptions({ username: params.userId, password: params.accessToken }),
+    );
 
     mqttClient.on('connect', () => {
-      retryCount = 0
-      allowReconnection = true
-    })
+      retryCount = 0;
+      allowReconnection = true;
+    });
 
     mqttClient.on('error', (error: Error & { code: number }) => {
+      // eslint-disable-next-line default-case
       switch (error.code) {
         case MqttError.IDENTIFIER_REJECTED:
         case MqttError.BAD_USERNAME_OR_PASSWORD:
         case MqttError.NOT_AUTHORIZED:
-          allowReconnection = false
+          allowReconnection = false;
       }
-    })
+    });
 
     mqttClient.on('close', () => {
       if (allowReconnection) {
-        reconnect()
+        reconnect();
       }
-    })
+    });
 
-    return new Promise(resolve => mqttClient!.once('connect', () => resolve()))
-  }
-
-  const reconnect = () => {
-    setTimeout(() => {
-      retryCount = retryCount + 1
-      mqttClient!.reconnect()
-    }, RETRY_BASE_TIMEOUT * Math.pow(2, retryCount > RETRY_COUNT_MAX ? RETRY_COUNT_MAX : retryCount))
+    return new Promise(resolve => mqttClient!.once('connect', () => resolve()));
   }
 
   return {
     connect,
     async disconnect(): Promise<void> {
-      allowReconnection = false
+      allowReconnection = false;
 
       if (this.connected) {
-        return new Promise(resolve => mqttClient?.end(true, undefined, () => resolve()))
+        return new Promise(resolve => mqttClient?.end(true, undefined, () => resolve()));
       }
     },
     get connected() {
-      return !!mqttClient?.connected
+      return !!mqttClient?.connected;
     },
-    on<T extends keyof Amity.MqttEvents>(event: T, handler: (payload: Amity.MqttEvents[T]) => void) {
-      mqttClient?.on(event, handler)
+    on<T extends keyof Amity.MqttEvents>(
+      event: T,
+      handler: (payload: Amity.MqttEvents[T]) => void,
+    ) {
+      mqttClient?.on(event, handler);
     },
-    once<T extends keyof Amity.MqttEvents>(event: T, handler: (payload: Amity.MqttEvents[T]) => void) {
-      mqttClient?.once(event, handler)
+    once<T extends keyof Amity.MqttEvents>(
+      event: T,
+      handler: (payload: Amity.MqttEvents[T]) => void,
+    ) {
+      mqttClient?.once(event, handler);
     },
-    off<T extends keyof Amity.MqttEvents>(event: T, handler?: (payload: Amity.MqttEvents[T]) => void) {
+    off<T extends keyof Amity.MqttEvents>(
+      event: T,
+      handler?: (payload: Amity.MqttEvents[T]) => void,
+    ) {
       if (handler !== undefined) {
-        mqttClient?.off(event, handler)
+        mqttClient?.off(event, handler);
       } else {
-        mqttClient?.removeAllListeners(event)
+        mqttClient?.removeAllListeners(event);
       }
     },
     removeAllListeners() {
-      mqttClient?.removeAllListeners()
+      mqttClient?.removeAllListeners();
     },
     subscribe(topic: string, callback?: Amity.Listener<ASCError | void>): Amity.Unsubscriber {
       const callbackWrapper = (error: Error, granted: ISubscriptionGrant[]) => {
         if (error || granted[0].qos === QOS_FAILURE_CODE) {
           const ascError = error
             ? new ASCError(error.message, Amity.ClientError.UNKNOWN_ERROR, Amity.ErrorLevel.ERROR)
-            // TODO throw the actual error, once BE can tell us the actual error code
-            : new ASCUnknownError(Amity.ClientError.UNKNOWN_ERROR, Amity.ErrorLevel.ERROR)
+            : // TODO throw the actual error, once BE can tell us the actual error code
+              new ASCUnknownError(Amity.ClientError.UNKNOWN_ERROR, Amity.ErrorLevel.ERROR);
 
-          console.error(`Failed to subscribe to topic ${topic}`, ascError)
-          callback?.(ascError)
+          console.error(`Failed to subscribe to topic ${topic}`, ascError);
+          callback?.(ascError);
         } else {
-          console.log(`Subscribed to topic ${granted[0].topic}`)
-          callback?.()
+          console.log(`Subscribed to topic ${granted[0].topic}`);
+          callback?.();
         }
-      }
+      };
 
       if (mqttClient) {
-        mqttClient.subscribe(topic, { qos: 0 }, callbackWrapper)
+        mqttClient.subscribe(topic, { qos: 0 }, callbackWrapper);
       } else {
         callbackWrapper(new Error('No connection to broker'), []);
       }
 
-      return () => mqttClient?.unsubscribe(topic)
+      return () => mqttClient?.unsubscribe(topic);
     },
     unsubscribe(topic: string) {
-      mqttClient?.unsubscribe(topic)
-    }
-  }
-}
+      mqttClient?.unsubscribe(topic);
+    },
+  };
+};

package/src/core/transports/utils.ts

@@ -1,4 +1,4 @@
-import { ASCApiError, ASCUnknownError } from '~/core/errors'
+import { ASCApiError, ASCUnknownError } from '~/core/errors';
 
 /**
  * Unwraps v3 server payload (for error handling and type extraction)
@@ -13,13 +13,14 @@ import { ASCApiError, ASCUnknownError } from '~/core/errors'
  */
 export const unwrapPayload = <T>(response: Amity.Response<T>): T => {
   if (response.status === 'success') {
-    return response.data
-  } else if (response.status === 'fail') {
-    throw new ASCUnknownError(response.code)
+    return response.data;
+  }
+  if (response.status === 'fail') {
+    throw new ASCUnknownError(response.code);
   } else if (response.status === 'error') {
-    throw new ASCApiError(response.message, response.code, Amity.ErrorLevel.ERROR)
+    throw new ASCApiError(response.message, response.code, Amity.ErrorLevel.ERROR);
   }
 
   // unjust, but helps force uncast "T | undefined" to allow deconstruction without warnings
-  return undefined as unknown as T
-}
+  return undefined as unknown as T;
+};

package/src/core/transports/ws.ts

@@ -1,5 +1,5 @@
-import io from 'socket.io-client'
-import { unwrapPayload } from './utils'
+import io from 'socket.io-client';
+import { unwrapPayload } from './utils';
 
 /**
  * Creates a pre-configured socket.io instance
@@ -15,16 +15,15 @@ export const createWebsocketTransport = (endpoint: string) => {
     autoConnect: false,
     reconnectionDelay: 2000,
     transports: ['websocket'],
-  })
+  });
 
   // FIXME: disconnectClient removes this listener and client can get global ban event
   socket.on('disconnect', (reason: string) => {
-    if (reason === 'io server disconnect')
-      socket.connect()
-  })
+    if (reason === 'io server disconnect') socket.connect();
+  });
 
-  return socket
-}
+  return socket;
+};
 
 /**
  * Promisify a websocket event emission - resulting in a synchronous http-like XHR (ws legacy)
@@ -43,19 +42,19 @@ export const createWebsocketTransport = (endpoint: string) => {
 export const synchronousWSCall = async <T>(
   client: Amity.Client,
   event: string,
-  data?: Object,
-)=> {
-  const { ws } = client
+  data?: Record<string, unknown>,
+) => {
+  const { ws } = client;
 
   const value = await new Promise<T | undefined>((resolve, reject) => {
     ws.emit(event, data, (response: Amity.Response<T>) => {
       try {
-        resolve(unwrapPayload(response))
+        resolve(unwrapPayload(response));
       } catch (error) {
-        reject(error)
+        reject(error);
       }
-    })
-  })
+    });
+  });
 
-  return value
-}
+  return value;
+};

package/src/core/uuid.ts

@@ -1,2 +1,3 @@
-import nativeIdGenerator from 'react-native-uuid'
-export const uuid = () => nativeIdGenerator.v4().toString()
+import nativeIdGenerator from 'react-native-uuid';
+
+export const uuid = () => nativeIdGenerator.v4().toString();

package/src/external/api/createUserToken.ts

@@ -0,0 +1,43 @@
+import { createHttpTransport } from '~/core/transports';
+import { getDeviceInfo, getDeviceId } from '~/core/device';
+import { API_REGIONS, computeUrl } from '~/client/utils/endpoints';
+
+/**
+ * Retrieves accessToken info to use in Beta services
+ *
+ * @param apiKey for the Http Client instance
+ * @param apiRegion endpoint to connect to
+ * @param params The token parameters
+ * @param params.userId The userId to use to issue a token
+ * @param params.displayName The user's displayName
+ * @param params.authToken The authentication token - necessary when network option is set to secure
+ * @return An accessToken info object for the given userId
+ *
+ * @category External API
+ * @hidden
+ */
+export const createUserToken = async (
+  apiKey: string,
+  apiRegion: typeof API_REGIONS[keyof typeof API_REGIONS],
+  params: {
+    userId: Amity.User['userId'];
+    displayName?: Amity.User['displayName'];
+    authToken?: string;
+  },
+) => {
+  const deviceId = getDeviceId();
+  const deviceInfo = await getDeviceInfo();
+  const http = createHttpTransport(computeUrl('http', apiRegion));
+
+  const { data } = await http.post<Amity.Tokens>(
+    '/api/v3/sessions',
+    {
+      ...params,
+      deviceId,
+      deviceInfo: { ...deviceInfo, model: 'token management API on TS-SDK' },
+    },
+    { headers: { 'X-API-Key': apiKey } },
+  );
+
+  return { accessToken: data.accessToken };
+};

package/src/external/api/index.ts

@@ -0,0 +1 @@
+export * from './createUserToken';

package/src/feed/api/index.ts

@@ -1 +1 @@
-export * from './queryGlobalFeed'
+export * from './queryGlobalFeed';

package/src/feed/api/queryGlobalFeed.ts

@@ -1,9 +1,9 @@
-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 { pullFromCache, pushToCache } from '~/cache/api'
-import { getResolver } from '~/core/model'
+import { toPage, toToken } from '~/core/query';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { getResolver } from '~/core/model';
 
 /**
  * ```js
@@ -18,43 +18,50 @@ import { getResolver } from '~/core/model'
  *
  * @category Feed API
  * @async
- **/
+ * */
 export const queryGlobalFeed = async (query?: {
-  dataTypes?: ('video' | 'image' | 'file' | 'liveStream')[]
-  useCustomRanking?: boolean
-  page?: Amity.Page
+  dataTypes?: ('video' | 'image' | 'file' | 'liveStream')[];
+  useCustomRanking?: boolean;
+  page?: Amity.Page;
 }): Promise<Amity.Cached<Amity.Paged<Amity.Post>>> => {
-  const client = getActiveClient()
-  client.log('feed/queryGlobalFeed', query)
+  const client = getActiveClient();
+  client.log('feed/queryGlobalFeed', query);
 
-  const { useCustomRanking, page, ...params } = query ?? {}
+  const { useCustomRanking, page, ...params } = query ?? {};
 
   const { data } = await client.http.get<Amity.PostPayload & Amity.Pagination>(
-    useCustomRanking ? `/api/v5/me/global-feeds` : `/api/v4/me/global-feeds`, { params: {
-      ...params,
-      options: {
-        token: toToken(page, 'skiplimit')
+    useCustomRanking ? `/api/v5/me/global-feeds` : `/api/v4/me/global-feeds`,
+    {
+      params: {
+        ...params,
+        options: {
+          token: toToken(page, 'skiplimit'),
+        },
       },
-    } }
-  )
+    },
+  );
 
-  const { paging, ...payload } = data
-  const { posts } = payload
+  const { paging, ...payload } = data;
+  const { posts } = payload;
 
-  const cachedAt = client.cache && Date.now()
+  const cachedAt = client.cache && Date.now();
 
   if (client.cache) {
-    ingestInCache(payload as Amity.PostPayload)
-
-    const cacheKey = ['globalFeed', 'query', { ...params, useCustomRanking, options: { ...page } } as Amity.Serializable]
-    pushToCache(cacheKey, { posts: posts.map(getResolver('post')), paging })
+    ingestInCache(payload as Amity.PostPayload);
+
+    const cacheKey = [
+      'globalFeed',
+      'query',
+      { ...params, useCustomRanking, options: { ...page } } as Amity.Serializable,
+    ];
+    pushToCache(cacheKey, { posts: posts.map(getResolver('post')), paging });
   }
 
-  const nextPage = toPage(paging.next)
-  const prevPage = toPage(paging.previous)
+  const nextPage = toPage(paging.next);
+  const prevPage = toPage(paging.previous);
 
-  return { data: posts, cachedAt, prevPage, nextPage }
-}
+  return { data: posts, cachedAt, prevPage, nextPage };
+};
 
 /**
  * ```js
@@ -69,32 +76,35 @@ export const queryGlobalFeed = async (query?: {
  *
  * @category Feed API
  * @async
- **/
+ * */
 queryGlobalFeed.locally = (
   query: Parameters<typeof queryGlobalFeed>[0],
 ): Amity.Cached<Amity.Paged<Amity.Post>> | undefined => {
-  const client = getActiveClient()
-  client.log('post/queryGlobalFeed.locally', query)
+  const client = getActiveClient();
+  client.log('post/queryGlobalFeed.locally', query);
 
-  if (!client.cache) return
+  if (!client.cache) return;
 
-  const { useCustomRanking, page, ...params } = query ?? {}
+  const { useCustomRanking, page, ...params } = query ?? {};
 
-  const queryKey = ['globalFeed', 'query', { ...params, useCustomRanking, options: { ...page }} as Amity.Serializable];
-  const { data, cachedAt } = pullFromCache<{ posts: string[] } & Amity.Pagination>(queryKey) ?? {}
+  const queryKey = [
+    'globalFeed',
+    'query',
+    { ...params, useCustomRanking, options: { ...page } } as Amity.Serializable,
+  ];
+  const { data, cachedAt } = pullFromCache<{ posts: string[] } & Amity.Pagination>(queryKey) ?? {};
 
-  if (!data?.posts.length)
-    return
+  if (!data?.posts.length) return;
 
   const posts: Amity.Post[] = data.posts
     .map(postId => pullFromCache<Amity.Post>(['post', 'get', postId])!)
     .filter(Boolean)
-    .map(({ data }) => data)
+    .map(({ data }) => data);
 
-  const prevPage = toPage(data?.paging.previous)
-  const nextPage = toPage(data?.paging.next)
+  const prevPage = toPage(data?.paging.previous);
+  const nextPage = toPage(data?.paging.next);
 
   return posts.length === data?.posts?.length
     ? { data: posts, cachedAt, prevPage, nextPage }
-    : undefined
-}
+    : undefined;
+};