@amityco/ts-sdk 0.0.1-e26de88.0 → 0.0.1-e556efe.0

package/src/file/api/createVideo.ts

@@ -1,6 +1,6 @@
-import { getActiveClient } from '~/client/api'
+import { getActiveClient } from '~/client/api';
 
-import { ingestInCache } from '~/cache/api/ingestInCache'
+import { ingestInCache } from '~/cache/api/ingestInCache';
 
 /**
  * ```js
@@ -11,6 +11,7 @@ import { ingestInCache } from '~/cache/api/ingestInCache'
  * Creates an {@link Amity.File<'video'>}
  *
  * @param formData The data necessary to create a new {@link Amity.File<'video'>}
+ * @param onProgress The callback to track the upload progress
  * @returns The newly created {@link Amity.File<'video'>}
  *
  * @category File API
@@ -20,34 +21,38 @@ export const createVideo = async (
   formData: FormData,
   onProgress?: (percent: number) => void,
 ): Promise<Amity.Cached<Amity.File<'video'>[]>> => {
-  const client = getActiveClient()
-  client.log('file/createVideo', formData)
+  const client = getActiveClient();
+  client.log('file/createVideo', formData);
 
   if (!formData.getAll('files').length)
-    throw new Error('The formData object must have a `files` key.')
+    throw new Error('The formData object must have a `files` key.');
 
-  const headers = 'getHeaders' in formData
-    ? (formData as any).getHeaders()
-    : { 'content-type': 'multipart/form-data' }
+  const headers =
+    'getHeaders' in formData
+      ? (formData as any).getHeaders()
+      : { 'content-type': 'multipart/form-data' };
 
   const { data } = await client.http.post<Amity.CreateFilePayload<'video'>>(
-    '/api/v4/videos', formData, {
-      headers, onUploadProgress({ loaded, total }) {
-        onProgress && onProgress(Math.round((loaded * 100) / total))
-      }
-    }
-  )
+    '/api/v4/videos',
+    formData,
+    {
+      headers,
+      onUploadProgress({ loaded, total }) {
+        onProgress && onProgress(Math.round((loaded * 100) / total));
+      },
+    },
+  );
 
   // API-FIX: payload should be serialized properly
   // const { files } = data
 
-  const cachedAt = client.cache && Date.now()
-  if (client.cache) ingestInCache({ files: data }, { cachedAt })
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache({ files: data }, { cachedAt });
 
   return {
     data,
     cachedAt,
-  }
-}
+  };
+};
 
 // TODO: consider doing local creation with URL.createObjectURL()

package/src/file/api/getFile.ts

@@ -11,7 +11,7 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
  *
  * Fetches a {@link Amity.File} object
  *
- * @param filelId the ID of the {@link Amity.File} to fetch
+ * @param fileId the ID of the {@link Amity.File} to fetch
  * @returns the associated {@link Amity.File} object
  *
  * @category File API

package/src/file/api/index.ts

@@ -3,3 +3,4 @@ export * from './createFile';
 export * from './deleteFile';
 export * from './fileUrlWithSize';
 export * from './createVideo';
+export * from './createImage';

package/src/follow/api/acceptFollower.ts

@@ -28,7 +28,7 @@ export const acceptFollower = async (userId: Amity.User['userId']): Promise<bool
     ingestInCache(data);
   }
 
-  fireEvent('follow.accepted', data.follows[0]);
+  fireEvent('follow.accepted', data);
 
   return true;
 };

package/src/follow/api/declineFollower.ts

@@ -28,7 +28,7 @@ export const declineFollower = async (userId: Amity.User['userId']): Promise<boo
     ingestInCache(data);
   }
 
-  fireEvent('follow.requestDeclined', data.follows[0]);
+  fireEvent('follow.requestDeclined', data);
 
   return true;
 };

package/src/follow/api/follow.ts

@@ -32,10 +32,7 @@ export const follow = async (
     ingestInCache(data, { cachedAt });
   }
 
-  fireEvent(
-    data.follows[0].status === 'accepted' ? 'follow.created' : 'follow.requested',
-    data.follows[0],
-  );
+  fireEvent(data.follows[0].status === 'accepted' ? 'follow.created' : 'follow.requested', data);
 
   return {
     data: data.follows[0],

package/src/follow/api/getFollowInfo.ts

@@ -27,15 +27,18 @@ export const getFollowInfo = async (
   const client = getActiveClient();
   client.log('follow/getFollowInfo', userId);
 
-  const { data } = await client.http.get<Amity.FollowInfoPayload>(
+  const { data } = await client.http.get<Amity.FollowInfoMePayload | Amity.FollowInfoPayload>(
     client.userId === userId ? `/api/v4/me/followInfo` : `/api/v4/users/${userId}/followInfo`,
   );
 
   const cachedAt = client.cache && Date.now();
-  const followInfo = {
-    ...data.followCounts[0],
-    status: data.follows?.[0]?.status,
-  };
+  const followInfo =
+    'follows' in data
+      ? {
+          ...data.followCounts[0],
+          status: data.follows?.[0]?.status,
+        }
+      : data.followCounts[0];
 
   if (client.cache) {
     pushToCache(getCacheKey(userId), followInfo, { cachedAt });

package/src/follow/api/queryFollowers.ts

@@ -16,9 +16,10 @@ import { queryFollows } from './utils';
  */
 export const queryFollowers = async (query: {
   userId: Amity.User['userId'];
-  status?: 'all' | Exclude<Amity.FollowStatus['status'], 'none'>;
-  page?: Amity.Page;
-}): Promise<Amity.Cached<Amity.Paged<Amity.FollowStatus>>> => queryFollows('followers', query);
+  status?: Exclude<Amity.FollowStatusType, 'none'>;
+  page?: Amity.PageRaw;
+}): Promise<Amity.Cached<Amity.Paged<Amity.FollowStatus, Amity.PageRaw>>> =>
+  queryFollows('followers', query);
 
 /**
  * ```js
@@ -35,5 +36,5 @@ export const queryFollowers = async (query: {
  */
 queryFollowers.locally = (
   query: Parameters<typeof queryFollowers>[0],
-): Amity.Cached<Amity.Paged<Amity.FollowStatus>> | undefined =>
+): Amity.Cached<Amity.Paged<Amity.FollowStatus, Amity.PageRaw>> | undefined =>
   queryFollows.locally('followers', query);

package/src/follow/api/queryFollowings.ts

@@ -16,9 +16,10 @@ import { queryFollows } from './utils';
  */
 export const queryFollowings = async (query: {
   userId: Amity.User['userId'];
-  status?: Exclude<Amity.FollowStatus['status'], 'none'>;
-  page?: Amity.Page;
-}): Promise<Amity.Cached<Amity.Paged<Amity.FollowStatus>>> => queryFollows('following', query);
+  status?: Exclude<Amity.FollowStatusType, 'none'>;
+  page?: Amity.PageRaw;
+}): Promise<Amity.Cached<Amity.Paged<Amity.FollowStatus, Amity.PageRaw>>> =>
+  queryFollows('following', query);
 
 /**
  * ```js
@@ -35,5 +36,5 @@ export const queryFollowings = async (query: {
  */
 queryFollowings.locally = (
   query: Parameters<typeof queryFollowings>[0],
-): Amity.Cached<Amity.Paged<Amity.FollowStatus>> | undefined =>
+): Amity.Cached<Amity.Paged<Amity.FollowStatus, Amity.PageRaw>> | undefined =>
   queryFollows.locally('following', query);

package/src/follow/api/unfollow.ts

@@ -28,7 +28,7 @@ export const unfollow = async (userId: Amity.User['userId']): Promise<boolean> =
     ingestInCache(data);
   }
 
-  fireEvent('follow.unfollowed', data.follows[0]);
+  fireEvent('follow.unfollowed', data);
 
   return true;
 };

package/src/follow/api/utils.ts

@@ -1,5 +1,5 @@
 import { getActiveClient } from '~/client/api';
-import { toPage, toToken } from '~/core/query';
+import { toPageRaw, toToken } from '~/core/query';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { pullFromCache, pushToCache } from '~/cache/api';
 import { getResolver } from '~/core/model';
@@ -8,10 +8,10 @@ export const queryFollows = async (
   key: 'followers' | 'following',
   query: {
     userId: Amity.User['userId'];
-    status?: 'all' | Exclude<Amity.FollowStatus['status'], 'none'>;
-    page?: Amity.Page;
+    status?: Exclude<Amity.FollowStatusType, 'none'>;
+    page?: Amity.PageRaw;
   },
-): Promise<Amity.Cached<Amity.Paged<Amity.FollowStatus>>> => {
+): Promise<Amity.Cached<Amity.Paged<Amity.FollowStatus, Amity.PageRaw>>> => {
   const client = getActiveClient();
   client.log(`follow/queryF${key.substring(1)}`, query);
 
@@ -22,7 +22,7 @@ export const queryFollows = async (
     {
       params: {
         ...params,
-        token: toToken(page, 'skiplimit'),
+        token: toToken(page, 'afterbeforeraw'),
       },
     },
   );
@@ -43,8 +43,8 @@ export const queryFollows = async (
     pushToCache(cacheKey, { follows: follows.map(getResolver('follow')), paging });
   }
 
-  const nextPage = toPage(paging.next);
-  const prevPage = toPage(paging.previous);
+  const nextPage = toPageRaw(paging.next);
+  const prevPage = toPageRaw(paging.previous);
 
   return { data: follows, cachedAt, prevPage, nextPage };
 };
@@ -52,7 +52,7 @@ export const queryFollows = async (
 queryFollows.locally = (
   key: Parameters<typeof queryFollows>[0],
   query: Parameters<typeof queryFollows>[1],
-): Amity.Cached<Amity.Paged<Amity.FollowStatus>> | undefined => {
+): Amity.Cached<Amity.Paged<Amity.FollowStatus, Amity.PageRaw>> | undefined => {
   const client = getActiveClient();
   client.log(`follow/queryF${key.substring(1)}.locally`, query);
 
@@ -73,8 +73,8 @@ queryFollows.locally = (
     .filter(Boolean)
     .map(({ data }) => data);
 
-  const prevPage = toPage(data?.paging.previous);
-  const nextPage = toPage(data?.paging.next);
+  const prevPage = toPageRaw(data?.paging.previous);
+  const nextPage = toPageRaw(data?.paging.next);
 
   return follows.length === data?.follows?.length
     ? { data: follows, cachedAt, prevPage, nextPage }

package/src/follow/events/utils.ts

@@ -9,11 +9,11 @@ export const createFollowEventSubscriber = (
 ) => {
   const client = getActiveClient();
 
-  const filter = (payload: Amity.FollowStatus) => {
+  const filter = (payload: Amity.FollowersPayload | Amity.FollowStatusPayload) => {
     if (!client.cache) {
-      callback(payload);
+      callback(payload.follows[0]);
     } else {
-      ingestInCache({ follows: [payload] });
+      ingestInCache(payload);
 
       const queries = [
         ...(queryCache(['followers', 'query']) ?? []),
@@ -21,11 +21,14 @@ export const createFollowEventSubscriber = (
       ];
 
       queries
-        // @ts-ignore
-        .filter(({ key }) => key[2].userId === payload.from || key[2].userId === payload.to)
+        .filter(
+          ({ key }) =>
+            // @ts-ignore
+            key[2].userId === payload.follows[0].from || key[2].userId === payload.follows[0].to,
+        )
         .forEach(({ key, data }) => upsertInCache(key, data as any, { cachedAt: -1 }));
 
-      callback(payload);
+      callback(payload.follows[0]);
     }
   };
 

package/src/index.ts

@@ -25,6 +25,7 @@ export * from './role/api';
 // // asc partials
 export * from './reaction/api';
 export * from './reaction/events';
+export * from './reaction/observers';
 
 export * from './report/api';
 
@@ -42,6 +43,8 @@ export * from './community/api';
 export * from './community/events';
 export * from './community/observers';
 
+export * from './category/api';
+
 export * from './feed/api';
 
 export * from './follow/api';
@@ -56,5 +59,12 @@ export * from './comment/api';
 export * from './comment/events';
 export * from './comment/observers';
 
+export * from './poll/api';
+export * from './poll/events';
+export * from './poll/observers';
+
 export * from './stream/api';
 export * from './stream/events';
+
+// // external apis
+export * from './external/api';

package/src/message/api/createMessage.ts

@@ -3,6 +3,7 @@ import { getActiveClient } from '~/client/api';
 import { upsertInCache, pullFromCache, pushToCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { fireEvent } from '~/core/events';
+import { uuid } from '~/core/uuid';
 
 /**
  * ```js
@@ -22,9 +23,13 @@ import { fireEvent } from '~/core/events';
  * @async
  */
 export const createMessage = async <T extends Amity.MessageContentType>(
-  bundle: Pick<Amity.Message<T>, 'channelId' | 'type' | 'data' | 'metadata' | 'mentionees'>,
+  bundle: Pick<
+    Amity.Message<T>,
+    'channelId' | 'parentId' | 'type' | 'data' | 'tags' | 'metadata' | 'mentionees'
+  >,
 ): Promise<Amity.Cached<Amity.Message>> => {
   const client = getActiveClient();
+
   client.log('user/createMessage', bundle);
 
   const { data } = await client.http.post<Amity.MessagePayload>('/api/v3/messages', bundle);
@@ -58,26 +63,43 @@ export const createMessage = async <T extends Amity.MessageContentType>(
  * @category Message API
  */
 createMessage.optimistically = (
-  bundle: Pick<Amity.Message, 'channelId' | 'type' | 'data' | 'metadata' | 'mentionees'>,
+  bundle: Pick<
+    Amity.Message,
+    'channelId' | 'parentId' | 'type' | 'data' | 'tags' | 'metadata' | 'mentionees'
+  >,
 ): Amity.Cached<Amity.Message> | undefined => {
   const client = getActiveClient();
-  client.log('user/createMessage.locally', bundle);
 
   if (!client.cache) return;
 
-  const channel = pullFromCache<Amity.Channel>(['channel', 'get', bundle.channelId]);
+  /*
+   * when creating messages optimistically a messageId needs to be added by the
+   * client, created a new variable so as to allow backward compatibility of API
+   *
+   * Updated to handle client requirement to add messageId while uploading
+   * message with image. Temporary!
+   */
+  const bundleWithMessageId = { messageId: uuid(), ...bundle };
+
+  // only log if cache is enabled
+  client.log('user/createMessage.locally', bundleWithMessageId);
 
-  upsertInCache(['channel', 'get', bundle.channelId], {
+  const channel = pullFromCache<Amity.Channel>(['channel', 'get', bundleWithMessageId.channelId]);
+
+  upsertInCache(['channel', 'get', bundleWithMessageId.channelId], {
     ...channel?.data,
     messageCount: (channel?.data.messageCount ?? 0) + 1,
   });
 
+  // as reused to update created and updated time, which should be the same
+  const createdTime = new Date().toISOString();
+
   const message = {
-    messageId: Math.random().toString(16),
     userId: client.userId,
     channelSegment: (channel?.data.messageCount ?? 0) + 1,
-    createdAt: new Date().toISOString(),
-    ...bundle,
+    createdAt: createdTime,
+    updatedAt: createdTime,
+    ...bundleWithMessageId,
   } as Amity.Message;
 
   pushToCache(['message', 'get', message.messageId], message, { cachedAt: -1 });

package/src/message/api/updateMessage.ts

@@ -23,7 +23,7 @@ import { fireEvent } from '~/core/events';
  */
 export const updateMessage = async (
   messageId: Amity.Message['messageId'],
-  patch: Patch<Amity.Message, 'data' | 'metadata' | 'mentionees'>,
+  patch: Patch<Amity.Message, 'data' | 'tags' | 'metadata' | 'mentionees'>,
 ): Promise<Amity.Cached<Amity.Message>> => {
   const client = getActiveClient();
   client.log('user/updateMessage', patch);
@@ -62,7 +62,7 @@ export const updateMessage = async (
  */
 updateMessage.optimistically = (
   messageId: Amity.Message['messageId'],
-  patch: Patch<Amity.Message, 'data' | 'metadata' | 'mentionees'>,
+  patch: Patch<Amity.Message, 'data' | 'tags' | 'metadata' | 'mentionees'>,
 ): Amity.Cached<Amity.Message> | undefined => {
   const client = getActiveClient();
   client.log('user/updateMessage', patch);

package/src/message/events/onMessageUpdated.ts

@@ -2,6 +2,7 @@ import { getActiveClient } from '~/client/api';
 import { createEventSubscriber } from '~/core/events';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
+import { prepareMessagePayloadForCache } from '~/reaction/utils';
 
 /**
  * ```js
@@ -23,7 +24,14 @@ export const onMessageUpdated = (callback: Amity.Listener<Amity.Message>): Amity
 
   const filter = (payload: Amity.MessagePayload) => {
     ingestInCache(payload);
-    callback(payload.messages[0]);
+    const message = payload.messages[0];
+
+    // if payload does not have myReactions
+    if (!message?.myReactions) {
+      prepareMessagePayloadForCache(message);
+    }
+
+    callback(message);
   };
 
   return createEventSubscriber(client, 'message/onMessageUpdated', 'v3.message.didUpdate', filter);

package/src/poll/api/closePoll.ts

@@ -0,0 +1,42 @@
+import { fireEvent } from '~/core/events';
+import { getActiveClient } from '~/client/api';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/**
+ * ```js
+ * import { closePoll } from '@amityco/ts-sdk'
+ * const updated = await closePoll(pollId)
+ * ```
+ *
+ * Updates an {@link Amity.Poll}
+ *
+ * @param pollId The ID of the {@link Amity.Poll} to close
+ * @returns the updated {@link Amity.Poll} object
+ *
+ * @category Poll API
+ * @async
+ */
+export const closePoll = async (
+  pollId: Amity.Poll['pollId'],
+): Promise<Amity.Cached<Amity.Poll>> => {
+  const client = getActiveClient();
+  client.log('user/closePoll', pollId);
+
+  const { data } = await client.http.put<Amity.PollPayload>(
+    `/api/v3/polls/${encodeURIComponent(pollId)}`,
+    { status: 'closed' },
+  );
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  fireEvent('poll.updated', data);
+
+  const { polls } = data;
+
+  return {
+    data: polls.find(poll => poll.pollId === pollId)!,
+    cachedAt,
+  };
+};

package/src/poll/api/createPoll.ts

@@ -0,0 +1,45 @@
+import { getActiveClient } from '~/client/api';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/**
+ * ```js
+ * import { createPoll } from '@amityco/ts-sdk'
+ * const created = await createPoll({
+ *   question: 'question',
+ *   answers: [
+ *      { dataType: 'text', data: 'answer1' },
+ *      { dataType: 'text', data: 'answer2' },
+ *   ],
+ *   closedIn: 1649136484
+ * }))
+ * ```
+ *
+ * Creates an {@link Amity.Poll}
+ *
+ * @param bundle The data necessary to create a new {@link Amity.Poll}
+ * @returns The newly created {@link Amity.Poll}
+ *
+ * @category Poll API
+ * @async
+ */
+export const createPoll = async (
+  bundle: Pick<Amity.Poll, 'question' | 'answerType' | 'closedIn'> & {
+    answers: Pick<Amity.PollAnswer, 'dataType' | 'data'>[];
+  },
+): Promise<Amity.Cached<Amity.Poll>> => {
+  const client = getActiveClient();
+  client.log('post/createPoll', bundle);
+
+  const { data } = await client.http.post<Amity.PollPayload>('/api/v3/polls', bundle);
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  const { polls } = data;
+
+  return {
+    data: polls[0],
+    cachedAt,
+  };
+};

package/src/poll/api/deletePoll.ts

@@ -0,0 +1,39 @@
+import { fireEvent } from '~/core/events';
+import { getActiveClient } from '~/client/api';
+
+import { upsertInCache } from '~/cache/api';
+
+import { getPoll } from './getPoll';
+
+/**
+ * ```js
+ * import { deletePoll } from '@amityco/ts-sdk'
+ * const success = await deletePoll(pollId)
+ * ```
+ *
+ * Deletes a {@link Amity.Poll}
+ *
+ * @param pollId The {@link Amity.Poll} ID to delete
+ * @return A success boolean if the {@link Amity.Poll} was deleted
+ *
+ * @category Poll API
+ * @async
+ */
+export const deletePoll = async (pollId: Amity.Poll['pollId']): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('poll/deletePoll', pollId);
+
+  const poll = await getPoll(pollId);
+
+  // API-FIX: it returns { success: boolean } but seems it should be Amity.Response<{ success: boolean }
+  const { data } = await client.http.delete<{ success: boolean }>(`/api/v3/polls/${pollId}`);
+
+  const { success } = data; // unwrapPayload(data)
+  const deleted = { ...poll.data, isDeleted: true };
+
+  upsertInCache(['poll', 'get', pollId], deleted);
+
+  fireEvent('poll.deleted', { polls: [deleted], users: [] });
+
+  return success;
+};

package/src/poll/api/getPoll.ts

@@ -0,0 +1,64 @@
+import { getActiveClient } from '~/client/api';
+
+import { pullFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/**
+ * ```js
+ * import { getPoll } from '@amityco/ts-sdk'
+ * const poll = await getPoll('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.Poll} object
+ *
+ * @param pollId the ID of the {@link Amity.Poll} to fetch
+ * @returns the associated {@link Amity.Poll} object
+ *
+ * @category Poll API
+ * @async
+ */
+export const getPoll = async (pollId: Amity.Poll['pollId']): Promise<Amity.Cached<Amity.Poll>> => {
+  const client = getActiveClient();
+  client.log('poll/getPoll', pollId);
+
+  const { data } = await client.http.get<Amity.PollPayload>(`/api/v3/polls/${pollId}`);
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  const { polls } = data;
+
+  return {
+    data: polls.find(poll => poll.pollId === pollId)!,
+    cachedAt,
+  };
+};
+
+/**
+ * ```js
+ * import { getPoll } from '@amityco/ts-sdk'
+ * const poll = getPoll.locally('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.Poll} object
+ *
+ * @param pollId the ID of the {@link Amity.Poll} to fetch
+ * @returns the associated {@link Amity.Poll} object
+ *
+ * @category Poll API
+ */
+getPoll.locally = (pollId: Amity.Poll['pollId']): Amity.Cached<Amity.Poll> | undefined => {
+  const client = getActiveClient();
+  client.log('poll/getPoll', pollId);
+
+  if (!client.cache) return;
+
+  const cached = pullFromCache<Amity.Poll>(['poll', 'get', pollId]);
+
+  if (!cached) return;
+
+  return {
+    data: cached.data,
+    cachedAt: cached.cachedAt,
+  };
+};

package/src/poll/api/index.ts

@@ -0,0 +1,7 @@
+export * from './getPoll';
+
+export * from './createPoll';
+export * from './closePoll';
+export * from './deletePoll';
+
+export * from './votePoll';