Files
pages/internal/store/activity_outbox.go
Anya Tokugawa c1175d389f Implement Knowledge City platform, organizer and DAV integration
Capture accumulated application, UI, CLI, regression tests and design documentation changes, including task project mapping and default CalDAV list naming.

Keep deployment data, backups, local credentials and build artifacts out of Git. Move the Compose enrollment token to an ignored local environment file.
2026-09-27 14:44:43 +09:00

304 lines
12 KiB
Go

package store
import (
"context"
"database/sql"
"encoding/json"
"errors"
"strings"
"time"
"github.com/google/uuid"
)
// ActivityOutboxEvent is the small, immutable envelope written together with
// a source mutation. Payloads are deliberately opaque to the store; consumers
// must re-authorize the referenced object when they project it.
type ActivityOutboxEvent struct {
UUID string
DomainUUID string
EventType string
ActorUUID string
TargetKind string
TargetUUID string
Payload string
IdempotencyKey string
}
type ActivityOutboxRecord struct {
UUID string `json:"uuid"`
DomainUUID string `json:"domain_uuid"`
Sequence int64 `json:"sequence"`
EventType string `json:"event_type"`
ActorUUID string `json:"actor_uuid,omitempty"`
TargetKind string `json:"target_kind,omitempty"`
TargetUUID string `json:"target_uuid,omitempty"`
Payload string `json:"payload,omitempty"`
IdempotencyKey string `json:"idempotency_key"`
Status string `json:"status"`
Attempts int `json:"attempts"`
NextAttemptMS int64 `json:"next_attempt_ms"`
LastError string `json:"last_error,omitempty"`
CreatedAtMS int64 `json:"created_at_ms"`
ClaimedAtMS int64 `json:"claimed_at_ms,omitempty"`
}
type ActivityOutboxCheckpoint struct {
ConsumerID string `json:"consumer_id"`
DomainUUID string `json:"domain_uuid"`
LastSequence int64 `json:"last_sequence"`
UpdatedAtMS int64 `json:"updated_at_ms"`
}
var ErrActivityOutboxInput = errors.New("invalid activity outbox event")
func (s *Store) EnsureActivityOutboxSchema() error {
statements := []string{
`CREATE TABLE IF NOT EXISTS activity_outbox (
uuid TEXT PRIMARY KEY,
domain_uuid TEXT NOT NULL,
sequence INTEGER NOT NULL,
event_type TEXT NOT NULL,
actor_uuid TEXT NOT NULL DEFAULT '',
target_kind TEXT NOT NULL DEFAULT '',
target_uuid TEXT NOT NULL DEFAULT '',
payload TEXT NOT NULL DEFAULT '',
idempotency_key TEXT NOT NULL,
status TEXT NOT NULL DEFAULT 'pending',
attempts INTEGER NOT NULL DEFAULT 0,
next_attempt_ms INTEGER NOT NULL,
last_error TEXT NOT NULL DEFAULT '',
created_at_ms INTEGER NOT NULL,
claimed_at_ms INTEGER NOT NULL DEFAULT 0,
UNIQUE(domain_uuid, sequence),
UNIQUE(domain_uuid, idempotency_key)
)`,
`CREATE INDEX IF NOT EXISTS idx_activity_outbox_pending
ON activity_outbox(status, next_attempt_ms, domain_uuid, sequence)`,
`CREATE INDEX IF NOT EXISTS idx_activity_outbox_target
ON activity_outbox(domain_uuid, target_uuid, sequence)`,
`CREATE TABLE IF NOT EXISTS activity_outbox_checkpoints (
consumer_id TEXT NOT NULL,
domain_uuid TEXT NOT NULL,
last_sequence INTEGER NOT NULL DEFAULT 0,
updated_at_ms INTEGER NOT NULL,
PRIMARY KEY(consumer_id, domain_uuid)
)`,
}
for _, statement := range statements {
if _, err := s.DB.Exec(statement); err != nil {
return err
}
}
return s.ensureActivitySubscriptions()
}
// AppendActivityOutboxTx must be called using the transaction that commits the
// source mutation. Repeated idempotency keys return the original envelope and
// never create a second Domain sequence number.
func (s *Store) AppendActivityOutboxTx(tx *sql.Tx, event ActivityOutboxEvent) (ActivityOutboxRecord, bool, error) {
event.DomainUUID = strings.TrimSpace(event.DomainUUID)
event.EventType = strings.TrimSpace(event.EventType)
event.IdempotencyKey = strings.TrimSpace(event.IdempotencyKey)
if event.DomainUUID == "" || event.EventType == "" || event.IdempotencyKey == "" {
return ActivityOutboxRecord{}, false, ErrActivityOutboxInput
}
if event.UUID == "" {
event.UUID = uuid.NewString()
}
var existing ActivityOutboxRecord
err := scanActivityOutbox(tx.QueryRow(`SELECT `+activityOutboxColumns+`
FROM activity_outbox WHERE domain_uuid=? AND idempotency_key=?`, event.DomainUUID, event.IdempotencyKey), &existing)
if err == nil {
return existing, false, nil
}
if !errors.Is(err, sql.ErrNoRows) {
return ActivityOutboxRecord{}, false, err
}
var sequence int64
if err := tx.QueryRow(`SELECT COALESCE(MAX(last_sequence),0)+1 FROM activity_outbox_heads WHERE domain_uuid=?`, event.DomainUUID).Scan(&sequence); err != nil {
return ActivityOutboxRecord{}, false, err
}
now := time.Now().UnixMilli()
if _, err := tx.Exec(`INSERT INTO activity_outbox
(uuid,domain_uuid,sequence,event_type,actor_uuid,target_kind,target_uuid,payload,idempotency_key,status,attempts,next_attempt_ms,last_error,created_at_ms,claimed_at_ms)
VALUES(?,?,?,?,?,?,?,?,?,'pending',0,?,'',?,0)`, event.UUID, event.DomainUUID, sequence, event.EventType,
event.ActorUUID, event.TargetKind, event.TargetUUID, event.Payload, event.IdempotencyKey, now, now); err != nil {
return ActivityOutboxRecord{}, false, err
}
var created ActivityOutboxRecord
if err := scanActivityOutbox(tx.QueryRow(`SELECT `+activityOutboxColumns+` FROM activity_outbox WHERE uuid=?`, event.UUID), &created); err != nil {
return ActivityOutboxRecord{}, false, err
}
return created, true, nil
}
// appendActivityOutboxIfAvailable keeps lightweight legacy fixtures (which
// intentionally construct only a subset of the schema) usable while every
// normal Store created through New has the outbox table.
func (s *Store) appendActivityOutboxIfAvailable(tx *sql.Tx, event ActivityOutboxEvent) error {
var present int
if err := tx.QueryRow(`SELECT COUNT(*) FROM sqlite_master WHERE type='table' AND name='activity_outbox'`).Scan(&present); err != nil {
return err
}
if present == 0 {
return nil
}
_, _, err := s.AppendActivityOutboxTx(tx, event)
return err
}
func (s *Store) appendRevisionActivityOutboxIfAvailable(tx *sql.Tx, revision *Revision) error {
var domainUUID string
err := tx.QueryRow(`SELECT domain_uuid FROM paths WHERE object_uuid=? ORDER BY is_primary DESC, path LIMIT 1`, revision.ObjectUUID).Scan(&domainUUID)
if errors.Is(err, sql.ErrNoRows) {
return nil
}
if err != nil {
// Asset-only or legacy fixtures may not have a path for the object.
return nil
}
payload, err := json.Marshal(map[string]any{
"revision_uuid": revision.UUID, "object_uuid": revision.ObjectUUID,
"document_hash": revision.DocumentHash, "content_type": revision.ContentType,
"filename": revision.Filename,
})
if err != nil {
return err
}
return s.appendActivityOutboxIfAvailable(tx, ActivityOutboxEvent{
DomainUUID: domainUUID, EventType: "revision.created", TargetKind: "revision", TargetUUID: revision.UUID,
Payload: string(payload), IdempotencyKey: "revision.created:" + revision.UUID,
})
}
const activityOutboxColumns = `uuid,domain_uuid,sequence,event_type,actor_uuid,target_kind,target_uuid,payload,idempotency_key,status,attempts,next_attempt_ms,last_error,created_at_ms,claimed_at_ms`
func scanActivityOutbox(scanner interface{ Scan(...any) error }, out *ActivityOutboxRecord) error {
return scanner.Scan(&out.UUID, &out.DomainUUID, &out.Sequence, &out.EventType, &out.ActorUUID, &out.TargetKind,
&out.TargetUUID, &out.Payload, &out.IdempotencyKey, &out.Status, &out.Attempts, &out.NextAttemptMS,
&out.LastError, &out.CreatedAtMS, &out.ClaimedAtMS)
}
// PendingActivityOutbox returns a bounded page for a worker or repair command.
// Claiming is intentionally separate so consumers can use their own lease and
// authorization policy without making reads of the source object implicit.
// Deprecated: this is a legacy-status inspection, not consumer pending work.
// New workers must use ActivityOutboxForConsumer and their own checkpoint.
func (s *Store) PendingActivityOutbox(ctx context.Context, domainUUID string, limit int) ([]ActivityOutboxRecord, error) {
if limit < 1 || limit > 500 {
limit = 100
}
rows, err := s.DB.QueryContext(ctx, `SELECT `+activityOutboxColumns+` FROM activity_outbox
WHERE status='pending' AND next_attempt_ms<=? AND (?='' OR domain_uuid=?)
ORDER BY domain_uuid,sequence LIMIT ?`, time.Now().UnixMilli(), domainUUID, domainUUID, limit)
if err != nil {
return nil, err
}
defer rows.Close()
items := make([]ActivityOutboxRecord, 0, limit)
for rows.Next() {
var item ActivityOutboxRecord
if err := scanActivityOutbox(rows, &item); err != nil {
return nil, err
}
items = append(items, item)
}
return items, rows.Err()
}
// ActivityOutboxAfter reads the immutable Domain sequence independently for
// each consumer. It intentionally includes every status: a consumer's
// checkpoint, rather than a shared job status, is the delivery contract.
func (s *Store) ActivityOutboxAfter(ctx context.Context, domainUUID string, afterSequence int64, limit int) ([]ActivityOutboxRecord, error) {
if strings.TrimSpace(domainUUID) == "" || afterSequence < 0 {
return nil, ErrActivityOutboxInput
}
if limit < 1 || limit > 500 {
limit = 100
}
rows, err := s.DB.QueryContext(ctx, `SELECT `+activityOutboxColumns+` FROM activity_outbox
WHERE domain_uuid=? AND sequence>? ORDER BY sequence LIMIT ?`, domainUUID, afterSequence, limit)
if err != nil {
return nil, err
}
defer rows.Close()
items := make([]ActivityOutboxRecord, 0, limit)
for rows.Next() {
var item ActivityOutboxRecord
if err := scanActivityOutbox(rows, &item); err != nil {
return nil, err
}
items = append(items, item)
}
return items, rows.Err()
}
func (s *Store) ActivityOutboxCheckpoint(consumerID, domainUUID string) (ActivityOutboxCheckpoint, error) {
consumerID, domainUUID = strings.TrimSpace(consumerID), strings.TrimSpace(domainUUID)
if consumerID == "" || domainUUID == "" {
return ActivityOutboxCheckpoint{}, ErrActivityOutboxInput
}
var checkpoint ActivityOutboxCheckpoint
err := s.DB.QueryRow(`SELECT consumer_id,domain_uuid,last_sequence,updated_at_ms FROM activity_outbox_checkpoints WHERE consumer_id=? AND domain_uuid=?`, consumerID, domainUUID).
Scan(&checkpoint.ConsumerID, &checkpoint.DomainUUID, &checkpoint.LastSequence, &checkpoint.UpdatedAtMS)
if errors.Is(err, sql.ErrNoRows) {
return ActivityOutboxCheckpoint{ConsumerID: consumerID, DomainUUID: domainUUID}, nil
}
return checkpoint, err
}
// AdvanceActivityOutboxCheckpointTx is monotonic and safe to call after an
// idempotently completed consumer action. A stale retry can never move the
// checkpoint backwards.
func (s *Store) AdvanceActivityOutboxCheckpointTx(tx *sql.Tx, consumerID, domainUUID string, sequence int64) error {
consumerID, domainUUID = strings.TrimSpace(consumerID), strings.TrimSpace(domainUUID)
if consumerID == "" || domainUUID == "" || sequence < 0 {
return ErrActivityOutboxInput
}
now := time.Now().UnixMilli()
_, err := tx.Exec(`INSERT INTO activity_outbox_checkpoints(consumer_id,domain_uuid,last_sequence,updated_at_ms)
VALUES(?,?,?,?) ON CONFLICT(consumer_id,domain_uuid) DO UPDATE SET
last_sequence=CASE WHEN excluded.last_sequence>last_sequence THEN excluded.last_sequence ELSE last_sequence END,
updated_at_ms=CASE WHEN excluded.last_sequence>last_sequence THEN excluded.updated_at_ms ELSE updated_at_ms END`, consumerID, domainUUID, sequence, now)
return err
}
func (s *Store) AdvanceActivityOutboxCheckpoint(consumerID, domainUUID string, sequence int64) error {
tx, err := s.DB.Begin()
if err != nil {
return err
}
defer tx.Rollback()
if err := s.AdvanceActivityOutboxCheckpointTx(tx, consumerID, domainUUID, sequence); err != nil {
return err
}
return tx.Commit()
}
// Deprecated: use PendingActivityConsumerDomains; a shared status cannot
// represent delivery to independent subscribers.
func (s *Store) PendingActivityOutboxDomains(ctx context.Context) ([]string, error) {
rows, err := s.DB.QueryContext(ctx, `SELECT DISTINCT domain_uuid FROM activity_outbox WHERE status='pending' ORDER BY domain_uuid LIMIT 100`)
if err != nil {
return nil, err
}
defer rows.Close()
domains := make([]string, 0)
for rows.Next() {
var domain string
if err := rows.Scan(&domain); err != nil {
return nil, err
}
domains = append(domains, domain)
}
return domains, rows.Err()
}
// CompleteActivityOutboxThrough acknowledges only this consumer. The legacy
// per-event status is not a delivery receipt for any other subscriber.
// A failed projection must not call this.
func (s *Store) CompleteActivityOutboxThrough(consumerID, domainUUID string, sequence int64) error {
return s.AdvanceActivityOutboxCheckpoint(consumerID, domainUUID, sequence)
}