@automattic/data-stores 3.0.0 → 3.1.0-rc.1

package/src/reader/mutations/use-pending-post-confirm-mutation.ts

@@ -0,0 +1,116 @@
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { callApi } from '../helpers';
+import { useCacheKey, useIsLoggedIn } from '../hooks';
+import { postSubscriptionsQueryKeyPrefix } from '../queries/use-post-subscriptions-query';
+import { subscriptionsCountQueryKeyPrefix } from '../queries/use-subscriptions-count-query';
+import { PendingPostSubscriptionsResult, SubscriptionManagerSubscriptionsCount } from '../types';
+
+type PendingPostConfirmParams = {
+	id: string;
+};
+
+type PendingPostConfirmResponse = {
+	confirmed: boolean;
+};
+
+const usePendingPostConfirmMutation = () => {
+	const { isLoggedIn } = useIsLoggedIn();
+	const queryClient = useQueryClient();
+	const subscriptionsCacheKey = useCacheKey( postSubscriptionsQueryKeyPrefix );
+	const countCacheKey = useCacheKey( subscriptionsCountQueryKeyPrefix );
+
+	return useMutation( {
+		mutationFn: async ( { id }: PendingPostConfirmParams ) => {
+			if ( ! id ) {
+				throw new Error(
+					// reminder: translate this string when we add it to the UI
+					'Invalid subscription key'
+				);
+			}
+
+			const response = await callApi< PendingPostConfirmResponse >( {
+				apiNamespace: 'wpcom/v2',
+				path: `/post-comment-subscriptions/${ id }/confirm`,
+				method: 'POST',
+				isLoggedIn,
+				apiVersion: '2',
+			} );
+			if ( ! response.confirmed ) {
+				throw new Error(
+					// reminder: translate this string when we add it to the UI
+					'Something went wrong while confirming subscription.'
+				);
+			}
+
+			return response;
+		},
+		onMutate: async ( { id } ) => {
+			await queryClient.cancelQueries( {
+				queryKey: [ 'read', 'pending-post-subscriptions', isLoggedIn ],
+			} );
+			await queryClient.cancelQueries( { queryKey: subscriptionsCacheKey } );
+			await queryClient.cancelQueries( { queryKey: countCacheKey } );
+
+			const previousPendingPostSubscriptions =
+				queryClient.getQueryData< PendingPostSubscriptionsResult >( [
+					'read',
+					'pending-post-subscriptions',
+					isLoggedIn,
+				] );
+
+			// remove post comment from pending post subscriptions
+			if ( previousPendingPostSubscriptions?.pendingPosts ) {
+				queryClient.setQueryData< PendingPostSubscriptionsResult >(
+					[ [ 'read', 'pending-post-subscriptions', isLoggedIn ] ],
+					{
+						pendingPosts: previousPendingPostSubscriptions.pendingPosts.filter(
+							( pendingPost ) => pendingPost.id !== id
+						),
+						totalCount: previousPendingPostSubscriptions.totalCount - 1,
+					}
+				);
+			}
+
+			const previousSubscriptionsCount =
+				queryClient.getQueryData< SubscriptionManagerSubscriptionsCount >( countCacheKey );
+
+			// decrement the post comment count
+			if ( previousSubscriptionsCount ) {
+				queryClient.setQueryData< SubscriptionManagerSubscriptionsCount >( countCacheKey, {
+					...previousSubscriptionsCount,
+					comments: previousSubscriptionsCount?.comments
+						? previousSubscriptionsCount?.comments + 1
+						: 1,
+					pending: previousSubscriptionsCount?.pending
+						? previousSubscriptionsCount?.pending - 1
+						: null,
+				} );
+			}
+
+			return { previousPendingPostSubscriptions, previousSubscriptionsCount };
+		},
+		onError: ( error, variables, context ) => {
+			if ( context?.previousPendingPostSubscriptions ) {
+				queryClient.setQueryData< PendingPostSubscriptionsResult >(
+					[ 'read', 'pending-post-subscriptions', isLoggedIn ],
+					context.previousPendingPostSubscriptions
+				);
+			}
+			if ( context?.previousSubscriptionsCount ) {
+				queryClient.setQueryData< SubscriptionManagerSubscriptionsCount >(
+					countCacheKey,
+					context.previousSubscriptionsCount
+				);
+			}
+		},
+		onSettled: () => {
+			queryClient.invalidateQueries( {
+				queryKey: [ 'read', 'pending-post-subscriptions', isLoggedIn ],
+			} );
+			queryClient.invalidateQueries( { queryKey: subscriptionsCacheKey } );
+			queryClient.invalidateQueries( { queryKey: countCacheKey } );
+		},
+	} );
+};
+
+export default usePendingPostConfirmMutation;

package/src/reader/mutations/use-pending-post-delete-mutation.ts

@@ -0,0 +1,109 @@
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { callApi } from '../helpers';
+import { useCacheKey, useIsLoggedIn } from '../hooks';
+import { subscriptionsCountQueryKeyPrefix } from '../queries/use-subscriptions-count-query';
+import { PendingPostSubscriptionsResult, SubscriptionManagerSubscriptionsCount } from '../types';
+
+type PendingPostDeleteParams = {
+	id: number | string;
+};
+
+type PendingPostDeleteResponse = {
+	deleted: boolean;
+};
+
+const usePendingPostDeleteMutation = () => {
+	const { isLoggedIn } = useIsLoggedIn();
+	const queryClient = useQueryClient();
+	const countCacheKey = useCacheKey( subscriptionsCountQueryKeyPrefix );
+
+	return useMutation( {
+		mutationFn: async ( params: PendingPostDeleteParams ) => {
+			if ( ! params.id ) {
+				throw new Error(
+					// reminder: translate this string when we add it to the UI
+					'ID is missing.'
+				);
+			}
+
+			const response = await callApi< PendingPostDeleteResponse >( {
+				apiNamespace: 'wpcom/v2',
+				path: `/post-comment-subscriptions/${ params.id }/delete`,
+				method: 'POST',
+				isLoggedIn,
+				apiVersion: '2',
+			} );
+			if ( ! response.deleted ) {
+				throw new Error(
+					// reminder: translate this string when we add it to the UI
+					'Something went wrong while deleting pending subscription.'
+				);
+			}
+
+			return response;
+		},
+		onMutate: async ( params ) => {
+			await queryClient.cancelQueries( {
+				queryKey: [ 'read', 'pending-post-subscriptions', isLoggedIn ],
+			} );
+			await queryClient.cancelQueries( { queryKey: countCacheKey } );
+
+			const previousPendingPostSubscriptions =
+				queryClient.getQueryData< PendingPostSubscriptionsResult >( [
+					'read',
+					'pending-post-subscriptions',
+					isLoggedIn,
+				] );
+
+			// remove post comment from pending post subscriptions
+			if ( previousPendingPostSubscriptions?.pendingPosts ) {
+				queryClient.setQueryData< PendingPostSubscriptionsResult >(
+					[ [ 'read', 'pending-post-subscriptions', isLoggedIn ] ],
+					{
+						pendingPosts: previousPendingPostSubscriptions.pendingPosts.filter(
+							( pendingPostSubscription ) => pendingPostSubscription.id !== params.id
+						),
+						totalCount: previousPendingPostSubscriptions.totalCount - 1,
+					}
+				);
+			}
+
+			const previousSubscriptionsCount =
+				queryClient.getQueryData< SubscriptionManagerSubscriptionsCount >( countCacheKey );
+
+			// decrement the post comment count
+			if ( previousSubscriptionsCount ) {
+				queryClient.setQueryData< SubscriptionManagerSubscriptionsCount >( countCacheKey, {
+					...previousSubscriptionsCount,
+					pending: previousSubscriptionsCount?.pending
+						? previousSubscriptionsCount?.pending - 1
+						: null,
+				} );
+			}
+
+			return { previousPendingPostSubscriptions, previousSubscriptionsCount };
+		},
+		onError: ( error, variables, context ) => {
+			if ( context?.previousPendingPostSubscriptions ) {
+				queryClient.setQueryData< PendingPostSubscriptionsResult >(
+					[ 'read', 'pending-post-subscriptions', isLoggedIn ],
+					context.previousPendingPostSubscriptions
+				);
+			}
+			if ( context?.previousSubscriptionsCount ) {
+				queryClient.setQueryData< SubscriptionManagerSubscriptionsCount >(
+					countCacheKey,
+					context.previousSubscriptionsCount
+				);
+			}
+		},
+		onSettled: () => {
+			queryClient.invalidateQueries( {
+				queryKey: [ 'read', 'pending-post-subscriptions', isLoggedIn ],
+			} );
+			queryClient.invalidateQueries( { queryKey: countCacheKey } );
+		},
+	} );
+};
+
+export default usePendingPostDeleteMutation;

package/src/reader/mutations/use-pending-site-confirm-mutation.ts

@@ -0,0 +1,115 @@
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { callApi } from '../helpers';
+import { useCacheKey, useIsLoggedIn } from '../hooks';
+import { siteSubscriptionsQueryKeyPrefix } from '../queries';
+import { subscriptionsCountQueryKeyPrefix } from '../queries/use-subscriptions-count-query';
+import { PendingSiteSubscriptionsResult, SubscriptionManagerSubscriptionsCount } from '../types';
+
+type PendingSiteConfirmParams = {
+	id: string;
+	activation_key: string;
+};
+
+type PendingSiteConfirmResponse = {
+	confirmed: boolean;
+};
+
+const usePendingSiteConfirmMutation = () => {
+	const { isLoggedIn } = useIsLoggedIn();
+	const queryClient = useQueryClient();
+	const subscriptionsCacheKey = useCacheKey( siteSubscriptionsQueryKeyPrefix );
+	const countCacheKey = useCacheKey( subscriptionsCountQueryKeyPrefix );
+
+	return useMutation( {
+		mutationFn: async ( params: PendingSiteConfirmParams ) => {
+			if ( ! params.activation_key ) {
+				throw new Error(
+					// reminder: translate this string when we add it to the UI
+					'Invalid activation key.'
+				);
+			}
+
+			const response = await callApi< PendingSiteConfirmResponse >( {
+				apiNamespace: 'wpcom/v2',
+				path: `/pending-blog-subscriptions/${ params.activation_key }/confirm`,
+				method: 'POST',
+				isLoggedIn,
+				apiVersion: '2',
+			} );
+			if ( ! response.confirmed ) {
+				throw new Error(
+					// reminder: translate this string when we add it to the UI
+					'Something went wrong while confirming subscription.'
+				);
+			}
+
+			return response;
+		},
+		onMutate: async ( params ) => {
+			await queryClient.cancelQueries( {
+				queryKey: [ 'read', 'pending-site-subscriptions', isLoggedIn ],
+			} );
+			await queryClient.cancelQueries( { queryKey: subscriptionsCacheKey } );
+			await queryClient.cancelQueries( { queryKey: countCacheKey } );
+
+			const previousPendingSiteSubscriptions =
+				queryClient.getQueryData< PendingSiteSubscriptionsResult >( [
+					'read',
+					'pending-site-subscriptions',
+					isLoggedIn,
+				] );
+
+			// remove blog from pending site subscriptions
+			if ( previousPendingSiteSubscriptions?.pendingSites ) {
+				queryClient.setQueryData< PendingSiteSubscriptionsResult >(
+					[ [ 'read', 'pending-site-subscriptions', isLoggedIn ] ],
+					{
+						pendingSites: previousPendingSiteSubscriptions.pendingSites.filter(
+							( pendingSiteSubscription ) => pendingSiteSubscription.id !== params.id
+						),
+						totalCount: previousPendingSiteSubscriptions.totalCount - 1,
+					}
+				);
+			}
+
+			const previousSubscriptionsCount =
+				queryClient.getQueryData< SubscriptionManagerSubscriptionsCount >( countCacheKey );
+
+			// decrement the blog count
+			if ( previousSubscriptionsCount ) {
+				queryClient.setQueryData< SubscriptionManagerSubscriptionsCount >( countCacheKey, {
+					...previousSubscriptionsCount,
+					blogs: previousSubscriptionsCount?.blogs ? previousSubscriptionsCount?.blogs + 1 : 1,
+					pending: previousSubscriptionsCount?.pending
+						? previousSubscriptionsCount?.pending - 1
+						: null,
+				} );
+			}
+
+			return { previousPendingSiteSubscriptions, previousSubscriptionsCount };
+		},
+		onError: ( error, variables, context ) => {
+			if ( context?.previousPendingSiteSubscriptions ) {
+				queryClient.setQueryData< PendingSiteSubscriptionsResult >(
+					[ 'read', 'pending-site-subscriptions', isLoggedIn ],
+					context.previousPendingSiteSubscriptions
+				);
+			}
+			if ( context?.previousSubscriptionsCount ) {
+				queryClient.setQueryData< SubscriptionManagerSubscriptionsCount >(
+					countCacheKey,
+					context.previousSubscriptionsCount
+				);
+			}
+		},
+		onSettled: () => {
+			queryClient.invalidateQueries( {
+				queryKey: [ 'read', 'pending-site-subscriptions', isLoggedIn ],
+			} );
+			queryClient.invalidateQueries( { queryKey: subscriptionsCacheKey } );
+			queryClient.invalidateQueries( { queryKey: countCacheKey } );
+		},
+	} );
+};
+
+export default usePendingSiteConfirmMutation;

package/src/reader/mutations/use-pending-site-delete-mutation.ts

@@ -0,0 +1,109 @@
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { callApi } from '../helpers';
+import { useCacheKey, useIsLoggedIn } from '../hooks';
+import { subscriptionsCountQueryKeyPrefix } from '../queries/use-subscriptions-count-query';
+import { PendingSiteSubscriptionsResult, SubscriptionManagerSubscriptionsCount } from '../types';
+
+type PendingSiteDeleteParams = {
+	id: number | string;
+};
+
+type PendingSiteDeleteResponse = {
+	deleted: boolean;
+};
+
+const usePendingSiteDeleteMutation = () => {
+	const { isLoggedIn } = useIsLoggedIn();
+	const queryClient = useQueryClient();
+	const countCacheKey = useCacheKey( subscriptionsCountQueryKeyPrefix );
+
+	return useMutation( {
+		mutationFn: async ( params: PendingSiteDeleteParams ) => {
+			if ( ! params.id ) {
+				throw new Error(
+					// reminder: translate this string when we add it to the UI
+					'ID is missing.'
+				);
+			}
+
+			const response = await callApi< PendingSiteDeleteResponse >( {
+				apiNamespace: 'wpcom/v2',
+				path: `/pending-blog-subscriptions/${ params.id }/delete`,
+				method: 'POST',
+				isLoggedIn,
+				apiVersion: '2',
+			} );
+			if ( ! response.deleted ) {
+				throw new Error(
+					// reminder: translate this string when we add it to the UI
+					'Something went wrong while deleting pending subscription.'
+				);
+			}
+
+			return response;
+		},
+		onMutate: async ( params ) => {
+			await queryClient.cancelQueries( {
+				queryKey: [ 'read', 'pending-site-subscriptions', isLoggedIn ],
+			} );
+			await queryClient.cancelQueries( { queryKey: countCacheKey } );
+
+			const previousPendingSiteSubscriptions =
+				queryClient.getQueryData< PendingSiteSubscriptionsResult >( [
+					'read',
+					'pending-site-subscriptions',
+					isLoggedIn,
+				] );
+
+			// remove blog from pending site subscriptions
+			if ( previousPendingSiteSubscriptions?.pendingSites ) {
+				queryClient.setQueryData< PendingSiteSubscriptionsResult >(
+					[ [ 'read', 'pending-site-subscriptions', isLoggedIn ] ],
+					{
+						pendingSites: previousPendingSiteSubscriptions.pendingSites.filter(
+							( pendingSiteSubscription ) => pendingSiteSubscription.id !== params.id
+						),
+						totalCount: previousPendingSiteSubscriptions.totalCount - 1,
+					}
+				);
+			}
+
+			const previousSubscriptionsCount =
+				queryClient.getQueryData< SubscriptionManagerSubscriptionsCount >( countCacheKey );
+
+			// decrement the blog count
+			if ( previousSubscriptionsCount ) {
+				queryClient.setQueryData< SubscriptionManagerSubscriptionsCount >( countCacheKey, {
+					...previousSubscriptionsCount,
+					pending: previousSubscriptionsCount?.pending
+						? previousSubscriptionsCount?.pending - 1
+						: null,
+				} );
+			}
+
+			return { previousPendingSiteSubscriptions, previousSubscriptionsCount };
+		},
+		onError: ( error, variables, context ) => {
+			if ( context?.previousPendingSiteSubscriptions ) {
+				queryClient.setQueryData< PendingSiteSubscriptionsResult >(
+					[ 'read', 'pending-site-subscriptions', isLoggedIn ],
+					context.previousPendingSiteSubscriptions
+				);
+			}
+			if ( context?.previousSubscriptionsCount ) {
+				queryClient.setQueryData< SubscriptionManagerSubscriptionsCount >(
+					countCacheKey,
+					context.previousSubscriptionsCount
+				);
+			}
+		},
+		onSettled: () => {
+			queryClient.invalidateQueries( {
+				queryKey: [ 'read', 'pending-site-subscriptions', isLoggedIn ],
+			} );
+			queryClient.invalidateQueries( { queryKey: countCacheKey } );
+		},
+	} );
+};
+
+export default usePendingSiteDeleteMutation;

package/src/reader/mutations/use-post-notify-me-of-new-comments-mutation.ts

@@ -0,0 +1,89 @@
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { callApi } from '../helpers';
+import { useCacheKey, useIsLoggedIn } from '../hooks';
+import { postSubscriptionsQueryKeyPrefix } from '../queries/use-post-subscriptions-query';
+import type { PostSubscriptionsResult } from '../types';
+
+type PostSubscriptionNotifyMeOfNewCommentsParams = {
+	subscriptionId: string;
+	sendComments: boolean;
+};
+
+type PostSubscriptionNotifyMeOfNewCommentsResponse = {
+	updated: boolean;
+};
+
+const usePostNotifyMeOfNewCommentsMutation = () => {
+	const { isLoggedIn } = useIsLoggedIn();
+	const queryClient = useQueryClient();
+	const postSubscriptionsCacheKey = useCacheKey( postSubscriptionsQueryKeyPrefix );
+
+	return useMutation( {
+		mutationFn: async ( params: PostSubscriptionNotifyMeOfNewCommentsParams ) => {
+			if ( ! params.subscriptionId || typeof params.sendComments !== 'boolean' ) {
+				throw new Error(
+					'Something went wrong while changing the "Notify me of new comments" setting.'
+				);
+			}
+
+			const response = await callApi< PostSubscriptionNotifyMeOfNewCommentsResponse >( {
+				apiNamespace: 'wpcom/v2',
+				path: `/post-comment-subscriptions/${ params.subscriptionId }/update`,
+				method: 'POST',
+				body: {
+					send_comments: params.sendComments,
+				},
+				isLoggedIn,
+				apiVersion: '2',
+			} );
+			if ( ! response.updated ) {
+				throw new Error(
+					// reminder: translate this string when we add it to the UI
+					'Something went wrong while changing the "Notify me of new posts" setting.'
+				);
+			}
+
+			return response;
+		},
+		onMutate: async ( { subscriptionId, sendComments } ) => {
+			const previousPostSubscriptions =
+				queryClient.getQueryData< PostSubscriptionsResult >( postSubscriptionsCacheKey );
+
+			if ( previousPostSubscriptions ) {
+				queryClient.setQueryData( postSubscriptionsCacheKey, {
+					...previousPostSubscriptions,
+					pages: previousPostSubscriptions.pages.map( ( page ) => ( {
+						...page,
+						comment_subscriptions: page.comment_subscriptions.map( ( commentSubscription ) => {
+							if ( commentSubscription.id === subscriptionId ) {
+								return {
+									...commentSubscription,
+									notification: {
+										send_comments: sendComments,
+									},
+								};
+							}
+							return commentSubscription;
+						} ),
+					} ) ),
+				} );
+			}
+			return {
+				previousPostSubscriptions,
+			};
+		},
+		onError: ( err, _, context ) => {
+			if ( context?.previousPostSubscriptions ) {
+				queryClient.setQueryData(
+					postSubscriptionsQueryKeyPrefix,
+					context.previousPostSubscriptions
+				);
+			}
+		},
+		onSettled: () => {
+			queryClient.invalidateQueries( { queryKey: postSubscriptionsQueryKeyPrefix } );
+		},
+	} );
+};
+
+export default usePostNotifyMeOfNewCommentsMutation;

package/src/reader/mutations/use-post-unsubscribe-mutation.ts

@@ -0,0 +1,123 @@
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { callApi } from '../helpers';
+import { useCacheKey, useIsLoggedIn } from '../hooks';
+import { PostSubscription, SubscriptionManagerSubscriptionsCount } from '../types';
+
+type UnsubscribeParams = {
+	id: number | string;
+	blog_id: number | string;
+	post_id: number | string;
+};
+
+type UnsubscribeResponse = {
+	success: boolean;
+	subscribed: boolean;
+	subscription: null;
+};
+
+type PostSubscriptions = {
+	comment_subscriptions: PostSubscription[];
+	total_comment_subscriptions_count: number;
+};
+
+type PostSubscriptionsPages = {
+	pageParams: [];
+	pages: PostSubscriptions[];
+};
+
+const usePostUnsubscribeMutation = () => {
+	const { isLoggedIn } = useIsLoggedIn();
+	const queryClient = useQueryClient();
+	const postSubscriptionsCacheKey = useCacheKey( [ 'read', 'post-subscriptions' ] );
+	const subscriptionsCountCacheKey = useCacheKey( [ 'read', 'subscriptions-count' ] );
+
+	return useMutation( {
+		mutationFn: async ( params: UnsubscribeParams ) => {
+			if ( ! params.blog_id ) {
+				throw new Error(
+					// reminder: translate this string when we add it to the UI
+					'Something went wrong while unsubscribing.'
+				);
+			}
+
+			const response = await callApi< UnsubscribeResponse >( {
+				path: `/read/site/${ params.blog_id }/comment_email_subscriptions/delete?post_id=${ params.post_id }`,
+				method: 'POST',
+				isLoggedIn,
+				apiVersion: '1.2',
+			} );
+
+			if ( ! response.success ) {
+				throw new Error(
+					// reminder: translate this string when we add it to the UI
+					'Something went wrong while unsubscribing.'
+				);
+			}
+
+			return response;
+		},
+		onMutate: async ( params ) => {
+			await queryClient.cancelQueries( { queryKey: postSubscriptionsCacheKey } );
+			await queryClient.cancelQueries( {
+				queryKey: [ 'read', 'subscriptions-count', isLoggedIn ],
+			} );
+
+			const previousPostSubscriptions =
+				queryClient.getQueryData< PostSubscriptionsPages >( postSubscriptionsCacheKey );
+
+			// remove post from comment subscriptions
+			if ( previousPostSubscriptions ) {
+				queryClient.setQueryData< PostSubscriptionsPages >( postSubscriptionsCacheKey, {
+					...previousPostSubscriptions,
+					pages: previousPostSubscriptions.pages.map( ( page ) => ( {
+						...page,
+						comment_subscriptions: page.comment_subscriptions.filter(
+							( subscription ) => subscription.id !== params.id
+						),
+						total_comment_subscriptions_count: page.total_comment_subscriptions_count - 1,
+					} ) ),
+				} );
+			}
+
+			const previousSubscriptionsCount =
+				queryClient.getQueryData< SubscriptionManagerSubscriptionsCount >(
+					subscriptionsCountCacheKey
+				);
+
+			// decrement the comments count
+			if ( previousSubscriptionsCount ) {
+				queryClient.setQueryData< SubscriptionManagerSubscriptionsCount >(
+					subscriptionsCountCacheKey,
+					{
+						...previousSubscriptionsCount,
+						comments: previousSubscriptionsCount?.comments
+							? previousSubscriptionsCount?.comments - 1
+							: null,
+					}
+				);
+			}
+
+			return { previousPostSubscriptions, previousSubscriptionsCount };
+		},
+		onError: ( error, variables, context ) => {
+			if ( context?.previousPostSubscriptions ) {
+				queryClient.setQueryData< PostSubscriptionsPages >(
+					postSubscriptionsCacheKey,
+					context.previousPostSubscriptions
+				);
+			}
+			if ( context?.previousSubscriptionsCount ) {
+				queryClient.setQueryData< SubscriptionManagerSubscriptionsCount >(
+					subscriptionsCountCacheKey,
+					context.previousSubscriptionsCount
+				);
+			}
+		},
+		onSettled: () => {
+			queryClient.invalidateQueries( { queryKey: postSubscriptionsCacheKey } );
+			queryClient.invalidateQueries( { queryKey: subscriptionsCountCacheKey } );
+		},
+	} );
+};
+
+export default usePostUnsubscribeMutation;