@amityco/ts-sdk-react-native 6.29.2 → 6.29.3-fe4e045.0

package/src/commentRepository/api/deleteComment.ts

@@ -3,12 +3,12 @@ import { getActiveClient } from '~/client/api';
 import { upsertInCache } from '~/cache/api';
 import { fireEvent } from '~/core/events';
 
-import { getPost } from '~/postRepository/api/getPost';
 import { pushToTombstone } from '~/cache/api/pushToTombstone';
 import { scheduleTask } from '~/core/microtasks';
 
 import { getStoryByStoryId } from '~/storyRepository/internalApi/getStoryByStoryId';
 import { getComment } from './getComment';
+import { pullFromCache } from '~/cache/api/pullFromCache';
 
 /* begin_public_function
   id: comment.soft_delete, comment.hard_delete
@@ -62,19 +62,29 @@ export const deleteComment = async (
       users: [],
     });
   } else {
-    const post = await getPost(comment.data.referenceId);
+    const post = pullFromCache<Amity.Post>(['post', 'get', comment.data.referenceId])?.data;
 
-    fireEvent('local.post.updated', {
-      posts: [post.data],
-      categories: [],
-      comments: [],
-      communities: [],
-      communityUsers: [],
-      feeds: [],
-      files: [],
-      postChildren: [],
-      users: [],
-    });
+    if (post) {
+      let removeCount: number;
+      if (!deleted.parentId) {
+        // NOTE: delete the parent comment will remove all children comments
+        removeCount = deleted.childrenNumber + 1;
+      } else removeCount = 1;
+
+      post.commentsCount -= removeCount;
+
+      fireEvent('local.post.updated', {
+        posts: [post],
+        categories: [],
+        comments: [],
+        communities: [],
+        communityUsers: [],
+        feeds: [],
+        files: [],
+        postChildren: [],
+        users: [],
+      });
+    }
   }
 
   fireEvent('local.comment.deleted', {

package/src/commentRepository/events/onCommentCreatedLocal.ts

@@ -0,0 +1,22 @@
+import { createCommentEventSubscriber, createLocalCommentEventSubscriber } from './utils';
+
+/**
+ * ```js
+ * import { onCommentCreated } from '@amityco/ts-sdk-react-native'
+ * const dispose = onCommentCreated(comment => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.InternalComment} has been created
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Comment Events
+ */
+export const onCommentCreatedLocal = (
+  callback: Amity.Listener<Amity.InternalComment>,
+): Amity.Unsubscriber => {
+  return createLocalCommentEventSubscriber('local.comment.created', callback);
+};

package/src/commentRepository/events/onCommentDeletedLocal.ts

@@ -0,0 +1,20 @@
+import { createLocalCommentEventSubscriber } from './utils';
+
+/**
+ * ```js
+ * import { onCommentDeleteLocal } from '@amityco/ts-sdk-react-native'
+ * const dispose = onCommentDeleteLocal(comment => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.InternalComment} has been deleted
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Comment Events
+ */
+export const onCommentDeleteLocal = (
+  callback: Amity.Listener<Amity.InternalComment>,
+): Amity.Unsubscriber => createLocalCommentEventSubscriber('local.comment.deleted', callback);

package/src/commentRepository/events/onLocalCommentReactionAdded.ts

@@ -0,0 +1,42 @@
+import { getActiveClient } from '~/client/api';
+import { pullFromCache, upsertInCache } from '~/cache/api';
+import { createEventSubscriber } from '~/core/events';
+import { commentLinkedObject } from '~/utils/linkedObject/commentLinkedObject';
+
+/**
+ * ```js
+ * import { onLocalCommentReactionAdded } from '@amityco/ts-sdk-react-native'
+ * const dispose = onLocalCommentReactionAdded(comment => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.InternalComment} has been reacted
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Comment Events
+ */
+export const onLocalCommentReactionAdded = (
+  callback: Amity.Listener<Amity.InternalComment>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const filter = ({ comment }: Amity.Events['local.comment.addReaction']) => {
+    if (!client.cache) {
+      callback(comment);
+    } else {
+      upsertInCache(['comment', 'get', comment.commentId], comment);
+
+      callback(commentLinkedObject(comment));
+    }
+  };
+
+  return createEventSubscriber(
+    client,
+    'local.comment.addReaction',
+    'local.comment.addReaction',
+    filter,
+  );
+};

package/src/commentRepository/events/onLocalCommentReactionRemoved.ts

@@ -0,0 +1,42 @@
+import { getActiveClient } from '~/client/api';
+import { pullFromCache, upsertInCache } from '~/cache/api';
+import { createEventSubscriber } from '~/core/events';
+import { commentLinkedObject } from '~/utils/linkedObject/commentLinkedObject';
+
+/**
+ * ```js
+ * import { onLocalCommentReactionRemoved } from '@amityco/ts-sdk-react-native'
+ * const dispose = onLocalCommentReactionRemoved(comment => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.InternalComment} has been reacted
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Comment Events
+ */
+export const onLocalCommentReactionRemoved = (
+  callback: Amity.Listener<Amity.InternalComment>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const filter = ({ comment }: Amity.Events['local.comment.removeReaction']) => {
+    if (!client.cache) {
+      callback(comment);
+    } else {
+      upsertInCache(['comment', 'get', comment.commentId], comment);
+
+      callback(commentLinkedObject(comment));
+    }
+  };
+
+  return createEventSubscriber(
+    client,
+    'local.comment.removeReaction',
+    'local.comment.removeReaction',
+    filter,
+  );
+};

package/src/commentRepository/events/utils.ts

@@ -31,6 +31,9 @@ export const createCommentEventSubscriber = (
         ])!;
 
         if (['comment.created'].includes(event)) {
+          // NOTE: skip adding comment to parent comment children if it's the same user since we use the local event to update instead.
+          if (event === 'comment.created' && comment.data.userId === client.userId) return;
+
           if (comments[0].parentId) {
             const parentComment = pullFromCache<Amity.InternalComment>([
               'comment',
@@ -64,3 +67,77 @@ export const createCommentEventSubscriber = (
 
   return createEventSubscriber(client, event, event, filter);
 };
+
+export const createLocalCommentEventSubscriber = (
+  event: keyof Omit<
+    Amity.LocalCommentEvents,
+    'local.comment.addReaction' | 'local.comment.removeReaction'
+  >,
+  callback: Amity.Listener<Amity.InternalComment>,
+) => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.CommentPayload) => {
+    if (!client.cache) {
+      // TODO: here we are missing specific properties here!
+      callback(LinkedObject.comment(payload.comments[0]));
+    } else {
+      const processed = payload;
+
+      ingestInCache(processed);
+
+      const { comments } = processed;
+
+      if (comments.length > 0) {
+        const comment = pullFromCache<Amity.InternalComment>([
+          'comment',
+          'get',
+          comments[0].commentId,
+        ])!;
+
+        if (['local.comment.created'].includes(event)) {
+          if (comments[0].parentId) {
+            const parentComment = pullFromCache<Amity.InternalComment>([
+              'comment',
+              'get',
+              comments[0].parentId,
+            ]);
+
+            if (parentComment?.data) {
+              // Skip to update parent childComment if current comment already exists
+              if (!parentComment.data.children.includes(comments[0].commentId)) {
+                const newParentComment = {
+                  ...parentComment.data,
+                  childrenNumber: parentComment.data.childrenNumber + 1,
+                  children: [...new Set([...parentComment.data.children, comments[0].commentId])],
+                };
+                pushToCache(['comment', 'get', comments[0].parentId], newParentComment);
+
+                setTimeout(() => {
+                  // NOTE: This is workaround solution for emitting event not work properly.
+                  fireEvent('comment.updated', {
+                    comments: [newParentComment],
+                    commentChildren: [],
+                    files: [],
+                    users: [],
+                    communityUsers: [],
+                  });
+                }, 200);
+              }
+            }
+          }
+
+          const queries = queryCache<Amity.InternalComment[]>(['comment', 'query'])?.filter(
+            ({ key }) => (key[2] as Amity.QueryComments)?.referenceId === comment.data.referenceId,
+          );
+
+          queries?.map(({ key, data }) => upsertInCache(key, data as any, { cachedAt: -1 }));
+        }
+
+        callback(LinkedObject.comment(comment.data));
+      }
+    }
+  };
+
+  return createEventSubscriber(client, event, event, filter);
+};

package/src/commentRepository/observers/getComment.ts

@@ -10,6 +10,9 @@ import {
   onCommentUnflagged,
   onCommentUpdated,
 } from '../events';
+import { onCommentDeleteLocal } from '../events/onCommentDeletedLocal';
+import { onLocalCommentReactionAdded } from '../events/onLocalCommentReactionAdded';
+import { onLocalCommentReactionRemoved } from '../events/onLocalCommentReactionRemoved';
 
 /* begin_public_function
   id: comment.get
@@ -38,31 +41,15 @@ export const getComment = (
   callback: Amity.LiveObjectCallback<Amity.Comment>,
 ): Amity.Unsubscriber => {
   return liveObject(commentId, callback, 'commentId', _getComment, [
+    onCommentDeleteLocal,
     onCommentDeleted,
     onCommentFlagged,
     onCommentReactionAdded,
     onCommentReactionRemoved,
     onCommentUnflagged,
     onCommentUpdated,
-    (callback: Amity.Listener<Amity.InternalComment>) => {
-      return onCommentCreated((comment: Amity.InternalComment) => {
-        if (comment.parentId !== commentId) return;
-
-        const cacheParent = pullFromCache<Amity.InternalComment>([
-          'comment',
-          'get',
-          comment.parentId,
-        ]);
-
-        if (!cacheParent?.data) return;
-
-        callback({
-          ...cacheParent.data,
-          childrenNumber: cacheParent.data.childrenNumber + 1,
-          children: [...new Set([...cacheParent.data.children, comment.commentId])],
-        });
-      });
-    },
+    onLocalCommentReactionAdded,
+    onLocalCommentReactionRemoved,
   ]);
 };
 /* end_public_function */

package/src/commentRepository/observers/getComments/CommentLiveCollectionController.ts

@@ -17,6 +17,10 @@ import { isNonNullable } from '~/utils';
 import { EnumCommentActions } from './enums';
 import { LinkedObject } from '~/utils/linkedObject';
 import { prepareCommentPayload } from '~/commentRepository/utils/payload';
+import { onCommentCreatedLocal } from '~/commentRepository/events/onCommentCreatedLocal';
+import { onCommentDeleteLocal } from '~/commentRepository/events/onCommentDeletedLocal';
+import { onLocalCommentReactionAdded } from '~/commentRepository/events/onLocalCommentReactionAdded';
+import { onLocalCommentReactionRemoved } from '~/commentRepository/events/onLocalCommentReactionRemoved';
 
 export class CommentLiveCollectionController extends LiveCollectionController<
   'comment',
@@ -74,6 +78,8 @@ export class CommentLiveCollectionController extends LiveCollectionController<
 
   startSubscription() {
     return this.queryStreamController.subscribeRTE([
+      { fn: onCommentCreatedLocal, action: EnumCommentActions.OnCommentCreated },
+      { fn: onCommentDeleteLocal, action: EnumCommentActions.OnCommentDeleted },
       { fn: onCommentCreated, action: EnumCommentActions.OnCommentCreated },
       { fn: onCommentUpdated, action: EnumCommentActions.OnCommentUpdated },
       { fn: onCommentDeleted, action: EnumCommentActions.OnCommentDeleted },
@@ -81,6 +87,8 @@ export class CommentLiveCollectionController extends LiveCollectionController<
       { fn: onCommentUnflagged, action: EnumCommentActions.OnCommentUnflagged },
       { fn: onCommentReactionAdded, action: EnumCommentActions.OnCommentReactionAdded },
       { fn: onCommentReactionRemoved, action: EnumCommentActions.OnCommentReactionRemoved },
+      { fn: onLocalCommentReactionAdded, action: EnumCommentActions.OnCommentReactionAdded },
+      { fn: onLocalCommentReactionRemoved, action: EnumCommentActions.OnCommentReactionRemoved },
     ]);
   }
 

package/src/communityRepository/communityMembership/api/addMembers.ts

@@ -34,7 +34,7 @@ export const addMembers = async (
     { communityId, userIds },
   );
 
-  fireEvent('community.userAdded', payload);
+  fireEvent('local.community.userAdded', payload);
 
   const data = prepareMembershipPayload(payload, 'communityUsers');
 

package/src/communityRepository/communityMembership/api/removeMembers.ts

@@ -34,7 +34,7 @@ export const removeMembers = async (
     { data: { communityId, userIds } },
   );
 
-  fireEvent('community.userRemoved', payload);
+  fireEvent('local.community.userRemoved', payload);
 
   const data = prepareMembershipPayload(payload, 'communityUsers');
 

package/src/communityRepository/communityMembership/events/index.ts

@@ -5,6 +5,8 @@ export * from './onCommunityUserChanged';
 export * from './onCommunityUserUnbanned';
 export * from './onCommunityUserRoleAdded';
 export * from './onCommunityUserRoleRemoved';
+export * from './onLocalCommunityUserAdded';
+export * from './onLocalCommunityUserRemoved';
 
 export * from './onCommunityJoined';
 export * from './onCommunityLeft';

package/src/communityRepository/communityMembership/events/onLocalCommunityUserAdded.ts

@@ -0,0 +1,20 @@
+import { createLocalCommunityMemberEventSubscriber } from './utils';
+
+/**
+ * ```js
+ * import { onLocalCommunityUserAdded } from '@amityco/ts-sdk-react-native'
+ * const dispose = onLocalCommunityUserAdded((community, member) => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a user has been added to a {@link Amity.Community}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Community Events
+ */
+export const onLocalCommunityUserAdded = (
+  callback: (community: Amity.Community, member: Amity.Membership<'community'>[]) => void,
+) => createLocalCommunityMemberEventSubscriber('local.community.userAdded', callback);

package/src/communityRepository/communityMembership/events/onLocalCommunityUserRemoved.ts

@@ -0,0 +1,20 @@
+import { createLocalCommunityMemberEventSubscriber } from './utils';
+
+/**
+ * ```js
+ * import { onLocalCommunityUserRemoved } from '@amityco/ts-sdk-react-native'
+ * const dispose = onLocalCommunityUserRemoved((community, member) => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a user has been removed from a {@link Amity.Community}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Community Events
+ */
+export const onLocalCommunityUserRemoved = (
+  callback: (community: Amity.Community, member: Amity.Membership<'community'>[]) => void,
+) => createLocalCommunityMemberEventSubscriber('local.community.userRemoved', callback);

package/src/communityRepository/communityMembership/events/onUserDeleted.ts

@@ -0,0 +1,64 @@
+import { prepareUserPayload } from '~/userRepository/utils/prepareUserPayload';
+import { pullFromCache, pushToCache, upsertInCache } from '~/cache/api';
+import { createEventSubscriber } from '~/core/events';
+import { getActiveClient } from '~/client';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { getResolver } from '~/core/model';
+
+/**
+ * ```js
+ * import { onUserDeleted } from '@amityco/ts-sdk'
+ * const dispose = onUserDeleted((community, member) => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.Community} has been joined
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Community Events
+ */
+export const onUserDeleted =
+  (communityId: string) =>
+  (callback: (community: Amity.Community, member: Amity.Membership<'community'>[]) => void) => {
+    const client = getActiveClient();
+
+    const filter = (payload: Amity.UserPayload) => {
+      const userPayload = prepareUserPayload(payload);
+
+      if (userPayload.users.length === 0) return;
+
+      const user = userPayload.users[0];
+
+      ingestInCache(userPayload);
+
+      const communityUserCacheKey = getResolver('communityUsers')({
+        communityId,
+        userId: user.userId,
+      });
+
+      const cacheData = pullFromCache<Amity.Membership<'community'>>([
+        'communityUsers',
+        'get',
+        communityUserCacheKey,
+      ])?.data!;
+
+      pushToCache(['communityUsers', 'get', communityUserCacheKey], {
+        ...cacheData,
+        user,
+      });
+
+      const community = pullFromCache<Amity.Community>(['community', 'get', communityId])?.data!;
+
+      callback(community, [
+        {
+          ...cacheData,
+          user,
+        },
+      ]);
+    };
+
+    return createEventSubscriber(client, 'user.deleted', 'user.deleted', filter);
+  };

package/src/communityRepository/communityMembership/events/utils.ts

@@ -25,7 +25,7 @@ function hasPermission(
 }
 
 function getEventRelatedMember(
-  event: keyof Amity.MqttCommunityUserEvents,
+  event: keyof Amity.MqttCommunityUserEvents | keyof Amity.LocalCommunityEvents,
   payload: {
     communityUsers: Amity.Membership<'community'>[];
     users: Amity.InternalUser[];
@@ -37,7 +37,7 @@ function getEventRelatedMember(
 
   // NOTE: backend returns the one who took the action and the one on whom
   // the action was taken. We need the 2nd one
-  if (event === 'community.userRemoved') {
+  if (event === 'community.userRemoved' || event === 'local.community.userRemoved') {
     return payload.communityUsers!.filter(x => x.communityMembership === 'none');
   }
 
@@ -100,3 +100,51 @@ export const createCommunityMemberEventSubscriber = (
 
   return createEventSubscriber(client, event, event, filter);
 };
+
+export const createLocalCommunityMemberEventSubscriber = (
+  event: keyof Amity.LocalCommunityEvents,
+  callback: (community: Amity.Community, members: Amity.Membership<'community'>[]) => void,
+) => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.CommunityMembershipPayload) => {
+    const preparedPayload = prepareCommunityPayload(payload);
+    const { communities, communityUsers } = preparedPayload;
+
+    /*
+     * community.isJoined is not part of the communityMembership payload, and needs
+     * to be calculated based on the communityMembership value
+     */
+    const communitiesWithMembership = updateMembershipStatus(communities, communityUsers);
+
+    preparedPayload.communities = communitiesWithMembership;
+
+    if (!client.cache) {
+      // TODO: here we are missing specific properties here!
+      callback(preparedPayload.communities[0], getEventRelatedMember(event, preparedPayload));
+    } else {
+      ingestInCache(preparedPayload);
+
+      const community = pullFromCache<Amity.Community>([
+        'community',
+        'get',
+        preparedPayload.communities[0].communityId,
+      ])!;
+
+      const members = getEventRelatedMember(event, preparedPayload)
+        .map(member => {
+          const memberCache = pullFromCache<Amity.Membership<'community'>>([
+            'communityUsers',
+            'get',
+            getResolver('communityUsers')(member),
+          ]);
+          return memberCache?.data;
+        })
+        .filter(isNonNullable);
+
+      callback(community.data, members);
+    }
+  };
+
+  return createEventSubscriber(client, event, event, filter);
+};

package/src/communityRepository/communityMembership/observers/getMembers/CommunityMembersLiveCollectionController.ts

@@ -11,17 +11,21 @@ import {
   onCommunityUserRoleAdded,
   onCommunityUserRoleRemoved,
   onCommunityUserUnbanned,
+  onLocalCommunityUserAdded,
+  onLocalCommunityUserRemoved,
 } from '~/communityRepository/communityMembership/events';
 import {
   filterByPropIntersection,
   filterBySearchTerm,
-  sortByDisplayName,
   sortByFirstCreated,
   sortByLastCreated,
 } from '~/core/query';
 import { prepareCommunityPayload } from '~/communityRepository/utils';
 import { isNonNullable } from '~/utils';
 import { EnumCommunityMemberActions } from './enums';
+import { onLocalCommunityRoleRemoved } from '~/communityRepository/communityModeration/events/onLocalCommunityRoleRemoved';
+import { onLocalCommunityRoleAdded } from '~/communityRepository/communityModeration/events/onLocalCommunityRoleAdded';
+import { onUserDeleted } from '~/communityRepository/communityMembership/events/onUserDeleted';
 
 export class CommunityMembersLiveCollectionController extends LiveCollectionController<
   'communityUser',
@@ -88,7 +92,24 @@ export class CommunityMembersLiveCollectionController extends LiveCollectionCont
         fn: onCommunityUserRoleRemoved,
         action: EnumCommunityMemberActions.OnCommunityUserRoleRemoved,
       },
+      {
+        fn: onLocalCommunityRoleAdded,
+        action: EnumCommunityMemberActions.OnCommunityUserRoleAdded,
+      },
+      {
+        fn: onLocalCommunityRoleRemoved,
+        action: EnumCommunityMemberActions.OnCommunityUserRoleRemoved,
+      },
       { fn: onCommunityUserUnbanned, action: EnumCommunityMemberActions.OnCommunityUserUnbanned },
+      { fn: onLocalCommunityUserAdded, action: EnumCommunityMemberActions.OnCommunityUserAdded },
+      {
+        fn: onLocalCommunityUserRemoved,
+        action: EnumCommunityMemberActions.onCommunityUserRemoved,
+      },
+      {
+        fn: onUserDeleted(this.query.communityId),
+        action: EnumCommunityMemberActions.OnCommunityUserChanged,
+      },
     ]);
   }
 
@@ -128,6 +149,10 @@ export class CommunityMembersLiveCollectionController extends LiveCollectionCont
       communityMembers = filterBySearchTerm(communityMembers, this.query.search);
     }
 
+    if (this.query.includeDeleted === false) {
+      communityMembers = communityMembers.filter(({ user }) => user?.isDeleted !== true);
+    }
+
     switch (this.query.sortBy) {
       case 'firstCreated':
         communityMembers = communityMembers.sort(sortByFirstCreated);

package/src/communityRepository/communityMembership/observers/getMembers/CommunityMembersPaginationController.ts

@@ -10,15 +10,18 @@ export class CommunityMembersPaginationController extends PaginationController<
   Amity.CommunityMemberLiveCollection
 > {
   async getRequest(queryParams: Amity.CommunityMemberLiveCollection, token: string | undefined) {
-    const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT, ...params } = queryParams;
+    const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT, includeDeleted, ...params } = queryParams;
     const options = token ? { token } : { limit };
 
+    const isDeleted = includeDeleted === false ? false : undefined;
+
     const { data: queryResponse } = await this.http.get<
       Amity.CommunityMembershipPayload & Amity.Pagination
     >(`/api/v3/communities/${params.communityId}/users`, {
       params: {
         ...params,
         options,
+        isDeleted,
       },
     });
     return queryResponse;

package/src/communityRepository/communityMembership/observers/getMembers/enums.ts

@@ -7,4 +7,7 @@ export enum EnumCommunityMemberActions {
   OnCommunityUserRoleRemoved = 'onCommunityUserRoleRemoved',
   OnCommunityUserUnbanned = 'onCommunityUserUnbanned',
   OnMemberCountChanged = 'OnMemberCountChanged',
+  OnCommunityUserAdded = 'OnCommunityUserAdded',
+  onCommunityUserRemoved = 'onCommunityUserRemoved',
+  OnUserDeleted = 'OnUserDeleted',
 }