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

package/src/core/transports/mqtt.ts

@@ -0,0 +1,160 @@
+/* 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 RETRY_BASE_TIMEOUT = 1000;
+const RETRY_COUNT_MAX = 10;
+
+const enum MqttError {
+  IDENTIFIER_REJECTED = 2,
+  BAD_USERNAME_OR_PASSWORD = 4,
+  NOT_AUTHORIZED = 5,
+}
+
+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)}`,
+    protocolId: 'MQTT',
+    protocolVersion: 4,
+    reconnectPeriod: 0, // disable auto reconnect
+    will: {
+      topic: 'WillMsg',
+      payload: 'Connection Closed abnormally..!',
+      qos: 0,
+      retain: false,
+    },
+
+    ...params,
+  };
+}
+
+/**
+ * Creates a pre-configured socket.io instance
+ *
+ * @param endpoint The mqtt server's URL
+ * @returns A pre-configured (non-connected) mqtt client instance
+ *
+ * @category Transport
+ * @hidden
+ */
+export const createMqttTransport = (endpoint: string): Amity.MqttClient => {
+  let mqttClient: MqttClient | void;
+  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> {
+    if (mqttClient) {
+      mqttClient.removeAllListeners();
+      mqttClient.end(true);
+    }
+
+    mqttClient = mqtt.connect(
+      endpoint,
+      getMqttOptions({ username: params.userId, password: params.accessToken }),
+    );
+
+    mqttClient.on('connect', () => {
+      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;
+      }
+    });
+
+    mqttClient.on('close', () => {
+      if (allowReconnection) {
+        reconnect();
+      }
+    });
+
+    return new Promise(resolve => mqttClient!.once('connect', () => resolve()));
+  }
+
+  return {
+    connect,
+    async disconnect(): Promise<void> {
+      allowReconnection = false;
+
+      if (this.connected) {
+        return new Promise(resolve => mqttClient?.end(true, undefined, () => resolve()));
+      }
+    },
+    get connected() {
+      return !!mqttClient?.connected;
+    },
+    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);
+    },
+    off<T extends keyof Amity.MqttEvents>(
+      event: T,
+      handler?: (payload: Amity.MqttEvents[T]) => void,
+    ) {
+      if (handler !== undefined) {
+        mqttClient?.off(event, handler);
+      } else {
+        mqttClient?.removeAllListeners(event);
+      }
+    },
+    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);
+
+          console.error(`Failed to subscribe to topic ${topic}`, ascError);
+          callback?.(ascError);
+        } else {
+          console.log(`Subscribed to topic ${granted[0].topic}`);
+          callback?.();
+        }
+      };
+
+      if (mqttClient) {
+        mqttClient.subscribe(topic, { qos: 0 }, callbackWrapper);
+      } else {
+        callbackWrapper(new Error('No connection to broker'), []);
+      }
+
+      return () => mqttClient?.unsubscribe(topic);
+    },
+    unsubscribe(topic: string) {
+      mqttClient?.unsubscribe(topic);
+    },
+  };
+};

package/src/core/transports/test/http.test.ts

@@ -0,0 +1,83 @@
+import { createHttpTransport, stringify } from '../http';
+
+describe('core/transports', () => {
+  describe('stringify', () => {
+    test('should serializer simple string', () => {
+      const params = { a: 'c' };
+      const url = stringify(params);
+      expect(url).toBe('a=c');
+    });
+
+    test('should serializer empty string', () => {
+      const params = { a: '' };
+      const url = stringify(params);
+      expect(url).toBe('a=');
+    });
+
+    test('should serializer special character', () => {
+      const params = { a: '✓', b: 'ø' };
+      const url = stringify(params);
+      expect(url).toBe('a=%E2%9C%93&b=%C3%B8');
+    });
+
+    test('should serializer boolean', () => {
+      const params = { a: true, b: false };
+      const url = stringify(params);
+      expect(url).toBe('a=true&b=false');
+    });
+
+    test('should serializer null ', () => {
+      const params = { a: null };
+      const url = stringify(params);
+      expect(url).toBe('a=');
+    });
+
+    test('should serializer undefined', () => {
+      const params = { a: undefined };
+      const url = stringify(params);
+      expect(url).toBe('');
+    });
+
+    test('should serializer NaN', () => {
+      const params = { a: NaN };
+      const url = stringify(params);
+      expect(url).toBe('a=NaN');
+    });
+
+    test('should serializer simple array', () => {
+      const params = { a: ['b', 'c', 'd'] };
+      const url = stringify(params);
+      expect(url).toBe('a%5B%5D=b&a%5B%5D=c&a%5B%5D=d');
+    });
+
+    test('should serializer complex array', () => {
+      const params = { a: ['b', { c: 'd' }] };
+      const url = stringify(params);
+      expect(url).toBe('a%5B%5D=b&a%5B%5D%5Bc%5D=d');
+    });
+
+    test('should serializer nested object', () => {
+      const params = { a: { b: 'c' } };
+      const url = stringify(params);
+      expect(url).toBe('a%5Bb%5D=c');
+    });
+
+    test('should serializer deep nested object', () => {
+      const params = { a: { b: { c: { d: { e: { f: { g: { h: { i: 'j' } } } } } } } } };
+      const url = stringify(params);
+      expect(url).toBe('a%5Bb%5D%5Bc%5D%5Bd%5D%5Be%5D%5Bf%5D%5Bg%5D%5Bh%5D%5Bi%5D=j');
+    });
+
+    test('should serializer empty object', () => {
+      const params = { a: { b: [] } };
+      const url = stringify(params);
+      expect(url).toBe('');
+    });
+  });
+
+  describe('createHttpTransport', () => {
+    test('should create axios instance with out error', () => {
+      expect(createHttpTransport('/')).not.toThrow();
+    });
+  });
+});

package/src/core/transports/utils.ts

@@ -0,0 +1,26 @@
+import { ASCApiError, ASCUnknownError } from '~/core/errors';
+
+/**
+ * Unwraps v3 server payload (for error handling and type extraction)
+ *
+ * @param response A typical "v3" response (related to backend's service strategy)
+ *
+ * @returns The data returned by the backend
+ * @throws An error related to backend's rejection
+ *
+ * @category Transport
+ * @hidden
+ */
+export const unwrapPayload = <T>(response: Amity.Response<T>): T => {
+  if (response.status === 'success') {
+    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);
+  }
+
+  // unjust, but helps force uncast "T | undefined" to allow deconstruction without warnings
+  return undefined as unknown as T;
+};

package/src/core/transports/ws.ts

@@ -0,0 +1,60 @@
+import io from 'socket.io-client';
+import { unwrapPayload } from './utils';
+
+/**
+ * Creates a pre-configured socket.io instance
+ *
+ * @param endpoint The socket.io server's URL
+ * @returns A pre-configured (non-connected) socket.io client instance
+ *
+ * @category Transport
+ * @hidden
+ */
+export const createWebsocketTransport = (endpoint: string) => {
+  const socket = io(endpoint, {
+    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();
+  });
+
+  return socket;
+};
+
+/**
+ * Promisify a websocket event emission - resulting in a synchronous http-like XHR (ws legacy)
+ *
+ * @param client The current client for which to send the event with
+ * @param event The websocket event name
+ * @param data The event's payload
+ *
+ * @returns The data returned by the backend
+ * @throws An error related to backend's rejection
+ *
+ * @category Transport
+ * @async
+ * @hidden
+ */
+export const synchronousWSCall = async <T>(
+  client: Amity.Client,
+  event: string,
+  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));
+      } catch (error) {
+        reject(error);
+      }
+    });
+  });
+
+  return value;
+};

package/src/core/uuid.ts

@@ -0,0 +1,3 @@
+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

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

package/src/feed/api/queryGlobalFeed.ts

@@ -0,0 +1,110 @@
+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';
+
+/**
+ * ```js
+ * import { queryGlobalFeed } from '@amityco/ts-sdk'
+ * const posts = await queryGlobalFeed()
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.Post} objects
+ *
+ * @param query The query parameters
+ * @returns A page of {@link Amity.Post} objects
+ *
+ * @category Feed API
+ * @async
+ * */
+export const queryGlobalFeed = async (query?: {
+  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 { 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'),
+        },
+      },
+    },
+  );
+
+  const { paging, ...payload } = data;
+  const { posts } = payload;
+
+  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 });
+  }
+
+  const nextPage = toPage(paging.next);
+  const prevPage = toPage(paging.previous);
+
+  return { data: posts, cachedAt, prevPage, nextPage };
+};
+
+/**
+ * ```js
+ * import { queryGlobalFeed } from '@amityco/ts-sdk'
+ * const posts = await queryGlobalFeed.locally()
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.Post} objects from cache
+ *
+ * @param query The query parameters
+ * @returns A page of {@link Amity.Post} objects
+ *
+ * @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);
+
+  if (!client.cache) return;
+
+  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) ?? {};
+
+  if (!data?.posts.length) return;
+
+  const posts: Amity.Post[] = data.posts
+    .map(postId => pullFromCache<Amity.Post>(['post', 'get', postId])!)
+    .filter(Boolean)
+    .map(({ data }) => data);
+
+  const prevPage = toPage(data?.paging.previous);
+  const nextPage = toPage(data?.paging.next);
+
+  return posts.length === data?.posts?.length
+    ? { data: posts, cachedAt, prevPage, nextPage }
+    : undefined;
+};

package/src/file/api/createFile.ts

@@ -0,0 +1,54 @@
+import { getActiveClient } from '~/client/api';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/**
+ * ```js
+ * import { createFile } from '@amityco/ts-sdk'
+ * const created = await createFile(formData)
+ * ```
+ *
+ * Creates an {@link Amity.File}
+ *
+ * @param formData The data necessary to create a new {@link Amity.File}
+ * @param onProgress The callback to track the upload progress
+ * @returns The newly created {@link Amity.File}
+ *
+ * @category File API
+ * @async
+ */
+export const createFile = async <T extends Amity.FileType = any>(
+  formData: FormData,
+  onProgress?: (percent: number) => void,
+): Promise<Amity.Cached<Amity.File[]>> => {
+  const client = getActiveClient();
+  client.log('file/createFile', formData);
+
+  if (!formData.getAll('files').length)
+    throw new Error('The formData object must have a `files` key.');
+
+  const headers =
+    'getHeaders' in formData
+      ? (formData as any).getHeaders()
+      : { 'content-type': 'multipart/form-data' };
+
+  const { data } = await client.http.post<Amity.CreateFilePayload<T>>('/api/v4/files', formData, {
+    headers,
+    onUploadProgress({ loaded, total }) {
+      onProgress && onProgress(Math.round((loaded * 100) / total));
+    },
+  });
+
+  // API-FIX: payload should be serialized properly
+  // const { files } = data
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache({ files: data }, { cachedAt });
+
+  return {
+    data,
+    cachedAt,
+  };
+};
+
+// TODO: consider doing local creation with URL.createObjectURL()

package/src/file/api/createImage.ts

@@ -0,0 +1,58 @@
+import { getActiveClient } from '~/client/api';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/**
+ * ```js
+ * import { createImage } from '@amityco/ts-sdk'
+ * const created = await createImage(formData)
+ * ```
+ *
+ * Creates an {@link Amity.File<'image'>}
+ *
+ * @param formData The data necessary to create a new {@link Amity.File<'image'>}
+ * @param onProgress The callback to track the upload progress
+ * @returns The newly created {@link Amity.File<'image'>}
+ *
+ * @category File API
+ * @async
+ */
+export const createImage = async (
+  formData: FormData,
+  onProgress?: (percent: number) => void,
+): Promise<Amity.Cached<Amity.File<'image'>[]>> => {
+  const client = getActiveClient();
+  client.log('file/createImage', formData);
+
+  if (!formData.getAll('files').length)
+    throw new Error('The formData object must have a `files` key.');
+
+  const headers =
+    'getHeaders' in formData
+      ? (formData as any).getHeaders()
+      : { 'content-type': 'multipart/form-data' };
+
+  const { data } = await client.http.post<Amity.CreateFilePayload<'image'>>(
+    '/api/v4/images',
+    formData,
+    {
+      headers,
+      onUploadProgress({ loaded, total }) {
+        onProgress && onProgress(Math.round((loaded * 100) / total));
+      },
+    },
+  );
+
+  // API-FIX: payload should be serialized properly
+  // const { files } = data
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache({ files: data }, { cachedAt });
+
+  return {
+    data,
+    cachedAt,
+  };
+};
+
+// TODO: consider doing local creation with URL.createObjectURL()

package/src/file/api/createVideo.ts

@@ -0,0 +1,64 @@
+import { getActiveClient } from '~/client/api';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/**
+ * ```js
+ * import { createVideo } from '@amityco/ts-sdk'
+ * const created = await createVideo(formData)
+ * ```
+ *
+ * Creates an {@link Amity.File<'video'>}
+ *
+ * @param formData The data necessary to create a new {@link Amity.File<'video'>}
+ * @param feedType The {@link Amity.File<'video'>} feed type
+ * @param onProgress The callback to track the upload progress
+ * @returns The newly created {@link Amity.File<'video'>}
+ *
+ * @category File API
+ * @async
+ */
+export const createVideo = async (
+  formData: FormData,
+  feedType?: Amity.ContentFeedType,
+  onProgress?: (percent: number) => void,
+): Promise<Amity.Cached<Amity.File<'video'>[]>> => {
+  const client = getActiveClient();
+  client.log('file/createVideo', formData);
+
+  if (!formData.getAll('files').length)
+    throw new Error('The formData object must have a `files` key.');
+
+  if (feedType) {
+    formData.append('feedType', feedType);
+  }
+
+  const headers =
+    'getHeaders' in formData
+      ? (formData as any).getHeaders()
+      : { 'content-type': 'multipart/form-data' };
+
+  const { data } = await client.http.post<Amity.CreateFilePayload<'video'>>(
+    '/api/v4/videos',
+    formData,
+    {
+      headers,
+      onUploadProgress({ loaded, total }) {
+        onProgress && onProgress(Math.round((loaded * 100) / total));
+      },
+    },
+  );
+
+  // API-FIX: payload should be serialized properly
+  // const { files } = data
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache({ files: data }, { cachedAt });
+
+  return {
+    data,
+    cachedAt,
+  };
+};
+
+// TODO: consider doing local creation with URL.createObjectURL()