mirror of
https://gh-proxy.org/https://github.com/klinsmaya/multica.git
synced 2026-11-08 01:16:45 +08:00
Claude
5ca20d1123
Before: GET /api/issues/thread-summaries told a client how many replies an issue had and when the last one landed, but not what it said, so a compact list had to open the thread to show it. After: each summary row carries last_reply_excerpt, the newest counted (non-deleted, non-system) comment flattened to one line of at most 80 runes with mentions collapsed to @Label; null when the issue has no counted comment. How: ListIssueThreadSummaries joins a lateral lookup of the newest counted comment (body capped at 2000 characters in SQL) onto the existing rollup, so the batch is still one query; the handler flattens it with commentExcerpt. A DB-backed handler test covers newest-wins, deleted and system exclusion, mention flattening and truncation (not run here, no PostgreSQL). Co-Authored-By: Claude Fable 5.1 <[email protected]> Claude-Session: https://claude.ai/code/session_017deksZDSzZBA4QSqZZoBip
3120 lines
109 KiB
Go
3120 lines
109 KiB
Go
// Code generated by sqlc. DO NOT EDIT.
|
|
// versions:
|
|
// sqlc v1.31.1
|
|
// source: comment.sql
|
|
|
|
package db
|
|
|
|
import (
|
|
"context"
|
|
|
|
"github.com/jackc/pgx/v5/pgtype"
|
|
)
|
|
|
|
const bumpCommentRevision = `-- name: BumpCommentRevision :one
|
|
UPDATE comment
|
|
SET revision = revision + 1,
|
|
updated_at = now()
|
|
WHERE id = $1
|
|
AND workspace_id = $2
|
|
RETURNING id, issue_id, author_type, author_id, content, type, created_at, updated_at, parent_id, workspace_id, resolved_at, resolved_by_type, resolved_by_id, source_task_id, quick_action_id, via_plugin_id, revision, recovery_settled_at, deleted_at, suppressed_agent_ids
|
|
`
|
|
|
|
type BumpCommentRevisionParams struct {
|
|
ID pgtype.UUID `json:"id"`
|
|
WorkspaceID pgtype.UUID `json:"workspace_id"`
|
|
}
|
|
|
|
func (q *Queries) BumpCommentRevision(ctx context.Context, arg BumpCommentRevisionParams) (Comment, error) {
|
|
row := q.db.QueryRow(ctx, bumpCommentRevision, arg.ID, arg.WorkspaceID)
|
|
var i Comment
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.IssueID,
|
|
&i.AuthorType,
|
|
&i.AuthorID,
|
|
&i.Content,
|
|
&i.Type,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.ParentID,
|
|
&i.WorkspaceID,
|
|
&i.ResolvedAt,
|
|
&i.ResolvedByType,
|
|
&i.ResolvedByID,
|
|
&i.SourceTaskID,
|
|
&i.QuickActionID,
|
|
&i.ViaPluginID,
|
|
&i.Revision,
|
|
&i.RecoverySettledAt,
|
|
&i.DeletedAt,
|
|
&i.SuppressedAgentIds,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const clearOtherThreadResolutions = `-- name: ClearOtherThreadResolutions :many
|
|
WITH RECURSIVE root_of AS (
|
|
-- Walk up from the target to its thread root.
|
|
SELECT c.id, c.parent_id
|
|
FROM comment c
|
|
WHERE c.id = $1 AND c.issue_id = $2 AND c.workspace_id = $3
|
|
UNION ALL
|
|
SELECT p.id, p.parent_id
|
|
FROM comment p
|
|
JOIN root_of r ON p.id = r.parent_id
|
|
),
|
|
thread_root AS (
|
|
SELECT id FROM root_of WHERE parent_id IS NULL LIMIT 1
|
|
),
|
|
descendants AS (
|
|
-- Expand back down from the root over the whole subtree. Cycle-safe under
|
|
-- the PK constraint (a comment cannot be its own ancestor).
|
|
SELECT c.id
|
|
FROM comment c
|
|
JOIN thread_root tr ON c.id = tr.id
|
|
UNION
|
|
SELECT c.id
|
|
FROM comment c
|
|
JOIN descendants d ON c.parent_id = d.id
|
|
WHERE c.issue_id = $2 AND c.workspace_id = $3
|
|
)
|
|
UPDATE comment SET
|
|
resolved_at = NULL,
|
|
resolved_by_type = NULL,
|
|
resolved_by_id = NULL,
|
|
revision = revision + 1,
|
|
updated_at = now()
|
|
WHERE comment.id IN (SELECT id FROM descendants)
|
|
AND comment.id <> $1
|
|
AND comment.resolved_at IS NOT NULL
|
|
RETURNING id, issue_id, author_type, author_id, content, type, created_at, updated_at, parent_id, workspace_id, resolved_at, resolved_by_type, resolved_by_id, source_task_id, quick_action_id, via_plugin_id, revision, recovery_settled_at, deleted_at, suppressed_agent_ids
|
|
`
|
|
|
|
type ClearOtherThreadResolutionsParams struct {
|
|
TargetID pgtype.UUID `json:"target_id"`
|
|
IssueID pgtype.UUID `json:"issue_id"`
|
|
WorkspaceID pgtype.UUID `json:"workspace_id"`
|
|
}
|
|
|
|
// Single-resolution invariant: a thread has at most one resolved comment.
|
|
// Resolving @target_id makes it the sole resolution, so this clears resolved_at
|
|
// on every OTHER currently-resolved comment in the same thread (the root of
|
|
// @target_id plus every descendant). The handler runs this in the SAME tx as
|
|
// ResolveComment so the replace is atomic — a crash can never leave two
|
|
// resolutions or zero. Scope is the thread only (id IN descendants AND
|
|
// id <> @target_id), never the whole issue. Returns each cleared row so the
|
|
// handler can emit a comment:unresolved event per row; granular realtime
|
|
// consumers replace a single comment in place and would otherwise keep
|
|
// displaying the stale resolution.
|
|
func (q *Queries) ClearOtherThreadResolutions(ctx context.Context, arg ClearOtherThreadResolutionsParams) ([]Comment, error) {
|
|
rows, err := q.db.Query(ctx, clearOtherThreadResolutions, arg.TargetID, arg.IssueID, arg.WorkspaceID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []Comment{}
|
|
for rows.Next() {
|
|
var i Comment
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.IssueID,
|
|
&i.AuthorType,
|
|
&i.AuthorID,
|
|
&i.Content,
|
|
&i.Type,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.ParentID,
|
|
&i.WorkspaceID,
|
|
&i.ResolvedAt,
|
|
&i.ResolvedByType,
|
|
&i.ResolvedByID,
|
|
&i.SourceTaskID,
|
|
&i.QuickActionID,
|
|
&i.ViaPluginID,
|
|
&i.Revision,
|
|
&i.RecoverySettledAt,
|
|
&i.DeletedAt,
|
|
&i.SuppressedAgentIds,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const commentHasReplies = `-- name: CommentHasReplies :one
|
|
SELECT EXISTS (
|
|
SELECT 1 FROM comment
|
|
WHERE parent_id = $1 AND workspace_id = $2
|
|
) AS has_replies
|
|
`
|
|
|
|
type CommentHasRepliesParams struct {
|
|
ID pgtype.UUID `json:"id"`
|
|
WorkspaceID pgtype.UUID `json:"workspace_id"`
|
|
}
|
|
|
|
func (q *Queries) CommentHasReplies(ctx context.Context, arg CommentHasRepliesParams) (bool, error) {
|
|
row := q.db.QueryRow(ctx, commentHasReplies, arg.ID, arg.WorkspaceID)
|
|
var has_replies bool
|
|
err := row.Scan(&has_replies)
|
|
return has_replies, err
|
|
}
|
|
|
|
const countComments = `-- name: CountComments :one
|
|
SELECT count(*) FROM comment
|
|
WHERE issue_id = $1 AND workspace_id = $2
|
|
`
|
|
|
|
type CountCommentsParams struct {
|
|
IssueID pgtype.UUID `json:"issue_id"`
|
|
WorkspaceID pgtype.UUID `json:"workspace_id"`
|
|
}
|
|
|
|
func (q *Queries) CountComments(ctx context.Context, arg CountCommentsParams) (int64, error) {
|
|
row := q.db.QueryRow(ctx, countComments, arg.IssueID, arg.WorkspaceID)
|
|
var count int64
|
|
err := row.Scan(&count)
|
|
return count, err
|
|
}
|
|
|
|
const countNewCommentsSince = `-- name: CountNewCommentsSince :one
|
|
SELECT count(*) FROM comment
|
|
WHERE issue_id = $1
|
|
AND workspace_id = $2
|
|
AND created_at > $3
|
|
AND id <> $4
|
|
AND deleted_at IS NULL
|
|
AND NOT (author_type = 'agent' AND author_id = $5)
|
|
`
|
|
|
|
type CountNewCommentsSinceParams struct {
|
|
IssueID pgtype.UUID `json:"issue_id"`
|
|
WorkspaceID pgtype.UUID `json:"workspace_id"`
|
|
Since pgtype.Timestamptz `json:"since"`
|
|
AnchorID pgtype.UUID `json:"anchor_id"`
|
|
AuthorID pgtype.UUID `json:"author_id"`
|
|
}
|
|
|
|
// Counts comments on an issue created strictly after @since, ACROSS THE WHOLE
|
|
// ISSUE (every thread, not just the triggering one). Excludes the triggering
|
|
// comment itself (@anchor_id — its body is already injected into the prompt)
|
|
// and any authored by the given agent (@author_id), so a chatty agent does not
|
|
// inflate its own new-comment count. The agent is steered to read the
|
|
// triggering thread first (see BuildNewCommentsHint), but the count is
|
|
// issue-wide so it knows the full catch-up volume. Feeds the daemon claim
|
|
// response without shipping comment bodies.
|
|
func (q *Queries) CountNewCommentsSince(ctx context.Context, arg CountNewCommentsSinceParams) (int64, error) {
|
|
row := q.db.QueryRow(ctx, countNewCommentsSince,
|
|
arg.IssueID,
|
|
arg.WorkspaceID,
|
|
arg.Since,
|
|
arg.AnchorID,
|
|
arg.AuthorID,
|
|
)
|
|
var count int64
|
|
err := row.Scan(&count)
|
|
return count, err
|
|
}
|
|
|
|
const createComment = `-- name: CreateComment :one
|
|
WITH touched_issue AS (
|
|
UPDATE issue SET
|
|
updated_at = now(),
|
|
revision = revision + 1,
|
|
last_activity_at = GREATEST(COALESCE(last_activity_at, updated_at), now())
|
|
WHERE issue.id = $1 AND issue.workspace_id = $2
|
|
RETURNING issue.id, issue.workspace_id, issue.revision
|
|
), inserted_comment AS (
|
|
INSERT INTO comment (issue_id, workspace_id, author_type, author_id, content, type, parent_id, source_task_id, quick_action_id, via_plugin_id, suppressed_agent_ids, id)
|
|
SELECT ti.id, ti.workspace_id, $3, $4, $5, $6, $7, $8, $9, $10, $11::uuid[], COALESCE($12::uuid, gen_random_uuid())
|
|
FROM touched_issue ti
|
|
RETURNING id, issue_id, author_type, author_id, content, type, created_at, updated_at, parent_id, workspace_id, resolved_at, resolved_by_type, resolved_by_id, source_task_id, quick_action_id, via_plugin_id, revision, recovery_settled_at, deleted_at, suppressed_agent_ids
|
|
)
|
|
SELECT inserted_comment.id, inserted_comment.issue_id, inserted_comment.author_type, inserted_comment.author_id, inserted_comment.content, inserted_comment.type, inserted_comment.created_at, inserted_comment.updated_at, inserted_comment.parent_id, inserted_comment.workspace_id, inserted_comment.resolved_at, inserted_comment.resolved_by_type, inserted_comment.resolved_by_id, inserted_comment.source_task_id, inserted_comment.quick_action_id, inserted_comment.via_plugin_id, inserted_comment.revision, inserted_comment.recovery_settled_at, inserted_comment.deleted_at, inserted_comment.suppressed_agent_ids, touched_issue.revision AS issue_revision
|
|
FROM inserted_comment
|
|
JOIN touched_issue ON touched_issue.id = inserted_comment.issue_id
|
|
`
|
|
|
|
type CreateCommentParams struct {
|
|
IssueID pgtype.UUID `json:"issue_id"`
|
|
WorkspaceID pgtype.UUID `json:"workspace_id"`
|
|
AuthorType string `json:"author_type"`
|
|
AuthorID pgtype.UUID `json:"author_id"`
|
|
Content string `json:"content"`
|
|
Type string `json:"type"`
|
|
ParentID pgtype.UUID `json:"parent_id"`
|
|
SourceTaskID pgtype.UUID `json:"source_task_id"`
|
|
QuickActionID pgtype.UUID `json:"quick_action_id"`
|
|
ViaPluginID pgtype.UUID `json:"via_plugin_id"`
|
|
SuppressedAgentIds []pgtype.UUID `json:"suppressed_agent_ids"`
|
|
ID pgtype.UUID `json:"id"`
|
|
}
|
|
|
|
type CreateCommentRow struct {
|
|
ID pgtype.UUID `json:"id"`
|
|
IssueID pgtype.UUID `json:"issue_id"`
|
|
AuthorType string `json:"author_type"`
|
|
AuthorID pgtype.UUID `json:"author_id"`
|
|
Content string `json:"content"`
|
|
Type string `json:"type"`
|
|
CreatedAt pgtype.Timestamptz `json:"created_at"`
|
|
UpdatedAt pgtype.Timestamptz `json:"updated_at"`
|
|
ParentID pgtype.UUID `json:"parent_id"`
|
|
WorkspaceID pgtype.UUID `json:"workspace_id"`
|
|
ResolvedAt pgtype.Timestamptz `json:"resolved_at"`
|
|
ResolvedByType pgtype.Text `json:"resolved_by_type"`
|
|
ResolvedByID pgtype.UUID `json:"resolved_by_id"`
|
|
SourceTaskID pgtype.UUID `json:"source_task_id"`
|
|
QuickActionID pgtype.UUID `json:"quick_action_id"`
|
|
ViaPluginID pgtype.UUID `json:"via_plugin_id"`
|
|
Revision int64 `json:"revision"`
|
|
RecoverySettledAt pgtype.Timestamptz `json:"recovery_settled_at"`
|
|
DeletedAt pgtype.Timestamptz `json:"deleted_at"`
|
|
SuppressedAgentIds []pgtype.UUID `json:"suppressed_agent_ids"`
|
|
IssueRevision int64 `json:"issue_revision"`
|
|
}
|
|
|
|
// A new comment counts as activity on its issue, so the same statement bumps
|
|
// the parent issue's updated_at and last_activity_at. The touch is a leading data-modifying CTE and
|
|
// the INSERT selects the issue/workspace back out of it, which makes the two
|
|
// inseparable and gives two query-level guarantees:
|
|
// - atomicity — the insert and the timestamp bump commit or roll back
|
|
// together, so an issue is never left with a stale updated_at after a
|
|
// comment persists; and
|
|
// - tenant integrity — the comment can only be created against an issue that
|
|
// actually exists in the given workspace. A mismatched (issue, workspace)
|
|
// pair matches 0 rows in the CTE, the dependent INSERT then selects nothing,
|
|
// and the :one query returns pgx.ErrNoRows. A wrong workspace can therefore
|
|
// never leave a mis-attributed comment or a silently un-touched issue.
|
|
//
|
|
// Centralizing this here means every comment entrypoint inherits both
|
|
// guarantees regardless of what a caller passes. The "Updated date" sort and
|
|
// the daemon GC TTL both read updated_at, so this consistency is load-bearing.
|
|
func (q *Queries) CreateComment(ctx context.Context, arg CreateCommentParams) (CreateCommentRow, error) {
|
|
row := q.db.QueryRow(ctx, createComment,
|
|
arg.IssueID,
|
|
arg.WorkspaceID,
|
|
arg.AuthorType,
|
|
arg.AuthorID,
|
|
arg.Content,
|
|
arg.Type,
|
|
arg.ParentID,
|
|
arg.SourceTaskID,
|
|
arg.QuickActionID,
|
|
arg.ViaPluginID,
|
|
arg.SuppressedAgentIds,
|
|
arg.ID,
|
|
)
|
|
var i CreateCommentRow
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.IssueID,
|
|
&i.AuthorType,
|
|
&i.AuthorID,
|
|
&i.Content,
|
|
&i.Type,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.ParentID,
|
|
&i.WorkspaceID,
|
|
&i.ResolvedAt,
|
|
&i.ResolvedByType,
|
|
&i.ResolvedByID,
|
|
&i.SourceTaskID,
|
|
&i.QuickActionID,
|
|
&i.ViaPluginID,
|
|
&i.Revision,
|
|
&i.RecoverySettledAt,
|
|
&i.DeletedAt,
|
|
&i.SuppressedAgentIds,
|
|
&i.IssueRevision,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const deleteLeafComment = `-- name: DeleteLeafComment :one
|
|
DELETE FROM comment
|
|
WHERE comment.id = $1 AND comment.workspace_id = $2
|
|
AND NOT EXISTS (SELECT 1 FROM comment child WHERE child.parent_id = comment.id)
|
|
RETURNING comment.id, comment.parent_id
|
|
`
|
|
|
|
type DeleteLeafCommentParams struct {
|
|
ID pgtype.UUID `json:"id"`
|
|
WorkspaceID pgtype.UUID `json:"workspace_id"`
|
|
}
|
|
|
|
type DeleteLeafCommentRow struct {
|
|
ID pgtype.UUID `json:"id"`
|
|
ParentID pgtype.UUID `json:"parent_id"`
|
|
}
|
|
|
|
// Removes a comment that has no replies. The NOT EXISTS guard keeps this
|
|
// statement from ever reaching the legacy parent_id cascade: a comment with a
|
|
// reply is tombstoned instead, never deleted with its replies.
|
|
func (q *Queries) DeleteLeafComment(ctx context.Context, arg DeleteLeafCommentParams) (DeleteLeafCommentRow, error) {
|
|
row := q.db.QueryRow(ctx, deleteLeafComment, arg.ID, arg.WorkspaceID)
|
|
var i DeleteLeafCommentRow
|
|
err := row.Scan(&i.ID, &i.ParentID)
|
|
return i, err
|
|
}
|
|
|
|
const deleteReplylessCommentTombstone = `-- name: DeleteReplylessCommentTombstone :one
|
|
DELETE FROM comment
|
|
WHERE comment.id = $1 AND comment.workspace_id = $2
|
|
AND comment.deleted_at IS NOT NULL
|
|
AND NOT EXISTS (SELECT 1 FROM comment child WHERE child.parent_id = comment.id)
|
|
RETURNING comment.id, comment.parent_id
|
|
`
|
|
|
|
type DeleteReplylessCommentTombstoneParams struct {
|
|
ID pgtype.UUID `json:"id"`
|
|
WorkspaceID pgtype.UUID `json:"workspace_id"`
|
|
}
|
|
|
|
type DeleteReplylessCommentTombstoneRow struct {
|
|
ID pgtype.UUID `json:"id"`
|
|
ParentID pgtype.UUID `json:"parent_id"`
|
|
}
|
|
|
|
// Removes a tombstone whose last reply is gone. The delete transaction calls
|
|
// this for each ancestor in turn, so a chain of placeholders never outlives
|
|
// the replies it kept attached.
|
|
func (q *Queries) DeleteReplylessCommentTombstone(ctx context.Context, arg DeleteReplylessCommentTombstoneParams) (DeleteReplylessCommentTombstoneRow, error) {
|
|
row := q.db.QueryRow(ctx, deleteReplylessCommentTombstone, arg.ID, arg.WorkspaceID)
|
|
var i DeleteReplylessCommentTombstoneRow
|
|
err := row.Scan(&i.ID, &i.ParentID)
|
|
return i, err
|
|
}
|
|
|
|
const existsCommentRootAfterForIssue = `-- name: ExistsCommentRootAfterForIssue :one
|
|
SELECT EXISTS (
|
|
SELECT 1 FROM comment
|
|
WHERE issue_id = $1
|
|
AND workspace_id = $2
|
|
AND parent_id IS NULL
|
|
AND (created_at, id) > ($3::timestamptz, $4::uuid)
|
|
)
|
|
`
|
|
|
|
type ExistsCommentRootAfterForIssueParams struct {
|
|
IssueID pgtype.UUID `json:"issue_id"`
|
|
WorkspaceID pgtype.UUID `json:"workspace_id"`
|
|
AfterAt pgtype.Timestamptz `json:"after_at"`
|
|
AfterID pgtype.UUID `json:"after_id"`
|
|
}
|
|
|
|
// Whether the issue has a top-level comment strictly newer than the
|
|
// (@after_at, @after_id) pair. Backs has_more_after on an `around` timeline page.
|
|
func (q *Queries) ExistsCommentRootAfterForIssue(ctx context.Context, arg ExistsCommentRootAfterForIssueParams) (bool, error) {
|
|
row := q.db.QueryRow(ctx, existsCommentRootAfterForIssue,
|
|
arg.IssueID,
|
|
arg.WorkspaceID,
|
|
arg.AfterAt,
|
|
arg.AfterID,
|
|
)
|
|
var exists bool
|
|
err := row.Scan(&exists)
|
|
return exists, err
|
|
}
|
|
|
|
const getComment = `-- name: GetComment :one
|
|
SELECT id, issue_id, author_type, author_id, content, type, created_at, updated_at, parent_id, workspace_id, resolved_at, resolved_by_type, resolved_by_id, source_task_id, quick_action_id, via_plugin_id, revision, recovery_settled_at, deleted_at, suppressed_agent_ids FROM comment
|
|
WHERE id = $1
|
|
`
|
|
|
|
func (q *Queries) GetComment(ctx context.Context, id pgtype.UUID) (Comment, error) {
|
|
row := q.db.QueryRow(ctx, getComment, id)
|
|
var i Comment
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.IssueID,
|
|
&i.AuthorType,
|
|
&i.AuthorID,
|
|
&i.Content,
|
|
&i.Type,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.ParentID,
|
|
&i.WorkspaceID,
|
|
&i.ResolvedAt,
|
|
&i.ResolvedByType,
|
|
&i.ResolvedByID,
|
|
&i.SourceTaskID,
|
|
&i.QuickActionID,
|
|
&i.ViaPluginID,
|
|
&i.Revision,
|
|
&i.RecoverySettledAt,
|
|
&i.DeletedAt,
|
|
&i.SuppressedAgentIds,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const getCommentInWorkspace = `-- name: GetCommentInWorkspace :one
|
|
SELECT id, issue_id, author_type, author_id, content, type, created_at, updated_at, parent_id, workspace_id, resolved_at, resolved_by_type, resolved_by_id, source_task_id, quick_action_id, via_plugin_id, revision, recovery_settled_at, deleted_at, suppressed_agent_ids FROM comment
|
|
WHERE id = $1 AND workspace_id = $2
|
|
`
|
|
|
|
type GetCommentInWorkspaceParams struct {
|
|
ID pgtype.UUID `json:"id"`
|
|
WorkspaceID pgtype.UUID `json:"workspace_id"`
|
|
}
|
|
|
|
func (q *Queries) GetCommentInWorkspace(ctx context.Context, arg GetCommentInWorkspaceParams) (Comment, error) {
|
|
row := q.db.QueryRow(ctx, getCommentInWorkspace, arg.ID, arg.WorkspaceID)
|
|
var i Comment
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.IssueID,
|
|
&i.AuthorType,
|
|
&i.AuthorID,
|
|
&i.Content,
|
|
&i.Type,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.ParentID,
|
|
&i.WorkspaceID,
|
|
&i.ResolvedAt,
|
|
&i.ResolvedByType,
|
|
&i.ResolvedByID,
|
|
&i.SourceTaskID,
|
|
&i.QuickActionID,
|
|
&i.ViaPluginID,
|
|
&i.Revision,
|
|
&i.RecoverySettledAt,
|
|
&i.DeletedAt,
|
|
&i.SuppressedAgentIds,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const getDelegatedFailureRecoveryComment = `-- name: GetDelegatedFailureRecoveryComment :one
|
|
SELECT id, issue_id, author_type, author_id, content, type, created_at, updated_at, parent_id, workspace_id, resolved_at, resolved_by_type, resolved_by_id, source_task_id, quick_action_id, via_plugin_id, revision, recovery_settled_at, deleted_at, suppressed_agent_ids FROM comment
|
|
WHERE issue_id = $1
|
|
AND workspace_id = $2
|
|
AND author_type = 'system'
|
|
AND type = 'progress_update'
|
|
AND source_task_id = $3
|
|
ORDER BY created_at ASC, id ASC
|
|
LIMIT 1
|
|
`
|
|
|
|
type GetDelegatedFailureRecoveryCommentParams struct {
|
|
IssueID pgtype.UUID `json:"issue_id"`
|
|
WorkspaceID pgtype.UUID `json:"workspace_id"`
|
|
SourceTaskID pgtype.UUID `json:"source_task_id"`
|
|
}
|
|
|
|
// The failed task row is locked by the caller before this lookup/insert pair,
|
|
// making (source issue, failed task) a durable idempotency key without a new
|
|
// hot-table index or schema migration. Platform recovery signals are the only
|
|
// system-authored progress updates that carry source_task_id.
|
|
func (q *Queries) GetDelegatedFailureRecoveryComment(ctx context.Context, arg GetDelegatedFailureRecoveryCommentParams) (Comment, error) {
|
|
row := q.db.QueryRow(ctx, getDelegatedFailureRecoveryComment, arg.IssueID, arg.WorkspaceID, arg.SourceTaskID)
|
|
var i Comment
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.IssueID,
|
|
&i.AuthorType,
|
|
&i.AuthorID,
|
|
&i.Content,
|
|
&i.Type,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.ParentID,
|
|
&i.WorkspaceID,
|
|
&i.ResolvedAt,
|
|
&i.ResolvedByType,
|
|
&i.ResolvedByID,
|
|
&i.SourceTaskID,
|
|
&i.QuickActionID,
|
|
&i.ViaPluginID,
|
|
&i.Revision,
|
|
&i.RecoverySettledAt,
|
|
&i.DeletedAt,
|
|
&i.SuppressedAgentIds,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const getDelegatedFailureRecoveryExhaustionComment = `-- name: GetDelegatedFailureRecoveryExhaustionComment :one
|
|
SELECT id, issue_id, author_type, author_id, content, type, created_at, updated_at, parent_id, workspace_id, resolved_at, resolved_by_type, resolved_by_id, source_task_id, quick_action_id, via_plugin_id, revision, recovery_settled_at, deleted_at, suppressed_agent_ids FROM comment
|
|
WHERE issue_id = $1
|
|
AND workspace_id = $2
|
|
AND author_type = 'system'
|
|
AND type = 'system'
|
|
AND source_task_id = $3
|
|
ORDER BY created_at ASC, id ASC
|
|
LIMIT 1
|
|
`
|
|
|
|
type GetDelegatedFailureRecoveryExhaustionCommentParams struct {
|
|
IssueID pgtype.UUID `json:"issue_id"`
|
|
WorkspaceID pgtype.UUID `json:"workspace_id"`
|
|
SourceTaskID pgtype.UUID `json:"source_task_id"`
|
|
}
|
|
|
|
// The failed task and newest recovery-attempt row are locked by the caller
|
|
// before this lookup/insert pair. Keeping exhaustion as a separate system
|
|
// comment preserves the original recovery signal while making the automatic
|
|
// stop visible in the issue timeline.
|
|
func (q *Queries) GetDelegatedFailureRecoveryExhaustionComment(ctx context.Context, arg GetDelegatedFailureRecoveryExhaustionCommentParams) (Comment, error) {
|
|
row := q.db.QueryRow(ctx, getDelegatedFailureRecoveryExhaustionComment, arg.IssueID, arg.WorkspaceID, arg.SourceTaskID)
|
|
var i Comment
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.IssueID,
|
|
&i.AuthorType,
|
|
&i.AuthorID,
|
|
&i.Content,
|
|
&i.Type,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.ParentID,
|
|
&i.WorkspaceID,
|
|
&i.ResolvedAt,
|
|
&i.ResolvedByType,
|
|
&i.ResolvedByID,
|
|
&i.SourceTaskID,
|
|
&i.QuickActionID,
|
|
&i.ViaPluginID,
|
|
&i.Revision,
|
|
&i.RecoverySettledAt,
|
|
&i.DeletedAt,
|
|
&i.SuppressedAgentIds,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const getLatestMemberCommentForIssueSince = `-- name: GetLatestMemberCommentForIssueSince :one
|
|
SELECT id, issue_id, author_type, author_id, content, type, created_at, updated_at, parent_id, workspace_id, resolved_at, resolved_by_type, resolved_by_id, source_task_id, quick_action_id, via_plugin_id, revision, recovery_settled_at, deleted_at, suppressed_agent_ids FROM comment
|
|
WHERE issue_id = $1
|
|
AND author_type = 'member'
|
|
AND created_at > $2
|
|
AND deleted_at IS NULL
|
|
ORDER BY created_at DESC
|
|
LIMIT 1
|
|
`
|
|
|
|
type GetLatestMemberCommentForIssueSinceParams struct {
|
|
IssueID pgtype.UUID `json:"issue_id"`
|
|
Since pgtype.Timestamptz `json:"since"`
|
|
}
|
|
|
|
// MUL-4195 completion reconciliation: the newest MEMBER-authored comment on an
|
|
// issue created strictly after @since (a run's started_at). Used when a task
|
|
// completes to detect deliberate user input that landed while the agent was
|
|
// busy — or that was merged into the running task after its context was
|
|
// already built — so a single follow-up run can be scheduled for it. Restricted
|
|
// to author_type = 'member' on purpose: only human input earns the guaranteed
|
|
// follow-up, which preserves the existing anti-loop guarantees (agent replies,
|
|
// acknowledgements, and self-triggers never qualify). Returns pgx.ErrNoRows
|
|
// when nothing newer exists, i.e. the run already covered the latest input.
|
|
func (q *Queries) GetLatestMemberCommentForIssueSince(ctx context.Context, arg GetLatestMemberCommentForIssueSinceParams) (Comment, error) {
|
|
row := q.db.QueryRow(ctx, getLatestMemberCommentForIssueSince, arg.IssueID, arg.Since)
|
|
var i Comment
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.IssueID,
|
|
&i.AuthorType,
|
|
&i.AuthorID,
|
|
&i.Content,
|
|
&i.Type,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.ParentID,
|
|
&i.WorkspaceID,
|
|
&i.ResolvedAt,
|
|
&i.ResolvedByType,
|
|
&i.ResolvedByID,
|
|
&i.SourceTaskID,
|
|
&i.QuickActionID,
|
|
&i.ViaPluginID,
|
|
&i.Revision,
|
|
&i.RecoverySettledAt,
|
|
&i.DeletedAt,
|
|
&i.SuppressedAgentIds,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const getThreadRoot = `-- name: GetThreadRoot :one
|
|
WITH RECURSIVE root_of AS (
|
|
SELECT c.id, c.parent_id
|
|
FROM comment c
|
|
WHERE c.id = $1 AND c.workspace_id = $2
|
|
UNION ALL
|
|
SELECT p.id, p.parent_id
|
|
FROM comment p
|
|
JOIN root_of r ON p.id = r.parent_id
|
|
)
|
|
SELECT c.id, c.issue_id, c.author_type, c.author_id, c.content, c.type, c.created_at, c.updated_at, c.parent_id, c.workspace_id, c.resolved_at, c.resolved_by_type, c.resolved_by_id, c.source_task_id, c.quick_action_id, c.via_plugin_id, c.revision, c.recovery_settled_at, c.deleted_at, c.suppressed_agent_ids FROM comment c
|
|
WHERE c.id = (SELECT id FROM root_of WHERE parent_id IS NULL LIMIT 1)
|
|
`
|
|
|
|
type GetThreadRootParams struct {
|
|
CommentID pgtype.UUID `json:"comment_id"`
|
|
WorkspaceID pgtype.UUID `json:"workspace_id"`
|
|
}
|
|
|
|
// Returns the thread-root comment for @comment_id by walking parent_id up to
|
|
// the row whose parent_id IS NULL. For a root comment it returns that comment
|
|
// itself. Used when callers need thread-level behavior while parent_id remains
|
|
// the exact direct parent of a reply. Cycle-safe under the PK constraint (a
|
|
// comment cannot be its own ancestor).
|
|
func (q *Queries) GetThreadRoot(ctx context.Context, arg GetThreadRootParams) (Comment, error) {
|
|
row := q.db.QueryRow(ctx, getThreadRoot, arg.CommentID, arg.WorkspaceID)
|
|
var i Comment
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.IssueID,
|
|
&i.AuthorType,
|
|
&i.AuthorID,
|
|
&i.Content,
|
|
&i.Type,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.ParentID,
|
|
&i.WorkspaceID,
|
|
&i.ResolvedAt,
|
|
&i.ResolvedByType,
|
|
&i.ResolvedByID,
|
|
&i.SourceTaskID,
|
|
&i.QuickActionID,
|
|
&i.ViaPluginID,
|
|
&i.Revision,
|
|
&i.RecoverySettledAt,
|
|
&i.DeletedAt,
|
|
&i.SuppressedAgentIds,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const hasAgentCommentedSince = `-- name: HasAgentCommentedSince :one
|
|
SELECT EXISTS (
|
|
SELECT 1 FROM comment
|
|
WHERE issue_id = $1
|
|
AND author_type = 'agent'
|
|
AND author_id = $2
|
|
AND created_at >= $3
|
|
AND deleted_at IS NULL
|
|
) AS commented
|
|
`
|
|
|
|
type HasAgentCommentedSinceParams struct {
|
|
IssueID pgtype.UUID `json:"issue_id"`
|
|
AuthorID pgtype.UUID `json:"author_id"`
|
|
Since pgtype.Timestamptz `json:"since"`
|
|
}
|
|
|
|
func (q *Queries) HasAgentCommentedSince(ctx context.Context, arg HasAgentCommentedSinceParams) (bool, error) {
|
|
row := q.db.QueryRow(ctx, hasAgentCommentedSince, arg.IssueID, arg.AuthorID, arg.Since)
|
|
var commented bool
|
|
err := row.Scan(&commented)
|
|
return commented, err
|
|
}
|
|
|
|
const hasAgentRepliedInThread = `-- name: HasAgentRepliedInThread :one
|
|
SELECT count(*) > 0 AS has_replied FROM comment
|
|
WHERE parent_id = $1 AND author_type = 'agent' AND author_id = $2
|
|
`
|
|
|
|
type HasAgentRepliedInThreadParams struct {
|
|
ParentID pgtype.UUID `json:"parent_id"`
|
|
AgentID pgtype.UUID `json:"agent_id"`
|
|
}
|
|
|
|
// Returns true if the given agent has posted a reply in the thread rooted at
|
|
// the specified parent comment. Used to detect agent participation in a
|
|
// member-started thread so that follow-up member replies still trigger the agent.
|
|
func (q *Queries) HasAgentRepliedInThread(ctx context.Context, arg HasAgentRepliedInThreadParams) (bool, error) {
|
|
row := q.db.QueryRow(ctx, hasAgentRepliedInThread, arg.ParentID, arg.AgentID)
|
|
var has_replied bool
|
|
err := row.Scan(&has_replied)
|
|
return has_replied, err
|
|
}
|
|
|
|
const listAgentQuestionsForIssues = `-- name: ListAgentQuestionsForIssues :many
|
|
WITH RECURSIVE roots AS (
|
|
SELECT c.id AS root_id
|
|
FROM comment c
|
|
WHERE c.workspace_id = $2
|
|
AND c.issue_id = ANY($3::uuid[])
|
|
AND c.parent_id IS NULL
|
|
AND c.resolved_at IS NULL
|
|
AND c.deleted_at IS NULL
|
|
),
|
|
membership(id, root_id) AS (
|
|
SELECT r.root_id, r.root_id
|
|
FROM roots r
|
|
UNION ALL
|
|
SELECT c.id, m.root_id
|
|
FROM comment c
|
|
JOIN membership m ON c.parent_id = m.id
|
|
WHERE c.workspace_id = $2
|
|
AND c.issue_id = ANY($3::uuid[])
|
|
),
|
|
latest AS (
|
|
SELECT DISTINCT ON (m.root_id)
|
|
c.id, c.issue_id, c.author_type, c.author_id, c.content, c.created_at
|
|
FROM membership m
|
|
JOIN comment c ON c.id = m.id
|
|
WHERE c.deleted_at IS NULL
|
|
AND c.author_type <> 'system'
|
|
ORDER BY m.root_id, c.created_at DESC, c.id DESC
|
|
)
|
|
SELECT l.issue_id,
|
|
l.id AS comment_id,
|
|
l.author_id,
|
|
l.content,
|
|
l.created_at
|
|
FROM latest l
|
|
WHERE l.author_type = 'agent'
|
|
AND l.content ILIKE '%](mention://member/' || $1::uuid::text || ')%'
|
|
ORDER BY l.issue_id, l.created_at DESC, l.id DESC
|
|
`
|
|
|
|
type ListAgentQuestionsForIssuesParams struct {
|
|
CallerID pgtype.UUID `json:"caller_id"`
|
|
WorkspaceID pgtype.UUID `json:"workspace_id"`
|
|
IssueIds []pgtype.UUID `json:"issue_ids"`
|
|
}
|
|
|
|
type ListAgentQuestionsForIssuesRow struct {
|
|
IssueID pgtype.UUID `json:"issue_id"`
|
|
CommentID pgtype.UUID `json:"comment_id"`
|
|
AuthorID pgtype.UUID `json:"author_id"`
|
|
Content string `json:"content"`
|
|
CreatedAt pgtype.Timestamptz `json:"created_at"`
|
|
}
|
|
|
|
// Threads whose latest word is an agent @-mentioning the caller: the reader's
|
|
// turn to answer. A thread is a top-level comment plus every descendant (same
|
|
// notion of root as ListCommentRepliesForRoots); only unresolved, non-deleted
|
|
// roots qualify. The latest comment is picked by (created_at, id) among
|
|
// non-deleted, non-system rows, so a deleted tail hands the decision back to the
|
|
// comment before it and platform notices never mask a pending question.
|
|
//
|
|
// The mention test runs only on one row per thread, after the latest comment is
|
|
// chosen. Mentions serialize as [@Label](mention://member/<user-id>); ILIKE
|
|
// tolerates an upper-case UUID written by an agent.
|
|
func (q *Queries) ListAgentQuestionsForIssues(ctx context.Context, arg ListAgentQuestionsForIssuesParams) ([]ListAgentQuestionsForIssuesRow, error) {
|
|
rows, err := q.db.Query(ctx, listAgentQuestionsForIssues, arg.CallerID, arg.WorkspaceID, arg.IssueIds)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []ListAgentQuestionsForIssuesRow{}
|
|
for rows.Next() {
|
|
var i ListAgentQuestionsForIssuesRow
|
|
if err := rows.Scan(
|
|
&i.IssueID,
|
|
&i.CommentID,
|
|
&i.AuthorID,
|
|
&i.Content,
|
|
&i.CreatedAt,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const listChildCommentsForParents = `-- name: ListChildCommentsForParents :many
|
|
SELECT id, issue_id, author_type, author_id, content, type, created_at, updated_at, parent_id, workspace_id, resolved_at, resolved_by_type, resolved_by_id, source_task_id, quick_action_id, via_plugin_id, revision, recovery_settled_at, deleted_at, suppressed_agent_ids FROM comment
|
|
WHERE parent_id = ANY($1::uuid[])
|
|
AND issue_id = $2
|
|
AND workspace_id = $3
|
|
AND (created_at, id) <= ($4::timestamptz, $5::uuid)
|
|
ORDER BY parent_id ASC, created_at ASC, id ASC
|
|
LIMIT $6
|
|
`
|
|
|
|
type ListChildCommentsForParentsParams struct {
|
|
ParentIds []pgtype.UUID `json:"parent_ids"`
|
|
IssueID pgtype.UUID `json:"issue_id"`
|
|
WorkspaceID pgtype.UUID `json:"workspace_id"`
|
|
ThroughAt pgtype.Timestamptz `json:"through_at"`
|
|
ThroughID pgtype.UUID `json:"through_id"`
|
|
RowLimit int32 `json:"row_limit"`
|
|
}
|
|
|
|
// Fetch one descendant level for a bounded set of parent comments. Each parent
|
|
// maps back to its thread root in the Go breadth-first walk, avoiding one query
|
|
// per root.
|
|
//
|
|
// Both tenant predicates apply at every level. row_limit is always a probe
|
|
// limit owned by completeCommentThreads; it prevents a wide level from defeating
|
|
// the response budget. through_at/through_id pin the walk to the newest row in
|
|
// the original window, so replies created concurrently are left to realtime
|
|
// delivery instead of making the multi-query snapshot internally inconsistent.
|
|
func (q *Queries) ListChildCommentsForParents(ctx context.Context, arg ListChildCommentsForParentsParams) ([]Comment, error) {
|
|
rows, err := q.db.Query(ctx, listChildCommentsForParents,
|
|
arg.ParentIds,
|
|
arg.IssueID,
|
|
arg.WorkspaceID,
|
|
arg.ThroughAt,
|
|
arg.ThroughID,
|
|
arg.RowLimit,
|
|
)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []Comment{}
|
|
for rows.Next() {
|
|
var i Comment
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.IssueID,
|
|
&i.AuthorType,
|
|
&i.AuthorID,
|
|
&i.Content,
|
|
&i.Type,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.ParentID,
|
|
&i.WorkspaceID,
|
|
&i.ResolvedAt,
|
|
&i.ResolvedByType,
|
|
&i.ResolvedByID,
|
|
&i.SourceTaskID,
|
|
&i.QuickActionID,
|
|
&i.ViaPluginID,
|
|
&i.Revision,
|
|
&i.RecoverySettledAt,
|
|
&i.DeletedAt,
|
|
&i.SuppressedAgentIds,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const listCommentAncestorPath = `-- name: ListCommentAncestorPath :many
|
|
WITH RECURSIVE ancestor_path AS (
|
|
SELECT c.id, c.issue_id, c.author_type, c.author_id, c.content, c.type, c.created_at, c.updated_at, c.parent_id, c.workspace_id, c.resolved_at, c.resolved_by_type, c.resolved_by_id, c.source_task_id, c.quick_action_id, c.via_plugin_id, c.revision, c.recovery_settled_at, c.deleted_at, c.suppressed_agent_ids, ARRAY[c.id]::uuid[] AS visited_ids, 1::integer AS depth, false AS cycle
|
|
FROM comment c
|
|
WHERE c.id = $1
|
|
AND c.workspace_id = $2
|
|
AND c.issue_id = $3
|
|
|
|
UNION ALL
|
|
|
|
SELECT parent.id, parent.issue_id, parent.author_type, parent.author_id, parent.content, parent.type, parent.created_at, parent.updated_at, parent.parent_id, parent.workspace_id, parent.resolved_at, parent.resolved_by_type, parent.resolved_by_id, parent.source_task_id, parent.quick_action_id, parent.via_plugin_id, parent.revision, parent.recovery_settled_at, parent.deleted_at, parent.suppressed_agent_ids,
|
|
path.visited_ids || parent.id,
|
|
path.depth + 1,
|
|
parent.id = ANY(path.visited_ids)
|
|
FROM ancestor_path path
|
|
JOIN comment parent ON parent.id = path.parent_id
|
|
WHERE parent.workspace_id = $2
|
|
AND parent.issue_id = $3
|
|
AND path.depth <= 256
|
|
AND NOT path.cycle
|
|
)
|
|
SELECT id, issue_id, author_type, author_id, content, type, created_at,
|
|
updated_at, workspace_id, parent_id, resolved_at, resolved_by_type,
|
|
resolved_by_id, source_task_id, revision, quick_action_id, via_plugin_id,
|
|
deleted_at, depth, cycle
|
|
FROM ancestor_path
|
|
ORDER BY depth DESC
|
|
`
|
|
|
|
type ListCommentAncestorPathParams struct {
|
|
CommentID pgtype.UUID `json:"comment_id"`
|
|
WorkspaceID pgtype.UUID `json:"workspace_id"`
|
|
IssueID pgtype.UUID `json:"issue_id"`
|
|
}
|
|
|
|
type ListCommentAncestorPathRow struct {
|
|
ID pgtype.UUID `json:"id"`
|
|
IssueID pgtype.UUID `json:"issue_id"`
|
|
AuthorType string `json:"author_type"`
|
|
AuthorID pgtype.UUID `json:"author_id"`
|
|
Content string `json:"content"`
|
|
Type string `json:"type"`
|
|
CreatedAt pgtype.Timestamptz `json:"created_at"`
|
|
UpdatedAt pgtype.Timestamptz `json:"updated_at"`
|
|
WorkspaceID pgtype.UUID `json:"workspace_id"`
|
|
ParentID pgtype.UUID `json:"parent_id"`
|
|
ResolvedAt pgtype.Timestamptz `json:"resolved_at"`
|
|
ResolvedByType pgtype.Text `json:"resolved_by_type"`
|
|
ResolvedByID pgtype.UUID `json:"resolved_by_id"`
|
|
SourceTaskID pgtype.UUID `json:"source_task_id"`
|
|
Revision int64 `json:"revision"`
|
|
QuickActionID pgtype.UUID `json:"quick_action_id"`
|
|
ViaPluginID pgtype.UUID `json:"via_plugin_id"`
|
|
DeletedAt pgtype.Timestamptz `json:"deleted_at"`
|
|
Depth int32 `json:"depth"`
|
|
Cycle bool `json:"cycle"`
|
|
}
|
|
|
|
func (q *Queries) ListCommentAncestorPath(ctx context.Context, arg ListCommentAncestorPathParams) ([]ListCommentAncestorPathRow, error) {
|
|
rows, err := q.db.Query(ctx, listCommentAncestorPath, arg.CommentID, arg.WorkspaceID, arg.IssueID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []ListCommentAncestorPathRow{}
|
|
for rows.Next() {
|
|
var i ListCommentAncestorPathRow
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.IssueID,
|
|
&i.AuthorType,
|
|
&i.AuthorID,
|
|
&i.Content,
|
|
&i.Type,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.WorkspaceID,
|
|
&i.ParentID,
|
|
&i.ResolvedAt,
|
|
&i.ResolvedByType,
|
|
&i.ResolvedByID,
|
|
&i.SourceTaskID,
|
|
&i.Revision,
|
|
&i.QuickActionID,
|
|
&i.ViaPluginID,
|
|
&i.DeletedAt,
|
|
&i.Depth,
|
|
&i.Cycle,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const listCommentRepliesForRoots = `-- name: ListCommentRepliesForRoots :many
|
|
WITH RECURSIVE roots AS (
|
|
SELECT c.id AS root_id, c.created_at AS root_created_at
|
|
FROM comment c
|
|
WHERE c.id = ANY($2::uuid[])
|
|
AND c.issue_id = $3
|
|
AND c.workspace_id = $4
|
|
AND c.parent_id IS NULL
|
|
),
|
|
membership(id, root_id, root_created_at) AS (
|
|
SELECT c.id, r.root_id, r.root_created_at
|
|
FROM comment c
|
|
JOIN roots r ON c.parent_id = r.root_id
|
|
WHERE c.issue_id = $3
|
|
AND c.workspace_id = $4
|
|
UNION ALL
|
|
SELECT c.id, m.root_id, m.root_created_at
|
|
FROM comment c
|
|
JOIN membership m ON c.parent_id = m.id
|
|
WHERE c.issue_id = $3
|
|
AND c.workspace_id = $4
|
|
)
|
|
SELECT c.id, c.issue_id, c.author_type, c.author_id, c.content, c.type, c.created_at, c.updated_at, c.parent_id, c.workspace_id, c.resolved_at, c.resolved_by_type, c.resolved_by_id, c.source_task_id, c.quick_action_id, c.via_plugin_id, c.revision, c.recovery_settled_at, c.deleted_at, c.suppressed_agent_ids, m.root_id
|
|
FROM membership m
|
|
JOIN comment c ON c.id = m.id
|
|
ORDER BY m.root_created_at DESC, m.root_id DESC, c.created_at ASC, c.id ASC
|
|
LIMIT $1
|
|
`
|
|
|
|
type ListCommentRepliesForRootsParams struct {
|
|
RowLimit int32 `json:"row_limit"`
|
|
RootIds []pgtype.UUID `json:"root_ids"`
|
|
IssueID pgtype.UUID `json:"issue_id"`
|
|
WorkspaceID pgtype.UUID `json:"workspace_id"`
|
|
}
|
|
|
|
type ListCommentRepliesForRootsRow struct {
|
|
Comment Comment `json:"comment"`
|
|
RootID pgtype.UUID `json:"root_id"`
|
|
}
|
|
|
|
// Every descendant of the given root comments, at any reply depth, each labelled
|
|
// with its thread root. Roots themselves are not returned.
|
|
//
|
|
// Rows come back grouped by root in the same order the roots page uses
|
|
// ((created_at, id) DESC) and chronologically inside a root, so a LIMIT cuts
|
|
// through at most one thread and a chronological prefix of a thread is closed
|
|
// under "parent of" (a reply is never older than its parent). The caller probes
|
|
// with limit + 1 and drops the trailing partial thread.
|
|
//
|
|
// Both tenant predicates apply at every level of the walk, and @root_ids only
|
|
// matches top-level comments of this issue, so an id from elsewhere expands to
|
|
// nothing.
|
|
func (q *Queries) ListCommentRepliesForRoots(ctx context.Context, arg ListCommentRepliesForRootsParams) ([]ListCommentRepliesForRootsRow, error) {
|
|
rows, err := q.db.Query(ctx, listCommentRepliesForRoots,
|
|
arg.RowLimit,
|
|
arg.RootIds,
|
|
arg.IssueID,
|
|
arg.WorkspaceID,
|
|
)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []ListCommentRepliesForRootsRow{}
|
|
for rows.Next() {
|
|
var i ListCommentRepliesForRootsRow
|
|
if err := rows.Scan(
|
|
&i.Comment.ID,
|
|
&i.Comment.IssueID,
|
|
&i.Comment.AuthorType,
|
|
&i.Comment.AuthorID,
|
|
&i.Comment.Content,
|
|
&i.Comment.Type,
|
|
&i.Comment.CreatedAt,
|
|
&i.Comment.UpdatedAt,
|
|
&i.Comment.ParentID,
|
|
&i.Comment.WorkspaceID,
|
|
&i.Comment.ResolvedAt,
|
|
&i.Comment.ResolvedByType,
|
|
&i.Comment.ResolvedByID,
|
|
&i.Comment.SourceTaskID,
|
|
&i.Comment.QuickActionID,
|
|
&i.Comment.ViaPluginID,
|
|
&i.Comment.Revision,
|
|
&i.Comment.RecoverySettledAt,
|
|
&i.Comment.DeletedAt,
|
|
&i.Comment.SuppressedAgentIds,
|
|
&i.RootID,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const listCommentRootsForIssueBefore = `-- name: ListCommentRootsForIssueBefore :many
|
|
SELECT id, issue_id, author_type, author_id, content, type, created_at, updated_at, parent_id, workspace_id, resolved_at, resolved_by_type, resolved_by_id, source_task_id, quick_action_id, via_plugin_id, revision, recovery_settled_at, deleted_at, suppressed_agent_ids FROM comment
|
|
WHERE issue_id = $1
|
|
AND workspace_id = $2
|
|
AND parent_id IS NULL
|
|
AND (
|
|
$3::boolean = FALSE
|
|
OR (created_at, id) < ($4::timestamptz, $5::uuid)
|
|
)
|
|
ORDER BY created_at DESC, id DESC
|
|
LIMIT $6
|
|
`
|
|
|
|
type ListCommentRootsForIssueBeforeParams struct {
|
|
IssueID pgtype.UUID `json:"issue_id"`
|
|
WorkspaceID pgtype.UUID `json:"workspace_id"`
|
|
HasCursor bool `json:"has_cursor"`
|
|
BeforeAt pgtype.Timestamptz `json:"before_at"`
|
|
BeforeID pgtype.UUID `json:"before_id"`
|
|
RowLimit int32 `json:"row_limit"`
|
|
}
|
|
|
|
// Top-level comments (parent_id IS NULL) of an issue, newest first, strictly
|
|
// older than the (@before_at, @before_id) cursor when @has_cursor is TRUE.
|
|
//
|
|
// Powers the root-paged timeline: a page is a set of whole threads, so the page
|
|
// boundary can never split a reply thread (the reason time-based paging was
|
|
// removed earlier). Tombstoned roots (deleted_at set) stay in the page like
|
|
// ListCommentsForIssue returns them, because their replies still render under
|
|
// them. Callers pass limit + 1 to probe for an older page.
|
|
func (q *Queries) ListCommentRootsForIssueBefore(ctx context.Context, arg ListCommentRootsForIssueBeforeParams) ([]Comment, error) {
|
|
rows, err := q.db.Query(ctx, listCommentRootsForIssueBefore,
|
|
arg.IssueID,
|
|
arg.WorkspaceID,
|
|
arg.HasCursor,
|
|
arg.BeforeAt,
|
|
arg.BeforeID,
|
|
arg.RowLimit,
|
|
)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []Comment{}
|
|
for rows.Next() {
|
|
var i Comment
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.IssueID,
|
|
&i.AuthorType,
|
|
&i.AuthorID,
|
|
&i.Content,
|
|
&i.Type,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.ParentID,
|
|
&i.WorkspaceID,
|
|
&i.ResolvedAt,
|
|
&i.ResolvedByType,
|
|
&i.ResolvedByID,
|
|
&i.SourceTaskID,
|
|
&i.QuickActionID,
|
|
&i.ViaPluginID,
|
|
&i.Revision,
|
|
&i.RecoverySettledAt,
|
|
&i.DeletedAt,
|
|
&i.SuppressedAgentIds,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const listCommentThreadHistory = `-- name: ListCommentThreadHistory :many
|
|
WITH RECURSIVE thread_history AS (
|
|
SELECT root.id, root.issue_id, root.author_type, root.author_id, root.content, root.type, root.created_at, root.updated_at, root.parent_id, root.workspace_id, root.resolved_at, root.resolved_by_type, root.resolved_by_id, root.source_task_id, root.quick_action_id, root.via_plugin_id, root.revision, root.recovery_settled_at, root.deleted_at, root.suppressed_agent_ids
|
|
FROM comment root
|
|
WHERE root.id = $2
|
|
AND root.workspace_id = $3
|
|
AND root.issue_id = $4
|
|
AND root.parent_id IS NULL
|
|
AND (root.created_at, root.id) <= (
|
|
$5::timestamptz,
|
|
$6::uuid
|
|
)
|
|
|
|
UNION ALL
|
|
|
|
SELECT child.id, child.issue_id, child.author_type, child.author_id, child.content, child.type, child.created_at, child.updated_at, child.parent_id, child.workspace_id, child.resolved_at, child.resolved_by_type, child.resolved_by_id, child.source_task_id, child.quick_action_id, child.via_plugin_id, child.revision, child.recovery_settled_at, child.deleted_at, child.suppressed_agent_ids
|
|
FROM comment child
|
|
JOIN thread_history parent ON child.parent_id = parent.id
|
|
WHERE child.workspace_id = $3
|
|
AND child.issue_id = $4
|
|
AND (child.created_at, child.id) <= (
|
|
$5::timestamptz,
|
|
$6::uuid
|
|
)
|
|
)
|
|
SELECT id, issue_id, author_type, author_id, content, type, created_at, updated_at, parent_id, workspace_id, resolved_at, resolved_by_type, resolved_by_id, source_task_id, quick_action_id, via_plugin_id, revision, recovery_settled_at, deleted_at, suppressed_agent_ids
|
|
FROM thread_history
|
|
ORDER BY created_at, id
|
|
LIMIT $1
|
|
`
|
|
|
|
type ListCommentThreadHistoryParams struct {
|
|
RowLimit int32 `json:"row_limit"`
|
|
RootID pgtype.UUID `json:"root_id"`
|
|
WorkspaceID pgtype.UUID `json:"workspace_id"`
|
|
IssueID pgtype.UUID `json:"issue_id"`
|
|
AnchorCreatedAt pgtype.Timestamptz `json:"anchor_created_at"`
|
|
AnchorID pgtype.UUID `json:"anchor_id"`
|
|
}
|
|
|
|
type ListCommentThreadHistoryRow struct {
|
|
ID pgtype.UUID `json:"id"`
|
|
IssueID pgtype.UUID `json:"issue_id"`
|
|
AuthorType string `json:"author_type"`
|
|
AuthorID pgtype.UUID `json:"author_id"`
|
|
Content string `json:"content"`
|
|
Type string `json:"type"`
|
|
CreatedAt pgtype.Timestamptz `json:"created_at"`
|
|
UpdatedAt pgtype.Timestamptz `json:"updated_at"`
|
|
ParentID pgtype.UUID `json:"parent_id"`
|
|
WorkspaceID pgtype.UUID `json:"workspace_id"`
|
|
ResolvedAt pgtype.Timestamptz `json:"resolved_at"`
|
|
ResolvedByType pgtype.Text `json:"resolved_by_type"`
|
|
ResolvedByID pgtype.UUID `json:"resolved_by_id"`
|
|
SourceTaskID pgtype.UUID `json:"source_task_id"`
|
|
QuickActionID pgtype.UUID `json:"quick_action_id"`
|
|
ViaPluginID pgtype.UUID `json:"via_plugin_id"`
|
|
Revision int64 `json:"revision"`
|
|
RecoverySettledAt pgtype.Timestamptz `json:"recovery_settled_at"`
|
|
DeletedAt pgtype.Timestamptz `json:"deleted_at"`
|
|
SuppressedAgentIds []pgtype.UUID `json:"suppressed_agent_ids"`
|
|
}
|
|
|
|
// Capture the anchor comment's complete chronological thread through that
|
|
// comment. Later replies are outside the immutable context boundary.
|
|
// UUID is the stable tiebreaker used by the issue timeline when timestamps tie.
|
|
func (q *Queries) ListCommentThreadHistory(ctx context.Context, arg ListCommentThreadHistoryParams) ([]ListCommentThreadHistoryRow, error) {
|
|
rows, err := q.db.Query(ctx, listCommentThreadHistory,
|
|
arg.RowLimit,
|
|
arg.RootID,
|
|
arg.WorkspaceID,
|
|
arg.IssueID,
|
|
arg.AnchorCreatedAt,
|
|
arg.AnchorID,
|
|
)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []ListCommentThreadHistoryRow{}
|
|
for rows.Next() {
|
|
var i ListCommentThreadHistoryRow
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.IssueID,
|
|
&i.AuthorType,
|
|
&i.AuthorID,
|
|
&i.Content,
|
|
&i.Type,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.ParentID,
|
|
&i.WorkspaceID,
|
|
&i.ResolvedAt,
|
|
&i.ResolvedByType,
|
|
&i.ResolvedByID,
|
|
&i.SourceTaskID,
|
|
&i.QuickActionID,
|
|
&i.ViaPluginID,
|
|
&i.Revision,
|
|
&i.RecoverySettledAt,
|
|
&i.DeletedAt,
|
|
&i.SuppressedAgentIds,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const listCommentsByIDsForIssue = `-- name: ListCommentsByIDsForIssue :many
|
|
SELECT id, issue_id, author_type, author_id, content, type, created_at, updated_at, parent_id, workspace_id, resolved_at, resolved_by_type, resolved_by_id, source_task_id, quick_action_id, via_plugin_id, revision, recovery_settled_at, deleted_at, suppressed_agent_ids FROM comment
|
|
WHERE id = ANY($1::uuid[])
|
|
AND issue_id = $2
|
|
AND workspace_id = $3
|
|
ORDER BY created_at ASC, id ASC
|
|
`
|
|
|
|
type ListCommentsByIDsForIssueParams struct {
|
|
Ids []pgtype.UUID `json:"ids"`
|
|
IssueID pgtype.UUID `json:"issue_id"`
|
|
WorkspaceID pgtype.UUID `json:"workspace_id"`
|
|
}
|
|
|
|
// The subset of @ids that exists within this issue and workspace.
|
|
//
|
|
// Used to walk parent chains one level at a time (see completeCommentThreads).
|
|
// Deliberately NOT a recursive CTE: an earlier revision walked parent_id upward
|
|
// in SQL, which had no depth bound — a deep chain could pull tens of thousands of
|
|
// ancestors back and defeat the whole point of the row cap — and its recursive
|
|
// branch matched on parent_id alone, so a stray cross-workspace parent reference
|
|
// would have dragged another tenant's comments into the response. Both tenant
|
|
// columns are required here on every level, and the caller owns the budget.
|
|
func (q *Queries) ListCommentsByIDsForIssue(ctx context.Context, arg ListCommentsByIDsForIssueParams) ([]Comment, error) {
|
|
rows, err := q.db.Query(ctx, listCommentsByIDsForIssue, arg.Ids, arg.IssueID, arg.WorkspaceID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []Comment{}
|
|
for rows.Next() {
|
|
var i Comment
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.IssueID,
|
|
&i.AuthorType,
|
|
&i.AuthorID,
|
|
&i.Content,
|
|
&i.Type,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.ParentID,
|
|
&i.WorkspaceID,
|
|
&i.ResolvedAt,
|
|
&i.ResolvedByType,
|
|
&i.ResolvedByID,
|
|
&i.SourceTaskID,
|
|
&i.QuickActionID,
|
|
&i.ViaPluginID,
|
|
&i.Revision,
|
|
&i.RecoverySettledAt,
|
|
&i.DeletedAt,
|
|
&i.SuppressedAgentIds,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const listCommentsForIssue = `-- name: ListCommentsForIssue :many
|
|
SELECT id, issue_id, author_type, author_id, content, type, created_at, updated_at, parent_id, workspace_id, resolved_at, resolved_by_type, resolved_by_id, source_task_id, quick_action_id, via_plugin_id, revision, recovery_settled_at, deleted_at, suppressed_agent_ids FROM (
|
|
SELECT id, issue_id, author_type, author_id, content, type, created_at, updated_at, parent_id, workspace_id, resolved_at, resolved_by_type, resolved_by_id, source_task_id, quick_action_id, via_plugin_id, revision, recovery_settled_at, deleted_at, suppressed_agent_ids FROM comment
|
|
WHERE issue_id = $1 AND workspace_id = $2
|
|
ORDER BY created_at DESC, id DESC
|
|
LIMIT $3
|
|
) AS recent
|
|
ORDER BY created_at ASC, id ASC
|
|
`
|
|
|
|
type ListCommentsForIssueParams struct {
|
|
IssueID pgtype.UUID `json:"issue_id"`
|
|
WorkspaceID pgtype.UUID `json:"workspace_id"`
|
|
Limit int32 `json:"limit"`
|
|
}
|
|
|
|
// The NEWEST $3 comments for an issue, returned in chronological order.
|
|
//
|
|
// Same shape and same reason as ListActivitiesForIssue: the inner query takes
|
|
// the window with the keyset ordering so the cap discards the OLDEST rows, and
|
|
// the outer query restores the ascending contract callers rely on. The ordering
|
|
// of the inner window is satisfied by idx_comment_issue_keyset (migration 068);
|
|
// the outer query sorts that bounded window back into chronological order.
|
|
//
|
|
// A newest-N window is a suffix of the timeline, and unlike a prefix it is NOT
|
|
// closed under "parent of": a reply is always newer than its parent, so an old
|
|
// thread root can fall outside the window while a fresh reply to it stays
|
|
// inside. Callers that render threads must close the parent chains afterwards —
|
|
// see completeCommentThreads (MUL-5492).
|
|
//
|
|
// The cap is still purely defensive here — issue p99 is ~30 comments and the max
|
|
// ever observed in prod is ~1.1k — but "defensive" is not a reason to drop the
|
|
// newest rows when it does fire (MUL-5492).
|
|
func (q *Queries) ListCommentsForIssue(ctx context.Context, arg ListCommentsForIssueParams) ([]Comment, error) {
|
|
rows, err := q.db.Query(ctx, listCommentsForIssue, arg.IssueID, arg.WorkspaceID, arg.Limit)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []Comment{}
|
|
for rows.Next() {
|
|
var i Comment
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.IssueID,
|
|
&i.AuthorType,
|
|
&i.AuthorID,
|
|
&i.Content,
|
|
&i.Type,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.ParentID,
|
|
&i.WorkspaceID,
|
|
&i.ResolvedAt,
|
|
&i.ResolvedByType,
|
|
&i.ResolvedByID,
|
|
&i.SourceTaskID,
|
|
&i.QuickActionID,
|
|
&i.ViaPluginID,
|
|
&i.Revision,
|
|
&i.RecoverySettledAt,
|
|
&i.DeletedAt,
|
|
&i.SuppressedAgentIds,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const listCommentsSinceForIssue = `-- name: ListCommentsSinceForIssue :many
|
|
SELECT id, issue_id, author_type, author_id, content, type, created_at, updated_at, parent_id, workspace_id, resolved_at, resolved_by_type, resolved_by_id, source_task_id, quick_action_id, via_plugin_id, revision, recovery_settled_at, deleted_at, suppressed_agent_ids FROM comment
|
|
WHERE issue_id = $1 AND workspace_id = $2 AND created_at > $3
|
|
ORDER BY created_at ASC, id ASC
|
|
LIMIT $4
|
|
`
|
|
|
|
type ListCommentsSinceForIssueParams struct {
|
|
IssueID pgtype.UUID `json:"issue_id"`
|
|
WorkspaceID pgtype.UUID `json:"workspace_id"`
|
|
CreatedAt pgtype.Timestamptz `json:"created_at"`
|
|
Limit int32 `json:"limit"`
|
|
}
|
|
|
|
// Comments created strictly after $3 in chronological order, capped at $4.
|
|
// Powers the CLI's `--since` agent-polling flow.
|
|
func (q *Queries) ListCommentsSinceForIssue(ctx context.Context, arg ListCommentsSinceForIssueParams) ([]Comment, error) {
|
|
rows, err := q.db.Query(ctx, listCommentsSinceForIssue,
|
|
arg.IssueID,
|
|
arg.WorkspaceID,
|
|
arg.CreatedAt,
|
|
arg.Limit,
|
|
)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []Comment{}
|
|
for rows.Next() {
|
|
var i Comment
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.IssueID,
|
|
&i.AuthorType,
|
|
&i.AuthorID,
|
|
&i.Content,
|
|
&i.Type,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.ParentID,
|
|
&i.WorkspaceID,
|
|
&i.ResolvedAt,
|
|
&i.ResolvedByType,
|
|
&i.ResolvedByID,
|
|
&i.SourceTaskID,
|
|
&i.QuickActionID,
|
|
&i.ViaPluginID,
|
|
&i.Revision,
|
|
&i.RecoverySettledAt,
|
|
&i.DeletedAt,
|
|
&i.SuppressedAgentIds,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const listIssueDeliverableSummaries = `-- name: ListIssueDeliverableSummaries :many
|
|
WITH files AS (
|
|
SELECT c.issue_id,
|
|
lower(btrim(split_part(a.content_type, ';', 1))) AS media_type,
|
|
btrim(a.filename) AS file_name,
|
|
MAX(a.created_at) AS latest_at
|
|
FROM attachment a
|
|
JOIN comment c ON c.id = a.comment_id
|
|
WHERE c.workspace_id = $1
|
|
AND a.workspace_id = $1
|
|
AND c.issue_id = ANY($2::uuid[])
|
|
AND c.deleted_at IS NULL
|
|
GROUP BY c.issue_id, 2, 3
|
|
)
|
|
SELECT issue_id,
|
|
COUNT(*)::bigint AS deliverable_count,
|
|
MAX(latest_at)::timestamptz AS last_deliverable_at
|
|
FROM files
|
|
GROUP BY issue_id
|
|
`
|
|
|
|
type ListIssueDeliverableSummariesParams struct {
|
|
WorkspaceID pgtype.UUID `json:"workspace_id"`
|
|
IssueIds []pgtype.UUID `json:"issue_ids"`
|
|
}
|
|
|
|
type ListIssueDeliverableSummariesRow struct {
|
|
IssueID pgtype.UUID `json:"issue_id"`
|
|
DeliverableCount int64 `json:"deliverable_count"`
|
|
LastDeliverableAt pgtype.Timestamptz `json:"last_deliverable_at"`
|
|
}
|
|
|
|
// Per-issue deliverable rollup for the project feed's output strip. A
|
|
// deliverable is a file uploaded in a live comment; description attachments
|
|
// are inputs, not output. Uploads with the same media type (parameters
|
|
// dropped, case-insensitive) and filename are versions of ONE file, so each
|
|
// group counts once and the group's newest upload dates it. This is the SQL
|
|
// twin of deliverableKey / collectDeliverableFiles in
|
|
// packages/core/attachments/deliverables.ts.
|
|
func (q *Queries) ListIssueDeliverableSummaries(ctx context.Context, arg ListIssueDeliverableSummariesParams) ([]ListIssueDeliverableSummariesRow, error) {
|
|
rows, err := q.db.Query(ctx, listIssueDeliverableSummaries, arg.WorkspaceID, arg.IssueIds)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []ListIssueDeliverableSummariesRow{}
|
|
for rows.Next() {
|
|
var i ListIssueDeliverableSummariesRow
|
|
if err := rows.Scan(&i.IssueID, &i.DeliverableCount, &i.LastDeliverableAt); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const listIssueThreadParticipants = `-- name: ListIssueThreadParticipants :many
|
|
SELECT issue_id, author_type, author_id, MAX(created_at)::timestamptz AS last_at
|
|
FROM comment
|
|
WHERE workspace_id = $1
|
|
AND issue_id = ANY($2::uuid[])
|
|
AND deleted_at IS NULL
|
|
AND author_type <> 'system'
|
|
GROUP BY issue_id, author_type, author_id
|
|
ORDER BY issue_id, last_at DESC
|
|
`
|
|
|
|
type ListIssueThreadParticipantsParams struct {
|
|
WorkspaceID pgtype.UUID `json:"workspace_id"`
|
|
IssueIds []pgtype.UUID `json:"issue_ids"`
|
|
}
|
|
|
|
type ListIssueThreadParticipantsRow struct {
|
|
IssueID pgtype.UUID `json:"issue_id"`
|
|
AuthorType string `json:"author_type"`
|
|
AuthorID pgtype.UUID `json:"author_id"`
|
|
LastAt pgtype.Timestamptz `json:"last_at"`
|
|
}
|
|
|
|
// Distinct commenters per issue, most recently active first; the caller keeps
|
|
// the first few per issue.
|
|
func (q *Queries) ListIssueThreadParticipants(ctx context.Context, arg ListIssueThreadParticipantsParams) ([]ListIssueThreadParticipantsRow, error) {
|
|
rows, err := q.db.Query(ctx, listIssueThreadParticipants, arg.WorkspaceID, arg.IssueIds)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []ListIssueThreadParticipantsRow{}
|
|
for rows.Next() {
|
|
var i ListIssueThreadParticipantsRow
|
|
if err := rows.Scan(
|
|
&i.IssueID,
|
|
&i.AuthorType,
|
|
&i.AuthorID,
|
|
&i.LastAt,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const listIssueThreadPullRequests = `-- name: ListIssueThreadPullRequests :many
|
|
WITH ranked AS (
|
|
SELECT ipr.issue_id,
|
|
pr.id AS pr_id,
|
|
ROW_NUMBER() OVER (
|
|
PARTITION BY ipr.issue_id
|
|
ORDER BY pr.pr_created_at DESC, pr.id DESC
|
|
) AS rn
|
|
FROM issue_pull_request ipr
|
|
JOIN github_pull_request pr ON pr.id = ipr.pull_request_id
|
|
JOIN issue i ON i.id = ipr.issue_id
|
|
WHERE ipr.issue_id = ANY($1::uuid[])
|
|
AND i.workspace_id = $2
|
|
AND pr.workspace_id = $2
|
|
),
|
|
top AS (
|
|
SELECT issue_id, pr_id FROM ranked WHERE rn <= $3::int
|
|
),
|
|
checks AS (
|
|
SELECT
|
|
cr.pr_id,
|
|
SUM(CASE WHEN cr.status = 'completed' AND cr.conclusion IN
|
|
('failure','cancelled','timed_out','action_required','startup_failure','stale','error')
|
|
THEN 1 ELSE 0 END)::bigint AS failed,
|
|
SUM(CASE WHEN cr.status = 'completed' AND cr.conclusion IN
|
|
('success','neutral','skipped')
|
|
THEN 1 ELSE 0 END)::bigint AS passed,
|
|
SUM(CASE WHEN cr.status <> 'completed' OR cr.conclusion IS NULL
|
|
THEN 1 ELSE 0 END)::bigint AS running
|
|
FROM github_pull_request_check_run cr
|
|
JOIN github_pull_request pr ON pr.id = cr.pr_id
|
|
WHERE cr.pr_id IN (SELECT pr_id FROM top)
|
|
AND pr.snapshot_head_sha <> ''
|
|
AND cr.head_sha = pr.snapshot_head_sha
|
|
GROUP BY cr.pr_id
|
|
)
|
|
SELECT
|
|
top.issue_id,
|
|
pr.id, pr.pr_number, pr.title, pr.state, pr.html_url,
|
|
pr.additions, pr.deletions, pr.pr_created_at,
|
|
pr.head_sha, pr.snapshot_head_sha, pr.snapshot_fetched_at, pr.checks_rollup_state,
|
|
COALESCE(c.passed, 0)::bigint AS checks_passed,
|
|
COALESCE(c.failed, 0)::bigint AS checks_failed,
|
|
COALESCE(c.running, 0)::bigint AS checks_running
|
|
FROM top
|
|
JOIN github_pull_request pr ON pr.id = top.pr_id
|
|
LEFT JOIN checks c ON c.pr_id = pr.id
|
|
ORDER BY top.issue_id, pr.pr_created_at DESC, pr.id DESC
|
|
`
|
|
|
|
type ListIssueThreadPullRequestsParams struct {
|
|
IssueIds []pgtype.UUID `json:"issue_ids"`
|
|
WorkspaceID pgtype.UUID `json:"workspace_id"`
|
|
PrLimit int32 `json:"pr_limit"`
|
|
}
|
|
|
|
type ListIssueThreadPullRequestsRow struct {
|
|
IssueID pgtype.UUID `json:"issue_id"`
|
|
ID pgtype.UUID `json:"id"`
|
|
PrNumber int32 `json:"pr_number"`
|
|
Title string `json:"title"`
|
|
State string `json:"state"`
|
|
HtmlUrl string `json:"html_url"`
|
|
Additions int32 `json:"additions"`
|
|
Deletions int32 `json:"deletions"`
|
|
PrCreatedAt pgtype.Timestamptz `json:"pr_created_at"`
|
|
HeadSha string `json:"head_sha"`
|
|
SnapshotHeadSha string `json:"snapshot_head_sha"`
|
|
SnapshotFetchedAt pgtype.Timestamptz `json:"snapshot_fetched_at"`
|
|
ChecksRollupState pgtype.Text `json:"checks_rollup_state"`
|
|
ChecksPassed int64 `json:"checks_passed"`
|
|
ChecksFailed int64 `json:"checks_failed"`
|
|
ChecksRunning int64 `json:"checks_running"`
|
|
}
|
|
|
|
// The newest linked GitHub PRs for a batch of issues, at most pr_limit per
|
|
// issue, for the project feed's output strip. Same snapshot and check-run
|
|
// aggregation as ListPullRequestsByIssue (current snapshot head only), but
|
|
// narrowed to the ranked PR ids first so check rows are read for those PRs
|
|
// alone. Rows arrive ordered by issue, then newest PR first.
|
|
func (q *Queries) ListIssueThreadPullRequests(ctx context.Context, arg ListIssueThreadPullRequestsParams) ([]ListIssueThreadPullRequestsRow, error) {
|
|
rows, err := q.db.Query(ctx, listIssueThreadPullRequests, arg.IssueIds, arg.WorkspaceID, arg.PrLimit)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []ListIssueThreadPullRequestsRow{}
|
|
for rows.Next() {
|
|
var i ListIssueThreadPullRequestsRow
|
|
if err := rows.Scan(
|
|
&i.IssueID,
|
|
&i.ID,
|
|
&i.PrNumber,
|
|
&i.Title,
|
|
&i.State,
|
|
&i.HtmlUrl,
|
|
&i.Additions,
|
|
&i.Deletions,
|
|
&i.PrCreatedAt,
|
|
&i.HeadSha,
|
|
&i.SnapshotHeadSha,
|
|
&i.SnapshotFetchedAt,
|
|
&i.ChecksRollupState,
|
|
&i.ChecksPassed,
|
|
&i.ChecksFailed,
|
|
&i.ChecksRunning,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const listIssueThreadSummaries = `-- name: ListIssueThreadSummaries :many
|
|
SELECT s.issue_id,
|
|
s.reply_count,
|
|
s.last_reply_at,
|
|
s.open_thread_count,
|
|
l.content AS last_reply_content
|
|
FROM (
|
|
SELECT cm.issue_id,
|
|
COUNT(*)::bigint AS reply_count,
|
|
MAX(cm.created_at)::timestamptz AS last_reply_at,
|
|
COUNT(*) FILTER (WHERE cm.parent_id IS NULL AND cm.resolved_at IS NULL)::bigint AS open_thread_count
|
|
FROM comment cm
|
|
WHERE cm.workspace_id = $1
|
|
AND cm.issue_id = ANY($2::uuid[])
|
|
AND cm.deleted_at IS NULL
|
|
AND cm.author_type <> 'system'
|
|
GROUP BY cm.issue_id
|
|
) s
|
|
CROSS JOIN LATERAL (
|
|
SELECT LEFT(c.content, 2000)::text AS content
|
|
FROM comment c
|
|
WHERE c.issue_id = s.issue_id
|
|
AND c.deleted_at IS NULL
|
|
AND c.author_type <> 'system'
|
|
ORDER BY c.created_at DESC, c.id DESC
|
|
LIMIT 1
|
|
) l
|
|
`
|
|
|
|
type ListIssueThreadSummariesParams struct {
|
|
WorkspaceID pgtype.UUID `json:"workspace_id"`
|
|
IssueIds []pgtype.UUID `json:"issue_ids"`
|
|
}
|
|
|
|
type ListIssueThreadSummariesRow struct {
|
|
IssueID pgtype.UUID `json:"issue_id"`
|
|
ReplyCount int64 `json:"reply_count"`
|
|
LastReplyAt pgtype.Timestamptz `json:"last_reply_at"`
|
|
OpenThreadCount int64 `json:"open_thread_count"`
|
|
LastReplyContent string `json:"last_reply_content"`
|
|
}
|
|
|
|
// Per-issue comment rollup for the project feed. System rows (platform
|
|
// notices) and soft-deleted comments are not conversation, so they are not
|
|
// counted. A thread is open when its root comment is unresolved. The newest
|
|
// counted comment's body is returned (capped) for the caller to flatten into
|
|
// a one-line excerpt.
|
|
func (q *Queries) ListIssueThreadSummaries(ctx context.Context, arg ListIssueThreadSummariesParams) ([]ListIssueThreadSummariesRow, error) {
|
|
rows, err := q.db.Query(ctx, listIssueThreadSummaries, arg.WorkspaceID, arg.IssueIds)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []ListIssueThreadSummariesRow{}
|
|
for rows.Next() {
|
|
var i ListIssueThreadSummariesRow
|
|
if err := rows.Scan(
|
|
&i.IssueID,
|
|
&i.ReplyCount,
|
|
&i.LastReplyAt,
|
|
&i.OpenThreadCount,
|
|
&i.LastReplyContent,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const listIssueThreadVCSPullRequests = `-- name: ListIssueThreadVCSPullRequests :many
|
|
WITH ranked AS (
|
|
SELECT ipr.issue_id,
|
|
pr.id AS pr_id,
|
|
ROW_NUMBER() OVER (
|
|
PARTITION BY ipr.issue_id
|
|
ORDER BY pr.pr_created_at DESC, pr.id DESC
|
|
) AS rn
|
|
FROM issue_vcs_pull_request ipr
|
|
JOIN vcs_pull_request pr ON pr.id = ipr.pull_request_id
|
|
JOIN issue i ON i.id = ipr.issue_id
|
|
WHERE ipr.issue_id = ANY($1::uuid[])
|
|
AND i.workspace_id = $2
|
|
AND pr.workspace_id = $2
|
|
),
|
|
top AS (
|
|
SELECT issue_id, pr_id FROM ranked WHERE rn <= $3::int
|
|
),
|
|
checks AS (
|
|
SELECT
|
|
pr.id AS pr_id,
|
|
COUNT(*)::bigint AS total,
|
|
SUM(CASE WHEN cs.state = 'failed' THEN 1 ELSE 0 END)::bigint AS failed,
|
|
SUM(CASE WHEN cs.state = 'passed' THEN 1 ELSE 0 END)::bigint AS passed,
|
|
SUM(CASE WHEN cs.state = 'pending' THEN 1 ELSE 0 END)::bigint AS pending
|
|
FROM vcs_pull_request pr
|
|
JOIN vcs_commit_status cs
|
|
ON cs.connection_id = pr.connection_id
|
|
AND cs.sha = pr.head_sha
|
|
WHERE pr.id IN (SELECT pr_id FROM top)
|
|
AND pr.head_sha <> ''
|
|
GROUP BY pr.id
|
|
)
|
|
SELECT
|
|
top.issue_id,
|
|
pr.id, pr.pr_number, pr.title, pr.state, pr.html_url,
|
|
pr.additions, pr.deletions, pr.pr_created_at,
|
|
COALESCE(c.total, 0)::bigint AS checks_total,
|
|
COALESCE(c.passed, 0)::bigint AS checks_passed,
|
|
COALESCE(c.failed, 0)::bigint AS checks_failed,
|
|
COALESCE(c.pending, 0)::bigint AS checks_pending
|
|
FROM top
|
|
JOIN vcs_pull_request pr ON pr.id = top.pr_id
|
|
LEFT JOIN checks c ON c.pr_id = pr.id
|
|
ORDER BY top.issue_id, pr.pr_created_at DESC, pr.id DESC
|
|
`
|
|
|
|
type ListIssueThreadVCSPullRequestsParams struct {
|
|
IssueIds []pgtype.UUID `json:"issue_ids"`
|
|
WorkspaceID pgtype.UUID `json:"workspace_id"`
|
|
PrLimit int32 `json:"pr_limit"`
|
|
}
|
|
|
|
type ListIssueThreadVCSPullRequestsRow struct {
|
|
IssueID pgtype.UUID `json:"issue_id"`
|
|
ID pgtype.UUID `json:"id"`
|
|
PrNumber int32 `json:"pr_number"`
|
|
Title string `json:"title"`
|
|
State string `json:"state"`
|
|
HtmlUrl string `json:"html_url"`
|
|
Additions int32 `json:"additions"`
|
|
Deletions int32 `json:"deletions"`
|
|
PrCreatedAt pgtype.Timestamptz `json:"pr_created_at"`
|
|
ChecksTotal int64 `json:"checks_total"`
|
|
ChecksPassed int64 `json:"checks_passed"`
|
|
ChecksFailed int64 `json:"checks_failed"`
|
|
ChecksPending int64 `json:"checks_pending"`
|
|
}
|
|
|
|
// ListIssueThreadPullRequests for token-based providers (Forgejo / Gitea /
|
|
// GitLab): commit statuses for the PR's current head sha, folded into
|
|
// passed/failed/pending counts like ListVCSPullRequestsByIssue.
|
|
func (q *Queries) ListIssueThreadVCSPullRequests(ctx context.Context, arg ListIssueThreadVCSPullRequestsParams) ([]ListIssueThreadVCSPullRequestsRow, error) {
|
|
rows, err := q.db.Query(ctx, listIssueThreadVCSPullRequests, arg.IssueIds, arg.WorkspaceID, arg.PrLimit)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []ListIssueThreadVCSPullRequestsRow{}
|
|
for rows.Next() {
|
|
var i ListIssueThreadVCSPullRequestsRow
|
|
if err := rows.Scan(
|
|
&i.IssueID,
|
|
&i.ID,
|
|
&i.PrNumber,
|
|
&i.Title,
|
|
&i.State,
|
|
&i.HtmlUrl,
|
|
&i.Additions,
|
|
&i.Deletions,
|
|
&i.PrCreatedAt,
|
|
&i.ChecksTotal,
|
|
&i.ChecksPassed,
|
|
&i.ChecksFailed,
|
|
&i.ChecksPending,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const listLatestProgressCommentsForIssues = `-- name: ListLatestProgressCommentsForIssues :many
|
|
SELECT DISTINCT ON (issue_id) issue_id, id AS comment_id, content, created_at
|
|
FROM comment
|
|
WHERE workspace_id = $1
|
|
AND issue_id = ANY($2::uuid[])
|
|
AND deleted_at IS NULL
|
|
AND type = 'progress_update'
|
|
AND author_type = 'agent'
|
|
AND content ~ '(^|\n)[ \t]*[-*+][ \t]+\[[ xX]\]'
|
|
ORDER BY issue_id, created_at DESC, id DESC
|
|
`
|
|
|
|
type ListLatestProgressCommentsForIssuesParams struct {
|
|
WorkspaceID pgtype.UUID `json:"workspace_id"`
|
|
IssueIds []pgtype.UUID `json:"issue_ids"`
|
|
}
|
|
|
|
type ListLatestProgressCommentsForIssuesRow struct {
|
|
IssueID pgtype.UUID `json:"issue_id"`
|
|
CommentID pgtype.UUID `json:"comment_id"`
|
|
Content string `json:"content"`
|
|
CreatedAt pgtype.Timestamptz `json:"created_at"`
|
|
}
|
|
|
|
// The newest agent progress report per issue: a non-deleted progress_update
|
|
// comment whose body holds a Markdown task list (a "- [ ]" / "- [x]" item,
|
|
// any bullet marker and indentation). Reports without a checklist are not
|
|
// progress the feed can render, so they never shadow an older checklist.
|
|
func (q *Queries) ListLatestProgressCommentsForIssues(ctx context.Context, arg ListLatestProgressCommentsForIssuesParams) ([]ListLatestProgressCommentsForIssuesRow, error) {
|
|
rows, err := q.db.Query(ctx, listLatestProgressCommentsForIssues, arg.WorkspaceID, arg.IssueIds)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []ListLatestProgressCommentsForIssuesRow{}
|
|
for rows.Next() {
|
|
var i ListLatestProgressCommentsForIssuesRow
|
|
if err := rows.Scan(
|
|
&i.IssueID,
|
|
&i.CommentID,
|
|
&i.Content,
|
|
&i.CreatedAt,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const listRecentThreadCommentsForIssue = `-- name: ListRecentThreadCommentsForIssue :many
|
|
WITH RECURSIVE membership(id, root_id, comment_created_at) AS (
|
|
-- Each root maps to itself.
|
|
SELECT c.id, c.id AS root_id, c.created_at
|
|
FROM comment c
|
|
WHERE c.issue_id = $1
|
|
AND c.workspace_id = $2
|
|
AND c.parent_id IS NULL
|
|
UNION ALL
|
|
-- Each descendant inherits its parent's root_id.
|
|
SELECT c.id, m.root_id, c.created_at
|
|
FROM comment c
|
|
JOIN membership m ON c.parent_id = m.id
|
|
WHERE c.issue_id = $1
|
|
AND c.workspace_id = $2
|
|
),
|
|
thread_stats AS (
|
|
SELECT root_id, MAX(comment_created_at)::timestamptz AS last_activity_at
|
|
FROM membership
|
|
GROUP BY root_id
|
|
),
|
|
picked AS (
|
|
SELECT ts.root_id, ts.last_activity_at
|
|
FROM thread_stats ts
|
|
WHERE (
|
|
$3::boolean = FALSE
|
|
OR (ts.last_activity_at, ts.root_id) < ($4::timestamptz, $5::uuid)
|
|
)
|
|
ORDER BY ts.last_activity_at DESC, ts.root_id DESC
|
|
LIMIT $6
|
|
)
|
|
SELECT c.id, c.issue_id, c.author_type, c.author_id, c.content, c.type,
|
|
c.created_at, c.updated_at, c.parent_id, c.workspace_id,
|
|
c.resolved_at, c.resolved_by_type, c.resolved_by_id,
|
|
c.source_task_id, c.quick_action_id, c.revision, c.deleted_at,
|
|
p.root_id AS thread_root_id,
|
|
p.last_activity_at AS thread_last_activity_at
|
|
FROM picked p
|
|
JOIN membership m ON m.root_id = p.root_id
|
|
JOIN comment c ON c.id = m.id
|
|
ORDER BY p.last_activity_at ASC, p.root_id ASC, c.created_at ASC, c.id ASC
|
|
`
|
|
|
|
type ListRecentThreadCommentsForIssueParams struct {
|
|
IssueID pgtype.UUID `json:"issue_id"`
|
|
WorkspaceID pgtype.UUID `json:"workspace_id"`
|
|
HasCursor bool `json:"has_cursor"`
|
|
BeforeAt pgtype.Timestamptz `json:"before_at"`
|
|
BeforeID pgtype.UUID `json:"before_id"`
|
|
ThreadLimit int32 `json:"thread_limit"`
|
|
}
|
|
|
|
type ListRecentThreadCommentsForIssueRow struct {
|
|
ID pgtype.UUID `json:"id"`
|
|
IssueID pgtype.UUID `json:"issue_id"`
|
|
AuthorType string `json:"author_type"`
|
|
AuthorID pgtype.UUID `json:"author_id"`
|
|
Content string `json:"content"`
|
|
Type string `json:"type"`
|
|
CreatedAt pgtype.Timestamptz `json:"created_at"`
|
|
UpdatedAt pgtype.Timestamptz `json:"updated_at"`
|
|
ParentID pgtype.UUID `json:"parent_id"`
|
|
WorkspaceID pgtype.UUID `json:"workspace_id"`
|
|
ResolvedAt pgtype.Timestamptz `json:"resolved_at"`
|
|
ResolvedByType pgtype.Text `json:"resolved_by_type"`
|
|
ResolvedByID pgtype.UUID `json:"resolved_by_id"`
|
|
SourceTaskID pgtype.UUID `json:"source_task_id"`
|
|
QuickActionID pgtype.UUID `json:"quick_action_id"`
|
|
Revision int64 `json:"revision"`
|
|
DeletedAt pgtype.Timestamptz `json:"deleted_at"`
|
|
ThreadRootID pgtype.UUID `json:"thread_root_id"`
|
|
ThreadLastActivityAt pgtype.Timestamptz `json:"thread_last_activity_at"`
|
|
}
|
|
|
|
// Returns the N most recently active threads (root + every descendant) rather
|
|
// than the N most recent rows. A thread's "last activity" is MAX(created_at)
|
|
// over its whole subtree; threads are ranked by (last_activity_at DESC,
|
|
// root_id DESC) and the top N are expanded.
|
|
//
|
|
// Why thread-grouped instead of row-recent: with row-recent the newest 20
|
|
// comments can come from 8 different threads — the agent sees 8 unrelated
|
|
// tails. With thread-grouped the agent sees N complete conversational arcs,
|
|
// which matches how a human reads an issue (#2340).
|
|
//
|
|
// Response ordering:
|
|
//
|
|
// threads: (thread_last_activity_at ASC, root_id ASC)
|
|
// in-thread: (created_at ASC, id ASC)
|
|
//
|
|
// So the oldest-active thread appears first and the most recently-active
|
|
// thread is at the tail, closest to "now" in an agent prompt.
|
|
//
|
|
// Cursor scrolls back through threads. When @has_cursor=TRUE only threads
|
|
// with (last_activity_at, root_id) < (@before_at, @before_id) are eligible.
|
|
// The cursor is a THREAD cursor — both values identify a thread (its last
|
|
// activity timestamp and its root comment id), not a single row.
|
|
//
|
|
// The recursive `membership` CTE labels each comment with its thread root by
|
|
// walking down from every root. It does not assume any maximum nesting depth,
|
|
// which preserves correctness even if the schema ever allows reply-of-reply
|
|
// (the agent path in TaskService.createAgentComment collapses to root today,
|
|
// but the user-facing CreateComment handler does not enforce it).
|
|
func (q *Queries) ListRecentThreadCommentsForIssue(ctx context.Context, arg ListRecentThreadCommentsForIssueParams) ([]ListRecentThreadCommentsForIssueRow, error) {
|
|
rows, err := q.db.Query(ctx, listRecentThreadCommentsForIssue,
|
|
arg.IssueID,
|
|
arg.WorkspaceID,
|
|
arg.HasCursor,
|
|
arg.BeforeAt,
|
|
arg.BeforeID,
|
|
arg.ThreadLimit,
|
|
)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []ListRecentThreadCommentsForIssueRow{}
|
|
for rows.Next() {
|
|
var i ListRecentThreadCommentsForIssueRow
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.IssueID,
|
|
&i.AuthorType,
|
|
&i.AuthorID,
|
|
&i.Content,
|
|
&i.Type,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.ParentID,
|
|
&i.WorkspaceID,
|
|
&i.ResolvedAt,
|
|
&i.ResolvedByType,
|
|
&i.ResolvedByID,
|
|
&i.SourceTaskID,
|
|
&i.QuickActionID,
|
|
&i.Revision,
|
|
&i.DeletedAt,
|
|
&i.ThreadRootID,
|
|
&i.ThreadLastActivityAt,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const listReconcilableCommentsForIssueSince = `-- name: ListReconcilableCommentsForIssueSince :many
|
|
SELECT c.id, c.issue_id, c.author_type, c.author_id, c.content, c.type, c.created_at, c.updated_at, c.parent_id, c.workspace_id, c.resolved_at, c.resolved_by_type, c.resolved_by_id, c.source_task_id, c.quick_action_id, c.via_plugin_id, c.revision, c.recovery_settled_at, c.deleted_at, c.suppressed_agent_ids FROM comment c
|
|
WHERE c.issue_id = $1
|
|
AND (c.id = ANY($2::uuid[])
|
|
OR comment_thread_root_id(c.id) = $3::uuid)
|
|
-- A deleted comment is no longer input, even when replies keep its row.
|
|
AND c.deleted_at IS NULL
|
|
-- A comment that steered this agent's running turn belongs to that turn,
|
|
-- regardless of delivery status: failed delivery must not become an automatic
|
|
-- new run. The same comment still reconciles normally for any other agent
|
|
-- it addressed without steering.
|
|
AND NOT EXISTS (
|
|
SELECT 1 FROM task_supplement s
|
|
JOIN agent_task_queue bound ON bound.id = s.task_id
|
|
WHERE s.comment_id = c.id AND s.workspace_id = c.workspace_id
|
|
AND bound.agent_id = $4
|
|
)
|
|
-- An explicit member/agent cancellation acknowledges the planned input for
|
|
-- this agent only for completing tasks already in flight at cancellation;
|
|
-- automatic cancellations deliberately remain replayable.
|
|
AND NOT EXISTS (
|
|
SELECT 1
|
|
FROM agent_task_queue cancelled
|
|
WHERE cancelled.issue_id = c.issue_id
|
|
AND cancelled.agent_id = $4
|
|
AND cancelled.status = 'cancelled'
|
|
AND cancelled.cancelled_by_type IN ('member', 'agent')
|
|
AND cancelled.cancelled_by_id IS NOT NULL
|
|
AND cancelled.completed_at IS NOT NULL
|
|
AND cancelled.completed_at >= $5
|
|
AND c.updated_at <= cancelled.completed_at
|
|
AND (
|
|
cancelled.trigger_comment_id = c.id
|
|
OR c.id = ANY(cancelled.coalesced_comment_ids)
|
|
)
|
|
)
|
|
-- Nor does a comment whose author chose not to start this agent for it.
|
|
AND NOT COALESCE($4::uuid = ANY(c.suppressed_agent_ids), false)
|
|
AND (
|
|
(
|
|
c.author_type IN ('member', 'agent')
|
|
AND (c.created_at > $5 OR c.id = ANY($2::uuid[]))
|
|
)
|
|
OR (
|
|
c.author_type = 'system'
|
|
AND c.type = 'progress_update'
|
|
AND c.source_task_id IS NOT NULL
|
|
AND c.id = ANY($2::uuid[])
|
|
)
|
|
)
|
|
ORDER BY c.created_at ASC, c.id ASC
|
|
`
|
|
|
|
type ListReconcilableCommentsForIssueSinceParams struct {
|
|
IssueID pgtype.UUID `json:"issue_id"`
|
|
PlannedCommentIds []pgtype.UUID `json:"planned_comment_ids"`
|
|
CommentThreadID pgtype.UUID `json:"comment_thread_id"`
|
|
AgentID pgtype.UUID `json:"agent_id"`
|
|
Since pgtype.Timestamptz `json:"since"`
|
|
}
|
|
|
|
// MUL-4195 / MUL-4304 completion reconciliation: every MEMBER- or AGENT-authored
|
|
// comment on an issue created strictly after @since (the completing run's
|
|
// created_at anchor), plus every id in its planned trigger/coalesced batch.
|
|
// The one platform-authored exception is a delegated-failure recovery signal:
|
|
// author_type=system, type=progress_update, source_task_id set. Such a signal
|
|
// can be registered after a coordinator was claimed and must be replayed when
|
|
// that run completes; the handler routes it through the dedicated recovery
|
|
// path instead of generic comment/mention routing.
|
|
// Planned ids matter for retry children because their input comments predate
|
|
// the child's created_at; if one could not be embedded at claim time it still
|
|
// needs reconciliation. The handler excludes only delivered_comment_ids, then
|
|
// replays the remainder through the normal trigger pipeline oldest first.
|
|
//
|
|
// Author-type scope (MUL-4304): originally restricted to author_type = 'member'.
|
|
// That left a gap — an explicit agent→agent @mention (agent A comments
|
|
// `@agent B`) that landed while B already had a DISPATCHED task was dropped by
|
|
// the create-time enqueue path (merge only folds into a QUEUED task, so a
|
|
// dispatched target hits the merge-miss + active-task continue) and then never
|
|
// compensated here, because agent-authored comments were excluded. We now also
|
|
// return 'agent' comments so those explicit mentions can be replayed.
|
|
//
|
|
// The handler rechecks current routing and permissions. For agent authors it
|
|
// accepts explicit mentions, plus worker-to-assigned-leader replies already
|
|
// recorded in this run's planned inputs. Timestamp-only implicit agent replies
|
|
// remain excluded. Replays are scoped to the completing agent, never a fan-out.
|
|
// Ordered ASC so later comments coalesce onto the follow-up created by the first.
|
|
func (q *Queries) ListReconcilableCommentsForIssueSince(ctx context.Context, arg ListReconcilableCommentsForIssueSinceParams) ([]Comment, error) {
|
|
rows, err := q.db.Query(ctx, listReconcilableCommentsForIssueSince,
|
|
arg.IssueID,
|
|
arg.PlannedCommentIds,
|
|
arg.CommentThreadID,
|
|
arg.AgentID,
|
|
arg.Since,
|
|
)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []Comment{}
|
|
for rows.Next() {
|
|
var i Comment
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.IssueID,
|
|
&i.AuthorType,
|
|
&i.AuthorID,
|
|
&i.Content,
|
|
&i.Type,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.ParentID,
|
|
&i.WorkspaceID,
|
|
&i.ResolvedAt,
|
|
&i.ResolvedByType,
|
|
&i.ResolvedByID,
|
|
&i.SourceTaskID,
|
|
&i.QuickActionID,
|
|
&i.ViaPluginID,
|
|
&i.Revision,
|
|
&i.RecoverySettledAt,
|
|
&i.DeletedAt,
|
|
&i.SuppressedAgentIds,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const listRootCommentsForIssue = `-- name: ListRootCommentsForIssue :many
|
|
WITH RECURSIVE selected_roots AS (
|
|
SELECT c.id, c.created_at
|
|
FROM comment c
|
|
WHERE c.issue_id = $1
|
|
AND c.workspace_id = $2
|
|
AND c.parent_id IS NULL
|
|
ORDER BY c.created_at DESC, c.id DESC
|
|
LIMIT $3
|
|
),
|
|
membership(id, root_id, comment_created_at) AS (
|
|
SELECT sr.id, sr.id AS root_id, sr.created_at
|
|
FROM selected_roots sr
|
|
UNION ALL
|
|
SELECT c.id, m.root_id, c.created_at
|
|
FROM comment c
|
|
JOIN membership m ON c.parent_id = m.id
|
|
WHERE c.issue_id = $1
|
|
AND c.workspace_id = $2
|
|
),
|
|
thread_stats AS (
|
|
SELECT root_id,
|
|
(COUNT(*) - 1)::int AS reply_count,
|
|
MAX(comment_created_at)::timestamptz AS last_activity_at
|
|
FROM membership
|
|
GROUP BY root_id
|
|
)
|
|
SELECT c.id, c.issue_id, c.author_type, c.author_id, c.content, c.type,
|
|
c.created_at, c.updated_at, c.parent_id, c.workspace_id,
|
|
c.resolved_at, c.resolved_by_type, c.resolved_by_id,
|
|
c.source_task_id, c.quick_action_id, c.revision, c.deleted_at,
|
|
ts.reply_count AS reply_count,
|
|
ts.last_activity_at AS last_activity_at
|
|
FROM selected_roots sr
|
|
JOIN comment c ON c.id = sr.id
|
|
JOIN thread_stats ts ON ts.root_id = sr.id
|
|
ORDER BY c.created_at ASC, c.id ASC
|
|
`
|
|
|
|
type ListRootCommentsForIssueParams struct {
|
|
IssueID pgtype.UUID `json:"issue_id"`
|
|
WorkspaceID pgtype.UUID `json:"workspace_id"`
|
|
RowLimit int32 `json:"row_limit"`
|
|
}
|
|
|
|
type ListRootCommentsForIssueRow struct {
|
|
ID pgtype.UUID `json:"id"`
|
|
IssueID pgtype.UUID `json:"issue_id"`
|
|
AuthorType string `json:"author_type"`
|
|
AuthorID pgtype.UUID `json:"author_id"`
|
|
Content string `json:"content"`
|
|
Type string `json:"type"`
|
|
CreatedAt pgtype.Timestamptz `json:"created_at"`
|
|
UpdatedAt pgtype.Timestamptz `json:"updated_at"`
|
|
ParentID pgtype.UUID `json:"parent_id"`
|
|
WorkspaceID pgtype.UUID `json:"workspace_id"`
|
|
ResolvedAt pgtype.Timestamptz `json:"resolved_at"`
|
|
ResolvedByType pgtype.Text `json:"resolved_by_type"`
|
|
ResolvedByID pgtype.UUID `json:"resolved_by_id"`
|
|
SourceTaskID pgtype.UUID `json:"source_task_id"`
|
|
QuickActionID pgtype.UUID `json:"quick_action_id"`
|
|
Revision int64 `json:"revision"`
|
|
DeletedAt pgtype.Timestamptz `json:"deleted_at"`
|
|
ReplyCount int32 `json:"reply_count"`
|
|
LastActivityAt pgtype.Timestamptz `json:"last_activity_at"`
|
|
}
|
|
|
|
// Top-level comments only, in issue chronological order, each annotated with
|
|
// per-thread orientation stats: reply_count (number of descendants) and
|
|
// last_activity_at (MAX(created_at) over the whole subtree). This powers
|
|
// `comment list --roots-only` so agents can not only orient around the global
|
|
// discussion but also triage which thread to drill into (biggest / most
|
|
// recently active) before fetching any specific reply thread.
|
|
//
|
|
// `selected_roots` takes the newest @row_limit roots. The final SELECT restores
|
|
// chronological order, so the defensive cap drops the oldest roots without
|
|
// changing the wire order. The recursive `membership` walk only expands those
|
|
// selected threads rather than every thread in the issue, and labels every
|
|
// descendant with its root so the stats stay correct at any reply depth.
|
|
func (q *Queries) ListRootCommentsForIssue(ctx context.Context, arg ListRootCommentsForIssueParams) ([]ListRootCommentsForIssueRow, error) {
|
|
rows, err := q.db.Query(ctx, listRootCommentsForIssue, arg.IssueID, arg.WorkspaceID, arg.RowLimit)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []ListRootCommentsForIssueRow{}
|
|
for rows.Next() {
|
|
var i ListRootCommentsForIssueRow
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.IssueID,
|
|
&i.AuthorType,
|
|
&i.AuthorID,
|
|
&i.Content,
|
|
&i.Type,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.ParentID,
|
|
&i.WorkspaceID,
|
|
&i.ResolvedAt,
|
|
&i.ResolvedByType,
|
|
&i.ResolvedByID,
|
|
&i.SourceTaskID,
|
|
&i.QuickActionID,
|
|
&i.Revision,
|
|
&i.DeletedAt,
|
|
&i.ReplyCount,
|
|
&i.LastActivityAt,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const listRootCommentsSinceForIssue = `-- name: ListRootCommentsSinceForIssue :many
|
|
WITH RECURSIVE selected_roots AS (
|
|
SELECT c.id, c.created_at
|
|
FROM comment c
|
|
WHERE c.issue_id = $1
|
|
AND c.workspace_id = $2
|
|
AND c.parent_id IS NULL
|
|
AND c.created_at > $3
|
|
ORDER BY c.created_at ASC, c.id ASC
|
|
LIMIT $4
|
|
),
|
|
membership(id, root_id, comment_created_at) AS (
|
|
SELECT sr.id, sr.id AS root_id, sr.created_at
|
|
FROM selected_roots sr
|
|
UNION ALL
|
|
SELECT c.id, m.root_id, c.created_at
|
|
FROM comment c
|
|
JOIN membership m ON c.parent_id = m.id
|
|
WHERE c.issue_id = $1
|
|
AND c.workspace_id = $2
|
|
),
|
|
thread_stats AS (
|
|
SELECT root_id,
|
|
(COUNT(*) - 1)::int AS reply_count,
|
|
MAX(comment_created_at)::timestamptz AS last_activity_at
|
|
FROM membership
|
|
GROUP BY root_id
|
|
)
|
|
SELECT c.id, c.issue_id, c.author_type, c.author_id, c.content, c.type,
|
|
c.created_at, c.updated_at, c.parent_id, c.workspace_id,
|
|
c.resolved_at, c.resolved_by_type, c.resolved_by_id,
|
|
c.source_task_id, c.quick_action_id, c.revision, c.deleted_at,
|
|
ts.reply_count AS reply_count,
|
|
ts.last_activity_at AS last_activity_at
|
|
FROM selected_roots sr
|
|
JOIN comment c ON c.id = sr.id
|
|
JOIN thread_stats ts ON ts.root_id = sr.id
|
|
ORDER BY c.created_at ASC, c.id ASC
|
|
`
|
|
|
|
type ListRootCommentsSinceForIssueParams struct {
|
|
IssueID pgtype.UUID `json:"issue_id"`
|
|
WorkspaceID pgtype.UUID `json:"workspace_id"`
|
|
Since pgtype.Timestamptz `json:"since"`
|
|
RowLimit int32 `json:"row_limit"`
|
|
}
|
|
|
|
type ListRootCommentsSinceForIssueRow struct {
|
|
ID pgtype.UUID `json:"id"`
|
|
IssueID pgtype.UUID `json:"issue_id"`
|
|
AuthorType string `json:"author_type"`
|
|
AuthorID pgtype.UUID `json:"author_id"`
|
|
Content string `json:"content"`
|
|
Type string `json:"type"`
|
|
CreatedAt pgtype.Timestamptz `json:"created_at"`
|
|
UpdatedAt pgtype.Timestamptz `json:"updated_at"`
|
|
ParentID pgtype.UUID `json:"parent_id"`
|
|
WorkspaceID pgtype.UUID `json:"workspace_id"`
|
|
ResolvedAt pgtype.Timestamptz `json:"resolved_at"`
|
|
ResolvedByType pgtype.Text `json:"resolved_by_type"`
|
|
ResolvedByID pgtype.UUID `json:"resolved_by_id"`
|
|
SourceTaskID pgtype.UUID `json:"source_task_id"`
|
|
QuickActionID pgtype.UUID `json:"quick_action_id"`
|
|
Revision int64 `json:"revision"`
|
|
DeletedAt pgtype.Timestamptz `json:"deleted_at"`
|
|
ReplyCount int32 `json:"reply_count"`
|
|
LastActivityAt pgtype.Timestamptz `json:"last_activity_at"`
|
|
}
|
|
|
|
// Top-level comments created strictly after @since, each annotated with the
|
|
// same reply_count / last_activity_at stats as ListRootCommentsForIssue. The
|
|
// @since filter narrows which roots are returned; the stats are still computed
|
|
// over each selected thread's full subtree (so a freshly created root with no
|
|
// replies reports reply_count 0 and last_activity_at = its own created_at).
|
|
// selected_roots applies the @since + @row_limit cut up front so the recursive
|
|
// membership walk only touches the subtrees of the roots we actually return.
|
|
func (q *Queries) ListRootCommentsSinceForIssue(ctx context.Context, arg ListRootCommentsSinceForIssueParams) ([]ListRootCommentsSinceForIssueRow, error) {
|
|
rows, err := q.db.Query(ctx, listRootCommentsSinceForIssue,
|
|
arg.IssueID,
|
|
arg.WorkspaceID,
|
|
arg.Since,
|
|
arg.RowLimit,
|
|
)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []ListRootCommentsSinceForIssueRow{}
|
|
for rows.Next() {
|
|
var i ListRootCommentsSinceForIssueRow
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.IssueID,
|
|
&i.AuthorType,
|
|
&i.AuthorID,
|
|
&i.Content,
|
|
&i.Type,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.ParentID,
|
|
&i.WorkspaceID,
|
|
&i.ResolvedAt,
|
|
&i.ResolvedByType,
|
|
&i.ResolvedByID,
|
|
&i.SourceTaskID,
|
|
&i.QuickActionID,
|
|
&i.Revision,
|
|
&i.DeletedAt,
|
|
&i.ReplyCount,
|
|
&i.LastActivityAt,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const listThreadCommentsForIssuePaged = `-- name: ListThreadCommentsForIssuePaged :many
|
|
WITH RECURSIVE root_of AS (
|
|
SELECT c.id, c.parent_id
|
|
FROM comment c
|
|
WHERE c.id = $1 AND c.issue_id = $2 AND c.workspace_id = $3
|
|
UNION ALL
|
|
SELECT p.id, p.parent_id
|
|
FROM comment p
|
|
JOIN root_of r ON p.id = r.parent_id
|
|
WHERE p.issue_id = $2 AND p.workspace_id = $3
|
|
),
|
|
thread_root AS (
|
|
SELECT id FROM root_of WHERE parent_id IS NULL LIMIT 1
|
|
),
|
|
descendants AS (
|
|
SELECT c.id, c.issue_id, c.author_type, c.author_id, c.content, c.type,
|
|
c.created_at, c.updated_at, c.parent_id, c.workspace_id,
|
|
c.resolved_at, c.resolved_by_type, c.resolved_by_id,
|
|
c.source_task_id, c.quick_action_id, c.revision, c.deleted_at
|
|
FROM comment c
|
|
JOIN thread_root tr ON c.id = tr.id
|
|
UNION
|
|
SELECT c.id, c.issue_id, c.author_type, c.author_id, c.content, c.type,
|
|
c.created_at, c.updated_at, c.parent_id, c.workspace_id,
|
|
c.resolved_at, c.resolved_by_type, c.resolved_by_id,
|
|
c.source_task_id, c.quick_action_id, c.revision, c.deleted_at
|
|
FROM comment c
|
|
JOIN descendants d ON c.parent_id = d.id
|
|
WHERE c.issue_id = $2 AND c.workspace_id = $3
|
|
),
|
|
reply_page AS (
|
|
SELECT d.id, d.issue_id, d.author_type, d.author_id, d.content, d.type,
|
|
d.created_at, d.updated_at, d.parent_id, d.workspace_id,
|
|
d.resolved_at, d.resolved_by_type, d.resolved_by_id,
|
|
d.source_task_id, d.quick_action_id, d.revision, d.deleted_at
|
|
FROM descendants d
|
|
WHERE d.id NOT IN (SELECT id FROM thread_root)
|
|
AND (
|
|
$4::boolean = FALSE
|
|
OR (d.created_at, d.id) < ($5::timestamptz, $6::uuid)
|
|
)
|
|
ORDER BY d.created_at DESC, d.id DESC
|
|
LIMIT $7
|
|
)
|
|
SELECT id, issue_id, author_type, author_id, content, type,
|
|
created_at, updated_at, parent_id, workspace_id,
|
|
resolved_at, resolved_by_type, resolved_by_id,
|
|
source_task_id, quick_action_id, revision, deleted_at
|
|
FROM (
|
|
SELECT d.id, d.issue_id, d.author_type, d.author_id, d.content, d.type,
|
|
d.created_at, d.updated_at, d.parent_id, d.workspace_id,
|
|
d.resolved_at, d.resolved_by_type, d.resolved_by_id,
|
|
d.source_task_id, d.quick_action_id, d.revision, d.deleted_at
|
|
FROM descendants d
|
|
JOIN thread_root tr ON d.id = tr.id
|
|
UNION ALL
|
|
SELECT id, issue_id, author_type, author_id, content, type,
|
|
created_at, updated_at, parent_id, workspace_id,
|
|
resolved_at, resolved_by_type, resolved_by_id,
|
|
source_task_id, quick_action_id, revision, deleted_at
|
|
FROM reply_page
|
|
) combined
|
|
ORDER BY created_at ASC, id ASC
|
|
`
|
|
|
|
type ListThreadCommentsForIssuePagedParams struct {
|
|
AnchorID pgtype.UUID `json:"anchor_id"`
|
|
IssueID pgtype.UUID `json:"issue_id"`
|
|
WorkspaceID pgtype.UUID `json:"workspace_id"`
|
|
HasCursor bool `json:"has_cursor"`
|
|
BeforeAt pgtype.Timestamptz `json:"before_at"`
|
|
BeforeID pgtype.UUID `json:"before_id"`
|
|
ReplyLimit int32 `json:"reply_limit"`
|
|
}
|
|
|
|
type ListThreadCommentsForIssuePagedRow struct {
|
|
ID pgtype.UUID `json:"id"`
|
|
IssueID pgtype.UUID `json:"issue_id"`
|
|
AuthorType string `json:"author_type"`
|
|
AuthorID pgtype.UUID `json:"author_id"`
|
|
Content string `json:"content"`
|
|
Type string `json:"type"`
|
|
CreatedAt pgtype.Timestamptz `json:"created_at"`
|
|
UpdatedAt pgtype.Timestamptz `json:"updated_at"`
|
|
ParentID pgtype.UUID `json:"parent_id"`
|
|
WorkspaceID pgtype.UUID `json:"workspace_id"`
|
|
ResolvedAt pgtype.Timestamptz `json:"resolved_at"`
|
|
ResolvedByType pgtype.Text `json:"resolved_by_type"`
|
|
ResolvedByID pgtype.UUID `json:"resolved_by_id"`
|
|
SourceTaskID pgtype.UUID `json:"source_task_id"`
|
|
QuickActionID pgtype.UUID `json:"quick_action_id"`
|
|
Revision int64 `json:"revision"`
|
|
DeletedAt pgtype.Timestamptz `json:"deleted_at"`
|
|
}
|
|
|
|
// Resolves @anchor_id to its thread root, recursively expands every descendant,
|
|
// and returns the root + only the @reply_limit most recent replies (per the
|
|
// (created_at, id) composite key). When @has_cursor=TRUE only replies with
|
|
// (created_at, id) < (@before_at, @before_id) are eligible — that is the
|
|
// cursor for scrolling *within* a thread.
|
|
//
|
|
// Root is unconditional: it is included regardless of @reply_limit (even 0)
|
|
// and regardless of the cursor. A reader landing on a long thread needs the
|
|
// root for the "what is this thread about" context, even if every reply has
|
|
// been paginated past.
|
|
//
|
|
// Reply selection happens DESC (newest replies first) so the cursor walks
|
|
// toward older replies; the outer SELECT then re-sorts the combined output
|
|
// ASC so the body stays chronological (oldest → newest), matching every
|
|
// other comment list path.
|
|
func (q *Queries) ListThreadCommentsForIssuePaged(ctx context.Context, arg ListThreadCommentsForIssuePagedParams) ([]ListThreadCommentsForIssuePagedRow, error) {
|
|
rows, err := q.db.Query(ctx, listThreadCommentsForIssuePaged,
|
|
arg.AnchorID,
|
|
arg.IssueID,
|
|
arg.WorkspaceID,
|
|
arg.HasCursor,
|
|
arg.BeforeAt,
|
|
arg.BeforeID,
|
|
arg.ReplyLimit,
|
|
)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []ListThreadCommentsForIssuePagedRow{}
|
|
for rows.Next() {
|
|
var i ListThreadCommentsForIssuePagedRow
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.IssueID,
|
|
&i.AuthorType,
|
|
&i.AuthorID,
|
|
&i.Content,
|
|
&i.Type,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.ParentID,
|
|
&i.WorkspaceID,
|
|
&i.ResolvedAt,
|
|
&i.ResolvedByType,
|
|
&i.ResolvedByID,
|
|
&i.SourceTaskID,
|
|
&i.QuickActionID,
|
|
&i.Revision,
|
|
&i.DeletedAt,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const lockCommentAncestorPath = `-- name: LockCommentAncestorPath :many
|
|
WITH RECURSIVE ancestor_ids AS (
|
|
SELECT c.id, c.parent_id, 1::integer AS depth, ARRAY[c.id]::uuid[] AS visited_ids
|
|
FROM comment c
|
|
WHERE c.id = $1
|
|
AND c.workspace_id = $2
|
|
AND c.issue_id = $3
|
|
|
|
UNION ALL
|
|
|
|
SELECT parent.id, parent.parent_id, path.depth + 1, path.visited_ids || parent.id
|
|
FROM ancestor_ids path
|
|
JOIN comment parent ON parent.id = path.parent_id
|
|
WHERE parent.workspace_id = $2
|
|
AND parent.issue_id = $3
|
|
AND path.depth <= 256
|
|
AND NOT parent.id = ANY(path.visited_ids)
|
|
)
|
|
SELECT c.id
|
|
FROM comment c
|
|
JOIN ancestor_ids path ON path.id = c.id
|
|
ORDER BY c.id
|
|
FOR UPDATE OF c
|
|
`
|
|
|
|
type LockCommentAncestorPathParams struct {
|
|
CommentID pgtype.UUID `json:"comment_id"`
|
|
WorkspaceID pgtype.UUID `json:"workspace_id"`
|
|
IssueID pgtype.UUID `json:"issue_id"`
|
|
}
|
|
|
|
func (q *Queries) LockCommentAncestorPath(ctx context.Context, arg LockCommentAncestorPathParams) ([]pgtype.UUID, error) {
|
|
rows, err := q.db.Query(ctx, lockCommentAncestorPath, arg.CommentID, arg.WorkspaceID, arg.IssueID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []pgtype.UUID{}
|
|
for rows.Next() {
|
|
var id pgtype.UUID
|
|
if err := rows.Scan(&id); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, id)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const lockCommentForDelete = `-- name: LockCommentForDelete :one
|
|
WITH locked_issue AS MATERIALIZED (
|
|
SELECT issue.id
|
|
FROM issue
|
|
JOIN comment ON comment.issue_id = issue.id
|
|
AND comment.workspace_id = issue.workspace_id
|
|
WHERE comment.id = $1 AND comment.workspace_id = $2
|
|
FOR UPDATE OF issue
|
|
), issue_fence AS MATERIALIZED (
|
|
-- The consumed locked_count below is the ordering fence: the issue lock is
|
|
-- acquired before the comment lock. MATERIALIZED only prevents
|
|
-- folding/re-evaluation and is not, by itself, a lock-order guarantee.
|
|
SELECT count(*) AS locked_count FROM locked_issue
|
|
)
|
|
SELECT comment.id, comment.issue_id, comment.author_type, comment.author_id, comment.content, comment.type, comment.created_at, comment.updated_at, comment.parent_id, comment.workspace_id, comment.resolved_at, comment.resolved_by_type, comment.resolved_by_id, comment.source_task_id, comment.quick_action_id, comment.via_plugin_id, comment.revision, comment.recovery_settled_at, comment.deleted_at, comment.suppressed_agent_ids
|
|
FROM comment
|
|
CROSS JOIN issue_fence
|
|
WHERE comment.id = $1 AND comment.workspace_id = $2
|
|
AND comment.deleted_at IS NULL
|
|
AND issue_fence.locked_count >= 0
|
|
FOR UPDATE OF comment
|
|
`
|
|
|
|
type LockCommentForDeleteParams struct {
|
|
ID pgtype.UUID `json:"id"`
|
|
WorkspaceID pgtype.UUID `json:"workspace_id"`
|
|
}
|
|
|
|
// First statement of the comment delete transaction (#8296). Defense-in-depth:
|
|
// workspace_id is a SQL-layer tenant guard. See DeleteIssue.
|
|
//
|
|
// It takes the aggregate owner's lock before the comment's, so deleting cannot
|
|
// deadlock with issue teardown (which takes the same issue -> comment order).
|
|
// The issue lock is also what freezes the thread: every comment insert goes
|
|
// through CreateComment, whose first step updates this issue row, so no reply
|
|
// can be added to the issue until the delete transaction ends. The caller's
|
|
// later statements start from a fresh snapshot taken after the locks, which is
|
|
// what makes their reply check exact.
|
|
//
|
|
// A tombstone is excluded: deleting an already-deleted comment finds nothing.
|
|
func (q *Queries) LockCommentForDelete(ctx context.Context, arg LockCommentForDeleteParams) (Comment, error) {
|
|
row := q.db.QueryRow(ctx, lockCommentForDelete, arg.ID, arg.WorkspaceID)
|
|
var i Comment
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.IssueID,
|
|
&i.AuthorType,
|
|
&i.AuthorID,
|
|
&i.Content,
|
|
&i.Type,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.ParentID,
|
|
&i.WorkspaceID,
|
|
&i.ResolvedAt,
|
|
&i.ResolvedByType,
|
|
&i.ResolvedByID,
|
|
&i.SourceTaskID,
|
|
&i.QuickActionID,
|
|
&i.ViaPluginID,
|
|
&i.Revision,
|
|
&i.RecoverySettledAt,
|
|
&i.DeletedAt,
|
|
&i.SuppressedAgentIds,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const lockLiveComment = `-- name: LockLiveComment :one
|
|
WITH locked_issue AS MATERIALIZED (
|
|
SELECT issue.id
|
|
FROM issue
|
|
JOIN comment ON comment.issue_id = issue.id
|
|
AND comment.workspace_id = issue.workspace_id
|
|
WHERE comment.id = $1 AND comment.workspace_id = $2
|
|
FOR NO KEY UPDATE OF issue
|
|
), issue_fence AS MATERIALIZED (
|
|
SELECT count(*) AS locked_count FROM locked_issue
|
|
)
|
|
SELECT comment.id, comment.issue_id, comment.author_type, comment.author_id, comment.content, comment.type, comment.created_at, comment.updated_at, comment.parent_id, comment.workspace_id, comment.resolved_at, comment.resolved_by_type, comment.resolved_by_id, comment.source_task_id, comment.quick_action_id, comment.via_plugin_id, comment.revision, comment.recovery_settled_at, comment.deleted_at, comment.suppressed_agent_ids
|
|
FROM comment
|
|
CROSS JOIN issue_fence
|
|
WHERE comment.id = $1 AND comment.workspace_id = $2
|
|
AND comment.deleted_at IS NULL
|
|
AND issue_fence.locked_count >= 0
|
|
FOR NO KEY UPDATE OF comment
|
|
`
|
|
|
|
type LockLiveCommentParams struct {
|
|
ID pgtype.UUID `json:"id"`
|
|
WorkspaceID pgtype.UUID `json:"workspace_id"`
|
|
}
|
|
|
|
// Locks a live comment ahead of a write to one of its children — reactions and
|
|
// attachments — in the order every comment mutation shares: issue, then
|
|
// comment, then child. A comment deleted before or while this waits reads as
|
|
// absent (the row lock re-checks deleted_at), so no child can land on its
|
|
// tombstone. FOR NO KEY UPDATE conflicts with the delete transaction's FOR
|
|
// UPDATE but not with a reply's FOR KEY SHARE, so it never blocks replies.
|
|
func (q *Queries) LockLiveComment(ctx context.Context, arg LockLiveCommentParams) (Comment, error) {
|
|
row := q.db.QueryRow(ctx, lockLiveComment, arg.ID, arg.WorkspaceID)
|
|
var i Comment
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.IssueID,
|
|
&i.AuthorType,
|
|
&i.AuthorID,
|
|
&i.Content,
|
|
&i.Type,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.ParentID,
|
|
&i.WorkspaceID,
|
|
&i.ResolvedAt,
|
|
&i.ResolvedByType,
|
|
&i.ResolvedByID,
|
|
&i.SourceTaskID,
|
|
&i.QuickActionID,
|
|
&i.ViaPluginID,
|
|
&i.Revision,
|
|
&i.RecoverySettledAt,
|
|
&i.DeletedAt,
|
|
&i.SuppressedAgentIds,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const resolveComment = `-- name: ResolveComment :one
|
|
UPDATE comment SET
|
|
resolved_at = COALESCE(resolved_at, now()),
|
|
resolved_by_type = COALESCE(resolved_by_type, $2),
|
|
resolved_by_id = COALESCE(resolved_by_id, $3),
|
|
revision = revision + CASE WHEN resolved_at IS NULL THEN 1 ELSE 0 END,
|
|
updated_at = CASE WHEN resolved_at IS NULL THEN now() ELSE updated_at END
|
|
WHERE id = $1
|
|
AND deleted_at IS NULL
|
|
RETURNING id, issue_id, author_type, author_id, content, type, created_at, updated_at, parent_id, workspace_id, resolved_at, resolved_by_type, resolved_by_id, source_task_id, quick_action_id, via_plugin_id, revision, recovery_settled_at, deleted_at, suppressed_agent_ids
|
|
`
|
|
|
|
type ResolveCommentParams struct {
|
|
ID pgtype.UUID `json:"id"`
|
|
ResolvedByType pgtype.Text `json:"resolved_by_type"`
|
|
ResolvedByID pgtype.UUID `json:"resolved_by_id"`
|
|
}
|
|
|
|
// Idempotent: re-resolving keeps the original resolved_at + resolver. Always
|
|
// returns the row so the handler can surface the canonical state — unless the
|
|
// comment has been deleted, whose tombstone cannot be a resolution.
|
|
func (q *Queries) ResolveComment(ctx context.Context, arg ResolveCommentParams) (Comment, error) {
|
|
row := q.db.QueryRow(ctx, resolveComment, arg.ID, arg.ResolvedByType, arg.ResolvedByID)
|
|
var i Comment
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.IssueID,
|
|
&i.AuthorType,
|
|
&i.AuthorID,
|
|
&i.Content,
|
|
&i.Type,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.ParentID,
|
|
&i.WorkspaceID,
|
|
&i.ResolvedAt,
|
|
&i.ResolvedByType,
|
|
&i.ResolvedByID,
|
|
&i.SourceTaskID,
|
|
&i.QuickActionID,
|
|
&i.ViaPluginID,
|
|
&i.Revision,
|
|
&i.RecoverySettledAt,
|
|
&i.DeletedAt,
|
|
&i.SuppressedAgentIds,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const tombstoneComment = `-- name: TombstoneComment :one
|
|
UPDATE comment SET
|
|
content = '',
|
|
deleted_at = now(),
|
|
resolved_at = NULL,
|
|
resolved_by_type = NULL,
|
|
resolved_by_id = NULL,
|
|
revision = revision + 1,
|
|
updated_at = now()
|
|
WHERE id = $1 AND workspace_id = $2
|
|
AND deleted_at IS NULL
|
|
RETURNING id, issue_id, author_type, author_id, content, type, created_at, updated_at, parent_id, workspace_id, resolved_at, resolved_by_type, resolved_by_id, source_task_id, quick_action_id, via_plugin_id, revision, recovery_settled_at, deleted_at, suppressed_agent_ids
|
|
`
|
|
|
|
type TombstoneCommentParams struct {
|
|
ID pgtype.UUID `json:"id"`
|
|
WorkspaceID pgtype.UUID `json:"workspace_id"`
|
|
}
|
|
|
|
// Deletes a comment that still has replies by clearing it in place. The row,
|
|
// its id and its parent_id stay so every reply keeps its direct parent; the
|
|
// body goes, and so does any resolution, since a deleted comment cannot be a
|
|
// thread's conclusion. The caller removes attachments and reactions in the
|
|
// same transaction.
|
|
func (q *Queries) TombstoneComment(ctx context.Context, arg TombstoneCommentParams) (Comment, error) {
|
|
row := q.db.QueryRow(ctx, tombstoneComment, arg.ID, arg.WorkspaceID)
|
|
var i Comment
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.IssueID,
|
|
&i.AuthorType,
|
|
&i.AuthorID,
|
|
&i.Content,
|
|
&i.Type,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.ParentID,
|
|
&i.WorkspaceID,
|
|
&i.ResolvedAt,
|
|
&i.ResolvedByType,
|
|
&i.ResolvedByID,
|
|
&i.SourceTaskID,
|
|
&i.QuickActionID,
|
|
&i.ViaPluginID,
|
|
&i.Revision,
|
|
&i.RecoverySettledAt,
|
|
&i.DeletedAt,
|
|
&i.SuppressedAgentIds,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const touchIssueForCommentDelete = `-- name: TouchIssueForCommentDelete :one
|
|
UPDATE issue
|
|
SET revision = revision + 1,
|
|
last_activity_at = GREATEST(COALESCE(last_activity_at, updated_at), now())
|
|
WHERE id = $1 AND workspace_id = $2
|
|
RETURNING revision
|
|
`
|
|
|
|
type TouchIssueForCommentDeleteParams struct {
|
|
IssueID pgtype.UUID `json:"issue_id"`
|
|
WorkspaceID pgtype.UUID `json:"workspace_id"`
|
|
}
|
|
|
|
// A delete counts as activity on its issue, like CreateComment and
|
|
// UpdateComment. Runs inside the delete transaction after the comment rows
|
|
// changed, so a delete that lost its race never touches the issue.
|
|
func (q *Queries) TouchIssueForCommentDelete(ctx context.Context, arg TouchIssueForCommentDeleteParams) (int64, error) {
|
|
row := q.db.QueryRow(ctx, touchIssueForCommentDelete, arg.IssueID, arg.WorkspaceID)
|
|
var revision int64
|
|
err := row.Scan(&revision)
|
|
return revision, err
|
|
}
|
|
|
|
const unresolveComment = `-- name: UnresolveComment :one
|
|
UPDATE comment SET
|
|
resolved_at = NULL,
|
|
resolved_by_type = NULL,
|
|
resolved_by_id = NULL,
|
|
revision = revision + CASE WHEN resolved_at IS NOT NULL THEN 1 ELSE 0 END,
|
|
updated_at = CASE WHEN resolved_at IS NOT NULL THEN now() ELSE updated_at END
|
|
WHERE id = $1
|
|
RETURNING id, issue_id, author_type, author_id, content, type, created_at, updated_at, parent_id, workspace_id, resolved_at, resolved_by_type, resolved_by_id, source_task_id, quick_action_id, via_plugin_id, revision, recovery_settled_at, deleted_at, suppressed_agent_ids
|
|
`
|
|
|
|
// Idempotent: a no-op clear (already unresolved) just returns the row.
|
|
func (q *Queries) UnresolveComment(ctx context.Context, id pgtype.UUID) (Comment, error) {
|
|
row := q.db.QueryRow(ctx, unresolveComment, id)
|
|
var i Comment
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.IssueID,
|
|
&i.AuthorType,
|
|
&i.AuthorID,
|
|
&i.Content,
|
|
&i.Type,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.ParentID,
|
|
&i.WorkspaceID,
|
|
&i.ResolvedAt,
|
|
&i.ResolvedByType,
|
|
&i.ResolvedByID,
|
|
&i.SourceTaskID,
|
|
&i.QuickActionID,
|
|
&i.ViaPluginID,
|
|
&i.Revision,
|
|
&i.RecoverySettledAt,
|
|
&i.DeletedAt,
|
|
&i.SuppressedAgentIds,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const updateComment = `-- name: UpdateComment :one
|
|
WITH locked_issue AS MATERIALIZED (
|
|
-- Keep the global issue -> child lock order used by issue teardown. The
|
|
-- aggregate below still yields one row when the parent was concurrently
|
|
-- deleted, preserving best-effort edits of an orphaned comment.
|
|
SELECT issue.id
|
|
FROM issue
|
|
JOIN comment ON comment.issue_id = issue.id
|
|
AND comment.workspace_id = issue.workspace_id
|
|
WHERE comment.id = $1
|
|
FOR UPDATE OF issue
|
|
), issue_fence AS MATERIALIZED (
|
|
-- The aggregate always emits one row. Consuming locked_count in target's
|
|
-- tautological predicate creates a real data dependency: locked_issue must
|
|
-- acquire the owner lock before target can lock the comment. MATERIALIZED
|
|
-- prevents folding/re-evaluation; it does not itself establish lock order.
|
|
SELECT count(*) AS locked_count FROM locked_issue
|
|
), target AS MATERIALIZED (
|
|
SELECT comment.id, comment.issue_id, comment.author_type, comment.author_id, comment.content, comment.type, comment.created_at, comment.updated_at, comment.parent_id, comment.workspace_id, comment.resolved_at, comment.resolved_by_type, comment.resolved_by_id, comment.source_task_id, comment.quick_action_id, comment.via_plugin_id, comment.revision, comment.recovery_settled_at, comment.deleted_at, comment.suppressed_agent_ids,
|
|
ROW(comment.content, comment.source_task_id) IS DISTINCT FROM
|
|
ROW($2, $3::uuid) AS did_change
|
|
FROM comment
|
|
CROSS JOIN issue_fence
|
|
WHERE comment.id = $1
|
|
AND issue_fence.locked_count >= 0
|
|
-- A deleted comment's tombstone is not editable.
|
|
AND comment.deleted_at IS NULL
|
|
AND ($4::bigint IS NULL OR revision = $4::bigint)
|
|
AND (
|
|
$5::text IS NULL
|
|
OR content IS NOT DISTINCT FROM $5::text
|
|
OR content IS NOT DISTINCT FROM $2
|
|
)
|
|
FOR UPDATE OF comment
|
|
), updated_comment AS (
|
|
UPDATE comment SET
|
|
content = $2,
|
|
source_task_id = $3::uuid,
|
|
-- New text re-decides which agents it must not start, under the same
|
|
-- revision check as the text itself.
|
|
suppressed_agent_ids = CASE WHEN target.content IS DISTINCT FROM $2
|
|
THEN $6::uuid[]
|
|
ELSE comment.suppressed_agent_ids END,
|
|
revision = comment.revision + CASE WHEN target.did_change THEN 1 ELSE 0 END,
|
|
updated_at = CASE WHEN target.did_change THEN now() ELSE comment.updated_at END
|
|
FROM target
|
|
WHERE comment.id = target.id
|
|
RETURNING comment.id, comment.issue_id, comment.author_type, comment.author_id,
|
|
comment.content, comment.type, comment.created_at, comment.updated_at,
|
|
comment.parent_id, comment.workspace_id, comment.resolved_at,
|
|
comment.resolved_by_type, comment.resolved_by_id, comment.source_task_id,
|
|
comment.quick_action_id, comment.via_plugin_id, comment.revision,
|
|
comment.deleted_at, target.did_change
|
|
), touched_issue AS (
|
|
UPDATE issue
|
|
SET revision = issue.revision + 1,
|
|
last_activity_at = GREATEST(COALESCE(issue.last_activity_at, issue.updated_at), now())
|
|
FROM updated_comment
|
|
WHERE updated_comment.did_change
|
|
AND issue.id = updated_comment.issue_id
|
|
AND issue.workspace_id = updated_comment.workspace_id
|
|
RETURNING issue.id, issue.revision
|
|
)
|
|
SELECT updated_comment.id, updated_comment.issue_id, updated_comment.author_type,
|
|
updated_comment.author_id, updated_comment.content, updated_comment.type,
|
|
updated_comment.created_at, updated_comment.updated_at, updated_comment.parent_id,
|
|
updated_comment.workspace_id, updated_comment.resolved_at,
|
|
updated_comment.resolved_by_type, updated_comment.resolved_by_id,
|
|
updated_comment.source_task_id, updated_comment.quick_action_id,
|
|
updated_comment.via_plugin_id, updated_comment.revision,
|
|
updated_comment.deleted_at,
|
|
COALESCE((SELECT revision FROM touched_issue), 0)::bigint AS issue_revision
|
|
FROM updated_comment
|
|
`
|
|
|
|
type UpdateCommentParams struct {
|
|
ID pgtype.UUID `json:"id"`
|
|
Content string `json:"content"`
|
|
SourceTaskID pgtype.UUID `json:"source_task_id"`
|
|
ExpectedRevision pgtype.Int8 `json:"expected_revision"`
|
|
ContentBase pgtype.Text `json:"content_base"`
|
|
SuppressedAgentIds []pgtype.UUID `json:"suppressed_agent_ids"`
|
|
}
|
|
|
|
type UpdateCommentRow struct {
|
|
ID pgtype.UUID `json:"id"`
|
|
IssueID pgtype.UUID `json:"issue_id"`
|
|
AuthorType string `json:"author_type"`
|
|
AuthorID pgtype.UUID `json:"author_id"`
|
|
Content string `json:"content"`
|
|
Type string `json:"type"`
|
|
CreatedAt pgtype.Timestamptz `json:"created_at"`
|
|
UpdatedAt pgtype.Timestamptz `json:"updated_at"`
|
|
ParentID pgtype.UUID `json:"parent_id"`
|
|
WorkspaceID pgtype.UUID `json:"workspace_id"`
|
|
ResolvedAt pgtype.Timestamptz `json:"resolved_at"`
|
|
ResolvedByType pgtype.Text `json:"resolved_by_type"`
|
|
ResolvedByID pgtype.UUID `json:"resolved_by_id"`
|
|
SourceTaskID pgtype.UUID `json:"source_task_id"`
|
|
QuickActionID pgtype.UUID `json:"quick_action_id"`
|
|
ViaPluginID pgtype.UUID `json:"via_plugin_id"`
|
|
Revision int64 `json:"revision"`
|
|
DeletedAt pgtype.Timestamptz `json:"deleted_at"`
|
|
IssueRevision int64 `json:"issue_revision"`
|
|
}
|
|
|
|
func (q *Queries) UpdateComment(ctx context.Context, arg UpdateCommentParams) (UpdateCommentRow, error) {
|
|
row := q.db.QueryRow(ctx, updateComment,
|
|
arg.ID,
|
|
arg.Content,
|
|
arg.SourceTaskID,
|
|
arg.ExpectedRevision,
|
|
arg.ContentBase,
|
|
arg.SuppressedAgentIds,
|
|
)
|
|
var i UpdateCommentRow
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.IssueID,
|
|
&i.AuthorType,
|
|
&i.AuthorID,
|
|
&i.Content,
|
|
&i.Type,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.ParentID,
|
|
&i.WorkspaceID,
|
|
&i.ResolvedAt,
|
|
&i.ResolvedByType,
|
|
&i.ResolvedByID,
|
|
&i.SourceTaskID,
|
|
&i.QuickActionID,
|
|
&i.ViaPluginID,
|
|
&i.Revision,
|
|
&i.DeletedAt,
|
|
&i.IssueRevision,
|
|
)
|
|
return i, err
|
|
}
|