@amityco/ts-sdk 0.0.1-beta.22 → 0.0.1-beta.23

package/dist/message/api/createMessage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createMessage.d.ts","sourceRoot":"","sources":["../../../src/message/api/createMessage.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,aAAa;2JAKvB,QAAQ,MAAM,MAAM,CAAC,MAAM,OAAO,CAAC,CAAC;IAkBvC;;;;;;;;;;;;;;;OAeG;2BAEO,KACN,MAAM,OAAO,EACb,WAAW,GAAG,UAAU,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,UAAU,GAAG,YAAY,CAChF,GACA,MAAM,MAAM,CAAC,MAAM,OAAO,CAAC,GAAG,SAAS;CAvBzC,CAAC"}
+{"version":3,"file":"createMessage.d.ts","sourceRoot":"","sources":["../../../src/message/api/createMessage.ts"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,aAAa;2JAKvB,QAAQ,MAAM,MAAM,CAAC,MAAM,OAAO,CAAC,CAAC;IAmBvC;;;;;;;;;;;;;;;OAeG;2BAEO,KACN,MAAM,OAAO,EACb,WAAW,GAAG,UAAU,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,UAAU,GAAG,YAAY,CAChF,GACA,MAAM,MAAM,CAAC,MAAM,OAAO,CAAC,GAAG,SAAS;CAvBzC,CAAC"}

package/dist/message/events/onMessageUpdated.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"onMessageUpdated.d.ts","sourceRoot":"","sources":["../../../src/message/events/onMessageUpdated.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,gBAAgB,aAAc,MAAM,QAAQ,CAAC,MAAM,OAAO,CAAC,KAAG,MAAM,YAShF,CAAC"}
+{"version":3,"file":"onMessageUpdated.d.ts","sourceRoot":"","sources":["../../../src/message/events/onMessageUpdated.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,gBAAgB,aAAc,MAAM,QAAQ,CAAC,MAAM,OAAO,CAAC,KAAG,MAAM,YAgBhF,CAAC"}

package/dist/reaction/events/onReactionAdded.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"onReactionAdded.d.ts","sourceRoot":"","sources":["../../../src/reaction/events/onReactionAdded.ts"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;KAgBK;AACL,eAAO,MAAM,eAAe,kBACX,MAAM,aAAa,eACrB,MAAM,QAAQ,CAAC,aAAa,CAAC,0FAEzC,MAAM,YAsCR,CAAC"}
+{"version":3,"file":"onReactionAdded.d.ts","sourceRoot":"","sources":["../../../src/reaction/events/onReactionAdded.ts"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;KAgBK;AACL,eAAO,MAAM,eAAe,kBACX,MAAM,aAAa,eACrB,MAAM,QAAQ,CAAC,aAAa,CAAC,0FAEzC,MAAM,YA0CR,CAAC"}

package/dist/reaction/utils/index.d.ts

@@ -1,4 +1,5 @@
 export * from './dispatchReactable';
 export * from './fetchReference';
 export * from './preparePayloadForCache';
+export * from './prepareMessagePayloadForCache';
 //# sourceMappingURL=index.d.ts.map

package/dist/reaction/utils/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/reaction/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,kBAAkB,CAAC;AACjC,cAAc,0BAA0B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/reaction/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,kBAAkB,CAAC;AACjC,cAAc,0BAA0B,CAAC;AACzC,cAAc,iCAAiC,CAAC"}

package/dist/reaction/utils/prepareMessagePayloadForCache.d.ts

@@ -0,0 +1,3 @@
+/** @hidden */
+export declare const prepareMessagePayloadForCache: (payload: Amity.Message) => void;
+//# sourceMappingURL=prepareMessagePayloadForCache.d.ts.map

package/dist/reaction/utils/prepareMessagePayloadForCache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prepareMessagePayloadForCache.d.ts","sourceRoot":"","sources":["../../../src/reaction/utils/prepareMessagePayloadForCache.ts"],"names":[],"mappings":"AAGA,cAAc;AAKd,eAAO,MAAM,6BAA6B,YAAa,MAAM,OAAO,SA+BnE,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amityco/ts-sdk",
-  "version": "0.0.1-beta.22",
+  "version": "0.0.1-beta.23",
   "license": "CC-BY-ND-4.0",
   "author": "amity.co <developers@amity.co> (https://amity.co)",
   "description": "Amity Social Cloud Typescript SDK",

package/src/@types/domains/reaction.ts

@@ -18,7 +18,7 @@ declare global {
       myReactions?: string[];
 
       latestReaction?: Amity.Reaction & {
-        eventName: 'added' | 'removed';
+        eventName: 'add' | 'remove';
       };
     };
 

package/src/channel/api/queryChannelMembers.ts

@@ -19,22 +19,22 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
  * */
 export const queryChannelMembers = async (query: {
   channelId: string;
-  membership?: 'all' | 'muted' | 'banned' | 'member&banned';
+  memberships?: ('muted' | 'banned' | 'member')[];
   roles?: string[];
   sortBy?: 'firstCreated' | 'lastCreated';
+  search?: string;
   page?: Amity.Page;
 }): Promise<Amity.Cached<Amity.Paged<Amity.Membership<'channel'>>>> => {
   const client = getActiveClient();
   client.log('channel/queryChannelMembers', query);
 
-  const { page, channelId, membership, ...params } = query ?? {};
+  const { page, channelId, ...params } = query ?? {};
 
   const { data } = await client.http.get<Amity.ChannelMembershipPayload & Amity.Pagination>(
-    `/api/v3/channels/${encodeURIComponent(channelId)}/users`,
+    `/api/v4/channels/${encodeURIComponent(channelId)}/users`,
     {
       params: {
         ...params,
-        filter: membership,
         options: {
           token: toToken(page, 'skiplimit'),
         },

package/src/client/api/connectClient.ts

@@ -32,12 +32,15 @@ import { onUserDeleted } from '~/user/events/onUserDeleted';
  * @category Client API
  * @async
  */
-export const connectClient = async (params: {
-  userId: Amity.User['userId'];
-  displayName?: Amity.User['displayName'];
-  authToken?: string;
-  deviceId?: Amity.Device['deviceId'];
-}): Promise<boolean> => {
+export const connectClient = async (
+  params: {
+    userId: Amity.User['userId'];
+    displayName?: Amity.User['displayName'];
+    authToken?: string;
+    deviceId?: Amity.Device['deviceId'];
+  },
+  config?: { disableRTE: boolean },
+): Promise<boolean> => {
   const client = getActiveClient();
   client.log('client/api/connectClient', { apiKey: client.apiKey, ...params });
 
@@ -70,7 +73,9 @@ export const connectClient = async (params: {
 
   setActiveUser(users[0]);
 
-  subscribeTopic(getNetworkTopic());
+  if (config?.disableRTE !== true) {
+    subscribeTopic(getNetworkTopic());
+  }
 
   const subscriptions = [
     onClientBanned(() => {

package/src/comment/api/queryComments.ts

@@ -22,6 +22,7 @@ import { getResolver } from '~/core/model';
 export const queryComments = async (query: {
   referenceType: Amity.Comment['referenceType'];
   referenceId: Amity.Comment['referenceId'];
+  sortBy?: 'lastCreated' | 'firstCreated' | 'lastUpdated' | 'firstUpdated';
   parentId?: Amity.Comment['commentId'] | null;
   hasFlag?: boolean;
   isDeleted?: Amity.Comment['isDeleted'];
@@ -32,6 +33,10 @@ export const queryComments = async (query: {
 
   const { page = { limit: 10 }, ...params } = query;
 
+  const options = {
+    type: params.sortBy ? 'pagination' : undefined,
+    token: toToken(page, params.sortBy ? 'skiplimit' : 'afterbefore'),
+  };
   // const filterByParentId = query.parentId !== undefined
 
   // API-FIX: parameters should be querystring. (1)
@@ -43,9 +48,7 @@ export const queryComments = async (query: {
       params: {
         ...params,
         //      filterByParentId, API-FIX: backend does not support this boolean LOL. what the hell seriously.
-        options: {
-          token: toToken(page, 'afterbefore'),
-        },
+        options,
       },
     },
   );

package/src/core/model/identifyModel.ts

@@ -57,3 +57,21 @@ export const identifyModel = (model: Record<string, unknown>) => {
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
   return criterias.find(([_, keys]) => hasKeys(model, keys))?.[0];
 };
+
+/*
+ * Identify the modal key for a model
+ * Used to get args for optimistic updates
+ * Example: createMessage: get messageId on optimistic message creation
+ *
+ * @param model to be recognized
+ * @returns model key array if one if found or undefined
+ */
+export const identifyModelKey = (model: Record<string, unknown>): string | undefined => {
+  const modalKey = identifyModel(model);
+
+  if (!modalKey) {
+    return undefined;
+  }
+
+  return CRITERIAS[modalKey]?.[0];
+};

package/src/core/query/query.ts

@@ -1,5 +1,6 @@
 /* eslint-disable no-use-before-define */
 import { isPaged } from './paging';
+import { identifyModelKey } from '~/core/model';
 
 /**
  * Type guard to check and cast that a given async function is has the ".locally" property
@@ -201,7 +202,24 @@ export const runQuery = <Args extends any[], Returned extends any>(
     );
   }
 
-  func(...args)
+  let optimisticArgs = args;
+  /* get args for optimistic method calls
+   *
+   * On optimistic updates, the modal key for the update needs to be passed to
+   * the server so as to avoid duplicate modal creation
+   *
+   * ex: on creating a new message pass the modalKey is messageId, pass this
+   * id onto the server so that a duplicate with seperate messageId is not
+   * created.
+   */
+  if (isMutator(func)) {
+    // @ts-ignore
+    const modelKey = local && local.data && identifyModelKey(local.data);
+    // @ts-ignore
+    optimisticArgs = modelKey ? [{ ...args[0], [modelKey]: local.data[modelKey] }] : args;
+  }
+
+  func(...optimisticArgs)
     .then(fresh => {
       // @ts-ignore i know.
       // isLocal(local) && syncInCache(local, fresh)

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
@@ -28,6 +29,7 @@ export const createMessage = async <T extends Amity.MessageContentType>(
   >,
 ): 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);
@@ -67,23 +69,34 @@ createMessage.optimistically = (
   >,
 ): 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
+   */
+  const bundleWithMessageId = { ...bundle, messageId: uuid() };
+
+  // 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/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/reaction/events/onReactionAdded.ts

@@ -34,6 +34,10 @@ export const onReactionAdded = (
     }
   };
 
+  /*
+   * Important: Want to point out that reference type will never be 'message'
+   * for onReactionAdded
+   */
   if (referenceType === 'message') {
     const client = getActiveClient();
 

package/src/reaction/utils/index.ts

@@ -1,3 +1,4 @@
 export * from './dispatchReactable';
 export * from './fetchReference';
 export * from './preparePayloadForCache';
+export * from './prepareMessagePayloadForCache';

package/src/reaction/utils/prepareMessagePayloadForCache.ts

@@ -0,0 +1,40 @@
+import { pullFromCache } from '~/cache/api';
+import { getActiveClient } from '~/client/api';
+
+/** @hidden */
+/*
+ * @param message payload from http request without myReactions
+ * add myReactions to http response if the event was a reaction event
+ */
+export const prepareMessagePayloadForCache = (payload: Amity.Message) => {
+  const client = getActiveClient();
+
+  const cached = pullFromCache<Amity.Message>(['message', 'get', payload.messageId]);
+  // '[]' in cases where the new reaction is the first one
+  const myReactions = cached?.data.myReactions || [];
+
+  // add myReactions to the payload
+  Object.assign(payload, { myReactions });
+
+  // check if there are any updates to the reactions
+  const latestReaction = payload?.latestReaction;
+  const isLatestReactionMine = latestReaction && latestReaction.userId === client.userId;
+
+  if (!isLatestReactionMine) {
+    return;
+  }
+
+  // new reaction added
+  if (latestReaction.eventName === 'add' && !myReactions.includes(latestReaction.reactionName)) {
+    Object.assign(payload, {
+      myReactions: [...myReactions, latestReaction.reactionName],
+    });
+  }
+
+  // existing reaction removed
+  if (latestReaction.eventName === 'remove' && myReactions.includes(latestReaction.reactionName)) {
+    Object.assign(payload, {
+      myReactions: myReactions.filter(x => x !== latestReaction.reactionName),
+    });
+  }
+};