@amityco/ts-sdk-react-native 6.25.2-843ba7e.0 → 6.26.1-4e1acd6.0

package/dist/utils/linkedObject/adLinkedObject.d.ts

@@ -0,0 +1,2 @@
+export declare const adLinkedObject: (ad: Amity.RawAd) => Amity.Ad;
+//# sourceMappingURL=adLinkedObject.d.ts.map

package/dist/utils/linkedObject/adLinkedObject.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adLinkedObject.d.ts","sourceRoot":"","sources":["../../../src/utils/linkedObject/adLinkedObject.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,cAAc,OAAQ,MAAM,KAAK,KAAG,MAAM,EA8CtD,CAAC"}

package/dist/utils/linkedObject/index.d.ts

@@ -1,4 +1,5 @@
 export declare const LinkedObject: {
+    ad: (ad: Amity.RawAd) => Amity.Ad;
     comment: (comment: Amity.InternalComment<any>) => Amity.Comment<any>;
     post: (post: Amity.InternalPost<any>) => Amity.Post<any>;
     user: (user: Amity.InternalUser) => Amity.User;

package/dist/utils/linkedObject/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/utils/linkedObject/index.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,YAAY;;;;;;;;;;;CAWxB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/utils/linkedObject/index.ts"],"names":[],"mappings":"AAYA,eAAO,MAAM,YAAY;;;;;;;;;;;;CAYxB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amityco/ts-sdk-react-native",
-  "version": "6.25.2-843ba7e.0",
+  "version": "6.26.1-4e1acd6.0",
   "license": "CC-BY-ND-4.0",
   "author": "amity.co <developers@amity.co> (https://amity.co)",
   "description": "Amity Social Cloud Typescript SDK",

package/src/@types/core/model.ts

@@ -49,6 +49,9 @@ declare global {
       followCount: Amity.FollowCount;
 
       feed: Amity.Feed;
+
+      ad: Pick<Amity.Ad, 'adId'>;
+      advertiser: Pick<Amity.AdvertiserItem, 'advertiserId'>;
     };
 
     type Model = ValueOf<Models>;
@@ -102,6 +105,9 @@ declare global {
       followCount: Pick<Amity.FollowInfo, 'userId' | 'followerCount'>;
 
       feed: Pick<Amity.Feed, 'targetId' | 'feedId'>;
+
+      ad: Pick<Amity.Ad, 'adId'>;
+      advertiser: Pick<Amity.AdvertiserItem, 'advertiserId'>;
     };
   }
 }

package/src/@types/core/payload.ts

@@ -34,6 +34,13 @@ declare global {
       }[];
     };
 
+    type AdPayload = {
+      ads: Amity.RawAd[];
+      advertisers: Amity.RawAdvertiser[];
+      files: Amity.File[];
+      settings: Amity.AdsSettings;
+    };
+
     // API-FIX: backend should return a payload like { files: Amity.File<T>[] }
     type CreateFilePayload<T extends Amity.FileType = any> = Amity.File<T>[];
     type FilePayload<T extends Amity.FileType = any> = Amity.File<T>;
@@ -354,6 +361,11 @@ declare global {
       communityUsers: Amity.Membership<'community'>[];
     };
 
+    type ProcessedCommentPayload<T extends Amity.CommentContentType = any> = Omit<
+      CommentPayload<T>,
+      'users' | 'files' | 'communityUsers'
+    >;
+
     type PollPayload = {
       users: Amity.InternalUser[];
       polls: Amity.Poll[];

package/src/@types/domains/ad.ts

@@ -0,0 +1,88 @@
+export {};
+
+declare global {
+  namespace Amity {
+    const enum AdPlacement {
+      FEED = 'feed',
+      STORY = 'story',
+      COMMENT = 'comment',
+      CHATLIST = 'chatlist',
+      CHAT = 'chat',
+    }
+
+    const enum SettingDisplayType {
+      Fixed = 'fixed',
+      TimeWindow = 'time-window',
+    }
+
+    type AdTarget = {
+      communityIds: Amity.Community['communityId'][];
+    };
+
+    type RawAd = {
+      adId: string;
+      advertiserId: string;
+      name: string;
+      placements: AdPlacement[];
+      headline: string;
+      description: string;
+      body: string;
+      image1_1: string;
+      image9_16: string;
+      callToAction: string;
+      callToActionUrl: string;
+      targets: Amity.AdTarget;
+      startAt: Amity.timestamp;
+      endAt: Amity.timestamp;
+      createdAt: Amity.timestamp;
+      updatedAt: Amity.timestamp;
+    };
+
+    type RawAdvertiser = {
+      advertiserId: string;
+      name: string;
+      companyName: string;
+      avatarFileId: string;
+      adsCount: number;
+      createdAt: Amity.timestamp;
+      updatedAt: Amity.timestamp;
+    };
+
+    type AdFrequency = {
+      type: Amity.SettingDisplayType;
+      value: number;
+    };
+
+    type FrequencySettings = {
+      feed?: Amity.AdFrequency;
+      story?: Amity.AdFrequency;
+      comment?: Amity.AdFrequency;
+    };
+
+    type AdsSettings = {
+      enabled: boolean;
+      maxActiveAds: number;
+      frequency: Amity.FrequencySettings;
+      updatedAt: Amity.timestamp;
+    };
+
+    type Advertiser = RawAdvertiser & {
+      avatar?: Amity.File<'image'>;
+    };
+
+    type Ad = Omit<RawAd, 'image1_1' | 'image9_16'> & {
+      advertiser?: Amity.Advertiser;
+      image1_1?: Amity.File<'image'>;
+      image9_16?: Amity.File<'image'>;
+      // analytics: {
+      //   markAsSeen: (placement: Amity.AdPlacement) => void;
+      //   markLinkAsClicked: (placement: Amity.AdPlacement) => void;
+      // };
+    };
+
+    type NetworkAds = {
+      ads: Amity.Ad[];
+      settings: Amity.AdsSettings;
+    };
+  }
+}

package/src/@types/domains/analytics.ts

@@ -10,6 +10,7 @@ declare global {
     const enum AnalyticEventContentType {
       Post = 'post',
       Story = 'story',
+      Ad = 'ad',
     }
 
     type AnalyticEventModel = {
@@ -17,6 +18,7 @@ declare global {
       contentType: AnalyticEventContentType;
       activityType: AnalyticEventActivityType;
       timestamp: Amity.timestamp;
+      metadata?: Record<string, string>;
     };
 
     type AnalyticPostData = {

package/src/@types/index.ts

@@ -35,3 +35,5 @@ export * from './domains/content';
 export * from './domains/file';
 export * from './domains/message';
 export * from './domains/post';
+export * from './domains/story';
+export * from './domains/ad';

package/src/adRepository/api/getNetworkAds.ts

@@ -0,0 +1,24 @@
+import { getActiveClient } from '~/client';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { pushToCache } from '~/cache/api';
+import { LinkedObject } from '~/utils/linkedObject';
+
+const convertToNetworkAds = (data: Amity.AdPayload): Amity.NetworkAds => {
+  const { ads, settings } = data;
+
+  return {
+    ads: ads.map(LinkedObject.ad),
+    settings,
+  };
+};
+
+export const getNetworkAds = async (): Promise<Amity.NetworkAds> => {
+  const client = getActiveClient();
+
+  const { data } = await client.http.get<Amity.AdPayload>('/api/v1/ads/me');
+  const { settings, ...rest } = data;
+  ingestInCache(rest as Omit<Amity.AdPayload, 'settings'>);
+  pushToCache(['ad', 'setting'], settings);
+
+  return convertToNetworkAds(data);
+};

package/src/adRepository/api/index.ts

@@ -0,0 +1 @@
+export { getNetworkAds } from './getNetworkAds';

package/src/adRepository/index.ts

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

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

@@ -33,6 +33,24 @@ class AnalyticsEngine {
     }
   }
 
+  markAdAsViewed(ad: Amity.RawAd, 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.RawAd, 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 ||

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

@@ -48,8 +48,13 @@ export class AnalyticsEventCapturer {
     return true;
   }
 
-  markPostAsViewed(postId: Amity.InternalPost['postId']) {
-    if (!this.isAbleToEnqueue({ itemId: postId, expireTime: this._expireTime })) return;
+  markAs(
+    itemId: string,
+    contentType: Amity.AnalyticEventContentType,
+    activityType: Amity.AnalyticEventActivityType,
+    metadata: Record<string, string> | undefined = undefined,
+  ) {
+    if (!this.isAbleToEnqueue({ itemId, expireTime: this._expireTime })) return;
 
     const now = new Date();
 
@@ -66,15 +71,25 @@ export class AnalyticsEventCapturer {
       currentData.event.shift();
     }
 
-    currentData.event.push({
-      contentId: postId,
-      contentType: Amity.AnalyticEventContentType.Post,
-      activityType: Amity.AnalyticEventActivityType.View,
+    const analyticItem: Amity.AnalyticEventModel = {
+      contentId: itemId,
+      contentType,
+      activityType,
       timestamp: now.toISOString(),
-    });
+    };
+
+    if (metadata) {
+      analyticItem.metadata = metadata;
+    }
+
+    currentData.event.push(analyticItem);
 
     upsertInCache(ANALYTIC_CACHE_KEY, currentData);
-    this._recentViewed[postId] = now;
+    this._recentViewed[itemId] = now;
+  }
+
+  markPostAsViewed(postId: Amity.InternalPost['postId']) {
+    this.markAs(postId, Amity.AnalyticEventContentType.Post, Amity.AnalyticEventActivityType.View);
   }
 
   markStory(story: Amity.InternalStory, activityType: Amity.AnalyticEventActivityType) {
@@ -163,4 +178,30 @@ export class AnalyticsEventCapturer {
   markStoryAsClicked(story: Amity.InternalStory) {
     this.markStory(story, Amity.AnalyticEventActivityType.Click);
   }
+
+  markAdAsViewed(ad: Amity.RawAd, placement: Amity.AdPlacement) {
+    const metadata = {
+      placement,
+    };
+
+    this.markAs(
+      `${ad.adId}.${Amity.AnalyticEventActivityType.View}.${placement}`,
+      Amity.AnalyticEventContentType.Ad,
+      Amity.AnalyticEventActivityType.View,
+      metadata,
+    );
+  }
+
+  markAdAsClicked(ad: Amity.RawAd, placement: Amity.AdPlacement) {
+    const metadata = {
+      placement,
+    };
+
+    this.markAs(
+      `${ad.adId}.${Amity.AnalyticEventActivityType.View}.${placement}`,
+      Amity.AnalyticEventContentType.Ad,
+      Amity.AnalyticEventActivityType.Click,
+      metadata,
+    );
+  }
 }

package/src/client/api/getToken.ts

@@ -16,7 +16,7 @@ import { getDeviceInfo } from '~/core/device';
  */
 export const getToken = async (params: {
   userId: Amity.InternalUser['userId'];
-  displayName: Amity.InternalUser['displayName'];
+  displayName?: Amity.InternalUser['displayName'];
   authToken?: string;
   deviceId: Amity.Device['deviceId'];
 }) => {

package/src/client/api/login.ts

@@ -93,7 +93,7 @@ export const login = async (
   try {
     const { users } = await setClientToken({
       ...params,
-      displayName: params?.displayName || params.userId,
+      displayName: params?.displayName,
       deviceId: params?.deviceId || defaultDeviceId,
     });
 

package/src/commentRepository/observers/getComments/CommentLiveCollectionController.ts

@@ -0,0 +1,132 @@
+import hash from 'object-hash';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { CommentPaginationController } from './CommentPaginationController';
+import { CommentQueryStreamController } from './CommentQueryStreamController';
+import { LiveCollectionController } from '~/core/liveCollection/LiveCollectionController';
+import {
+  onCommentCreated,
+  onCommentUpdated,
+  onCommentDeleted,
+  onCommentFlagged,
+  onCommentUnflagged,
+  onCommentReactionAdded,
+  onCommentReactionRemoved,
+} from '~/commentRepository/events';
+import { filterByPropEquality, sortByFirstCreated, sortByLastCreated } from '~/core/query';
+import { isNonNullable } from '~/utils';
+import { EnumCommentActions } from './enums';
+import { LinkedObject } from '~/utils/linkedObject';
+import { prepareCommentPayload } from '~/commentRepository/utils/payload';
+
+export class CommentLiveCollectionController extends LiveCollectionController<
+  'comment',
+  Amity.CommentLiveCollection,
+  Amity.Comment,
+  CommentPaginationController
+> {
+  private queryStreamController: CommentQueryStreamController;
+
+  private query: Amity.CommentLiveCollection;
+
+  constructor(
+    query: Amity.CommentLiveCollection,
+    callback: Amity.LiveCollectionCallback<Amity.Comment>,
+  ) {
+    const queryStreamId = hash(query);
+    const cacheKey = ['comments', 'collection', queryStreamId];
+    const paginationController = new CommentPaginationController(query);
+
+    super(paginationController, queryStreamId, cacheKey, callback);
+
+    this.query = query;
+    this.queryStreamController = new CommentQueryStreamController(
+      this.query,
+      this.cacheKey,
+      this.notifyChange.bind(this),
+      prepareCommentPayload,
+    );
+
+    this.callback = callback.bind(this);
+    this.loadPage({ initial: true });
+  }
+
+  protected setup() {
+    const collection = pullFromCache<Amity.CommentLiveCollectionCache>(this.cacheKey)?.data;
+    if (!collection) {
+      pushToCache(this.cacheKey, {
+        data: [],
+        params: {},
+      });
+    }
+  }
+
+  protected async persistModel(queryPayload: Amity.CommentPayload & Amity.Pagination) {
+    await this.queryStreamController.saveToMainDB(queryPayload);
+  }
+
+  protected persistQueryStream({
+    response,
+    direction,
+    refresh,
+  }: Amity.LiveCollectionPersistQueryStreamParams<'comment'>) {
+    this.queryStreamController.appendToQueryStream(response, direction, refresh);
+  }
+
+  startSubscription() {
+    return this.queryStreamController.subscribeRTE([
+      { fn: onCommentCreated, action: EnumCommentActions.OnCommentCreated },
+      { fn: onCommentUpdated, action: EnumCommentActions.OnCommentUpdated },
+      { fn: onCommentDeleted, action: EnumCommentActions.OnCommentDeleted },
+      { fn: onCommentFlagged, action: EnumCommentActions.OnCommentFlagged },
+      { fn: onCommentUnflagged, action: EnumCommentActions.OnCommentUnflagged },
+      { fn: onCommentReactionAdded, action: EnumCommentActions.OnCommentReactionAdded },
+      { fn: onCommentReactionRemoved, action: EnumCommentActions.OnCommentReactionRemoved },
+    ]);
+  }
+
+  notifyChange({ origin, loading, error }: Amity.LiveCollectionNotifyParams) {
+    const collection = pullFromCache<Amity.CommentLiveCollectionCache>(this.cacheKey)?.data;
+    if (!collection) return;
+
+    const data = this.applyFilter(
+      collection.data
+        .map(id => pullFromCache<Amity.InternalComment>(['comments', 'get', id])!)
+        .filter(isNonNullable)
+        .map(({ data }) => data) ?? [],
+    ).map(LinkedObject.comment);
+
+    if (!this.shouldNotify(data) && origin === 'event') return;
+
+    this.callback({
+      onNextPage: () => this.loadPage({ direction: Amity.LiveCollectionPageDirection.NEXT }),
+      data,
+      hasNextPage: !!this.paginationController.getNextToken(),
+      loading,
+      error,
+    });
+  }
+
+  applyFilter(data: Amity.InternalComment[]) {
+    let comments = data;
+
+    if (this.query.includeDeleted) {
+      comments = filterByPropEquality(comments, 'isDeleted', false);
+    }
+
+    if (this.query.parentId) {
+      comments = comments.filter(comment => comment.parentId === this.query.parentId);
+    }
+
+    switch (this.query.sortBy) {
+      case 'firstCreated':
+        comments = comments.sort(sortByFirstCreated);
+        break;
+      case 'lastCreated':
+      default:
+        comments = comments.sort(sortByLastCreated);
+        break;
+    }
+
+    return comments;
+  }
+}

package/src/commentRepository/observers/getComments/CommentPaginationController.ts

@@ -0,0 +1,25 @@
+import { PaginationController } from '~/core/liveCollection/PaginationController';
+import { COLLECTION_DEFAULT_PAGINATION_LIMIT } from '~/utils/constants';
+import { inferIsDeleted } from '~/utils/inferIsDeleted';
+
+export class CommentPaginationController extends PaginationController<
+  'comment',
+  Amity.CommentLiveCollection
+> {
+  async getRequest(queryParams: Amity.CommentLiveCollection, token: string | undefined) {
+    const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT, includeDeleted, ...params } = queryParams;
+    const options = token ? { token } : { limit };
+
+    const { data: queryResponse } = await this.http.get<Amity.CommentPayload & Amity.Pagination>(
+      `/api/v3/comments`,
+      {
+        params: {
+          ...params,
+          isDeleted: inferIsDeleted(includeDeleted),
+          options,
+        },
+      },
+    );
+    return queryResponse;
+  }
+}

package/src/commentRepository/observers/getComments/CommentQueryStreamController.ts

@@ -0,0 +1,90 @@
+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';
+import { EnumCommentActions } from './enums';
+
+export class CommentQueryStreamController extends QueryStreamController<
+  Amity.CommentPayload,
+  Amity.CommentLiveCollection
+> {
+  private notifyChange: (params: Amity.LiveCollectionNotifyParams) => void;
+
+  private preparePayload: (response: Amity.CommentPayload) => Amity.ProcessedCommentPayload;
+
+  constructor(
+    query: Amity.CommentLiveCollection,
+    cacheKey: string[],
+    notifyChange: (params: Amity.LiveCollectionNotifyParams) => void,
+    preparePayload: (response: Amity.CommentPayload) => Amity.ProcessedCommentPayload,
+  ) {
+    super(query, cacheKey);
+    this.notifyChange = notifyChange;
+    this.preparePayload = preparePayload;
+  }
+
+  async saveToMainDB(response: Amity.CommentPayload) {
+    const processedPayload = await this.preparePayload(response);
+
+    const client = getActiveClient();
+    const cachedAt = client.cache && Date.now();
+
+    if (client.cache) {
+      ingestInCache(processedPayload, { cachedAt });
+    }
+  }
+
+  appendToQueryStream(
+    response: Amity.CommentPayload & Partial<Amity.Pagination>,
+    direction: Amity.LiveCollectionPageDirection,
+    refresh = false,
+  ) {
+    if (refresh) {
+      pushToCache(this.cacheKey, {
+        data: response.comments.map(getResolver('comment')),
+      });
+    } else {
+      const collection = pullFromCache<Amity.CommunityLiveCollectionCache>(this.cacheKey)?.data;
+
+      const comments = collection?.data ?? [];
+
+      pushToCache(this.cacheKey, {
+        ...collection,
+        data: [...new Set([...comments, ...response.comments.map(getResolver('comment'))])],
+      });
+    }
+  }
+
+  reactor(action: EnumCommentActions) {
+    return (comment: Amity.InternalComment) => {
+      const collection = pullFromCache<Amity.CommentLiveCollectionCache>(this.cacheKey)?.data;
+
+      if (
+        this.query.referenceId !== comment.referenceId ||
+        this.query.referenceType !== comment.referenceType ||
+        !collection
+      ) {
+        return;
+      }
+
+      if (action === EnumCommentActions.OnCommentCreated) {
+        collection.data = [...new Set([comment.commentId, ...collection.data])];
+      } else if (action === EnumCommentActions.OnCommentDeleted) {
+        collection.data = collection.data.filter(p => p !== comment.commentId);
+      }
+
+      pushToCache(this.cacheKey, collection);
+      this.notifyChange({ origin: Amity.LiveDataOrigin.EVENT, loading: false });
+    };
+  }
+
+  subscribeRTE(
+    createSubscriber: {
+      fn: (reactor: (comment: Amity.InternalComment) => void) => Amity.Unsubscriber;
+      action: EnumCommentActions;
+    }[],
+  ) {
+    return createSubscriber.map(subscriber => subscriber.fn(this.reactor(subscriber.action)));
+  }
+}

package/src/commentRepository/observers/getComments/enums.ts

@@ -0,0 +1,9 @@
+export enum EnumCommentActions {
+  OnCommentCreated = 'onCommentCreated',
+  OnCommentUpdated = 'onCommentUpdated',
+  OnCommentDeleted = 'onCommentDeleted',
+  OnCommentFlagged = 'onCommentFlagged',
+  OnCommentUnflagged = 'onCommentUnflagged',
+  OnCommentReactionAdded = 'onCommentReactionAdded',
+  OnCommentReactionRemoved = 'onCommentReactionRemoved',
+}