@amityco/ts-sdk-react-native 6.7.1-80c1951.0

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

@@ -0,0 +1,111 @@
+export const MessageContentType = Object.freeze({
+  TEXT: 'text',
+  IMAGE: 'image',
+  FILE: 'file',
+  VIDEO: 'video',
+  AUDIO: 'audio',
+  CUSTOM: 'custom',
+});
+
+declare global {
+  namespace Amity {
+    type MessageContentType = ValueOf<typeof MessageContentType>;
+
+    type MessageActionType =
+      | 'onCreate'
+      | 'onUpdate'
+      | 'onDelete'
+      | 'onFetch'
+      | 'onFlagged'
+      | 'onUnflagged'
+      | 'onFlagCleared'
+      | 'onReactionAdded'
+      | 'onReactionRemoved';
+
+    type RawMessage<T extends Amity.MessageContentType = any> = {
+      channelId: string;
+      channelPublicId: string;
+      channelType: Amity.Channel['type'];
+      childCount: number;
+      creatorId: string;
+      creatorPublicId: string;
+      // TODO: check if editedAt appears on edit
+      editedAt?: Amity.timestamp;
+      mentionedUsers?: Array<
+        Amity.ChannelMention | (Amity.UserMention & { userPublicIds: string[] })
+      >;
+      messageFeedId: Amity.RawSubChannel['messageFeedId'];
+      messageId: string;
+      myReactions?: string[];
+      parentId?: string;
+      reactionCount: number;
+      reactions?: Record<string, number>;
+      referenceId?: string; // https://ekoapp.atlassian.net/wiki/spaces/UP/pages/2085716114/SDK+V5+message+migration#Handling-%E2%80%98ReferenceId%E2%80%99-in-message-creation
+      segment: number;
+    } & Amity.Content<T> &
+      Amity.Flaggable &
+      Amity.Metadata &
+      // Amity.Reactable &
+      Amity.SoftDelete &
+      Amity.Subscribable &
+      Amity.Taggable &
+      Amity.Timestamps;
+
+    type Message<T extends Amity.MessageContentType = any> = {
+      channelId: Amity.Channel['channelId'];
+      channelSegment: number;
+      childrenNumber: number;
+      creatorId: string;
+      editedAt?: Amity.timestamp;
+      parentId?: string;
+      messageId: string;
+      subChannelId: Amity.SubChannel['subChannelId'];
+      channelType: Amity.Channel['type'];
+      uniqueId: string;
+      readCount: number;
+      deliveredCount: number;
+      referenceId?: string;
+    } & Amity.Content<T> &
+      Amity.Mentionable<'user' | 'channel'> &
+      Amity.Metadata &
+      Amity.Reactable &
+      Amity.SoftDelete &
+      Amity.Subscribable &
+      Amity.Timestamps &
+      Amity.Taggable;
+
+    type QueryMessages = {
+      subChannelId: Amity.SubChannel['subChannelId'];
+      dataType?: Amity.MessageContentType;
+      excludeTags?: Amity.Taggable['tags'];
+      hasFlags?: boolean;
+      includeDeleted?: boolean;
+      /*
+       * For messages the after and before values are messageId
+       */
+      page?: Amity.Page<string>;
+      parentId?: Amity.Message['parentId'];
+      sortBy?: 'segmentAsc' | 'segmentDesc';
+      tags?: Amity.Taggable['tags'];
+    };
+
+    type QueryReadUsers = {
+      messageId: Amity.Message['messageId'];
+      memberships?: ('member' | 'banned' | 'muted' | 'non-member' | 'deleted')[];
+      page?: Amity.Page;
+    };
+
+    type QueryDeliveredUsers = {
+      messageId: Amity.Message['messageId'];
+      memberships?: ('member' | 'banned' | 'muted' | 'non-member' | 'deleted')[];
+      page?: Amity.Page;
+    };
+
+    type MessagesLiveCollection = Amity.LiveCollectionParams<Omit<QueryMessages, 'page'>>;
+
+    type MessageLiveCollectionCache = Amity.LiveCollectionCache<
+      Amity.Message['subChannelId'],
+      Pick<QueryMessages, 'page'>
+    >;
+  }
+}

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

@@ -0,0 +1,60 @@
+export {};
+
+declare global {
+  namespace Amity {
+    type timestamp = string;
+
+    type CreatedAt = {
+      createdAt: timestamp;
+    };
+
+    type UpdatedAt = {
+      updatedAt?: timestamp;
+    };
+
+    type DeletedAt = {
+      deletedAt?: timestamp;
+    };
+
+    type SyncAt = {
+      lastSyncAt: timestamp;
+    };
+
+    type Timestamps = CreatedAt & UpdatedAt;
+
+    type SoftDelete = DeletedAt & {
+      isDeleted?: boolean;
+    };
+
+    type Metadata = {
+      metadata?: Record<string, any>;
+    };
+
+    type Relationship<T extends string> = {
+      referenceId: string;
+      referenceType: T;
+    };
+
+    type Flaggable = {
+      flagCount: number;
+      hashFlag: {
+        bits: number;
+        hashes: number;
+        hash: string;
+      } | null;
+    };
+
+    type Taggable = {
+      tags?: string[];
+    };
+
+    type Accredited = {
+      roles: Amity.Role['displayName'][];
+      permissions: Amity.Permission[];
+    };
+
+    type Subscribable = {
+      path: string;
+    };
+  }
+}

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

@@ -0,0 +1,32 @@
+export {};
+
+declare global {
+  namespace Amity {
+    type PollDataType = 'text';
+
+    type PollAnswerType = 'single' | 'multiple';
+
+    type PollAnswer = {
+      id: string;
+      dataType: PollDataType;
+      data: string;
+      voteCount: number;
+      isVotedByUser: boolean;
+    };
+
+    type PollStatus = 'closed' | 'open';
+
+    type Poll = {
+      pollId: string;
+      question: string;
+      answers: PollAnswer[];
+      answerType: PollAnswerType;
+      closedAt?: Amity.timestamp;
+      closedIn?: number;
+      isVoted?: boolean;
+      status: PollStatus;
+      userId: Amity.User['userId'];
+    } & Amity.Timestamps &
+      Amity.SoftDelete;
+  }
+}

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

@@ -0,0 +1,78 @@
+export const PostContentType = Object.freeze({
+  TEXT: 'text',
+  IMAGE: 'image',
+  FILE: 'file',
+  VIDEO: 'video',
+  LIVESTREAM: 'liveStream',
+  POLL: 'poll',
+  CUSTOM: 'custom',
+});
+
+declare global {
+  namespace Amity {
+    // bad hack until we get proper feed objects in backend
+    type PostTargetType = Amity.Feed['targetType'] | 'content';
+
+    type PostContentType = ValueOf<typeof PostContentType>;
+
+    type PostActionType =
+      | 'onFetch'
+      | 'onCreate'
+      | 'onUpdate'
+      | 'onDelete'
+      | 'onApproved'
+      | 'onDeclined'
+      | 'onFlagged'
+      | 'onUnflagged'
+      | 'onReactionAdded'
+      | 'onReactionRemoved';
+
+    type Post<T extends PostContentType = any> = {
+      postId: string;
+      postedUserId: Amity.User['userId']; // API-FIX: it should be "userId"
+      parentId: Post['postId'];
+      targetType: PostTargetType;
+      targetId: string;
+      feedId: Amity.Feed['feedId'];
+      children: Amity.Post['postId'][];
+      comments: Amity.Comment['commentId'][];
+      commentsCount: number; // API-FIX: backend doesnt follow its own convention
+      hasFlaggedChildren: false;
+      hasFlaggedComment: false;
+      editedAt: Amity.timestamp;
+    } & Amity.Content<T> &
+      Amity.Metadata &
+      Amity.Flaggable &
+      Amity.Reactable &
+      Amity.Taggable &
+      Amity.Timestamps &
+      Amity.SoftDelete &
+      Amity.Subscribable &
+      Amity.Mentionable<'user'>;
+
+    type QueryPosts = {
+      targetId: string;
+      targetType: Amity.Post['targetType'];
+      sortBy?: 'lastCreated' | 'firstCreated';
+      dataTypes?: Exclude<Amity.PostContentType, 'text'>[];
+      includeDeleted?: boolean;
+      hasFlag?: boolean;
+      feedType?: 'reviewing' | 'published';
+      tags?: Amity.Taggable['tags'];
+      matchingOnlyParentPost?: boolean;
+      page?: Amity.PageRaw;
+    };
+
+    // Omit sortBy explained in asc-3398
+    type PostLiveCollection = Amity.LiveCollectionParams<
+      Omit<QueryPosts, 'sortBy' | 'page'> & {
+        sortBy?: 'lastCreated' | 'firstCreated';
+      }
+    >;
+
+    type PostLiveCollectionCache = Amity.LiveCollectionCache<
+      Amity.Post['postId'],
+      Pick<QueryPosts, 'page'>
+    >;
+  }
+}

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

@@ -0,0 +1,39 @@
+export {};
+
+declare global {
+  namespace Amity {
+    type ReactableType = 'message' | 'post' | 'comment';
+
+    type ReactionActionType = 'onAdded' | 'onRemoved';
+
+    type Reactor = {
+      reactionId: string;
+      reactionName: string;
+      userId: Amity.User['userId'];
+    } & Amity.Timestamps;
+
+    type Reactable = {
+      reactionsCount: number;
+      reactions: Record<string, number>;
+      myReactions?: string[];
+    };
+
+    type Reaction = {
+      reactors: Reactor[];
+    } & Amity.Relationship<ReactableType>;
+
+    type QueryReactions = {
+      referenceId: Amity.Reaction['referenceId'];
+      referenceType: Amity.Reaction['referenceType'];
+      reactionName?: Amity.Reactor['reactionName'];
+      page?: Amity.Page<string>;
+    };
+
+    type ReactionLiveCollection = Amity.LiveCollectionParams<Omit<QueryReactions, 'page'>>;
+
+    type ReactionLiveCollectionCache = Amity.LiveCollectionCache<
+      Amity.Reactor['reactionId'],
+      Pick<QueryReactions, 'page'>
+    >;
+  }
+}

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

@@ -0,0 +1,85 @@
+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;
+      m3u8?: 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 Stream = {
+      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.User['userId'];
+      resolution: StreamResolution;
+
+      streamerUrl: StreamEndpoint;
+      watcherUrl: MultiFormat<StreamEndpoint>;
+      recordings: MultiFormat<StreamRecording>[];
+    } & Amity.Metadata &
+      Amity.Timestamps &
+      Amity.SoftDelete;
+
+    type QueryStreams = {
+      isLive?: boolean;
+      statuses?: Amity.StreamStatus[];
+      userPublicIds?: Amity.User['userId'][];
+      sortBy?: 'lastCreated' | 'firstCreated';
+      isDeleted?: Amity.Stream['isDeleted'];
+      page?: Amity.Page;
+    };
+
+    type StreamLiveCollection = Amity.LiveCollectionParams<Omit<QueryStreams, 'page'>>;
+
+    type StreamLiveCollectionCache = Amity.LiveCollectionCache<
+      Amity.Stream['streamId'],
+      Pick<QueryStreams, 'page'>
+    >;
+
+    type StreamActionType = 'onStreamRecorded' | 'onStreamStarted' | 'onStreamStopped';
+  }
+}

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

@@ -0,0 +1,50 @@
+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;
+    } & Amity.Timestamps &
+      Amity.Subscribable;
+
+    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;
+    } & Amity.Timestamps &
+      Amity.Subscribable;
+
+    type QuerySubChannels = {
+      channelId: Amity.Channel['channelId'];
+      excludeDefaultSubChannel?: boolean;
+      includeDeleted?: boolean;
+      page?: Amity.Page;
+    };
+
+    type SubChannelLiveCollection = Amity.LiveCollectionParams<Omit<QuerySubChannels, 'page'>>;
+
+    type SubChannelLiveCollectionCache = Amity.LiveCollectionCache<
+      Amity.SubChannel,
+      Pick<QuerySubChannels, 'page'>
+    >;
+  }
+}

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

@@ -0,0 +1,44 @@
+export {};
+
+declare global {
+  namespace Amity {
+    type UserActionType =
+      | 'onFetch'
+      | 'onUpdate'
+      | 'onDelete'
+      | 'onFlagged'
+      | 'onUnflagged'
+      | 'onFlagCleared';
+
+    type User = {
+      _id: string;
+      userId: string;
+      displayName?: string;
+      avatarFileId?: Amity.File<'image'>['fileId'];
+      avatarCustomUrl?: string;
+      description?: string;
+    } & Amity.Metadata &
+      Amity.Taggable &
+      Amity.Flaggable &
+      Amity.Accredited &
+      Amity.Timestamps &
+      Amity.SoftDelete &
+      Amity.Subscribable;
+
+    type QueryUsers = {
+      displayName?: Amity.User['displayName'];
+      filter?: 'all' | 'flagged';
+      sortBy?: 'displayName' | 'firstCreated' | 'lastCreated';
+      page?: Amity.Page;
+    };
+
+    type UserLiveCollection = Amity.LiveCollectionParams<Omit<QueryUsers, 'page'>>;
+
+    type UserSearchLiveCollection = Amity.LiveCollectionParams<Omit<QueryUsers, 'sortBy'>>;
+
+    type UserLiveCollectionCache = Amity.LiveCollectionCache<
+      Amity.User['userId'],
+      Pick<QueryUsers, 'page'>
+    >;
+  }
+}

package/src/@types/global.ts

@@ -0,0 +1,65 @@
+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

@@ -0,0 +1,39 @@
+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';
+
+export * from './domains/community';
+export * from './domains/content';
+export * from './domains/file';
+export * from './domains/message';
+export * from './domains/post';

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

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

package/src/cache/api/backupCache.ts

@@ -0,0 +1,48 @@
+import AsyncStorage from '@react-native-async-storage/async-storage';
+
+import { getActiveClient } from '~/client/api/activeClient';
+
+/**
+ * ```js
+ * import { backupCache } from '@amityco/ts-sdk-react-native'
+ * 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;
+
+  await AsyncStorage.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-react-native'
+ * 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;
+};