mirror of
https://github.com/multica-ai/multica.git
synced 2026-07-06 14:00:09 +02:00
9e807efc62
* feat(sidebar): mark which workspace has unread in the switcher dropdown (MUL-3695) The aggregate avatar dot only says "some other workspace has unread". When the user opens the workspace switcher they couldn't tell which one. Add a per-row brand dot next to each OTHER workspace that has unread inbox items, in the same right-edge slot as the active-workspace check (the active workspace is excluded — its unread is the Inbox nav count — so dot and check never collide on one row). Reuses the existing cross-workspace summary data; no backend change. New pure helper unreadWorkspaceIds() + unit tests, and AppSidebar dropdown tests covering: dot only on the other unread workspace, no dot at count 0, and never on the active workspace. Co-authored-by: multica-agent <github@multica.ai> * fix(inbox): count switcher unread per issue, matching the inbox dedup (MUL-3695) The unread-summary that drives the workspace-switcher dot counted raw unread inbox_item rows, but the inbox UI deduplicates notifications per issue and treats an issue as read when its NEWEST non-archived item is read. Opening an issue marks only that newest item read (markInboxRead is per-item; only archive cascades to siblings), so older siblings stay unread in the DB. Result: a workspace whose inbox the user sees as empty still lit the dot (reported on bohan-personal showing a dot for Multica AI with no unread). Rewrite CountUnreadInboxByWorkspace to pick the newest non-archived item per (workspace, issue-or-id group) via DISTINCT ON and count only groups whose newest item is unread — the exact semantics of deduplicateInboxItems(...).filter(!read) on the client. No schema/handler change; query-only. Adds TestInboxUnreadSummaryDedupesByIssue covering the read-newest / unread-older case and its inverse. Co-authored-by: multica-agent <github@multica.ai> --------- Co-authored-by: J <j@multica.ai> Co-authored-by: multica-agent <github@multica.ai>
465 lines
14 KiB
Go
465 lines
14 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 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
|
|
}
|