@rudderhq/server 0.7.16 → 0.7.19-canary.0

package/dist/services/issues.js

@@ -8,6 +8,7 @@ import { logger } from "../middleware/logger.js";
 import { defaultIssueExecutionWorkspaceSettingsForProject, parseProjectExecutionWorkspacePolicy, } from "./execution-workspace-policy.js";
 import { instanceSettingsService } from "./instance-settings.js";
 import { issueMaterialUpdateActivitySql } from "./issue-activity-filters.js";
+import { resolveIssueReferenceInputs } from "./issue-references.js";
 import { removeMessengerCustomGroupEntriesForItem } from "./messenger-saved-views.js";
 import { ensureProductAnalyticsWorkCycle, recordProductAnalyticsEvent } from "./product-analytics.js";
 import { createIssueCommentAttachmentMethods } from "./issues.comments-attachments.js";
@@ -15,6 +16,8 @@ import { BOARD_ORDER_STEP, TERMINAL_HEARTBEAT_RUN_STATUSES, activeRunMapForIssue
 export { deriveIssueUserContext } from "./issues.helpers.js";
 const DEFAULT_ISSUE_SEARCH_FIELDS = ["title"];
 const MAX_ISSUE_LIST_LIMIT = 500;
+const DEFAULT_ISSUE_SORT_FIELD = "priority";
+const DEFAULT_ISSUE_SORT_DIR = "asc";
 const ISSUE_DESCRIPTION_ASSET_PATH_RE = /\/api\/assets\/([^/?#\s)]+)\/content/g;
 export function extractIssueDescriptionAssetIds(description) {
     if (!description)
@@ -126,6 +129,52 @@ function normalizeIssueListOffset(offset) {
         return undefined;
     return normalized;
 }
+function issueSortExpression(expression, direction) {
+    return direction === "desc" ? desc(expression) : asc(expression);
+}
+function issueCTextExpression(expression) {
+    return sql `${expression} COLLATE "C"`;
+}
+function issuePriorityOrderExpression() {
+    return sql `CASE ${issues.priority}
+    WHEN 'critical' THEN 0
+    WHEN 'high' THEN 1
+    WHEN 'medium' THEN 2
+    WHEN 'low' THEN 3
+    ELSE 4
+  END`;
+}
+function issueStatusOrderExpression() {
+    return sql `CASE ${issues.status}
+    WHEN 'in_progress' THEN 0
+    WHEN 'todo' THEN 1
+    WHEN 'backlog' THEN 2
+    WHEN 'in_review' THEN 3
+    WHEN 'blocked' THEN 4
+    WHEN 'done' THEN 5
+    WHEN 'cancelled' THEN 6
+    ELSE 7
+  END`;
+}
+function issueListOrderBy(sortField = DEFAULT_ISSUE_SORT_FIELD, sortDir = DEFAULT_ISSUE_SORT_DIR) {
+    const primary = sortField === "manual"
+        ? issues.boardOrder
+        : sortField === "status"
+            ? issueStatusOrderExpression()
+            : sortField === "priority"
+                ? issuePriorityOrderExpression()
+                : sortField === "title"
+                    ? issueCTextExpression(issues.title)
+                    : sortField === "created"
+                        ? issues.createdAt
+                        : issues.updatedAt;
+    return [
+        issueSortExpression(primary, sortDir),
+        desc(issues.updatedAt),
+        desc(issues.createdAt),
+        asc(sql `COALESCE(${issues.identifier}, ${issues.id}::text) COLLATE "C"`),
+    ];
+}
 export function issueService(db, storage) {
     const instanceSettings = instanceSettingsService(db);
     const issueCreateResults = new WeakMap();
@@ -491,6 +540,9 @@ export function issueService(db, storage) {
             return Boolean(row);
         },
         list: async (orgId, filters) => {
+            if (filters) {
+                filters = await resolveIssueReferenceInputs(db, orgId, filters);
+            }
             const conditions = [eq(issues.orgId, orgId)];
             const touchedByUserId = filters?.touchedByUserId?.trim() || undefined;
             const unreadForUserId = filters?.unreadForUserId?.trim() || undefined;
@@ -623,7 +675,7 @@ export function issueService(db, storage) {
                     : ne(issues.originKind, "automation_execution"));
             }
             conditions.push(isNull(issues.hiddenAt));
-            const priorityOrder = sql `CASE ${issues.priority} WHEN 'critical' THEN 0 WHEN 'high' THEN 1 WHEN 'medium' THEN 2 WHEN 'low' THEN 3 ELSE 4 END`;
+            const priorityOrder = issuePriorityOrderExpression();
             const searchOrder = sql `
         CASE
           WHEN ${searchFields.has("title")} AND ${titleStartsWithMatch} THEN 0
@@ -639,7 +691,15 @@ export function issueService(db, storage) {
                 .select()
                 .from(issues)
                 .where(and(...conditions))
-                .orderBy(hasSearch ? asc(searchOrder) : asc(priorityOrder), asc(priorityOrder), desc(issues.updatedAt))
+                .orderBy(...(hasSearch
+                ? [
+                    asc(searchOrder),
+                    asc(priorityOrder),
+                    desc(issues.updatedAt),
+                    desc(issues.createdAt),
+                    asc(sql `COALESCE(${issues.identifier}, ${issues.id}::text) COLLATE "C"`),
+                ]
+                : issueListOrderBy(filters?.sortField, filters?.sortDir)))
                 .$dynamic();
             const limit = normalizeIssueListLimit(filters?.limit);
             if (limit !== undefined) {
@@ -821,6 +881,7 @@ export function issueService(db, storage) {
             };
         },
         create: async (orgId, data) => {
+            data = await resolveIssueReferenceInputs(db, orgId, data);
             const { labelIds: inputLabelIds, ...rawIssueData } = data;
             const issueData = { ...rawIssueData };
             const idempotentOrigin = resolveIdempotentIssueOrigin(issueData.originKind, issueData.originId);
@@ -1074,6 +1135,7 @@ export function issueService(db, storage) {
                 .then((rows) => rows[0] ?? null);
             if (!existing)
                 return null;
+            data = await resolveIssueReferenceInputs(db, existing.orgId, data);
             const { labelIds: nextLabelIds, ...issueData } = data;
             const hasIssueFieldChangesFrom = (current) => Object.entries(issueData).some(([key, value]) => {
                 const currentValue = current[key];
@@ -1340,106 +1402,109 @@ export function issueService(db, storage) {
                 return enriched;
             });
         },
-        reorder: async (orgId, input) => db.transaction(async (tx) => {
-            const existing = await tx
-                .select()
-                .from(issues)
-                .where(and(eq(issues.id, input.issueId), eq(issues.orgId, orgId)))
-                .for("update")
-                .then((rows) => rows[0] ?? null);
-            if (!existing)
-                return null;
-            assertTransition(existing.status, input.targetStatus);
-            assertIssueReviewStateTransition({
-                currentStatus: existing.status,
-                nextStatus: input.targetStatus,
-                currentReviewerAgentId: existing.reviewerAgentId,
-                currentReviewerUserId: existing.reviewerUserId,
-                nextReviewerAgentId: existing.reviewerAgentId,
-                nextReviewerUserId: existing.reviewerUserId,
-            });
-            const targetRows = await tx
-                .select()
-                .from(issues)
-                .where(and(eq(issues.orgId, orgId), eq(issues.status, input.targetStatus), ne(issues.id, input.issueId), isNull(issues.hiddenAt)))
-                .orderBy(asc(issues.boardOrder), desc(issues.updatedAt), desc(issues.createdAt), asc(issues.id));
-            const targetIds = new Set(targetRows.map((row) => row.id));
-            if (input.previousIssueId && !targetIds.has(input.previousIssueId)) {
-                throw unprocessable("previousIssueId must belong to the target status lane");
-            }
-            if (input.nextIssueId && !targetIds.has(input.nextIssueId)) {
-                throw unprocessable("nextIssueId must belong to the target status lane");
-            }
-            let insertIndex = input.position === "start" ? 0 : targetRows.length;
-            const previousIndex = input.previousIssueId
-                ? targetRows.findIndex((row) => row.id === input.previousIssueId)
-                : -1;
-            const nextIndex = input.nextIssueId
-                ? targetRows.findIndex((row) => row.id === input.nextIssueId)
-                : -1;
-            if (previousIndex >= 0 && nextIndex >= 0) {
-                if (nextIndex !== previousIndex + 1) {
-                    throw unprocessable("previousIssueId and nextIssueId must be adjacent in the target lane");
+        reorder: async (orgId, input) => {
+            input = await resolveIssueReferenceInputs(db, orgId, input);
+            return db.transaction(async (tx) => {
+                const existing = await tx
+                    .select()
+                    .from(issues)
+                    .where(and(eq(issues.id, input.issueId), eq(issues.orgId, orgId)))
+                    .for("update")
+                    .then((rows) => rows[0] ?? null);
+                if (!existing)
+                    return null;
+                assertTransition(existing.status, input.targetStatus);
+                assertIssueReviewStateTransition({
+                    currentStatus: existing.status,
+                    nextStatus: input.targetStatus,
+                    currentReviewerAgentId: existing.reviewerAgentId,
+                    currentReviewerUserId: existing.reviewerUserId,
+                    nextReviewerAgentId: existing.reviewerAgentId,
+                    nextReviewerUserId: existing.reviewerUserId,
+                });
+                const targetRows = await tx
+                    .select()
+                    .from(issues)
+                    .where(and(eq(issues.orgId, orgId), eq(issues.status, input.targetStatus), ne(issues.id, input.issueId), isNull(issues.hiddenAt)))
+                    .orderBy(asc(issues.boardOrder), desc(issues.updatedAt), desc(issues.createdAt), asc(issues.id));
+                const targetIds = new Set(targetRows.map((row) => row.id));
+                if (input.previousIssueId && !targetIds.has(input.previousIssueId)) {
+                    throw unprocessable("previousIssueId must belong to the target status lane");
                 }
-                insertIndex = nextIndex;
-            }
-            else if (previousIndex >= 0) {
-                insertIndex = previousIndex + 1;
-            }
-            else if (nextIndex >= 0) {
-                insertIndex = nextIndex;
-            }
-            const orderedRows = [...targetRows];
-            orderedRows.splice(insertIndex, 0, existing);
-            const now = new Date();
-            let updatedIssue = null;
-            for (const [index, row] of orderedRows.entries()) {
-                const nextOrder = (index + 1) * BOARD_ORDER_STEP;
-                if (row.id === existing.id) {
-                    const patch = {
-                        boardOrder: nextOrder,
-                    };
-                    if (existing.status !== input.targetStatus) {
-                        patch.status = input.targetStatus;
-                        patch.updatedAt = now;
-                        applyStatusSideEffects(input.targetStatus, patch);
-                        if (input.targetStatus !== "done") {
-                            patch.completedAt = null;
-                        }
-                        if (input.targetStatus !== "cancelled") {
-                            patch.cancelledAt = null;
-                        }
-                        if (input.targetStatus !== "in_progress") {
-                            patch.checkoutRunId = null;
-                            patch.executionRunId = null;
-                            patch.executionAgentNameKey = null;
-                            patch.executionLockedAt = null;
+                if (input.nextIssueId && !targetIds.has(input.nextIssueId)) {
+                    throw unprocessable("nextIssueId must belong to the target status lane");
+                }
+                let insertIndex = input.position === "start" ? 0 : targetRows.length;
+                const previousIndex = input.previousIssueId
+                    ? targetRows.findIndex((row) => row.id === input.previousIssueId)
+                    : -1;
+                const nextIndex = input.nextIssueId
+                    ? targetRows.findIndex((row) => row.id === input.nextIssueId)
+                    : -1;
+                if (previousIndex >= 0 && nextIndex >= 0) {
+                    if (nextIndex !== previousIndex + 1) {
+                        throw unprocessable("previousIssueId and nextIssueId must be adjacent in the target lane");
+                    }
+                    insertIndex = nextIndex;
+                }
+                else if (previousIndex >= 0) {
+                    insertIndex = previousIndex + 1;
+                }
+                else if (nextIndex >= 0) {
+                    insertIndex = nextIndex;
+                }
+                const orderedRows = [...targetRows];
+                orderedRows.splice(insertIndex, 0, existing);
+                const now = new Date();
+                let updatedIssue = null;
+                for (const [index, row] of orderedRows.entries()) {
+                    const nextOrder = (index + 1) * BOARD_ORDER_STEP;
+                    if (row.id === existing.id) {
+                        const patch = {
+                            boardOrder: nextOrder,
+                        };
+                        if (existing.status !== input.targetStatus) {
+                            patch.status = input.targetStatus;
+                            patch.updatedAt = now;
+                            applyStatusSideEffects(input.targetStatus, patch);
+                            if (input.targetStatus !== "done") {
+                                patch.completedAt = null;
+                            }
+                            if (input.targetStatus !== "cancelled") {
+                                patch.cancelledAt = null;
+                            }
+                            if (input.targetStatus !== "in_progress") {
+                                patch.checkoutRunId = null;
+                                patch.executionRunId = null;
+                                patch.executionAgentNameKey = null;
+                                patch.executionLockedAt = null;
+                            }
                         }
+                        updatedIssue = await tx
+                            .update(issues)
+                            .set(patch)
+                            .where(and(eq(issues.id, row.id), eq(issues.orgId, orgId)))
+                            .returning()
+                            .then((rows) => rows[0] ?? null);
+                        continue;
                     }
-                    updatedIssue = await tx
+                    if (row.boardOrder === nextOrder)
+                        continue;
+                    await tx
                         .update(issues)
-                        .set(patch)
-                        .where(and(eq(issues.id, row.id), eq(issues.orgId, orgId)))
-                        .returning()
-                        .then((rows) => rows[0] ?? null);
-                    continue;
+                        .set({ boardOrder: nextOrder })
+                        .where(and(eq(issues.id, row.id), eq(issues.orgId, orgId)));
                 }
-                if (row.boardOrder === nextOrder)
-                    continue;
-                await tx
-                    .update(issues)
-                    .set({ boardOrder: nextOrder })
-                    .where(and(eq(issues.id, row.id), eq(issues.orgId, orgId)));
-            }
-            if (!updatedIssue)
-                return null;
-            const [enriched] = await withIssueLabels(tx, [updatedIssue]);
-            return {
-                issue: enriched,
-                previousStatus: existing.status,
-                previousBoardOrder: existing.boardOrder,
-            };
-        }),
+                if (!updatedIssue)
+                    return null;
+                const [enriched] = await withIssueLabels(tx, [updatedIssue]);
+                return {
+                    issue: enriched,
+                    previousStatus: existing.status,
+                    previousBoardOrder: existing.boardOrder,
+                };
+            });
+        },
         remove: (id) => db.transaction(async (tx) => {
             const attachmentAssetIds = await tx
                 .select({ assetId: issueAttachments.assetId })
@@ -1480,6 +1545,8 @@ export function issueService(db, storage) {
                 .then((rows) => rows[0] ?? null);
             if (!issueCompany)
                 throw notFound("Issue not found");
+            const resolvedCheckout = await resolveIssueReferenceInputs(db, issueCompany.orgId, { agentId });
+            agentId = resolvedCheckout.agentId;
             await assertAssignableAgent(issueCompany.orgId, agentId);
             const now = new Date();
             const sameRunAssigneeCondition = checkoutRunId