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

package/src/analytic/api/syncEvent.ts

@@ -0,0 +1,10 @@
+import { getActiveClient } from '~/client/api/activeClient';
+
+export const syncEvent = async (events: Amity.AnalyticEventModel[]) => {
+  const client = getActiveClient();
+  const params: Record<string, any> = {
+    activities: events,
+  };
+
+  await client.http.post<Amity.ChannelPayload>('/api/v1/analytics/activities', params);
+};

package/src/analytic/constant.ts

@@ -0,0 +1,2 @@
+export const ANALYTIC_CACHE_KEY = ['analytic', 'normal-priority'];
+export const HIGH_PRIORITY_ANALYTIC_CACHE_KEY = ['analytic', 'high-priority'];

package/src/analytic/service/analytic/AnalyticsEngine.ts

@@ -0,0 +1,90 @@
+import { getActiveClient } from '~/client/api/activeClient';
+import { AnalyticsEventSyncer } from './AnalyticsEventSyncer';
+import { AnalyticsEventCapturer } from './AnalyticsEventCapturer';
+
+class AnalyticsEngine {
+  private _client: Amity.Client;
+
+  private _eventCapturer;
+
+  private _eventSyncer;
+
+  constructor() {
+    this._client = getActiveClient();
+    this._eventCapturer = new AnalyticsEventCapturer();
+    this._eventSyncer = new AnalyticsEventSyncer();
+  }
+
+  markPostAsViewed(postId: Amity.InternalPost['postId']) {
+    if (
+      this._client.sessionState === Amity.SessionStates.ESTABLISHED ||
+      this._client.sessionState === Amity.SessionStates.TOKEN_EXPIRED // For case token_expired, we assume token is expired and gonna re-connect soon
+    ) {
+      this._eventCapturer.markPostAsViewed(postId);
+    }
+  }
+
+  markStoryAsViewed(story: Amity.InternalStory) {
+    if (
+      this._client.sessionState === Amity.SessionStates.ESTABLISHED ||
+      this._client.sessionState === Amity.SessionStates.TOKEN_EXPIRED // For case token_expired, we assume token is expired and gonna re-connect soon
+    ) {
+      this._eventCapturer.markStoryAsViewed(story);
+    }
+  }
+
+  markAdAsViewed(ad: Amity.InternalAd, placement: Amity.AdPlacement) {
+    if (
+      this._client.sessionState === Amity.SessionStates.ESTABLISHED ||
+      this._client.sessionState === Amity.SessionStates.TOKEN_EXPIRED
+    ) {
+      this._eventCapturer.markAdAsViewed(ad, placement);
+    }
+  }
+
+  markAdAsClicked(ad: Amity.InternalAd, placement: Amity.AdPlacement) {
+    if (
+      this._client.sessionState === Amity.SessionStates.ESTABLISHED ||
+      this._client.sessionState === Amity.SessionStates.TOKEN_EXPIRED
+    ) {
+      this._eventCapturer.markAdAsClicked(ad, placement);
+    }
+  }
+
+  markStoryAsClicked(story: Amity.InternalStory) {
+    if (
+      this._client.sessionState === Amity.SessionStates.ESTABLISHED ||
+      this._client.sessionState === Amity.SessionStates.TOKEN_EXPIRED
+    ) {
+      this._eventCapturer.markStoryAsClicked(story);
+    }
+  }
+
+  established() {
+    this._eventSyncer.start();
+  }
+
+  handleTokenExpired() {
+    this._stopAndDestroy();
+  }
+
+  destroy() {
+    this._stopAndDestroy();
+  }
+
+  _stopAndDestroy() {
+    this._eventSyncer.stop();
+    this._eventCapturer.resetAllBuckets();
+  }
+}
+
+let instance: AnalyticsEngine;
+
+export default {
+  getInstance: () => {
+    if (!instance) {
+      instance = new AnalyticsEngine();
+    }
+    return instance;
+  },
+};

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

@@ -0,0 +1,228 @@
+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();
+
+    // Get the recent view date (if any)
+    const recentViewedDate = isHighPriority
+      ? this._recentHighPriorityViewed[uniqueId]
+      : this._recentViewed[uniqueId];
+
+    // If this is the first view, always allow it
+    if (!recentViewedDate) {
+      return true;
+    }
+
+    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);
+    });
+  });
+};