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) }