@btst/stack 2.6.2 → 2.8.0

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

@@ -0,0 +1,335 @@
+'use strict';
+
+const api = require('@btst/stack/plugins/api');
+const z = require('zod');
+const db = require('../db.cjs');
+const schemas = require('../schemas.cjs');
+const getters = require('./getters.cjs');
+const mutations = require('./mutations.cjs');
+const utils = require('../../utils.cjs');
+
+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 api.defineBackendPlugin({
+    name: "comments",
+    dbPlugin: db.commentsSchema,
+    api: (adapter) => ({
+      listComments: (params) => getters.listComments(adapter, params, options?.resolveUser),
+      getCommentById: (id, currentUserId) => getters.getCommentById(adapter, id, options?.resolveUser, currentUserId),
+      getCommentCount: (params) => getters.getCommentCount(adapter, params)
+    }),
+    routes: (adapter) => {
+      const listCommentsEndpoint = api.createEndpoint(
+        "/comments",
+        {
+          method: "GET",
+          query: schemas.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 utils.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 utils.runHookWithShim(
+              () => options.onBeforeList(ctx.query, context),
+              ctx.error,
+              "Forbidden: Cannot list comments with this status filter"
+            );
+          } else if (options?.onBeforeList && !ctx.query.authorId) {
+            await utils.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 getters.listComments(
+            adapter,
+            { ...ctx.query, currentUserId: resolvedCurrentUserId },
+            options?.resolveUser
+          );
+        }
+      );
+      const createCommentEndpoint = api.createEndpoint(
+        "/comments",
+        {
+          method: "POST",
+          body: schemas.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 utils.runHookWithShim(
+            () => onBeforePost(ctx.body, context),
+            ctx.error,
+            "Unauthorized: Cannot post comment"
+          );
+          const status = options?.autoApprove ? "approved" : "pending";
+          const comment = await mutations.createComment(adapter, {
+            ...ctx.body,
+            authorId,
+            status
+          });
+          if (options?.onAfterPost) {
+            await options.onAfterPost(comment, context);
+          }
+          const serialized = await getters.getCommentById(
+            adapter,
+            comment.id,
+            options?.resolveUser
+          );
+          if (!serialized) {
+            throw ctx.error(500, {
+              message: "Failed to retrieve created comment"
+            });
+          }
+          return serialized;
+        }
+      );
+      const updateCommentEndpoint = api.createEndpoint(
+        "/comments/:id",
+        {
+          method: "PATCH",
+          body: schemas.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 utils.runHookWithShim(
+            () => options.onBeforeEdit(id, { body: ctx.body.body }, context),
+            ctx.error,
+            "Unauthorized: Cannot edit comment"
+          );
+          const updated = await mutations.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 getters.getCommentById(
+            adapter,
+            updated.id,
+            options?.resolveUser
+          );
+          if (!serialized) {
+            throw ctx.error(500, {
+              message: "Failed to retrieve updated comment"
+            });
+          }
+          return serialized;
+        }
+      );
+      const getCommentCountEndpoint = api.createEndpoint(
+        "/comments/count",
+        {
+          method: "GET",
+          query: schemas.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 utils.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 utils.runHookWithShim(
+              () => options.onBeforeList(
+                { ...ctx.query, status: ctx.query.status },
+                context
+              ),
+              ctx.error,
+              "Forbidden: Cannot count comments"
+            );
+          }
+          const count = await getters.getCommentCount(adapter, ctx.query);
+          return { count };
+        }
+      );
+      const toggleLikeEndpoint = api.createEndpoint(
+        "/comments/:id/like",
+        {
+          method: "POST",
+          body: z.z.object({ authorId: z.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 utils.runHookWithShim(
+            () => options.onBeforeLike(id, ctx.body.authorId, context),
+            ctx.error,
+            "Unauthorized: Cannot like comment"
+          );
+          const result = await mutations.toggleCommentLike(
+            adapter,
+            id,
+            ctx.body.authorId
+          );
+          return result;
+        }
+      );
+      const updateStatusEndpoint = api.createEndpoint(
+        "/comments/:id/status",
+        {
+          method: "PATCH",
+          body: schemas.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 utils.runHookWithShim(
+            () => options.onBeforeStatusChange(id, ctx.body.status, context),
+            ctx.error,
+            "Unauthorized: Cannot change comment status"
+          );
+          const updated = await mutations.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 getters.getCommentById(
+            adapter,
+            updated.id,
+            options?.resolveUser
+          );
+          if (!serialized) {
+            throw ctx.error(500, {
+              message: "Failed to retrieve updated comment"
+            });
+          }
+          return serialized;
+        }
+      );
+      const deleteCommentEndpoint = api.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 utils.runHookWithShim(
+            () => options.onBeforeDelete(id, context),
+            ctx.error,
+            "Unauthorized: Cannot delete comment"
+          );
+          const deleted = await mutations.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
+      };
+    }
+  });
+};
+
+exports.commentsBackendPlugin = commentsBackendPlugin;

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 };