@amityco/ts-sdk 0.0.1-beta.4 → 0.0.1-beta.41.1

package/src/message/api/createMessage.ts

@@ -1,18 +1,32 @@
-import { uuid } from '~/core/uuid'
+import { uuid } from '~/core/uuid';
+import { fireEvent } from '~/core/events';
+import { getActiveClient } from '~/client/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { UNSYNCED_OBJECT_CACHED_AT_VALUE } from '~/utils/constants';
+import { upsertInCache, pullFromCache, pushToCache, dropFromCache } from '~/cache/api';
 
-import { getActiveClient } from '~/client/api'
+import { convertParams, prepareMessagePayload } from '../utils';
 
-import { decoratePayload } from '~/core/query'
-import { ingestInCache, pullFromCache, pushToCache } from '~/core/cache'
-import { fireEvent } from '~/core/events'
+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,27 +38,47 @@ import { fireEvent } from '~/core/events'
  * @async
  */
 export const createMessage = async <T extends Amity.MessageContentType>(
-  bundle: Pick<Amity.Message<T>, 'channelId' | 'type' | 'data' | 'metadata'>
-) => {
-  const client = getActiveClient()
-  client.log('user/createMessage', bundle)
+  bundle: Pick<
+    Amity.Message<T>,
+    '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('message/createMessage', bundle);
+
+  const referenceId = uniqueId || getLocalId();
+  uniqueId = undefined;
+
+  const { data: payload } = await client.http.post<Amity.MessagePayload>('/api/v5/messages', {
+    ...convertParams(bundle),
+    referenceId,
+  });
+
+  const data = prepareMessagePayload(payload);
+  const { messages } = data;
 
-  const { data } = await client.http.post<Amity.MessagePayload>(
-    '/api/v3/messages', bundle,
-  )
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) {
+    dropFromCache(['message', 'get', referenceId]);
+    ingestInCache(data, { cachedAt });
+  }
 
-  decoratePayload(data)
-  ingestInCache(data)
-  // no need for event, fired by server
+  fireEvent('local.message.created', { messages });
 
-  const { messages } = data
-  return messages[0]
-}
+  return {
+    data: messages[0],
+    cachedAt,
+  };
+};
 
 /**
  * ```js
  * import { createMessage } from '@amityco/ts-sdk'
- * const created = createMessage.locally({
+ *
+ * const created = createMessage.optimistically({
  *   channelId: 'foobar',
  *   data: { text: 'hello world' }
  * })
@@ -58,33 +92,64 @@ export const createMessage = async <T extends Amity.MessageContentType>(
  * @category Message API
  */
 createMessage.optimistically = (
-  bundle: Pick<Amity.Message, 'channelId' | 'type' | 'data' | 'metadata'>
-) => {
-  const client = getActiveClient()
-  client.log('user/createMessage.locally', bundle)
+  bundle: Parameters<typeof createMessage>[0],
+): Amity.Cached<Amity.Message> | undefined => {
+  const client = getActiveClient();
+
+  if (!client.cache) return;
+
+  /*
+   * 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 };
+
+  client.log('message/createMessage.optimistically', bundleWithMessageId);
+
+  const subChannel = pullFromCache<Amity.SubChannel>(['subChannel', 'get', bundle.subChannelId]);
 
-  // should we do this?
-  if (!client.cache) return
+  if (subChannel) {
+    upsertInCache(['subChannel', 'get', bundle.subChannelId], {
+      ...subChannel.data,
+      messageCount: subChannel.data.messageCount + 1,
+    });
 
-  const [channel] = pullFromCache('channel', bundle.channelId) ?? []
+    if (subChannel.data.channelId === subChannel.data.subChannelId) {
+      const channel = pullFromCache<Amity.Channel>(['channel', 'get', subChannel.data.channelId]);
 
-  pushToCache('channel', {
-    ...channel,
-    messageCount: (channel.messageCount ?? 0) + 1,
-  })
+      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 = {
-    localId: uuid(),
-    messageId: Math.random().toString(16),
-    userId: client.userId,
-    channelSegment: (channel?.messageCount ?? 0) + 1,
-    createdAt: new Date().toISOString(),
-    ...bundle,
-    syncedAt: -1,
-  } as Amity.Message
-
-  pushToCache('message', message)
-  fireEvent('v3.message.didCreate', { messages: [message] })
-
-  return message
-}
+    creatorId: client.userId!,
+    channelSegment: (subChannel?.data.messageCount ?? 0) + 1,
+    childrenNumber: 0,
+    createdAt: createdTime,
+    updatedAt: createdTime,
+    ...bundleWithMessageId,
+  } as Amity.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,
+  };
+};
+/* end_public_function */

package/src/message/api/deleteMessage.ts

@@ -1,13 +1,12 @@
-import { getActiveClient } from '~/client/api'
+import { getActiveClient } from '~/client/api';
+import { pullFromCache, upsertInCache } from '~/cache/api';
+import { fireEvent } from '~/core/events';
 
-import { getMessage } from './getMessage'
-
-import {
-  pullFromCache,
-  pushToCache,
-} from '~/core/cache'
-import { fireEvent } from '~/core/events'
+import { getMessage } from './getMessage';
 
+/* begin_public_function
+  id: message.soft_delete
+*/
 /**
  * ```js
  * import { deleteMessage } from '@amityco/ts-sdk'
@@ -16,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
@@ -24,25 +23,26 @@ import { fireEvent } from '~/core/events'
  */
 export const deleteMessage = async (
   messageId: Amity.Message['messageId'],
-) => {
-  const client = getActiveClient()
-  client.log('message/deleteMessage', messageId)
+): Promise<Amity.Message> => {
+  const client = getActiveClient();
+  client.log('message/deleteMessage', messageId);
 
   // API-FIX: This endpoint has not been implemented yet.
   await client.http.delete<{ success: boolean }>(
-    `/api/v3/messages/${messageId}`
-  )
+    `/api/v5/messages/${encodeURIComponent(messageId)}`,
+  );
+
+  const deleted = await getMessage(messageId);
 
-  const deleted = await getMessage(messageId)
-  // no need for event, fired by server
+  fireEvent('local.message.deleted', { messages: [deleted.data] });
 
-  return deleted
-}
+  return deleted.data;
+};
 
 /**
  * ```js
  * import { deleteMessage } from '@amityco/ts-sdk'
- * const success = deleteMessage.locally('foobar')
+ * const success = deleteMessage.optimistically('foobar')
  * ```
  *
  * Deletes a {@link Amity.Message}
@@ -54,22 +54,27 @@ export const deleteMessage = async (
  */
 deleteMessage.optimistically = (
   messageId: Amity.Message['messageId'],
-) => {
-  const client = getActiveClient()
-  client.log('message/deleteMessage', messageId)
+): Amity.Cached<Amity.Message> | undefined => {
+  const client = getActiveClient();
+  client.log('message/deleteMessage.optimistically', messageId);
 
-  const [message] = pullFromCache('message', messageId) ?? []
+  const message = pullFromCache<Amity.Message>(['message', 'get', messageId]);
 
-  if (!message) return
+  if (!message) return;
 
+  const cachedAt = -1;
   const deleted: Amity.Message = {
-    ...message,
+    ...message.data,
     isDeleted: true,
     updatedAt: new Date().toISOString(),
-  }
+  };
 
-  pushToCache('message', deleted)
-  fireEvent('v3.message.didDelete', { messages: [deleted] })
+  upsertInCache(['message', 'get', messageId], deleted, { cachedAt });
+  fireEvent('local.message.deleted', { messages: [deleted] });
 
-  return deleted
-}
+  return {
+    data: deleted,
+    cachedAt,
+  };
+};
+/* end_public_function */

package/src/message/api/getMessage.ts

@@ -1,9 +1,17 @@
-import { getActiveClient } from '~/client/api'
-import { ingestInCache, pullFromCache } from '~/core/cache'
-import { decoratePayload } from '~/core/query'
+import { getActiveClient } from '~/client/api';
 
-import { getMessages } from './getMessages'
+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'
@@ -20,21 +28,49 @@ import { getMessages } from './getMessages'
  */
 export const getMessage = async (
   messageId: Amity.Message['messageId'],
-) => {
-  const client = getActiveClient()
-  client.log('message/getMessage', messageId)
+  isLive = false,
+): Promise<Amity.Cached<Amity.Message>> => {
+  const client = getActiveClient();
+  client.log('message/getMessage', 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);
+    }
 
-  // API-FIX: endpoint should not be /list, parameters should be querystring.
-  const { data } = await client.http.get<Amity.MessagePayload>(
-    `/api/v3/messages/${messageId}`,
-  )
+    throw error;
+  }
 
-  decoratePayload(data)
-  ingestInCache(data)
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
 
-  const { messages } = data
-  return messages.find(message => message.messageId === messageId)!
-}
+  const { messages } = data;
+
+  fireEvent('local.message.fetched', { messages });
+
+  return {
+    data: messages.find(message => message.messageId === messageId)!,
+    cachedAt,
+  };
+};
+/* end_public_function */
 
 /**
  * ```js
@@ -51,10 +87,18 @@ export const getMessage = async (
  */
 getMessage.locally = (
   messageId: Amity.Message['messageId'],
-) => {
-  const client = getActiveClient()
-  client.log('message/getMessage.locally', messageId)
+): Amity.Cached<Amity.Message> | undefined => {
+  const client = getActiveClient();
+  client.log('message/getMessage.locally', messageId);
+
+  if (!client.cache) return;
+
+  const cached = pullFromCache<Amity.Message>(['message', 'get', messageId]);
+
+  if (!cached) return;
 
-  const [message] = pullFromCache('message', messageId) ?? []
-  return message
-}
+  return {
+    data: cached.data,
+    cachedAt: cached.cachedAt,
+  };
+};

package/src/message/api/getMessages.ts

@@ -1,8 +1,9 @@
-import { getActiveClient } from '~/client/api'
+import { getActiveClient } from '~/client/api';
 
-import { decoratePayload } from '~/core/query'
-import { ingestInCache, pullFromCache } from '~/core/cache'
-import { toRecord } from '~/core/model'
+import { fireEvent } from '~/core/events';
+import { pullFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { convertResponseFromRaw } from '../utils';
 
 /**
  * ```js
@@ -20,22 +21,28 @@ import { toRecord } from '~/core/model'
  */
 export const getMessages = async (
   messageIds: Amity.Message['messageId'][],
-) => {
-  const client = getActiveClient()
-  client.log('message/getMessages', messageIds)
+): Promise<Amity.Cached<Amity.Message[]>> => {
+  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);
 
-  decoratePayload(data)
-  ingestInCache(data)
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
 
-  const { messages } = data
-  return toRecord(messages)
-}
+  const { messages } = data;
+
+  fireEvent('local.message.fetched', { messages });
+
+  return {
+    data: messages,
+    cachedAt,
+  };
+};
 
 /**
  * ```js
@@ -52,12 +59,23 @@ export const getMessages = async (
  */
 getMessages.locally = (
   messageIds: Amity.Message['messageId'][],
-) => {
-  const client = getActiveClient()
-  client.log('message/getMessages.locally', messageIds)
+): Amity.Cached<Amity.Message[]> | undefined => {
+  const client = getActiveClient();
+  client.log('message/getMessages.locally', messageIds);
+
+  if (!client.cache) return;
+
+  const cached = messageIds
+    .map(messageId => pullFromCache<Amity.Message>(['message', 'get', messageId])!)
+    .filter(Boolean);
+
+  const messages = cached.map(({ data }) => data);
+  const oldest = cached.sort((a, b) => (a.cachedAt! < b.cachedAt! ? -1 : 1))?.[0];
 
-  const cached = pullFromCache('message', ...messageIds) ?? []
+  if (cached?.length < messageIds.length) return;
 
-  if (cached?.length === messageIds.length)
-    return toRecord(cached)
-}
+  return {
+    data: messages,
+    cachedAt: oldest.cachedAt,
+  };
+};

package/src/message/api/index.ts

@@ -1,6 +1,6 @@
-export * from './getMessage'
-export * from './getMessages'
-export * from './queryMessages'
-export * from './createMessage'
-export * from './updateMessage'
-export * from './deleteMessage'
+export * from './getMessage';
+export * from './getMessages';
+export * from './queryMessages';
+export * from './createMessage';
+export * from './updateMessage';
+export * from './deleteMessage';