@btst/stack 2.6.2 → 2.8.0

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

@@ -0,0 +1,280 @@
+async function resolveAuthors(authorIds, resolveUser) {
+  const unique = [...new Set(authorIds)];
+  const map = /* @__PURE__ */ new Map();
+  if (!resolveUser || unique.length === 0) {
+    for (const id of unique) {
+      map.set(id, { name: "[deleted]", avatarUrl: null });
+    }
+    return map;
+  }
+  await Promise.all(
+    unique.map(async (id) => {
+      try {
+        const result = await resolveUser(id);
+        map.set(id, {
+          name: result?.name ?? "[deleted]",
+          avatarUrl: result?.avatarUrl ?? null
+        });
+      } catch {
+        map.set(id, { name: "[deleted]", avatarUrl: null });
+      }
+    })
+  );
+  return map;
+}
+function enrichComment(comment, authorMap, likedCommentIds, replyCount = 0) {
+  const author = authorMap.get(comment.authorId) ?? {
+    name: "[deleted]",
+    avatarUrl: null
+  };
+  return {
+    id: comment.id,
+    resourceId: comment.resourceId,
+    resourceType: comment.resourceType,
+    parentId: comment.parentId ?? null,
+    authorId: comment.authorId,
+    resolvedAuthorName: author.name,
+    resolvedAvatarUrl: author.avatarUrl,
+    body: comment.body,
+    status: comment.status,
+    likes: comment.likes,
+    isLikedByCurrentUser: likedCommentIds.has(comment.id),
+    editedAt: comment.editedAt?.toISOString() ?? null,
+    createdAt: comment.createdAt.toISOString(),
+    updatedAt: comment.updatedAt.toISOString(),
+    replyCount
+  };
+}
+function buildBaseConditions(params) {
+  const conditions = [];
+  if (params.resourceId) {
+    conditions.push({
+      field: "resourceId",
+      value: params.resourceId,
+      operator: "eq"
+    });
+  }
+  if (params.resourceType) {
+    conditions.push({
+      field: "resourceType",
+      value: params.resourceType,
+      operator: "eq"
+    });
+  }
+  if (params.parentId !== void 0) {
+    const parentValue = params.parentId === null || params.parentId === "null" ? null : params.parentId;
+    conditions.push({ field: "parentId", value: parentValue, operator: "eq" });
+  }
+  if (params.authorId) {
+    conditions.push({
+      field: "authorId",
+      value: params.authorId,
+      operator: "eq"
+    });
+  }
+  return conditions;
+}
+async function listComments(adapter, params, resolveUser) {
+  const limit = params.limit ?? 20;
+  const offset = params.offset ?? 0;
+  const sortDirection = params.sort ?? "asc";
+  const omitStatusFilter = !!params.authorId && !params.status;
+  const statusFilter = omitStatusFilter ? null : params.status ?? "approved";
+  const baseConditions = buildBaseConditions(params);
+  let comments;
+  let total;
+  if (!omitStatusFilter && statusFilter === "approved" && params.currentUserId) {
+    const [ownPendingAll, approvedCount] = await Promise.all([
+      adapter.findMany({
+        model: "comment",
+        where: [
+          ...baseConditions,
+          { field: "status", value: "pending", operator: "eq" },
+          { field: "authorId", value: params.currentUserId, operator: "eq" }
+        ],
+        sortBy: { field: "createdAt", direction: sortDirection }
+      }),
+      adapter.count({
+        model: "comment",
+        where: [
+          ...baseConditions,
+          { field: "status", value: "approved", operator: "eq" }
+        ]
+      })
+    ]);
+    total = approvedCount + ownPendingAll.length;
+    if (ownPendingAll.length === 0) {
+      comments = await adapter.findMany({
+        model: "comment",
+        limit,
+        offset,
+        where: [
+          ...baseConditions,
+          { field: "status", value: "approved", operator: "eq" }
+        ],
+        sortBy: { field: "createdAt", direction: sortDirection }
+      });
+    } else {
+      const dateOp = sortDirection === "asc" ? "lt" : "gt";
+      const pendingWithPositions = await Promise.all(
+        ownPendingAll.map(async (p, i) => {
+          const approvedBefore = await adapter.count({
+            model: "comment",
+            where: [
+              ...baseConditions,
+              { field: "status", value: "approved", operator: "eq" },
+              {
+                field: "createdAt",
+                value: p.createdAt,
+                operator: dateOp
+              }
+            ]
+          });
+          return { comment: p, mergedPosition: approvedBefore + i };
+        })
+      );
+      const pendingInWindow = pendingWithPositions.filter(
+        ({ mergedPosition }) => mergedPosition >= offset && mergedPosition < offset + limit
+      );
+      const countPendingBeforeWindow = pendingWithPositions.filter(
+        ({ mergedPosition }) => mergedPosition < offset
+      ).length;
+      const approvedOffset = Math.max(0, offset - countPendingBeforeWindow);
+      const approvedLimit = limit - pendingInWindow.length;
+      const approvedPage = approvedLimit > 0 ? await adapter.findMany({
+        model: "comment",
+        limit: approvedLimit,
+        offset: approvedOffset,
+        where: [
+          ...baseConditions,
+          { field: "status", value: "approved", operator: "eq" }
+        ],
+        sortBy: { field: "createdAt", direction: sortDirection }
+      }) : [];
+      const merged = [
+        ...approvedPage,
+        ...pendingInWindow.map(({ comment }) => comment)
+      ];
+      merged.sort((a, b) => {
+        const diff = a.createdAt.getTime() - b.createdAt.getTime();
+        return sortDirection === "desc" ? -diff : diff;
+      });
+      comments = merged;
+    }
+  } else {
+    const where = [...baseConditions];
+    if (statusFilter !== null) {
+      where.push({
+        field: "status",
+        value: statusFilter,
+        operator: "eq"
+      });
+    }
+    const [found, count] = await Promise.all([
+      adapter.findMany({
+        model: "comment",
+        limit,
+        offset,
+        where,
+        sortBy: { field: "createdAt", direction: sortDirection }
+      }),
+      adapter.count({ model: "comment", where })
+    ]);
+    comments = found;
+    total = count;
+  }
+  const authorIds = comments.map((c) => c.authorId);
+  const authorMap = await resolveAuthors(authorIds, resolveUser);
+  const likedCommentIds = /* @__PURE__ */ new Set();
+  if (params.currentUserId && comments.length > 0) {
+    const commentIds = comments.map((c) => c.id);
+    const likes = await Promise.all(
+      commentIds.map(
+        (commentId) => adapter.findOne({
+          model: "commentLike",
+          where: [
+            { field: "commentId", value: commentId, operator: "eq" },
+            {
+              field: "authorId",
+              value: params.currentUserId,
+              operator: "eq"
+            }
+          ]
+        })
+      )
+    );
+    likes.forEach((like, i) => {
+      if (like) likedCommentIds.add(commentIds[i]);
+    });
+  }
+  const replyCounts = /* @__PURE__ */ new Map();
+  const isTopLevelQuery = params.parentId === null || params.parentId === "null";
+  if (isTopLevelQuery && comments.length > 0) {
+    await Promise.all(
+      comments.map(async (c) => {
+        const approvedCount = await adapter.count({
+          model: "comment",
+          where: [
+            { field: "parentId", value: c.id, operator: "eq" },
+            { field: "status", value: "approved", operator: "eq" }
+          ]
+        });
+        let ownPendingCount = 0;
+        if (params.currentUserId) {
+          ownPendingCount = await adapter.count({
+            model: "comment",
+            where: [
+              { field: "parentId", value: c.id, operator: "eq" },
+              { field: "status", value: "pending", operator: "eq" },
+              {
+                field: "authorId",
+                value: params.currentUserId,
+                operator: "eq"
+              }
+            ]
+          });
+        }
+        replyCounts.set(c.id, approvedCount + ownPendingCount);
+      })
+    );
+  }
+  const items = comments.map(
+    (c) => enrichComment(c, authorMap, likedCommentIds, replyCounts.get(c.id) ?? 0)
+  );
+  return { items, total, limit, offset };
+}
+async function getCommentById(adapter, id, resolveUser, currentUserId) {
+  const comment = await adapter.findOne({
+    model: "comment",
+    where: [{ field: "id", value: id, operator: "eq" }]
+  });
+  if (!comment) return null;
+  const authorMap = await resolveAuthors([comment.authorId], resolveUser);
+  const likedCommentIds = /* @__PURE__ */ new Set();
+  if (currentUserId) {
+    const like = await adapter.findOne({
+      model: "commentLike",
+      where: [
+        { field: "commentId", value: id, operator: "eq" },
+        { field: "authorId", value: currentUserId, operator: "eq" }
+      ]
+    });
+    if (like) likedCommentIds.add(id);
+  }
+  return enrichComment(comment, authorMap, likedCommentIds);
+}
+async function getCommentCount(adapter, params) {
+  const whereConditions = [
+    { field: "resourceId", value: params.resourceId, operator: "eq" },
+    { field: "resourceType", value: params.resourceType, operator: "eq" }
+  ];
+  const statusFilter = params.status ?? "approved";
+  whereConditions.push({
+    field: "status",
+    value: statusFilter,
+    operator: "eq"
+  });
+  return adapter.count({ model: "comment", where: whereConditions });
+}
+
+export { getCommentById, getCommentCount, listComments };

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