@rudderhq/server 0.2.5-canary.9 → 0.2.5

package/dist/services/issues.js

@@ -1,278 +1,14 @@
 import { and, asc, desc, eq, inArray, isNull, ne, or, sql } from "drizzle-orm";
-import { activityLog, agents, assets, organizations, organizationMemberships, documents, goals, heartbeatRuns, executionWorkspaces, issueAttachments, issueFollows, issueLabels, issueComments, issueDocuments, issueReadStates, issues, labels, projectWorkspaces, projects, } from "@rudderhq/db";
-import { extractAgentMentionIds, extractProjectMentionIds, isUuidLike, } from "@rudderhq/shared";
+import { agents, assets, organizations, organizationMemberships, documents, goals, heartbeatRuns, executionWorkspaces, issueAttachments, issueFollows, issueLabels, issueComments, issueDocuments, issueReadStates, issues, labels, projectWorkspaces, projects, } from "@rudderhq/db";
 import { conflict, notFound, unprocessable } from "../errors.js";
 import { defaultIssueExecutionWorkspaceSettingsForProject, parseProjectExecutionWorkspacePolicy, } from "./execution-workspace-policy.js";
 import { instanceSettingsService } from "./instance-settings.js";
 import { redactCurrentUserText } from "../log-redaction.js";
 import { resolveIssueGoalId, resolveNextIssueGoalId } from "./issue-goal-fallback.js";
 import { getDefaultCompanyGoal } from "./goals.js";
-const ALL_ISSUE_STATUSES = ["backlog", "todo", "in_progress", "in_review", "blocked", "done", "cancelled"];
-const MAX_ISSUE_COMMENT_PAGE_LIMIT = 500;
-const BOARD_ORDER_STEP = 1000;
-function isUniqueConstraintConflict(error, constraintName) {
-    return (typeof error === "object" &&
-        error !== null &&
-        "code" in error &&
-        error.code === "23505" &&
-        "constraint" in error &&
-        error.constraint === constraintName);
-}
-function assertTransition(from, to) {
-    if (from === to)
-        return;
-    if (!ALL_ISSUE_STATUSES.includes(to)) {
-        throw conflict(`Unknown issue status: ${to}`);
-    }
-}
-function applyStatusSideEffects(status, patch) {
-    if (!status)
-        return patch;
-    if (status === "in_progress" && !patch.startedAt) {
-        patch.startedAt = new Date();
-    }
-    if (status === "done") {
-        patch.completedAt = new Date();
-    }
-    if (status === "cancelled") {
-        patch.cancelledAt = new Date();
-    }
-    return patch;
-}
-function sameRunLock(checkoutRunId, actorRunId) {
-    if (actorRunId)
-        return checkoutRunId === actorRunId;
-    return checkoutRunId == null;
-}
-const TERMINAL_HEARTBEAT_RUN_STATUSES = new Set(["succeeded", "failed", "cancelled", "timed_out"]);
-function escapeLikePattern(value) {
-    return value.replace(/[\\%_]/g, "\\$&");
-}
-function textContains(value, query) {
-    return Boolean(value && value.toLowerCase().includes(query.toLowerCase()));
-}
-function buildSearchSnippet(value, query, maxLength = 160) {
-    const compact = value.replace(/\s+/g, " ").trim();
-    if (compact.length <= maxLength)
-        return compact;
-    const index = compact.toLowerCase().indexOf(query.toLowerCase());
-    if (index < 0)
-        return `${compact.slice(0, maxLength - 1).trimEnd()}…`;
-    const context = Math.max(20, Math.floor((maxLength - query.length) / 2));
-    const start = Math.max(0, index - context);
-    const end = Math.min(compact.length, start + maxLength);
-    const prefix = start > 0 ? "…" : "";
-    const suffix = end < compact.length ? "…" : "";
-    return `${prefix}${compact.slice(start, end).trim()}${suffix}`;
-}
-function fieldSearchMatch(row, query) {
-    if (textContains(row.identifier, query)) {
-        return { field: "identifier", snippet: buildSearchSnippet(row.identifier, query) };
-    }
-    if (textContains(row.title, query)) {
-        return { field: "title", snippet: buildSearchSnippet(row.title, query) };
-    }
-    if (textContains(row.description, query)) {
-        return { field: "description", snippet: buildSearchSnippet(row.description, query) };
-    }
-    return null;
-}
-function touchedByUserCondition(orgId, userId) {
-    return sql `
-    (
-      ${issues.createdByUserId} = ${userId}
-      OR ${issues.assigneeUserId} = ${userId}
-      OR ${issues.reviewerUserId} = ${userId}
-      OR EXISTS (
-        SELECT 1
-        FROM ${issueReadStates}
-        WHERE ${issueReadStates.issueId} = ${issues.id}
-          AND ${issueReadStates.orgId} = ${orgId}
-          AND ${issueReadStates.userId} = ${userId}
-      )
-      OR EXISTS (
-        SELECT 1
-        FROM ${issueComments}
-        WHERE ${issueComments.issueId} = ${issues.id}
-          AND ${issueComments.orgId} = ${orgId}
-          AND ${issueComments.authorUserId} = ${userId}
-      )
-    )
-  `;
-}
-function participatedByAgentCondition(orgId, agentId) {
-    return sql `
-    (
-      ${issues.createdByAgentId} = ${agentId}
-      OR ${issues.assigneeAgentId} = ${agentId}
-      OR ${issues.reviewerAgentId} = ${agentId}
-      OR EXISTS (
-        SELECT 1
-        FROM ${issueComments}
-        WHERE ${issueComments.issueId} = ${issues.id}
-          AND ${issueComments.orgId} = ${orgId}
-          AND ${issueComments.authorAgentId} = ${agentId}
-      )
-      OR EXISTS (
-        SELECT 1
-        FROM ${activityLog}
-        WHERE ${activityLog.orgId} = ${orgId}
-          AND ${activityLog.entityType} = 'issue'
-          AND ${activityLog.entityId} = ${issues.id}::text
-          AND ${activityLog.agentId} = ${agentId}
-      )
-    )
-  `;
-}
-function myLastCommentAtExpr(orgId, userId) {
-    return sql `
-    (
-      SELECT MAX(${issueComments.createdAt})
-      FROM ${issueComments}
-      WHERE ${issueComments.issueId} = ${issues.id}
-        AND ${issueComments.orgId} = ${orgId}
-        AND ${issueComments.authorUserId} = ${userId}
-    )
-  `;
-}
-function myLastReadAtExpr(orgId, userId) {
-    return sql `
-    (
-      SELECT MAX(${issueReadStates.lastReadAt})
-      FROM ${issueReadStates}
-      WHERE ${issueReadStates.issueId} = ${issues.id}
-        AND ${issueReadStates.orgId} = ${orgId}
-        AND ${issueReadStates.userId} = ${userId}
-    )
-  `;
-}
-function myLastTouchAtExpr(orgId, userId) {
-    const myLastCommentAt = myLastCommentAtExpr(orgId, userId);
-    const myLastReadAt = myLastReadAtExpr(orgId, userId);
-    return sql `
-    GREATEST(
-      COALESCE(${myLastCommentAt}, to_timestamp(0)),
-      COALESCE(${myLastReadAt}, to_timestamp(0)),
-      COALESCE(CASE WHEN ${issues.createdByUserId} = ${userId} THEN ${issues.createdAt} ELSE NULL END, to_timestamp(0)),
-      COALESCE(CASE WHEN ${issues.assigneeUserId} = ${userId} THEN ${issues.updatedAt} ELSE NULL END, to_timestamp(0)),
-      COALESCE(CASE WHEN ${issues.reviewerUserId} = ${userId} THEN ${issues.updatedAt} ELSE NULL END, to_timestamp(0))
-    )
-  `;
-}
-function unreadForUserCondition(orgId, userId) {
-    const touchedCondition = touchedByUserCondition(orgId, userId);
-    const myLastTouchAt = myLastTouchAtExpr(orgId, userId);
-    return sql `
-    (
-      ${touchedCondition}
-      AND EXISTS (
-        SELECT 1
-        FROM ${issueComments}
-        WHERE ${issueComments.issueId} = ${issues.id}
-          AND ${issueComments.orgId} = ${orgId}
-          AND (
-            ${issueComments.authorUserId} IS NULL
-            OR ${issueComments.authorUserId} <> ${userId}
-          )
-          AND ${issueComments.createdAt} > ${myLastTouchAt}
-      )
-    )
-  `;
-}
-export function deriveIssueUserContext(issue, userId, stats) {
-    const normalizeDate = (value) => {
-        if (!value)
-            return null;
-        if (value instanceof Date)
-            return Number.isNaN(value.getTime()) ? null : value;
-        const parsed = new Date(value);
-        return Number.isNaN(parsed.getTime()) ? null : parsed;
-    };
-    const myLastCommentAt = normalizeDate(stats?.myLastCommentAt);
-    const myLastReadAt = normalizeDate(stats?.myLastReadAt);
-    const createdTouchAt = issue.createdByUserId === userId ? normalizeDate(issue.createdAt) : null;
-    const assignedTouchAt = issue.assigneeUserId === userId ? normalizeDate(issue.updatedAt) : null;
-    const reviewerTouchAt = issue.reviewerUserId === userId ? normalizeDate(issue.updatedAt) : null;
-    const myLastTouchAt = [myLastCommentAt, myLastReadAt, createdTouchAt, assignedTouchAt, reviewerTouchAt]
-        .filter((value) => value instanceof Date)
-        .sort((a, b) => b.getTime() - a.getTime())[0] ?? null;
-    const lastExternalCommentAt = normalizeDate(stats?.lastExternalCommentAt);
-    const isUnreadForMe = Boolean(myLastTouchAt &&
-        lastExternalCommentAt &&
-        lastExternalCommentAt.getTime() > myLastTouchAt.getTime());
-    return {
-        myLastTouchAt,
-        lastExternalCommentAt,
-        isUnreadForMe,
-    };
-}
-async function labelMapForIssues(dbOrTx, issueIds) {
-    const map = new Map();
-    if (issueIds.length === 0)
-        return map;
-    const rows = await dbOrTx
-        .select({
-        issueId: issueLabels.issueId,
-        label: labels,
-    })
-        .from(issueLabels)
-        .innerJoin(labels, eq(issueLabels.labelId, labels.id))
-        .where(inArray(issueLabels.issueId, issueIds))
-        .orderBy(asc(labels.name), asc(labels.id));
-    for (const row of rows) {
-        const existing = map.get(row.issueId);
-        if (existing)
-            existing.push(row.label);
-        else
-            map.set(row.issueId, [row.label]);
-    }
-    return map;
-}
-async function withIssueLabels(dbOrTx, rows) {
-    if (rows.length === 0)
-        return [];
-    const labelsByIssueId = await labelMapForIssues(dbOrTx, rows.map((row) => row.id));
-    return rows.map((row) => {
-        const issueLabels = labelsByIssueId.get(row.id) ?? [];
-        return {
-            ...row,
-            labels: issueLabels,
-            labelIds: issueLabels.map((label) => label.id),
-        };
-    });
-}
-const ACTIVE_RUN_STATUSES = ["queued", "running"];
-async function activeRunMapForIssues(dbOrTx, issueRows) {
-    const map = new Map();
-    const runIds = issueRows
-        .map((row) => row.executionRunId)
-        .filter((id) => id != null);
-    if (runIds.length === 0)
-        return map;
-    const rows = await dbOrTx
-        .select({
-        id: heartbeatRuns.id,
-        status: heartbeatRuns.status,
-        agentId: heartbeatRuns.agentId,
-        invocationSource: heartbeatRuns.invocationSource,
-        triggerDetail: heartbeatRuns.triggerDetail,
-        startedAt: heartbeatRuns.startedAt,
-        finishedAt: heartbeatRuns.finishedAt,
-        createdAt: heartbeatRuns.createdAt,
-    })
-        .from(heartbeatRuns)
-        .where(and(inArray(heartbeatRuns.id, runIds), inArray(heartbeatRuns.status, ACTIVE_RUN_STATUSES)));
-    for (const row of rows) {
-        map.set(row.id, row);
-    }
-    return map;
-}
-function withActiveRuns(issueRows, runMap) {
-    return issueRows.map((row) => ({
-        ...row,
-        activeRun: row.executionRunId ? (runMap.get(row.executionRunId) ?? null) : null,
-    }));
-}
+import { BOARD_ORDER_STEP, isUniqueConstraintConflict, assertTransition, applyStatusSideEffects, sameRunLock, TERMINAL_HEARTBEAT_RUN_STATUSES, escapeLikePattern, buildSearchSnippet, fieldSearchMatch, touchedByUserCondition, participatedByAgentCondition, unreadForUserCondition, deriveIssueUserContext, withIssueLabels, activeRunMapForIssues, withActiveRuns, } from "./issues.helpers.js";
+import { createIssueCommentAttachmentMethods } from "./issues.comments-attachments.js";
+export { deriveIssueUserContext } from "./issues.helpers.js";
 export function issueService(db) {
     const instanceSettings = instanceSettingsService(db);
     function redactIssueComment(comment, censorUsernameInLogs) {
@@ -1374,307 +1110,7 @@ export function issueService(db) {
             .where(eq(labels.id, id))
             .returning()
             .then((rows) => rows[0] ?? null),
-        listComments: async (issueId, opts) => {
-            const order = opts?.order === "asc" ? "asc" : "desc";
-            const afterCommentId = opts?.afterCommentId?.trim() || null;
-            const limit = opts?.limit && opts.limit > 0
-                ? Math.min(Math.floor(opts.limit), MAX_ISSUE_COMMENT_PAGE_LIMIT)
-                : null;
-            const conditions = [eq(issueComments.issueId, issueId)];
-            if (afterCommentId) {
-                const anchor = await db
-                    .select({
-                    id: issueComments.id,
-                    createdAt: issueComments.createdAt,
-                })
-                    .from(issueComments)
-                    .where(and(eq(issueComments.issueId, issueId), eq(issueComments.id, afterCommentId)))
-                    .then((rows) => rows[0] ?? null);
-                if (!anchor)
-                    return [];
-                const anchorCreatedAt = anchor.createdAt instanceof Date
-                    ? anchor.createdAt.toISOString()
-                    : new Date(anchor.createdAt).toISOString();
-                conditions.push(order === "asc"
-                    ? sql `(
-                ${issueComments.createdAt} > ${anchorCreatedAt}
-                OR (${issueComments.createdAt} = ${anchorCreatedAt} AND ${issueComments.id} > ${anchor.id})
-              )`
-                    : sql `(
-                ${issueComments.createdAt} < ${anchorCreatedAt}
-                OR (${issueComments.createdAt} = ${anchorCreatedAt} AND ${issueComments.id} < ${anchor.id})
-              )`);
-            }
-            const query = db
-                .select()
-                .from(issueComments)
-                .where(and(...conditions))
-                .orderBy(order === "asc" ? asc(issueComments.createdAt) : desc(issueComments.createdAt), order === "asc" ? asc(issueComments.id) : desc(issueComments.id));
-            const comments = limit ? await query.limit(limit) : await query;
-            const { censorUsernameInLogs } = await instanceSettings.getGeneral();
-            return comments.map((comment) => redactIssueComment(comment, censorUsernameInLogs));
-        },
-        getCommentCursor: async (issueId) => {
-            const [latest, countRow] = await Promise.all([
-                db
-                    .select({
-                    latestCommentId: issueComments.id,
-                    latestCommentAt: issueComments.createdAt,
-                })
-                    .from(issueComments)
-                    .where(eq(issueComments.issueId, issueId))
-                    .orderBy(desc(issueComments.createdAt), desc(issueComments.id))
-                    .limit(1)
-                    .then((rows) => rows[0] ?? null),
-                db
-                    .select({
-                    totalComments: sql `count(*)::int`,
-                })
-                    .from(issueComments)
-                    .where(eq(issueComments.issueId, issueId))
-                    .then((rows) => rows[0] ?? null),
-            ]);
-            return {
-                totalComments: Number(countRow?.totalComments ?? 0),
-                latestCommentId: latest?.latestCommentId ?? null,
-                latestCommentAt: latest?.latestCommentAt ?? null,
-            };
-        },
-        getComment: (commentId) => instanceSettings.getGeneral().then(({ censorUsernameInLogs }) => db
-            .select()
-            .from(issueComments)
-            .where(eq(issueComments.id, commentId))
-            .then((rows) => {
-            const comment = rows[0] ?? null;
-            return comment ? redactIssueComment(comment, censorUsernameInLogs) : null;
-        })),
-        addComment: async (issueId, body, actor) => {
-            const issue = await db
-                .select({ orgId: issues.orgId })
-                .from(issues)
-                .where(eq(issues.id, issueId))
-                .then((rows) => rows[0] ?? null);
-            if (!issue)
-                throw notFound("Issue not found");
-            const currentUserRedactionOptions = {
-                enabled: (await instanceSettings.getGeneral()).censorUsernameInLogs,
-            };
-            const redactedBody = redactCurrentUserText(body, currentUserRedactionOptions);
-            const [comment] = await db
-                .insert(issueComments)
-                .values({
-                orgId: issue.orgId,
-                issueId,
-                authorAgentId: actor.agentId ?? null,
-                authorUserId: actor.userId ?? null,
-                body: redactedBody,
-            })
-                .returning();
-            // Update issue's updatedAt so comment activity is reflected in recency sorting
-            await db
-                .update(issues)
-                .set({ updatedAt: new Date() })
-                .where(eq(issues.id, issueId));
-            return redactIssueComment(comment, currentUserRedactionOptions.enabled);
-        },
-        createAttachment: async (input) => {
-            const issue = await db
-                .select({ id: issues.id, orgId: issues.orgId })
-                .from(issues)
-                .where(eq(issues.id, input.issueId))
-                .then((rows) => rows[0] ?? null);
-            if (!issue)
-                throw notFound("Issue not found");
-            if (input.issueCommentId) {
-                const comment = await db
-                    .select({ id: issueComments.id, orgId: issueComments.orgId, issueId: issueComments.issueId })
-                    .from(issueComments)
-                    .where(eq(issueComments.id, input.issueCommentId))
-                    .then((rows) => rows[0] ?? null);
-                if (!comment)
-                    throw notFound("Issue comment not found");
-                if (comment.orgId !== issue.orgId || comment.issueId !== issue.id) {
-                    throw unprocessable("Attachment comment must belong to same issue and organization");
-                }
-            }
-            return db.transaction(async (tx) => {
-                const [asset] = await tx
-                    .insert(assets)
-                    .values({
-                    orgId: issue.orgId,
-                    provider: input.provider,
-                    objectKey: input.objectKey,
-                    contentType: input.contentType,
-                    byteSize: input.byteSize,
-                    sha256: input.sha256,
-                    originalFilename: input.originalFilename ?? null,
-                    createdByAgentId: input.createdByAgentId ?? null,
-                    createdByUserId: input.createdByUserId ?? null,
-                })
-                    .returning();
-                const [attachment] = await tx
-                    .insert(issueAttachments)
-                    .values({
-                    orgId: issue.orgId,
-                    issueId: issue.id,
-                    assetId: asset.id,
-                    issueCommentId: input.issueCommentId ?? null,
-                    usage: input.usage ?? "issue",
-                })
-                    .returning();
-                return {
-                    id: attachment.id,
-                    orgId: attachment.orgId,
-                    issueId: attachment.issueId,
-                    issueCommentId: attachment.issueCommentId,
-                    assetId: attachment.assetId,
-                    usage: attachment.usage,
-                    provider: asset.provider,
-                    objectKey: asset.objectKey,
-                    contentType: asset.contentType,
-                    byteSize: asset.byteSize,
-                    sha256: asset.sha256,
-                    originalFilename: asset.originalFilename,
-                    createdByAgentId: asset.createdByAgentId,
-                    createdByUserId: asset.createdByUserId,
-                    createdAt: attachment.createdAt,
-                    updatedAt: attachment.updatedAt,
-                };
-            });
-        },
-        listAttachments: async (issueId) => db
-            .select({
-            id: issueAttachments.id,
-            orgId: issueAttachments.orgId,
-            issueId: issueAttachments.issueId,
-            issueCommentId: issueAttachments.issueCommentId,
-            assetId: issueAttachments.assetId,
-            usage: issueAttachments.usage,
-            provider: assets.provider,
-            objectKey: assets.objectKey,
-            contentType: assets.contentType,
-            byteSize: assets.byteSize,
-            sha256: assets.sha256,
-            originalFilename: assets.originalFilename,
-            createdByAgentId: assets.createdByAgentId,
-            createdByUserId: assets.createdByUserId,
-            createdAt: issueAttachments.createdAt,
-            updatedAt: issueAttachments.updatedAt,
-        })
-            .from(issueAttachments)
-            .innerJoin(assets, eq(issueAttachments.assetId, assets.id))
-            .where(and(eq(issueAttachments.issueId, issueId), eq(issueAttachments.usage, "issue")))
-            .orderBy(desc(issueAttachments.createdAt)),
-        getAttachmentById: async (id) => db
-            .select({
-            id: issueAttachments.id,
-            orgId: issueAttachments.orgId,
-            issueId: issueAttachments.issueId,
-            issueCommentId: issueAttachments.issueCommentId,
-            assetId: issueAttachments.assetId,
-            usage: issueAttachments.usage,
-            provider: assets.provider,
-            objectKey: assets.objectKey,
-            contentType: assets.contentType,
-            byteSize: assets.byteSize,
-            sha256: assets.sha256,
-            originalFilename: assets.originalFilename,
-            createdByAgentId: assets.createdByAgentId,
-            createdByUserId: assets.createdByUserId,
-            createdAt: issueAttachments.createdAt,
-            updatedAt: issueAttachments.updatedAt,
-        })
-            .from(issueAttachments)
-            .innerJoin(assets, eq(issueAttachments.assetId, assets.id))
-            .where(eq(issueAttachments.id, id))
-            .then((rows) => rows[0] ?? null),
-        removeAttachment: async (id) => db.transaction(async (tx) => {
-            const existing = await tx
-                .select({
-                id: issueAttachments.id,
-                orgId: issueAttachments.orgId,
-                issueId: issueAttachments.issueId,
-                issueCommentId: issueAttachments.issueCommentId,
-                assetId: issueAttachments.assetId,
-                usage: issueAttachments.usage,
-                provider: assets.provider,
-                objectKey: assets.objectKey,
-                contentType: assets.contentType,
-                byteSize: assets.byteSize,
-                sha256: assets.sha256,
-                originalFilename: assets.originalFilename,
-                createdByAgentId: assets.createdByAgentId,
-                createdByUserId: assets.createdByUserId,
-                createdAt: issueAttachments.createdAt,
-                updatedAt: issueAttachments.updatedAt,
-            })
-                .from(issueAttachments)
-                .innerJoin(assets, eq(issueAttachments.assetId, assets.id))
-                .where(eq(issueAttachments.id, id))
-                .then((rows) => rows[0] ?? null);
-            if (!existing)
-                return null;
-            await tx.delete(issueAttachments).where(eq(issueAttachments.id, id));
-            await tx.delete(assets).where(eq(assets.id, existing.assetId));
-            return existing;
-        }),
-        findMentionedAgents: async (orgId, body) => {
-            const re = /\B@([^\s@,!?.]+)/g;
-            const tokens = new Set();
-            let m;
-            while ((m = re.exec(body)) !== null)
-                tokens.add(m[1].toLowerCase());
-            const explicitAgentMentionIds = extractAgentMentionIds(body).filter(isUuidLike);
-            if (tokens.size === 0 && explicitAgentMentionIds.length === 0)
-                return [];
-            const rows = await db.select({ id: agents.id, name: agents.name })
-                .from(agents).where(eq(agents.orgId, orgId));
-            const resolved = new Set(explicitAgentMentionIds);
-            for (const agent of rows) {
-                if (tokens.has(agent.name.toLowerCase())) {
-                    resolved.add(agent.id);
-                }
-            }
-            return [...resolved];
-        },
-        findMentionedProjectIds: async (issueId) => {
-            const issue = await db
-                .select({
-                orgId: issues.orgId,
-                title: issues.title,
-                description: issues.description,
-            })
-                .from(issues)
-                .where(eq(issues.id, issueId))
-                .then((rows) => rows[0] ?? null);
-            if (!issue)
-                return [];
-            const comments = await db
-                .select({ body: issueComments.body })
-                .from(issueComments)
-                .where(eq(issueComments.issueId, issueId));
-            const mentionedIds = new Set();
-            for (const source of [
-                issue.title,
-                issue.description ?? "",
-                ...comments.map((comment) => comment.body),
-            ]) {
-                for (const projectId of extractProjectMentionIds(source)) {
-                    mentionedIds.add(projectId);
-                }
-            }
-            if (mentionedIds.size === 0)
-                return [];
-            const validMentionedIds = [...mentionedIds].filter(isUuidLike);
-            if (validMentionedIds.length === 0)
-                return [];
-            const rows = await db
-                .select({ id: projects.id })
-                .from(projects)
-                .where(and(eq(projects.orgId, issue.orgId), inArray(projects.id, validMentionedIds)));
-            const valid = new Set(rows.map((row) => row.id));
-            return validMentionedIds.filter((projectId) => valid.has(projectId));
-        },
+        ...createIssueCommentAttachmentMethods({ db, instanceSettings, redactIssueComment }),
         getAncestors: async (issueId) => {
             const raw = [];
             const visited = new Set([issueId]);