@amityco/ts-sdk 0.0.1-beta.16 → 0.0.1-beta.19

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

@@ -1,33 +1,33 @@
-export {}
+export {};
 
 declare global {
   namespace Amity {
     // bad hack until we get proper feed objects in backend
-    type PostTargetType = Amity.FeedType | 'content'
+    type PostTargetType = Amity.FeedType | 'content';
 
-    type PostContentType = ('text' | 'image' | 'file' | 'video')
+    type PostContentType = 'text' | 'image' | 'file' | 'video' | 'liveStream' | 'poll';
 
     type Post<T extends PostContentType = any> = {
-      postId: string
-      postedUserId: User['userId'] // API-FIX: it should be "userId"
-      parentId: Post['postId']
-      targetType: PostTargetType
-      targetId: string
-      feedId: 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: timestamp,
-    }
-    & Amity.Content<T, 'dataType'>
-    & Amity.Metadata
-    & Amity.Flaggable
-    & Amity.Reactable
-    & Amity.Timestamps
-    & Amity.SoftDelete
-    & Amity.Subscribable
-    & Amity.Mentionable<'user'>
+      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, 'dataType'> &
+      Amity.Metadata &
+      Amity.Flaggable &
+      Amity.Reactable &
+      Amity.Taggable &
+      Amity.Timestamps &
+      Amity.SoftDelete &
+      Amity.Subscribable &
+      Amity.Mentionable<'user'>;
   }
 }

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

@@ -1,30 +1,29 @@
-export {}
+export {};
 
 declare global {
   namespace Amity {
-    type ReactableType = ('message' | 'post' | 'comment')
+    type ReactableType = 'message' | 'post' | 'comment';
 
-    type Reaction =  {
-      reactionId: string
-      userId: string
-      reactionName: string
-    }
-    & Amity.CreatedAt
-    & Amity.Relationship<ReactableType>
+    type Reaction = {
+      reactionId: string;
+      userId: string;
+      reactionName: string;
+    } & Amity.CreatedAt &
+      Amity.Relationship<ReactableType>;
 
     type Reactions = {
-      reactions: Record<string, number>
-      count: number
-    }
+      reactions: Record<string, number>;
+      count: number;
+    };
 
     type Reactable = {
-      reactionsCount: number
-      reactions: Record<string, number>
-      myReactions?: string[]
+      reactionsCount: number;
+      reactions: Record<string, number>;
+      myReactions?: string[];
 
       latestReaction?: Amity.Reaction & {
-        eventName: ('added' | 'removed')
-      }
-    }
+        eventName: 'added' | 'removed';
+      };
+    };
   }
 }

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

@@ -1,4 +1,4 @@
-export {}
+export {};
 
 declare global {
   namespace Amity {
@@ -16,53 +16,52 @@ declare global {
     }
 
     type MultiFormat<T> = {
-      flv?: T
-      mp4?: T
-      m3u8?: T
-    }
+      flv?: T;
+      mp4?: T;
+      m3u8?: T;
+    };
 
     type StreamPlatform = {
-      name: string
-      version: string
-    }
+      name: string;
+      version: string;
+    };
 
     type StreamEndpoint = {
-      url: string
+      url: string;
       components: {
-        origin: string
-        appName: string
-        streamName: string
-        query: string
-      }
-    }
+        origin: string;
+        appName: string;
+        streamName: string;
+        query: string;
+      };
+    };
 
     type StreamRecording = {
-      url: string
-      duration: number
-      startTime: number
-      stopTime: number
-    }
+      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
+      streamId: string;
+      title: string;
+      thumbnailFileId?: Amity.File<'image'>['fileId'];
+      description?: string;
+      status: StreamStatus;
+      platform: StreamPlatform;
 
-      isLive?: boolean
-      endedAt: timestamp
-      startedAt: timestamp
-      userId: User['userId']
-      resolution: StreamResolution
+      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
+      streamerUrl: StreamEndpoint;
+      watcherUrl: MultiFormat<StreamEndpoint>;
+      recordings: MultiFormat<StreamRecording>[];
+    } & Amity.Metadata &
+      Amity.Timestamps &
+      Amity.SoftDelete;
   }
 }

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

@@ -1,19 +1,19 @@
-export {}
+export {};
 
 declare global {
   namespace Amity {
     type User = {
-      _id: string
-      userId: string
-      displayName?: string
-      avatarFileId?: Amity.File<'image'>['fileId']
-      description?: string
-    }
-    & Amity.Metadata
-    & Amity.Taggable
-    & Amity.Flaggable
-    & Amity.Accredited
-    & Amity.Timestamps
-    & Amity.Subscribable
+      _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.Subscribable;
   }
 }

package/src/@types/global.ts

@@ -1,25 +1,28 @@
-export {}
+export {};
 
 declare global {
-  type Writeable<T> = { -readonly [P in keyof T]: T[P] }
+  type Writeable<T> = { -readonly [P in keyof T]: T[P] };
 
-  type Patch<T, K extends keyof T> = Partial<Pick<T, K>>
+  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
-  )
+  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>
+    keys<T>(o: T): ObjectKeys<T>;
   }
-
-  type ObjectKeys<T> =  (
-    T extends object ? (keyof T)[] :
-    T extends number ? [] :
-    T extends Array<any> | string ? string[] :
-    never
-  )
 }

package/src/@types/index.ts

@@ -1,34 +1,36 @@
-import './global' // global types (system)
+import './global'; // global types (system)
 
-import './core/errors' // global errors
-import './core/permissions' // permissions enum
+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/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', ...)
 
 // domains
-import './domains/client' // client definition
+import './domains/client'; // client definition
 
-import './domains/user'
-import './domains/follow'
-import './domains/file'
+import './domains/user';
+import './domains/follow';
+import './domains/file';
 
-import './domains/partials' // small model partials (CreatedAt, etc...)
-import './domains/content' // content partial
-import './domains/reaction'
+import './domains/partials'; // small model partials (CreatedAt, etc...)
+import './domains/content'; // content partial
+import './domains/reaction';
 
-import './domains/group'
-import './domains/channel'
-import './domains/message'
+import './domains/group';
+import './domains/channel';
+import './domains/message';
 
-import './domains/community'
-import './domains/category'
-import './domains/post'
-import './domains/comment'
+import './domains/community';
+import './domains/category';
+import './domains/post';
+import './domains/comment';
 
-import './domains/stream'
+import './domains/stream';
 
-import './domains/mention'
+import './domains/mention';
+
+import './domains/poll';

package/src/cache/api/backupCache.ts

@@ -1,6 +1,7 @@
-import AsyncStorage from '@react-native-async-storage/async-storage'
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import AsyncStorage from '@react-native-async-storage/async-storage';
 
-import { getActiveClient } from '~/client/api/activeClient'
+import { getActiveClient } from '~/client/api/activeClient';
 
 /**
  * ```js
@@ -25,29 +26,24 @@ import { getActiveClient } from '~/client/api/activeClient'
  * @category Cache API
  */
 export const backupCache = async (
-  storageKey: string = 'amitySdk',
+  storageKey = 'amitySdk',
   persistIf = (entry: Amity.CacheEntry) => entry.offline,
-) => {
-  const { log, cache, userId } = getActiveClient()
+): Promise<boolean> => {
+  const { log, cache, userId } = getActiveClient();
 
-  if (!cache) return false
-  log('cache/api/backupCache', { storageKey })
+  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))
-  )
+    Object.entries(cache.data).filter(([_, entry]) => persistIf(entry)),
+  );
 
   // nothing to backup, abort
-  if (!Object.keys(offlineEntries).length)
-    return false
+  if (!Object.keys(offlineEntries).length) return false;
 
-  await AsyncStorage.setItem(
-    `${storageKey}#${userId}`,
-    JSON.stringify(offlineEntries),
-  )
+  await AsyncStorage.setItem(`${storageKey}#${userId}`, JSON.stringify(offlineEntries));
 
-  return true
-}
+  return true;
+};

package/src/cache/api/disableCache.ts

@@ -1,4 +1,4 @@
-import { getActiveClient } from '~/client/api/activeClient'
+import { getActiveClient } from '~/client/api/activeClient';
 
 /**
  * ```js
@@ -12,12 +12,12 @@ import { getActiveClient } from '~/client/api/activeClient'
  * @category Cache API
  */
 export const disableCache = () => {
-  const client = getActiveClient()
+  const client = getActiveClient();
 
-  if (!client.cache) return
-  client.log('cache/api/disableCache')
+  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
-}
+  delete client.cache;
+};

package/src/cache/api/dropFromCache.ts

@@ -1,5 +1,5 @@
-import { getActiveClient } from '~/client/api/activeClient'
-import { decodeKey, encodeKey, partialMatch } from '../utils'
+import { getActiveClient } from '~/client/api/activeClient';
+import { decodeKey, encodeKey, partialMatch } from '../utils';
 
 /**
  * ```js
@@ -16,29 +16,26 @@ import { decodeKey, encodeKey, partialMatch } from '../utils'
  *
  * @category Cache API
  */
-export const dropFromCache = (
-  key: Amity.CacheKey,
-  exact: boolean = false,
-): boolean => {
-  const { log, cache } = getActiveClient()
+export const dropFromCache = (key: Amity.CacheKey, exact = false): boolean => {
+  const { log, cache } = getActiveClient();
 
-  if (!cache) return false
-  log('cache/api/dropFromCache', { key, exact })
+  if (!cache) return false;
+  log('cache/api/dropFromCache', { key, exact });
 
   if (!exact) {
-    return (Object.keys(cache.data))
+    return Object.keys(cache.data)
       .map(stringKey => decodeKey(stringKey))
       .filter(candidate => partialMatch(key, candidate))
       .map<boolean>(filteredKey => dropFromCache(filteredKey, true))
-      .every(returned => returned)
+      .every(returned => returned);
   }
 
-  const encodedKey = encodeKey(key)
+  const encodedKey = encodeKey(key);
 
   if (encodedKey in cache.data) {
-    delete cache.data[encodedKey]
-    return true
+    delete cache.data[encodedKey];
+    return true;
   }
 
-  return false
-}
+  return false;
+};

package/src/cache/api/enableCache.ts

@@ -1,4 +1,4 @@
-import { getActiveClient } from '~/client/api/activeClient'
+import { getActiveClient } from '~/client/api/activeClient';
 
 /**
  * ```js
@@ -20,10 +20,10 @@ export const enableCache = (
   prevState: Amity.Cache['data'] = {},
   persistIf?: Amity.Cache['persistIf'],
 ) => {
-  const client = getActiveClient()
+  const client = getActiveClient();
 
-  if (client.cache) return
-  client.log('cache/api/enableCache')
+  if (client.cache) return;
+  client.log('cache/api/enableCache');
 
-  client.cache = { data: prevState, persistIf }
-}
+  client.cache = { data: prevState, persistIf };
+};

package/src/cache/api/index.ts

@@ -1,21 +1,21 @@
 // on/off
-export * from './enableCache'
-export * from './disableCache'
+export * from './enableCache';
+export * from './disableCache';
 
 // persistency
-export * from './restoreCache'
-export * from './backupCache'
-export * from './wipeCache'
+export * from './restoreCache';
+export * from './backupCache';
+export * from './wipeCache';
 
 // fetch
-export * from './queryCache'
-export * from './pullFromCache'
+export * from './queryCache';
+export * from './pullFromCache';
 
 // mutate
-export * from './pushToCache'
-export * from './mergeInCache'
-export * from './upsertInCache'
-export * from './dropFromCache'
+export * from './pushToCache';
+export * from './mergeInCache';
+export * from './upsertInCache';
+export * from './dropFromCache';
 
 /*
  * ingestInCache and syncInCache are not exported ;

package/src/cache/api/ingestInCache.ts

@@ -1,4 +1,4 @@
-import { PAYLOAD2MODEL, getResolver } from '~/core/model'
+import { PAYLOAD2MODEL, getResolver } from '~/core/model';
 
 import { upsertInCache } from './upsertInCache';
 
@@ -15,19 +15,18 @@ export const ingestInCache = (
   payload: Record<string, Record<string, unknown>[]> = {},
   options?: Amity.CacheOptions,
 ) => {
-  Object.entries(payload)
-    .forEach(([key, models]) => {
-      const type = PAYLOAD2MODEL[key];
-      if (!type) return
+  Object.entries(payload).forEach(([key, models]) => {
+    const type = PAYLOAD2MODEL[key];
+    if (!type) return;
 
-      const resolver = getResolver(type);
-      models.forEach(model => {
-        upsertInCache(
-          // eslint-disable @typescript-eslint no-explicit-any
-          [type, 'get', resolver(model as any)], // this 'any' cannot be avoided, sorry.
-          model,
-          options,
-        );
-      })
-    })
-}
+    const resolver = getResolver(type);
+    models.forEach(model => {
+      upsertInCache(
+        // eslint-disable @typescript-eslint no-explicit-any
+        [type, 'get', resolver(model as any)], // this 'any' cannot be avoided, sorry.
+        model,
+        options,
+      );
+    });
+  });
+};

package/src/cache/api/mergeInCache.ts

@@ -1,7 +1,7 @@
-import { getActiveClient } from '~/client/api/activeClient'
+import { getActiveClient } from '~/client/api/activeClient';
 
-import { pullFromCache } from './pullFromCache'
-import { pushToCache } from './pushToCache'
+import { pullFromCache } from './pullFromCache';
+import { pushToCache } from './pushToCache';
 
 /**
  * ```js
@@ -21,24 +21,22 @@ import { pushToCache } from './pushToCache'
  *
  * @category Cache API
  */
- export const mergeInCache = <T extends {}>(
+export const mergeInCache = <T extends Record<string, unknown>>(
   key: Amity.CacheKey,
   mutation: Partial<T> | ((oldVal: T) => T),
   options?: Amity.CacheOptions,
 ): boolean => {
-  const { log, cache } = getActiveClient()
+  const { log, cache } = getActiveClient();
 
-  if (!cache) return false
-  log('cache/api/mergeInCache', { key, mutation })
+  if (!cache) return false;
+  log('cache/api/mergeInCache', { key, mutation });
 
   const oldVal = pullFromCache<T>(key);
 
-  if (!oldVal)
-    return false;
+  if (!oldVal) return false;
 
-  const newVal = typeof mutation === 'function'
-    ? mutation(oldVal.data)
-    : { ...oldVal.data, ...mutation };
+  const newVal =
+    typeof mutation === 'function' ? mutation(oldVal.data) : { ...oldVal.data, ...mutation };
 
   pushToCache(key, newVal, options);
   return true;