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

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

@@ -1,196 +0,0 @@
-import { VideoResolution } from './file';
-
-declare global {
-  namespace Amity {
-    type CommunityStorySettings = {
-      storySetting?: {
-        enableComment?: boolean;
-      };
-    };
-
-    type StoryTargetType = 'community' | 'user' | 'content';
-
-    type StorySortBy = 'createdAt' | 'updatedAt';
-
-    const enum StoryItemType {
-      Hyperlink = 'hyperlink',
-    }
-
-    const enum StoryActionType {
-      OnCreate = 'onCreate',
-      OnUpdate = 'onUpdate',
-      OnDelete = 'onDelete',
-      OnError = 'onError',
-      OnReactionAdded = 'onReactionAdded',
-      OnReactionRemoved = 'onReactionRemoved',
-    }
-
-    const enum StoryDataType {
-      Text = 'text',
-      Image = 'image',
-      Video = 'video',
-    }
-
-    const enum StorySeenQuery {
-      SEEN = 'seen',
-      UNSEEN = 'unseen',
-      ALL = 'all',
-      SMART = 'smart',
-    }
-
-    type StorySortOption = {
-      sortBy?: StorySortBy;
-      orderBy?: 'asc' | 'desc';
-    };
-
-    type StoryGlobalQuery = {
-      seenState: Amity.StorySeenQuery;
-    };
-
-    type RawStoryTarget = {
-      targetId: string;
-      targetType: string;
-      targetPublicId: string;
-      targetUpdatedAt: Amity.timestamp;
-
-      lastStoryExpiresAt?: Amity.timestamp;
-      lastStorySeenExpiresAt?: Amity.timestamp;
-
-      localFilter?: Amity.StorySeenQuery;
-    };
-
-    type StoryTargetQueryParam = Pick<Amity.RawStoryTarget, 'targetId' | 'targetType'>;
-
-    type StoryTargetLiveObjectParam = {
-      query: Amity.StoryTargetQueryParam;
-    };
-
-    type GetStoriesByTargetParam = {
-      options?: Amity.StorySortOption;
-    } & Amity.StoryTargetQueryParam;
-
-    type StoryLiveCollection = {
-      targets: Amity.StoryTargetQueryParam[];
-      options?: Amity.StorySortOption;
-    };
-
-    type StoryTarget = Pick<Amity.RawStoryTarget, 'targetId' | 'targetType'> & {
-      updatedAt: Amity.timestamp;
-      hasUnseen: boolean;
-      lastStoryExpiresAt?: Amity.timestamp;
-
-      localLastExpires: number;
-      localLastSeen: number;
-      localSortingDate: number;
-      localFilter?: Amity.StorySeenQuery;
-
-      syncingStoriesCount: number;
-      failedStoriesCount: number;
-    };
-
-    type StoryItemData<T extends StoryItemType> = T extends 'hyperlink'
-      ? { url: string; customText: string }
-      : never;
-
-    type StoryItem = {
-      type: StoryItemType;
-      data: StoryItemData<StoryItemType>;
-      placement?: {
-        width: number;
-        height: number;
-        transform: {
-          translate_x: number;
-          translate_y: number;
-          scale_x: number;
-          scale_y: number;
-          rotate: number;
-        };
-      };
-    };
-
-    // internal used for optimistic update
-    type StoryOptimistic = {
-      syncState?: Amity.SyncState;
-    };
-
-    type StoryLinkedObject = {
-      videoData?: Amity.File<'video'>;
-      imageData?: Amity.File<'image'>;
-      analytics: {
-        markAsSeen: () => void;
-        markLinkAsClicked: () => void;
-      };
-      creator?: Amity.User;
-      storyTarget?: Amity.StoryTarget;
-      community?: Amity.Community;
-      communityCategories?: Amity.Category[];
-      isSeen?: boolean;
-    };
-
-    type RawStory = {
-      storyId: string;
-      path: string;
-      creatorId: Amity.InternalUser['userId'];
-      creatorPublicId: string;
-      targetId: string;
-      targetPublicId: string;
-      targetType: StoryTargetType;
-      dataType: StoryDataType;
-      items: StoryItem[];
-      data: {
-        text?: string;
-        fileId?: Amity.File['fileId'];
-        fileData?: ArrayBuffer | string | null;
-        thumbnailFileId?: Amity.File['fileId'];
-        imageDisplayMode?: Amity.ImageDisplayMode;
-        videoFileId?: {
-          [VideoResolution.ORIGINAL]?: string;
-        };
-      };
-      comments: Amity.Comment['commentId'][];
-      commentsCount: Amity.InternalPost['commentsCount'];
-      isDeleted: boolean;
-      hasFlaggedComment: boolean;
-      mentionedUsers: Amity.Post['mentionees'];
-      impression: 0;
-      reach: 0;
-      referenceId?: string;
-    } & Amity.Metadata &
-      Amity.Flaggable &
-      Amity.CreatedAt &
-      Amity.UpdatedAt &
-      Amity.ExpiresAt &
-      Amity.Reactable;
-
-    type InternalStory = Amity.RawStory & Amity.StoryOptimistic;
-
-    type StoryCreatePayload = {
-      data: {
-        text?: string;
-        fileId?: Amity.File['fileId'];
-        fileData?: ArrayBuffer | string | null;
-        imageDisplayMode?: Amity.ImageDisplayMode;
-        videoFileId?: Amity.RawStory['data']['videoFileId'];
-      };
-      referenceId: string; // Random ID used to reference story item between local-optimistic data and BE
-      dataType: Amity.StoryDataType;
-      items: Amity.StoryItem[];
-      targetType: Amity.StoryTargetType;
-      targetId: string;
-      metadata: Amity.Metadata;
-      syncState: Amity.SyncState;
-    };
-
-    type StoryLiveCollectionCache = Amity.LiveCollectionCache<
-      Amity.InternalStory['referenceId'],
-      { page?: Amity.Token }
-    >;
-
-    type StoryTargetLiveCollectionCache = Amity.LiveCollectionCache<
-      Amity.RawStoryTarget['targetId'],
-      { page?: Amity.Token }
-    >;
-
-    type Story = Amity.InternalStory & Amity.StoryLinkedObject;
-  }
-}

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

@@ -1,138 +0,0 @@
-export {};
-
-declare global {
-  namespace Amity {
-    const enum StreamStatus {
-      IDLE = 'idle',
-      LIVE = 'live',
-      ENDED = 'ended',
-      RECORDED = 'recorded',
-    }
-
-    const enum StreamResolution {
-      SD = 'SD',
-      HD = 'HD',
-      FHD = 'FHD',
-    }
-
-    type MultiFormat<T> = {
-      flv?: T;
-      mp4?: T;
-      hls?: T;
-      m3u8?: T;
-      rtmp?: T;
-    };
-
-    type StreamPlatform = {
-      name: string;
-      version: string;
-    };
-
-    type StreamEndpoint = {
-      url: string;
-      components: {
-        origin: string;
-        appName: string;
-        streamName: string;
-        query: string;
-      };
-    };
-
-    type StreamRecording = {
-      url: string;
-      duration: number;
-      startTime: number;
-      stopTime: number;
-    };
-
-    type RawStream = {
-      streamId: string;
-      title: string;
-      thumbnailFileId?: Amity.File<'image'>['fileId'];
-      description?: string;
-      status: StreamStatus;
-      platform: StreamPlatform;
-
-      isLive?: boolean;
-      endedAt: Amity.timestamp;
-      startedAt: Amity.timestamp;
-      userId: Amity.InternalUser['userId'];
-      resolution: StreamResolution;
-
-      streamerUrl: StreamEndpoint;
-      watcherUrl: MultiFormat<StreamEndpoint>;
-      recordings: MultiFormat<StreamRecording>[];
-
-      /*
-       * If the stream is create and use to create a post,
-       * the referenceType should be 'post' and referenceId should be the postId.
-       */
-      referenceId?: string; // 'post', etc..
-      referenceType?: string;
-      /*
-       * Target is the livestream post's target when create a post.
-       */
-      targetId?: string; // communityId, userId, etc..
-      targetType?: string; // 'community', 'user', etc..
-      /*
-       * when stream linked with a post and a live channel.
-       */
-      postId?: string;
-      channelId?: string;
-      channelEnabled?: boolean;
-
-      isParent: boolean;
-      parentStreamId?: string;
-      childStreamIds: string[];
-    } & Amity.Metadata &
-      Amity.Timestamps &
-      Amity.SoftDelete;
-
-    type InternalStream = RawStream;
-
-    type StreamLinkedObject = {
-      moderation?: Amity.StreamModeration;
-      post?: Amity.InternalPost;
-      childStreams: Amity.Stream[];
-      getLiveChat: () => Promise<Amity.Channel<'live'> | undefined>;
-    };
-
-    type Stream = Omit<Amity.InternalStream & Amity.StreamLinkedObject, 'watcherUrl'> & {
-      isBanned: boolean;
-      watcherUrl: null;
-    };
-
-    type QueryStreams = {
-      isLive?: boolean;
-      statuses?: Amity.StreamStatus[];
-      userPublicIds?: Amity.InternalUser['userId'][];
-      sortBy?: 'lastCreated' | 'firstCreated';
-      isDeleted?: Amity.InternalStream['isDeleted'];
-      page?: string;
-      limit?: number;
-    };
-
-    type StreamModerationLabel = {
-      categoryId: string;
-      detectedAt: Amity.timestamp;
-    };
-
-    type StreamModeration = {
-      moderationId: string;
-      streamId: Amity.InternalStream['streamId'];
-      flagLabels: Amity.StreamModerationLabel[];
-      terminateLabels: Amity.StreamModerationLabel[];
-      createdAt: Amity.timestamp;
-      updatedAt: Amity.timestamp;
-    };
-
-    type StreamLiveCollection = Amity.LiveCollectionParams<Omit<QueryStreams, 'page'>>;
-
-    type StreamLiveCollectionCache = Amity.LiveCollectionCache<
-      Amity.InternalStream['streamId'],
-      Pick<QueryStreams, 'page'>
-    >;
-
-    type StreamActionType = 'onStreamRecorded' | 'onStreamStarted' | 'onStreamStopped';
-  }
-}

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

@@ -1,59 +0,0 @@
-export {};
-
-declare global {
-  namespace Amity {
-    type RawSubChannel = {
-      channelId: string;
-      channelPublicId: string;
-      channelType: Amity.ChannelType;
-      childCount: number;
-      creatorId: string;
-      creatorPublicId: string;
-      editedAt?: Amity.timestamp;
-      isDeleted: boolean;
-      messageFeedId: string;
-      lastMessageId: string;
-      lastMessageTimestamp: Amity.timestamp;
-      name: string;
-      messagePreviewId?: string | null;
-    } & Amity.Timestamps &
-      Amity.Subscribable;
-
-    /* internal use only */
-    // type SubChannelModel = RawSubChannel & {};
-
-    /* public type */
-    type SubChannel = {
-      channelId: string;
-      creatorId: string;
-      displayName: string;
-      editedAt?: Amity.timestamp;
-      isDeleted: boolean;
-      messageCount: number;
-      lastActivity: Amity.timestamp;
-      latestMessageId: string;
-      subChannelId: string;
-      isUnreadCountSupport: boolean;
-      unreadCount: number;
-      isMentioned: boolean;
-      messagePreviewId?: string | null;
-      messagePreview?: Amity.MessagePreview | null;
-    } & Amity.Timestamps &
-      Amity.Subscribable;
-
-    type QuerySubChannels = {
-      channelId: Amity.Channel['channelId'];
-      excludeDefaultSubChannel?: boolean;
-      includeDeleted?: boolean;
-      page?: Amity.Page;
-      pageToken?: string;
-    };
-
-    type SubChannelLiveCollection = Amity.LiveCollectionParams<Omit<QuerySubChannels, 'page'>>;
-
-    type SubChannelLiveCollectionCache = Amity.LiveCollectionCache<
-      Amity.SubChannel['subChannelId'],
-      Pick<QuerySubChannels, 'page'> & { paging?: Amity.Pagination['paging'] }
-    >;
-  }
-}

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

@@ -1,103 +0,0 @@
-import { AmityUserSearchMatchType } from '~/userRepository';
-
-export const enum UserTypeEnum {
-  SIGNED_IN = 'signed-in',
-  VISITOR = 'visitor',
-  BOT = 'bot',
-}
-
-export {};
-
-declare global {
-  namespace Amity {
-    const enum UserSortByEnum {
-      FirstCreated = 'firstCreated',
-      LastCreated = 'lastCreated',
-    }
-
-    type UserSearchMatchType = AmityUserSearchMatchType;
-
-    type UserSortBy = `${Amity.UserSortByEnum}`;
-
-    const enum SearchUserSortByEnum {
-      FirstCreated = 'firstCreated',
-      LastCreated = 'lastCreated',
-      DisplayName = 'displayName',
-    }
-
-    type SearchUserSortBy = `${Amity.SearchUserSortByEnum}`;
-
-    type UserActionType =
-      | 'onFetch'
-      | 'onUpdate'
-      | 'onDelete'
-      | 'onFlagged'
-      | 'onUnflagged'
-      | 'onFlagCleared';
-
-    type UserType = `${UserTypeEnum}`;
-
-    type RawUser = {
-      _id: string;
-      userId: string;
-      userInternalId: string;
-      userPublicId: string;
-      displayName?: string;
-      avatarFileId?: string;
-      avatarCustomUrl?: string;
-      description?: string;
-      isBrand: boolean;
-      isGlobalBan: boolean;
-    } & Amity.Metadata &
-      Amity.Taggable &
-      Amity.Flaggable &
-      Amity.Accredited &
-      Amity.Timestamps &
-      Amity.SoftDelete &
-      Amity.Subscribable;
-
-    type InternalUser = Amity.RawUser & {
-      isGlobalBanned: boolean;
-    } & Amity.Metadata &
-      Amity.Taggable &
-      Amity.Flaggable &
-      Amity.Accredited &
-      Amity.Timestamps &
-      Amity.SoftDelete &
-      Amity.Subscribable;
-
-    type User = Amity.InternalUser & {
-      avatar?: Amity.File<'image'> | null;
-    };
-
-    type QueryUsers = {
-      filter?: 'all' | 'flagged';
-      sortBy?: Amity.UserSortBy | Amity.UserSortByEnum;
-      limit?: number;
-      page?: string;
-      matchType?: UserSearchMatchType;
-    };
-
-    type QuerySearchUsers = {
-      displayName?: Amity.InternalUser['displayName'];
-      filter?: 'all' | 'flagged';
-      sortBy?: Amity.SearchUserSortBy | Amity.SearchUserSortByEnum;
-      limit?: number;
-      page?: string;
-      matchType?: UserSearchMatchType;
-    };
-
-    type UserLiveCollection = Amity.LiveCollectionParams<Omit<Amity.QueryUsers, 'page'>>;
-
-    type SearchUserLiveCollection = Amity.LiveCollectionParams<
-      Omit<Amity.QuerySearchUsers, 'sortBy'>
-    >;
-
-    type UserSearchLiveCollection = Amity.SearchUserLiveCollection;
-
-    type UserLiveCollectionCache = Amity.LiveCollectionCache<
-      Amity.InternalUser['userId'],
-      Pick<QueryUsers, 'page'>
-    >;
-  }
-}

package/src/@types/global.ts

@@ -1,65 +0,0 @@
-export {};
-
-declare global {
-  type Writeable<T> = { -readonly [P in keyof T]: T[P] };
-
-  type Patch<T, K extends keyof T> = Partial<Pick<T, K>>;
-
-  type Unwrap<T> = T extends Promise<infer U>
-    ? U
-    : T extends (...args: any) => Promise<infer U>
-    ? U
-    : T extends (...args: any) => infer U
-    ? U
-    : T;
-
-  // eslint-disable-next-line @typescript-eslint/ban-types
-  type ObjectKeys<T> = T extends object
-    ? (keyof T)[]
-    : T extends number
-    ? []
-    : T extends Array<any> | string
-    ? string[]
-    : never;
-
-  interface ObjectConstructor {
-    keys<T>(o: T): ObjectKeys<T>;
-  }
-
-  type ValueOf<T extends Record<any, any>> = T[keyof T];
-
-  /**
-   *  Make properties required otherwise optional
-   */
-  type MakeRequired<T, K extends keyof T> = Required<Pick<T, K>> & Partial<T>;
-
-  /**
-   *  Make properties optional otherwise required
-   */
-  type MakeOptional<T, K extends keyof T> = Partial<Pick<T, K>> & Required<T>;
-}
-
-/*
- * Extented to pass token expiry into request config, for internal use only.
- * Since it's in the request config, it does not get sent for the server, and
- * allows us to intercept the tokenExpiry value to check if the token has not
- * expired & cancel the request if yes.
- *
- */
-declare module 'axios' {
-  interface MetaData {
-    tokenExpiry: string;
-    isGlobalBanned: boolean;
-    isUserDeleted: boolean;
-  }
-
-  export interface AxiosDefaults {
-    // expires at iso string for access token
-    metadata?: MetaData;
-  }
-
-  export interface AxiosRequestConfig {
-    // expires at iso string for access token
-    metadata?: MetaData;
-  }
-}

package/src/@types/index.ts

@@ -1,49 +0,0 @@
-import './global'; // global types (system)
-import './core/errors'; // global errors
-import './core/permissions'; // permissions enum
-import './core/payload'; // backend payload definition
-import './core/events'; // sdk events definitions
-import './core/paging'; // createQuery, runQuery
-import './core/query'; // createQuery, runQuery
-import './core/cache'; // cache.pull('user', ...)
-import './core/live';
-
-// domains
-import './domains/client'; // client definition
-import './domains/user';
-import './domains/follow';
-
-import './domains/partials'; // small model partials (CreatedAt, etc...)
-import './domains/reaction';
-
-import './domains/group';
-import './domains/channel';
-import './domains/subChannel';
-
-import './domains/category';
-import './domains/comment';
-
-import './domains/stream';
-
-import './domains/mention';
-
-import './domains/poll';
-import './domains/story';
-
-export * from './domains/community';
-export * from './domains/content';
-export * from './domains/file';
-export * from './domains/message';
-export * from './domains/post';
-export * from './domains/story';
-export * from './domains/ad';
-export * from './domains/notification';
-export * from './domains/client';
-export * from './domains/invitation';
-export * from './domains/joinRequest';
-export * from './domains/pin';
-export * from './domains/pinnedPost';
-export * from './domains/liveReaction';
-export * from './domains/feed';
-export * from './domains/hashtag';
-export * from './domains/user';

package/src/@types/mqtt.d.ts

@@ -1,3 +0,0 @@
-declare module 'mqtt/dist/mqtt' {
-  export * from 'mqtt';
-}

package/src/adRepository/api/getNetworkAds.ts

@@ -1,38 +0,0 @@
-import { getActiveClient } from '~/client';
-import { ingestInCache } from '~/cache/api/ingestInCache';
-import { pushToCache } from '~/cache/api';
-import { LinkedObject } from '~/utils/linkedObject';
-
-const convertToInternalAd = (ad: Amity.RawAd): Amity.InternalAd => {
-  return {
-    ...ad,
-    endAt: ad.endAt ? ad.endAt : null,
-  };
-};
-
-const convertToInternalAdvertiser = (advertiser: Amity.RawAdvertiser): Amity.InternalAdvertiser => {
-  return {
-    ...advertiser,
-  };
-};
-
-export const getNetworkAds = async (): Promise<Amity.NetworkAds> => {
-  const client = getActiveClient();
-
-  const { data } = await client.http.get<Amity.AdPayload>('/api/v1/ads/me');
-
-  const internalAds = data.ads.map(convertToInternalAd);
-  const internalAdvertisers = data.advertisers.map(convertToInternalAdvertiser);
-
-  ingestInCache({
-    ads: internalAds,
-    advertisers: internalAdvertisers,
-    files: data.files,
-  });
-  pushToCache(['ad', 'setting'], data.settings);
-
-  return {
-    ads: internalAds.map(LinkedObject.ad),
-    settings: data.settings,
-  };
-};

package/src/adRepository/api/index.ts

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

package/src/adRepository/index.ts

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

package/src/analytic/api/queryReachUser.ts

@@ -1,36 +0,0 @@
-import { getActiveClient } from '~/client';
-import { ingestInCache } from '~/cache/api/ingestInCache';
-
-export const queryReachUser = async ({
-  viewId,
-  viewedType,
-  limit,
-  token,
-}: {
-  viewId: Amity.ViewedUsersLiveCollection['viewId'];
-  viewedType: Amity.ViewedUsersLiveCollection['viewedType'];
-  limit: number;
-  token?: string;
-}) => {
-  const client = getActiveClient();
-
-  const params: { token?: string; limit?: number } = {};
-  if (token) {
-    // If it's not a first query, we can use token to get next user list from previous query.
-    params.token = token;
-  } else {
-    // First query.
-    params.limit = limit;
-  }
-
-  const view = viewedType === 'post' ? 'posts' : 'stories';
-  const url = `/api/v1/analytics/views/${view}/${viewId}/users`;
-
-  const response = await client.http.get(url, {
-    params,
-  });
-
-  ingestInCache(response.data);
-
-  return response.data;
-};