@btst/stack 2.7.0 → 2.8.0

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

@@ -0,0 +1,118 @@
+'use strict';
+
+async function createComment(adapter, input) {
+  return adapter.create({
+    model: "comment",
+    data: {
+      resourceId: input.resourceId,
+      resourceType: input.resourceType,
+      parentId: input.parentId ?? null,
+      authorId: input.authorId,
+      body: input.body,
+      status: input.status ?? "pending",
+      likes: 0,
+      createdAt: /* @__PURE__ */ new Date(),
+      updatedAt: /* @__PURE__ */ new Date()
+    }
+  });
+}
+async function updateComment(adapter, id, body) {
+  const existing = await adapter.findOne({
+    model: "comment",
+    where: [{ field: "id", value: id, operator: "eq" }]
+  });
+  if (!existing) return null;
+  return adapter.update({
+    model: "comment",
+    where: [{ field: "id", value: id, operator: "eq" }],
+    update: {
+      body,
+      editedAt: /* @__PURE__ */ new Date(),
+      updatedAt: /* @__PURE__ */ new Date()
+    }
+  });
+}
+async function updateCommentStatus(adapter, id, status) {
+  const existing = await adapter.findOne({
+    model: "comment",
+    where: [{ field: "id", value: id, operator: "eq" }]
+  });
+  if (!existing) return null;
+  return adapter.update({
+    model: "comment",
+    where: [{ field: "id", value: id, operator: "eq" }],
+    update: { status, updatedAt: /* @__PURE__ */ new Date() }
+  });
+}
+async function deleteComment(adapter, id) {
+  const existing = await adapter.findOne({
+    model: "comment",
+    where: [{ field: "id", value: id, operator: "eq" }]
+  });
+  if (!existing) return false;
+  await adapter.transaction(async (tx) => {
+    await tx.delete({
+      model: "comment",
+      where: [{ field: "parentId", value: id, operator: "eq" }]
+    });
+    await tx.delete({
+      model: "comment",
+      where: [{ field: "id", value: id, operator: "eq" }]
+    });
+  });
+  return true;
+}
+async function toggleCommentLike(adapter, commentId, authorId) {
+  return adapter.transaction(async (tx) => {
+    const comment = await tx.findOne({
+      model: "comment",
+      where: [{ field: "id", value: commentId, operator: "eq" }]
+    });
+    if (!comment) {
+      throw new Error("Comment not found");
+    }
+    const existingLike = await tx.findOne({
+      model: "commentLike",
+      where: [
+        { field: "commentId", value: commentId, operator: "eq" },
+        { field: "authorId", value: authorId, operator: "eq" }
+      ]
+    });
+    let newLikes;
+    let isLiked;
+    if (existingLike) {
+      await tx.delete({
+        model: "commentLike",
+        where: [
+          { field: "commentId", value: commentId, operator: "eq" },
+          { field: "authorId", value: authorId, operator: "eq" }
+        ]
+      });
+      newLikes = Math.max(0, comment.likes - 1);
+      isLiked = false;
+    } else {
+      await tx.create({
+        model: "commentLike",
+        data: {
+          commentId,
+          authorId,
+          createdAt: /* @__PURE__ */ new Date()
+        }
+      });
+      newLikes = comment.likes + 1;
+      isLiked = true;
+    }
+    await tx.update({
+      model: "comment",
+      where: [{ field: "id", value: commentId, operator: "eq" }],
+      update: { likes: newLikes, updatedAt: /* @__PURE__ */ new Date() }
+    });
+    return { likes: newLikes, isLiked };
+  });
+}
+
+exports.createComment = createComment;
+exports.deleteComment = deleteComment;
+exports.toggleCommentLike = toggleCommentLike;
+exports.updateComment = updateComment;
+exports.updateCommentStatus = updateCommentStatus;

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

@@ -0,0 +1,112 @@
+async function createComment(adapter, input) {
+  return adapter.create({
+    model: "comment",
+    data: {
+      resourceId: input.resourceId,
+      resourceType: input.resourceType,
+      parentId: input.parentId ?? null,
+      authorId: input.authorId,
+      body: input.body,
+      status: input.status ?? "pending",
+      likes: 0,
+      createdAt: /* @__PURE__ */ new Date(),
+      updatedAt: /* @__PURE__ */ new Date()
+    }
+  });
+}
+async function updateComment(adapter, id, body) {
+  const existing = await adapter.findOne({
+    model: "comment",
+    where: [{ field: "id", value: id, operator: "eq" }]
+  });
+  if (!existing) return null;
+  return adapter.update({
+    model: "comment",
+    where: [{ field: "id", value: id, operator: "eq" }],
+    update: {
+      body,
+      editedAt: /* @__PURE__ */ new Date(),
+      updatedAt: /* @__PURE__ */ new Date()
+    }
+  });
+}
+async function updateCommentStatus(adapter, id, status) {
+  const existing = await adapter.findOne({
+    model: "comment",
+    where: [{ field: "id", value: id, operator: "eq" }]
+  });
+  if (!existing) return null;
+  return adapter.update({
+    model: "comment",
+    where: [{ field: "id", value: id, operator: "eq" }],
+    update: { status, updatedAt: /* @__PURE__ */ new Date() }
+  });
+}
+async function deleteComment(adapter, id) {
+  const existing = await adapter.findOne({
+    model: "comment",
+    where: [{ field: "id", value: id, operator: "eq" }]
+  });
+  if (!existing) return false;
+  await adapter.transaction(async (tx) => {
+    await tx.delete({
+      model: "comment",
+      where: [{ field: "parentId", value: id, operator: "eq" }]
+    });
+    await tx.delete({
+      model: "comment",
+      where: [{ field: "id", value: id, operator: "eq" }]
+    });
+  });
+  return true;
+}
+async function toggleCommentLike(adapter, commentId, authorId) {
+  return adapter.transaction(async (tx) => {
+    const comment = await tx.findOne({
+      model: "comment",
+      where: [{ field: "id", value: commentId, operator: "eq" }]
+    });
+    if (!comment) {
+      throw new Error("Comment not found");
+    }
+    const existingLike = await tx.findOne({
+      model: "commentLike",
+      where: [
+        { field: "commentId", value: commentId, operator: "eq" },
+        { field: "authorId", value: authorId, operator: "eq" }
+      ]
+    });
+    let newLikes;
+    let isLiked;
+    if (existingLike) {
+      await tx.delete({
+        model: "commentLike",
+        where: [
+          { field: "commentId", value: commentId, operator: "eq" },
+          { field: "authorId", value: authorId, operator: "eq" }
+        ]
+      });
+      newLikes = Math.max(0, comment.likes - 1);
+      isLiked = false;
+    } else {
+      await tx.create({
+        model: "commentLike",
+        data: {
+          commentId,
+          authorId,
+          createdAt: /* @__PURE__ */ new Date()
+        }
+      });
+      newLikes = comment.likes + 1;
+      isLiked = true;
+    }
+    await tx.update({
+      model: "comment",
+      where: [{ field: "id", value: commentId, operator: "eq" }],
+      update: { likes: newLikes, updatedAt: /* @__PURE__ */ new Date() }
+    });
+    return { likes: newLikes, isLiked };
+  });
+}
+
+export { createComment, deleteComment, toggleCommentLike, updateComment, updateCommentStatus };

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;