@amityco/ts-sdk-react-native 7.2.0 → 7.3.0

package/src/notificationTray/events/onNotificationTraySeenUpdated.ts

@@ -0,0 +1,36 @@
+import { getActiveClient } from '~/client/api/activeClient';
+import { createEventSubscriber } from '~/core/events';
+
+/**
+ * ```js
+ * import { onNotificationTraySeenUpdated } from '@amityco/ts-sdk'
+ * const dispose = onNotificationTraySeenUpdated(data => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.NotificationTraySeen} has been updated
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category NotificationTraySeen Events
+ */
+export const onNotificationTraySeenUpdated = (
+  callback: Amity.Listener<Amity.InternalNotificationTraySeen>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const disposers = [
+    createEventSubscriber(
+      client,
+      'onNotificationTraySeenUpdated',
+      'local.notificationTraySeen.updated',
+      payload => callback(payload),
+    ),
+  ];
+
+  return () => {
+    disposers.forEach(fn => fn());
+  };
+};

package/src/notificationTray/index.ts

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

package/src/notificationTray/internalApi/getNotificationTraySeen.ts

@@ -0,0 +1,80 @@
+import { getActiveClient } from '~/client/api/activeClient';
+import { pullFromCache, pushToCache } from '~/cache/api';
+
+/* begin_public_function
+  id: notificationTray.getNotificationTraySeen
+*/
+/**
+ * ```js
+ * import { notificationTray } from '@amityco/ts-sdk'
+ * const notificationTraySeen = await notificationTray.getNotificationTraySeen()
+ * ```
+ *
+ *
+ * @returns A page of {@link Amity.NotificationTraySeen} objects
+ *
+ * @category NotificationTray API
+ * @async
+ * */
+export const getNotificationTraySeen = async (): Promise<
+  Amity.Cached<Amity.InternalNotificationTraySeen>
+> => {
+  const client = getActiveClient();
+  client.log('notificationTray/getNotificationTraySeen', {});
+
+  const { data: payload } = await client.http.get<Amity.NotificationTraySeenPayload>(
+    `api/v1/notification-tray/tray/seen`,
+  );
+
+  const cachedAt = client.cache && Date.now();
+
+  if (client.cache) {
+    const cacheKey = ['notificationTraySeen', 'get', client.userId];
+    pushToCache(cacheKey, {
+      userId: client.userId,
+      lastTraySeenAt: payload.lastTraySeenAt,
+      lastTrayOccuredAt: payload.lastTrayOccurredAt,
+    });
+  }
+
+  return {
+    data: {
+      userId: client.userId!,
+      lastTraySeenAt: payload.lastTraySeenAt,
+      lastTrayOccurredAt: payload.lastTrayOccurredAt,
+      isSeen: payload.lastTraySeenAt > payload.lastTrayOccurredAt,
+    },
+    cachedAt,
+  };
+};
+/* end_public_function */
+
+/**
+ * ```js
+ * import { notificationTray } from '@amityco/ts-sdk'
+ * const notificationTraySeen = await notificationTray.getNotificationTraySeen.locally()
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.NotificationTraySeen} objects from cache
+ *
+ * @returns A page of {@link Amity.NotificationTraySeen} objects
+ *
+ * @category NotificationTray API
+ * @async
+ * */
+getNotificationTraySeen.locally = ():
+  | Amity.Cached<Amity.InternalNotificationTraySeen>
+  | undefined => {
+  const client = getActiveClient();
+  client.log('notificationTray/getNotificationTraySeen.locally', {});
+
+  if (!client.cache) return;
+
+  const queryKey = ['notificationTraySeen', 'get'];
+
+  const { data, cachedAt } = pullFromCache<Amity.InternalNotificationTraySeen>(queryKey) ?? {};
+
+  if (!data) return;
+
+  return { data, cachedAt };
+};

package/src/notificationTray/observers/getNotificationTrayItems/NotificationTrayItemsLiveCollectionController.ts

@@ -0,0 +1,96 @@
+import hash from 'object-hash';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { NotificationTrayItemsPaginationController } from './NotificationTrayItemsPaginationController';
+import { NotificationTrayItemsQuerystreamController } from './NotificationTrayItemsQuerystreamController';
+import { LiveCollectionController } from '~/core/liveCollection/LiveCollectionController';
+import { prepareNotificationTrayItemsPayload } from '~/notificationTray/utils/prepareNotificationTrayItemsPayload';
+import { isNonNullable } from '~/utils';
+import { LinkedObject } from '~/utils/linkedObject';
+
+export class NotificationTrayItemsLiveCollectionController extends LiveCollectionController<
+  'notificationTrayItem',
+  Amity.NotificationTrayItemLiveCollection,
+  Amity.NotificationTrayItem,
+  NotificationTrayItemsPaginationController
+> {
+  private queryStreamController: NotificationTrayItemsQuerystreamController;
+
+  private query: Amity.NotificationTrayItemLiveCollection;
+
+  constructor(
+    query: Amity.NotificationTrayItemLiveCollection,
+    callback: Amity.LiveCollectionCallback<Amity.NotificationTrayItem>,
+  ) {
+    const queryStreamId = hash(query);
+    const cacheKey = ['notificationTrayItem', 'collection', queryStreamId];
+    const paginationController = new NotificationTrayItemsPaginationController(query);
+
+    super(paginationController, queryStreamId, cacheKey, callback);
+
+    this.query = query;
+    this.queryStreamController = new NotificationTrayItemsQuerystreamController(
+      this.query,
+      this.cacheKey,
+      this.notifyChange.bind(this),
+      prepareNotificationTrayItemsPayload,
+    );
+
+    this.callback = callback.bind(this);
+    this.loadPage({ initial: true });
+  }
+
+  protected setup() {
+    const collection = pullFromCache<Amity.NotificationTrayItemLiveCollectionCache>(
+      this.cacheKey,
+    )?.data;
+    if (!collection) {
+      pushToCache(this.cacheKey, {
+        data: [],
+        params: {},
+      });
+    }
+  }
+
+  protected async persistModel(queryPayload: Amity.NotificationTrayPayload & Amity.Pagination) {
+    await this.queryStreamController.saveToMainDB(queryPayload);
+  }
+
+  protected persistQueryStream({
+    response,
+    direction,
+    refresh,
+  }: Amity.LiveCollectionPersistQueryStreamParams<'notificationTrayItem'>) {
+    this.queryStreamController.appendToQueryStream(response, direction, refresh);
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  startSubscription() {
+    return [] as Amity.Unsubscriber[];
+  }
+
+  notifyChange({ origin, loading, error }: Amity.LiveCollectionNotifyParams) {
+    const collection = pullFromCache<Amity.NotificationTrayItemLiveCollectionCache>(
+      this.cacheKey,
+    )?.data;
+    if (!collection) return;
+
+    const data = (
+      collection.data
+        .map(id =>
+          pullFromCache<Amity.InternalNotificationTrayItem>(['notificationTrayItem', 'get', id]),
+        )
+        .filter(isNonNullable)
+        .map(({ data }) => data) ?? []
+    ).map(LinkedObject.notificationTray);
+
+    if (!this.shouldNotify(data) && origin === 'event') return;
+
+    this.callback({
+      onNextPage: () => this.loadPage({ direction: Amity.LiveCollectionPageDirection.NEXT }),
+      data,
+      hasNextPage: !!this.paginationController.getNextToken(),
+      loading,
+      error,
+    });
+  }
+}

package/src/notificationTray/observers/getNotificationTrayItems/NotificationTrayItemsPaginationController.ts

@@ -0,0 +1,31 @@
+import { PaginationController } from '~/core/liveCollection/PaginationController';
+import { COLLECTION_DEFAULT_PAGINATION_LIMIT } from '~/utils/constants';
+
+/**
+ * TODO: handle cache receive cache option, and cache policy
+ * TODO: check if querybyIds is supported
+ */
+export class NotificationTrayItemsPaginationController extends PaginationController<
+  'notificationTrayItem',
+  Amity.NotificationTrayItemLiveCollection
+> {
+  async getRequest(
+    queryParams: Amity.NotificationTrayItemLiveCollection,
+    token: string | undefined,
+  ) {
+    const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT, ...params } = queryParams;
+
+    const options = token ? { token } : { limit };
+
+    const { data: queryResponse } = await this.http.get<
+      Amity.NotificationTrayPayload & Amity.Pagination
+    >(`/api/v1/notification-tray`, {
+      params: {
+        ...params,
+        options,
+      },
+    });
+
+    return queryResponse;
+  }
+}

package/src/notificationTray/observers/getNotificationTrayItems/NotificationTrayItemsQuerystreamController.ts

@@ -0,0 +1,68 @@
+import { QueryStreamController } from '~/core/liveCollection/QueryStreamController';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { getResolver } from '~/core/model';
+import { getActiveClient } from '~/client';
+
+export class NotificationTrayItemsQuerystreamController extends QueryStreamController<
+  Amity.NotificationTrayPayload,
+  Amity.NotificationTrayItemLiveCollection
+> {
+  private notifyChange: (params: Amity.LiveCollectionNotifyParams) => void;
+
+  private preparePayload: (
+    response: Amity.NotificationTrayPayload,
+  ) => Amity.ProcessedNotificationTrayPayload;
+
+  constructor(
+    query: Amity.NotificationTrayItemLiveCollection,
+    cacheKey: string[],
+    notifyChange: (params: Amity.LiveCollectionNotifyParams) => void,
+    preparePayload: (
+      response: Amity.NotificationTrayPayload,
+    ) => Amity.ProcessedNotificationTrayPayload,
+  ) {
+    super(query, cacheKey);
+    this.notifyChange = notifyChange;
+    this.preparePayload = preparePayload;
+  }
+
+  async saveToMainDB(response: Amity.NotificationTrayPayload) {
+    const processedPayload = await this.preparePayload(response);
+
+    const client = getActiveClient();
+    const cachedAt = client.cache && Date.now();
+
+    if (client.cache) {
+      ingestInCache(processedPayload, { cachedAt });
+    }
+  }
+
+  appendToQueryStream(
+    response: Amity.NotificationTrayPayload & Partial<Amity.Pagination>,
+    direction: Amity.LiveCollectionPageDirection,
+    refresh = false,
+  ) {
+    if (refresh) {
+      pushToCache(this.cacheKey, {
+        data: response.notificationTrayItems.map(getResolver('notificationTrayItem')),
+      });
+    } else {
+      const collection = pullFromCache<Amity.NotificationTrayItemLiveCollectionCache>(
+        this.cacheKey,
+      )?.data;
+
+      const notifications = collection?.data ?? [];
+
+      pushToCache(this.cacheKey, {
+        ...collection,
+        data: [
+          ...new Set([
+            ...notifications,
+            ...response.notificationTrayItems.map(getResolver('notificationTrayItem')),
+          ]),
+        ],
+      });
+    }
+  }
+}

package/src/notificationTray/observers/getNotificationTrayItems.ts

@@ -0,0 +1,44 @@
+import { getActiveClient } from '~/client/api';
+import { dropFromCache } from '~/cache/api';
+import { ENABLE_CACHE_MESSAGE } from '~/utils/constants';
+import { NotificationTrayItemsLiveCollectionController } from './getNotificationTrayItems/NotificationTrayItemsLiveCollectionController';
+
+/**
+ * Get notification tray items for a notification tray page
+ *
+ * @param params the limit query parameters
+ * @param callback the callback to be called when the notification tray items are updated
+ * @returns items in the notification tray
+ *
+ * @category Notification tray items Live Collection
+ *
+ */
+export const getNotificationTrayItems = (
+  params: Amity.LiveCollectionParams<Amity.NotificationTrayItemLiveCollection>,
+  callback: Amity.LiveCollectionCallback<Amity.NotificationTrayItem>,
+  config?: Amity.LiveCollectionConfig,
+) => {
+  const { log, cache } = getActiveClient();
+
+  if (!cache) {
+    console.log(ENABLE_CACHE_MESSAGE);
+  }
+
+  const timestamp = Date.now();
+  log(`getNotificationTrayItems(tmpid: ${timestamp}) > listen`);
+
+  const notiTrayItemsLiveCollection = new NotificationTrayItemsLiveCollectionController(
+    params,
+    callback,
+  );
+  const disposers = notiTrayItemsLiveCollection.startSubscription();
+
+  const cacheKey = notiTrayItemsLiveCollection.getCacheKey();
+
+  disposers.push(() => dropFromCache(cacheKey));
+
+  return () => {
+    log(`getNotificationTrayItems(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/notificationTray/observers/getNotificationTraySeen.ts

@@ -0,0 +1,60 @@
+import { liveObject } from '~/utils/liveObject';
+import { getNotificationTraySeen as _getNotificationTraySeen } from '../internalApi/getNotificationTraySeen';
+import { onNotificationTraySeenUpdated } from '../events/onNotificationTraySeenUpdated';
+import { getActiveUser } from '~/client';
+import { convertDateStringToTimestamp } from '~/utils/dateTime';
+
+/* begin_public_function
+  id: notificationTray.getNotificationTraySeen
+*/
+/**
+ * ```js
+ * import { notificationTray } from '@amityco/ts-sdk';
+ *
+ * let notificationTraySeen;
+ *
+ * const unsubscribe = getNotificationTraySeen(response => {
+ *   notificationTraySeen = response.data;
+ * });
+ * ```
+ *
+ * Observe all mutation on a given {@link Amity.NotificationTraySeen}
+ *
+ * @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 message
+ *
+ * @category NotificationTraySeen Live Object
+ */
+export const getNotificationTraySeen = (
+  callback: Amity.LiveObjectCallback<Amity.NotificationTraySeen>,
+): Amity.Unsubscriber => {
+  const { userId } = getActiveUser();
+  return liveObject(
+    userId,
+    callback,
+    'userId',
+    _getNotificationTraySeen,
+    [onNotificationTraySeenUpdated],
+    {
+      callbackDataSelector: (data: Amity.InternalNotificationTraySeen) => {
+        let isSeen = true;
+
+        if (data?.lastTrayOccurredAt) {
+          if (!data.lastTraySeenAt) {
+            isSeen = false;
+          } else {
+            isSeen =
+              convertDateStringToTimestamp(data.lastTraySeenAt) >
+              convertDateStringToTimestamp(data.lastTrayOccurredAt);
+          }
+        }
+        return {
+          lastTrayOccurredAt: data?.lastTrayOccurredAt,
+          lastTraySeenAt: data?.lastTraySeenAt,
+          isSeen,
+        };
+      },
+    },
+  );
+};
+/* end_public_function */

package/src/notificationTray/observers/index.ts

@@ -0,0 +1,2 @@
+export * from './getNotificationTraySeen';
+export * from './getNotificationTrayItems';

package/src/notificationTray/utils/prepareNotificationTrayItemsPayload.ts

@@ -0,0 +1,12 @@
+import { convertRawUserToInternalUser } from '~/userRepository/utils/convertRawUserToInternalUser';
+
+export const prepareNotificationTrayItemsPayload = (
+  rawPayload: Amity.NotificationTrayPayload,
+): Amity.ProcessedNotificationTrayPayload => {
+  const users = rawPayload.users.map(convertRawUserToInternalUser);
+
+  return {
+    ...rawPayload,
+    users,
+  };
+};

package/src/utils/linkedObject/index.ts

@@ -10,6 +10,7 @@ import { reactorLinkedObject } from './reactorLinkedObject';
 import { channelLinkedObject } from './channelLinkedObject';
 import { adLinkedObject } from './adLinkedObject';
 import { pinnedPostLinkedObject } from './pinnedPostLinkedObject';
+import { notificationTrayLinkedObject } from './notificationTrayLinkedObject';
 
 export const LinkedObject = {
   ad: adLinkedObject,
@@ -24,4 +25,5 @@ export const LinkedObject = {
   reactor: reactorLinkedObject,
   channel: channelLinkedObject,
   pinnedPost: pinnedPostLinkedObject,
+  notificationTray: notificationTrayLinkedObject,
 };

package/src/utils/linkedObject/notificationTrayLinkedObject.ts

@@ -0,0 +1,19 @@
+import { pullFromCache } from '~/cache/api';
+import { isNonNullable } from '..';
+import { WEEK } from '../constants';
+import { userLinkedObject } from './userLinkedObject';
+
+export const notificationTrayLinkedObject = (
+  noti: Amity.InternalNotificationTrayItem,
+): Amity.NotificationTrayItem => {
+  return {
+    ...noti,
+    isSeen: noti.lastSeenAt > noti.lastOccurredAt,
+    isRecent: new Date(noti.lastOccurredAt).getTime() >= Date.now() - WEEK,
+    users: noti.actors
+      .map(({ publicId }) => pullFromCache<Amity.InternalUser>(['user', 'get', publicId])!)
+      .filter(isNonNullable)
+      .map(({ data }) => data)
+      .map(user => userLinkedObject(user)),
+  };
+};