@amityco/ts-sdk 0.0.1-cb052d5.0 → 0.0.1-cb5cdb1.0

package/src/index.ts

@@ -1,5 +1,5 @@
 // types
-import './@types';
+export * from './@types';
 
 export * from './version';
 
@@ -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';
 
@@ -33,6 +34,10 @@ export * from './channel/api';
 export * from './channel/events';
 export * from './channel/observers';
 
+export * from './subChannel/api';
+export * from './subChannel/events';
+export * from './subChannel/observers';
+
 export * from './message/api';
 export * from './message/events';
 export * from './message/observers';
@@ -43,6 +48,7 @@ export * from './community/events';
 export * from './community/observers';
 
 export * from './category/api';
+export * from './category/observers';
 
 export * from './feed/api';
 
@@ -59,6 +65,8 @@ 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';

package/src/message/api/createMessage.ts

@@ -1,16 +1,32 @@
+import { uuid } from '~/core/uuid';
+import { fireEvent } from '~/core/events';
 import { getActiveClient } from '~/client/api';
-
-import { upsertInCache, pullFromCache, pushToCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
-import { fireEvent } from '~/core/events';
+import { UNSYNCED_OBJECT_CACHED_AT_VALUE } from '~/utils/constants';
+import { upsertInCache, pullFromCache, pushToCache, dropFromCache } from '~/cache/api';
+
+import { convertParams, prepareMessagePayload } from '../utils';
 
+const getLocalId = () => `LOCAL_${uuid()}`;
+
+// FIXME: temp solution
+let uniqueId: string | undefined;
+
+/* begin_public_function
+  id: message.create.text_message, message.create.image_message, message.create.file_message, message.create.video_message, message.create.audio_message, message.create.custom_message
+*/
 /**
  * ```js
- * import { createMessage } from '@amityco/ts-sdk'
- * const created = await createMessage({
- *   channelId: 'foobar',
- *   data: { text: 'hello world' }
- * })
+ * import { createMessage, createQuery, runQuery } from '@amityco/ts-sdk'
+ *
+ * const query = createQuery(createMessage, {
+ *   subChannelId: 'foobar',
+ *   data: { text: 'hello world' },
+ * });
+ *
+ * runQuery(query, ({ data: message, loading }) => {
+ *   console.log(message);
+ * });
  * ```
  *
  * Creates an {@link Amity.Message}
@@ -24,20 +40,34 @@ import { fireEvent } from '~/core/events';
 export const createMessage = async <T extends Amity.MessageContentType>(
   bundle: Pick<
     Amity.Message<T>,
-    'channelId' | 'parentId' | 'type' | 'data' | 'metadata' | 'mentionees'
-  >,
+    'subChannelId' | 'parentId' | 'dataType' | 'tags' | 'metadata' | 'mentionees'
+  > & {
+    data?: Amity.Message<T>['data'];
+    fileId?: Amity.File['fileId'];
+  },
 ): Promise<Amity.Cached<Amity.Message>> => {
   const client = getActiveClient();
-  client.log('user/createMessage', bundle);
+  client.log('message/createMessage', bundle);
 
-  const { data } = await client.http.post<Amity.MessagePayload>('/api/v3/messages', bundle);
+  const referenceId = uniqueId || getLocalId();
+  uniqueId = undefined;
 
-  const cachedAt = client.cache && Date.now();
-  if (client.cache) ingestInCache(data, { cachedAt });
-  // no need for event, fired by server
+  const { data: payload } = await client.http.post<Amity.MessagePayload>('/api/v5/messages', {
+    ...convertParams(bundle),
+    referenceId,
+  });
 
+  const data = prepareMessagePayload(payload);
   const { messages } = data;
 
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) {
+    dropFromCache(['message', 'get', referenceId]);
+    ingestInCache(data, { cachedAt });
+  }
+
+  fireEvent('local.message.created', { messages });
+
   return {
     data: messages[0],
     cachedAt,
@@ -47,7 +77,8 @@ export const createMessage = async <T extends Amity.MessageContentType>(
 /**
  * ```js
  * import { createMessage } from '@amityco/ts-sdk'
- * const created = createMessage.locally({
+ *
+ * const created = createMessage.optimistically({
  *   channelId: 'foobar',
  *   data: { text: 'hello world' }
  * })
@@ -61,36 +92,64 @@ export const createMessage = async <T extends Amity.MessageContentType>(
  * @category Message API
  */
 createMessage.optimistically = (
-  bundle: Pick<
-    Amity.Message,
-    'channelId' | 'parentId' | 'type' | 'data' | 'metadata' | 'mentionees'
-  >,
+  bundle: Parameters<typeof createMessage>[0],
 ): 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!
+   */
+  uniqueId = getLocalId();
+  const bundleWithMessageId = { messageId: uniqueId, uniqueId, ...bundle };
 
-  upsertInCache(['channel', 'get', bundle.channelId], {
-    ...channel?.data,
-    messageCount: (channel?.data.messageCount ?? 0) + 1,
-  });
+  client.log('message/createMessage.optimistically', bundleWithMessageId);
+
+  const subChannel = pullFromCache<Amity.SubChannel>(['subChannel', 'get', bundle.subChannelId]);
+
+  if (subChannel) {
+    upsertInCache(['subChannel', 'get', bundle.subChannelId], {
+      ...subChannel.data,
+      messageCount: subChannel.data.messageCount + 1,
+    });
+
+    if (subChannel.data.channelId === subChannel.data.subChannelId) {
+      const channel = pullFromCache<Amity.Channel>(['channel', 'get', subChannel.data.channelId]);
+
+      if (channel?.data) {
+        upsertInCache(['channel', 'get', subChannel.data.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,
+    creatorId: client.userId!,
+    channelSegment: (subChannel?.data.messageCount ?? 0) + 1,
+    childrenNumber: 0,
+    createdAt: createdTime,
+    updatedAt: createdTime,
+    ...bundleWithMessageId,
   } as Amity.Message;
 
-  pushToCache(['message', 'get', message.messageId], message, { cachedAt: -1 });
-  fireEvent('v3.message.didCreate', { messages: [message] });
+  const cachedAt = UNSYNCED_OBJECT_CACHED_AT_VALUE;
+
+  pushToCache(['message', 'get', message.messageId], message, { cachedAt });
+  fireEvent('local.message.created', { messages: [message] });
 
   return {
+    cachedAt,
     data: message,
-    cachedAt: -1,
   };
 };
+/* end_public_function */

package/src/message/api/deleteMessage.ts

@@ -1,10 +1,12 @@
 import { getActiveClient } from '~/client/api';
-
-import { getMessage } from './getMessage';
-
 import { pullFromCache, upsertInCache } from '~/cache/api';
 import { fireEvent } from '~/core/events';
 
+import { getMessage } from './getMessage';
+
+/* begin_public_function
+  id: message.soft_delete
+*/
 /**
  * ```js
  * import { deleteMessage } from '@amityco/ts-sdk'
@@ -13,7 +15,7 @@ import { fireEvent } from '~/core/events';
  *
  * Delete a {@link Amity.Message}
  *
- * @param The ID of the {@link Amity.Message} to delete
+ * @param messageId the ID of the {@link Amity.Message} to delete
  * @return A success boolean if the {@link Amity.Message} was deleted
  *
  * @category Message API
@@ -27,11 +29,12 @@ export const deleteMessage = async (
 
   // API-FIX: This endpoint has not been implemented yet.
   await client.http.delete<{ success: boolean }>(
-    `/api/v3/messages/${encodeURIComponent(messageId)}`,
+    `/api/v5/messages/${encodeURIComponent(messageId)}`,
   );
 
   const deleted = await getMessage(messageId);
-  // no need for event, fired by server
+
+  fireEvent('local.message.deleted', { messages: [deleted.data] });
 
   return deleted.data;
 };
@@ -39,7 +42,7 @@ export const deleteMessage = async (
 /**
  * ```js
  * import { deleteMessage } from '@amityco/ts-sdk'
- * const success = deleteMessage.locally('foobar')
+ * const success = deleteMessage.optimistically('foobar')
  * ```
  *
  * Deletes a {@link Amity.Message}
@@ -53,7 +56,7 @@ deleteMessage.optimistically = (
   messageId: Amity.Message['messageId'],
 ): Amity.Cached<Amity.Message> | undefined => {
   const client = getActiveClient();
-  client.log('message/deleteMessage', messageId);
+  client.log('message/deleteMessage.optimistically', messageId);
 
   const message = pullFromCache<Amity.Message>(['message', 'get', messageId]);
 
@@ -67,10 +70,11 @@ deleteMessage.optimistically = (
   };
 
   upsertInCache(['message', 'get', messageId], deleted, { cachedAt });
-  fireEvent('v3.message.didDelete', { messages: [deleted] });
+  fireEvent('local.message.deleted', { messages: [deleted] });
 
   return {
     data: deleted,
     cachedAt,
   };
 };
+/* end_public_function */

package/src/message/api/getMessage.ts

@@ -1,8 +1,17 @@
 import { getActiveClient } from '~/client/api';
 
+import { fireEvent } from '~/core/events';
 import { pullFromCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
+import { isInTombstone } from '~/cache/api/isInTombstone';
+import { checkIfShouldGoesToTombstone } from '~/cache/utils';
+import { pushToTombstone } from '~/cache/api/pushToTombstone';
+import { convertResponseFromRaw } from '../utils';
+
+/* begin_public_function
+  id: message.get
+*/
 /**
  * ```js
  * import { getMessage } from '@amityco/ts-sdk'
@@ -19,25 +28,49 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
  */
 export const getMessage = async (
   messageId: Amity.Message['messageId'],
+  isLive = false,
 ): Promise<Amity.Cached<Amity.Message>> => {
   const client = getActiveClient();
   client.log('message/getMessage', messageId);
 
-  // API-FIX: endpoint should not be /list, parameters should be querystring.
-  const { data } = await client.http.get<Amity.MessagePayload>(
-    `/api/v3/messages/${encodeURIComponent(messageId)}`,
-  );
+  if (!isLive) {
+    console.log(
+      'getMessage will be deprecated on 15th November 2022, please use liveMessage instead.',
+    );
+  }
+
+  isInTombstone('message', messageId);
+
+  let data: Amity.ProcessedMessagePayload;
+
+  try {
+    // API-FIX: endpoint should not be /list, parameters should be querystring.
+    const response = await client.http
+      .get<Amity.MessagePayload>(`/api/v5/messages/${encodeURIComponent(messageId)}`)
+      .then(convertResponseFromRaw);
+
+    data = response.data;
+  } catch (error) {
+    if (checkIfShouldGoesToTombstone((error as Amity.ErrorResponse)?.code)) {
+      pushToTombstone('message', messageId);
+    }
+
+    throw error;
+  }
 
   const cachedAt = client.cache && Date.now();
   if (client.cache) ingestInCache(data, { cachedAt });
 
   const { messages } = data;
 
+  fireEvent('local.message.fetched', { messages });
+
   return {
     data: messages.find(message => message.messageId === messageId)!,
     cachedAt,
   };
 };
+/* end_public_function */
 
 /**
  * ```js

package/src/message/api/getMessages.ts

@@ -1,7 +1,9 @@
 import { getActiveClient } from '~/client/api';
 
+import { fireEvent } from '~/core/events';
 import { pullFromCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
+import { convertResponseFromRaw } from '../utils';
 
 /**
  * ```js
@@ -23,16 +25,21 @@ export const getMessages = async (
   const client = getActiveClient();
   client.log('message/getMessages', messageIds);
 
-  // API-FIX: endpoint should not be /list, parameters should be querystring.
-  const { data } = await client.http.get<Amity.MessagePayload>(`/api/v3/messages/list`, {
-    params: { messageIds },
-  });
+  const { data } = await client.http
+    .get<Amity.MessagePayload>(`/api/v5/messages/list`, {
+      params: { messageIds: messageIds.map(encodeURIComponent) },
+    })
+    .then(convertResponseFromRaw);
 
   const cachedAt = client.cache && Date.now();
   if (client.cache) ingestInCache(data, { cachedAt });
 
+  const { messages } = data;
+
+  fireEvent('local.message.fetched', { messages });
+
   return {
-    data: data.messages,
+    data: messages,
     cachedAt,
   };
 };

package/src/message/api/queryMessages.ts

@@ -1,10 +1,15 @@
 import { getActiveClient } from '~/client/api';
 
-import { toPage, toToken } from '~/core/query';
+import { fireEvent } from '~/core/events';
+import { toPageRaw } from '~/core/query';
 import { pullFromCache, pushToCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { getResolver } from '~/core/model';
+import { convertQueryParams, convertResponseFromRaw } from '../utils';
 
+/* begin_public_function
+  id: message.query
+*/
 /**
  * ```js
  * import { queryMessages } from '@amityco/ts-sdk'
@@ -19,61 +24,44 @@ import { getResolver } from '~/core/model';
  * @category Message API
  * @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;
-}): Promise<Amity.Cached<Amity.Paged<Amity.Message>>> => {
+export const queryMessages = async (
+  query: Amity.QueryMessages,
+): Promise<Amity.Cached<Amity.Paged<Amity.Message, Amity.Page<string>>>> => {
   const client = getActiveClient();
   client.log('message/queryMessages', query);
 
-  const { page = { limit: 10 }, ...params } = query;
+  const params = convertQueryParams(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'),
-        },
-      },
-    },
-  );
+  const response = await client.http
+    .get<Amity.MessagePayload & Amity.Pagination>(`/api/v5/messages`, { params })
+    .then(convertResponseFromRaw);
 
   // API-FIX: backend should answer Amity.Response (2)
   // const { paging, messages } = unwrapPayload(data)
-
-  const { paging, ...payload } = data;
-  const { messages } = payload;
+  const { paging, ...data } = response.data;
+  const { messages } = data;
 
   const cachedAt = client.cache && Date.now();
 
   if (client.cache) {
-    ingestInCache(payload as Amity.MessagePayload, { cachedAt });
+    ingestInCache(data as Amity.ProcessedMessagePayload, { cachedAt });
 
-    const cacheKey = [
-      'message',
-      'query',
-      { ...params, options: { ...page } } as Amity.Serializable,
-    ];
+    const cacheKey = ['message', 'query', params as Amity.Serializable];
     pushToCache(cacheKey, { messages: messages.map(getResolver('message')), paging });
   }
 
-  const nextPage = toPage(paging.next);
-  const prevPage = toPage(paging.previous);
+  fireEvent('local.message.fetched', { messages });
+
+  const nextPage = toPageRaw(paging.next);
+  const prevPage = toPageRaw(paging.previous);
 
   return { data: messages, cachedAt, prevPage, nextPage };
 };
+/* end_public_function */
 
 /**
  * ```js
@@ -90,15 +78,15 @@ export const queryMessages = async (query: {
  */
 queryMessages.locally = (
   query: Parameters<typeof queryMessages>[0],
-): Amity.Cached<Amity.Paged<Amity.Message>> | undefined => {
+): Amity.Cached<Amity.Paged<Amity.Message, Amity.Page<string>>> | undefined => {
   const client = getActiveClient();
   client.log('message/queryMessages.locally', query);
 
   if (!client.cache) return;
 
-  const { page = { limit: 10 }, ...params } = query;
+  const params = convertQueryParams(query);
 
-  const queryKey = ['message', 'query', { ...params, options: { ...page } } as Amity.Serializable];
+  const queryKey = ['message', 'query', params as Amity.Serializable];
   const { data, cachedAt } =
     pullFromCache<{ messages: Pick<Amity.Message, 'messageId'>[] } & Amity.Pagination>(queryKey) ??
     {};
@@ -110,8 +98,8 @@ queryMessages.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 messages.length === data?.messages?.length
     ? { data: messages, cachedAt, prevPage, nextPage }