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

package/src/message/api/queryMessages.ts

@@ -1,9 +1,9 @@
-import { getActiveClient } from '~/client/api'
+import { getActiveClient } from '~/client/api';
 
-import { toPage, toToken } from '~/core/query'
-import { pullFromCache, pushToCache } from '~/cache/api'
-import { ingestInCache } from '~/cache/api/ingestInCache'
-import { getResolver } from '~/core/model'
+import { toPage, toToken } from '~/core/query';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { getResolver } from '~/core/model';
 
 /**
  * ```js
@@ -20,53 +20,60 @@ import { getResolver } from '~/core/model'
  * @async
  */
 export const queryMessages = async (query: {
-  channelId: Amity.Channel['channelId']
-  type?: Amity.MessageContentType
-  parentId?: Amity.Message['parentId']
-  filterByParentId?: boolean
-  isDeleted?: boolean
-  tags?: Amity.Taggable['tags']
-  excludeTags?: Amity.Taggable['tags']
-  page?: Amity.Page
+  channelId: Amity.Channel['channelId'];
+  type?: Amity.MessageContentType;
+  parentId?: Amity.Message['parentId'];
+  filterByParentId?: boolean;
+  isDeleted?: boolean;
+  tags?: Amity.Taggable['tags'];
+  excludeTags?: Amity.Taggable['tags'];
+  page?: Amity.Page;
 }): Promise<Amity.Cached<Amity.Paged<Amity.Message>>> => {
-  const client = getActiveClient()
-  client.log('message/queryMessages', query)
+  const client = getActiveClient();
+  client.log('message/queryMessages', query);
 
-  const { page = { limit: 10 }, ...params } = query
+  const { page = { limit: 10 }, ...params } = query;
 
   // API-FIX: parameters should be querystring. (1)
   // API-FIX: backend should answer Amity.Response (2)
   // API-FIX: pagination should not be indexed on channelSegment (3)
   // const { data } = await client.http.get<Amity.Response<Amity.Paged<Amity.MessagePayload>>>(
   const { data } = await client.http.get<Amity.MessagePayload & Amity.Pagination>(
-    `/api/v3/messages`, { params: {
-      ...params,
-      options: {
-        token: toToken(page, 'afterbefore'),
+    `/api/v3/messages`,
+    {
+      params: {
+        ...params,
+        options: {
+          token: toToken(page, 'afterbefore'),
+        },
       },
-    },}
-  )
+    },
+  );
 
   // API-FIX: backend should answer Amity.Response (2)
   // const { paging, messages } = unwrapPayload(data)
 
-  const { paging, ...payload } = data
-  const { messages } = payload
+  const { paging, ...payload } = data;
+  const { messages } = payload;
 
-  const cachedAt = client.cache && Date.now()
+  const cachedAt = client.cache && Date.now();
 
   if (client.cache) {
-    ingestInCache(payload as Amity.MessagePayload, { cachedAt })
-
-    const cacheKey = ['message', 'query', { ...params, options: { ...page } } as Amity.Serializable]
-    pushToCache(cacheKey, { messages: messages.map(getResolver('message')), paging })
+    ingestInCache(payload as Amity.MessagePayload, { cachedAt });
+
+    const cacheKey = [
+      'message',
+      'query',
+      { ...params, options: { ...page } } as Amity.Serializable,
+    ];
+    pushToCache(cacheKey, { messages: messages.map(getResolver('message')), paging });
   }
 
-  const nextPage = toPage(paging.next)
-  const prevPage = toPage(paging.previous)
+  const nextPage = toPage(paging.next);
+  const prevPage = toPage(paging.previous);
 
-  return { data: messages, cachedAt, prevPage, nextPage }
-}
+  return { data: messages, cachedAt, prevPage, nextPage };
+};
 
 /**
  * ```js
@@ -82,30 +89,31 @@ export const queryMessages = async (query: {
  * @category Message API
  */
 queryMessages.locally = (
-  query: Parameters<typeof queryMessages>[0]
+  query: Parameters<typeof queryMessages>[0],
 ): Amity.Cached<Amity.Paged<Amity.Message>> | undefined => {
-  const client = getActiveClient()
-  client.log('message/queryMessages.locally', query)
+  const client = getActiveClient();
+  client.log('message/queryMessages.locally', query);
 
-  if (!client.cache) return
+  if (!client.cache) return;
 
-  const { page = { limit: 10 }, ...params } = query
+  const { page = { limit: 10 }, ...params } = query;
 
-  const queryKey = ['message', 'query', { ...params, options: { ...page }} as Amity.Serializable];
-  const { data, cachedAt } = pullFromCache<{messages: Pick<Amity.Message, 'messageId'>[]} & Amity.Pagination>(queryKey) ?? {}
+  const queryKey = ['message', 'query', { ...params, options: { ...page } } as Amity.Serializable];
+  const { data, cachedAt } =
+    pullFromCache<{ messages: Pick<Amity.Message, 'messageId'>[] } & Amity.Pagination>(queryKey) ??
+    {};
 
-  if (!data?.messages.length)
-    return
+  if (!data?.messages.length) return;
 
   const messages: Amity.Message[] = data.messages
     .map(messageId => pullFromCache<Amity.Message>(['message', 'get', messageId])!)
     .filter(Boolean)
-    .map(({ data }) => data)
+    .map(({ data }) => data);
 
-  const prevPage = toPage(data?.paging.previous)
-  const nextPage = toPage(data?.paging.next)
+  const prevPage = toPage(data?.paging.previous);
+  const nextPage = toPage(data?.paging.next);
 
   return messages.length === data?.messages?.length
     ? { data: messages, cachedAt, prevPage, nextPage }
-    : undefined
-}
+    : undefined;
+};

package/src/message/api/updateMessage.ts

@@ -1,8 +1,8 @@
-import { getActiveClient } from '~/client/api'
+import { getActiveClient } from '~/client/api';
 
-import { ingestInCache } from '~/cache/api/ingestInCache'
-import { pullFromCache, upsertInCache } from '~/cache/api'
-import { fireEvent } from '~/core/events'
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { pullFromCache, upsertInCache } from '~/cache/api';
+import { fireEvent } from '~/core/events';
 
 /**
  * ```js
@@ -25,23 +25,24 @@ export const updateMessage = async (
   messageId: Amity.Message['messageId'],
   patch: Patch<Amity.Message, 'data' | 'metadata' | 'mentionees'>,
 ): Promise<Amity.Cached<Amity.Message>> => {
-  const client = getActiveClient()
-  client.log('user/updateMessage', patch)
+  const client = getActiveClient();
+  client.log('user/updateMessage', patch);
 
   const { data } = await client.http.put<Amity.MessagePayload>(
-    `/api/v3/messages/${encodeURIComponent(messageId)}`, patch,
-  )
+    `/api/v3/messages/${encodeURIComponent(messageId)}`,
+    patch,
+  );
 
-  const cachedAt = client.cache && Date.now()
-  if (client.cache) ingestInCache(data, { cachedAt })
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
 
-  const { messages } = data
+  const { messages } = data;
 
   return {
     data: messages.find(message => message.messageId === messageId)!,
     cachedAt,
-  }
-}
+  };
+};
 
 /**
  * ```js
@@ -63,27 +64,27 @@ updateMessage.optimistically = (
   messageId: Amity.Message['messageId'],
   patch: Patch<Amity.Message, 'data' | 'metadata' | 'mentionees'>,
 ): Amity.Cached<Amity.Message> | undefined => {
-  const client = getActiveClient()
-  client.log('user/updateMessage', patch)
+  const client = getActiveClient();
+  client.log('user/updateMessage', patch);
 
-  if (!client.cache) return
+  if (!client.cache) return;
 
-  const message = pullFromCache<Amity.Message>(['message', 'get', messageId])
+  const message = pullFromCache<Amity.Message>(['message', 'get', messageId]);
 
-  if (!message) return
+  if (!message) return;
 
-  const cachedAt = -1
+  const cachedAt = -1;
   const updated: Amity.Message = {
     ...message.data,
     ...patch,
     updatedAt: new Date().toISOString(),
-  }
+  };
 
-  upsertInCache(['message', 'get', messageId], updated, { cachedAt })
-  fireEvent('v3.message.didUpdate', { messages: [updated] })
+  upsertInCache(['message', 'get', messageId], updated, { cachedAt });
+  fireEvent('v3.message.didUpdate', { messages: [updated] });
 
   return {
     data: updated,
-    cachedAt
-  }
-}
+    cachedAt,
+  };
+};

package/src/message/events/index.ts

@@ -1,3 +1,3 @@
-export * from './onMessageCreated'
-export * from './onMessageUpdated'
-export * from './onMessageDeleted'
+export * from './onMessageCreated';
+export * from './onMessageUpdated';
+export * from './onMessageDeleted';

package/src/message/events/onMessageCreated.ts

@@ -1,7 +1,7 @@
-import { getActiveClient } from '~/client/api'
-import { createEventSubscriber } from '~/core/events'
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
 
-import { ingestInCache } from '~/cache/api/ingestInCache'
+import { ingestInCache } from '~/cache/api/ingestInCache';
 
 /**
  * ```js
@@ -18,20 +18,13 @@ import { ingestInCache } from '~/cache/api/ingestInCache'
  *
  * @category Message Events
  */
-export const onMessageCreated = (
-  callback: Amity.Listener<Amity.Message>,
-): Amity.Unsubscriber => {
-  const client = getActiveClient()
+export const onMessageCreated = (callback: Amity.Listener<Amity.Message>): Amity.Unsubscriber => {
+  const client = getActiveClient();
 
   const filter = (payload: Amity.MessagePayload) => {
-    ingestInCache(payload)
-    callback(payload.messages[0])
-  }
+    ingestInCache(payload);
+    callback(payload.messages[0]);
+  };
 
-  return createEventSubscriber(
-    client,
-    'message/onMessageCreated',
-    'v3.message.didCreate',
-    filter,
-  )
-}
+  return createEventSubscriber(client, 'message/onMessageCreated', 'v3.message.didCreate', filter);
+};

package/src/message/events/onMessageDeleted.ts

@@ -1,7 +1,7 @@
-import { getActiveClient } from '~/client/api'
-import { createEventSubscriber } from '~/core/events'
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
 
-import { ingestInCache } from '~/cache/api/ingestInCache'
+import { ingestInCache } from '~/cache/api/ingestInCache';
 
 /**
  * ```js
@@ -18,20 +18,13 @@ import { ingestInCache } from '~/cache/api/ingestInCache'
  *
  * @category Message Events
  */
-export const onMessageDeleted = (
-  callback: Amity.Listener<Amity.Message>,
-): Amity.Unsubscriber => {
-  const client = getActiveClient()
+export const onMessageDeleted = (callback: Amity.Listener<Amity.Message>): Amity.Unsubscriber => {
+  const client = getActiveClient();
 
   const filter = (payload: Amity.MessagePayload) => {
-    ingestInCache(payload)
-    callback(payload.messages[0])
-  }
+    ingestInCache(payload);
+    callback(payload.messages[0]);
+  };
 
-  return createEventSubscriber(
-    client,
-    'message/onMessageDeleted',
-    'v3.message.didDelete',
-    filter,
-  )
-}
+  return createEventSubscriber(client, 'message/onMessageDeleted', 'v3.message.didDelete', filter);
+};

package/src/message/events/onMessageUpdated.ts

@@ -1,7 +1,7 @@
-import { getActiveClient } from '~/client/api'
-import { createEventSubscriber } from '~/core/events'
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
 
-import { ingestInCache } from '~/cache/api/ingestInCache'
+import { ingestInCache } from '~/cache/api/ingestInCache';
 
 /**
  * ```js
@@ -18,20 +18,13 @@ import { ingestInCache } from '~/cache/api/ingestInCache'
  *
  * @category Message Events
  */
-export const onMessageUpdated = (
-  callback: Amity.Listener<Amity.Message>,
-): Amity.Unsubscriber => {
-  const client = getActiveClient()
+export const onMessageUpdated = (callback: Amity.Listener<Amity.Message>): Amity.Unsubscriber => {
+  const client = getActiveClient();
 
   const filter = (payload: Amity.MessagePayload) => {
-    ingestInCache(payload)
-    callback(payload.messages[0])
-  }
+    ingestInCache(payload);
+    callback(payload.messages[0]);
+  };
 
-  return createEventSubscriber(
-    client,
-    'message/onMessageUpdated',
-    'v3.message.didUpdate',
-    filter,
-  )
-}
+  return createEventSubscriber(client, 'message/onMessageUpdated', 'v3.message.didUpdate', filter);
+};

package/src/message/observers/index.ts

@@ -1,2 +1,2 @@
-export { observeMessage } from './observeMessage'
-export { observeMessages } from './observeMessages'
+export { observeMessage } from './observeMessage';
+export { observeMessages } from './observeMessages';

package/src/message/observers/observeMessage.ts

@@ -1,13 +1,10 @@
-import { getActiveClient } from '~/client/api'
+import { getActiveClient } from '~/client/api';
 
-import { createQuery, runQuery, queryOptions } from '~/core/query'
+import { createQuery, runQuery, queryOptions } from '~/core/query';
 
-import { getMessage } from '../api'
+import { getMessage } from '../api';
 
-import {
-  onMessageUpdated,
-  onMessageDeleted,
-} from '../events'
+import { onMessageUpdated, onMessageDeleted } from '../events';
 
 /**
  * ```js
@@ -30,45 +27,42 @@ import {
 export const observeMessage = <Events extends ['onFetch', 'onUpdate', 'onDelete']>(
   messageId: Amity.Message['messageId'],
   callback: Amity.ObjectListener<Amity.Snapshot<Amity.Message>, Events>,
-  policy: Amity.QueryPolicy = 'cache_then_server'
+  policy: Amity.QueryPolicy = 'cache_then_server',
 ): Amity.Unsubscriber => {
-  const { log } = getActiveClient()
+  const { log } = getActiveClient();
 
-  const timestamp = Date.now()
-  log(`observeMessage(tmpid: ${timestamp}) > listen`)
+  const timestamp = Date.now();
+  log(`observeMessage(tmpid: ${timestamp}) > listen`);
 
   // wrapper function to make sure
-  const router = (
-    result: Amity.Snapshot<Amity.Message>,
-    action: Events[number]
-  ) => {
+  const router = (result: Amity.Snapshot<Amity.Message>, action: Events[number]) => {
     // filter function
-    if (result.data?.messageId !== messageId) return
+    if (result.data?.messageId !== messageId) return;
 
-    if (callback instanceof Function) return callback(result)
+    if (callback instanceof Function) return callback(result);
 
-    if (action !== 'onFetch') callback.onEvent?.(action, result)
+    if (action !== 'onFetch') callback.onEvent?.(action, result);
 
-    callback[action]?.(result)
-  }
+    callback[action]?.(result);
+  };
 
-  const disposers: Amity.Unsubscriber[] = []
+  const disposers: Amity.Unsubscriber[] = [];
 
   disposers.push(
     onMessageUpdated(data => router({ data, loading: false, origin: 'event' }, 'onUpdate')),
-    onMessageDeleted(data => router({ data, loading: false, origin: 'event' }, 'onDelete'))
-  )
+    onMessageDeleted(data => router({ data, loading: false, origin: 'event' }, 'onDelete')),
+  );
 
   if (policy !== 'no_fetch') {
     runQuery(
       createQuery(getMessage, messageId),
       result => result.data && router(result, 'onFetch'),
-      queryOptions(policy)
-    )
+      queryOptions(policy),
+    );
   }
 
   return () => {
-    log(`observeMessages(tmpid: ${timestamp}) > dispose`)
-    disposers.forEach(fn => fn())
-  }
-}
+    log(`observeMessages(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/message/observers/observeMessages.ts

@@ -1,10 +1,6 @@
-import { getActiveClient } from '~/client/api'
+import { getActiveClient } from '~/client/api';
 
-import {
-  onMessageCreated,
-  onMessageUpdated,
-  onMessageDeleted,
-} from '../events'
+import { onMessageCreated, onMessageUpdated, onMessageDeleted } from '../events';
 
 /**
  * ```js
@@ -25,36 +21,38 @@ import {
  */
 export const observeMessages = (
   channelId: Amity.Channel['channelId'],
-  callback: Amity.ObjectListener<Amity.Snapshot<Amity.Message>, ['onCreate', 'onUpdate', 'onDelete']>,
+  callback: Amity.ObjectListener<
+    Amity.Snapshot<Amity.Message>,
+    ['onCreate', 'onUpdate', 'onDelete']
+  >,
 ): Amity.Unsubscriber => {
-  const { log } = getActiveClient()
+  const { log } = getActiveClient();
 
-  const timestamp = Date.now()
-  log(`observeMessages(tmpid: ${timestamp}) > listen`)
+  const timestamp = Date.now();
+  log(`observeMessages(tmpid: ${timestamp}) > listen`);
 
-  const disposers: Amity.Unsubscriber[] = []
+  const disposers: Amity.Unsubscriber[] = [];
 
   const router = (
     message: Amity.Snapshot<Amity.Message>,
     action: 'onCreate' | 'onUpdate' | 'onDelete',
   ) => {
-    if (message.data?.channelId !== channelId) return
+    if (message.data?.channelId !== channelId) return;
 
-    if (callback instanceof Function)
-      return callback(message)
+    if (callback instanceof Function) return callback(message);
 
-    callback.onEvent?.(action, message)
-    callback[action]?.(message)
-  }
+    callback.onEvent?.(action, message);
+    callback[action]?.(message);
+  };
 
   disposers.push(
     onMessageCreated(data => router({ data, loading: false, origin: 'event' }, 'onCreate')),
     onMessageUpdated(data => router({ data, loading: false, origin: 'event' }, 'onUpdate')),
     onMessageDeleted(data => router({ data, loading: false, origin: 'event' }, 'onDelete')),
-  )
+  );
 
   return () => {
-    log(`observeMessages(tmpid: ${timestamp}) > dispose`)
-    disposers.forEach(fn => fn())
-  }
-}
+    log(`observeMessages(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/poll/api/closePoll.ts

@@ -0,0 +1,39 @@
+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 });
+
+  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,36 @@
+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);
+
+  return success;
+};