minstrel/internal/db/queries/notifications.sql

-- M489 notifications inbox (#726). Rows are written only through
-- internal/notifications.Notifier, which decides recipients and honours each
-- recipient's inbox preference before it reaches these.

-- name: InsertNotification :one
INSERT INTO user_notifications (user_id, kind, payload)
VALUES (sqlc.arg(user_id), sqlc.arg(kind), sqlc.arg(payload))
RETURNING id;

-- name: UpsertCoalescedNotification :one
-- One unread row per (user, coalesce_key). A new event while that row is
-- unread updates it in place and moves it back to the top of the inbox.
--
-- sum_count: the payload's `count` adds to the unread row's count rather than
-- replacing it. For kinds whose event is "N more happened" (tracks marked
-- missing). Kinds whose event states the whole current total (pending
-- duplicate groups) pass false and the payload simply replaces.
--
-- emailed_at is cleared so the newer state goes out in the next batch; an
-- emailed-but-unread row that keeps growing is news the user hasn't seen.
INSERT INTO user_notifications (user_id, kind, payload, coalesce_key)
VALUES (sqlc.arg(user_id), sqlc.arg(kind), sqlc.arg(payload), sqlc.arg(coalesce_key))
ON CONFLICT (user_id, coalesce_key) WHERE read_at IS NULL AND coalesce_key IS NOT NULL
DO UPDATE SET
    payload = CASE
        WHEN sqlc.arg(sum_count)::boolean THEN
            EXCLUDED.payload || jsonb_build_object('count',
                COALESCE((user_notifications.payload->>'count')::bigint, 0)
              + COALESCE((EXCLUDED.payload->>'count')::bigint, 0))
        ELSE EXCLUDED.payload
    END,
    created_at = now(),
    emailed_at = NULL
RETURNING id;

-- name: ListNotifications :many
-- Newest first, keyset-paged on (created_at, id). Pass both cursor halves
-- from the last row of the previous page, or neither for the first page.
SELECT id, kind, payload, created_at, read_at
  FROM user_notifications
 WHERE user_id = sqlc.arg(user_id)
   AND (sqlc.narg(before_created_at)::timestamptz IS NULL
        OR (created_at, id) < (sqlc.narg(before_created_at)::timestamptz, sqlc.narg(before_id)::uuid))
 ORDER BY created_at DESC, id DESC
 LIMIT sqlc.arg(page_limit);

-- name: CountUnreadNotifications :one
SELECT count(*) FROM user_notifications
 WHERE user_id = $1 AND read_at IS NULL;

-- name: MarkNotificationRead :execrows
-- Scoped to the owner: another user's id matches no row. Marking an already
-- read row keeps its original read_at and still matches, so a repeat is not
-- mistaken for "not yours".
UPDATE user_notifications
   SET read_at = COALESCE(read_at, now())
 WHERE id = sqlc.arg(id) AND user_id = sqlc.arg(user_id);

-- name: MarkAllNotificationsRead :execrows
UPDATE user_notifications
   SET read_at = now()
 WHERE user_id = $1 AND read_at IS NULL;

-- name: TrimNotifications :execrows
-- Retention: read rows go after read_cutoff, and anything at all after
-- any_cutoff, so an inbox nobody opens doesn't grow without bound either.
DELETE FROM user_notifications
 WHERE (read_at IS NOT NULL AND read_at < sqlc.arg(read_cutoff))
    OR created_at < sqlc.arg(any_cutoff);

-- name: ListAdminUserIDs :many
SELECT id FROM users WHERE is_admin = true ORDER BY created_at, id;

-- name: ListNotificationPrefsForUser :many
SELECT kind, inbox, phone, email
  FROM user_notification_prefs
 WHERE user_id = $1;

-- name: ListNotificationPrefsForKind :many
-- The stored prefs of one kind for a set of recipients. A recipient with no
-- row has the kind's defaults.
SELECT user_id, inbox, phone, email
  FROM user_notification_prefs
 WHERE kind = sqlc.arg(kind) AND user_id = ANY(sqlc.arg(user_ids)::uuid[]);

-- name: UpsertNotificationPref :exec
INSERT INTO user_notification_prefs (user_id, kind, inbox, phone, email)
VALUES (sqlc.arg(user_id), sqlc.arg(kind), sqlc.arg(inbox), sqlc.arg(phone), sqlc.arg(email))
ON CONFLICT (user_id, kind) DO UPDATE SET
    inbox      = EXCLUDED.inbox,
    phone      = EXCLUDED.phone,
    email      = EXCLUDED.email,
    updated_at = now();