mirror of
https://gh-proxy.org/https://github.com/klinsmaya/multica.git
synced 2026-11-08 01:16:45 +08:00
bb3747186e
* feat(server): let agents steer running turns they could start (MUL-8285) An agent comment can now be added to another agent's running turn, the way a member steers from the composer: exactly when the comment could start that agent (canInvokeAgent, judged on the human at the top of the chain), never its own turn. - steer_task_ids now work for agent authors; steer: true asks the server to add the comment to the current running turn of every recipient without a named turn. - Agent-authored bindings are capped per turn (10) and per authoring agent (3). The task row is locked in its own statement before the bind, so the cap count sees what an earlier lock holder committed. - An agent comment that steered a turn but was never read is replayed on completion like the mention it replaced. Member receipts keep today's behaviour (the member sees the failure and can retry or resend). - The supplement claim returns author_type and the agent's name. A daemon that does not send task-supplement-author-v1 gets the attribution in the content, so an agent message never reads as a human's. - can_supplement on task-runs is computed for an agent caller by the same rule. Co-authored-by: Tim Smart <[email protected]> Co-authored-by: WitMiao <[email protected]> Co-authored-by: multica-agent <[email protected]> * feat(daemon): present an agent's added message as an agent's (MUL-8285) Claims send the task-supplement-author-v1 capability and render agent messages as peer input that cannot replace the objective or override humans. Co-authored-by: Tim Smart <[email protected]> Co-authored-by: multica-agent <[email protected]> * feat(cli): add --steer and --steer-active to issue comment add (MUL-8285) Docs: CLI help, CLI_AND_DAEMON.md, the CLI docs in every locale, the squad leader briefing, and a steering section in the multica-platform mentions reference. Co-authored-by: Tim Smart <[email protected]> Co-authored-by: multica-agent <[email protected]> * fix: close the review gaps in agent steering (MUL-8285) - Replay an unread agent steer even when it reached the turn through an implicit route (a worker's reply to its leader): a comment bound to the completing run counts as planned input for the replay filter. - Drop the receipt of an agent steer once completion has replayed it, so no client (old or new) offers to resend what the follow-up already handles. - Never hand an agent's message to a daemon without task-supplement-author-v1: it would frame it as a human's. The message stays pending, settles when the turn ends, and is replayed as a mention. - Tell a squad leader about --steer only when its daemon advertises cli-comment-steer-v1, since an older CLI rejects the flag; the skill reference says to drop the flag on 'unknown flag'. Co-authored-by: multica-agent <[email protected]> --------- Co-authored-by: Tim Smart <[email protected]> Co-authored-by: WitMiao <[email protected]> Co-authored-by: multica-agent <[email protected]>
2376 lines
85 KiB
Go
2376 lines
85 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 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 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 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 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
|
|
-- An agent comment that steered this run but was never read took the
|
|
-- place of the follow-up its mention would have queued; replay it.
|
|
OR (c.author_type = 'agent' AND EXISTS (
|
|
SELECT 1 FROM task_supplement steered
|
|
WHERE steered.comment_id = c.id AND steered.task_id = $4::uuid
|
|
AND steered.status <> 'delivered'
|
|
)))
|
|
-- A deleted comment is no longer input, even when replies keep its row.
|
|
AND c.deleted_at IS NULL
|
|
-- A member 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, because the member sees the failure and can retry or
|
|
-- send it as a new run. No one watches an agent's steering receipt, so an
|
|
-- agent comment belongs to the turn only once delivered; otherwise it is
|
|
-- replayed like any other mention. 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 = $5
|
|
AND (c.author_type <> 'agent' OR s.status = 'delivered')
|
|
)
|
|
-- 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 = $5
|
|
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 >= $6
|
|
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($5::uuid = ANY(c.suppressed_agent_ids), false)
|
|
AND (
|
|
(
|
|
c.author_type IN ('member', 'agent')
|
|
AND (c.created_at > $6 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"`
|
|
TaskID pgtype.UUID `json:"task_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.TaskID,
|
|
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
|
|
}
|