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.
This commit is contained in:
sam committed 2026-09-24 02:17:31 +10:00
1 parent cebbcb5690
commit cea754872c
6 files changed
+1765

No files matched your search

@@ -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
}
@@ -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")
}
}
@@ -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;
@@ -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
}
@@ -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
@@ -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;