@amityco/ts-sdk 0.0.1-73c3ccf.0 → 0.0.1-79eb069.0

package/dist/comment/api/deleteComment.d.ts

@@ -12,7 +12,40 @@
  * @category Comment API
  * @async
  */
-export declare const deleteComment: (commentId: Amity.Comment['commentId'], permanent?: boolean) => Promise<Amity.Comment<any> | {
-    success: boolean;
+export declare const deleteComment: (commentId: Amity.Comment['commentId'], permanent?: boolean) => Promise<{
+    isDeleted: boolean;
+    commentId: string;
+    userId: string;
+    parentId?: string | undefined;
+    rootId: string;
+    childrenNumber: number;
+    children: string[];
+    segmentNumber: number;
+    referenceId: string;
+    referenceType: Amity.CommentReferenceType;
+    dataType?: any;
+    data: any;
+    metadata?: Record<string, any> | undefined;
+    flagCount: number;
+    hashFlag: {
+        bits: number;
+        hashes: number;
+        hash: string;
+    } | null;
+    reactionsCount: number;
+    reactions: Record<string, number>;
+    myReactions?: string[] | undefined;
+    latestReaction?: ({
+        reactionId: string;
+        userId: string;
+        reactionName: string;
+    } & Amity.CreatedAt & Amity.Relationship<Amity.ReactableType> & {
+        eventName: "added" | "removed";
+    }) | undefined;
+    createdAt: string;
+    updatedAt?: string | undefined;
+    deletedAt?: string | undefined;
+    localId: string;
+    syncedAt: number;
 }>;
 //# sourceMappingURL=deleteComment.d.ts.map

package/dist/comment/api/deleteComment.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"deleteComment.d.ts","sourceRoot":"","sources":["../../../src/comment/api/deleteComment.ts"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,aAAa,cACb,aAAa,CAAC,WAAW,CAAC,cAC1B,OAAO;;EAuCnB,CAAA"}
+{"version":3,"file":"deleteComment.d.ts","sourceRoot":"","sources":["../../../src/comment/api/deleteComment.ts"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,aAAa,cACb,aAAa,CAAC,WAAW,CAAC,cAC1B,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmCnB,CAAA"}

package/dist/index.cjs.js

@@ -2993,9 +2993,9 @@ const removeCommunityMembersRole = async (communityId, roleId, userIds) => {
  * @async
  */
 const deletePost = async (postId, permanent = false) => {
-    var _a;
     const client = getActiveClient();
     client.log('post/deletePost', postId);
+    let post = await getPost(postId);
     // API-FIX: This endpoint has not been implemented yet.
     await client.http.delete(`/api/v4/posts/${postId}`, {
         params: {
@@ -3003,26 +3003,25 @@ const deletePost = async (postId, permanent = false) => {
             permanent,
         },
     });
-    let deleted;
-    try {
-        // API-FIX: as for now we have no choice but to refetch
-        deleted = await getPost(postId);
-    }
-    catch (error) {
-        if (((_a = error) === null || _a === void 0 ? void 0 : _a.code) === 400400 /* ITEM_NOT_FOUND */) {
-            // there is currently a limitation which doesnt allow us to fire event to tell that community
-            // has been updated. reason is that, when the object is deleted, we don't have its `communityId`
-            // and so we cannot refetch the community or advertise on events. hopefully this should be solved
-            // later when realtime events covers that for us.
-            return { success: true };
-        }
-        throw (error);
-    }
-    if (deleted.targetType === 'community') {
-        const community = await getCommunity(deleted.targetId);
+    // there is currently a limitation which doesn't allow us to fire event to tell that community
+    // has been updated. reason is that, when the object is deleted, we don't have its `communityId`
+    // and so we cannot refetch the community or advertise on events. hopefully this should be solved
+    // later when realtime events covers that for us.
+    if (post.targetType === 'community') {
+        const community = await getCommunity(post.targetId);
         fireEvent('v3.community.didUpdate', { communities: [community] });
     }
+    // to support hard deletion
+    const deleted = Object.assign(Object.assign({}, post), { isDeleted: true });
     fireEvent('v3.post.didDelete', { posts: [deleted] });
+    if (permanent) {
+        setTimeout(() => {
+            dropFromCache('post', { postId });
+        }, 0);
+    }
+    else {
+        mergeInCache('post', { postId, isDeleted: true });
+    }
     return deleted;
 };
 
@@ -3309,9 +3308,9 @@ const updateComment = async (commentId, patch) => {
  * @async
  */
 const deleteComment = async (commentId, permanent = false) => {
-    var _a;
     const client = getActiveClient();
     client.log('comment/deleteComment', commentId);
+    const comment = await getComment(commentId);
     // API-FIX: This endpoint has not been implemented yet.
     await client.http.delete(`/api/v4/comments/${commentId}`, {
         params: {
@@ -3319,24 +3318,19 @@ const deleteComment = async (commentId, permanent = false) => {
             permanent,
         },
     });
-    let deleted;
-    try {
-        // API-FIX: as for now we have no choice but to refetch
-        deleted = await getComment(commentId);
-    }
-    catch (error) {
-        if (((_a = error) === null || _a === void 0 ? void 0 : _a.code) === 400400 /* ITEM_NOT_FOUND */) {
-            // there is currently a limitation which doesnt allow us to fire event to tell that post
-            // has been updated. reason is that, when the object is deleted, we don't have its `postId`
-            // and so we cannot refetch the post or advertise on events. hopefully this should be solved
-            // later when realtime events covers that for us.
-            return { success: true };
-        }
-        throw (error);
-    }
-    const post = await getPost(deleted.referenceId);
+    // to support hard deletion
+    const deleted = Object.assign(Object.assign({}, comment), { isDeleted: true });
+    const post = await getPost(comment.referenceId);
     fireEvent('v3.post.didUpdate', { posts: [post] });
     fireEvent('v3.comment.didDelete', { comments: [deleted] });
+    if (permanent) {
+        setTimeout(() => {
+            dropFromCache('comment', { commentId });
+        }, 0);
+    }
+    else {
+        mergeInCache('comment', { commentId, isDeleted: true });
+    }
     return deleted;
 };
 

package/dist/index.esm.js

@@ -2979,9 +2979,9 @@ const removeCommunityMembersRole = async (communityId, roleId, userIds) => {
  * @async
  */
 const deletePost = async (postId, permanent = false) => {
-    var _a;
     const client = getActiveClient();
     client.log('post/deletePost', postId);
+    let post = await getPost(postId);
     // API-FIX: This endpoint has not been implemented yet.
     await client.http.delete(`/api/v4/posts/${postId}`, {
         params: {
@@ -2989,26 +2989,25 @@ const deletePost = async (postId, permanent = false) => {
             permanent,
         },
     });
-    let deleted;
-    try {
-        // API-FIX: as for now we have no choice but to refetch
-        deleted = await getPost(postId);
-    }
-    catch (error) {
-        if (((_a = error) === null || _a === void 0 ? void 0 : _a.code) === 400400 /* ITEM_NOT_FOUND */) {
-            // there is currently a limitation which doesnt allow us to fire event to tell that community
-            // has been updated. reason is that, when the object is deleted, we don't have its `communityId`
-            // and so we cannot refetch the community or advertise on events. hopefully this should be solved
-            // later when realtime events covers that for us.
-            return { success: true };
-        }
-        throw (error);
-    }
-    if (deleted.targetType === 'community') {
-        const community = await getCommunity(deleted.targetId);
+    // there is currently a limitation which doesn't allow us to fire event to tell that community
+    // has been updated. reason is that, when the object is deleted, we don't have its `communityId`
+    // and so we cannot refetch the community or advertise on events. hopefully this should be solved
+    // later when realtime events covers that for us.
+    if (post.targetType === 'community') {
+        const community = await getCommunity(post.targetId);
         fireEvent('v3.community.didUpdate', { communities: [community] });
     }
+    // to support hard deletion
+    const deleted = Object.assign(Object.assign({}, post), { isDeleted: true });
     fireEvent('v3.post.didDelete', { posts: [deleted] });
+    if (permanent) {
+        setTimeout(() => {
+            dropFromCache('post', { postId });
+        }, 0);
+    }
+    else {
+        mergeInCache('post', { postId, isDeleted: true });
+    }
     return deleted;
 };
 
@@ -3295,9 +3294,9 @@ const updateComment = async (commentId, patch) => {
  * @async
  */
 const deleteComment = async (commentId, permanent = false) => {
-    var _a;
     const client = getActiveClient();
     client.log('comment/deleteComment', commentId);
+    const comment = await getComment(commentId);
     // API-FIX: This endpoint has not been implemented yet.
     await client.http.delete(`/api/v4/comments/${commentId}`, {
         params: {
@@ -3305,24 +3304,19 @@ const deleteComment = async (commentId, permanent = false) => {
             permanent,
         },
     });
-    let deleted;
-    try {
-        // API-FIX: as for now we have no choice but to refetch
-        deleted = await getComment(commentId);
-    }
-    catch (error) {
-        if (((_a = error) === null || _a === void 0 ? void 0 : _a.code) === 400400 /* ITEM_NOT_FOUND */) {
-            // there is currently a limitation which doesnt allow us to fire event to tell that post
-            // has been updated. reason is that, when the object is deleted, we don't have its `postId`
-            // and so we cannot refetch the post or advertise on events. hopefully this should be solved
-            // later when realtime events covers that for us.
-            return { success: true };
-        }
-        throw (error);
-    }
-    const post = await getPost(deleted.referenceId);
+    // to support hard deletion
+    const deleted = Object.assign(Object.assign({}, comment), { isDeleted: true });
+    const post = await getPost(comment.referenceId);
     fireEvent('v3.post.didUpdate', { posts: [post] });
     fireEvent('v3.comment.didDelete', { comments: [deleted] });
+    if (permanent) {
+        setTimeout(() => {
+            dropFromCache('comment', { commentId });
+        }, 0);
+    }
+    else {
+        mergeInCache('comment', { commentId, isDeleted: true });
+    }
     return deleted;
 };
 

package/dist/index.umd.js

@@ -2983,9 +2983,9 @@ var Amity = (function (exports, jsBase64, nativeIdGenerator, debug, axios, HttpA
    * @async
    */
   const deletePost = async (postId, permanent = false) => {
-      var _a;
       const client = getActiveClient();
       client.log('post/deletePost', postId);
+      let post = await getPost(postId);
       // API-FIX: This endpoint has not been implemented yet.
       await client.http.delete(`/api/v4/posts/${postId}`, {
           params: {
@@ -2993,26 +2993,25 @@ var Amity = (function (exports, jsBase64, nativeIdGenerator, debug, axios, HttpA
               permanent,
           },
       });
-      let deleted;
-      try {
-          // API-FIX: as for now we have no choice but to refetch
-          deleted = await getPost(postId);
-      }
-      catch (error) {
-          if (((_a = error) === null || _a === void 0 ? void 0 : _a.code) === 400400 /* ITEM_NOT_FOUND */) {
-              // there is currently a limitation which doesnt allow us to fire event to tell that community
-              // has been updated. reason is that, when the object is deleted, we don't have its `communityId`
-              // and so we cannot refetch the community or advertise on events. hopefully this should be solved
-              // later when realtime events covers that for us.
-              return { success: true };
-          }
-          throw (error);
-      }
-      if (deleted.targetType === 'community') {
-          const community = await getCommunity(deleted.targetId);
+      // there is currently a limitation which doesn't allow us to fire event to tell that community
+      // has been updated. reason is that, when the object is deleted, we don't have its `communityId`
+      // and so we cannot refetch the community or advertise on events. hopefully this should be solved
+      // later when realtime events covers that for us.
+      if (post.targetType === 'community') {
+          const community = await getCommunity(post.targetId);
           fireEvent('v3.community.didUpdate', { communities: [community] });
       }
+      // to support hard deletion
+      const deleted = Object.assign(Object.assign({}, post), { isDeleted: true });
       fireEvent('v3.post.didDelete', { posts: [deleted] });
+      if (permanent) {
+          setTimeout(() => {
+              dropFromCache('post', { postId });
+          }, 0);
+      }
+      else {
+          mergeInCache('post', { postId, isDeleted: true });
+      }
       return deleted;
   };
 
@@ -3299,9 +3298,9 @@ var Amity = (function (exports, jsBase64, nativeIdGenerator, debug, axios, HttpA
    * @async
    */
   const deleteComment = async (commentId, permanent = false) => {
-      var _a;
       const client = getActiveClient();
       client.log('comment/deleteComment', commentId);
+      const comment = await getComment(commentId);
       // API-FIX: This endpoint has not been implemented yet.
       await client.http.delete(`/api/v4/comments/${commentId}`, {
           params: {
@@ -3309,24 +3308,19 @@ var Amity = (function (exports, jsBase64, nativeIdGenerator, debug, axios, HttpA
               permanent,
           },
       });
-      let deleted;
-      try {
-          // API-FIX: as for now we have no choice but to refetch
-          deleted = await getComment(commentId);
-      }
-      catch (error) {
-          if (((_a = error) === null || _a === void 0 ? void 0 : _a.code) === 400400 /* ITEM_NOT_FOUND */) {
-              // there is currently a limitation which doesnt allow us to fire event to tell that post
-              // has been updated. reason is that, when the object is deleted, we don't have its `postId`
-              // and so we cannot refetch the post or advertise on events. hopefully this should be solved
-              // later when realtime events covers that for us.
-              return { success: true };
-          }
-          throw (error);
-      }
-      const post = await getPost(deleted.referenceId);
+      // to support hard deletion
+      const deleted = Object.assign(Object.assign({}, comment), { isDeleted: true });
+      const post = await getPost(comment.referenceId);
       fireEvent('v3.post.didUpdate', { posts: [post] });
       fireEvent('v3.comment.didDelete', { comments: [deleted] });
+      if (permanent) {
+          setTimeout(() => {
+              dropFromCache('comment', { commentId });
+          }, 0);
+      }
+      else {
+          mergeInCache('comment', { commentId, isDeleted: true });
+      }
       return deleted;
   };
 

package/dist/post/api/deletePost.d.ts

@@ -12,7 +12,43 @@
  * @category Post API
  * @async
  */
-export declare const deletePost: (postId: Amity.Post['postId'], permanent?: boolean) => Promise<Amity.Post<any> | {
-    success: boolean;
+export declare const deletePost: (postId: Amity.Post['postId'], permanent?: boolean) => Promise<{
+    isDeleted: boolean;
+    postId: string;
+    postedUserId: string;
+    parentId: string;
+    targetType: Amity.PostTargetType;
+    targetId: string;
+    feedId: string;
+    children: string[];
+    comments: string[];
+    commentsCount: number;
+    hasFlaggedChildren: false;
+    hasFlaggedComment: false;
+    editedAt: string;
+    dataType?: any;
+    data: any;
+    metadata?: Record<string, any> | undefined;
+    flagCount: number;
+    hashFlag: {
+        bits: number;
+        hashes: number;
+        hash: string;
+    } | null;
+    reactionsCount: number;
+    reactions: Record<string, number>;
+    myReactions?: string[] | undefined;
+    latestReaction?: ({
+        reactionId: string;
+        userId: string;
+        reactionName: string;
+    } & Amity.CreatedAt & Amity.Relationship<Amity.ReactableType> & {
+        eventName: "added" | "removed";
+    }) | undefined;
+    createdAt: string;
+    updatedAt?: string | undefined;
+    deletedAt?: string | undefined;
+    localId: string;
+    syncedAt: number;
 }>;
 //# sourceMappingURL=deletePost.d.ts.map

package/dist/post/api/deletePost.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"deletePost.d.ts","sourceRoot":"","sources":["../../../src/post/api/deletePost.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,UAAU,WACb,MAAM,IAAI,CAAC,QAAQ,CAAC,cACjB,OAAO;;EAyCnB,CAAA"}
+{"version":3,"file":"deletePost.d.ts","sourceRoot":"","sources":["../../../src/post/api/deletePost.ts"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,UAAU,WACb,MAAM,IAAI,CAAC,QAAQ,CAAC,cACjB,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwCnB,CAAA"}

package/package.json

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

package/src/comment/api/deleteComment.ts

@@ -1,5 +1,6 @@
 import { getActiveClient } from '~/client/api'
 import { fireEvent } from '~/core/events'
+import { dropFromCache, mergeInCache } from '~/core/cache'
 
 import { getComment } from './getComment'
 
@@ -26,6 +27,8 @@ export const deleteComment = async (
   const client = getActiveClient()
   client.log('comment/deleteComment', commentId)
 
+  const comment = await getComment(commentId)
+
   // API-FIX: This endpoint has not been implemented yet.
   await client.http.delete<{ success: boolean }>(
     `/api/v4/comments/${commentId}`, {
@@ -36,28 +39,22 @@ export const deleteComment = async (
     },
   )
 
-  let deleted: Amity.Comment;
-
-  try {
-    // API-FIX: as for now we have no choice but to refetch
-    deleted = await getComment(commentId)
-  } catch (error) {
-    if ((error as Amity.ErrorResponse)?.code === Amity.ServerError.ITEM_NOT_FOUND) {
-      // there is currently a limitation which doesnt allow us to fire event to tell that post
-      // has been updated. reason is that, when the object is deleted, we don't have its `postId`
-      // and so we cannot refetch the post or advertise on events. hopefully this should be solved
-      // later when realtime events covers that for us.
-
-      return { success: true }
-    }
-
-    throw(error);
-  }
+  // to support hard deletion
+  const deleted = { ...comment, isDeleted: true }
 
-  const post = await getPost(deleted.referenceId)
+  const post = await getPost(comment.referenceId)
 
   fireEvent('v3.post.didUpdate', { posts: [post] })
   fireEvent('v3.comment.didDelete', { comments: [deleted] })
 
+
+  if (permanent) {
+    setTimeout(() => {
+      dropFromCache('comment', {commentId})
+    }, 0)
+  } else {
+    mergeInCache('comment', {commentId, isDeleted: true})
+  }
+
   return deleted
 }

package/src/post/api/deletePost.ts

@@ -1,6 +1,7 @@
 import { getActiveClient } from '~/client/api'
 import { getCommunity } from '~/community/api'
 import { fireEvent } from '~/core/events'
+import { dropFromCache, mergeInCache } from '~/core/cache'
 
 import { getPost } from './getPost'
 
@@ -25,6 +26,8 @@ export const deletePost = async (
   const client = getActiveClient()
   client.log('post/deletePost', postId)
 
+  let post = await getPost(postId)
+
   // API-FIX: This endpoint has not been implemented yet.
   await client.http.delete<{ success: boolean }>(
     `/api/v4/posts/${postId}`, {
@@ -35,30 +38,27 @@ export const deletePost = async (
     },
   )
 
-  let deleted: Amity.Post;
-
-  try {
-    // API-FIX: as for now we have no choice but to refetch
-    deleted = await getPost(postId)
-  } catch (error) {
-    if ((error as Amity.ErrorResponse)?.code === Amity.ServerError.ITEM_NOT_FOUND) {
-      // there is currently a limitation which doesnt allow us to fire event to tell that community
-      // has been updated. reason is that, when the object is deleted, we don't have its `communityId`
-      // and so we cannot refetch the community or advertise on events. hopefully this should be solved
-      // later when realtime events covers that for us.
-
-      return { success: true }
-    }
-
-    throw(error);
-  }
-
-  if (deleted.targetType === 'community') {
-    const community = await getCommunity(deleted.targetId);
+  // there is currently a limitation which doesn't allow us to fire event to tell that community
+  // has been updated. reason is that, when the object is deleted, we don't have its `communityId`
+  // and so we cannot refetch the community or advertise on events. hopefully this should be solved
+  // later when realtime events covers that for us.
+  if (post.targetType === 'community') {
+    const community = await getCommunity(post.targetId);
     fireEvent('v3.community.didUpdate', { communities: [community] })
   }
 
+  // to support hard deletion
+  const deleted = { ...post, isDeleted: true }
+
   fireEvent('v3.post.didDelete', { posts: [deleted] })
 
+  if (permanent) {
+    setTimeout(() => {
+      dropFromCache('post', {postId})
+    }, 0)
+  } else {
+    mergeInCache('post', {postId, isDeleted: true})
+  }
+
   return deleted
 }