mirror of
https://github.com/multica-ai/multica.git
synced 2026-07-27 21:33:41 +02:00
6b2097ccbb
Adds an "Archived" sub-view to the Inbox, reachable from an entry at the
bottom of the main list, with per-row unarchive. Mirrors chat's archived
sub-view so the two surfaces share one mental model.
Backend:
- GET /api/inbox/archived and POST /api/inbox/{id}/unarchive. Kept off the
existing GET /api/inbox so installed clients keep their contract and the
unbounded archive never rides along with the main list.
- The archived query excludes any issue that still has an active row. Archiving
is issue-level, so a new notification on an archived issue leaves old archived
rows beside a fresh active one — without the guard the issue renders in BOTH
lists. The exclusion lives in SQL so neither list depends on the other's cache.
- Unarchive is issue-level (mirroring archive) and leaves `read` untouched, so a
restored unread item raises the unread badge again.
- v1 ships no pagination: LIMIT 200, newest-first, so truncation drops the
oldest rows and never hides a group's newest one.
- inbox:unarchived event, fanned out to the recipient like the other personal
inbox events.
- Two CONCURRENTLY-built indexes; inbox_item previously had none covering
workspace/archived/created_at.
Frontend:
- Separate TanStack cache per list; every inbox event invalidates the workspace
prefix, since any of them can move an item across the boundary.
- View persisted as ?view=archived, so refresh, back/forward, and the mobile
detail-back all return to the list the user was in.
- Batch actions stay main-view only — they archive from the MAIN inbox, so
offering them over the archived list would do the opposite of what it reads.
- Mobile subscribes to inbox:unarchived (its list gains the restored row); its
own archived view remains follow-up.
Known debt: no pagination, so an archive past ~200 rows is truncated silently
in the UI; the entry's count is the deduplicated count of the rows returned.
Verified: pnpm typecheck/test/lint (0 errors), go build/vet, Go inbox suite
against a real Postgres, migrations up+down, and EXPLAIN confirming both new
indexes serve the query.
Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>
Co-authored-by: multica-agent <github@multica.ai>
621 lines
19 KiB
Go
621 lines
19 KiB
Go
// Code generated by sqlc. DO NOT EDIT.
|
|
// versions:
|
|
// sqlc v1.31.1
|
|
// source: inbox.sql
|
|
|
|
package db
|
|
|
|
import (
|
|
"context"
|
|
|
|
"github.com/jackc/pgx/v5/pgtype"
|
|
)
|
|
|
|
const archiveAllInbox = `-- name: ArchiveAllInbox :execrows
|
|
UPDATE inbox_item SET archived = true
|
|
WHERE workspace_id = $1 AND recipient_type = 'member' AND recipient_id = $2 AND archived = false
|
|
`
|
|
|
|
type ArchiveAllInboxParams struct {
|
|
WorkspaceID pgtype.UUID `json:"workspace_id"`
|
|
RecipientID pgtype.UUID `json:"recipient_id"`
|
|
}
|
|
|
|
func (q *Queries) ArchiveAllInbox(ctx context.Context, arg ArchiveAllInboxParams) (int64, error) {
|
|
result, err := q.db.Exec(ctx, archiveAllInbox, arg.WorkspaceID, arg.RecipientID)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return result.RowsAffected(), nil
|
|
}
|
|
|
|
const archiveAllReadInbox = `-- name: ArchiveAllReadInbox :execrows
|
|
UPDATE inbox_item SET archived = true
|
|
WHERE workspace_id = $1 AND recipient_type = 'member' AND recipient_id = $2 AND read = true AND archived = false
|
|
`
|
|
|
|
type ArchiveAllReadInboxParams struct {
|
|
WorkspaceID pgtype.UUID `json:"workspace_id"`
|
|
RecipientID pgtype.UUID `json:"recipient_id"`
|
|
}
|
|
|
|
func (q *Queries) ArchiveAllReadInbox(ctx context.Context, arg ArchiveAllReadInboxParams) (int64, error) {
|
|
result, err := q.db.Exec(ctx, archiveAllReadInbox, arg.WorkspaceID, arg.RecipientID)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return result.RowsAffected(), nil
|
|
}
|
|
|
|
const archiveCompletedInbox = `-- name: ArchiveCompletedInbox :execrows
|
|
UPDATE inbox_item i SET archived = true
|
|
WHERE i.workspace_id = $1 AND i.recipient_type = 'member' AND i.recipient_id = $2 AND i.archived = false
|
|
AND i.issue_id IN (SELECT id FROM issue WHERE status IN ('done', 'cancelled'))
|
|
`
|
|
|
|
type ArchiveCompletedInboxParams struct {
|
|
WorkspaceID pgtype.UUID `json:"workspace_id"`
|
|
RecipientID pgtype.UUID `json:"recipient_id"`
|
|
}
|
|
|
|
func (q *Queries) ArchiveCompletedInbox(ctx context.Context, arg ArchiveCompletedInboxParams) (int64, error) {
|
|
result, err := q.db.Exec(ctx, archiveCompletedInbox, arg.WorkspaceID, arg.RecipientID)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return result.RowsAffected(), nil
|
|
}
|
|
|
|
const archiveInboxByIssue = `-- name: ArchiveInboxByIssue :execrows
|
|
UPDATE inbox_item SET archived = true
|
|
WHERE workspace_id = $1 AND recipient_type = $2 AND recipient_id = $3 AND issue_id = $4 AND archived = false
|
|
`
|
|
|
|
type ArchiveInboxByIssueParams struct {
|
|
WorkspaceID pgtype.UUID `json:"workspace_id"`
|
|
RecipientType string `json:"recipient_type"`
|
|
RecipientID pgtype.UUID `json:"recipient_id"`
|
|
IssueID pgtype.UUID `json:"issue_id"`
|
|
}
|
|
|
|
func (q *Queries) ArchiveInboxByIssue(ctx context.Context, arg ArchiveInboxByIssueParams) (int64, error) {
|
|
result, err := q.db.Exec(ctx, archiveInboxByIssue,
|
|
arg.WorkspaceID,
|
|
arg.RecipientType,
|
|
arg.RecipientID,
|
|
arg.IssueID,
|
|
)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return result.RowsAffected(), nil
|
|
}
|
|
|
|
const archiveInboxByIssueAndType = `-- name: ArchiveInboxByIssueAndType :many
|
|
UPDATE inbox_item SET archived = true
|
|
WHERE workspace_id = $1 AND issue_id = $2 AND type = $3 AND archived = false
|
|
RETURNING recipient_type, recipient_id
|
|
`
|
|
|
|
type ArchiveInboxByIssueAndTypeParams struct {
|
|
WorkspaceID pgtype.UUID `json:"workspace_id"`
|
|
IssueID pgtype.UUID `json:"issue_id"`
|
|
Type string `json:"type"`
|
|
}
|
|
|
|
type ArchiveInboxByIssueAndTypeRow struct {
|
|
RecipientType string `json:"recipient_type"`
|
|
RecipientID pgtype.UUID `json:"recipient_id"`
|
|
}
|
|
|
|
func (q *Queries) ArchiveInboxByIssueAndType(ctx context.Context, arg ArchiveInboxByIssueAndTypeParams) ([]ArchiveInboxByIssueAndTypeRow, error) {
|
|
rows, err := q.db.Query(ctx, archiveInboxByIssueAndType, arg.WorkspaceID, arg.IssueID, arg.Type)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []ArchiveInboxByIssueAndTypeRow{}
|
|
for rows.Next() {
|
|
var i ArchiveInboxByIssueAndTypeRow
|
|
if err := rows.Scan(&i.RecipientType, &i.RecipientID); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const archiveInboxItem = `-- name: ArchiveInboxItem :one
|
|
UPDATE inbox_item SET archived = true
|
|
WHERE id = $1
|
|
RETURNING id, workspace_id, recipient_type, recipient_id, type, severity, issue_id, title, body, read, archived, created_at, actor_type, actor_id, details
|
|
`
|
|
|
|
func (q *Queries) ArchiveInboxItem(ctx context.Context, id pgtype.UUID) (InboxItem, error) {
|
|
row := q.db.QueryRow(ctx, archiveInboxItem, id)
|
|
var i InboxItem
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.WorkspaceID,
|
|
&i.RecipientType,
|
|
&i.RecipientID,
|
|
&i.Type,
|
|
&i.Severity,
|
|
&i.IssueID,
|
|
&i.Title,
|
|
&i.Body,
|
|
&i.Read,
|
|
&i.Archived,
|
|
&i.CreatedAt,
|
|
&i.ActorType,
|
|
&i.ActorID,
|
|
&i.Details,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const countUnreadInbox = `-- name: CountUnreadInbox :one
|
|
SELECT count(*) FROM inbox_item
|
|
WHERE workspace_id = $1 AND recipient_type = $2 AND recipient_id = $3 AND read = false AND archived = false
|
|
`
|
|
|
|
type CountUnreadInboxParams struct {
|
|
WorkspaceID pgtype.UUID `json:"workspace_id"`
|
|
RecipientType string `json:"recipient_type"`
|
|
RecipientID pgtype.UUID `json:"recipient_id"`
|
|
}
|
|
|
|
func (q *Queries) CountUnreadInbox(ctx context.Context, arg CountUnreadInboxParams) (int64, error) {
|
|
row := q.db.QueryRow(ctx, countUnreadInbox, arg.WorkspaceID, arg.RecipientType, arg.RecipientID)
|
|
var count int64
|
|
err := row.Scan(&count)
|
|
return count, err
|
|
}
|
|
|
|
const countUnreadInboxByWorkspace = `-- name: CountUnreadInboxByWorkspace :many
|
|
SELECT newest.workspace_id, count(*) AS count
|
|
FROM (
|
|
SELECT DISTINCT ON (i.workspace_id, COALESCE(i.issue_id, i.id))
|
|
i.workspace_id, i.read
|
|
FROM inbox_item i
|
|
JOIN member m ON m.workspace_id = i.workspace_id AND m.user_id = i.recipient_id
|
|
WHERE i.recipient_type = 'member'
|
|
AND i.recipient_id = $1
|
|
AND i.archived = false
|
|
ORDER BY i.workspace_id, COALESCE(i.issue_id, i.id), i.created_at DESC
|
|
) newest
|
|
WHERE newest.read = false
|
|
GROUP BY newest.workspace_id
|
|
`
|
|
|
|
type CountUnreadInboxByWorkspaceRow struct {
|
|
WorkspaceID pgtype.UUID `json:"workspace_id"`
|
|
Count int64 `json:"count"`
|
|
}
|
|
|
|
// Per-workspace unread inbox counts for a recipient member, matching the
|
|
// inbox UI's deduplicated view: notifications are grouped per issue
|
|
// (Linear-style, one row per issue) and an issue counts as unread only when
|
|
// its NEWEST non-archived item is unread. Opening an issue marks just that
|
|
// newest item read, so counting raw unread rows would keep older siblings
|
|
// alive and light the switcher dot for a workspace whose inbox the user sees
|
|
// as empty (MUL-3695). Items without an issue group on their own id. The
|
|
// member join keeps counts scoped to workspaces the user still belongs to,
|
|
// so a stale item left behind in a workspace the user has since left cannot
|
|
// light the dot.
|
|
func (q *Queries) CountUnreadInboxByWorkspace(ctx context.Context, recipientID pgtype.UUID) ([]CountUnreadInboxByWorkspaceRow, error) {
|
|
rows, err := q.db.Query(ctx, countUnreadInboxByWorkspace, recipientID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []CountUnreadInboxByWorkspaceRow{}
|
|
for rows.Next() {
|
|
var i CountUnreadInboxByWorkspaceRow
|
|
if err := rows.Scan(&i.WorkspaceID, &i.Count); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const createInboxItem = `-- name: CreateInboxItem :one
|
|
INSERT INTO inbox_item (
|
|
workspace_id, recipient_type, recipient_id,
|
|
type, severity, issue_id, title, body,
|
|
actor_type, actor_id, details
|
|
) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)
|
|
RETURNING id, workspace_id, recipient_type, recipient_id, type, severity, issue_id, title, body, read, archived, created_at, actor_type, actor_id, details
|
|
`
|
|
|
|
type CreateInboxItemParams struct {
|
|
WorkspaceID pgtype.UUID `json:"workspace_id"`
|
|
RecipientType string `json:"recipient_type"`
|
|
RecipientID pgtype.UUID `json:"recipient_id"`
|
|
Type string `json:"type"`
|
|
Severity string `json:"severity"`
|
|
IssueID pgtype.UUID `json:"issue_id"`
|
|
Title string `json:"title"`
|
|
Body pgtype.Text `json:"body"`
|
|
ActorType pgtype.Text `json:"actor_type"`
|
|
ActorID pgtype.UUID `json:"actor_id"`
|
|
Details []byte `json:"details"`
|
|
}
|
|
|
|
func (q *Queries) CreateInboxItem(ctx context.Context, arg CreateInboxItemParams) (InboxItem, error) {
|
|
row := q.db.QueryRow(ctx, createInboxItem,
|
|
arg.WorkspaceID,
|
|
arg.RecipientType,
|
|
arg.RecipientID,
|
|
arg.Type,
|
|
arg.Severity,
|
|
arg.IssueID,
|
|
arg.Title,
|
|
arg.Body,
|
|
arg.ActorType,
|
|
arg.ActorID,
|
|
arg.Details,
|
|
)
|
|
var i InboxItem
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.WorkspaceID,
|
|
&i.RecipientType,
|
|
&i.RecipientID,
|
|
&i.Type,
|
|
&i.Severity,
|
|
&i.IssueID,
|
|
&i.Title,
|
|
&i.Body,
|
|
&i.Read,
|
|
&i.Archived,
|
|
&i.CreatedAt,
|
|
&i.ActorType,
|
|
&i.ActorID,
|
|
&i.Details,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const getInboxItem = `-- name: GetInboxItem :one
|
|
SELECT id, workspace_id, recipient_type, recipient_id, type, severity, issue_id, title, body, read, archived, created_at, actor_type, actor_id, details FROM inbox_item
|
|
WHERE id = $1
|
|
`
|
|
|
|
func (q *Queries) GetInboxItem(ctx context.Context, id pgtype.UUID) (InboxItem, error) {
|
|
row := q.db.QueryRow(ctx, getInboxItem, id)
|
|
var i InboxItem
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.WorkspaceID,
|
|
&i.RecipientType,
|
|
&i.RecipientID,
|
|
&i.Type,
|
|
&i.Severity,
|
|
&i.IssueID,
|
|
&i.Title,
|
|
&i.Body,
|
|
&i.Read,
|
|
&i.Archived,
|
|
&i.CreatedAt,
|
|
&i.ActorType,
|
|
&i.ActorID,
|
|
&i.Details,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const getInboxItemInWorkspace = `-- name: GetInboxItemInWorkspace :one
|
|
SELECT id, workspace_id, recipient_type, recipient_id, type, severity, issue_id, title, body, read, archived, created_at, actor_type, actor_id, details FROM inbox_item
|
|
WHERE id = $1 AND workspace_id = $2
|
|
`
|
|
|
|
type GetInboxItemInWorkspaceParams struct {
|
|
ID pgtype.UUID `json:"id"`
|
|
WorkspaceID pgtype.UUID `json:"workspace_id"`
|
|
}
|
|
|
|
func (q *Queries) GetInboxItemInWorkspace(ctx context.Context, arg GetInboxItemInWorkspaceParams) (InboxItem, error) {
|
|
row := q.db.QueryRow(ctx, getInboxItemInWorkspace, arg.ID, arg.WorkspaceID)
|
|
var i InboxItem
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.WorkspaceID,
|
|
&i.RecipientType,
|
|
&i.RecipientID,
|
|
&i.Type,
|
|
&i.Severity,
|
|
&i.IssueID,
|
|
&i.Title,
|
|
&i.Body,
|
|
&i.Read,
|
|
&i.Archived,
|
|
&i.CreatedAt,
|
|
&i.ActorType,
|
|
&i.ActorID,
|
|
&i.Details,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const listArchivedInboxItems = `-- name: ListArchivedInboxItems :many
|
|
SELECT i.id, i.workspace_id, i.recipient_type, i.recipient_id, i.type, i.severity, i.issue_id, i.title, i.body, i.read, i.archived, i.created_at, i.actor_type, i.actor_id, i.details,
|
|
iss.status as issue_status
|
|
FROM inbox_item i
|
|
LEFT JOIN issue iss ON iss.id = i.issue_id
|
|
WHERE i.workspace_id = $1 AND i.recipient_type = $2 AND i.recipient_id = $3 AND i.archived = true
|
|
AND (i.issue_id IS NULL OR NOT EXISTS (
|
|
SELECT 1
|
|
FROM inbox_item active
|
|
WHERE active.workspace_id = i.workspace_id
|
|
AND active.recipient_type = i.recipient_type
|
|
AND active.recipient_id = i.recipient_id
|
|
AND active.issue_id = i.issue_id
|
|
AND active.archived = false
|
|
))
|
|
ORDER BY i.created_at DESC
|
|
LIMIT 200
|
|
`
|
|
|
|
type ListArchivedInboxItemsParams struct {
|
|
WorkspaceID pgtype.UUID `json:"workspace_id"`
|
|
RecipientType string `json:"recipient_type"`
|
|
RecipientID pgtype.UUID `json:"recipient_id"`
|
|
}
|
|
|
|
type ListArchivedInboxItemsRow struct {
|
|
ID pgtype.UUID `json:"id"`
|
|
WorkspaceID pgtype.UUID `json:"workspace_id"`
|
|
RecipientType string `json:"recipient_type"`
|
|
RecipientID pgtype.UUID `json:"recipient_id"`
|
|
Type string `json:"type"`
|
|
Severity string `json:"severity"`
|
|
IssueID pgtype.UUID `json:"issue_id"`
|
|
Title string `json:"title"`
|
|
Body pgtype.Text `json:"body"`
|
|
Read bool `json:"read"`
|
|
Archived bool `json:"archived"`
|
|
CreatedAt pgtype.Timestamptz `json:"created_at"`
|
|
ActorType pgtype.Text `json:"actor_type"`
|
|
ActorID pgtype.UUID `json:"actor_id"`
|
|
Details []byte `json:"details"`
|
|
IssueStatus pgtype.Text `json:"issue_status"`
|
|
}
|
|
|
|
// Archived counterpart of ListInboxItems, backing the inbox's "Archived"
|
|
// sub-view (MUL-3736).
|
|
//
|
|
// An issue whose group still has an active row is excluded: archiving is
|
|
// issue-level, so a NEW notification on an already-archived issue leaves the
|
|
// old archived rows in place alongside the fresh active one. The issue belongs
|
|
// in the main inbox at that point, and the two lists must stay mutually
|
|
// exclusive per issue group — otherwise the same issue renders in both. The
|
|
// exclusion lives here rather than in the client so neither list depends on
|
|
// the other's cache being loaded. Items without an issue_id group on their own
|
|
// id and can never have an active sibling, hence the IS NULL short-circuit.
|
|
//
|
|
// LIMIT bounds the response while the archive grows without end (v1 ships no
|
|
// pagination). Rows are newest-first, so truncation drops the OLDEST rows and
|
|
// can never hide a group's newest row — the one the deduplicated UI renders.
|
|
func (q *Queries) ListArchivedInboxItems(ctx context.Context, arg ListArchivedInboxItemsParams) ([]ListArchivedInboxItemsRow, error) {
|
|
rows, err := q.db.Query(ctx, listArchivedInboxItems, arg.WorkspaceID, arg.RecipientType, arg.RecipientID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []ListArchivedInboxItemsRow{}
|
|
for rows.Next() {
|
|
var i ListArchivedInboxItemsRow
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.WorkspaceID,
|
|
&i.RecipientType,
|
|
&i.RecipientID,
|
|
&i.Type,
|
|
&i.Severity,
|
|
&i.IssueID,
|
|
&i.Title,
|
|
&i.Body,
|
|
&i.Read,
|
|
&i.Archived,
|
|
&i.CreatedAt,
|
|
&i.ActorType,
|
|
&i.ActorID,
|
|
&i.Details,
|
|
&i.IssueStatus,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const listInboxItems = `-- name: ListInboxItems :many
|
|
SELECT i.id, i.workspace_id, i.recipient_type, i.recipient_id, i.type, i.severity, i.issue_id, i.title, i.body, i.read, i.archived, i.created_at, i.actor_type, i.actor_id, i.details,
|
|
iss.status as issue_status
|
|
FROM inbox_item i
|
|
LEFT JOIN issue iss ON iss.id = i.issue_id
|
|
WHERE i.workspace_id = $1 AND i.recipient_type = $2 AND i.recipient_id = $3 AND i.archived = false
|
|
ORDER BY i.created_at DESC
|
|
`
|
|
|
|
type ListInboxItemsParams struct {
|
|
WorkspaceID pgtype.UUID `json:"workspace_id"`
|
|
RecipientType string `json:"recipient_type"`
|
|
RecipientID pgtype.UUID `json:"recipient_id"`
|
|
}
|
|
|
|
type ListInboxItemsRow struct {
|
|
ID pgtype.UUID `json:"id"`
|
|
WorkspaceID pgtype.UUID `json:"workspace_id"`
|
|
RecipientType string `json:"recipient_type"`
|
|
RecipientID pgtype.UUID `json:"recipient_id"`
|
|
Type string `json:"type"`
|
|
Severity string `json:"severity"`
|
|
IssueID pgtype.UUID `json:"issue_id"`
|
|
Title string `json:"title"`
|
|
Body pgtype.Text `json:"body"`
|
|
Read bool `json:"read"`
|
|
Archived bool `json:"archived"`
|
|
CreatedAt pgtype.Timestamptz `json:"created_at"`
|
|
ActorType pgtype.Text `json:"actor_type"`
|
|
ActorID pgtype.UUID `json:"actor_id"`
|
|
Details []byte `json:"details"`
|
|
IssueStatus pgtype.Text `json:"issue_status"`
|
|
}
|
|
|
|
func (q *Queries) ListInboxItems(ctx context.Context, arg ListInboxItemsParams) ([]ListInboxItemsRow, error) {
|
|
rows, err := q.db.Query(ctx, listInboxItems, arg.WorkspaceID, arg.RecipientType, arg.RecipientID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []ListInboxItemsRow{}
|
|
for rows.Next() {
|
|
var i ListInboxItemsRow
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.WorkspaceID,
|
|
&i.RecipientType,
|
|
&i.RecipientID,
|
|
&i.Type,
|
|
&i.Severity,
|
|
&i.IssueID,
|
|
&i.Title,
|
|
&i.Body,
|
|
&i.Read,
|
|
&i.Archived,
|
|
&i.CreatedAt,
|
|
&i.ActorType,
|
|
&i.ActorID,
|
|
&i.Details,
|
|
&i.IssueStatus,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const markAllInboxRead = `-- name: MarkAllInboxRead :execrows
|
|
UPDATE inbox_item SET read = true
|
|
WHERE workspace_id = $1 AND recipient_type = 'member' AND recipient_id = $2 AND archived = false AND read = false
|
|
`
|
|
|
|
type MarkAllInboxReadParams struct {
|
|
WorkspaceID pgtype.UUID `json:"workspace_id"`
|
|
RecipientID pgtype.UUID `json:"recipient_id"`
|
|
}
|
|
|
|
func (q *Queries) MarkAllInboxRead(ctx context.Context, arg MarkAllInboxReadParams) (int64, error) {
|
|
result, err := q.db.Exec(ctx, markAllInboxRead, arg.WorkspaceID, arg.RecipientID)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return result.RowsAffected(), nil
|
|
}
|
|
|
|
const markInboxRead = `-- name: MarkInboxRead :one
|
|
UPDATE inbox_item SET read = true
|
|
WHERE id = $1
|
|
RETURNING id, workspace_id, recipient_type, recipient_id, type, severity, issue_id, title, body, read, archived, created_at, actor_type, actor_id, details
|
|
`
|
|
|
|
func (q *Queries) MarkInboxRead(ctx context.Context, id pgtype.UUID) (InboxItem, error) {
|
|
row := q.db.QueryRow(ctx, markInboxRead, id)
|
|
var i InboxItem
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.WorkspaceID,
|
|
&i.RecipientType,
|
|
&i.RecipientID,
|
|
&i.Type,
|
|
&i.Severity,
|
|
&i.IssueID,
|
|
&i.Title,
|
|
&i.Body,
|
|
&i.Read,
|
|
&i.Archived,
|
|
&i.CreatedAt,
|
|
&i.ActorType,
|
|
&i.ActorID,
|
|
&i.Details,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const unarchiveInboxByIssue = `-- name: UnarchiveInboxByIssue :execrows
|
|
UPDATE inbox_item SET archived = false
|
|
WHERE workspace_id = $1 AND recipient_type = $2 AND recipient_id = $3 AND issue_id = $4 AND archived = true
|
|
`
|
|
|
|
type UnarchiveInboxByIssueParams struct {
|
|
WorkspaceID pgtype.UUID `json:"workspace_id"`
|
|
RecipientType string `json:"recipient_type"`
|
|
RecipientID pgtype.UUID `json:"recipient_id"`
|
|
IssueID pgtype.UUID `json:"issue_id"`
|
|
}
|
|
|
|
// Issue-level restore, mirroring ArchiveInboxByIssue: archiving one item
|
|
// archives every sibling for the same issue, so unarchiving must bring the
|
|
// whole group back. Leaves `read` untouched for the same reason as above.
|
|
func (q *Queries) UnarchiveInboxByIssue(ctx context.Context, arg UnarchiveInboxByIssueParams) (int64, error) {
|
|
result, err := q.db.Exec(ctx, unarchiveInboxByIssue,
|
|
arg.WorkspaceID,
|
|
arg.RecipientType,
|
|
arg.RecipientID,
|
|
arg.IssueID,
|
|
)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return result.RowsAffected(), nil
|
|
}
|
|
|
|
const unarchiveInboxItem = `-- name: UnarchiveInboxItem :one
|
|
UPDATE inbox_item SET archived = false
|
|
WHERE id = $1
|
|
RETURNING id, workspace_id, recipient_type, recipient_id, type, severity, issue_id, title, body, read, archived, created_at, actor_type, actor_id, details
|
|
`
|
|
|
|
// Deliberately does not touch `read`: unarchiving restores an item to the main
|
|
// inbox in the exact read/unread state it was archived in, so restoring an
|
|
// unread item legitimately raises the unread badge again (MUL-3736).
|
|
func (q *Queries) UnarchiveInboxItem(ctx context.Context, id pgtype.UUID) (InboxItem, error) {
|
|
row := q.db.QueryRow(ctx, unarchiveInboxItem, id)
|
|
var i InboxItem
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.WorkspaceID,
|
|
&i.RecipientType,
|
|
&i.RecipientID,
|
|
&i.Type,
|
|
&i.Severity,
|
|
&i.IssueID,
|
|
&i.Title,
|
|
&i.Body,
|
|
&i.Read,
|
|
&i.Archived,
|
|
&i.CreatedAt,
|
|
&i.ActorType,
|
|
&i.ActorID,
|
|
&i.Details,
|
|
)
|
|
return i, err
|
|
}
|