@btst/stack 2.7.0 → 2.8.1

package/dist/packages/stack/src/plugins/comments/api/plugin.mjs

@@ -0,0 +1,333 @@
+import { defineBackendPlugin, createEndpoint } from '@btst/stack/plugins/api';
+import { z } from 'zod';
+import { commentsSchema } from '../db.mjs';
+import { CommentListQuerySchema, createCommentSchema, updateCommentSchema, CommentCountQuerySchema, updateCommentStatusSchema } from '../schemas.mjs';
+import { getCommentCount, getCommentById, listComments } from './getters.mjs';
+import { createComment, updateComment, toggleCommentLike, updateCommentStatus, deleteComment } from './mutations.mjs';
+import { runHookWithShim } from '../../utils.mjs';
+
+const commentsBackendPlugin = (options) => {
+  const postingEnabled = options.allowPosting !== false;
+  const editingEnabled = options.allowEditing !== false;
+  const onBeforePost = options.allowPosting !== false ? options.onBeforePost : void 0;
+  const resolveCurrentUserId = options.allowPosting !== false ? options.resolveCurrentUserId : void 0;
+  return defineBackendPlugin({
+    name: "comments",
+    dbPlugin: commentsSchema,
+    api: (adapter) => ({
+      listComments: (params) => listComments(adapter, params, options?.resolveUser),
+      getCommentById: (id, currentUserId) => getCommentById(adapter, id, options?.resolveUser, currentUserId),
+      getCommentCount: (params) => getCommentCount(adapter, params)
+    }),
+    routes: (adapter) => {
+      const listCommentsEndpoint = createEndpoint(
+        "/comments",
+        {
+          method: "GET",
+          query: CommentListQuerySchema
+        },
+        async (ctx) => {
+          const context = {
+            query: ctx.query,
+            request: ctx.request,
+            headers: ctx.headers
+          };
+          if (ctx.query.authorId) {
+            if (!options?.onBeforeListByAuthor) {
+              throw ctx.error(403, {
+                message: "Forbidden: authorId filter requires onBeforeListByAuthor hook"
+              });
+            }
+            await runHookWithShim(
+              () => options.onBeforeListByAuthor(
+                ctx.query.authorId,
+                ctx.query,
+                context
+              ),
+              ctx.error,
+              "Forbidden: Cannot list comments for this author"
+            );
+          }
+          if (ctx.query.status && ctx.query.status !== "approved") {
+            if (!options?.onBeforeList) {
+              throw ctx.error(403, {
+                message: "Forbidden: status filter requires authorization"
+              });
+            }
+            await runHookWithShim(
+              () => options.onBeforeList(ctx.query, context),
+              ctx.error,
+              "Forbidden: Cannot list comments with this status filter"
+            );
+          } else if (options?.onBeforeList && !ctx.query.authorId) {
+            await runHookWithShim(
+              () => options.onBeforeList(ctx.query, context),
+              ctx.error,
+              "Forbidden: Cannot list comments"
+            );
+          }
+          let resolvedCurrentUserId;
+          if (resolveCurrentUserId) {
+            try {
+              const result = await resolveCurrentUserId(context);
+              resolvedCurrentUserId = result ?? void 0;
+            } catch {
+              resolvedCurrentUserId = void 0;
+            }
+          }
+          return await listComments(
+            adapter,
+            { ...ctx.query, currentUserId: resolvedCurrentUserId },
+            options?.resolveUser
+          );
+        }
+      );
+      const createCommentEndpoint = createEndpoint(
+        "/comments",
+        {
+          method: "POST",
+          body: createCommentSchema
+        },
+        async (ctx) => {
+          if (!postingEnabled) {
+            throw ctx.error(403, { message: "Posting comments is disabled" });
+          }
+          const context = {
+            body: ctx.body,
+            headers: ctx.headers
+          };
+          const { authorId } = await runHookWithShim(
+            () => onBeforePost(ctx.body, context),
+            ctx.error,
+            "Unauthorized: Cannot post comment"
+          );
+          const status = options?.autoApprove ? "approved" : "pending";
+          const comment = await createComment(adapter, {
+            ...ctx.body,
+            authorId,
+            status
+          });
+          if (options?.onAfterPost) {
+            await options.onAfterPost(comment, context);
+          }
+          const serialized = await getCommentById(
+            adapter,
+            comment.id,
+            options?.resolveUser
+          );
+          if (!serialized) {
+            throw ctx.error(500, {
+              message: "Failed to retrieve created comment"
+            });
+          }
+          return serialized;
+        }
+      );
+      const updateCommentEndpoint = createEndpoint(
+        "/comments/:id",
+        {
+          method: "PATCH",
+          body: updateCommentSchema
+        },
+        async (ctx) => {
+          if (!editingEnabled) {
+            throw ctx.error(403, { message: "Editing comments is disabled" });
+          }
+          const { id } = ctx.params;
+          const context = {
+            params: ctx.params,
+            body: ctx.body,
+            headers: ctx.headers
+          };
+          if (!options?.onBeforeEdit) {
+            throw ctx.error(403, {
+              message: "Forbidden: editing comments requires the onBeforeEdit hook"
+            });
+          }
+          await runHookWithShim(
+            () => options.onBeforeEdit(id, { body: ctx.body.body }, context),
+            ctx.error,
+            "Unauthorized: Cannot edit comment"
+          );
+          const updated = await updateComment(adapter, id, ctx.body.body);
+          if (!updated) {
+            throw ctx.error(404, { message: "Comment not found" });
+          }
+          if (options?.onAfterEdit) {
+            await options.onAfterEdit(updated, context);
+          }
+          const serialized = await getCommentById(
+            adapter,
+            updated.id,
+            options?.resolveUser
+          );
+          if (!serialized) {
+            throw ctx.error(500, {
+              message: "Failed to retrieve updated comment"
+            });
+          }
+          return serialized;
+        }
+      );
+      const getCommentCountEndpoint = createEndpoint(
+        "/comments/count",
+        {
+          method: "GET",
+          query: CommentCountQuerySchema
+        },
+        async (ctx) => {
+          const context = {
+            query: ctx.query,
+            headers: ctx.headers
+          };
+          if (ctx.query.status && ctx.query.status !== "approved") {
+            if (!options?.onBeforeList) {
+              throw ctx.error(403, {
+                message: "Forbidden: status filter requires authorization"
+              });
+            }
+            await runHookWithShim(
+              () => options.onBeforeList(
+                { ...ctx.query, status: ctx.query.status },
+                context
+              ),
+              ctx.error,
+              "Forbidden: Cannot count comments with this status filter"
+            );
+          } else if (options?.onBeforeList) {
+            await runHookWithShim(
+              () => options.onBeforeList(
+                { ...ctx.query, status: ctx.query.status },
+                context
+              ),
+              ctx.error,
+              "Forbidden: Cannot count comments"
+            );
+          }
+          const count = await getCommentCount(adapter, ctx.query);
+          return { count };
+        }
+      );
+      const toggleLikeEndpoint = createEndpoint(
+        "/comments/:id/like",
+        {
+          method: "POST",
+          body: z.object({ authorId: z.string().min(1) })
+        },
+        async (ctx) => {
+          const { id } = ctx.params;
+          const context = {
+            params: ctx.params,
+            body: ctx.body,
+            headers: ctx.headers
+          };
+          if (!options?.onBeforeLike) {
+            throw ctx.error(403, {
+              message: "Forbidden: toggling likes requires the onBeforeLike hook"
+            });
+          }
+          await runHookWithShim(
+            () => options.onBeforeLike(id, ctx.body.authorId, context),
+            ctx.error,
+            "Unauthorized: Cannot like comment"
+          );
+          const result = await toggleCommentLike(
+            adapter,
+            id,
+            ctx.body.authorId
+          );
+          return result;
+        }
+      );
+      const updateStatusEndpoint = createEndpoint(
+        "/comments/:id/status",
+        {
+          method: "PATCH",
+          body: updateCommentStatusSchema
+        },
+        async (ctx) => {
+          const { id } = ctx.params;
+          const context = {
+            params: ctx.params,
+            body: ctx.body,
+            headers: ctx.headers
+          };
+          if (!options?.onBeforeStatusChange) {
+            throw ctx.error(403, {
+              message: "Forbidden: changing comment status requires the onBeforeStatusChange hook"
+            });
+          }
+          await runHookWithShim(
+            () => options.onBeforeStatusChange(id, ctx.body.status, context),
+            ctx.error,
+            "Unauthorized: Cannot change comment status"
+          );
+          const updated = await updateCommentStatus(
+            adapter,
+            id,
+            ctx.body.status
+          );
+          if (!updated) {
+            throw ctx.error(404, { message: "Comment not found" });
+          }
+          if (ctx.body.status === "approved" && options?.onAfterApprove) {
+            await options.onAfterApprove(updated, context);
+          }
+          const serialized = await getCommentById(
+            adapter,
+            updated.id,
+            options?.resolveUser
+          );
+          if (!serialized) {
+            throw ctx.error(500, {
+              message: "Failed to retrieve updated comment"
+            });
+          }
+          return serialized;
+        }
+      );
+      const deleteCommentEndpoint = createEndpoint(
+        "/comments/:id",
+        {
+          method: "DELETE"
+        },
+        async (ctx) => {
+          const { id } = ctx.params;
+          const context = {
+            params: ctx.params,
+            headers: ctx.headers
+          };
+          if (!options?.onBeforeDelete) {
+            throw ctx.error(403, {
+              message: "Forbidden: deleting comments requires the onBeforeDelete hook"
+            });
+          }
+          await runHookWithShim(
+            () => options.onBeforeDelete(id, context),
+            ctx.error,
+            "Unauthorized: Cannot delete comment"
+          );
+          const deleted = await deleteComment(adapter, id);
+          if (!deleted) {
+            throw ctx.error(404, { message: "Comment not found" });
+          }
+          if (options?.onAfterDelete) {
+            await options.onAfterDelete(id, context);
+          }
+          return { success: true };
+        }
+      );
+      return {
+        listComments: listCommentsEndpoint,
+        ...postingEnabled && { createComment: createCommentEndpoint },
+        ...editingEnabled && { updateComment: updateCommentEndpoint },
+        getCommentCount: getCommentCountEndpoint,
+        toggleLike: toggleLikeEndpoint,
+        updateCommentStatus: updateStatusEndpoint,
+        deleteComment: deleteCommentEndpoint
+      };
+    }
+  });
+};
+
+export { commentsBackendPlugin };

package/dist/packages/stack/src/plugins/comments/api/query-key-defs.cjs

@@ -0,0 +1,60 @@
+'use strict';
+
+function commentsListDiscriminator(params) {
+  return {
+    resourceId: params?.resourceId,
+    resourceType: params?.resourceType,
+    parentId: params?.parentId,
+    status: params?.status,
+    currentUserId: params?.currentUserId,
+    authorId: params?.authorId,
+    sort: params?.sort,
+    limit: params?.limit ?? 20,
+    offset: params?.offset ?? 0
+  };
+}
+function commentCountDiscriminator(params) {
+  return {
+    resourceId: params.resourceId,
+    resourceType: params.resourceType,
+    status: params.status
+  };
+}
+function commentsThreadDiscriminator(params) {
+  return {
+    resourceId: params?.resourceId,
+    resourceType: params?.resourceType,
+    parentId: params?.parentId,
+    status: params?.status,
+    currentUserId: params?.currentUserId,
+    limit: params?.limit ?? 20
+  };
+}
+const COMMENTS_QUERY_KEYS = {
+  /**
+   * Key for comments list query.
+   * Full key: ["comments", "list", { resourceId, resourceType, parentId, status, currentUserId, limit, offset }]
+   */
+  commentsList: (params) => ["comments", "list", commentsListDiscriminator(params)],
+  /**
+   * Key for a single comment detail query.
+   * Full key: ["comments", "detail", id]
+   */
+  commentDetail: (id) => ["comments", "detail", id],
+  /**
+   * Key for comment count query.
+   * Full key: ["comments", "count", { resourceId, resourceType, status }]
+   */
+  commentCount: (params) => ["comments", "count", commentCountDiscriminator(params)],
+  /**
+   * Key for the infinite thread query (top-level comments, load-more).
+   * Full key: ["commentsThread", "list", { resourceId, resourceType, parentId, status, currentUserId, limit }]
+   * Offset is excluded — it is driven by `pageParam`, not baked into the key.
+   */
+  commentsThread: (params) => ["commentsThread", "list", commentsThreadDiscriminator(params)]
+};
+
+exports.COMMENTS_QUERY_KEYS = COMMENTS_QUERY_KEYS;
+exports.commentCountDiscriminator = commentCountDiscriminator;
+exports.commentsListDiscriminator = commentsListDiscriminator;
+exports.commentsThreadDiscriminator = commentsThreadDiscriminator;

package/dist/packages/stack/src/plugins/comments/api/query-key-defs.mjs

@@ -0,0 +1,55 @@
+function commentsListDiscriminator(params) {
+  return {
+    resourceId: params?.resourceId,
+    resourceType: params?.resourceType,
+    parentId: params?.parentId,
+    status: params?.status,
+    currentUserId: params?.currentUserId,
+    authorId: params?.authorId,
+    sort: params?.sort,
+    limit: params?.limit ?? 20,
+    offset: params?.offset ?? 0
+  };
+}
+function commentCountDiscriminator(params) {
+  return {
+    resourceId: params.resourceId,
+    resourceType: params.resourceType,
+    status: params.status
+  };
+}
+function commentsThreadDiscriminator(params) {
+  return {
+    resourceId: params?.resourceId,
+    resourceType: params?.resourceType,
+    parentId: params?.parentId,
+    status: params?.status,
+    currentUserId: params?.currentUserId,
+    limit: params?.limit ?? 20
+  };
+}
+const COMMENTS_QUERY_KEYS = {
+  /**
+   * Key for comments list query.
+   * Full key: ["comments", "list", { resourceId, resourceType, parentId, status, currentUserId, limit, offset }]
+   */
+  commentsList: (params) => ["comments", "list", commentsListDiscriminator(params)],
+  /**
+   * Key for a single comment detail query.
+   * Full key: ["comments", "detail", id]
+   */
+  commentDetail: (id) => ["comments", "detail", id],
+  /**
+   * Key for comment count query.
+   * Full key: ["comments", "count", { resourceId, resourceType, status }]
+   */
+  commentCount: (params) => ["comments", "count", commentCountDiscriminator(params)],
+  /**
+   * Key for the infinite thread query (top-level comments, load-more).
+   * Full key: ["commentsThread", "list", { resourceId, resourceType, parentId, status, currentUserId, limit }]
+   * Offset is excluded — it is driven by `pageParam`, not baked into the key.
+   */
+  commentsThread: (params) => ["commentsThread", "list", commentsThreadDiscriminator(params)]
+};
+
+export { COMMENTS_QUERY_KEYS, commentCountDiscriminator, commentsListDiscriminator, commentsThreadDiscriminator };

package/dist/packages/stack/src/plugins/comments/api/serializers.cjs

@@ -0,0 +1,23 @@
+'use strict';
+
+function serializeComment(comment) {
+  return {
+    id: comment.id,
+    resourceId: comment.resourceId,
+    resourceType: comment.resourceType,
+    parentId: comment.parentId ?? null,
+    authorId: comment.authorId,
+    resolvedAuthorName: "[deleted]",
+    resolvedAvatarUrl: null,
+    isLikedByCurrentUser: false,
+    body: comment.body,
+    status: comment.status,
+    likes: comment.likes,
+    editedAt: comment.editedAt?.toISOString() ?? null,
+    createdAt: comment.createdAt.toISOString(),
+    updatedAt: comment.updatedAt.toISOString(),
+    replyCount: 0
+  };
+}
+
+exports.serializeComment = serializeComment;

package/dist/packages/stack/src/plugins/comments/api/serializers.mjs

@@ -0,0 +1,21 @@
+function serializeComment(comment) {
+  return {
+    id: comment.id,
+    resourceId: comment.resourceId,
+    resourceType: comment.resourceType,
+    parentId: comment.parentId ?? null,
+    authorId: comment.authorId,
+    resolvedAuthorName: "[deleted]",
+    resolvedAvatarUrl: null,
+    isLikedByCurrentUser: false,
+    body: comment.body,
+    status: comment.status,
+    likes: comment.likes,
+    editedAt: comment.editedAt?.toISOString() ?? null,
+    createdAt: comment.createdAt.toISOString(),
+    updatedAt: comment.updatedAt.toISOString(),
+    replyCount: 0
+  };
+}
+
+export { serializeComment };

package/dist/packages/stack/src/plugins/comments/client/components/comment-count.cjs

@@ -0,0 +1,46 @@
+"use client";
+'use strict';
+
+const jsxRuntime = require('react/jsx-runtime');
+const LucideIcons = require('lucide-react');
+const useComments = require('../hooks/use-comments.cjs');
+
+function CommentCount({
+  resourceId,
+  resourceType,
+  status = "approved",
+  apiBaseURL,
+  apiBasePath,
+  headers,
+  className
+}) {
+  const { count, isLoading } = useComments.useCommentCount(
+    { apiBaseURL, apiBasePath, headers },
+    { resourceId, resourceType, status }
+  );
+  if (isLoading) {
+    return /* @__PURE__ */ jsxRuntime.jsxs(
+      "span",
+      {
+        className: `inline-flex items-center gap-1 text-xs text-muted-foreground ${className ?? ""}`,
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsx(LucideIcons.MessageSquare, { className: "h-3.5 w-3.5" }),
+          /* @__PURE__ */ jsxRuntime.jsx("span", { className: "animate-pulse", children: "\u2026" })
+        ]
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "span",
+    {
+      className: `inline-flex items-center gap-1 text-xs text-muted-foreground ${className ?? ""}`,
+      "data-testid": "comment-count",
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx(LucideIcons.MessageSquare, { className: "h-3.5 w-3.5" }),
+        count
+      ]
+    }
+  );
+}
+
+exports.CommentCount = CommentCount;

package/dist/packages/stack/src/plugins/comments/client/components/comment-count.mjs

@@ -0,0 +1,44 @@
+"use client";
+import { jsxs, jsx } from 'react/jsx-runtime';
+import { MessageSquare } from 'lucide-react';
+import { useCommentCount } from '../hooks/use-comments.mjs';
+
+function CommentCount({
+  resourceId,
+  resourceType,
+  status = "approved",
+  apiBaseURL,
+  apiBasePath,
+  headers,
+  className
+}) {
+  const { count, isLoading } = useCommentCount(
+    { apiBaseURL, apiBasePath, headers },
+    { resourceId, resourceType, status }
+  );
+  if (isLoading) {
+    return /* @__PURE__ */ jsxs(
+      "span",
+      {
+        className: `inline-flex items-center gap-1 text-xs text-muted-foreground ${className ?? ""}`,
+        children: [
+          /* @__PURE__ */ jsx(MessageSquare, { className: "h-3.5 w-3.5" }),
+          /* @__PURE__ */ jsx("span", { className: "animate-pulse", children: "\u2026" })
+        ]
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxs(
+    "span",
+    {
+      className: `inline-flex items-center gap-1 text-xs text-muted-foreground ${className ?? ""}`,
+      "data-testid": "comment-count",
+      children: [
+        /* @__PURE__ */ jsx(MessageSquare, { className: "h-3.5 w-3.5" }),
+        count
+      ]
+    }
+  );
+}
+
+export { CommentCount };

package/dist/packages/stack/src/plugins/comments/client/components/comment-form.cjs

@@ -0,0 +1,86 @@
+"use client";
+'use strict';
+
+const jsxRuntime = require('react/jsx-runtime');
+const React = require('react');
+const button = require('../../../../../../ui/src/components/button.cjs');
+const textarea = require('../../../../../../ui/src/components/textarea.cjs');
+const index = require('../localization/index.cjs');
+
+function CommentForm({
+  authorId: _authorId,
+  initialBody = "",
+  submitLabel,
+  onSubmit,
+  onCancel,
+  InputComponent,
+  localization: localizationProp
+}) {
+  const loc = { ...index.COMMENTS_LOCALIZATION, ...localizationProp };
+  const [body, setBody] = React.useState(initialBody);
+  const [isPending, setIsPending] = React.useState(false);
+  const [error, setError] = React.useState(null);
+  const resolvedSubmitLabel = submitLabel ?? loc.COMMENTS_FORM_POST_COMMENT;
+  const handleSubmit = async (e) => {
+    e.preventDefault();
+    if (!body.trim()) return;
+    setError(null);
+    setIsPending(true);
+    try {
+      await onSubmit(body.trim());
+      setBody("");
+    } catch (err) {
+      setError(
+        err instanceof Error ? err.message : loc.COMMENTS_FORM_SUBMIT_ERROR
+      );
+    } finally {
+      setIsPending(false);
+    }
+  };
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "form",
+    {
+      "data-testid": "comment-form",
+      onSubmit: handleSubmit,
+      className: "flex flex-col gap-2",
+      children: [
+        InputComponent ? /* @__PURE__ */ jsxRuntime.jsx(
+          InputComponent,
+          {
+            value: body,
+            onChange: setBody,
+            disabled: isPending,
+            placeholder: loc.COMMENTS_FORM_PLACEHOLDER
+          }
+        ) : /* @__PURE__ */ jsxRuntime.jsx(
+          textarea.Textarea,
+          {
+            value: body,
+            onChange: (e) => setBody(e.target.value),
+            placeholder: loc.COMMENTS_FORM_PLACEHOLDER,
+            disabled: isPending,
+            rows: 3,
+            className: "resize-none"
+          }
+        ),
+        error && /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-sm text-destructive", children: error }),
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex gap-2 justify-end", children: [
+          onCancel && /* @__PURE__ */ jsxRuntime.jsx(
+            button.Button,
+            {
+              type: "button",
+              variant: "ghost",
+              size: "sm",
+              onClick: onCancel,
+              disabled: isPending,
+              children: loc.COMMENTS_FORM_CANCEL
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsx(button.Button, { type: "submit", size: "sm", disabled: isPending || !body.trim(), children: isPending ? loc.COMMENTS_FORM_POSTING : resolvedSubmitLabel })
+        ] })
+      ]
+    }
+  );
+}
+
+exports.CommentForm = CommentForm;