Files
kandev/apps/backend/internal/task/share/repository.go
T
2026-09-07 19:28:31 +01:00

191 lines
5.9 KiB
Go

package share
import (
"context"
"database/sql"
"errors"
"fmt"
"time"
"github.com/jmoiron/sqlx"
"github.com/kandev/kandev/internal/common/logger"
"github.com/kandev/kandev/internal/db"
"github.com/kandev/kandev/internal/db/dialect"
)
// Backend identifiers persisted in task_shares.backend.
const (
BackendGitHubGist = "github_gist"
)
// ErrNotFound is returned when a share row cannot be located.
var ErrNotFound = errors.New("share not found")
// Share is the persisted representation of a published share link. The
// snapshot payload itself lives at ExternalURL; only metadata is stored
// locally.
type Share struct {
ID string
TaskSessionID string
Backend string
ExternalID string
ExternalURL string
SnapshotSizeBytes int64
CreatedAt time.Time
RevokedAt *time.Time
ViewCount int
}
// IsRevoked returns true when the share has been revoked.
func (s *Share) IsRevoked() bool { return s.RevokedAt != nil }
// Repository persists Share rows in the configured SQL database.
type Repository struct {
writer *sqlx.DB
reader *sqlx.DB
log *logger.Logger
}
// NewRepository creates a share repository and applies its migration. The
// caller owns the database connections; Close is a no-op.
func NewRepository(writer, reader *sqlx.DB, log *logger.Logger) (*Repository, error) {
r := &Repository{writer: writer, reader: reader, log: log}
if err := r.initSchema(); err != nil {
return nil, fmt.Errorf("share repo: init schema: %w", err)
}
return r, nil
}
func (r *Repository) initSchema() error {
mig := db.NewRequiredMigrateLogger(r.writer, r.log)
if err := mig.Apply("table.task_shares", dialect.MustRenderSchema(r.writer.DriverName(), shareTableSchema)); err != nil {
return fmt.Errorf("required task share migration: %w", err)
}
if err := mig.Apply("index.task_shares_session",
`CREATE INDEX IF NOT EXISTS idx_task_shares_session ON task_shares(task_session_id)`); err != nil {
return fmt.Errorf("required task share migration: %w", err)
}
if err := mig.Err(); err != nil {
return fmt.Errorf("required task share migration: %w", err)
}
return nil
}
const shareTableSchema = `CREATE TABLE IF NOT EXISTS task_shares (
id TEXT PRIMARY KEY,
task_session_id TEXT NOT NULL,
backend TEXT NOT NULL,
external_id TEXT NOT NULL,
external_url TEXT NOT NULL,
snapshot_size_bytes INTEGER NOT NULL,
created_at {{timestamp}} NOT NULL,
revoked_at {{timestamp}} NULL,
view_count INTEGER NOT NULL DEFAULT 0
)`
// Create inserts a new share row. ID, Backend, ExternalID, ExternalURL, and
// TaskSessionID must be set by the caller. CreatedAt defaults to time.Now()
// (UTC) if zero.
func (r *Repository) Create(ctx context.Context, s *Share) error {
if s.CreatedAt.IsZero() {
s.CreatedAt = time.Now().UTC()
}
_, err := r.writer.ExecContext(ctx, r.writer.Rebind(`INSERT INTO task_shares
(id, task_session_id, backend, external_id, external_url, snapshot_size_bytes, created_at, view_count)
VALUES (?, ?, ?, ?, ?, ?, ?, ?)`),
s.ID, s.TaskSessionID, s.Backend, s.ExternalID, s.ExternalURL,
s.SnapshotSizeBytes, s.CreatedAt, s.ViewCount,
)
if err != nil {
return fmt.Errorf("insert task_share: %w", err)
}
return nil
}
// GetByID returns the share with the given ID, or ErrNotFound.
func (r *Repository) GetByID(ctx context.Context, id string) (*Share, error) {
row := r.reader.QueryRowxContext(ctx, r.reader.Rebind(`SELECT
id, task_session_id, backend, external_id, external_url,
snapshot_size_bytes, created_at, revoked_at, view_count
FROM task_shares WHERE id = ?`), id)
return scanShareRow(row)
}
// ListByTaskSession returns every share row for a session ordered by creation
// time (newest first), including revoked rows.
func (r *Repository) ListByTaskSession(ctx context.Context, sessionID string) ([]*Share, error) {
rows, err := r.reader.QueryxContext(ctx, r.reader.Rebind(`SELECT
id, task_session_id, backend, external_id, external_url,
snapshot_size_bytes, created_at, revoked_at, view_count
FROM task_shares
WHERE task_session_id = ?
ORDER BY created_at DESC`), sessionID)
if err != nil {
return nil, fmt.Errorf("list task_shares: %w", err)
}
defer func() { _ = rows.Close() }()
var out []*Share
for rows.Next() {
s, err := scanShareRow(rows)
if err != nil {
return nil, err
}
out = append(out, s)
}
return out, rows.Err()
}
// MarkRevoked sets revoked_at on the share row. If the row is already revoked,
// the existing revoked_at is preserved.
func (r *Repository) MarkRevoked(ctx context.Context, id string, at time.Time) error {
res, err := r.writer.ExecContext(ctx, r.writer.Rebind(
`UPDATE task_shares SET revoked_at = ? WHERE id = ? AND revoked_at IS NULL`),
at.UTC(), id,
)
if err != nil {
return fmt.Errorf("update task_share revoked_at: %w", err)
}
affected, err := res.RowsAffected()
if err != nil {
return fmt.Errorf("rows affected: %w", err)
}
if affected == 0 {
// Either missing or already revoked. Distinguish so the caller can
// return a clean 404 vs treating the second call as a no-op.
existing, getErr := r.GetByID(ctx, id)
if errors.Is(getErr, ErrNotFound) {
return ErrNotFound
}
if getErr != nil {
return getErr
}
_ = existing // already revoked — caller treats this as success.
}
return nil
}
// scanShareRow is shared between QueryRowx and Queryx callers.
type rowScanner interface {
Scan(dest ...interface{}) error
}
func scanShareRow(row rowScanner) (*Share, error) {
var s Share
var revokedAt sql.NullTime
if err := row.Scan(
&s.ID, &s.TaskSessionID, &s.Backend, &s.ExternalID, &s.ExternalURL,
&s.SnapshotSizeBytes, &s.CreatedAt, &revokedAt, &s.ViewCount,
); err != nil {
if errors.Is(err, sql.ErrNoRows) {
return nil, ErrNotFound
}
return nil, fmt.Errorf("scan task_share: %w", err)
}
if revokedAt.Valid {
t := revokedAt.Time
s.RevokedAt = &t
}
return &s, nil
}