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

package/src/userRepository/utils/convertRawUserToInternalUser.ts

@@ -1,6 +0,0 @@
-export function convertRawUserToInternalUser(rawUser: Amity.RawUser): Amity.InternalUser {
-  return {
-    ...rawUser,
-    isGlobalBanned: rawUser?.isGlobalBan || false,
-  };
-}

package/src/userRepository/utils/prepareBlockedUserPayload.ts

@@ -1,19 +0,0 @@
-import { convertRawUserToInternalUser } from './convertRawUserToInternalUser';
-
-export function prepareBlockedUserPayload(
-  response: Amity.BlockedUserPayload,
-): Amity.ProcessedBlockedUserPayload {
-  const { users, follows, ...rest } = response;
-
-  return {
-    ...rest,
-    follows: follows.map(follow => {
-      const followUser = users.find(user => user.userId === follow.from)!;
-      return {
-        ...follow,
-        user: convertRawUserToInternalUser(followUser),
-      };
-    }),
-    users: users.map(convertRawUserToInternalUser),
-  };
-}

package/src/userRepository/utils/prepareUserPayload.ts

@@ -1,8 +0,0 @@
-import { convertRawUserToInternalUser } from './convertRawUserToInternalUser';
-
-export function prepareUserPayload(response: Amity.UserPayload): Amity.ProcessedUserPayload {
-  return {
-    users: response.users.map(convertRawUserToInternalUser),
-    files: response.files,
-  };
-}

package/src/utils/constants.ts

@@ -1,16 +0,0 @@
-export const COLLECTION_DEFAULT_PAGINATION_LIMIT = 5;
-export const COLLECTION_DEFAULT_CACHING_POLICY: Amity.QueryPolicy = 'cache_then_server';
-export const ENABLE_CACHE_MESSAGE = 'For using Live Collection feature you need to enable Cache!';
-export const LIVE_OBJECT_ENABLE_CACHE_MESSAGE =
-  'For using Live Object feature you need to enable Cache!';
-export const UNSYNCED_OBJECT_CACHED_AT_MESSAGE =
-  'Observing unsynced object is not supported by Live Object.';
-export const UNSYNCED_OBJECT_CACHED_AT_VALUE = -5;
-export const SECOND = 1000;
-export const MINUTE = 60 * SECOND;
-export const HOUR = 60 * MINUTE;
-export const DAY = 24 * HOUR;
-export const WEEK = 7 * DAY;
-export const MONTH = 30 * DAY;
-export const YEAR = 365 * DAY;
-export const ACCESS_TOKEN_WATCHER_INTERVAL = 10 * MINUTE;

package/src/utils/dateTime.ts

@@ -1,3 +0,0 @@
-export const convertDateStringToTimestamp = (dateString: string) => {
-  return new Date(dateString).getTime();
-};

package/src/utils/env.ts

@@ -1,12 +0,0 @@
-/* eslint-disable no-undef */
-const theGlobal =
-  // eslint-disable-next-line no-nested-ternary
-  typeof globalThis === 'object' ? globalThis : typeof global === 'object' ? global : window;
-
-export const { process: safeProcess = {} }: { process: Partial<NodeJS.Process> } = theGlobal;
-
-export function getEnv(): NodeJS.ProcessEnv | undefined {
-  return safeProcess.env ?? {};
-}
-
-export const isProduction = safeProcess.env?.NODE_ENV === 'production';

package/src/utils/event.ts

@@ -1,25 +0,0 @@
-import { pullFromCache } from '~/cache/api/pullFromCache';
-
-export const convertEventPayload =
-  <
-    SourceModel extends Amity.Model,
-    DestinationDomain extends Amity.Domain,
-    DestinationModel extends Amity.Models[DestinationDomain],
-  >(
-    eventHandler: (callback: Amity.Listener<SourceModel>) => Amity.Unsubscriber,
-    sourceModelProp: keyof SourceModel,
-    destinationDomain: DestinationDomain,
-  ) =>
-  (callback: Amity.Listener<DestinationModel>) =>
-    eventHandler(sourceModel => {
-      if (!sourceModel) {
-        return sourceModel;
-      }
-
-      const cacheKey = [destinationDomain, 'get', `${sourceModel[sourceModelProp]}`];
-      const model = pullFromCache<DestinationModel>(cacheKey)?.data;
-
-      if (!model) return;
-
-      return callback(model);
-    });

package/src/utils/index.ts

@@ -1,57 +0,0 @@
-import { identifyModelKey } from '~/core/model';
-import { isEqual } from '~/utils/isEqual';
-
-export function hasMention(model: Amity.Mentionable<'user' | 'channel'>, userId: string) {
-  const channelMention = model?.mentionees?.find(x => x.type === 'channel') as Amity.ChannelMention;
-
-  if (channelMention) {
-    return true;
-  }
-
-  const userMention = model?.mentionees?.find(x => x.type === 'user') as Amity.UserMention;
-
-  if (userMention) {
-    return userMention.userIds.includes(userId);
-  }
-
-  return false;
-}
-
-export function shouldDispatchCollection<T extends Amity.Models[Amity.Domain] & Amity.UpdatedAt>(
-  collection: T[],
-  newItem: T,
-  action: 'onCreate' | string,
-): boolean {
-  const key = identifyModelKey(newItem);
-  // @ts-ignore
-  const item = collection.find(x => x[key] === newItem[key]);
-
-  if (item) {
-    return !isEqual(item, newItem);
-  }
-
-  return action === 'onCreate';
-}
-
-export function merge<T extends Amity.Models[Amity.Domain]>(
-  collection1: T[],
-  collection2: T[],
-): T[] {
-  const temp = [...collection1, ...collection2];
-
-  if (temp.length === 0) {
-    return [];
-  }
-
-  const key = identifyModelKey(temp[0]);
-  const map = new Map<string, T>();
-
-  // @ts-ignore
-  temp.forEach(x => map.set(x[key], x));
-
-  return Array.from(map.values());
-}
-
-export function isNonNullable<TValue>(value: TValue | undefined | null): value is TValue {
-  return value != null;
-}

package/src/utils/inferIsDeleted.ts

@@ -1,16 +0,0 @@
-/*
- * This is a simple utility that infers the value of isDeleted based on the
- * value of includeDeleted
- *
- * There are two important things to note here:
- *  1. `includeDeleted` is purely client side query param and not recognized by
- *  the server
- *  2. The only values we wish to expose with regards to `isDeleted` (the server
- *  param for queries) is false | undefined and want to disallow users to query
- *  for deleted entities
- *
- *  Although this is a very simple utility, it's only purpose is to keep things
- *  DRY
- */
-export const inferIsDeleted = (includeDeleted?: boolean): boolean | undefined =>
-  includeDeleted === true ? undefined : false;

package/src/utils/isEqual.ts

@@ -1,81 +0,0 @@
-/**
- * ```js
- * import { isEqual } from '~/utils/isEqual'
- * const isEqual = isEqual(post1, post2)
- * ```
- *
- * Compares two Amity.Model
- *
- * @param x the Amity.Model to compare
- * @param y the Amity.Model to compare wit x
- * @returns a boolean based on equality
- *
- * @category utility
- * @private
- */
-export function isEqual(x: any, y: any): boolean {
-  if (x === null || x === undefined || y === null || y === undefined) {
-    return x === y;
-  }
-
-  // after this just checking type of one would be enough
-  if (x.constructor !== y.constructor) {
-    return false;
-  }
-
-  // if they are functions, they should exactly refer to same one (because of closures)
-  if (x instanceof Function) {
-    return x === y;
-  }
-
-  // if they are regexps, they should exactly refer to same one
-  if (x instanceof RegExp) {
-    return x === y;
-  }
-
-  if (x === y || x.valueOf() === y.valueOf()) {
-    return true;
-  }
-
-  if (Array.isArray(x) && x.length !== y.length) {
-    return false;
-  }
-
-  // check each element of the array for equality
-  if (Array.isArray(x) && Array.isArray(y)) {
-    if (x.length !== y.length) return false;
-
-    for (let i = 0; i < x.length; i += 1) {
-      if (!isEqual(x[i], y[i])) return false;
-    }
-
-    // if all elements are equal, the arrays are equal
-    return true;
-  }
-
-  // if they are dates, they must had equal valueOf
-  if (x instanceof Date) {
-    return false;
-  }
-
-  // if they are strictly equal, they both need to be object at least
-  if (!(x instanceof Object)) {
-    return false;
-  }
-
-  if (!(y instanceof Object)) {
-    return false;
-  }
-
-  // recursive object equality check
-  const p = Object.keys(x);
-  return (
-    Object.keys(y).every(i => {
-      // @ts-ignore
-      return p.indexOf(i) !== -1;
-    }) &&
-    p.every(i => {
-      return isEqual(x[i], y[i]);
-    })
-  );
-}

package/src/utils/linkedObject/adLinkedObject.ts

@@ -1,50 +0,0 @@
-import { pullFromCache } from '~/cache/api';
-import AnalyticsEngine from '~/analytic/service/analytic/AnalyticsEngine';
-
-export const adLinkedObject = (ad: Amity.InternalAd): Amity.Ad => {
-  const analyticsEngineInstance = AnalyticsEngine.getInstance();
-  const { image9_16: image916, image1_1: image11, ...restAds } = ad;
-  return {
-    ...restAds,
-    analytics: {
-      markAsSeen: (placement: Amity.AdPlacement) => {
-        analyticsEngineInstance.markAdAsViewed(ad, placement);
-      },
-      markLinkAsClicked: (placement: Amity.AdPlacement) => {
-        analyticsEngineInstance.markAdAsClicked(ad, placement);
-      },
-    },
-    get advertiser(): Amity.Advertiser | undefined {
-      const advertiserData = pullFromCache<Amity.RawAdvertiser>([
-        'advertiser',
-        'get',
-        ad.advertiserId,
-      ])?.data;
-
-      if (!advertiserData) return;
-
-      const avatarFile = pullFromCache<Amity.File<'image'>>([
-        'file',
-        'get',
-        advertiserData.avatarFileId,
-      ])?.data;
-
-      return {
-        ...advertiserData,
-        avatar: avatarFile,
-      };
-    },
-
-    get image1_1(): Amity.File<'image'> | undefined {
-      const cacheData = pullFromCache<Amity.File<'image'>>(['file', 'get', image11]);
-      if (!cacheData) return undefined;
-      return cacheData.data || undefined;
-    },
-
-    get image9_16(): Amity.File<'image'> | undefined {
-      const cacheData = pullFromCache<Amity.File<'image'>>(['file', 'get', image916]);
-      if (!cacheData) return undefined;
-      return cacheData.data || undefined;
-    },
-  };
-};

package/src/utils/linkedObject/categoryLinkedObject.ts

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

package/src/utils/linkedObject/channelLinkedObject.ts

@@ -1,32 +0,0 @@
-import { markAsRead } from '~/channelRepository/internalApi/markAsRead';
-import { shallowClone } from '../shallowClone';
-import { queryCache } from '~/cache/api';
-import { channelMemberLinkedObject } from './channelMemberLinkedObject';
-import { getMyMembership } from '~/channelRepository/observers/getMyMembership';
-
-export const channelLinkedObject = (channel: Amity.InternalChannel): Amity.Channel => {
-  let previewMembers: Amity.Membership<'channel'>[] = [];
-
-  if (['conversation', 'community'].includes(channel.type)) {
-    const channelUsers = queryCache<Amity.Membership<'channel'>>(['channelUsers', 'get']);
-    if (channelUsers && channelUsers?.length > 0) {
-      previewMembers = (
-        channelUsers?.filter(
-          ({ data }) => data.channelId === channel.channelId && data.membership !== 'none',
-        ) ?? []
-      )
-        // sort in ascending order by userInternalId
-        .sort((a, b) => a.data.userInternalId.localeCompare(b.data.userInternalId))
-        // Select only first 4 members
-        .slice(0, 4)
-        .map(({ data }) => channelMemberLinkedObject(data));
-    }
-  }
-
-  return shallowClone(channel, {
-    markAsRead: () => markAsRead(channel.channelInternalId),
-    previewMembers,
-    myMembership: (callback: Amity.LiveObjectCallback<Amity.Membership<'channel'> | undefined>) =>
-      getMyMembership(channel.channelId, callback),
-  });
-};

package/src/utils/linkedObject/channelMemberLinkedObject.ts

@@ -1,20 +0,0 @@
-import { pullFromCache } from '~/cache/api/pullFromCache';
-import { userLinkedObject } from './userLinkedObject';
-
-export const channelMemberLinkedObject = (
-  channelMember: Amity.Membership<'channel'>,
-): Amity.Membership<'channel'> => {
-  const getUser = (): Amity.User | undefined => {
-    const cacheKey = ['user', 'get', channelMember.userId];
-    const internalUser = pullFromCache<Amity.InternalUser>(cacheKey)?.data;
-
-    return internalUser ? userLinkedObject(internalUser) : undefined;
-  };
-
-  return {
-    ...channelMember,
-    get user() {
-      return getUser();
-    },
-  };
-};

package/src/utils/linkedObject/commentLinkedObject.ts

@@ -1,66 +0,0 @@
-import { pullFromCache } from '~/cache/api/pullFromCache';
-import { userLinkedObject } from './userLinkedObject';
-import { isNonNullable } from '~/utils';
-
-export const commentLinkedObject = (comment: Amity.InternalComment): Amity.Comment => {
-  return {
-    ...comment,
-    get target(): Amity.CommentTarget {
-      const commentTypes: Amity.CommentTarget = {
-        type: comment.targetType,
-      };
-
-      if (comment.targetType === 'user') {
-        return {
-          ...commentTypes,
-          userId: comment.targetId,
-        };
-      }
-
-      if (commentTypes.type === 'content') {
-        return {
-          ...commentTypes,
-          contentId: comment.targetId,
-        };
-      }
-
-      if (commentTypes.type === 'community') {
-        const cacheData = pullFromCache<Amity.Membership<'community'>>([
-          'communityUsers',
-          'get',
-          `${comment.targetId}#${comment.userId}`,
-        ]);
-
-        return {
-          ...commentTypes,
-          communityId: comment.targetId,
-          creatorMember: cacheData?.data,
-        };
-      }
-
-      return {
-        type: 'unknown',
-      };
-    },
-    get creator(): Amity.User | undefined {
-      const cacheData = pullFromCache<Amity.User>(['user', 'get', comment.userId]);
-      if (cacheData?.data) return userLinkedObject(cacheData.data);
-      return undefined;
-    },
-    get childrenComment(): Amity.Comment[] {
-      return comment.children
-        .map(childCommentId => {
-          const commentCache = pullFromCache<Amity.InternalComment>([
-            'comment',
-            'get',
-            childCommentId,
-          ]);
-
-          if (!commentCache?.data) return;
-          return commentCache?.data;
-        })
-        .filter(isNonNullable)
-        .map(item => commentLinkedObject(item!));
-    },
-  };
-};

package/src/utils/linkedObject/communityLinkedObject.ts

@@ -1,68 +0,0 @@
-import { InvitationTypeEnum } from '~/@types';
-import { pullFromCache } from '~/cache/api/pullFromCache';
-import { getMyJoinRequest } from '~/communityRepository/internalAPI/getMyJoinRequest';
-import { joinRequest } from '~/communityRepository/internalAPI/joinCommunity';
-import { getJoinRequests } from '~/communityRepository/observers/getJoinRequests';
-import { createInvitations } from '~/invitationRepository/internalApi';
-import { getInvitation } from '~/invitationRepository/internalApi/getInvitation';
-import { getInvitations } from '~/invitationRepository/observers/getInvitations';
-import { categoryLinkedObject } from './categoryLinkedObject';
-
-export const communityLinkedObject = (community: Amity.InternalCommunity): Amity.Community => {
-  return {
-    ...community,
-    get categories(): Amity.Category[] {
-      return (community?.categoryIds ?? [])
-        .map(categoryId => {
-          const cacheData = pullFromCache<Amity.Category>(['category', 'get', categoryId]);
-          if (cacheData?.data) return categoryLinkedObject(cacheData.data);
-          return undefined;
-        })
-        .filter(category => !!category);
-    },
-    createInvitations: async (userIds: string[]): Promise<void> => {
-      await createInvitations({
-        type: InvitationTypeEnum.CommunityMemberInvite,
-        targetType: 'community',
-        targetId: community.communityId,
-        userIds,
-      });
-    },
-    getMemberInvitations: (
-      params: Pick<Amity.InvitationLiveCollection, 'limit' | 'sortBy' | 'statuses'>,
-      callback: Amity.LiveCollectionCallback<Amity.Invitation>,
-    ): Amity.Unsubscriber => {
-      return getInvitations(
-        {
-          ...params,
-          targetId: community.communityId,
-          targetType: 'community',
-          type: InvitationTypeEnum.CommunityMemberInvite,
-        },
-        callback,
-      );
-    },
-    getInvitation: async () => {
-      const { data } = await getInvitation('community', community.communityId);
-      return data;
-    },
-    join: async () => joinRequest(community.communityId),
-
-    getJoinRequests: (
-      params: Omit<Amity.QueryJoinRequest, 'communityId'>,
-      callback: Amity.LiveCollectionCallback<Amity.JoinRequest>,
-    ): Amity.Unsubscriber => {
-      return getJoinRequests(
-        {
-          ...params,
-          communityId: community.communityId,
-        },
-        callback,
-      );
-    },
-    getMyJoinRequest: async () => {
-      const { data } = await getMyJoinRequest(community.communityId);
-      return data;
-    },
-  };
-};

package/src/utils/linkedObject/index.ts

@@ -1,37 +0,0 @@
-import { storyLinkedObject } from '~/utils/linkedObject/storyLinkedObject';
-import { streamLinkedObject } from '~/utils/linkedObject/streamLinkedObject';
-import { categoryLinkedObject } from './categoryLinkedObject';
-import { commentLinkedObject } from './commentLinkedObject';
-import { userLinkedObject } from './userLinkedObject';
-import { postLinkedObject } from './postLinkedObject';
-import { messageLinkedObject } from './messageLinkedObject';
-import { storyTargetLinkedObject } from './storyTargetLinkedObject';
-import { reactorLinkedObject } from './reactorLinkedObject';
-import { channelLinkedObject } from './channelLinkedObject';
-import { adLinkedObject } from './adLinkedObject';
-import { pinnedPostLinkedObject } from './pinnedPostLinkedObject';
-import { notificationTrayLinkedObject } from './notificationTrayLinkedObject';
-import { communityLinkedObject } from './communityLinkedObject';
-import { invitationLinkedObject } from './invitationLinkedObject';
-import { joinRequestLinkedObject } from './joinRequestLinkedObject';
-import { channelMemberLinkedObject } from './channelMemberLinkedObject';
-
-export const LinkedObject = {
-  ad: adLinkedObject,
-  comment: commentLinkedObject,
-  post: postLinkedObject,
-  user: userLinkedObject,
-  category: categoryLinkedObject,
-  stream: streamLinkedObject,
-  story: storyLinkedObject,
-  storyTarget: storyTargetLinkedObject,
-  message: messageLinkedObject,
-  reactor: reactorLinkedObject,
-  channel: channelLinkedObject,
-  pinnedPost: pinnedPostLinkedObject,
-  notificationTray: notificationTrayLinkedObject,
-  community: communityLinkedObject,
-  invitation: invitationLinkedObject,
-  joinRequest: joinRequestLinkedObject,
-  channelMember: channelMemberLinkedObject,
-};

package/src/utils/linkedObject/invitationLinkedObject.ts

@@ -1,37 +0,0 @@
-import { pullFromCache } from '~/cache/api';
-import { userLinkedObject } from './userLinkedObject';
-import { acceptInvitation, rejectInvitation } from '~/invitationRepository/internalApi';
-
-export const invitationLinkedObject = (invitation: Amity.InternalInvitation): Amity.Invitation => {
-  return {
-    ...invitation,
-    get user(): Amity.User | undefined {
-      const cacheData = pullFromCache<Amity.User>(['user', 'get', invitation.invitedUserPublicId]);
-      if (cacheData?.data) return userLinkedObject(cacheData.data);
-      return undefined;
-    },
-    get createdBy(): Amity.User | undefined {
-      const cacheData = pullFromCache<Amity.User>(['user', 'get', invitation.inviterUserPublicId]);
-      if (cacheData?.data) return userLinkedObject(cacheData.data);
-      return undefined;
-    },
-    get target(): Amity.InvitationTarget<Amity.InvitationTargetType> | undefined {
-      if (invitation.targetType === 'community') {
-        const cacheData = pullFromCache<Amity.InternalCommunity>([
-          'community',
-          'get',
-          invitation.targetId,
-        ]);
-        if (cacheData?.data) return cacheData.data;
-        return undefined;
-      }
-      return undefined;
-    },
-    accept: async () => {
-      await acceptInvitation(invitation._id);
-    },
-    reject: async () => {
-      await rejectInvitation(invitation._id);
-    },
-  };
-};

package/src/utils/linkedObject/joinRequestLinkedObject.ts

@@ -1,31 +0,0 @@
-import { pullFromCache } from '~/cache/api';
-import { userLinkedObject } from './userLinkedObject';
-import { approveJoinRequest } from '~/communityRepository/joinRequest/internalAPI/approveJoinRequest';
-import { cancelJoinRequest } from '~/communityRepository/joinRequest/internalAPI/cancelJoinRequest';
-import { rejectJoinRequest } from '~/communityRepository/joinRequest/internalAPI/rejectJoinRequest';
-
-export const joinRequestLinkedObject = (
-  joinRequest: Amity.InternalJoinRequest,
-): Amity.JoinRequest => {
-  return {
-    ...joinRequest,
-    get user(): Amity.User | undefined {
-      const user = pullFromCache<Amity.InternalUser>([
-        'user',
-        'get',
-        joinRequest.requestorPublicId,
-      ])?.data;
-      if (!user) return undefined;
-      return userLinkedObject(user);
-    },
-    cancel: async () => {
-      await cancelJoinRequest(joinRequest);
-    },
-    approve: async () => {
-      await approveJoinRequest(joinRequest);
-    },
-    reject: async () => {
-      await rejectJoinRequest(joinRequest);
-    },
-  };
-};

package/src/utils/linkedObject/messageLinkedObject.ts

@@ -1,24 +0,0 @@
-import { pullFromCache } from '~/cache/api';
-import { addReactionToMessage } from '~/messageRepository/utils/addReactionToMessage';
-import { getMessageReadCount } from '~/messageRepository/utils/getMessageReadCount';
-import { markReadMessage } from '~/messageRepository/utils/markReadMessage';
-import { removeReactionToMessage } from '~/messageRepository/utils/removeReactionToMessage';
-
-export const messageLinkedObject = (message: Amity.InternalMessage): Amity.Message => {
-  const { creatorPrivateId, ...rest } = message;
-  return {
-    ...rest,
-    get readCount() {
-      return getMessageReadCount(message).readCount;
-    },
-    get deliveredCount() {
-      return getMessageReadCount(message).deliveredCount;
-    },
-    get creator() {
-      return pullFromCache<Amity.InternalUser>(['user', 'get', message.creatorId])?.data;
-    },
-    markRead: () => markReadMessage(message),
-    addReaction: (reactionName: string) => addReactionToMessage(reactionName, message),
-    removeReaction: (reactionName: string) => removeReactionToMessage(reactionName, message),
-  };
-};

package/src/utils/linkedObject/notificationTrayLinkedObject.ts

@@ -1,19 +0,0 @@
-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)),
-  };
-};