@amityco/ts-sdk 6.35.3-f8f74ab5.0 → 6.35.3

package/src/analytic/service/analytic/AnalyticsEventCapturer.ts

@@ -0,0 +1,225 @@
+import { upsertInCache } from '~/cache/api/upsertInCache';
+import { pullFromCache } from '~/cache/api/pullFromCache';
+import { DAY, MINUTE } from '~/utils/constants';
+import { dropFromCache, pushToCache } from '~/cache/api';
+import { fireEvent } from '~/core/events';
+import { STORY_KEY_CACHE } from '~/storyRepository/constants';
+import { ANALYTIC_CACHE_KEY, HIGH_PRIORITY_ANALYTIC_CACHE_KEY } from '../../constant';
+
+export class AnalyticsEventCapturer {
+  _expireTime = 5 * MINUTE;
+
+  _poolLimit = 1000;
+
+  _recentViewed: { [key: Amity.InternalPost['postId']]: Date } = {};
+
+  _recentHighPriorityViewed: { [key: Amity.InternalStory['storyId']]: Date } = {};
+
+  // Story
+  _throttleStoryTimer: NodeJS.Timeout | undefined = undefined;
+
+  _bufferNewSeenStoryReferenceIds: Amity.Story['referenceId'][] = [];
+
+  isAbleToEnqueue({
+    uniqueId,
+    expireTime,
+    isHighPriority = false,
+  }: {
+    uniqueId: string;
+    expireTime: number;
+    isHighPriority?: boolean;
+  }) {
+    const now = new Date();
+
+    const getRecentViewedDate = () => {
+      if (isHighPriority) return this._recentHighPriorityViewed[uniqueId];
+      return this._recentViewed[uniqueId];
+    };
+
+    const recentViewedDate = getRecentViewedDate() || new Date(DAY * -1);
+
+    const timeDiff = now.getTime() - recentViewedDate.getTime();
+
+    if (timeDiff < expireTime) {
+      // just recently view this post, ignore the event.
+      return false;
+    }
+
+    return true;
+  }
+
+  markAs({
+    uniqueId,
+    contentId,
+    contentType,
+    activityType,
+    metadata,
+  }: {
+    uniqueId: string;
+    contentId: string;
+    contentType: Amity.AnalyticEventContentType;
+    activityType: Amity.AnalyticEventActivityType;
+    metadata?: Record<string, string>;
+  }) {
+    if (!this.isAbleToEnqueue({ uniqueId, expireTime: this._expireTime })) return;
+
+    const now = new Date();
+
+    const currentData: { event: Amity.AnalyticEventModel[] } = { event: [] };
+    const cache = pullFromCache<{ event: Amity.AnalyticEventModel[] }>(ANALYTIC_CACHE_KEY);
+
+    if (cache?.data) {
+      currentData.event = cache.data.event;
+    }
+
+    // If the pool is full (Max 1000 items), remove the oldest data
+    if (currentData.event.length >= this._poolLimit) {
+      // Remove oldest data
+      currentData.event.shift();
+    }
+
+    const analyticItem: Amity.AnalyticEventModel = {
+      contentId,
+      contentType,
+      activityType,
+      timestamp: now.toISOString(),
+    };
+
+    if (metadata) {
+      analyticItem.metadata = metadata;
+    }
+
+    currentData.event.push(analyticItem);
+
+    upsertInCache(ANALYTIC_CACHE_KEY, currentData);
+    this._recentViewed[uniqueId] = now;
+  }
+
+  markPostAsViewed(postId: Amity.InternalPost['postId']) {
+    this.markAs({
+      uniqueId: postId,
+      contentId: postId,
+      contentType: Amity.AnalyticEventContentType.Post,
+      activityType: Amity.AnalyticEventActivityType.View,
+    });
+  }
+
+  markStory(story: Amity.InternalStory, activityType: Amity.AnalyticEventActivityType) {
+    if (!story.expiresAt) return;
+    const now = new Date();
+    const expireTime = new Date(story.expiresAt);
+
+    if (
+      !this.isAbleToEnqueue({
+        uniqueId: story.storyId,
+        expireTime: expireTime.getTime(),
+        isHighPriority: true,
+      })
+    )
+      return;
+
+    const currentData: { event: Amity.AnalyticEventModel[] } = { event: [] };
+
+    const cache = pullFromCache<{ event: Amity.AnalyticEventModel[] }>(
+      HIGH_PRIORITY_ANALYTIC_CACHE_KEY,
+    );
+
+    if (cache?.data) {
+      currentData.event = cache.data.event;
+    }
+
+    // If the pool is full (Max 1000 items), remove the oldest data
+    if (currentData.event.length >= this._poolLimit) {
+      // Remove oldest data
+      currentData.event.shift();
+    }
+
+    currentData.event.push({
+      contentId: story.storyId,
+      contentType: Amity.AnalyticEventContentType.Story,
+      activityType,
+      timestamp: now.toISOString(),
+    });
+
+    upsertInCache(HIGH_PRIORITY_ANALYTIC_CACHE_KEY, currentData);
+    this._recentHighPriorityViewed[story.storyId] = now;
+
+    // Fire internal event if the activity type is not click
+    if (activityType === Amity.AnalyticEventActivityType.Click) return;
+
+    // Mark story as SEEN
+    pushToCache([STORY_KEY_CACHE.IS_SEEN, 'get', story.storyId], new Date().toISOString());
+
+    // Update the latest timestamp for LocalStoryLastSeen
+    const currentLastSeen = pullFromCache<Amity.timestamp>([
+      STORY_KEY_CACHE.LAST_SEEN,
+      story.targetId,
+    ]);
+
+    if (currentLastSeen?.data) {
+      if (new Date(currentLastSeen.data).getTime() < new Date(story.expiresAt).getTime()) {
+        pushToCache([STORY_KEY_CACHE.LAST_SEEN, story.targetId], story.expiresAt);
+      }
+    } else {
+      pushToCache([STORY_KEY_CACHE.LAST_SEEN, story.targetId], story.expiresAt);
+    }
+
+    this._bufferNewSeenStoryReferenceIds.push(story.referenceId);
+
+    if (this._throttleStoryTimer) return;
+
+    this._throttleStoryTimer = setTimeout(() => {
+      clearTimeout(this._throttleStoryTimer);
+      fireEvent('local.story.reload', { referenceIds: this._bufferNewSeenStoryReferenceIds });
+      this._bufferNewSeenStoryReferenceIds = [];
+    }, 300);
+  }
+
+  resetAllBuckets() {
+    this._recentViewed = {};
+    this._recentHighPriorityViewed = {};
+
+    dropFromCache(ANALYTIC_CACHE_KEY);
+    dropFromCache(HIGH_PRIORITY_ANALYTIC_CACHE_KEY);
+  }
+
+  markStoryAsViewed(story: Amity.InternalStory) {
+    this.markStory(story, Amity.AnalyticEventActivityType.View);
+  }
+
+  markStoryAsClicked(story: Amity.InternalStory) {
+    this.markStory(story, Amity.AnalyticEventActivityType.Click);
+  }
+
+  markAdAsViewed(ad: Amity.InternalAd, placement: Amity.AdPlacement) {
+    const metadata = {
+      placement,
+    };
+
+    const activityType = Amity.AnalyticEventActivityType.View;
+
+    this.markAs({
+      uniqueId: `${ad.adId}.${activityType}.${placement}`,
+      contentId: ad.adId,
+      contentType: Amity.AnalyticEventContentType.Ad,
+      activityType,
+      metadata,
+    });
+  }
+
+  markAdAsClicked(ad: Amity.InternalAd, placement: Amity.AdPlacement) {
+    const metadata = {
+      placement,
+    };
+
+    const activityType = Amity.AnalyticEventActivityType.Click;
+
+    this.markAs({
+      uniqueId: `${ad.adId}.${activityType}.${placement}`,
+      contentId: ad.adId,
+      contentType: Amity.AnalyticEventContentType.Ad,
+      activityType,
+      metadata,
+    });
+  }
+}

package/src/analytic/service/analytic/AnalyticsEventSyncer.ts

@@ -0,0 +1,81 @@
+import { pullFromCache } from '~/cache/api/pullFromCache';
+import { dropFromCache } from '~/cache/api/dropFromCache';
+import { MINUTE, SECOND } from '~/utils/constants';
+import { ANALYTIC_CACHE_KEY, HIGH_PRIORITY_ANALYTIC_CACHE_KEY } from '../../constant';
+import { syncEvent } from '../../api/syncEvent';
+
+export class AnalyticsEventSyncer {
+  _timer: NodeJS.Timeout | undefined = undefined;
+
+  _high_priority_timer: NodeJS.Timeout | undefined = undefined;
+
+  start() {
+    this.syncCapturedEvent();
+
+    this._timer = setInterval(() => {
+      this.syncCapturedEvent();
+    }, 1 * MINUTE);
+
+    this._high_priority_timer = setInterval(() => {
+      this.syncHighPriorityCapturedEvent();
+    }, 10 * SECOND);
+  }
+
+  stop() {
+    if (this._timer) {
+      clearInterval(this._timer);
+      this._timer = undefined;
+    }
+
+    if (this._high_priority_timer) {
+      clearInterval(this._high_priority_timer);
+      this._high_priority_timer = undefined;
+    }
+  }
+
+  async syncCapturedEvent() {
+    try {
+      // Must query only objects that have same userId with current logged-in user.
+      // Query captured event with maximum of 1000
+      // Order by latest first
+      // e.g., If there are 2000 events we will query 1000-2000 first
+      const cache = pullFromCache<{ event: Amity.AnalyticEventModel[] }>(ANALYTIC_CACHE_KEY);
+      if (!cache?.data) return;
+      if (cache.data.event.length === 0) return;
+
+      const capturedEvents = cache.data.event;
+
+      await syncEvent(capturedEvents);
+
+      dropFromCache(ANALYTIC_CACHE_KEY);
+    } catch (error) {
+      // stop and destroy all events
+      this.stop();
+      dropFromCache(ANALYTIC_CACHE_KEY);
+    }
+  }
+
+  async syncHighPriorityCapturedEvent() {
+    try {
+      // Must query only objects that have same userId with current logged-in user.
+      // Query captured event with maximum of 1000
+      // Order by latest first
+      // e.g., If there are 2000 events we will query 1000-2000 first
+      const cache = pullFromCache<{ event: Amity.AnalyticEventModel[] }>(
+        HIGH_PRIORITY_ANALYTIC_CACHE_KEY,
+      );
+      if (!cache?.data) return;
+      if (cache.data.event.length === 0) return;
+
+      const capturedEvents = cache.data.event;
+
+      await syncEvent(capturedEvents);
+
+      dropFromCache(HIGH_PRIORITY_ANALYTIC_CACHE_KEY);
+    } catch (error) {
+      // stop and destroy all events
+      this.stop();
+      dropFromCache(HIGH_PRIORITY_ANALYTIC_CACHE_KEY);
+    }
+  }
+}

package/src/analytic/service/analytic/AnalyticsService.ts

@@ -0,0 +1,23 @@
+import AnalyticsEngine from './AnalyticsEngine';
+
+class AnalyticsService {
+  private analyticEngine;
+
+  constructor() {
+    this.analyticEngine = AnalyticsEngine.getInstance();
+  }
+
+  markPostAsViewed(postId: string): void {
+    this.analyticEngine.markPostAsViewed(postId);
+  }
+}
+
+let instance: AnalyticsService;
+export default {
+  getInstance: () => {
+    if (!instance) {
+      instance = new AnalyticsService();
+    }
+    return instance;
+  },
+};

package/src/analytic/utils/analyticsEngineOnLoginHandler.ts

@@ -0,0 +1,19 @@
+import { onSessionStateChange } from '~/client/events/onSessionStateChange';
+import AnalyticsEngine from '../service/analytic/AnalyticsEngine';
+
+export default () => {
+  const analyticsEngine = AnalyticsEngine.getInstance();
+  analyticsEngine.established();
+
+  onSessionStateChange(state => {
+    if (state === Amity.SessionStates.ESTABLISHED) {
+      analyticsEngine.established();
+    } else {
+      analyticsEngine.handleTokenExpired();
+    }
+  });
+
+  return () => {
+    analyticsEngine.destroy();
+  };
+};

package/src/cache/api/backupCache.ts

@@ -0,0 +1,48 @@
+import { getActiveClient } from '~/client/api/activeClient';
+
+/**
+ * ```js
+ * import { backupCache } from '@amityco/ts-sdk'
+ * const success = await backupCache()
+ * ```
+ *
+ * Writes the {@link Amity.Cache} to a persistent storage.
+ *
+ * The strategy for persistent storage will depend on the runtime,
+ * which is supported by @react-native-async-storage/async-storage.
+ *
+ * The current userId will be appended to the given storageKey to avoid
+ * collision between multiple client instances over time.
+ *
+ * @param storageKey the name of the persistent storage
+ * @param persistIf a custom function to define the persistence policy. Default
+ * will check the value of {@link Amity.CacheEntry["offline"]}, which can be
+ * defined globally when customizing {@link Amity.Cache["persistIf"]}
+ * @returns a success boolean if the cache was dumped to persistent storage
+ *
+ * @category Cache API
+ */
+export const backupCache = async (
+  storageKey = 'amitySdk',
+  persistIf = (entry: Amity.CacheEntry) => entry.offline,
+): Promise<boolean> => {
+  const { log, cache, userId } = getActiveClient();
+
+  if (!cache) return false;
+  log('cache/api/backupCache', { storageKey });
+
+  // prepare a subset of the cache where only
+  // objects to backup are there
+  const offlineEntries = Object.fromEntries(
+    Object.entries(cache.data).filter(([_, entry]) => persistIf(entry)),
+  );
+
+  // nothing to backup, abort
+  if (!Object.keys(offlineEntries).length) return false;
+
+  if (localStorage) {
+    await localStorage.setItem(`${storageKey}#${userId}`, JSON.stringify(offlineEntries));
+  }
+
+  return true;
+};

package/src/cache/api/disableCache.ts

@@ -0,0 +1,23 @@
+import { getActiveClient } from '~/client/api/activeClient';
+
+/**
+ * ```js
+ * import { disableCache } from '@amityco/ts-sdk'
+ * disableCache()
+ * ```
+ *
+ * Wipes the existing {@link Amity.Cache} object attached to
+ * an {@link Amity.Client} instance
+ *
+ * @category Cache API
+ */
+export const disableCache = () => {
+  const client = getActiveClient();
+
+  if (!client.cache) return;
+  client.log('cache/api/disableCache');
+
+  // we do this so that testing if cache is enabled
+  // is only `if (client.cache)
+  delete client.cache;
+};

package/src/cache/api/dropFromCache.ts

@@ -0,0 +1,41 @@
+import { getActiveClient } from '~/client/api/activeClient';
+import { decodeKey, encodeKey, partialMatch } from '../utils';
+
+/**
+ * ```js
+ * import { dropFromCache } from '@amityco/ts-sdk'
+ * const success = dropFromCache(['user', 'foobar'])
+ * ```
+ *
+ * Removes an existing {@link Amity.CacheEntry} from the {@link Amity.Client}'s
+ * {@link Amity.Cache} from a given {@link Amity.CacheKey}
+ *
+ * @param key The key of the object to delete
+ * @param exact If false, the function will delete all keys satisfying the given key
+ * @returns A success boolean if the object was deleted
+ *
+ * @category Cache API
+ */
+export const dropFromCache = (key: Amity.CacheKey, exact = false): boolean => {
+  const { log, cache } = getActiveClient();
+
+  if (!cache) return false;
+  log('cache/api/dropFromCache', { key, exact });
+
+  if (!exact) {
+    return Object.keys(cache.data)
+      .map(stringKey => decodeKey(stringKey))
+      .filter(candidate => partialMatch(key, candidate))
+      .map<boolean>(filteredKey => dropFromCache(filteredKey, true))
+      .every(returned => returned);
+  }
+
+  const encodedKey = encodeKey(key);
+
+  if (encodedKey in cache.data) {
+    delete cache.data[encodedKey];
+    return true;
+  }
+
+  return false;
+};

package/src/cache/api/enableCache.ts

@@ -0,0 +1,29 @@
+import { getActiveClient } from '~/client/api/activeClient';
+
+/**
+ * ```js
+ * import { enableCache } from '@amityco/ts-sdk'
+ * enableCache()
+ * ```
+ *
+ * Adds a new {@link Amity.Cache} object to
+ * an {@link Amity.Client} instance
+ *
+ * @param prevState a previous state of cache instance (useful for SSR)
+ * @param persistIf a function to determine if an entry inserted in cache
+ * is destined to be also saved in the persistent storage when
+ * calling {@link backupCache}
+ *
+ * @category Cache API
+ */
+export const enableCache = (
+  prevState: Amity.Cache['data'] = {},
+  persistIf?: Amity.Cache['persistIf'],
+) => {
+  const client = getActiveClient();
+
+  if (client.cache) return;
+  client.log('cache/api/enableCache');
+
+  client.cache = { data: prevState, persistIf };
+};

package/src/cache/api/index.ts

@@ -0,0 +1,24 @@
+// on/off
+export * from './enableCache';
+export * from './disableCache';
+
+// persistency
+export * from './restoreCache';
+export * from './backupCache';
+export * from './wipeCache';
+
+// fetch
+export * from './queryCache';
+export * from './pullFromCache';
+
+// mutate
+export * from './pushToCache';
+export * from './mergeInCache';
+export * from './upsertInCache';
+export * from './dropFromCache';
+
+/*
+ * ingestInCache and syncInCache and isInTombstone
+ * and pushToTombstone are not exported ;
+ * we don't want it as part of the sdk's public api.
+ */

package/src/cache/api/ingestInCache.ts

@@ -0,0 +1,32 @@
+import { PAYLOAD2MODEL, getResolver } from '~/core/model';
+
+import { pushToCache } from './pushToCache';
+import { upsertInCache } from './upsertInCache';
+
+/**
+ * Ingest a payload (v3) into the cache
+ *
+ * @param payload a "backend v3" payload object
+ * @param options caching options like cachedAt or offline
+ * @param replace If TRUE it will overwrite the current cache with payload, if FALSE it will merge the payload into cache.
+ *
+ * @category Cache
+ * @hidden
+ */
+export const ingestInCache = (
+  payload: Record<keyof typeof PAYLOAD2MODEL, Amity.Model[]> = {},
+  options?: Amity.CacheOptions,
+  replace = true,
+) => {
+  Object.entries(payload).forEach(([key, models]) => {
+    const type = PAYLOAD2MODEL[key];
+    if (!type) return;
+
+    const resolver = getResolver(type);
+    if (!resolver) return;
+
+    models.forEach(model => {
+      (replace ? pushToCache : upsertInCache)([type, 'get', resolver(model)], model, options);
+    });
+  });
+};

package/src/cache/api/isInTombstone.ts

@@ -0,0 +1,41 @@
+import { getActiveClient } from '~/client/api/activeClient';
+
+import { ASCApiError } from '~/core/errors';
+import { pullFromCache } from '~/cache/api';
+import { isFresh, queryOptions } from '~/core/query';
+import { CACHE_KEY_TOMBSTONE, CACHE_LIFESPAN_TOMBSTONE } from '~/cache/utils';
+
+/**
+ * ```js
+ * import { isInTombstone } from '@amityco/ts-sdk'
+ * const user = isInTombstone(["message", "messageId"])
+ * ```
+ *
+ * Checks if the {@link Amity.TombstoneCacheOptions} exists
+ * in cache and it's not expired means it's in tombstone
+ * and we throw an Error
+ *
+ * @param model the model to check
+ * @param modelId the object id to check
+ * @returns the matching cache entry, or undefined.
+ *
+ * @category Cache API
+ */
+export const isInTombstone = (model: Amity.Domain, modelId: string) => {
+  const { log, cache } = getActiveClient();
+  const key = [model, CACHE_KEY_TOMBSTONE, modelId];
+
+  if (!cache) return;
+  log('cache/api/isInTombstone', key);
+
+  const isInTombstone = pullFromCache<Amity.TombstoneCacheOptions>(key);
+  const { lifeSpan } = queryOptions('cache_then_server', CACHE_LIFESPAN_TOMBSTONE);
+
+  if (isInTombstone && isFresh(isInTombstone.data, lifeSpan)) {
+    throw new ASCApiError(
+      'Item not found!',
+      Amity.ServerError.ITEM_NOT_FOUND,
+      Amity.ErrorLevel.ERROR,
+    );
+  }
+};

package/src/cache/api/mergeInCache.ts

@@ -0,0 +1,48 @@
+import { getActiveClient } from '~/client/api/activeClient';
+import { isOutdated } from '~/core/model';
+
+import { pullFromCache } from './pullFromCache';
+import { pushToCache } from './pushToCache';
+
+/**
+ * ```js
+ * import { mergeInCache } from '@amityco/ts-sdk'
+ *
+ * mergeInCache(
+ *   ["foo", "bar"],
+ *   (oldVal) => ({ ...oldVal, ...newVal }).
+ * )
+ * ```
+ *
+ * Merges a new {@link Amity.Cache} object to an {@link Amity.Client} instance
+ *
+ * @param key the key matching the object to retrieve from cache
+ * @param mutation either a plain object to shallow merge, or a function.
+ * @returns a success boolean if the object was updated
+ *
+ * @category Cache API
+ */
+export const mergeInCache = <T extends Record<string, unknown>>(
+  key: Amity.CacheKey,
+  mutation: Partial<T> | ((oldVal: T) => T),
+  options?: Amity.CacheOptions,
+): boolean => {
+  const { log, cache } = getActiveClient();
+
+  if (!cache) return false;
+  log('cache/api/mergeInCache', { key, mutation });
+
+  const oldVal = pullFromCache<T>(key);
+
+  if (!oldVal) return false;
+
+  const newVal =
+    typeof mutation === 'function' ? mutation(oldVal.data) : { ...oldVal.data, ...mutation };
+
+  if (isOutdated(oldVal.data, newVal)) {
+    return false;
+  }
+
+  pushToCache(key, newVal, options);
+  return true;
+};

package/src/cache/api/pullFromCache.ts

@@ -0,0 +1,31 @@
+import { getActiveClient } from '~/client/api/activeClient';
+
+import { encodeKey } from '../utils';
+
+/**
+ * ```js
+ * import { pullFromCache } from '@amityco/ts-sdk'
+ * const user = pullFromCache<Amity.User>(["user", "foobar"])
+ * ```
+ *
+ * Retrieves a {@link Amity.CacheEntry} object matching a given
+ * {@link Amity.CacheKey}. The cache entry is not typed, so the
+ * expected returned type must be passed manually.
+ *
+ * @param key the key matching the object to retrieve from cache
+ * @returns the matching cache entry, or undefined.
+ *
+ * @category Cache API
+ */
+export const pullFromCache = <T extends unknown>(
+  key: Amity.CacheKey,
+): Amity.CacheEntry<T> | undefined => {
+  const { log, cache } = getActiveClient();
+
+  if (!cache) return;
+  log('cache/api/pullFromCache', key);
+
+  const str = encodeKey(key);
+
+  return cache.data[str] ? (cache.data[str] as Amity.CacheEntry<T>) : undefined;
+};