multica/server/pkg/db/generated/inbox.sql.go

// Code generated by sqlc. DO NOT EDIT.
// versions:
//   sqlc v1.30.0
// source: inbox.sql

package db

import (
	"context"

	"github.com/jackc/pgx/v5/pgtype"
)

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
`

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,
	)
	return i, err
}

const countUnreadInbox = `-- name: CountUnreadInbox :one
SELECT count(*) FROM inbox_item
WHERE recipient_type = $1 AND recipient_id = $2 AND read = false AND archived = false
`

type CountUnreadInboxParams struct {
	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.RecipientType, arg.RecipientID)
	var count int64
	err := row.Scan(&count)
	return count, err
}

const createInboxItem = `-- name: CreateInboxItem :one
INSERT INTO inbox_item (
    workspace_id, recipient_type, recipient_id,
    type, severity, issue_id, title, body
) VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
RETURNING id, workspace_id, recipient_type, recipient_id, type, severity, issue_id, title, body, read, archived, created_at
`

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"`
}

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,
	)
	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,
	)
	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 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,
	)
	return i, err
}

const listInboxItems = `-- name: ListInboxItems :many
SELECT id, workspace_id, recipient_type, recipient_id, type, severity, issue_id, title, body, read, archived, created_at FROM inbox_item
WHERE recipient_type = $1 AND recipient_id = $2 AND archived = false
ORDER BY created_at DESC
LIMIT $3 OFFSET $4
`

type ListInboxItemsParams struct {
	RecipientType string      `json:"recipient_type"`
	RecipientID   pgtype.UUID `json:"recipient_id"`
	Limit         int32       `json:"limit"`
	Offset        int32       `json:"offset"`
}

func (q *Queries) ListInboxItems(ctx context.Context, arg ListInboxItemsParams) ([]InboxItem, error) {
	rows, err := q.db.Query(ctx, listInboxItems,
		arg.RecipientType,
		arg.RecipientID,
		arg.Limit,
		arg.Offset,
	)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []InboxItem{}
	for rows.Next() {
		var i InboxItem
		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,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, 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
`

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,
	)
	return i, err
}