@amityco/ts-sdk 7.10.1-c2a9783.0 → 7.10.1-ec1ce4a3.0

package/src/utils/linkedObject/pinnedPostLinkedObject.ts

@@ -1,28 +0,0 @@
-import { pullFromCache, queryCache } from '~/cache/api';
-import { postLinkedObject } from './postLinkedObject';
-
-export const pinnedPostLinkedObject = (pinnedPost: Amity.RawPin): Amity.PinnedPost => {
-  const postCached = pullFromCache<Amity.InternalPost>(['post', 'get', pinnedPost.referenceId]);
-  const pinnedBy = queryCache<Amity.InternalUser>(['user', 'get'])!.find(cache => {
-    return cache.data?.userInternalId === pinnedPost.pinnedBy;
-  })?.data!;
-
-  return {
-    ...pinnedPost,
-    pinnedBy,
-    get post(): Amity.Post | undefined {
-      if (!postCached?.data) return;
-      return postLinkedObject(postCached.data);
-    },
-    get target(): Amity.PinTarget | undefined {
-      const pinTarget = pullFromCache<Amity.InternalPinTarget>([
-        'pinTarget',
-        'get',
-        postCached?.data.targetId,
-      ]);
-
-      if (!pinTarget?.data) return;
-      return pinTarget?.data;
-    },
-  };
-};

package/src/utils/linkedObject/postLinkedObject.ts

@@ -1,105 +0,0 @@
-import { pullFromCache } from '~/cache/api';
-import { commentLinkedObject } from '~/utils/linkedObject/commentLinkedObject';
-import AnalyticsEngine from '../../analytic/service/analytic/AnalyticsEngine';
-import { userLinkedObject } from './userLinkedObject';
-import {
-  isAmityFilePost,
-  isAmityImagePost,
-  isAmityLivestreamPost,
-  isAmityPollPost,
-  isAmityVideoPost,
-  isAmityClipPost,
-} from '../postTypePredicate';
-import { shallowClone } from '../shallowClone';
-import { streamLinkedObject } from './streamLinkedObject';
-import { isNonNullable } from '..';
-
-export const postLinkedObject = (post: Amity.InternalPost): Amity.Post => {
-  return shallowClone(post, {
-    childrenPosts: post.children
-      .map(childPost => pullFromCache<Amity.InternalPost>(['post', 'get', childPost])?.data)
-      .filter(isNonNullable)
-      .map(postLinkedObject),
-    analytics: {
-      markAsViewed: () => {
-        const analyticsEngineInstance = AnalyticsEngine.getInstance();
-        analyticsEngineInstance.markPostAsViewed(post.postId);
-      },
-    },
-
-    get latestComments(): (Amity.Comment | null)[] {
-      if (!post.comments) return [];
-      return (
-        post.comments
-          .map(commentId => {
-            const commentCached = pullFromCache<Amity.InternalComment>([
-              'comment',
-              'get',
-              commentId,
-            ])?.data;
-
-            if (!commentCached) return null;
-
-            return commentLinkedObject(commentCached);
-          })
-          .filter(Boolean) || []
-      );
-    },
-
-    get creator(): Amity.User | undefined {
-      const cacheData = pullFromCache<Amity.User>(['user', 'get', post.postedUserId]);
-      if (!cacheData?.data) return;
-      return userLinkedObject(cacheData.data);
-    },
-
-    getImageInfo(): Amity.File<'image'> | undefined {
-      return isAmityImagePost(post)
-        ? pullFromCache<Amity.File<'image'>>(['file', 'get', post?.data?.fileId])?.data
-        : undefined;
-    },
-
-    getVideoInfo(): Amity.File<'video'> | undefined {
-      return isAmityVideoPost(post)
-        ? pullFromCache<Amity.File<'video'>>(['file', 'get', post?.data?.videoFileId?.original])
-            ?.data
-        : undefined;
-    },
-
-    getVideoThumbnailInfo(): Amity.File<'image'> | undefined {
-      return isAmityVideoPost(post)
-        ? pullFromCache<Amity.File<'image'>>(['file', 'get', post?.data?.thumbnailFileId])?.data
-        : undefined;
-    },
-
-    getFileInfo(): Amity.File<'file'> | undefined {
-      return isAmityFilePost(post)
-        ? pullFromCache<Amity.File<'file'>>(['file', 'get', post?.data?.fileId])?.data
-        : undefined;
-    },
-
-    getLivestreamInfo(): Amity.Stream | undefined {
-      if (!isAmityLivestreamPost(post)) return;
-      const cache = pullFromCache<Amity.InternalStream>([
-        'stream',
-        'get',
-        post?.data?.streamId,
-      ])?.data;
-      if (!cache) return;
-
-      return streamLinkedObject(cache);
-    },
-
-    getPollInfo(): Amity.Poll | undefined {
-      if (!isAmityPollPost(post)) return;
-      const cache = pullFromCache<Amity.Poll>(['poll', 'get', post?.data?.pollId])?.data;
-      if (!cache) return;
-      return cache;
-    },
-
-    getClipInfo(): Amity.File<'clip'> | undefined {
-      return isAmityClipPost(post)
-        ? pullFromCache<Amity.File<'clip'>>(['file', 'get', post?.data?.fileId])?.data
-        : undefined;
-    },
-  });
-};

package/src/utils/linkedObject/reactorLinkedObject.ts

@@ -1,13 +0,0 @@
-import { pullFromCache } from '~/cache/api/pullFromCache';
-import { userLinkedObject } from './userLinkedObject';
-
-export const reactorLinkedObject = (reactor: Amity.InternalReactor): Amity.Reactor => {
-  return {
-    ...reactor,
-    get user(): Amity.User | undefined {
-      const user = pullFromCache<Amity.InternalUser>(['user', 'get', reactor.userId])?.data;
-      if (!user) return undefined;
-      return userLinkedObject(user);
-    },
-  };
-};

package/src/utils/linkedObject/storyLinkedObject.ts

@@ -1,112 +0,0 @@
-import { pullFromCache } from '~/cache/api';
-import AnalyticsEngine from '~/analytic/service/analytic/AnalyticsEngine';
-import { userLinkedObject } from '~/utils/linkedObject/userLinkedObject';
-import { STORY_KEY_CACHE } from '~/storyRepository/constants';
-import { storyTargetLinkedObject } from '~/utils/linkedObject/storyTargetLinkedObject';
-
-export const storyLinkedObject = (story: Amity.InternalStory): Amity.Story => {
-  const analyticsEngineInstance = AnalyticsEngine.getInstance();
-
-  const storyTargetCache = pullFromCache<Amity.RawStoryTarget>([
-    STORY_KEY_CACHE.STORY_TARGET,
-    'get',
-    story.targetId,
-  ]);
-
-  const communityCacheData = pullFromCache<Amity.Community>(['community', 'get', story.targetId]);
-
-  return {
-    ...story,
-    analytics: {
-      markAsSeen: () => {
-        if (!story.expiresAt) return;
-        if (story.syncState !== Amity.SyncState.Synced) return;
-
-        analyticsEngineInstance.markStoryAsViewed(story);
-      },
-      markLinkAsClicked: () => {
-        if (!story.expiresAt) return;
-        if (story.syncState !== Amity.SyncState.Synced) return;
-        analyticsEngineInstance.markStoryAsClicked(story);
-      },
-    },
-
-    get videoData(): Amity.File<'video'> | undefined {
-      const cache = pullFromCache<Amity.File<'video'>>([
-        'file',
-        'get',
-        story.data?.videoFileId?.original,
-      ]);
-
-      if (!cache) return undefined;
-
-      const { data } = cache;
-      return data || undefined;
-    },
-
-    get imageData(): Amity.File<'image'> | undefined {
-      if (!story.data?.fileId) return undefined;
-
-      const cache = pullFromCache<Amity.File<'image'>>(['file', 'get', story.data?.fileId]);
-
-      if (!cache) return undefined;
-
-      const { data } = cache;
-
-      if (!data) return undefined;
-
-      return {
-        ...data,
-        fileUrl: `${data.fileUrl}?size=full`,
-      };
-    },
-
-    get community(): Amity.Community | undefined {
-      if (story.targetType !== 'community') return undefined;
-      if (!communityCacheData) return undefined;
-      return communityCacheData?.data || undefined;
-    },
-
-    get communityCategories(): Amity.Category[] | undefined {
-      if (story.targetType !== 'community') return undefined;
-      if (!communityCacheData) return undefined;
-
-      const {
-        data: { categoryIds },
-      } = communityCacheData;
-
-      if (categoryIds.length === 0) return undefined;
-
-      return categoryIds
-        .map(categoryId => {
-          const categoryCacheData = pullFromCache<Amity.Category>(['category', 'get', categoryId]);
-          return categoryCacheData?.data || undefined;
-        })
-        .filter(category => category !== undefined) as Amity.Category[];
-    },
-
-    get creator(): Amity.User | undefined {
-      const cacheData = pullFromCache<Amity.User>(['user', 'get', story.creatorPublicId]);
-      if (!cacheData?.data) return;
-      return userLinkedObject(cacheData.data);
-    },
-
-    get storyTarget(): Amity.StoryTarget | undefined {
-      if (!storyTargetCache?.data) return;
-      return storyTargetLinkedObject(storyTargetCache.data);
-    },
-
-    get isSeen(): boolean {
-      const cacheData = pullFromCache<Amity.timestamp>([STORY_KEY_CACHE.LAST_SEEN, story.targetId]);
-
-      if (!storyTargetCache?.data) return false;
-
-      const localLastSeen = cacheData?.data ? new Date(cacheData.data).getTime() : 0;
-      const serverLastSeen =
-        new Date(storyTargetCache?.data.lastStorySeenExpiresAt!).getTime() || 0;
-
-      const expiresAt = new Date(story.expiresAt!).getTime();
-      return Math.max(localLastSeen, serverLastSeen) >= expiresAt;
-    },
-  };
-};

package/src/utils/linkedObject/storyTargetLinkedObject.ts

@@ -1,35 +0,0 @@
-import { StoryComputedValue } from '~/storyRepository/utils/StoryComputedValue';
-
-export const storyTargetLinkedObject = (storyTarget: Amity.RawStoryTarget): Amity.StoryTarget => {
-  const {
-    targetType,
-    targetId,
-    lastStoryExpiresAt,
-    lastStorySeenExpiresAt,
-    targetUpdatedAt,
-    localFilter,
-  } = storyTarget;
-
-  const computedValue = new StoryComputedValue(
-    targetId,
-    lastStoryExpiresAt,
-    lastStorySeenExpiresAt,
-  );
-
-  return {
-    targetType,
-    targetId,
-    lastStoryExpiresAt,
-    updatedAt: targetUpdatedAt,
-
-    // Additional data
-    hasUnseen: computedValue.getHasUnseenFlag(),
-    syncingStoriesCount: computedValue.syncingStoriesCount,
-    failedStoriesCount: computedValue.failedStoriesCount,
-
-    localFilter,
-    localLastExpires: computedValue.localLastStoryExpires,
-    localLastSeen: computedValue.localLastStorySeenExpiresAt,
-    localSortingDate: computedValue.getLocalLastSortingDate(),
-  };
-};

package/src/utils/linkedObject/streamLinkedObject.ts

@@ -1,44 +0,0 @@
-import { pullFromCache } from '~/cache/api';
-import { getLiveChat as _getLiveChat } from '~/streamRepository/internalApi/getLiveChat';
-import { isNonNullable } from '..';
-
-const GET_WATCHER_URLS = Symbol('getWatcherUrls');
-
-export const streamLinkedObject = (stream: Amity.InternalStream): Amity.Stream => {
-  return {
-    ...stream,
-    get moderation() {
-      return pullFromCache<Amity.StreamModeration>(['streamModeration', 'get', stream.streamId])
-        ?.data;
-    },
-    get post() {
-      if (stream.referenceType !== 'post') return;
-      return pullFromCache<Amity.InternalPost>(['post', 'get', stream.referenceId])?.data;
-    },
-    get community() {
-      if (stream.targetType !== 'community') return;
-      return pullFromCache<Amity.Community>(['community', 'get', stream.targetId])?.data;
-    },
-    get user() {
-      return pullFromCache<Amity.User>(['user', 'get', stream.userId])?.data;
-    },
-    get childStreams() {
-      if (!stream.childStreamIds || stream.childStreamIds.length === 0) return [];
-      return stream.childStreamIds
-        .map(id => {
-          const streamCache = pullFromCache<Amity.InternalStream>(['stream', 'get', id])?.data;
-          if (!streamCache) return undefined;
-          return streamLinkedObject(streamCache);
-        })
-        .filter(isNonNullable);
-    },
-    getLiveChat: () => _getLiveChat(stream),
-    isBanned: !stream.watcherUrl,
-    watcherUrl: null,
-    get [GET_WATCHER_URLS](): Amity.MultiFormat<Amity.StreamEndpoint> {
-      return stream.watcherUrl;
-    },
-  };
-};
-
-export { GET_WATCHER_URLS };

package/src/utils/linkedObject/userLinkedObject.ts

@@ -1,17 +0,0 @@
-import { pullFromCache } from '~/cache/api/pullFromCache';
-
-export const userLinkedObject = (user: Amity.InternalUser): Amity.User => {
-  return {
-    ...user,
-    get avatar(): Amity.File<'image'> | undefined {
-      if (!user.avatarFileId) return undefined;
-      const avatar = pullFromCache<Amity.File<'image'>>([
-        'file',
-        'get',
-        `${user.avatarFileId}`,
-      ])?.data;
-
-      return avatar;
-    },
-  };
-};

package/src/utils/liveObject.ts

@@ -1,110 +0,0 @@
-import { getActiveClient } from '~/client/api';
-import {
-  LIVE_OBJECT_ENABLE_CACHE_MESSAGE,
-  UNSYNCED_OBJECT_CACHED_AT_MESSAGE,
-  UNSYNCED_OBJECT_CACHED_AT_VALUE,
-} from '~/utils/constants';
-import { createQuery, runQuery } from '~/core/query';
-import { ASCApiError } from '~/core/errors';
-import { convertGetterPropsToStatic } from '~/utils/object';
-
-import { isEqual } from './isEqual';
-
-/**
- * @deprecated This function will to be deprecated soon.
- */
-export const liveObject = <
-  T extends Amity.Model,
-  K extends keyof T,
-  CallbackData extends any = any,
->(
-  id: T[K],
-  callback: Amity.LiveObjectCallback<CallbackData>,
-  key: K,
-  fetcher: (id: T[K]) => Promise<Amity.Cached<T>>,
-  eventHandlers: Array<(callback: Amity.Listener<T>) => Amity.Unsubscriber>,
-  options?: Amity.LiveObjectOptions<T, CallbackData>,
-): Amity.Unsubscriber => {
-  const { forceDispatch, callbackDataSelector, callbackFilter } = {
-    forceDispatch: false,
-    callbackDataSelector: (data: T) => data as unknown as CallbackData,
-    ...options,
-  };
-
-  const { cache } = getActiveClient();
-
-  if (!cache) {
-    console.log(LIVE_OBJECT_ENABLE_CACHE_MESSAGE);
-  }
-
-  let model: T;
-  let isUnsyncedModel = false; // for messages
-  const disposers: Amity.Unsubscriber[] = [];
-
-  const dispatcher = (data: Amity.LiveObject<T>) => {
-    const { data: newModel, ...rest } = data;
-
-    if (!callbackFilter || callbackFilter(newModel, model)) {
-      callback({ data: callbackDataSelector(newModel), ...rest });
-    }
-
-    // resolve all getter on data model to a static value to avoid comparison problems
-    model = convertGetterPropsToStatic(newModel);
-  };
-
-  const realtimeRouter = (eventModel: T, forceDispatch = false) => {
-    if (id !== eventModel[key]) {
-      return;
-    }
-
-    if (model) {
-      if (!forceDispatch && isEqual(model, eventModel)) {
-        return;
-      }
-    }
-
-    dispatcher({ loading: false, data: eventModel, origin: 'event' });
-  };
-
-  const onFetch = () => {
-    // TODO: Ihis `@ts-ignore` is bring back to fix the build and it needs to be removed later
-    // @ts-ignore
-    const query = createQuery(fetcher, id, true);
-
-    runQuery(query, ({ error, data, loading, origin, cachedAt }) => {
-      if (cachedAt === UNSYNCED_OBJECT_CACHED_AT_VALUE) {
-        dispatcher({
-          // @ts-ignore
-          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) {
-        // @ts-ignore
-        dispatcher({ loading, data, origin, error });
-      }
-
-      if (error) {
-        disposers.forEach(fn => fn());
-      }
-    });
-  };
-
-  disposers.push(
-    ...eventHandlers.map(fn => fn(eventModel => realtimeRouter(eventModel, forceDispatch))),
-  );
-
-  onFetch();
-
-  return () => {
-    disposers.forEach(fn => fn());
-  };
-};

package/src/utils/marker.ts

@@ -1,23 +0,0 @@
-function doConvert<
-  T extends
-    | Amity.UserEntityMarkerResponse
-    | Amity.UserMarkerResponse
-    | Amity.UserFeedMarkerResponse,
->(markerResponses: T[]): (Omit<T, 'isMentioned'> & { hasMentioned: boolean })[] {
-  return markerResponses.map(({ isMentioned, ...rest }) => ({
-    hasMentioned: isMentioned,
-    ...rest,
-  }));
-}
-
-export function convertChannelMarkerResponse(
-  channelMarkerResponse: Amity.UserEntityMarkerResponse[],
-): Amity.ChannelMarker[] {
-  return doConvert(channelMarkerResponse);
-}
-
-export function convertSubChannelMarkerResponse(
-  subChannelMarkerResponse: Amity.UserFeedMarkerResponse[],
-): Amity.SubChannelMarker[] {
-  return doConvert(subChannelMarkerResponse);
-}

package/src/utils/object.ts

@@ -1,37 +0,0 @@
-export function isObject(value: unknown): value is Record<string, unknown> {
-  return typeof value === 'object' && value !== null;
-}
-/**
- *  convert all object getter property to static value
- */
-export const convertGetterPropsToStatic = <T extends Record<string, unknown>>(obj: T): T => {
-  if (!isObject(obj)) {
-    return obj;
-  }
-
-  const entries = Object.entries(obj).map(([key, value]) => {
-    const descriptor = Object.getOwnPropertyDescriptor(obj, key);
-
-    if (typeof descriptor?.get === 'function') {
-      return [key, descriptor.get.call(obj)];
-    }
-    return [key, value];
-  });
-
-  return Object.fromEntries(entries);
-};
-
-export const removeFunctionProperties = <T extends Record<string, unknown>>(obj: T): T => {
-  if (!isObject(obj)) {
-    return obj;
-  }
-
-  const entries = Object.entries(obj).map(([key, value]) => {
-    if (typeof value === 'function') {
-      return [key, undefined];
-    }
-    return [key, value];
-  });
-
-  return Object.fromEntries(entries);
-};

package/src/utils/postTypePredicate.ts

@@ -1,54 +0,0 @@
-export function isAmityImagePost(post: Amity.InternalPost): post is Amity.Post<'image'> {
-  return !!(
-    post.data &&
-    typeof post.data !== 'string' &&
-    'fileId' in post.data &&
-    post.dataType === 'image'
-  );
-}
-
-export function isAmityFilePost(post: Amity.InternalPost): post is Amity.Post<'file'> {
-  return !!(
-    post.data &&
-    typeof post.data !== 'string' &&
-    'fileId' in post.data &&
-    post.dataType === 'file'
-  );
-}
-
-export function isAmityVideoPost(post: Amity.InternalPost): post is Amity.Post<'video'> {
-  return !!(
-    post.data &&
-    typeof post.data !== 'string' &&
-    'videoFileId' in post.data &&
-    'thumbnailFileId' in post.data &&
-    post.dataType === 'video'
-  );
-}
-
-export function isAmityLivestreamPost(post: Amity.InternalPost): post is Amity.Post<'liveStream'> {
-  return !!(
-    post.data &&
-    typeof post.data !== 'string' &&
-    'streamId' in post.data &&
-    post.dataType === 'liveStream'
-  );
-}
-
-export function isAmityPollPost(post: Amity.InternalPost): post is Amity.Post<'poll'> {
-  return !!(
-    post.data &&
-    typeof post.data !== 'string' &&
-    'pollId' in post.data &&
-    post.dataType === 'poll'
-  );
-}
-
-export function isAmityClipPost(post: Amity.InternalPost): post is Amity.Post<'clip'> {
-  return !!(
-    post.data &&
-    typeof post.data !== 'string' &&
-    'fileId' in post.data &&
-    post.dataType === 'clip'
-  );
-}

package/src/utils/shallowClone.ts

@@ -1,23 +0,0 @@
-/**
- * ```js
- * import { shallowClone } from '~/utils/shallowClone'
- * const newObj = shallowClone(obj)
- * ```
- *
- * Clone an object with same prototype and properties
- *
- * @param obj the object to clone
- * @returns new object with same prototype and properties
- *
- * @category utility
- * @private
- */
-export function shallowClone(source: object, target: object) {
-  return Object.create(
-    Object.getPrototypeOf(source), // Use the prototype of the source object
-    {
-      ...Object.getOwnPropertyDescriptors(source), // Copy all descriptors (methods, properties) from the source
-      ...Object.getOwnPropertyDescriptors(target), // Merge/override with descriptors (getters, properties) from the target
-    },
-  );
-}

package/src/utils/tests/client.ts

@@ -1,52 +0,0 @@
-import {
-  createClient,
-  login as sdkConnectClient,
-  logout as sdkDisconnectClient,
-} from '~/client/api';
-
-import * as messagePreviewSetting from '~/client/utils/messagePreviewEngine';
-
-import { user11 } from './dummy';
-
-export const activeUser = user11;
-
-const sessionHandler: Amity.SessionHandler = {
-  sessionWillRenewAccessToken(_) {
-    // do nothing
-  },
-};
-
-jest
-  .spyOn(messagePreviewSetting, 'getMessagePreviewSetting')
-  .mockResolvedValue(Amity.MessagePreviewSetting.MESSAGE_PREVIEW_INCLUDE_DELETED);
-
-export const client = createClient('key', 'sg');
-client.userId = 'test';
-client.accessTokenExpiryWatcher = _ => () => {
-  //
-};
-
-export const connectClient = async () => {
-  const now = new Date();
-  const nextMonth = new Date();
-  nextMonth.setDate(now.getDate() + 30);
-
-  client.mqtt.connect = jest.fn();
-  client.mqtt.subscribe = jest.fn();
-  client.http.post = jest.fn().mockReturnValueOnce({
-    data: {
-      accessToken: 'accessToken',
-      users: [activeUser],
-      expiresAt: nextMonth.toISOString(),
-      issuedAt: now.toISOString(),
-    },
-  });
-
-  await sdkConnectClient({ userId: client.userId! }, sessionHandler);
-};
-
-export const disconnectClient = async () => {
-  sdkDisconnectClient();
-};
-
-export default {};