@amityco/ts-sdk 7.10.1-86aa7706.0 → 7.10.1-9fe9d33d.0

package/src/client/events/onConnectionError.ts

@@ -0,0 +1,46 @@
+import { getActiveClient } from '~/client/api/activeClient';
+
+import { createEventSubscriber } from '~/core/events';
+
+import { ASCError, ASCConnectionError } from '~/core/errors';
+
+const EVENTS = [
+  'disconnected',
+  'error',
+  'connect_error',
+  'reconnect_error',
+  'reconnect_failed',
+] as const;
+
+/**
+ * ```js
+ * import { onConnectionError } from '@amityco/ts-sdk'
+ * const dispose = onClientBanned(() => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.Client} have been banned from the platform
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Client Events
+ */
+export const onConnectionError = (callback: Amity.Listener<ASCError>): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const subscribers = EVENTS.map(event =>
+    createEventSubscriber(client, `client/onConnectionError(${event})`, event, response => {
+      const error = response?.code
+        ? new ASCError(response.message, response.code, Amity.ErrorLevel.FATAL)
+        : new ASCConnectionError(event);
+
+      callback(error);
+    }),
+  );
+
+  return () => {
+    subscribers.forEach(fn => fn());
+  };
+};

package/src/client/events/onNetworkActivities.ts

@@ -0,0 +1,22 @@
+import NetworkActivitiesWatcher from '~/client/utils/NetworkActivitiesWatcher';
+
+/**
+ *
+ * Fired when any {@link Amity.Client} has a session state change
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Client Events
+ */
+export const onNetworkActivities = (
+  callback: (
+    request: Request,
+    response: {
+      data: unknown;
+      status: number;
+      statusText: string;
+      headers: Headers;
+    },
+  ) => void,
+): Amity.Unsubscriber => NetworkActivitiesWatcher.getInstance().onNetworkActivities(callback);

package/src/client/events/onSessionStateChange.ts

@@ -0,0 +1,20 @@
+import SessionWatcher from '~/client/utils/SessionWatcher';
+
+/**
+ * ```js
+ * import { onSessionStateChange } from '@amityco/ts-sdk'
+ * const dispose = onSessionStateChange((state: Amity.SessionStates) => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.Client} has a session state change
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Client Events
+ */
+export const onSessionStateChange = (
+  callback: Amity.Listener<Amity.SessionStates>,
+): Amity.Unsubscriber => SessionWatcher.getInstance().onSessionStateChange(callback);

package/src/client/events/onTokenExpired.ts

@@ -0,0 +1,26 @@
+import { getActiveClient } from '~/client/api/activeClient';
+
+import { createEventSubscriber } from '~/core/events';
+
+/**
+ * ```js
+ * import { onTokenExpired } from '@amityco/ts-sdk'
+ * const dispose = onTokenExpired((state: Amity.SessionStates.TOKEN_EXPIRED) => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.Client} session state has expired
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category private
+ */
+export const onTokenExpired = (
+  callback: Amity.Listener<Amity.SessionStates.TOKEN_EXPIRED>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  return createEventSubscriber(client, `client/onTokenExpired`, 'tokenExpired', callback);
+};

package/src/client/events/onTokenTerminated.ts

@@ -0,0 +1,20 @@
+import { getActiveClient } from '~/client/api/activeClient';
+
+import { createEventSubscriber } from '~/core/events';
+
+/**
+ *
+ * Fired when any {@link Amity.Client} session state has terminated
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category private
+ */
+export const onTokenTerminated = (
+  callback: Amity.Listener<Amity.SessionStates.TERMINATED>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  return createEventSubscriber(client, `client/onTokenTerminated`, 'tokenTerminated', callback);
+};

package/src/client/events/tests/onSessionStateChange.test.ts

@@ -0,0 +1,33 @@
+import { connectClient, disconnectClient } from '~/utils/tests';
+import { setSessionState } from '~/client/api/setSessionState';
+import { onSessionStateChange } from '../onSessionStateChange';
+
+describe('onSessionStateChange', () => {
+  beforeAll(async () => {
+    await connectClient();
+  });
+
+  afterAll(async () => {
+    await disconnectClient();
+  });
+
+  test('it should call callback on event', () => {
+    const callback = jest.fn();
+    const expected = Amity.SessionStates.ESTABLISHED;
+
+    const unsub = onSessionStateChange(callback);
+    setSessionState(expected);
+    expect(callback).toHaveBeenCalledWith(expected);
+    unsub();
+  });
+
+  test('it should not call callback if unsubscribed', () => {
+    const callback = jest.fn();
+    const state = Amity.SessionStates.ESTABLISHED;
+
+    const unsub = onSessionStateChange(callback);
+    unsub();
+    setSessionState(state);
+    expect(callback).not.toHaveBeenCalled();
+  });
+});

package/src/client/events/tests/onTokenTerminated.test.ts

@@ -0,0 +1,37 @@
+import { client, connectClient, disconnectClient } from '~/utils/tests';
+
+import { onTokenTerminated } from '../onTokenTerminated';
+
+describe('onTokenTerminated', () => {
+  beforeAll(async () => {
+    await connectClient();
+  });
+
+  afterAll(async () => {
+    await disconnectClient();
+  });
+
+  test('it should call callback on event', () => {
+    const callback = jest.fn();
+    const expected = Amity.SessionStates.TERMINATED;
+
+    const unsub = onTokenTerminated(callback);
+    client.emitter.emit('tokenTerminated', expected);
+
+    expect(callback).toHaveBeenCalledWith(expected);
+
+    unsub();
+  });
+
+  test('it should not call callback if unsubscribed', () => {
+    const callback = jest.fn();
+    const state = Amity.SessionStates.TERMINATED;
+
+    const unsub = onTokenTerminated(callback);
+    unsub();
+
+    client.emitter.emit('tokenTerminated', state);
+
+    expect(callback).not.toHaveBeenCalled();
+  });
+});

package/src/client/index.ts

@@ -0,0 +1,4 @@
+export * from './api';
+export * from './events';
+export * from './observers';
+export * from './utils/markerSyncEngine';

package/src/client/observers/getUserUnread.ts

@@ -0,0 +1,156 @@
+import { ASCApiError, ASCError } from '~/core/errors';
+import { getUserMarker } from '~/marker/api';
+import { onUserMarkerFetched } from '~/marker/events';
+
+import { getActiveClient, getActiveUser } from '../api';
+import { createQuery, runQuery } from '~/core/query';
+import {
+  UNSYNCED_OBJECT_CACHED_AT_MESSAGE,
+  UNSYNCED_OBJECT_CACHED_AT_VALUE,
+} from '~/utils/constants';
+
+import { isEqual } from '~/utils/isEqual';
+import { convertGetterPropsToStatic } from '~/utils/object';
+
+/**
+ *
+ * ```js
+ * import { getUserUnread } from '@amityco/ts-sdk';
+ *
+ * const unsubscribe = getUserUnread(response => {
+ *   userUnread = response.data;
+ * });
+ * ```
+ *
+ * Observe current user's unread including unreadCount and hasMentioned from {@link Amity.UserMarker}
+ *
+ * @param callback the function to call when new data are available
+ * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the events
+ *
+ * @category Message Live Object
+ */
+export const getUserUnread = (
+  callback: Amity.LiveObjectCallback<Amity.UserUnread | undefined>,
+): Amity.Unsubscriber => {
+  const { _id: userId } = getActiveUser();
+
+  if (!userId)
+    throw new ASCError(
+      'The _id has not been defined in ActiveUser',
+      Amity.ClientError.UNKNOWN_ERROR,
+      Amity.ErrorLevel.ERROR,
+    );
+
+  const { log, cache } = getActiveClient();
+
+  if (!cache) {
+    console.log('For using Live Object feature you need to enable Cache!');
+  }
+
+  const timestamp = Date.now();
+  log(`liveUserUnread(tmpid: ${timestamp}) > listen`);
+
+  const disposers: Amity.Unsubscriber[] = [];
+
+  let isUnsyncedModel = false; // for messages
+
+  let model: Omit<Amity.UserUnread, 'hasMentioned'> | undefined;
+
+  const dispatcher = (data: Amity.LiveObject<Amity.UserMarker | undefined>) => {
+    const { data: userUnread } = data;
+
+    const callbackModel = userUnread
+      ? {
+          unreadCount: userUnread.unreadCount,
+          isMentioned: userUnread.isMentioned,
+        }
+      : undefined;
+
+    model = callbackModel ? convertGetterPropsToStatic(callbackModel) : callbackModel;
+
+    callback({
+      data: callbackModel
+        ? { ...callbackModel, isMentioned: callbackModel.isMentioned }
+        : callbackModel,
+
+      loading: data.loading,
+      error: data.error,
+    });
+  };
+
+  const realtimeRouter = (userMarkers: Amity.UserMarker[]) => {
+    const filterUserMarkers = userMarkers.filter(userMarker => userId === userMarker.userId);
+
+    const latestUserMarker = filterUserMarkers.reduce((currentMaxUserMarker, userMarker) => {
+      if (
+        currentMaxUserMarker == null ||
+        new Date(userMarker.lastSyncAt).getTime() >
+          new Date(currentMaxUserMarker.lastSyncAt).getTime()
+      ) {
+        return userMarker;
+      }
+      return currentMaxUserMarker;
+    }, null as Amity.UserMarker | null);
+
+    const eventModel = {
+      unreadCount: latestUserMarker?.unreadCount ?? 0,
+      isMentioned: filterUserMarkers.some(userMarker => !!userMarker.isMentioned),
+    } as Amity.UserMarker;
+
+    if (isEqual(model, eventModel)) return;
+
+    dispatcher({
+      loading: false,
+      data: eventModel,
+    });
+  };
+
+  function isAmityUserMarkerData(data: unknown): data is Amity.UserMarker {
+    /**
+     * The `data` return from runQuery is Amity.UserMarker | undefined.
+     * It's not located inside data field
+     */
+    if (data == null) return false;
+    return (data as { data: Amity.UserMarker }) != null;
+  }
+
+  const onFetch = () => {
+    const query = createQuery(getUserMarker);
+
+    runQuery(query, ({ error, data, loading, origin, cachedAt }) => {
+      if (!isAmityUserMarkerData(data)) {
+        dispatcher({ loading, data: undefined, origin, error });
+        return;
+      }
+      if (cachedAt === UNSYNCED_OBJECT_CACHED_AT_VALUE) {
+        dispatcher({
+          data,
+          origin,
+          loading: false,
+          error: new ASCApiError(
+            UNSYNCED_OBJECT_CACHED_AT_MESSAGE,
+            Amity.ClientError.DISALOOW_UNSYNCED_OBJECT,
+            Amity.ErrorLevel.ERROR,
+          ),
+        });
+
+        isUnsyncedModel = true;
+        disposers.forEach(fn => fn());
+      } else if (!isUnsyncedModel) {
+        dispatcher({ loading, data, origin, error });
+      }
+
+      if (error) {
+        disposers.forEach(fn => fn());
+      }
+    });
+  };
+
+  disposers.push(onUserMarkerFetched(userMarkers => realtimeRouter(userMarkers)));
+
+  onFetch();
+
+  return () => {
+    disposers.forEach(fn => fn());
+  };
+};

package/src/client/observers/index.ts

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

package/src/client/utils/GlobalFileAccessType.ts

@@ -0,0 +1,23 @@
+import { FileAccessTypeEnum } from '~/@types';
+
+export class GlobalFileAccessType {
+  #fileAccessType: Amity.FileAccessType = FileAccessTypeEnum.PUBLIC;
+
+  public setFileAccessType(fileAccessType: Amity.FileAccessType) {
+    this.#fileAccessType = fileAccessType;
+  }
+
+  public getFileAccessType() {
+    return this.#fileAccessType;
+  }
+}
+
+let instance: GlobalFileAccessType;
+export default {
+  getInstance: () => {
+    if (!instance) {
+      instance = new GlobalFileAccessType();
+    }
+    return instance;
+  },
+};

package/src/client/utils/NetworkActivitiesWatcher.ts

@@ -0,0 +1,47 @@
+type NetworkActivitiesCallback = (
+  request: Request,
+  response: {
+    data: unknown;
+    status: number;
+    statusText: string;
+    headers: Headers;
+  },
+) => void;
+
+class NetworkActivitiesWatcher {
+  private _listener = new Map<NetworkActivitiesCallback, NetworkActivitiesCallback>();
+
+  onNetworkActivities(callback: NetworkActivitiesCallback) {
+    this._listener.set(callback, callback);
+    return () => {
+      this._listener.delete(callback);
+    };
+  }
+
+  setNetworkActivities(
+    request: Request,
+    response: {
+      data: unknown;
+      status: number;
+      statusText: string;
+      headers: Headers;
+    },
+  ) {
+    this._listener.forEach(cb => cb(request, response));
+  }
+
+  destroy() {
+    this._listener.clear();
+  }
+}
+
+let instance: NetworkActivitiesWatcher;
+
+export default {
+  getInstance: () => {
+    if (!instance) {
+      instance = new NetworkActivitiesWatcher();
+    }
+    return instance;
+  },
+};

package/src/client/utils/ObjectResolver/objectResolverEngine.ts

@@ -0,0 +1,144 @@
+import { onOnline } from '../onOnline';
+
+import { onOffline } from '../onOffline';
+import { SECOND } from '~/utils/constants';
+import { resolveChannels } from '~/channelRepository/utils/resolveChannels';
+import { resolveUserMessageFeedMarkers } from '~/marker/utils/resolveUserMessageFeedMakers';
+
+class ObjectResolverEngine {
+  private readonly TIMER_INTERVAL_MS = SECOND;
+
+  private readonly BUFFER_ID_LIMIT = 100;
+
+  private buffer: Amity.ObjectIdBuffer = {
+    [Amity.ReferenceType.CHANNEL]: [],
+    [Amity.ReferenceType.USER_MESSAGE_FEED_MARKER]: [],
+  };
+
+  private timer: NodeJS.Timer | undefined;
+
+  private isResolvingTask = false;
+
+  private connectionListener: (() => void)[] = [];
+
+  private isConnected = true;
+
+  constructor() {
+    this.addConnectionListener();
+  }
+
+  startResolver() {
+    if (!this.timer) {
+      this.timer = setInterval(() => {
+        if (this.isConnected) this.resolveObjects();
+      }, this.TIMER_INTERVAL_MS);
+    }
+  }
+
+  stopResolver() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = undefined;
+    }
+  }
+
+  resolve(id: string, referenceType: Amity.ReferenceType) {
+    const objectIdList = this.getBuffer(referenceType);
+
+    if (objectIdList.includes(id)) return;
+
+    if (objectIdList.length >= this.BUFFER_ID_LIMIT) {
+      objectIdList.shift(); // Remove first element of the array
+    }
+
+    objectIdList.push(id);
+  }
+
+  private addConnectionListener() {
+    if (this.connectionListener.length > 0) return;
+    this.connectionListener.push(
+      onOnline(() => {
+        this.isConnected = true;
+      }),
+    );
+
+    this.connectionListener.push(
+      onOffline(() => {
+        this.isConnected = false;
+      }),
+    );
+  }
+
+  private removeConnectionListener() {
+    if (this.connectionListener.length > 0) this.connectionListener.forEach(listener => listener());
+  }
+
+  private resolveObjects() {
+    if (this.isResolvingTask) {
+      return;
+    }
+
+    this.isResolvingTask = true;
+
+    // Get first 100 ids for all reference type supported.
+    const channelIds = this.getBuffer(Amity.ReferenceType.CHANNEL);
+    const userMessageFeedMarkerIds = this.getBuffer(Amity.ReferenceType.USER_MESSAGE_FEED_MARKER);
+
+    // Clear buffer
+    this.clearBuffer();
+
+    // Send Requests.
+    // Incase of failure: Ignore
+    // Incase of success: Persist in Domain DB & Notify Live collection
+    if (channelIds.length > 0) resolveChannels(channelIds);
+    if (userMessageFeedMarkerIds.length > 0)
+      resolveUserMessageFeedMarkers(userMessageFeedMarkerIds);
+
+    // After sending request
+    this.isResolvingTask = false;
+  }
+
+  private clearBuffer() {
+    this.buffer = {
+      [Amity.ReferenceType.CHANNEL]: [],
+      [Amity.ReferenceType.USER_MESSAGE_FEED_MARKER]: [],
+    };
+  }
+
+  private getBuffer(referenceType: Amity.ReferenceType) {
+    return this.buffer[referenceType];
+  }
+
+  // Session Management : SessionComponent
+  onSessionEstablished() {
+    this.startResolver();
+    this.addConnectionListener();
+  }
+
+  onSessionDestroyed() {
+    // Stop timer
+    this.stopResolver();
+
+    // Clear buffer
+    this.clearBuffer();
+
+    // Reset state
+    this.isResolvingTask = false;
+
+    // remove connection listener
+    this.removeConnectionListener();
+  }
+
+  onTokenExpired() {
+    this.stopResolver();
+  }
+}
+
+let instance: ObjectResolverEngine | null = null;
+
+export default {
+  getInstance: () => {
+    if (!instance) instance = new ObjectResolverEngine();
+    return instance;
+  },
+};

package/src/client/utils/ObjectResolver/objectResolverEngineOnLoginHandler.ts

@@ -0,0 +1,21 @@
+import { onSessionStateChange } from '~/client/events/onSessionStateChange';
+import ObjectResolverEngine from './objectResolverEngine';
+
+export default () => {
+  const objectResolverEngine = ObjectResolverEngine.getInstance();
+  objectResolverEngine.startResolver();
+
+  onSessionStateChange(state => {
+    if (state === Amity.SessionStates.ESTABLISHED) {
+      objectResolverEngine.onSessionEstablished();
+    } else if (state === Amity.SessionStates.TOKEN_EXPIRED) {
+      objectResolverEngine.onTokenExpired();
+    } else {
+      objectResolverEngine.onSessionDestroyed();
+    }
+  });
+
+  return () => {
+    objectResolverEngine.onSessionDestroyed();
+  };
+};