captify 0.1.18 → 0.1.19

package/dist/comments/services/comments.service.js

@@ -0,0 +1,698 @@
+import { ATTACHMENT_URL_EXPIRY_SECONDS, DEFAULT_COMMENTS_LIMIT, DEFAULT_REPLIES_LIMIT, MAX_THREAD_DEPTH, MENTION_REGEX_GLOBAL, } from "../comments.constants";
+import { commentKeys } from "../../db/schemas";
+import { AttachmentNotFoundError, CommentNotFoundError, CommentUnauthorizedError, ParentCommentNotFoundError, ThreadDepthExceededError, } from "../comments.errors";
+import { createCommentSchema, deleteAttachmentSchema, deleteCommentSchema, getThreadedCommentsSchema, listCommentsSchema, listRepliesSchema, updateCommentSchema, } from "../comments.schemas";
+import { BaseAwsService } from "../../shared/services/base-aws-service";
+import { TABLE_INDEXES, TABLES } from "../../shared/shared.constants";
+export class CommentsService extends BaseAwsService {
+    constructor(db, s3, logger, config = {}) {
+        var _a, _b;
+        super({ logger, serviceName: "CommentsService" });
+        this.db = db;
+        this.s3 = s3;
+        this.tableName = (_a = config.tableName) !== null && _a !== void 0 ? _a : TABLES.comments;
+        this.defaultPageSize = (_b = config.defaultPageSize) !== null && _b !== void 0 ? _b : DEFAULT_COMMENTS_LIMIT;
+    }
+    /* ====================================================== */
+    /* CRUD Operations                                        */
+    /* ====================================================== */
+    /* Create a new comment --------------------------------- */
+    async createComment(params, options) {
+        var _a;
+        // Validate all inputs using Zod schema
+        const validated = createCommentSchema.parse(params);
+        this.logger.info("Creating comment", {
+            tenantId: validated.tenantId,
+            entityId: validated.entityId,
+            entityType: validated.entityType,
+            parentId: validated.parentId,
+            createdById: validated.createdById,
+        });
+        // Generate unique ID and timestamp
+        const commentId = crypto.randomUUID();
+        const createdAt = Date.now();
+        // Calculate thread depth based on parent
+        let threadDepth = 0;
+        if (validated.parentId) {
+            // Fetch parent comment to validate it exists and get its depth
+            // Pass entity context for efficient query (parent is in same entity)
+            const parentComment = await this.getCommentById(validated.tenantId, validated.parentId, validated.entityType, validated.entityId, options);
+            if (!parentComment) {
+                throw new ParentCommentNotFoundError(validated.parentId);
+            }
+            // Validate thread depth doesn't exceed maximum
+            if (parentComment.threadDepth >= MAX_THREAD_DEPTH) {
+                throw new ThreadDepthExceededError(MAX_THREAD_DEPTH);
+            }
+            threadDepth = parentComment.threadDepth + 1;
+        }
+        // Parse mentions from content
+        const mentions = this.parseMentions(validated.content);
+        const metadata = (_a = validated.metadata) !== null && _a !== void 0 ? _a : null;
+        // Build attachment objects with full metadata
+        const attachments = (validated.attachments || []).map((att) => ({
+            id: att.id,
+            commentId,
+            fileName: att.fileName,
+            fileType: att.fileType,
+            fileSize: att.fileSize,
+            s3Key: att.s3Key,
+            bucket: att.bucket,
+            uploadedAt: createdAt,
+            uploadedBy: validated.createdById,
+        }));
+        // Build Db item using standardized key builders from schema
+        const pk = commentKeys.pk(validated.tenantId, validated.createdById, validated.entityType, validated.entityId);
+        const sk = commentKeys.sk(createdAt, commentId);
+        const dynamoItem = {
+            PK: pk,
+            SK: sk,
+            GSI3PK: commentKeys.gsi3Pk(validated.tenantId, validated.entityType, validated.entityId),
+            GSI3SK: commentKeys.gsi3Sk(createdAt, commentId),
+            id: commentId,
+            tenantId: validated.tenantId,
+            entityId: validated.entityId,
+            entityType: validated.entityType,
+            createdById: validated.createdById,
+            authorName: validated.authorName,
+            authorEmail: validated.authorEmail,
+            authorAvatar: validated.authorAvatar,
+            content: validated.content,
+            attachments: JSON.stringify(attachments),
+            mentions: JSON.stringify(mentions),
+            metadata: metadata ? JSON.stringify(metadata) : undefined,
+            threadDepth,
+            replyCount: 0,
+            createdAt,
+            updatedAt: createdAt,
+            isEdited: false,
+        };
+        // Add parent-related fields for replies
+        if (validated.parentId) {
+            dynamoItem.parentId = validated.parentId;
+            dynamoItem.GSI1PK = commentKeys.gsi1Pk(validated.tenantId, validated.parentId);
+            dynamoItem.GSI1SK = commentKeys.gsi1Sk(createdAt, commentId);
+        }
+        // Add author index for listing user's comments
+        dynamoItem.GSI2PK = commentKeys.gsi2Pk(validated.tenantId, validated.createdById);
+        dynamoItem.GSI2SK = commentKeys.gsi2Sk(createdAt, commentId);
+        // Save to Db
+        await this.db.putItem(dynamoItem, {
+            tableName: this.tableName,
+            userCredentials: options === null || options === void 0 ? void 0 : options.userCredentials,
+        });
+        // If this is a reply, increment parent's reply count
+        if (validated.parentId) {
+            await this.incrementParentReplyCount(validated.tenantId, validated.parentId, validated.entityType, validated.entityId, options);
+        }
+        this.logger.info("Created comment", {
+            commentId,
+            tenantId: validated.tenantId,
+            entityId: validated.entityId,
+            parentId: validated.parentId,
+        });
+        // Return the created comment
+        return this.dynamoItemToComment(dynamoItem);
+    }
+    /* Update an existing comment --------------------------- */
+    async updateComment(params, options) {
+        var _a, _b, _c;
+        // Validate all inputs using Zod schema
+        const validated = updateCommentSchema.parse(params);
+        this.logger.info("Updating comment", {
+            tenantId: validated.tenantId,
+            commentId: validated.commentId,
+            userId: validated.userId,
+        });
+        // First, find the comment Db item to get PK/SK and verify ownership
+        // Note: We don't use Limit with scan+filter because Limit applies before filtering
+        const scanResult = await this.db.scanItems({
+            FilterExpression: "id = :id AND tenantId = :tenantId",
+            ExpressionAttributeValues: {
+                ":id": validated.commentId,
+                ":tenantId": validated.tenantId,
+            },
+        }, { tableName: this.tableName, userCredentials: options === null || options === void 0 ? void 0 : options.userCredentials });
+        if (!scanResult.Items || scanResult.Items.length === 0) {
+            throw new CommentNotFoundError(validated.commentId);
+        }
+        const existingItem = scanResult.Items[0];
+        // Check if user is the author (only author can edit their own comment)
+        if (existingItem.createdById !== validated.userId) {
+            throw new CommentUnauthorizedError("edit");
+        }
+        // Check if comment is deleted
+        if (existingItem.isDeleted) {
+            throw new CommentNotFoundError(validated.commentId);
+        }
+        // Build update expression
+        const updateExpressions = [];
+        const expressionAttributeValues = {};
+        const expressionAttributeNames = {};
+        // Update content if provided
+        if (validated.content !== undefined) {
+            updateExpressions.push("#content = :content");
+            expressionAttributeNames["#content"] = "content";
+            expressionAttributeValues[":content"] = validated.content;
+            // Update mentions if content changed
+            const mentions = this.parseMentions(validated.content);
+            updateExpressions.push("mentions = :mentions");
+            expressionAttributeValues[":mentions"] = JSON.stringify(mentions);
+        }
+        if (validated.metadata !== undefined) {
+            updateExpressions.push("#metadata = :metadata");
+            expressionAttributeNames["#metadata"] = "metadata";
+            expressionAttributeValues[":metadata"] = JSON.stringify((_a = validated.metadata) !== null && _a !== void 0 ? _a : {});
+        }
+        // Update attachments if provided
+        const existingAttachments = JSON.parse(existingItem.attachments || "[]");
+        const existingAttachmentMap = new Map(existingAttachments.map((att) => [
+            att.id,
+            { uploadedAt: att.uploadedAt, uploadedBy: att.uploadedBy },
+        ]));
+        // Set updated timestamp
+        const updatedAt = Date.now();
+        if (validated.attachments !== undefined) {
+            const attachments = validated.attachments.map((att) => {
+                var _a, _b;
+                // Preserve original metadata for existing attachments
+                const existing = existingAttachmentMap.get(att.id);
+                return {
+                    id: att.id,
+                    commentId: validated.commentId,
+                    fileName: att.fileName,
+                    fileType: att.fileType,
+                    fileSize: att.fileSize,
+                    s3Key: att.s3Key,
+                    bucket: att.bucket,
+                    uploadedAt: (_a = existing === null || existing === void 0 ? void 0 : existing.uploadedAt) !== null && _a !== void 0 ? _a : updatedAt,
+                    uploadedBy: (_b = existing === null || existing === void 0 ? void 0 : existing.uploadedBy) !== null && _b !== void 0 ? _b : validated.userId,
+                };
+            });
+            updateExpressions.push("attachments = :attachments");
+            expressionAttributeValues[":attachments"] = JSON.stringify(attachments);
+        }
+        updateExpressions.push("updatedAt = :updatedAt");
+        expressionAttributeValues[":updatedAt"] = updatedAt;
+        // Set modifiedById
+        updateExpressions.push("modifiedById = :modifiedById");
+        expressionAttributeValues[":modifiedById"] = validated.userId;
+        // Mark as edited
+        updateExpressions.push("isEdited = :isEdited");
+        expressionAttributeValues[":isEdited"] = true;
+        // Perform the update using existing PK/SK
+        await this.db.updateItem({ PK: existingItem.PK, SK: existingItem.SK }, `SET ${updateExpressions.join(", ")}`, Object.keys(expressionAttributeNames).length > 0 ? expressionAttributeNames : undefined, expressionAttributeValues, { tableName: this.tableName, userCredentials: options === null || options === void 0 ? void 0 : options.userCredentials });
+        this.logger.info("Updated comment", {
+            commentId: validated.commentId,
+            tenantId: validated.tenantId,
+            userId: validated.userId,
+        });
+        // Return updated comment
+        const existingComment = this.dynamoItemToComment(existingItem);
+        // Build updated attachments if provided, preserving original metadata for existing attachments
+        const updatedAttachments = validated.attachments
+            ? validated.attachments.map((att) => {
+                var _a, _b;
+                const existing = existingAttachmentMap.get(att.id);
+                return {
+                    id: att.id,
+                    commentId: validated.commentId,
+                    fileName: att.fileName,
+                    fileType: att.fileType,
+                    fileSize: att.fileSize,
+                    s3Key: att.s3Key,
+                    bucket: att.bucket,
+                    uploadedAt: (_a = existing === null || existing === void 0 ? void 0 : existing.uploadedAt) !== null && _a !== void 0 ? _a : updatedAt,
+                    uploadedBy: (_b = existing === null || existing === void 0 ? void 0 : existing.uploadedBy) !== null && _b !== void 0 ? _b : validated.userId,
+                };
+            })
+            : existingComment.attachments;
+        return Object.assign(Object.assign({}, existingComment), { content: (_b = validated.content) !== null && _b !== void 0 ? _b : existingComment.content, attachments: updatedAttachments, metadata: validated.metadata !== undefined ? ((_c = validated.metadata) !== null && _c !== void 0 ? _c : {}) : existingComment.metadata, mentions: validated.content
+                ? this.parseMentions(validated.content)
+                : existingComment.mentions, isEdited: true, updatedAt });
+    }
+    /* Delete a comment (soft delete) ----------------------- */
+    async deleteComment(params, options) {
+        // Validate all inputs using Zod schema
+        const validated = deleteCommentSchema.parse(params);
+        const { userId } = params;
+        this.logger.info("Deleting comment", {
+            tenantId: validated.tenantId,
+            commentId: validated.commentId,
+            userId,
+        });
+        // First, find the comment Db item to get PK/SK and verify ownership
+        // Note: We don't use Limit with scan+filter because Limit applies before filtering
+        const scanResult = await this.db.scanItems({
+            FilterExpression: "id = :id AND tenantId = :tenantId",
+            ExpressionAttributeValues: {
+                ":id": validated.commentId,
+                ":tenantId": validated.tenantId,
+            },
+        }, { tableName: this.tableName, userCredentials: options === null || options === void 0 ? void 0 : options.userCredentials });
+        if (!scanResult.Items || scanResult.Items.length === 0) {
+            throw new CommentNotFoundError(validated.commentId);
+        }
+        const existingItem = scanResult.Items[0];
+        // Check if already deleted
+        if (existingItem.isDeleted) {
+            throw new CommentNotFoundError(validated.commentId);
+        }
+        // Check authorization: only author can delete their own comment
+        if (existingItem.createdById !== userId) {
+            throw new CommentUnauthorizedError("delete");
+        }
+        // Parse and delete attachments from S3
+        const attachments = JSON.parse(existingItem.attachments || "[]");
+        if (attachments.length > 0) {
+            this.logger.info("Deleting comment attachments from S3", {
+                commentId: validated.commentId,
+                attachmentCount: attachments.length,
+            });
+            for (const attachment of attachments) {
+                try {
+                    if (attachment.s3Key) {
+                        await this.s3.deleteFile({
+                            key: attachment.s3Key,
+                            userCredentials: options === null || options === void 0 ? void 0 : options.userCredentials,
+                        });
+                    }
+                }
+                catch (error) {
+                    // Log but don't fail - continue deleting other attachments
+                    this.logger.warn("Failed to delete attachment file from S3", {
+                        s3Key: attachment.s3Key,
+                        error: error instanceof Error ? error.message : "Unknown error",
+                    });
+                }
+            }
+        }
+        // Soft delete: set isDeleted flag, replace content, and clear attachments and mentions
+        await this.db.updateItem({ PK: existingItem.PK, SK: existingItem.SK }, "SET isDeleted = :isDeleted, #content = :content, attachments = :attachments, mentions = :mentions, updatedAt = :updatedAt, modifiedById = :modifiedById", { "#content": "content" }, {
+            ":isDeleted": true,
+            ":content": "[deleted]",
+            ":attachments": "[]",
+            ":mentions": "[]",
+            ":updatedAt": Date.now(),
+            ":modifiedById": userId,
+        }, { tableName: this.tableName, userCredentials: options === null || options === void 0 ? void 0 : options.userCredentials });
+        this.logger.info("Deleted comment", {
+            commentId: validated.commentId,
+            tenantId: validated.tenantId,
+            userId,
+            attachmentsDeleted: attachments.length,
+        });
+    }
+    /* Delete an attachment from a comment ------------------ */
+    async deleteAttachment(params, options) {
+        // Validate all inputs using Zod schema
+        const validated = deleteAttachmentSchema.parse(params);
+        this.logger.info("Deleting attachment", {
+            tenantId: validated.tenantId,
+            commentId: validated.commentId,
+            attachmentId: validated.attachmentId,
+            userId: validated.userId,
+        });
+        // First, find the comment Db item to get PK/SK and verify ownership
+        const scanResult = await this.db.scanItems({
+            FilterExpression: "id = :id AND tenantId = :tenantId",
+            ExpressionAttributeValues: {
+                ":id": validated.commentId,
+                ":tenantId": validated.tenantId,
+            },
+        }, { tableName: this.tableName, userCredentials: options === null || options === void 0 ? void 0 : options.userCredentials });
+        if (!scanResult.Items || scanResult.Items.length === 0) {
+            throw new CommentNotFoundError(validated.commentId);
+        }
+        const existingItem = scanResult.Items[0];
+        // Check if comment is deleted
+        if (existingItem.isDeleted) {
+            throw new CommentNotFoundError(validated.commentId);
+        }
+        // Check if user is the author (only author can delete attachments)
+        if (existingItem.createdById !== validated.userId) {
+            throw new CommentUnauthorizedError("delete attachment");
+        }
+        // Parse existing attachments
+        const attachments = JSON.parse(existingItem.attachments || "[]");
+        // Find the attachment to delete
+        const attachmentIndex = attachments.findIndex((att) => att.id === validated.attachmentId);
+        if (attachmentIndex === -1) {
+            throw new AttachmentNotFoundError(validated.attachmentId);
+        }
+        const attachmentToDelete = attachments[attachmentIndex];
+        // Remove the attachment from the array
+        attachments.splice(attachmentIndex, 1);
+        // Update the comment with the new attachments list
+        const now = Date.now();
+        await this.db.updateItem({ PK: existingItem.PK, SK: existingItem.SK }, "SET attachments = :attachments, updatedAt = :updatedAt, modifiedById = :modifiedById", undefined, {
+            ":attachments": JSON.stringify(attachments),
+            ":updatedAt": now,
+            ":modifiedById": validated.userId,
+        }, { tableName: this.tableName, userCredentials: options === null || options === void 0 ? void 0 : options.userCredentials });
+        // Delete the file from S3 (optional - don't fail if S3 delete fails)
+        try {
+            if (attachmentToDelete.s3Key) {
+                await this.s3.deleteFile({
+                    key: attachmentToDelete.s3Key,
+                    userCredentials: options === null || options === void 0 ? void 0 : options.userCredentials,
+                });
+                this.logger.info("Deleted attachment file from S3", {
+                    s3Key: attachmentToDelete.s3Key,
+                });
+            }
+        }
+        catch (error) {
+            // Log but don't fail - the attachment reference is already removed
+            this.logger.warn("Failed to delete attachment file from S3", {
+                s3Key: attachmentToDelete.s3Key,
+                error: error instanceof Error ? error.message : "Unknown error",
+            });
+        }
+        this.logger.info("Deleted attachment", {
+            commentId: validated.commentId,
+            attachmentId: validated.attachmentId,
+            tenantId: validated.tenantId,
+        });
+        // Return updated comment
+        const updatedComment = this.dynamoItemToComment(Object.assign(Object.assign({}, existingItem), { attachments: JSON.stringify(attachments), updatedAt: now }));
+        return updatedComment;
+    }
+    /* ====================================================== */
+    /* List Operation                                         */
+    /* ====================================================== */
+    /* List comments for an entry --------------------------- */
+    async listComments(params, options) {
+        var _a, _b, _c;
+        // Validate all inputs using Zod schema
+        const validated = listCommentsSchema.parse(params);
+        this.logger.debug("Listing comments", {
+            tenantId: validated.tenantId,
+            entityId: validated.entityId,
+            entityType: validated.entityType,
+        });
+        const limit = (_a = validated.limit) !== null && _a !== void 0 ? _a : this.defaultPageSize;
+        const entityType = (_b = validated.entityType) !== null && _b !== void 0 ? _b : "custom";
+        // Build filter expression to find comments for this entity
+        // Using scan with filter since PK now includes userId (use ByEntity GSI for better performance)
+        let filterExpression = "tenantId = :tenantId AND entityId = :entityId AND entityType = :entityType";
+        const expressionAttributeValues = {
+            ":tenantId": validated.tenantId,
+            ":entityId": validated.entityId,
+            ":entityType": entityType,
+        };
+        // Filter for root comments only (no parent)
+        if (validated.rootOnly) {
+            filterExpression += " AND (attribute_not_exists(parentId) OR parentId = :null)";
+            expressionAttributeValues[":null"] = null;
+        }
+        // Filter out deleted comments
+        filterExpression += " AND (attribute_not_exists(isDeleted) OR isDeleted = :false)";
+        expressionAttributeValues[":false"] = false;
+        // When using FilterExpression with scan, Limit applies to scanned items, not returned items.
+        // We need to keep fetching until we have enough filtered results.
+        const collectedItems = [];
+        let lastEvaluatedKey = validated.cursor
+            ? JSON.parse(Buffer.from(validated.cursor, "base64").toString())
+            : undefined;
+        let hasMoreData = true;
+        // Keep scanning until we have enough items or no more data
+        while (collectedItems.length < limit + 1 && hasMoreData) {
+            const result = await this.db.scanItems({
+                FilterExpression: filterExpression,
+                ExpressionAttributeValues: expressionAttributeValues,
+                // Fetch more items per scan to reduce round trips
+                Limit: Math.max((limit + 1 - collectedItems.length) * 10, 100),
+                ExclusiveStartKey: lastEvaluatedKey,
+            }, { tableName: this.tableName, userCredentials: options === null || options === void 0 ? void 0 : options.userCredentials });
+            collectedItems.push(...((_c = result.Items) !== null && _c !== void 0 ? _c : []));
+            lastEvaluatedKey = result.LastEvaluatedKey;
+            hasMoreData = Boolean(lastEvaluatedKey);
+        }
+        // Sort items by createdAt (scan doesn't guarantee order)
+        collectedItems.sort((a, b) => {
+            const comparison = a.createdAt - b.createdAt;
+            return validated.sortOrder === "desc" ? -comparison : comparison;
+        });
+        // Take only what we need
+        const itemsToReturn = collectedItems.slice(0, limit);
+        const comments = itemsToReturn.map((item) => this.dynamoItemToComment(item));
+        // generate signed URLs for attachments
+        await this.populateAttachmentUrls(comments, options);
+        // Determine if there are more items
+        const hasMore = collectedItems.length > limit || hasMoreData;
+        let nextCursor;
+        if (hasMore && itemsToReturn.length > 0) {
+            // Use the last returned item's key as cursor
+            const lastReturnedItem = itemsToReturn[itemsToReturn.length - 1];
+            const cursorKey = {
+                PK: lastReturnedItem.PK,
+                SK: lastReturnedItem.SK,
+            };
+            nextCursor = Buffer.from(JSON.stringify(cursorKey)).toString("base64");
+        }
+        return {
+            comments,
+            nextCursor,
+            hasMore,
+        };
+    }
+    /* List replies to a comment ---------------------------- */
+    async listReplies(params, options) {
+        var _a, _b;
+        // Validate all inputs using Zod schema
+        const validated = listRepliesSchema.parse(params);
+        this.logger.debug("Listing replies", {
+            tenantId: validated.tenantId,
+            parentId: validated.parentId,
+        });
+        const limit = (_a = validated.limit) !== null && _a !== void 0 ? _a : DEFAULT_REPLIES_LIMIT;
+        // When using FilterExpression, Db's Limit applies to scanned items, not returned items.
+        // We need to keep fetching until we have enough filtered results.
+        const collectedItems = [];
+        let lastEvaluatedKey = validated.cursor
+            ? JSON.parse(Buffer.from(validated.cursor, "base64").toString())
+            : undefined;
+        let hasMoreData = true;
+        // Keep querying until we have enough items or no more data
+        while (collectedItems.length < limit + 1 && hasMoreData) {
+            const result = await this.db.queryTyped({
+                index: TABLE_INDEXES.comments.ByParent,
+                keyCondition: { GSI1PK: commentKeys.gsi1Pk(validated.tenantId, validated.parentId) },
+                filterExpression: "attribute_not_exists(isDeleted) OR isDeleted = :false",
+                expressionAttributeValues: {
+                    ":false": false,
+                },
+                // Fetch more items per query to reduce round trips (but cap at reasonable amount)
+                limit: Math.max((limit + 1 - collectedItems.length) * 5, 50),
+                exclusiveStartKey: lastEvaluatedKey,
+                scanIndexForward: validated.sortOrder !== "desc",
+            }, { tableName: this.tableName, userCredentials: options === null || options === void 0 ? void 0 : options.userCredentials });
+            collectedItems.push(...((_b = result.items) !== null && _b !== void 0 ? _b : []));
+            lastEvaluatedKey = result.lastEvaluatedKey;
+            hasMoreData = Boolean(lastEvaluatedKey);
+        }
+        // Take only what we need
+        const itemsToReturn = collectedItems.slice(0, limit);
+        const comments = itemsToReturn.map((item) => this.dynamoItemToComment(item));
+        await this.populateAttachmentUrls(comments, options);
+        // Determine if there are more items
+        const hasMore = collectedItems.length > limit || hasMoreData;
+        let nextCursor;
+        if (hasMore && itemsToReturn.length > 0) {
+            // Use the last returned item's key as cursor (need GSI keys for index-based pagination)
+            // Db's ExclusiveStartKey returns items AFTER this key
+            const lastReturnedItem = itemsToReturn[itemsToReturn.length - 1];
+            const cursorKey = {
+                PK: lastReturnedItem.PK,
+                SK: lastReturnedItem.SK,
+                GSI1PK: lastReturnedItem.GSI1PK,
+                GSI1SK: lastReturnedItem.GSI1SK,
+            };
+            nextCursor = Buffer.from(JSON.stringify(cursorKey)).toString("base64");
+        }
+        return {
+            comments,
+            nextCursor,
+            hasMore,
+        };
+    }
+    /* Get comments as threaded structure ------------------- */
+    async getThreadedComments(params, options) {
+        var _a, _b;
+        // Validate all inputs using Zod schema
+        const validated = getThreadedCommentsSchema.parse(params);
+        this.logger.debug("Getting threaded comments", {
+            tenantId: validated.tenantId,
+            entityId: validated.entityId,
+            entityType: validated.entityType,
+        });
+        // First get all root comments with pagination
+        const rootResult = await this.listComments({
+            tenantId: validated.tenantId,
+            entityId: validated.entityId,
+            entityType: validated.entityType,
+            rootOnly: true,
+            limit: (_a = validated.limit) !== null && _a !== void 0 ? _a : this.defaultPageSize,
+            sortOrder: (_b = validated.sortOrder) !== null && _b !== void 0 ? _b : "desc",
+            cursor: validated.cursor,
+        }, options);
+        // Recursively load replies for comments up to MAX_THREAD_DEPTH
+        const loadRepliesRecursively = async (comment, currentDepth) => {
+            // Stop recursion at max depth
+            if (currentDepth >= MAX_THREAD_DEPTH) {
+                return Object.assign(Object.assign({}, comment), { replies: [], hasMoreReplies: comment.replyCount > 0, repliesCursor: undefined });
+            }
+            const repliesResult = await this.listReplies({
+                tenantId: validated.tenantId,
+                parentId: comment.id,
+                limit: DEFAULT_REPLIES_LIMIT,
+                sortOrder: "asc",
+            }, options);
+            // Recursively load nested replies
+            const replyThreads = await Promise.all(repliesResult.comments.map((reply) => loadRepliesRecursively(reply, currentDepth + 1)));
+            return Object.assign(Object.assign({}, comment), { replies: replyThreads, hasMoreReplies: repliesResult.hasMore, repliesCursor: repliesResult.nextCursor });
+        };
+        // Load replies for each root comment
+        const threads = await Promise.all(rootResult.comments.map((comment) => loadRepliesRecursively(comment, 0)));
+        return {
+            comments: threads,
+            nextCursor: rootResult.nextCursor,
+            hasMore: rootResult.hasMore,
+        };
+    }
+    /* ====================================================== */
+    /* Private Helper Function                                */
+    /* ====================================================== */
+    dynamoItemToComment(item) {
+        return {
+            id: item.id,
+            entityId: item.entityId,
+            entityType: item.entityType,
+            parentId: item.parentId,
+            author: {
+                id: item.createdById,
+                name: item.authorName,
+                email: item.authorEmail,
+                avatarUrl: item.authorAvatar,
+            },
+            content: item.content,
+            attachments: JSON.parse(item.attachments || "[]"),
+            mentions: JSON.parse(item.mentions || "[]"),
+            metadata: item.metadata ? JSON.parse(item.metadata) : undefined,
+            threadDepth: item.threadDepth,
+            replyCount: item.replyCount,
+            createdAt: item.createdAt,
+            updatedAt: item.updatedAt,
+            isEdited: item.isEdited,
+            isDeleted: item.isDeleted,
+        };
+    }
+    async populateAttachmentUrls(comments, options) {
+        for (const comment of comments) {
+            for (const attachment of comment.attachments) {
+                // Pass fileName to set Content-Disposition: attachment header (forces download)
+                attachment.downloadUrl = await this.getAttachmentUrl(attachment.s3Key, attachment.fileName, options);
+            }
+        }
+    }
+    /**
+     * Get a comment by its ID within an entity context
+     * Uses scan with filter to find the comment
+     */
+    async getCommentById(tenantId, commentId, entityType, entityId, options) {
+        this.logger.debug("Getting comment by ID", { tenantId, commentId, entityType, entityId });
+        // Build filter expression - always filter by id and tenantId
+        let filterExpression = "id = :id AND tenantId = :tenantId";
+        const expressionAttributeValues = {
+            ":id": commentId,
+            ":tenantId": tenantId,
+        };
+        // Add entity context to filter if provided (more specific query)
+        if (entityType && entityId) {
+            filterExpression += " AND entityType = :entityType AND entityId = :entityId";
+            expressionAttributeValues[":entityType"] = entityType;
+            expressionAttributeValues[":entityId"] = entityId;
+        }
+        const result = await this.db.scanItems({
+            FilterExpression: filterExpression,
+            ExpressionAttributeValues: expressionAttributeValues,
+        }, { tableName: this.tableName, userCredentials: options === null || options === void 0 ? void 0 : options.userCredentials });
+        if (!result.Items || result.Items.length === 0) {
+            return null;
+        }
+        return this.dynamoItemToComment(result.Items[0]);
+    }
+    /**
+     * Parse @mentions from comment content
+     * Extracts mention positions and maps them to user IDs
+     * Matches the format: ___@[Display Name](userId)___ (with delimiters)
+     */
+    parseMentions(content) {
+        const mentions = [];
+        // Use matchAll with pre-compiled global regex (avoids dynamic regex construction)
+        for (const match of content.matchAll(MENTION_REGEX_GLOBAL)) {
+            const userName = match[1];
+            const userId = match[2];
+            mentions.push({
+                userId,
+                userName,
+                startIndex: match.index,
+                endIndex: match.index + match[0].length,
+            });
+        }
+        return mentions;
+    }
+    /**
+     * Increment the reply count of a parent comment
+     * Called when a new reply is added
+     */
+    async incrementParentReplyCount(tenantId, parentId, entityType, entityId, options) {
+        try {
+            this.logger.debug("Incrementing reply count for parent", { parentId, entityType, entityId });
+            // Find parent comment using scan with filter
+            const result = await this.db.scanItems({
+                FilterExpression: "id = :id AND tenantId = :tenantId AND entityType = :entityType AND entityId = :entityId",
+                ExpressionAttributeValues: {
+                    ":id": parentId,
+                    ":tenantId": tenantId,
+                    ":entityType": entityType,
+                    ":entityId": entityId,
+                },
+            }, { tableName: this.tableName, userCredentials: options === null || options === void 0 ? void 0 : options.userCredentials });
+            if (result.Items && result.Items.length > 0) {
+                const parentItem = result.Items[0];
+                await this.db.updateItem({ PK: parentItem.PK, SK: parentItem.SK }, "SET replyCount = if_not_exists(replyCount, :zero) + :inc", undefined, { ":inc": 1, ":zero": 0 }, { tableName: this.tableName, userCredentials: options === null || options === void 0 ? void 0 : options.userCredentials });
+            }
+            else {
+                this.logger.warn("Parent comment not found for reply count update", { parentId });
+            }
+        }
+        catch (error) {
+            // Log but don't fail the create operation if reply count update fails
+            this.logger.warn("Failed to increment parent reply count", {
+                parentId,
+                error: error instanceof Error ? error.message : "Unknown error",
+            });
+        }
+    }
+    /**
+     * Get signed download URL for an attachment
+     * @param s3Key - The S3 object key
+     * @param fileName - Original filename for Content-Disposition header (forces download)
+     * @param options - Operation options including userCredentials
+     */
+    async getAttachmentUrl(s3Key, fileName, options) {
+        return this.s3.generateSignedUrl({
+            key: s3Key,
+            operation: "getObject",
+            expiresIn: ATTACHMENT_URL_EXPIRY_SECONDS,
+            // Set Content-Disposition: attachment to force download instead of display
+            responseContentDisposition: fileName
+                ? `attachment; filename="${encodeURIComponent(fileName)}"`
+                : undefined,
+            userCredentials: options === null || options === void 0 ? void 0 : options.userCredentials,
+        });
+    }
+}
+//# sourceMappingURL=comments.service.js.map