@amityco/ts-sdk 0.0.1-e5fb0d2.0 → 0.0.1-e643f6f.0

package/src/group/utils/test/withUsers.test.ts

@@ -0,0 +1,103 @@
+import { disableCache, enableCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { withUser, withUsers } from '~/group/utils';
+import { baseMembership, user11, user12 } from '~/utils/tests';
+
+const users = [user11, user12];
+
+const member1: Amity.RawMembership<Amity.GroupType> = { ...baseMembership, userId: user11.userId };
+const mappedMember1: Amity.Membership<Amity.GroupType> = { ...member1, user: user11 };
+const unmapableMember1: Amity.Membership<Amity.GroupType> = { ...member1, user: undefined };
+
+const member2: Amity.RawMembership<Amity.GroupType> = { ...baseMembership, userId: user12.userId };
+const mappedMember2: Amity.Membership<Amity.GroupType> = { ...member2, user: user12 };
+const unmapableMember2: Amity.Membership<Amity.GroupType> = { ...member2, user: undefined };
+
+const members1: Amity.RawMembership<Amity.GroupType>[] = [member1, member2];
+const mappedMembers1: Amity.Membership<Amity.GroupType>[] = [mappedMember1, mappedMember2];
+const unmapableMembers1: Amity.Membership<Amity.GroupType>[] = [unmapableMember1, unmapableMember2];
+
+describe('withUser', () => {
+  test('should return mapped member', () => {
+    expect.assertions(2);
+    enableCache();
+    ingestInCache({ users });
+
+    expect(withUser(member1)).toEqual(mappedMember1);
+    expect(withUser(member2)).toEqual(mappedMember2);
+
+    disableCache();
+  });
+
+  test('`.user` should return undefined if cache disabled', () => {
+    disableCache();
+
+    expect(withUser(member1)).toEqual(unmapableMember1);
+  });
+
+  test('`.user` should return error member', () => {
+    expect.assertions(2);
+    enableCache();
+    ingestInCache({ users });
+
+    expect(withUser(member1)).toEqual(mappedMember1);
+    expect(withUser(member2)).toEqual(mappedMember2);
+
+    disableCache();
+  });
+
+  test('`.user` should return undefined when user not exist', () => {
+    enableCache();
+    ingestInCache({ users });
+    const member: Amity.RawMembership<Amity.GroupType> = {
+      ...member1,
+      userId: 'not-exist-user-id',
+    };
+    const expected: Amity.Membership<Amity.GroupType> = {
+      ...member,
+      user: undefined,
+    };
+
+    expect(withUser(member)).toEqual(expected);
+
+    disableCache();
+  });
+});
+
+describe('withUsers', () => {
+  test('should return mapped members', () => {
+    enableCache();
+    ingestInCache({ users });
+
+    expect(withUsers(members1)).toEqual(mappedMembers1);
+
+    disableCache();
+  });
+
+  test('`.user` should return undefined if cache disabled', () => {
+    disableCache();
+
+    expect(withUsers(members1)).toEqual(unmapableMembers1);
+  });
+
+  test('`.user` should return undefined when some user not exist', () => {
+    enableCache();
+    ingestInCache({ users });
+    const members: Amity.RawMembership<Amity.GroupType>[] = [
+      ...members1,
+      { ...member1, userId: 'not-exist-user-id' },
+    ];
+    const expected = [
+      ...mappedMembers1,
+      {
+        ...unmapableMember1,
+        userId: 'not-exist-user-id',
+        user: undefined,
+      },
+    ];
+
+    expect(withUsers(members)).toEqual(expected);
+
+    disableCache();
+  });
+});

package/src/group/utils/withUser.ts

@@ -0,0 +1,98 @@
+import { pullFromCache } from '~/cache/api';
+import { getActiveClient } from '~/client/api';
+
+/**
+ * Attach user object to membership model
+ * - If cache is not enabled, set user to undefined ({..., user: undefined})
+ * - If user object is not found in cache, set user to undefined
+ * ({..., user: undefined})
+ * - If a user is found in the cache, it attaches the user from the cache
+ * ({..., user: { userId, displayName,... }})
+ *
+ * @param member The membership model object
+ * @param userIdProp The user ID prop name of membership object
+ * @param userProp The user prop name of destination object
+ * @returns The membership model object that is already mapped to user
+ * @hidden
+ */
+export const withUser = <
+  M extends Record<any, any>,
+  I extends keyof M = 'userId',
+  U extends string = 'user',
+>(
+  member: M,
+  userIdProp: I = <I>'userId',
+  userProp: U = <U>'user',
+): Record<U, Amity.User | undefined> & M => {
+  // If the user prop already exists, do not overwrite.
+  if (member[userProp]) return member;
+
+  return {
+    get [userProp]() {
+      const client = getActiveClient();
+
+      if (!client.cache) return undefined;
+
+      const userCache = pullFromCache<Amity.User>(['user', 'get', member[userIdProp]])?.data;
+
+      if (!userCache) {
+        return undefined;
+      }
+
+      return userCache;
+    },
+    ...member,
+  };
+};
+
+/**
+ * Mapping membership model with user object
+ *
+ * @param members The membership model objects
+ * @param userIdProp The user ID prop name of membership object
+ * @param userProp The user prop name of destination object
+ * @returns The membership model objects that is already
+ * mapped to users
+ * @hidden
+ */
+export const withUsers = <
+  M extends Record<any, any>[],
+  I extends keyof M[number] = 'userId',
+  U extends string = 'user',
+>(
+  members: M,
+  userIdProp: I = <I>'userId',
+  userProp: U = <U>'user',
+): (Record<U, Amity.User | undefined> & M[number])[] => {
+  return members?.map(member => withUser(member, userIdProp, userProp)) ?? members;
+};
+
+/**
+ * Transform members prop in any payload with attached users members
+ *
+ * @param payload The payload contain members prop
+ * @param memberProp A name of members prop
+ * @param userIdProp The user ID prop name of membership object
+ * @param userProp The user prop name of destination object
+ * @returns The transforming payload
+ * @hidden
+ */
+export const prepareMembershipPayload = <
+  P extends Record<any, any>,
+  M extends keyof P,
+  I extends keyof P[M][number] = 'userId',
+  U extends string = 'user',
+>(
+  payload: P,
+  memberProp: M,
+  userIdProp: I = <I>'userId',
+  userProp: U = <U>'user',
+): Omit<P, M> & Record<M, (Record<U, Amity.User | undefined> & P[M][number])[]> => {
+  const { [memberProp]: memberPayload, ...rest } = payload;
+  const members = withUsers(memberPayload, userIdProp, userProp);
+
+  return {
+    ...rest,
+    ...{ [memberProp]: members },
+  };
+};

package/src/index.ts

@@ -1,53 +1,75 @@
 // types
-import './@types'
+export * from './@types';
+
+export * from './version';
 
 // sdk core
-export * from './core/query'
-export * from './core/cache'
-export * from './core/stores'
+export * from './core/query';
+export * from './core/subscription';
+export * from './cache/api';
 
-export * from './client/api'
-export * from './client/events'
+export * from './client/api';
+export * from './client/events';
+export { API_REGIONS } from './client/utils/endpoints';
 
 // asc core
-export * from './user/api'
-export * from './user/events'
-export * from './user/observers'
+export * from './user/api';
+export * from './user/events';
+export * from './user/observers';
+
+export * from './file/api';
+export * from './file/observers';
+
+export * from './role/api';
+
+// // asc partials
+export * from './reaction/api';
+export * from './reaction/events';
+export * from './reaction/observers';
+
+export * from './report/api';
+
+// // asc messaging
+export * from './channel/api';
+export * from './channel/events';
+export * from './channel/observers';
 
-export * from './file/api'
-export * from './file/observers'
+export * from './subChannel/api';
+export * from './subChannel/events';
+export * from './subChannel/observers';
 
-export * from './role/api'
+export * from './message/api';
+export * from './message/events';
+export * from './message/observers';
 
-// asc partials
-export * from './reaction/api'
-export * from './reaction/events'
+// // asc social
+export * from './community/api';
+export * from './community/events';
+export * from './community/observers';
 
-export * from './report/api'
+export * from './category/api';
+export * from './category/observers';
 
-// asc messaging
-export * from './channel/api'
-export * from './channel/events'
-export * from './channel/observers'
+export * from './feed/api';
 
-export * from './message/api'
-export * from './message/events'
-export * from './message/observers'
+export * from './follow/api';
+export * from './follow/events';
+export * from './follow/observers';
 
-// asc social
-export * from './community/api'
-export * from './community/events'
-export * from './community/observers'
+export * from './post/api';
+export * from './post/events';
+export * from './post/observers';
 
-export * from './feed/api'
+export * from './comment/api';
+export * from './comment/events';
+export * from './comment/observers';
 
-export * from './post/api'
-export * from './post/events'
-export * from './post/observers'
+export * from './poll/api';
+export * from './poll/events';
+export * from './poll/observers';
 
-export * from './comment/api'
-export * from './comment/events'
-export * from './comment/observers'
+export * from './stream/api';
+export * from './stream/events';
 
-export * from './stream/api'
-// export * from './stream/events'
+// // external apis
+export * from './external/api';

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,58 @@ 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'];
+    // Custom referenceId is a workaround for the case:
+    // User wants to create an image message. He should
+    // - create and show dummy message in ui
+    // - upload image to get fileId, while uploading show a spinner in dummy message in ui
+    // - call createMessage and pass fileId
+    // - replace dummy message with the actual message received from backend
+    // Custom referenceId is needed to make relation between dummy message and actual message.
+    // TODO: passing file src into createMessage so that sdk uploads files itself,
+    // returns the dummy message bound with the file to eliminate the need to create
+    // the dummy message on the user side,
+    referenceId?: string;
+  },
+): Promise<Amity.Cached<Amity.Message>> => {
+  const client = getActiveClient();
+  client.log('message/createMessage', bundle);
+
+  const referenceId = bundle.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' }
  * })
@@ -57,34 +102,66 @@ 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)
+createMessage.optimistically = ({
+  referenceId,
+  ...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 = referenceId || 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 */