Files
pages/internal/store/tasks_activity.go
T
Anya Tokugawa 38a4fcf530
Build and publish container images / images (push) Successful in 11m42s
Release container images / release (push) Successful in 27s
feat(tasks): add explicit deletion with DAV tombstones
2026-11-08 18:04:54 +09:00

95 lines
3.6 KiB
Go

package store
import (
"context"
"database/sql"
"encoding/json"
"strconv"
"time"
)
const TaskActivityBridgeEventType = "task.activity.publish"
// No title, notes, Wiki path or dates are copied into the common journal.
// Consumers must reload the item and verify current authority before delivery.
func (s *Store) appendTaskActivityTx(tx *sql.Tx, domain, actor, id, kind string, version, occurred int64) (bool, error) {
if (kind != "task" && kind != "project") || version < 1 {
return false, ErrTaskInvalid
}
payload, err := json.Marshal(struct {
Version int64 `json:"version"`
OccurredMS int64 `json:"occurred_at_ms"`
}{version, occurred})
if err != nil {
return false, err
}
_, created, err := s.AppendActivityOutboxTx(tx, ActivityOutboxEvent{DomainUUID: domain, ActorUUID: actor, EventType: "organizer." + kind + ".changed", TargetKind: kind, TargetUUID: id, Payload: string(payload), IdempotencyKey: "organizer:" + kind + ":" + id + ":" + strconv.FormatInt(version, 10)})
return created, err
}
// PublishTaskActivity migrates the existing compact journal in bounded,
// restartable batches. New mutations already append directly and atomically;
// their idempotency key also makes this repair path safe to replay.
func (s *Store) PublishTaskActivity(ctx context.Context, limit int) (int, int, error) {
if limit < 1 || limit > 100 {
limit = 100
}
ctx, cancel := context.WithTimeout(ctx, 3*time.Second)
defer cancel()
tx, err := s.DB.BeginTx(ctx, nil)
if err != nil {
return 0, 0, err
}
defer tx.Rollback()
if _, err = tx.ExecContext(ctx, `UPDATE organizer_activity_bridge SET last_sequence=last_sequence WHERE id=1`); err != nil {
return 0, 0, err
}
rows, err := tx.QueryContext(ctx, `SELECT c.sequence,c.domain_uuid,c.item_uuid,c.version,c.actor_uuid,c.created_at_ms,COALESCE(i.kind,CASE WHEN d.item_uuid IS NOT NULL THEN 'task' ELSE '' END) FROM organizer_changes c LEFT JOIN organizer_items i ON i.domain_uuid=c.domain_uuid AND i.uuid=c.item_uuid LEFT JOIN organizer_task_deletions d ON d.domain_uuid=c.domain_uuid AND d.item_uuid=c.item_uuid WHERE c.sequence>(SELECT last_sequence FROM organizer_activity_bridge WHERE id=1) ORDER BY c.sequence LIMIT ?`, limit)
if err != nil {
return 0, 0, err
}
type change struct {
sequence, version, occurred int64
domain, id, actor, kind string
}
changes := []change{}
for rows.Next() {
var c change
if err = rows.Scan(&c.sequence, &c.domain, &c.id, &c.version, &c.actor, &c.occurred, &c.kind); err != nil {
rows.Close()
return 0, 0, err
}
changes = append(changes, c)
}
err = rows.Err()
rows.Close()
if err != nil {
return 0, 0, err
}
published := 0
for _, c := range changes {
created, e := s.appendTaskActivityTx(tx, c.domain, c.actor, c.id, c.kind, c.version, c.occurred)
if e != nil {
return 0, 0, e
}
if created {
published++
}
}
if len(changes) > 0 {
if _, err = tx.ExecContext(ctx, `UPDATE organizer_activity_bridge SET last_sequence=? WHERE id=1`, changes[len(changes)-1].sequence); err != nil {
return 0, 0, err
}
}
if err = tx.Commit(); err != nil {
return 0, 0, err
}
return len(changes), published, nil
}
func (s *Store) EnsureTaskActivityBridgeEvent() error {
now := time.Now().UnixMilli()
_, err := s.DB.Exec(`INSERT OR IGNORE INTO event_definitions(uuid,name,event_type,event_key,payload,schedule_kind,interval_seconds,next_run_at_ms,enabled,priority,max_attempts,created_at_ms,updated_at_ms) VALUES(?,?,?,?,?,'interval',60,?,1,-5,3,?,?)`, "builtin.task.activity.publish", "Task activity journal bridge", TaskActivityBridgeEventType, "local", "{}", now, now, now)
return err
}