From cea754872ce5eee9310ac01eac9ef7f688ca0875 Mon Sep 17 00:00:00 2001 From: Sam Catlow Date: Thu, 24 Sep 2026 02:17:31 +1000 Subject: [PATCH] feat(postgres): port EDA store to Postgres (captures, mappings, bindings, ledgers, tool_calls) L2 of the PocketBase->Postgres migration (bead archie-core-7r0x.3): a new Postgres-backed EDA adapter (postgres.EDA) plus its goose migration (0002_edastore.sql) and sqlc queries (queries/edastore.sql), satisfying the same storecontract surfaces as internal/infrastructure/edastore.Store so the cutover wave can swap them behind the contract. The PocketBase opener in internal/app/archied/state_store.go is untouched: production still opens SQLite, and the cutover waits for the one-time import. Three recon-found hazards, each pinned by a test, not a comment: 1. Empty-secret early return. applyBinding deliberately never writes the secret column when the incoming secret is empty, so an edit form that does not echo the secret must not blank an armed binding's HMAC key. The UpdateBinding query keeps the stored secret via `secret = CASE WHEN $secret = '' THEN secret ELSE $secret END`; pinned by TestUpdateBindingEmptySecretPreservesStored (raw column unchanged across an empty-secret edit). 2. Unique-violation detection by SQLSTATE. isUniqueViolation previously grepped the driver's error text for "unique"/"already exists"; Postgres reports SQLSTATE 23505 and the text match would not fire, losing ErrAlreadyDispatched. The adapter detects by pgconn.PgError.Code == "23505"; pinned by TestIsUniqueViolationDetectsBySQLState (23505 with a message lacking those words is detected; a non-23505 whose text says "unique" is not). 3. One-binding-per-source / one-armed-binding-per-source were read-then-refuse with no transaction and a non-unique idx_bindings_source_status. Made them constraints: UNIQUE(source) plus a partial UNIQUE(source) WHERE status='armed' (the full unique subsumes the armed rule today, kept explicit for a future matcher extension). A concurrent insert for one source yields exactly one success and one ErrBindingOverlap; pinned by TestConcurrentInsertBindingSameSource. Dispatch ledgers kept exactly: UNIQUE(binding, capture) and UNIQUE(playbook_id, playbook_version, event_id, action_id); binding_version is stored but deliberately not part of the key (pinned by TestBindingDispatchVersionBumpDoesNotPermitRedispatch). The cipher is unchanged: AES-256-GCM, key = SHA-256(material), decrypt stays in the store and the gRPC wire still carries plaintext. Notify is left as an injected callback (EDA.SetNotify) and is NOT wired to LISTEN/NOTIFY. It is dead code today: edastore.Config.Notify is omitted at its only production construction and no consumer maps binding_changed/ mapping_changed, so building a LISTEN/NOTIFY path would be building for a consumer that does not exist. Wired or not is a separate decision. --- internal/infrastructure/postgres/edastore.go | 577 ++++++++++++++++++ .../infrastructure/postgres/edastore_test.go | 336 ++++++++++ .../postgres/migrations/0002_edastore.sql | 114 ++++ .../postgres/postgresdb/edastore.sql.go | 576 +++++++++++++++++ .../postgres/postgresdb/models.go | 63 ++ .../postgres/queries/edastore.sql | 99 +++ 6 files changed, 1765 insertions(+) create mode 100644 internal/infrastructure/postgres/edastore.go create mode 100644 internal/infrastructure/postgres/edastore_test.go create mode 100644 internal/infrastructure/postgres/migrations/0002_edastore.sql create mode 100644 internal/infrastructure/postgres/postgresdb/edastore.sql.go create mode 100644 internal/infrastructure/postgres/queries/edastore.sql diff --git a/internal/infrastructure/postgres/edastore.go b/internal/infrastructure/postgres/edastore.go new file mode 100644 index 000000000..e6f5358a6 --- /dev/null +++ b/internal/infrastructure/postgres/edastore.go @@ -0,0 +1,577 @@ +// Package postgres opens archie's PostgreSQL database and applies its schema +// migrations. This file is the PostgreSQL implementation of the EDA +// persistence contracts (captures, mappings, bindings and the two dispatch +// ledgers) plus the tool_calls transcript, mirroring the PocketBase-backed +// internal/infrastructure/edastore.Store it will replace in the cutover wave. +package postgres + +import ( + "context" + "encoding/json" + "errors" + "fmt" + "time" + + "github.com/google/uuid" + "github.com/jackc/pgx/v5" + "github.com/jackc/pgx/v5/pgconn" + "github.com/jackc/pgx/v5/pgxpool" + + "github.com/samcharles93/archie-core/internal/domain/binding" + "github.com/samcharles93/archie-core/internal/domain/mapping" + "github.com/samcharles93/archie-core/internal/domain/storecontract" + "github.com/samcharles93/archie-core/internal/events" + "github.com/samcharles93/archie-core/internal/infrastructure/edastore" + "github.com/samcharles93/archie-core/internal/infrastructure/postgres/postgresdb" +) + +// EDA is the PostgreSQL implementation of every event-capture contract, plus +// the tool_calls transcript the composition projection writes through. It +// satisfies the same surface as *edastore.Store, so the cutover wave can swap +// one for the other behind storecontract without touching the consumers. +var ( + _ storecontract.CaptureStore = (*EDA)(nil) + _ storecontract.MappingStore = (*EDA)(nil) + _ storecontract.BindingStore = (*EDA)(nil) + _ storecontract.BindingDispatcher = (*EDA)(nil) + _ storecontract.PlaybookDispatcher = (*EDA)(nil) +) + +// EDA is the PostgreSQL-backed EDA persistence. +type EDA struct { + pool *pgxpool.Pool + q *postgresdb.Queries + cipher edastore.BindingCipher + notify func(events.Event) +} + +// NewEDA builds an EDA store over pool. A nil cipher keeps binding secrets in +// plaintext (the behaviour that predates the option); the caller resolves the +// keyring through edastore.NewBindingCipher, exactly as the PocketBase store +// does. The pool is owned by the caller, not this store. +func NewEDA(pool *pgxpool.Pool, cipher edastore.BindingCipher) *EDA { + return &EDA{pool: pool, q: postgresdb.New(pool), cipher: cipher} +} + +// SetNotify wires the change-event callback that the PocketBase store's +// Config.Notify provides. It is the same injection point: nil is a silent +// no-op, which is what every production construction gets today. +func (s *EDA) SetNotify(fn func(events.Event)) { s.notify = fn } + +// notifyWrite announces one successful write on the bindings or mappings +// tables. It mirrors edastore.(*Store).notifyWrite byte-for-byte: the data +// carries the record id and action, and consumers refetch the row themselves. +func (s *EDA) notifyWrite(kind, subject, action, id string) { + if s.notify == nil { + return + } + past := map[string]string{"create": "created", "update": "updated", "approve": "approved", "delete": "deleted"}[action] + s.notify(events.Event{ + Kind: kind, + Detail: subject + " " + past, + Data: map[string]any{"id": id, "action": action}, + }) +} + +func newRecordID() string { return uuid.NewString() } + +// --- captures --- + +// InsertCapture stores one inbound event verbatim. retention and maxEvents are +// accepted for contract compatibility and applied as a prune after the insert, +// exactly as the PocketBase store does. +func (s *EDA) InsertCapture(ctx context.Context, c storecontract.CapturedEvent, retention time.Duration, maxEvents int) (string, error) { + received := c.ReceivedAt + if received.IsZero() { + received = time.Now() + } + id := newRecordID() + if err := s.q.InsertCapture(ctx, postgresdb.InsertCaptureParams{ + ID: id, + Source: c.Source, + RemoteAddr: c.RemoteAddr, + ContentType: c.ContentType, + Headers: c.Headers, + Body: c.Body, + Authenticated: c.Authenticated, + ReceivedAt: received.UTC(), + }); err != nil { + return "", fmt.Errorf("edastore: insert capture: %w", err) + } + if err := s.pruneCaptures(ctx, retention, maxEvents); err != nil { + return "", err + } + return id, nil +} + +func (s *EDA) pruneCaptures(ctx context.Context, retention time.Duration, maxEvents int) error { + if retention > 0 { + if err := s.q.DeleteCapturesOlderThan(ctx, time.Now().Add(-retention).UTC()); err != nil { + return fmt.Errorf("edastore: prune captures by age: %w", err) + } + } + if maxEvents > 0 { + if err := s.q.DeleteCapturesBeyondCount(ctx, int32(maxEvents)); err != nil { + return fmt.Errorf("edastore: prune captures by count: %w", err) + } + } + return nil +} + +func captureValue(r postgresdb.Capture) storecontract.CapturedEvent { + return storecontract.CapturedEvent{ + ID: r.ID, + ReceivedAt: r.ReceivedAt, + Source: r.Source, + RemoteAddr: r.RemoteAddr, + ContentType: r.ContentType, + Headers: r.Headers, + Body: r.Body, + Authenticated: r.Authenticated, + } +} + +// ListCaptures returns the newest captures first. +func (s *EDA) ListCaptures(ctx context.Context, limit int) ([]storecontract.CapturedEvent, error) { + rows, err := s.q.ListCaptures(ctx, int32(limit)) + if err != nil { + return nil, fmt.Errorf("edastore: list captures: %w", err) + } + out := make([]storecontract.CapturedEvent, 0, len(rows)) + for _, r := range rows { + out = append(out, captureValue(r)) + } + return out, nil +} + +// ListUndispatchedCaptures returns recent captures for the given sources that +// no binding has dispatched yet. +func (s *EDA) ListUndispatchedCaptures(ctx context.Context, sources []string, limit int) ([]storecontract.CapturedEvent, error) { + if len(sources) == 0 || limit <= 0 { + return nil, nil + } + rows, err := s.q.ListUndispatchedCaptures(ctx, postgresdb.ListUndispatchedCapturesParams{ + Sources: sources, + EntryLimit: int32(limit), + }) + if err != nil { + return nil, fmt.Errorf("edastore: list undispatched captures: %w", err) + } + out := make([]storecontract.CapturedEvent, 0, len(rows)) + for _, r := range rows { + out = append(out, captureValue(r)) + } + return out, nil +} + +// --- mappings --- + +func marshalMappingFields(fields []mapping.Field) (string, error) { + encoded, err := json.Marshal(fields) + if err != nil { + return "", fmt.Errorf("edastore: encode mapping fields: %w", err) + } + return string(encoded), nil +} + +func mappingValue(r postgresdb.Mapping) (mapping.Mapping, error) { + var fields []mapping.Field + if raw := r.Fields; raw != "" { + if err := json.Unmarshal([]byte(raw), &fields); err != nil { + return mapping.Mapping{}, fmt.Errorf("edastore: decode mapping fields: %w", err) + } + } + return mapping.Mapping{ + ID: r.ID, + Name: r.Name, + SourceHint: r.SourceHint, + Fields: fields, + CreatedAt: r.CreatedAt, + UpdatedAt: r.UpdatedAt, + }, nil +} + +func (s *EDA) InsertMapping(ctx context.Context, m mapping.Mapping) (string, error) { + encoded, err := marshalMappingFields(m.Fields) + if err != nil { + return "", err + } + id := newRecordID() + if err := s.q.InsertMapping(ctx, postgresdb.InsertMappingParams{ + ID: id, + Name: m.Name, + SourceHint: m.SourceHint, + Fields: encoded, + }); err != nil { + return "", fmt.Errorf("edastore: insert mapping: %w", err) + } + s.notifyWrite(events.KindMappingChanged, "mapping", "create", id) + return id, nil +} + +// GetMapping returns (nil, nil) for an absent mapping, matching the +// PocketBase store's found=false convention the gRPC layer translates. +func (s *EDA) GetMapping(ctx context.Context, id string) (*mapping.Mapping, error) { + r, err := s.q.GetMapping(ctx, id) + if errors.Is(err, pgx.ErrNoRows) { + return nil, nil + } + if err != nil { + return nil, err + } + m, err := mappingValue(r) + if err != nil { + return nil, err + } + return &m, nil +} + +func (s *EDA) ListMappings(ctx context.Context) ([]mapping.Mapping, error) { + rows, err := s.q.ListMappings(ctx) + if err != nil { + return nil, fmt.Errorf("edastore: list mappings: %w", err) + } + out := make([]mapping.Mapping, 0, len(rows)) + for _, r := range rows { + m, err := mappingValue(r) + if err != nil { + return nil, err + } + out = append(out, m) + } + return out, nil +} + +func (s *EDA) UpdateMapping(ctx context.Context, m mapping.Mapping) error { + encoded, err := marshalMappingFields(m.Fields) + if err != nil { + return err + } + n, err := s.q.UpdateMapping(ctx, postgresdb.UpdateMappingParams{ + ID: m.ID, + Name: m.Name, + SourceHint: m.SourceHint, + Fields: encoded, + }) + if err != nil { + return err + } + if n == 0 { + return storecontract.ErrMappingNotFound + } + s.notifyWrite(events.KindMappingChanged, "mapping", "update", m.ID) + return nil +} + +func (s *EDA) DeleteMapping(ctx context.Context, id string) error { + n, err := s.q.DeleteMapping(ctx, id) + if err != nil { + return err + } + if n == 0 { + return storecontract.ErrMappingNotFound + } + s.notifyWrite(events.KindMappingChanged, "mapping", "delete", id) + return nil +} + +// --- bindings --- + +func (s *EDA) encryptSecret(secret string) (string, error) { + if s.cipher == nil { + return secret, nil + } + encrypted, err := s.cipher.Encrypt(secret) + if err != nil { + return "", fmt.Errorf("edastore: encrypt binding secret: %w", err) + } + return encrypted, nil +} + +func (s *EDA) bindingValue(r postgresdb.Binding) (binding.Binding, error) { + b := binding.Binding{ + ID: r.ID, + Name: r.Name, + Matcher: binding.Matcher{Source: r.Source}, + MappingID: r.Mapping, + Workflow: r.Workflow, + Owner: r.Owner, + Repo: r.Repo, + Version: int(r.Version), + Status: binding.Status(r.Status), + Secret: r.Secret, + CreatedAt: r.CreatedAt, + UpdatedAt: r.UpdatedAt, + } + if s.cipher != nil && b.Secret != "" { + plain, err := s.cipher.Decrypt(b.Secret) + if err != nil { + return binding.Binding{}, fmt.Errorf("edastore: decrypt binding secret: %w", err) + } + b.Secret = plain + } + return b, nil +} + +// InsertBinding stores a new binding as pending_approval. "One binding per +// source" is a schema constraint (idx_bindings_source), so a concurrent +// second insert for the same source is refused by the database and surfaced +// here as ErrBindingOverlap. +func (s *EDA) InsertBinding(ctx context.Context, b binding.Binding) (string, error) { + secret := b.Secret + if secret != "" { + var err error + secret, err = s.encryptSecret(secret) + if err != nil { + return "", err + } + } + id := newRecordID() + err := s.q.InsertBinding(ctx, postgresdb.InsertBindingParams{ + ID: id, + Name: b.Name, + Source: b.Matcher.Source, + Mapping: b.MappingID, + Workflow: b.Workflow, + Owner: b.Owner, + Repo: b.Repo, + Status: string(binding.StatusPendingApproval), + Secret: secret, + }) + if isUniqueViolation(err) { + return "", storecontract.ErrBindingOverlap + } + if err != nil { + return "", fmt.Errorf("edastore: insert binding: %w", err) + } + s.notifyWrite(events.KindBindingChanged, "binding", "create", id) + return id, nil +} + +// GetBinding returns (nil, nil) for an absent binding, matching the +// PocketBase store's found=false convention the gRPC layer translates. +func (s *EDA) GetBinding(ctx context.Context, id string) (*binding.Binding, error) { + r, err := s.q.GetBinding(ctx, id) + if errors.Is(err, pgx.ErrNoRows) { + return nil, nil + } + if err != nil { + return nil, err + } + b, err := s.bindingValue(r) + if err != nil { + return nil, err + } + return &b, nil +} + +func (s *EDA) ListBindings(ctx context.Context) ([]binding.Binding, error) { + rows, err := s.q.ListBindings(ctx) + if err != nil { + return nil, fmt.Errorf("edastore: list bindings: %w", err) + } + out := make([]binding.Binding, 0, len(rows)) + for _, r := range rows { + b, err := s.bindingValue(r) + if err != nil { + return nil, err + } + out = append(out, b) + } + return out, nil +} + +// ArmedBindingsForSource returns the armed bindings a source can dispatch. +func (s *EDA) ArmedBindingsForSource(ctx context.Context, source string) ([]binding.Binding, error) { + rows, err := s.q.ArmedBindingsForSource(ctx, source) + if err != nil { + return nil, fmt.Errorf("edastore: list armed bindings: %w", err) + } + out := make([]binding.Binding, 0, len(rows)) + for _, r := range rows { + b, err := s.bindingValue(r) + if err != nil { + return nil, err + } + out = append(out, b) + } + return out, nil +} + +// UpdateBinding rewrites a binding's editable fields, bumps its version and +// drops it back to pending_approval. An empty secret means "keep the stored +// one" (the CASE in the query), so an edit form that does not echo the secret +// cannot blank an armed binding's HMAC key. +func (s *EDA) UpdateBinding(ctx context.Context, b binding.Binding) error { + secret := b.Secret + if secret != "" { + var err error + secret, err = s.encryptSecret(secret) + if err != nil { + return err + } + } + n, err := s.q.UpdateBinding(ctx, postgresdb.UpdateBindingParams{ + ID: b.ID, + Name: b.Name, + Source: b.Matcher.Source, + Mapping: b.MappingID, + Workflow: b.Workflow, + Owner: b.Owner, + Repo: b.Repo, + Status: string(binding.StatusPendingApproval), + Secret: secret, + }) + if isUniqueViolation(err) { + return storecontract.ErrBindingOverlap + } + if err != nil { + return err + } + if n == 0 { + return storecontract.ErrBindingNotFound + } + s.notifyWrite(events.KindBindingChanged, "binding", "update", b.ID) + return nil +} + +func (s *EDA) DeleteBinding(ctx context.Context, id string) error { + n, err := s.q.DeleteBinding(ctx, id) + if err != nil { + return err + } + if n == 0 { + return storecontract.ErrBindingNotFound + } + s.notifyWrite(events.KindBindingChanged, "binding", "delete", id) + return nil +} + +// ApproveBinding is the only transition that arms a binding. "One armed +// binding per source" is a partial unique constraint (idx_bindings_armed_source), +// so a concurrent approval of a sibling binding on the same source is refused +// by the database and surfaced here as ErrBindingOverlap. +func (s *EDA) ApproveBinding(ctx context.Context, id string) error { + r, err := s.q.GetBinding(ctx, id) + if errors.Is(err, pgx.ErrNoRows) { + return storecontract.ErrBindingNotFound + } + if err != nil { + return err + } + if r.Status != string(binding.StatusPendingApproval) { + return storecontract.ErrBindingTransition + } + n, err := s.q.SetBindingArmed(ctx, id) + if isUniqueViolation(err) { + return storecontract.ErrBindingOverlap + } + if err != nil { + return err + } + if n == 0 { + return storecontract.ErrBindingNotFound + } + s.notifyWrite(events.KindBindingChanged, "binding", "approve", id) + return nil +} + +// --- dispatch ledgers --- + +// RecordDispatch writes one at-most-once binding dispatch. binding_version is +// stored but is not part of the unique key, so a version bump does not permit +// re-dispatching the same (binding, capture). +func (s *EDA) RecordDispatch(ctx context.Context, bindingID string, bindingVersion int64, captureID string, taskID int64) error { + err := s.q.InsertBindingDispatch(ctx, postgresdb.InsertBindingDispatchParams{ + Binding: bindingID, + BindingVersion: bindingVersion, + Capture: captureID, + TaskID: taskID, + }) + return ledgerWrite(err, "edastore: record dispatch") +} + +func (s *EDA) RecordPlaybookDispatch(ctx context.Context, playbookID, playbookVersion, eventID, actionID string) error { + err := s.q.InsertPlaybookDispatch(ctx, postgresdb.InsertPlaybookDispatchParams{ + PlaybookID: playbookID, + PlaybookVersion: playbookVersion, + EventID: eventID, + ActionID: actionID, + }) + return ledgerWrite(err, "edastore: record playbook dispatch") +} + +func (s *EDA) DeletePlaybookDispatches(ctx context.Context, playbookID string) error { + if err := s.q.DeletePlaybookDispatches(ctx, playbookID); err != nil { + return fmt.Errorf("edastore: delete playbook dispatches: %w", err) + } + return nil +} + +// ledgerWrite turns the unique-index refusal into ErrAlreadyDispatched and +// leaves every other failure alone. +func ledgerWrite(err error, what string) error { + switch { + case err == nil: + return nil + case isUniqueViolation(err): + return storecontract.ErrAlreadyDispatched + default: + return fmt.Errorf("%s: %w", what, err) + } +} + +// isUniqueViolation reports whether err is a PostgreSQL unique-index refusal, +// detected by SQLSTATE 23505 rather than by matching the driver's error text. +// A Postgres error whose message happens to say "unique" but whose SQLSTATE is +// something else must not be treated as one. +func isUniqueViolation(err error) bool { + var pgErr *pgconn.PgError + if !errors.As(err, &pgErr) { + return false + } + return pgErr.Code == "23505" +} + +// --- tool calls --- + +// InsertToolCall appends one row to the tool_calls transcript. +func (s *EDA) InsertToolCall(ctx context.Context, tc edastore.ToolCall) error { + calledAt := tc.CalledAt + if calledAt.IsZero() { + calledAt = time.Now() + } + if err := s.q.InsertToolCall(ctx, postgresdb.InsertToolCallParams{ + ID: newRecordID(), + TaskID: tc.TaskID, + Attempt: int64(tc.Attempt), + Tool: tc.Tool, + Result: tc.Result, + Error: tc.Error, + CalledAt: calledAt, + }); err != nil { + return fmt.Errorf("edastore: insert tool call: %w", err) + } + return nil +} + +// TaskToolCalls returns one task's tool calls in call order. +func (s *EDA) TaskToolCalls(ctx context.Context, taskID int64) ([]edastore.ToolCall, error) { + rows, err := s.q.TaskToolCalls(ctx, taskID) + if err != nil { + return nil, fmt.Errorf("edastore: list tool calls: %w", err) + } + out := make([]edastore.ToolCall, 0, len(rows)) + for _, r := range rows { + out = append(out, edastore.ToolCall{ + ID: r.ID, + TaskID: r.TaskID, + Attempt: int(r.Attempt), + Tool: r.Tool, + Result: r.Result, + Error: r.Error, + CalledAt: r.CalledAt, + }) + } + return out, nil +} diff --git a/internal/infrastructure/postgres/edastore_test.go b/internal/infrastructure/postgres/edastore_test.go new file mode 100644 index 000000000..71a934b14 --- /dev/null +++ b/internal/infrastructure/postgres/edastore_test.go @@ -0,0 +1,336 @@ +package postgres + +import ( + "errors" + "testing" + "time" + + "github.com/jackc/pgx/v5/pgconn" + "github.com/jackc/pgx/v5/pgxpool" + + "github.com/samcharles93/archie-core/internal/domain/binding" + "github.com/samcharles93/archie-core/internal/domain/mapping" + "github.com/samcharles93/archie-core/internal/domain/storecontract" + "github.com/samcharles93/archie-core/internal/events" + "github.com/samcharles93/archie-core/internal/infrastructure/edastore" +) + +const edaTestKey = "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef" + +// edaFor builds an EDA store over a migrated database, with no cipher. +func edaFor(t *testing.T) *EDA { + t.Helper() + pool, _ := migrated(t) + return NewEDA(pool, nil) +} + +func edaWithCipher(t *testing.T, cipher edastore.BindingCipher) (*pgxpool.Pool, *EDA) { + t.Helper() + pool, _ := migrated(t) + return pool, NewEDA(pool, cipher) +} + +func insertBinding(t *testing.T, s *EDA, source string) string { + t.Helper() + id, err := s.InsertBinding(t.Context(), binding.Binding{ + Name: "n", Matcher: binding.Matcher{Source: source}, Workflow: "implement", + }) + if err != nil { + t.Fatalf("InsertBinding() error = %v", err) + } + return id +} + +// Hazard 2: unique-violation detection must be by SQLSTATE, not by grepping +// the driver's error text. A Postgres error whose message happens to contain +// "unique" but whose SQLSTATE is not 23505 must not be treated as one, and a +// 23505 with a message lacking those words must be detected. +func TestIsUniqueViolationDetectsBySQLState(t *testing.T) { + if !isUniqueViolation(&pgconn.PgError{Code: "23505", Message: "duplicate key value"}) { + t.Error("SQLSTATE 23505 was not detected as a unique violation") + } + if isUniqueViolation(&pgconn.PgError{Code: "23502", Message: "null value in column of a unique constraint"}) { + t.Error("a non-23505 error whose text says unique was treated as a unique violation; SQLSTATE is authoritative") + } + if isUniqueViolation(errors.New("not a database error")) { + t.Error("a non-Postgres error was treated as a unique violation") + } +} + +// Hazard 2 (integration): the dispatch ledger is at-most-once, refused by the +// schema and surfaced as ErrAlreadyDispatched. +func TestRecordDispatchIsIdempotent(t *testing.T) { + s := edaFor(t) + if err := s.RecordDispatch(t.Context(), "b1", 1, "c1", 42); err != nil { + t.Fatalf("first RecordDispatch() error = %v", err) + } + if err := s.RecordDispatch(t.Context(), "b1", 1, "c1", 99); !errors.Is(err, storecontract.ErrAlreadyDispatched) { + t.Errorf("second RecordDispatch() error = %v, want ErrAlreadyDispatched", err) + } +} + +// binding_version is stored but deliberately not part of the unique key: a +// version bump does not permit re-dispatching the same (binding, capture). +func TestBindingDispatchVersionBumpDoesNotPermitRedispatch(t *testing.T) { + s := edaFor(t) + if err := s.RecordDispatch(t.Context(), "b1", 1, "c1", 42); err != nil { + t.Fatalf("first RecordDispatch() error = %v", err) + } + if err := s.RecordDispatch(t.Context(), "b1", 2, "c1", 99); !errors.Is(err, storecontract.ErrAlreadyDispatched) { + t.Errorf("redispatch with a version bump = %v, want ErrAlreadyDispatched: binding_version is not part of the key", err) + } +} + +func TestPlaybookDispatchIsIdempotent(t *testing.T) { + s := edaFor(t) + if err := s.RecordPlaybookDispatch(t.Context(), "p1", "v1", "e1", "a1"); err != nil { + t.Fatalf("first RecordPlaybookDispatch() error = %v", err) + } + if err := s.RecordPlaybookDispatch(t.Context(), "p1", "v1", "e1", "a1"); !errors.Is(err, storecontract.ErrAlreadyDispatched) { + t.Errorf("second RecordPlaybookDispatch() error = %v, want ErrAlreadyDispatched", err) + } +} + +// Hazard 3: "one binding per source" is a schema constraint, so concurrent +// inserts for one source produce exactly one success and one ErrBindingOverlap +// rather than two bindings that a single SQLite writer would have serialised. +func TestConcurrentInsertBindingSameSource(t *testing.T) { + s := edaFor(t) + type result struct{ err error } + start := make(chan struct{}) + results := make(chan result, 2) + for range 2 { + go func() { + <-start + _, err := s.InsertBinding(t.Context(), binding.Binding{ + Name: "n", Matcher: binding.Matcher{Source: "sentry"}, Workflow: "implement", + }) + results <- result{err: err} + }() + } + close(start) + + var succeeded, overlapped int + for range 2 { + outcome := <-results + switch { + case outcome.err == nil: + succeeded++ + case errors.Is(outcome.err, storecontract.ErrBindingOverlap): + overlapped++ + default: + t.Fatalf("concurrent InsertBinding error = %v", outcome.err) + } + } + if succeeded != 1 || overlapped != 1 { + t.Fatalf("concurrent inserts = %d succeeded, %d overlapped; want 1 each", succeeded, overlapped) + } +} + +// Hazard 1: UpdateBinding with an empty secret must leave the stored envelope +// untouched, so an edit form that does not echo the secret cannot blank an +// armed binding's HMAC key. +func TestUpdateBindingEmptySecretPreservesStored(t *testing.T) { + cipher, err := edastore.NewBindingCipher(edaTestKey, nil) + if err != nil { + t.Fatalf("NewBindingCipher() error = %v", err) + } + pool, s := edaWithCipher(t, cipher) + + secretID, err := s.InsertBinding(t.Context(), binding.Binding{ + Name: "n", Matcher: binding.Matcher{Source: "src-secret"}, Workflow: "implement", + Secret: "supersecretvalue0123", + }) + if err != nil { + t.Fatalf("InsertBinding() error = %v", err) + } + before := readRawSecret(t, pool, secretID) + + // Edit with an empty secret: the stored envelope must not change. + if err := s.UpdateBinding(t.Context(), binding.Binding{ + ID: secretID, Name: "renamed", Matcher: binding.Matcher{Source: "src-secret"}, Workflow: "escalate", + }); err != nil { + t.Fatalf("UpdateBinding() error = %v", err) + } + after := readRawSecret(t, pool, secretID) + if after != before { + t.Fatalf("stored secret changed on empty-secret edit: %q -> %q", before, after) + } + if after == "" { + t.Fatal("stored secret is empty after an empty-secret edit; the binding was silently disarmed") + } +} + +func readRawSecret(t *testing.T, pool *pgxpool.Pool, id string) string { + t.Helper() + var stored string + if err := pool.QueryRow(t.Context(), "SELECT secret FROM bindings WHERE id = $1", id).Scan(&stored); err != nil { + t.Fatalf("read raw secret: %v", err) + } + return stored +} + +// The cipher path must keep decrypt-in-store: what is stored is an envelope, +// what reads back is the plaintext HMAC key the intake verifies with. +func TestBindingSecretEncryptedAtRestAndDecryptedOnRead(t *testing.T) { + cipher, err := edastore.NewBindingCipher(edaTestKey, nil) + if err != nil { + t.Fatalf("NewBindingCipher() error = %v", err) + } + pool, s := edaWithCipher(t, cipher) + + id, err := s.InsertBinding(t.Context(), binding.Binding{ + Name: "n", Matcher: binding.Matcher{Source: "src-cipher"}, Workflow: "implement", + Secret: "supersecretvalue0123", + }) + if err != nil { + t.Fatalf("InsertBinding() error = %v", err) + } + stored := readRawSecret(t, pool, id) + if stored == "supersecretvalue0123" { + t.Fatal("secret is stored plaintext; it must be encrypted at rest") + } + + got, err := s.GetBinding(t.Context(), id) + if err != nil { + t.Fatalf("GetBinding() error = %v", err) + } + if got.Secret != "supersecretvalue0123" { + t.Errorf("Secret = %q, want the plaintext on read: the wire carries plaintext, so decrypt must happen in the store", got.Secret) + } +} + +// The lifecycle gate survives the port: pending_approval -> armed, and only +// from pending_approval. +func TestBindingLifecycle(t *testing.T) { + s := edaFor(t) + id := insertBinding(t, s, "src-lifecycle") + + if err := s.ApproveBinding(t.Context(), id); err != nil { + t.Fatalf("ApproveBinding(pending_approval) error = %v", err) + } + if err := s.ApproveBinding(t.Context(), id); !errors.Is(err, storecontract.ErrBindingTransition) { + t.Errorf("re-approving an armed binding = %v, want ErrBindingTransition", err) + } + armed, err := s.ArmedBindingsForSource(t.Context(), "src-lifecycle") + if err != nil || len(armed) != 1 { + t.Fatalf("ArmedBindingsForSource() = %d bindings (err %v), want 1", len(armed), err) + } +} + +// A capture round-trips its payload verbatim, and a dispatched capture drops +// out of the undispatched listing. +func TestCaptureRoundTripAndUndispatched(t *testing.T) { + s := edaFor(t) + body := `{"action":"created"}` + if _, err := s.InsertCapture(t.Context(), storecontract.CapturedEvent{ + Source: "sentry", Body: body, Headers: `{"X-Hook":"1"}`, ContentType: "application/json", + }, 0, 0); err != nil { + t.Fatalf("InsertCapture() error = %v", err) + } + list, err := s.ListCaptures(t.Context(), 10) + if err != nil || len(list) != 1 { + t.Fatalf("ListCaptures() = %d (err %v), want 1", len(list), err) + } + if list[0].Body != body { + t.Errorf("Body round-trip = %q, want %q", list[0].Body, body) + } + + undispatched, err := s.ListUndispatchedCaptures(t.Context(), []string{"sentry"}, 10) + if err != nil || len(undispatched) != 1 { + t.Fatalf("ListUndispatchedCaptures() = %d (err %v), want 1", len(undispatched), err) + } + // Dispatch it; the capture must no longer be undispatched. + if err := s.RecordDispatch(t.Context(), "b1", 1, list[0].ID, 42); err != nil { + t.Fatalf("RecordDispatch() error = %v", err) + } + undispatched, err = s.ListUndispatchedCaptures(t.Context(), []string{"sentry"}, 10) + if err != nil || len(undispatched) != 0 { + t.Fatalf("ListUndispatchedCaptures() after dispatch = %d (err %v), want 0", len(undispatched), err) + } +} + +func TestMappingCRUD(t *testing.T) { + s := edaFor(t) + id, err := s.InsertMapping(t.Context(), mapping.Mapping{Name: "payload-map"}) + if err != nil { + t.Fatalf("InsertMapping() error = %v", err) + } + got, err := s.GetMapping(t.Context(), id) + if err != nil || got == nil { + t.Fatalf("GetMapping() = %v (err %v), want the mapping", got, err) + } + if got.Name != "payload-map" { + t.Errorf("Name = %q, want payload-map", got.Name) + } + got.Name = "renamed" + if err := s.UpdateMapping(t.Context(), *got); err != nil { + t.Fatalf("UpdateMapping() error = %v", err) + } + if err := s.DeleteMapping(t.Context(), id); err != nil { + t.Fatalf("DeleteMapping() error = %v", err) + } + if err := s.DeleteMapping(t.Context(), id); !errors.Is(err, storecontract.ErrMappingNotFound) { + t.Errorf("DeleteMapping(absent) = %v, want ErrMappingNotFound", err) + } +} + +// The Notify callback is an injected seam, not a LISTEN/NOTIFY path: a store +// wired with one fires a change event per successful bindings/mappings write, +// and one wired with none is a silent no-op. +func TestNotifyCallbackIsAnInjectedSeam(t *testing.T) { + s := edaFor(t) + var got []events.Event + s.SetNotify(func(e events.Event) { got = append(got, e) }) + + id, err := s.InsertMapping(t.Context(), mapping.Mapping{Name: "wired"}) + if err != nil { + t.Fatalf("InsertMapping() error = %v", err) + } + if len(got) != 1 { + t.Fatalf("notified %d times, want 1", len(got)) + } + if got[0].Data["id"] != id || got[0].Data["action"] != "create" { + t.Errorf("event data = %+v, want id=%q action=create", got[0].Data, id) + } + + // A store composed without a notifier is a silent no-op. + s.SetNotify(nil) + if _, err := s.InsertMapping(t.Context(), mapping.Mapping{Name: "silent"}); err != nil { + t.Fatalf("InsertMapping(nil notifier) error = %v", err) + } +} + +// tool_calls is an append-only transcript with no unique index: repeated rows +// are distinct entries, and one task's calls never surface in another's. +func TestToolCallRoundTrip(t *testing.T) { + s := edaFor(t) + at := time.Date(2026, 9, 23, 1, 2, 3, 0, time.UTC) + + for range 2 { + if err := s.InsertToolCall(t.Context(), edastore.ToolCall{ + TaskID: 42, Attempt: 2, Tool: "shell", Result: "all checks passed", CalledAt: at, + }); err != nil { + t.Fatalf("InsertToolCall() error = %v", err) + } + } + if err := s.InsertToolCall(t.Context(), edastore.ToolCall{ + TaskID: 7, Attempt: 1, Tool: "read_file", Error: "no such file", CalledAt: at.Add(time.Second), + }); err != nil { + t.Fatalf("InsertToolCall(other task) error = %v", err) + } + + got, err := s.TaskToolCalls(t.Context(), 42) + if err != nil { + t.Fatalf("TaskToolCalls() error = %v", err) + } + if len(got) != 2 { + t.Fatalf("TaskToolCalls() returned %d rows, want 2 (the transcript is append-only)", len(got)) + } + if got[0].Result != "all checks passed" || got[0].Error != "" { + t.Errorf("first row result/error = %q/%q, want the summary with no error", got[0].Result, got[0].Error) + } + if got[0].CalledAt.IsZero() { + t.Error("called_at did not round-trip") + } +} diff --git a/internal/infrastructure/postgres/migrations/0002_edastore.sql b/internal/infrastructure/postgres/migrations/0002_edastore.sql new file mode 100644 index 000000000..93603d4f9 --- /dev/null +++ b/internal/infrastructure/postgres/migrations/0002_edastore.sql @@ -0,0 +1,114 @@ +-- EDA schema: captures, mappings, bindings, the two dispatch ledgers and +-- tool_calls. This is the Postgres replacement for the PocketBase-owned +-- collections in internal/infrastructure/edastore. +-- +-- Translations from the PocketBase/SQLite schema this replaces, and why: +-- * Record ids stay text. PocketBase issued a random 15-character id and the +-- wire carries binding/capture/mapping ids as opaque strings; the adapter +-- mints a random id in Go, so nothing changes for consumers. +-- * Times become timestamptz, matching the State Store migration. The +-- SQLite store formatted captures.received_at as fixed-width text so +-- lexicographic order matched chronological order (PocketBase autodates +-- are only millisecond-precise); Postgres orders timestamptz natively, so +-- that normalisation does not exist here. This loses sub-microsecond +-- precision, which the State Store migration already accepted for event +-- timestamps. +-- * Every column behind a Go int is bigint. binding_version and task_id are +-- int64 on the wire; tool_calls.attempt and duration_ms are Go ints. +-- * bindings.mapping is a plain text column rather than a real foreign key: +-- the PocketBase Relation field was not enforced by SQLite (foreign_keys +-- is off; PocketBase resolves relations in app code), and the store +-- accepts an empty mapping id on insert. A real FK would reject those rows. +-- * bindings.secret stays text with no length bound: the cipher envelope is +-- base64url and must never be truncated or normalised, or Decrypt fails. + +-- +goose Up + +CREATE TABLE captures ( + id text PRIMARY KEY, + source text NOT NULL, + remote_addr text NOT NULL DEFAULT '', + content_type text NOT NULL DEFAULT '', + headers text NOT NULL DEFAULT '', + body text NOT NULL DEFAULT '', + authenticated boolean NOT NULL DEFAULT false, + received_at timestamptz NOT NULL +); +CREATE INDEX idx_captures_source ON captures (source, received_at); + +CREATE TABLE mappings ( + id text PRIMARY KEY, + name text NOT NULL, + source_hint text NOT NULL DEFAULT '', + fields text NOT NULL DEFAULT '', + created_at timestamptz NOT NULL DEFAULT now(), + updated_at timestamptz NOT NULL DEFAULT now() +); + +CREATE TABLE bindings ( + id text PRIMARY KEY, + name text NOT NULL, + source text NOT NULL, + mapping text NOT NULL DEFAULT '', + workflow text NOT NULL DEFAULT '', + owner text NOT NULL DEFAULT '', + repo text NOT NULL DEFAULT '', + version bigint NOT NULL DEFAULT 0, + status text NOT NULL DEFAULT 'pending_approval', + secret text NOT NULL DEFAULT '', + created_at timestamptz NOT NULL DEFAULT now(), + updated_at timestamptz NOT NULL DEFAULT now() +); +CREATE INDEX idx_bindings_source_status ON bindings (source, status); +-- "One binding per source" is now schema-enforced rather than read-then-refuse +-- in the store: a concurrent second insert for a source is refused by the +-- database (SQLSTATE 23505), which the store maps to ErrBindingOverlap. +CREATE UNIQUE INDEX idx_bindings_source ON bindings (source); +-- "One armed binding per source" is a distinct rule. The full unique above +-- already implies it, but the partial index keeps the invariant explicit and +-- durable if the per-source rule is ever relaxed to allow multiple matchers +-- while still forbidding two armed ones. +CREATE UNIQUE INDEX idx_bindings_armed_source ON bindings (source) WHERE status = 'armed'; + +CREATE TABLE binding_dispatches ( + binding text NOT NULL, + binding_version bigint NOT NULL DEFAULT 0, + capture text NOT NULL, + task_id bigint NOT NULL DEFAULT 0, + dispatched_at timestamptz NOT NULL DEFAULT now() +); +-- At-most-once: binding_version is stored but deliberately not part of the key, +-- so a version bump does not permit re-dispatching the same (binding, capture). +CREATE UNIQUE INDEX idx_binding_dispatch_once ON binding_dispatches (binding, capture); + +CREATE TABLE playbook_dispatches ( + playbook_id text NOT NULL, + playbook_version text NOT NULL, + event_id text NOT NULL, + action_id text NOT NULL, + dispatched_at timestamptz NOT NULL DEFAULT now() +); +CREATE UNIQUE INDEX idx_playbook_dispatch_once ON playbook_dispatches + (playbook_id, playbook_version, event_id, action_id); + +CREATE TABLE tool_calls ( + id text PRIMARY KEY, + task_id bigint NOT NULL DEFAULT 0, + attempt bigint NOT NULL DEFAULT 0, + tool text NOT NULL, + args text NOT NULL DEFAULT '', + result text NOT NULL DEFAULT '', + error text NOT NULL DEFAULT '', + duration_ms bigint NOT NULL DEFAULT 0, + called_at timestamptz NOT NULL DEFAULT now() +); +CREATE INDEX idx_tool_calls_task ON tool_calls (task_id, attempt); + +-- +goose Down + +DROP TABLE tool_calls; +DROP TABLE playbook_dispatches; +DROP TABLE binding_dispatches; +DROP TABLE bindings; +DROP TABLE mappings; +DROP TABLE captures; diff --git a/internal/infrastructure/postgres/postgresdb/edastore.sql.go b/internal/infrastructure/postgres/postgresdb/edastore.sql.go new file mode 100644 index 000000000..9a2df6114 --- /dev/null +++ b/internal/infrastructure/postgres/postgresdb/edastore.sql.go @@ -0,0 +1,576 @@ +// Code generated by sqlc. DO NOT EDIT. +// versions: +// sqlc v1.31.1 +// source: edastore.sql + +package postgresdb + +import ( + "context" + "time" +) + +const armedBindingsForSource = `-- name: ArmedBindingsForSource :many +SELECT id, name, source, mapping, workflow, owner, repo, version, status, secret, created_at, updated_at +FROM bindings WHERE source = $1 AND status = 'armed' ORDER BY created_at DESC +` + +func (q *Queries) ArmedBindingsForSource(ctx context.Context, source string) ([]Binding, error) { + rows, err := q.db.Query(ctx, armedBindingsForSource, source) + if err != nil { + return nil, err + } + defer rows.Close() + var items []Binding + for rows.Next() { + var i Binding + if err := rows.Scan( + &i.ID, + &i.Name, + &i.Source, + &i.Mapping, + &i.Workflow, + &i.Owner, + &i.Repo, + &i.Version, + &i.Status, + &i.Secret, + &i.CreatedAt, + &i.UpdatedAt, + ); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + +const deleteBinding = `-- name: DeleteBinding :execrows +DELETE FROM bindings WHERE id = $1 +` + +func (q *Queries) DeleteBinding(ctx context.Context, id string) (int64, error) { + result, err := q.db.Exec(ctx, deleteBinding, id) + if err != nil { + return 0, err + } + return result.RowsAffected(), nil +} + +const deleteCapturesBeyondCount = `-- name: DeleteCapturesBeyondCount :exec +DELETE FROM captures WHERE id NOT IN ( + SELECT id FROM captures ORDER BY received_at DESC LIMIT $1 +) +` + +func (q *Queries) DeleteCapturesBeyondCount(ctx context.Context, limit int32) error { + _, err := q.db.Exec(ctx, deleteCapturesBeyondCount, limit) + return err +} + +const deleteCapturesOlderThan = `-- name: DeleteCapturesOlderThan :exec +DELETE FROM captures WHERE received_at < $1 +` + +func (q *Queries) DeleteCapturesOlderThan(ctx context.Context, receivedAt time.Time) error { + _, err := q.db.Exec(ctx, deleteCapturesOlderThan, receivedAt) + return err +} + +const deleteMapping = `-- name: DeleteMapping :execrows +DELETE FROM mappings WHERE id = $1 +` + +func (q *Queries) DeleteMapping(ctx context.Context, id string) (int64, error) { + result, err := q.db.Exec(ctx, deleteMapping, id) + if err != nil { + return 0, err + } + return result.RowsAffected(), nil +} + +const deletePlaybookDispatches = `-- name: DeletePlaybookDispatches :exec +DELETE FROM playbook_dispatches WHERE playbook_id = $1 +` + +func (q *Queries) DeletePlaybookDispatches(ctx context.Context, playbookID string) error { + _, err := q.db.Exec(ctx, deletePlaybookDispatches, playbookID) + return err +} + +const getBinding = `-- name: GetBinding :one +SELECT id, name, source, mapping, workflow, owner, repo, version, status, secret, created_at, updated_at +FROM bindings WHERE id = $1 +` + +func (q *Queries) GetBinding(ctx context.Context, id string) (Binding, error) { + row := q.db.QueryRow(ctx, getBinding, id) + var i Binding + err := row.Scan( + &i.ID, + &i.Name, + &i.Source, + &i.Mapping, + &i.Workflow, + &i.Owner, + &i.Repo, + &i.Version, + &i.Status, + &i.Secret, + &i.CreatedAt, + &i.UpdatedAt, + ) + return i, err +} + +const getMapping = `-- name: GetMapping :one +SELECT id, name, source_hint, fields, created_at, updated_at +FROM mappings WHERE id = $1 +` + +func (q *Queries) GetMapping(ctx context.Context, id string) (Mapping, error) { + row := q.db.QueryRow(ctx, getMapping, id) + var i Mapping + err := row.Scan( + &i.ID, + &i.Name, + &i.SourceHint, + &i.Fields, + &i.CreatedAt, + &i.UpdatedAt, + ) + return i, err +} + +const insertBinding = `-- name: InsertBinding :exec +INSERT INTO bindings (id, name, source, mapping, workflow, owner, repo, version, status, secret) +VALUES ($1, $2, $3, $4, $5, $6, $7, 1, $8, $9) +` + +type InsertBindingParams struct { + ID string + Name string + Source string + Mapping string + Workflow string + Owner string + Repo string + Status string + Secret string +} + +func (q *Queries) InsertBinding(ctx context.Context, arg InsertBindingParams) error { + _, err := q.db.Exec(ctx, insertBinding, + arg.ID, + arg.Name, + arg.Source, + arg.Mapping, + arg.Workflow, + arg.Owner, + arg.Repo, + arg.Status, + arg.Secret, + ) + return err +} + +const insertBindingDispatch = `-- name: InsertBindingDispatch :exec +INSERT INTO binding_dispatches (binding, binding_version, capture, task_id) +VALUES ($1, $2, $3, $4) +` + +type InsertBindingDispatchParams struct { + Binding string + BindingVersion int64 + Capture string + TaskID int64 +} + +func (q *Queries) InsertBindingDispatch(ctx context.Context, arg InsertBindingDispatchParams) error { + _, err := q.db.Exec(ctx, insertBindingDispatch, + arg.Binding, + arg.BindingVersion, + arg.Capture, + arg.TaskID, + ) + return err +} + +const insertCapture = `-- name: InsertCapture :exec + +INSERT INTO captures (id, source, remote_addr, content_type, headers, body, authenticated, received_at) +VALUES ($1, $2, $3, $4, $5, $6, $7, $8) +` + +type InsertCaptureParams struct { + ID string + Source string + RemoteAddr string + ContentType string + Headers string + Body string + Authenticated bool + ReceivedAt time.Time +} + +// EDA queries: captures, mappings, bindings, dispatch ledgers, tool_calls. +func (q *Queries) InsertCapture(ctx context.Context, arg InsertCaptureParams) error { + _, err := q.db.Exec(ctx, insertCapture, + arg.ID, + arg.Source, + arg.RemoteAddr, + arg.ContentType, + arg.Headers, + arg.Body, + arg.Authenticated, + arg.ReceivedAt, + ) + return err +} + +const insertMapping = `-- name: InsertMapping :exec +INSERT INTO mappings (id, name, source_hint, fields) +VALUES ($1, $2, $3, $4) +` + +type InsertMappingParams struct { + ID string + Name string + SourceHint string + Fields string +} + +func (q *Queries) InsertMapping(ctx context.Context, arg InsertMappingParams) error { + _, err := q.db.Exec(ctx, insertMapping, + arg.ID, + arg.Name, + arg.SourceHint, + arg.Fields, + ) + return err +} + +const insertPlaybookDispatch = `-- name: InsertPlaybookDispatch :exec +INSERT INTO playbook_dispatches (playbook_id, playbook_version, event_id, action_id) +VALUES ($1, $2, $3, $4) +` + +type InsertPlaybookDispatchParams struct { + PlaybookID string + PlaybookVersion string + EventID string + ActionID string +} + +func (q *Queries) InsertPlaybookDispatch(ctx context.Context, arg InsertPlaybookDispatchParams) error { + _, err := q.db.Exec(ctx, insertPlaybookDispatch, + arg.PlaybookID, + arg.PlaybookVersion, + arg.EventID, + arg.ActionID, + ) + return err +} + +const insertToolCall = `-- name: InsertToolCall :exec +INSERT INTO tool_calls (id, task_id, attempt, tool, result, error, called_at) +VALUES ($1, $2, $3, $4, $5, $6, $7) +` + +type InsertToolCallParams struct { + ID string + TaskID int64 + Attempt int64 + Tool string + Result string + Error string + CalledAt time.Time +} + +func (q *Queries) InsertToolCall(ctx context.Context, arg InsertToolCallParams) error { + _, err := q.db.Exec(ctx, insertToolCall, + arg.ID, + arg.TaskID, + arg.Attempt, + arg.Tool, + arg.Result, + arg.Error, + arg.CalledAt, + ) + return err +} + +const listBindings = `-- name: ListBindings :many +SELECT id, name, source, mapping, workflow, owner, repo, version, status, secret, created_at, updated_at +FROM bindings ORDER BY created_at DESC +` + +func (q *Queries) ListBindings(ctx context.Context) ([]Binding, error) { + rows, err := q.db.Query(ctx, listBindings) + if err != nil { + return nil, err + } + defer rows.Close() + var items []Binding + for rows.Next() { + var i Binding + if err := rows.Scan( + &i.ID, + &i.Name, + &i.Source, + &i.Mapping, + &i.Workflow, + &i.Owner, + &i.Repo, + &i.Version, + &i.Status, + &i.Secret, + &i.CreatedAt, + &i.UpdatedAt, + ); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + +const listCaptures = `-- name: ListCaptures :many +SELECT id, source, remote_addr, content_type, headers, body, authenticated, received_at +FROM captures +ORDER BY received_at DESC +LIMIT $1 +` + +func (q *Queries) ListCaptures(ctx context.Context, limit int32) ([]Capture, error) { + rows, err := q.db.Query(ctx, listCaptures, limit) + if err != nil { + return nil, err + } + defer rows.Close() + var items []Capture + for rows.Next() { + var i Capture + if err := rows.Scan( + &i.ID, + &i.Source, + &i.RemoteAddr, + &i.ContentType, + &i.Headers, + &i.Body, + &i.Authenticated, + &i.ReceivedAt, + ); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + +const listMappings = `-- name: ListMappings :many +SELECT id, name, source_hint, fields, created_at, updated_at +FROM mappings ORDER BY created_at DESC +` + +func (q *Queries) ListMappings(ctx context.Context) ([]Mapping, error) { + rows, err := q.db.Query(ctx, listMappings) + if err != nil { + return nil, err + } + defer rows.Close() + var items []Mapping + for rows.Next() { + var i Mapping + if err := rows.Scan( + &i.ID, + &i.Name, + &i.SourceHint, + &i.Fields, + &i.CreatedAt, + &i.UpdatedAt, + ); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + +const listUndispatchedCaptures = `-- name: ListUndispatchedCaptures :many +SELECT id, source, remote_addr, content_type, headers, body, authenticated, received_at +FROM captures +WHERE source = ANY($1::text[]) + AND id NOT IN (SELECT capture FROM binding_dispatches) +ORDER BY received_at DESC +LIMIT $2 +` + +type ListUndispatchedCapturesParams struct { + Sources []string + EntryLimit int32 +} + +func (q *Queries) ListUndispatchedCaptures(ctx context.Context, arg ListUndispatchedCapturesParams) ([]Capture, error) { + rows, err := q.db.Query(ctx, listUndispatchedCaptures, arg.Sources, arg.EntryLimit) + if err != nil { + return nil, err + } + defer rows.Close() + var items []Capture + for rows.Next() { + var i Capture + if err := rows.Scan( + &i.ID, + &i.Source, + &i.RemoteAddr, + &i.ContentType, + &i.Headers, + &i.Body, + &i.Authenticated, + &i.ReceivedAt, + ); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + +const setBindingArmed = `-- name: SetBindingArmed :execrows +UPDATE bindings SET status = 'armed', updated_at = now() WHERE id = $1 +` + +func (q *Queries) SetBindingArmed(ctx context.Context, id string) (int64, error) { + result, err := q.db.Exec(ctx, setBindingArmed, id) + if err != nil { + return 0, err + } + return result.RowsAffected(), nil +} + +const taskToolCalls = `-- name: TaskToolCalls :many +SELECT id, task_id, attempt, tool, result, error, called_at +FROM tool_calls WHERE task_id = $1 ORDER BY called_at ASC +` + +type TaskToolCallsRow struct { + ID string + TaskID int64 + Attempt int64 + Tool string + Result string + Error string + CalledAt time.Time +} + +func (q *Queries) TaskToolCalls(ctx context.Context, taskID int64) ([]TaskToolCallsRow, error) { + rows, err := q.db.Query(ctx, taskToolCalls, taskID) + if err != nil { + return nil, err + } + defer rows.Close() + var items []TaskToolCallsRow + for rows.Next() { + var i TaskToolCallsRow + if err := rows.Scan( + &i.ID, + &i.TaskID, + &i.Attempt, + &i.Tool, + &i.Result, + &i.Error, + &i.CalledAt, + ); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + +const updateBinding = `-- name: UpdateBinding :execrows +UPDATE bindings +SET name = $2, source = $3, mapping = $4, workflow = $5, owner = $6, repo = $7, + version = version + 1, status = $8, + secret = CASE WHEN $9::text = '' THEN secret ELSE $9 END, + updated_at = now() +WHERE id = $1 +` + +type UpdateBindingParams struct { + ID string + Name string + Source string + Mapping string + Workflow string + Owner string + Repo string + Status string + Secret string +} + +// An empty secret means "keep the stored one": the CASE leaves the column +// untouched so an edit form that does not echo the secret cannot blank an +// armed binding's HMAC key. +func (q *Queries) UpdateBinding(ctx context.Context, arg UpdateBindingParams) (int64, error) { + result, err := q.db.Exec(ctx, updateBinding, + arg.ID, + arg.Name, + arg.Source, + arg.Mapping, + arg.Workflow, + arg.Owner, + arg.Repo, + arg.Status, + arg.Secret, + ) + if err != nil { + return 0, err + } + return result.RowsAffected(), nil +} + +const updateMapping = `-- name: UpdateMapping :execrows +UPDATE mappings +SET name = $2, source_hint = $3, fields = $4, updated_at = now() +WHERE id = $1 +` + +type UpdateMappingParams struct { + ID string + Name string + SourceHint string + Fields string +} + +func (q *Queries) UpdateMapping(ctx context.Context, arg UpdateMappingParams) (int64, error) { + result, err := q.db.Exec(ctx, updateMapping, + arg.ID, + arg.Name, + arg.SourceHint, + arg.Fields, + ) + if err != nil { + return 0, err + } + return result.RowsAffected(), nil +} diff --git a/internal/infrastructure/postgres/postgresdb/models.go b/internal/infrastructure/postgres/postgresdb/models.go index a4ec58e17..17277ca3d 100644 --- a/internal/infrastructure/postgres/postgresdb/models.go +++ b/internal/infrastructure/postgres/postgresdb/models.go @@ -16,6 +16,40 @@ type ApplyStatus struct { ReportedAt time.Time } +type Binding struct { + ID string + Name string + Source string + Mapping string + Workflow string + Owner string + Repo string + Version int64 + Status string + Secret string + CreatedAt time.Time + UpdatedAt time.Time +} + +type BindingDispatch struct { + Binding string + BindingVersion int64 + Capture string + TaskID int64 + DispatchedAt time.Time +} + +type Capture struct { + ID string + Source string + RemoteAddr string + ContentType string + Headers string + Body string + Authenticated bool + ReceivedAt time.Time +} + type ChannelStatus struct { ID string Name string @@ -85,6 +119,23 @@ type IdentitySubject struct { BoundAt time.Time } +type Mapping struct { + ID string + Name string + SourceHint string + Fields string + CreatedAt time.Time + UpdatedAt time.Time +} + +type PlaybookDispatch struct { + PlaybookID string + PlaybookVersion string + EventID string + ActionID string + DispatchedAt time.Time +} + type Resource struct { Kind string Value []byte @@ -140,6 +191,18 @@ type Task struct { UpdatedAt time.Time } +type ToolCall struct { + ID string + TaskID int64 + Attempt int64 + Tool string + Args string + Result string + Error string + DurationMs int64 + CalledAt time.Time +} + type Transition struct { ID int64 TaskID int64 diff --git a/internal/infrastructure/postgres/queries/edastore.sql b/internal/infrastructure/postgres/queries/edastore.sql new file mode 100644 index 000000000..54402fbf7 --- /dev/null +++ b/internal/infrastructure/postgres/queries/edastore.sql @@ -0,0 +1,99 @@ +-- EDA queries: captures, mappings, bindings, dispatch ledgers, tool_calls. + +-- name: InsertCapture :exec +INSERT INTO captures (id, source, remote_addr, content_type, headers, body, authenticated, received_at) +VALUES ($1, $2, $3, $4, $5, $6, $7, $8); + +-- name: ListCaptures :many +SELECT id, source, remote_addr, content_type, headers, body, authenticated, received_at +FROM captures +ORDER BY received_at DESC +LIMIT $1; + +-- name: ListUndispatchedCaptures :many +SELECT id, source, remote_addr, content_type, headers, body, authenticated, received_at +FROM captures +WHERE source = ANY(@sources::text[]) + AND id NOT IN (SELECT capture FROM binding_dispatches) +ORDER BY received_at DESC +LIMIT @entry_limit; + +-- name: DeleteCapturesOlderThan :exec +DELETE FROM captures WHERE received_at < $1; + +-- name: DeleteCapturesBeyondCount :exec +DELETE FROM captures WHERE id NOT IN ( + SELECT id FROM captures ORDER BY received_at DESC LIMIT $1 +); + +-- name: InsertMapping :exec +INSERT INTO mappings (id, name, source_hint, fields) +VALUES ($1, $2, $3, $4); + +-- name: GetMapping :one +SELECT id, name, source_hint, fields, created_at, updated_at +FROM mappings WHERE id = $1; + +-- name: ListMappings :many +SELECT id, name, source_hint, fields, created_at, updated_at +FROM mappings ORDER BY created_at DESC; + +-- name: UpdateMapping :execrows +UPDATE mappings +SET name = $2, source_hint = $3, fields = $4, updated_at = now() +WHERE id = $1; + +-- name: DeleteMapping :execrows +DELETE FROM mappings WHERE id = $1; + +-- name: InsertBinding :exec +INSERT INTO bindings (id, name, source, mapping, workflow, owner, repo, version, status, secret) +VALUES ($1, $2, $3, $4, $5, $6, $7, 1, $8, $9); + +-- name: GetBinding :one +SELECT id, name, source, mapping, workflow, owner, repo, version, status, secret, created_at, updated_at +FROM bindings WHERE id = $1; + +-- name: ListBindings :many +SELECT id, name, source, mapping, workflow, owner, repo, version, status, secret, created_at, updated_at +FROM bindings ORDER BY created_at DESC; + +-- name: ArmedBindingsForSource :many +SELECT id, name, source, mapping, workflow, owner, repo, version, status, secret, created_at, updated_at +FROM bindings WHERE source = $1 AND status = 'armed' ORDER BY created_at DESC; + +-- name: UpdateBinding :execrows +-- An empty secret means "keep the stored one": the CASE leaves the column +-- untouched so an edit form that does not echo the secret cannot blank an +-- armed binding's HMAC key. +UPDATE bindings +SET name = $2, source = $3, mapping = $4, workflow = $5, owner = $6, repo = $7, + version = version + 1, status = $8, + secret = CASE WHEN sqlc.arg(secret)::text = '' THEN secret ELSE sqlc.arg(secret) END, + updated_at = now() +WHERE id = $1; + +-- name: SetBindingArmed :execrows +UPDATE bindings SET status = 'armed', updated_at = now() WHERE id = $1; + +-- name: DeleteBinding :execrows +DELETE FROM bindings WHERE id = $1; + +-- name: InsertBindingDispatch :exec +INSERT INTO binding_dispatches (binding, binding_version, capture, task_id) +VALUES ($1, $2, $3, $4); + +-- name: InsertPlaybookDispatch :exec +INSERT INTO playbook_dispatches (playbook_id, playbook_version, event_id, action_id) +VALUES ($1, $2, $3, $4); + +-- name: DeletePlaybookDispatches :exec +DELETE FROM playbook_dispatches WHERE playbook_id = $1; + +-- name: InsertToolCall :exec +INSERT INTO tool_calls (id, task_id, attempt, tool, result, error, called_at) +VALUES ($1, $2, $3, $4, $5, $6, $7); + +-- name: TaskToolCalls :many +SELECT id, task_id, attempt, tool, result, error, called_at +FROM tool_calls WHERE task_id = $1 ORDER BY called_at ASC;