@btst/stack 2.7.0 → 2.8.0

package/dist/packages/stack/src/plugins/comments/client/hooks/use-comments.cjs

@@ -0,0 +1,476 @@
+"use client";
+'use strict';
+
+const reactQuery = require('@tanstack/react-query');
+const client = require('@btst/stack/plugins/client');
+const plugins_comments_queryKeys = require('../../../../../../../plugins/comments/query-keys.cjs');
+const utils = require('../utils.cjs');
+
+function getClient(config) {
+  return client.createApiClient({
+    baseURL: config.apiBaseURL,
+    basePath: config.apiBasePath
+  });
+}
+function useComments(config, params, options) {
+  const client = getClient(config);
+  const queries = plugins_comments_queryKeys.createCommentsQueryKeys(client, config.headers);
+  const query = reactQuery.useQuery({
+    ...queries.comments.list(params),
+    staleTime: 3e4,
+    retry: false,
+    enabled: options?.enabled ?? true
+  });
+  return {
+    data: query.data,
+    comments: query.data?.items ?? [],
+    total: query.data?.total ?? 0,
+    isLoading: query.isLoading,
+    isFetching: query.isFetching,
+    error: query.error,
+    refetch: query.refetch
+  };
+}
+function useSuspenseComments(config, params) {
+  const client = getClient(config);
+  const queries = plugins_comments_queryKeys.createCommentsQueryKeys(client, config.headers);
+  const { data, refetch, error, isFetching } = reactQuery.useSuspenseQuery({
+    ...queries.comments.list(params),
+    staleTime: 3e4,
+    retry: false
+  });
+  if (error && !isFetching) {
+    throw error;
+  }
+  return {
+    comments: data?.items ?? [],
+    total: data?.total ?? 0,
+    refetch
+  };
+}
+function useSuspenseModerationComments(config, params) {
+  const limit = params.limit ?? 20;
+  const page = params.page ?? 1;
+  const offset = (page - 1) * limit;
+  const client = getClient(config);
+  const queries = plugins_comments_queryKeys.createCommentsQueryKeys(client, config.headers);
+  const { data, refetch, error, isFetching } = reactQuery.useSuspenseQuery({
+    ...queries.comments.list({ status: params.status, limit, offset }),
+    staleTime: 3e4,
+    retry: false
+  });
+  if (error && !isFetching) {
+    throw error;
+  }
+  const comments = data?.items ?? [];
+  const total = data?.total ?? 0;
+  const totalPages = Math.max(1, Math.ceil(total / limit));
+  return {
+    comments,
+    total,
+    limit,
+    offset,
+    totalPages,
+    refetch
+  };
+}
+function useInfiniteComments(config, params, options) {
+  const pageSize = params.pageSize ?? 10;
+  const client = getClient(config);
+  const queries = plugins_comments_queryKeys.createCommentsQueryKeys(client, config.headers);
+  const baseQuery = queries.commentsThread.list({
+    resourceId: params.resourceId,
+    resourceType: params.resourceType,
+    parentId: params.parentId ?? null,
+    status: params.status,
+    currentUserId: params.currentUserId,
+    limit: pageSize
+  });
+  const query = reactQuery.useInfiniteQuery({
+    ...baseQuery,
+    initialPageParam: 0,
+    getNextPageParam: (lastPage) => {
+      const nextOffset = lastPage.offset + lastPage.limit;
+      return nextOffset < lastPage.total ? nextOffset : void 0;
+    },
+    staleTime: 3e4,
+    retry: false,
+    enabled: options?.enabled ?? true
+  });
+  const comments = query.data?.pages.flatMap((p) => p.items) ?? [];
+  const total = query.data?.pages[0]?.total ?? 0;
+  return {
+    comments,
+    total,
+    queryKey: baseQuery.queryKey,
+    isLoading: query.isLoading,
+    isFetching: query.isFetching,
+    loadMore: query.fetchNextPage,
+    hasMore: !!query.hasNextPage,
+    isLoadingMore: query.isFetchingNextPage,
+    error: query.error
+  };
+}
+function useCommentCount(config, params) {
+  const client = getClient(config);
+  const queries = plugins_comments_queryKeys.createCommentsQueryKeys(client, config.headers);
+  const query = reactQuery.useQuery({
+    ...queries.commentCount.byResource(params),
+    staleTime: 6e4,
+    retry: false
+  });
+  return {
+    count: query.data ?? 0,
+    isLoading: query.isLoading,
+    error: query.error
+  };
+}
+function usePostComment(config, params) {
+  const queryClient = reactQuery.useQueryClient();
+  const client = getClient(config);
+  const queries = plugins_comments_queryKeys.createCommentsQueryKeys(client, config.headers);
+  const getListKey = (parentId, offset, limit) => {
+    if (params.infiniteKey && (parentId ?? null) === null) {
+      return params.infiniteKey;
+    }
+    return queries.comments.list({
+      resourceId: params.resourceId,
+      resourceType: params.resourceType,
+      parentId: parentId ?? null,
+      status: "approved",
+      currentUserId: params.currentUserId,
+      limit,
+      offset
+    }).queryKey;
+  };
+  const isInfinitePost = (parentId) => !!params.infiniteKey && (parentId ?? null) === null;
+  return reactQuery.useMutation({
+    mutationFn: async (input) => {
+      const response = await client("@post/comments", {
+        method: "POST",
+        body: {
+          resourceId: params.resourceId,
+          resourceType: params.resourceType,
+          parentId: input.parentId ?? null,
+          body: input.body
+        },
+        headers: config.headers
+      });
+      const data = response.data;
+      if (!data) throw utils.toError(response.error);
+      return data;
+    },
+    onMutate: async (input) => {
+      const listKey = getListKey(input.parentId, input.offset, input.limit);
+      await queryClient.cancelQueries({ queryKey: listKey });
+      const optimisticId = `optimistic-${Date.now()}`;
+      const optimistic = {
+        id: optimisticId,
+        resourceId: params.resourceId,
+        resourceType: params.resourceType,
+        parentId: input.parentId ?? null,
+        authorId: params.currentUserId ?? "",
+        resolvedAuthorName: "You",
+        resolvedAvatarUrl: null,
+        body: input.body,
+        status: "pending",
+        likes: 0,
+        isLikedByCurrentUser: false,
+        editedAt: null,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        replyCount: 0
+      };
+      if (isInfinitePost(input.parentId)) {
+        const previous2 = queryClient.getQueryData(listKey);
+        queryClient.setQueryData(
+          listKey,
+          (old) => {
+            if (!old) {
+              return {
+                pages: [
+                  {
+                    items: [optimistic],
+                    total: 1,
+                    limit: params.pageSize ?? 10,
+                    offset: 0
+                  }
+                ],
+                pageParams: [0]
+              };
+            }
+            const lastIdx = old.pages.length - 1;
+            return {
+              ...old,
+              // Increment `total` on every page so the header count (which reads
+              // pages[0].total) stays in sync even after multiple pages are loaded.
+              pages: old.pages.map(
+                (page, idx) => idx === lastIdx ? {
+                  ...page,
+                  items: [...page.items, optimistic],
+                  total: page.total + 1
+                } : { ...page, total: page.total + 1 }
+              )
+            };
+          }
+        );
+        return { previous: previous2, isInfinite: true, listKey, optimisticId };
+      }
+      const previous = queryClient.getQueryData(listKey);
+      queryClient.setQueryData(listKey, (old) => {
+        if (!old) {
+          return { items: [optimistic], total: 1, limit: 20, offset: 0 };
+        }
+        return {
+          ...old,
+          items: [...old.items, optimistic],
+          total: old.total + 1
+        };
+      });
+      return { previous, isInfinite: false, listKey, optimisticId };
+    },
+    onSuccess: (data, _input, context) => {
+      if (!context) return;
+      if (context.isInfinite) {
+        queryClient.setQueryData(
+          context.listKey,
+          (old) => {
+            if (!old) {
+              return {
+                pages: [
+                  {
+                    items: [data],
+                    total: 1,
+                    limit: _input.limit ?? params.pageSize ?? 10,
+                    offset: _input.offset ?? 0
+                  }
+                ],
+                pageParams: [_input.offset ?? 0]
+              };
+            }
+            return {
+              ...old,
+              pages: old.pages.map((page) => ({
+                ...page,
+                items: page.items.map(
+                  (item) => item.id === context.optimisticId ? data : item
+                )
+              }))
+            };
+          }
+        );
+      } else {
+        queryClient.setQueryData(context.listKey, (old) => {
+          if (!old) {
+            return {
+              items: [data],
+              total: 1,
+              limit: _input.limit ?? params.pageSize ?? 20,
+              offset: _input.offset ?? 0
+            };
+          }
+          return {
+            ...old,
+            items: old.items.map(
+              (item) => item.id === context.optimisticId ? data : item
+            )
+          };
+        });
+      }
+    },
+    onError: (_err, _input, context) => {
+      if (!context) return;
+      queryClient.setQueryData(context.listKey, context.previous);
+    }
+  });
+}
+function useUpdateComment(config) {
+  const queryClient = reactQuery.useQueryClient();
+  const client = getClient(config);
+  const queries = plugins_comments_queryKeys.createCommentsQueryKeys(client, config.headers);
+  return reactQuery.useMutation({
+    mutationFn: async (input) => {
+      const response = await client("@patch/comments/:id", {
+        method: "PATCH",
+        params: { id: input.id },
+        body: { body: input.body },
+        headers: config.headers
+      });
+      const data = response.data;
+      if (!data) throw utils.toError(response.error);
+      return data;
+    },
+    onSettled: () => {
+      queryClient.invalidateQueries({
+        queryKey: queries.comments.list._def
+      });
+      queryClient.invalidateQueries({ queryKey: ["commentsThread"] });
+    }
+  });
+}
+function useApproveComment(config) {
+  const queryClient = reactQuery.useQueryClient();
+  const client = getClient(config);
+  const queries = plugins_comments_queryKeys.createCommentsQueryKeys(client, config.headers);
+  return reactQuery.useMutation({
+    mutationFn: async (id) => {
+      const response = await client("@patch/comments/:id/status", {
+        method: "PATCH",
+        params: { id },
+        body: { status: "approved" },
+        headers: config.headers
+      });
+      const data = response.data;
+      if (!data) throw utils.toError(response.error);
+      return data;
+    },
+    onSettled: () => {
+      queryClient.invalidateQueries({
+        queryKey: queries.comments.list._def
+      });
+      queryClient.invalidateQueries({
+        queryKey: queries.commentCount.byResource._def
+      });
+      queryClient.invalidateQueries({ queryKey: ["commentsThread"] });
+    }
+  });
+}
+function useUpdateCommentStatus(config) {
+  const queryClient = reactQuery.useQueryClient();
+  const client = getClient(config);
+  const queries = plugins_comments_queryKeys.createCommentsQueryKeys(client, config.headers);
+  return reactQuery.useMutation({
+    mutationFn: async (input) => {
+      const response = await client("@patch/comments/:id/status", {
+        method: "PATCH",
+        params: { id: input.id },
+        body: { status: input.status },
+        headers: config.headers
+      });
+      const data = response.data;
+      if (!data) throw utils.toError(response.error);
+      return data;
+    },
+    onSettled: () => {
+      queryClient.invalidateQueries({
+        queryKey: queries.comments.list._def
+      });
+      queryClient.invalidateQueries({
+        queryKey: queries.commentCount.byResource._def
+      });
+      queryClient.invalidateQueries({ queryKey: ["commentsThread"] });
+    }
+  });
+}
+function useDeleteComment(config) {
+  const queryClient = reactQuery.useQueryClient();
+  const client = getClient(config);
+  const queries = plugins_comments_queryKeys.createCommentsQueryKeys(client, config.headers);
+  return reactQuery.useMutation({
+    mutationFn: async (id) => {
+      const response = await client("@delete/comments/:id", {
+        method: "DELETE",
+        params: { id },
+        headers: config.headers
+      });
+      const data = response.data;
+      if (!data) throw utils.toError(response.error);
+      return data;
+    },
+    onSettled: () => {
+      queryClient.invalidateQueries({
+        queryKey: queries.comments.list._def
+      });
+      queryClient.invalidateQueries({
+        queryKey: queries.commentCount.byResource._def
+      });
+      queryClient.invalidateQueries({ queryKey: ["commentsThread"] });
+    }
+  });
+}
+function useToggleLike(config, params) {
+  const queryClient = reactQuery.useQueryClient();
+  const client = getClient(config);
+  const queries = plugins_comments_queryKeys.createCommentsQueryKeys(client, config.headers);
+  const isInfinite = !!params.infiniteKey && (params.parentId ?? null) === null;
+  const listKey = isInfinite ? params.infiniteKey : queries.comments.list({
+    resourceId: params.resourceId,
+    resourceType: params.resourceType,
+    parentId: params.parentId ?? null,
+    status: "approved",
+    currentUserId: params.currentUserId
+  }).queryKey;
+  function applyLikeUpdate(commentId, updater) {
+    if (isInfinite) {
+      queryClient.setQueryData(
+        listKey,
+        (old) => {
+          if (!old) return old;
+          return {
+            ...old,
+            pages: old.pages.map((page) => ({
+              ...page,
+              items: page.items.map(
+                (c) => c.id === commentId ? updater(c) : c
+              )
+            }))
+          };
+        }
+      );
+    } else {
+      queryClient.setQueryData(listKey, (old) => {
+        if (!old) return old;
+        return {
+          ...old,
+          items: old.items.map((c) => c.id === commentId ? updater(c) : c)
+        };
+      });
+    }
+  }
+  return reactQuery.useMutation({
+    mutationFn: async (input) => {
+      const response = await client("@post/comments/:id/like", {
+        method: "POST",
+        params: { id: input.commentId },
+        body: { authorId: input.authorId },
+        headers: config.headers
+      });
+      const data = response.data;
+      if (!data) throw utils.toError(response.error);
+      return data;
+    },
+    onMutate: async (input) => {
+      await queryClient.cancelQueries({ queryKey: listKey });
+      const previous = isInfinite ? queryClient.getQueryData(listKey) : queryClient.getQueryData(listKey);
+      applyLikeUpdate(input.commentId, (c) => {
+        const wasLiked = c.isLikedByCurrentUser;
+        return {
+          ...c,
+          isLikedByCurrentUser: !wasLiked,
+          likes: wasLiked ? Math.max(0, c.likes - 1) : c.likes + 1
+        };
+      });
+      return { previous };
+    },
+    onError: (_err, _input, context) => {
+      if (context?.previous !== void 0) {
+        queryClient.setQueryData(listKey, context.previous);
+      }
+    },
+    onSettled: () => {
+      queryClient.invalidateQueries({ queryKey: listKey });
+    }
+  });
+}
+
+exports.useApproveComment = useApproveComment;
+exports.useCommentCount = useCommentCount;
+exports.useComments = useComments;
+exports.useDeleteComment = useDeleteComment;
+exports.useInfiniteComments = useInfiniteComments;
+exports.usePostComment = usePostComment;
+exports.useSuspenseComments = useSuspenseComments;
+exports.useSuspenseModerationComments = useSuspenseModerationComments;
+exports.useToggleLike = useToggleLike;
+exports.useUpdateComment = useUpdateComment;
+exports.useUpdateCommentStatus = useUpdateCommentStatus;