// 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. package postgres import ( "context" "encoding/json" "errors" "fmt" "log/slog" "reflect" "time" "github.com/google/uuid" "github.com/jackc/pgx/v5" "github.com/jackc/pgx/v5/pgtype" "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/org" "github.com/samcharles93/archie-core/internal/domain/storecontract" "github.com/samcharles93/archie-core/internal/events" "github.com/samcharles93/archie-core/internal/infrastructure/bindingcipher" "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. var ( _ storecontract.CaptureStore = (*EDA)(nil) _ storecontract.MappingStore = (*EDA)(nil) _ storecontract.BindingStore = (*EDA)(nil) _ storecontract.BindingDispatcher = (*EDA)(nil) _ storecontract.MappingMatchRecorder = (*EDA)(nil) _ storecontract.PlaybookDispatcher = (*EDA)(nil) ) // EDA is the PostgreSQL-backed EDA persistence. type EDA struct { pool *pgxpool.Pool q *postgresdb.Queries cipher bindingcipher.BindingCipher notify func(events.Event) log *slog.Logger } // NewEDA builds an EDA store over pool. A nil cipher keeps source secrets in // plaintext; the caller resolves the keyring through // bindingcipher.NewBindingCipher. The pool is owned by the caller, not this store. func NewEDA(pool *pgxpool.Pool, cipher bindingcipher.BindingCipher, log *slog.Logger) *EDA { return &EDA{pool: pool, q: postgresdb.New(pool), cipher: cipher, log: log} } // SetNotify wires the change-event callback. 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. 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() } // decodedJSON keeps a stored JSON text structured in an audit value, and falls // back to the raw string when it will not decode. func decodedJSON(raw string) any { var v any if err := json.Unmarshal([]byte(raw), &v); err != nil { return raw } return v } // mappingAuditDoc is the record an audit row shows for a mapping. func mappingAuditDoc(id, name, sourceHint, eventType, fields string) map[string]any { return map[string]any{ "id": id, "name": name, "source_hint": sourceHint, "event_type": eventType, "fields": decodedJSON(fields), } } func mappingRowAuditDoc(r postgresdb.GetMappingRow) map[string]any { return mappingAuditDoc(r.Mapping.ID, r.Mapping.Name, r.Mapping.SourceHint, r.Mapping.EventType, r.Mapping.Fields) } // bindingAuditDoc is the record an audit row shows for a binding. func bindingAuditDoc(id, name, source, mappingID, filter, workflow, owner, repo, repoParam, inputs, status, workspaceID string, version int64) map[string]any { return map[string]any{ "id": id, "name": name, "source": source, "mapping": mappingID, "filter": filter, "workflow": workflow, "owner": owner, "repo": repo, "repo_param": repoParam, "inputs": decodedJSON(inputs), "status": status, "workspace_id": workspaceID, "version": version, } } func bindingRowAuditDoc(r postgresdb.GetBindingRow) map[string]any { return bindingAuditDoc(r.ID, r.Name, r.Source, r.Mapping, r.Filter, r.Workflow, r.Owner, r.Repo, r.RepoParam, r.Inputs, r.Status, r.WorkspaceID, r.Version) } // bindingWorkspace is the workspace the binding SQL derives: its source's, or // "default" when the source no longer exists. func bindingWorkspace(ctx context.Context, q *postgresdb.Queries, source, orgID string) (string, error) { workspace, err := q.SourceWorkspace(ctx, postgresdb.SourceWorkspaceParams{Path: source, OrgID: orgID}) if errors.Is(err, pgx.ErrNoRows) { return "default", nil } if err != nil { return "", err } return workspace, nil } // bindingEditableEqual reports whether b would change any field UpdateBinding // writes, so an identical save is not recorded as a change. func bindingEditableEqual(r postgresdb.GetBindingRow, b binding.Binding, inputs string) bool { return r.Name == b.Name && r.Source == b.Matcher.Source && r.Mapping == b.MappingID && r.Filter == b.Filter && r.Workflow == b.Workflow && r.Owner == b.Owner && r.Repo == b.Repo && r.RepoParam == b.RepoParam && r.Inputs == inputs } // --- captures --- // InsertCapture stores one inbound event verbatim, tagged with the event type // it is identified as on arrival (empty when unidentified). retention and maxEvents are // applied as a prune after the insert; a failed prune is logged, not returned, // because the capture is already stored and a retry would store it again. 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() } eventType, err := s.identifyCapture(ctx, c) if err != nil { return "", err } id := newRecordID() delivery := c.Delivery if delivery == "" { delivery = id } 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, Unsigned: c.Unsigned, ReceivedAt: received.UTC(), EventType: eventType, Delivery: delivery, DefaultOrg: string(org.DefaultOrgID), DefaultWorkspace: string(org.DefaultWorkspaceID), }); err != nil { return "", fmt.Errorf("edastore: insert capture: %w", err) } if err := s.pruneCaptures(ctx, id, retention, maxEvents); err != nil { s.log.WarnContext(ctx, "capture stored but not pruned", "capture", id, "err", err) } return id, nil } func (s *EDA) pruneCaptures(ctx context.Context, captureID string, 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, postgresdb.DeleteCapturesBeyondCountParams{ CaptureID: captureID, MaxEvents: 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, EventType: r.EventType, Unsigned: r.Unsigned, Delivery: r.Delivery, } } // ListCaptures returns the newest captures first in the acting org. func (s *EDA) ListCaptures(ctx context.Context, limit int) ([]storecontract.CapturedEvent, error) { rows, err := s.q.ListCaptures(ctx, postgresdb.ListCapturesParams{ OrgID: string(org.OrgFromContext(ctx)), Limit: 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 the oldest dispatchable, identified // captures that one of the given armed bindings, for their event type, has not // dispatched yet. An unidentified capture is never returned, so it // never dispatches. func (s *EDA) ListUndispatchedCaptures(ctx context.Context, bindings []string, limit int) ([]storecontract.CapturedEvent, error) { if len(bindings) == 0 || limit <= 0 { return nil, nil } rows, err := s.q.ListUndispatchedCaptures(ctx, postgresdb.ListUndispatchedCapturesParams{ OrgID: string(org.OrgFromContext(ctx)), Bindings: bindings, 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, matches int64, lastMatched time.Time) (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) } } // The query reports the epoch for a mapping that never matched. if matches == 0 { lastMatched = time.Time{} } return mapping.Mapping{ ID: r.ID, Name: r.Name, SourceHint: r.SourceHint, EventTypeID: r.EventType, Fields: fields, WorkspaceID: org.WorkspaceID(r.WorkspaceID), MatchCount: matches, LastMatchedAt: lastMatched, 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() orgID := string(org.OrgFromContext(ctx)) if err := pgx.BeginFunc(ctx, s.pool, func(tx pgx.Tx) error { q := postgresdb.New(tx) if err := q.InsertMapping(ctx, postgresdb.InsertMappingParams{ OrgID: orgID, ID: id, Name: m.Name, SourceHint: m.SourceHint, EventType: m.EventTypeID, Fields: encoded, }); err != nil { return fmt.Errorf("edastore: insert mapping: %w", err) } return insertAuditValues(ctx, q, "mappings", id, "mapping", nil, mappingAuditDoc(id, m.Name, m.SourceHint, m.EventTypeID, encoded), 0, orgID) }); err != nil { return "", err } s.notifyWrite(events.KindMappingChanged, "mapping", "create", id) return id, nil } // GetMapping returns (nil, nil) for an absent mapping, the 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, postgresdb.GetMappingParams{ID: id, ScopeOrg: scopeOrg(ctx)}) if errors.Is(err, pgx.ErrNoRows) { return nil, nil } if err != nil { return nil, err } m, err := mappingValue(r.Mapping, r.MatchCount, r.LastMatchedAt) 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, scopeOrg(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.Mapping, r.MatchCount, r.LastMatchedAt) 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 } err = pgx.BeginFunc(ctx, s.pool, func(tx pgx.Tx) error { q := postgresdb.New(tx) if err := q.LockAuditRecord(ctx, postgresdb.LockAuditRecordParams{TableName: "mappings", RecordKey: m.ID}); err != nil { return err } old, err := q.GetMapping(ctx, postgresdb.GetMappingParams{ID: m.ID, ScopeOrg: scopeOrg(ctx)}) if errors.Is(err, pgx.ErrNoRows) { return storecontract.ErrMappingNotFound } if err != nil { return err } oldDoc := mappingRowAuditDoc(old) newDoc := mappingAuditDoc(m.ID, m.Name, m.SourceHint, m.EventTypeID, encoded) if reflect.DeepEqual(oldDoc, newDoc) { return nil } n, err := q.UpdateMapping(ctx, postgresdb.UpdateMappingParams{ ScopeOrg: scopeOrg(ctx), ID: m.ID, Name: m.Name, SourceHint: m.SourceHint, EventType: m.EventTypeID, Fields: encoded, }) if err != nil { return err } if n == 0 { return storecontract.ErrMappingNotFound } return insertAuditValues(ctx, q, "mappings", m.ID, "mapping", oldDoc, newDoc, 0, old.Mapping.OrgID) }) if err != nil { return err } s.notifyWrite(events.KindMappingChanged, "mapping", "update", m.ID) return nil } func (s *EDA) DeleteMapping(ctx context.Context, id string) error { err := pgx.BeginFunc(ctx, s.pool, func(tx pgx.Tx) error { q := postgresdb.New(tx) if err := q.LockAuditRecord(ctx, postgresdb.LockAuditRecordParams{TableName: "mappings", RecordKey: id}); err != nil { return err } old, err := q.GetMapping(ctx, postgresdb.GetMappingParams{ID: id, ScopeOrg: scopeOrg(ctx)}) if errors.Is(err, pgx.ErrNoRows) { return storecontract.ErrMappingNotFound } if err != nil { return err } n, err := q.DeleteMapping(ctx, postgresdb.DeleteMappingParams{ID: id, ScopeOrg: scopeOrg(ctx)}) if err != nil { return err } if n == 0 { return storecontract.ErrMappingNotFound } return insertAuditValues(ctx, q, "mappings", id, "mapping", mappingRowAuditDoc(old), nil, 0, old.Mapping.OrgID) }) if err != nil { return err } s.notifyWrite(events.KindMappingChanged, "mapping", "delete", id) return nil } // RecordMappingMatch counts one event a mapping resolved. Recording the same // (mapping, capture) again is a no-op, so the count rises once per event no // matter how many bindings share the mapping. func (s *EDA) RecordMappingMatch(ctx context.Context, mappingID, captureID string) error { if err := s.q.InsertMappingMatch(ctx, postgresdb.InsertMappingMatchParams{Mapping: mappingID, Capture: captureID}); err != nil { return fmt.Errorf("edastore: record mapping match: %w", err) } return nil } // --- bindings --- // bindingValue takes GetBindingRow; the list queries' rows share its fields // and convert to it. func bindingValue(r postgresdb.GetBindingRow) (binding.Binding, error) { var inputs map[string]binding.InputSource if err := json.Unmarshal([]byte(r.Inputs), &inputs); err != nil { return binding.Binding{}, fmt.Errorf("edastore: decode binding %s inputs: %w", r.ID, err) } return binding.Binding{ ID: r.ID, Name: r.Name, Matcher: binding.Matcher{Source: r.Source}, MappingID: r.Mapping, Filter: r.Filter, Workflow: r.Workflow, Owner: r.Owner, Repo: r.Repo, RepoParam: r.RepoParam, Inputs: inputs, OrgID: org.OrgID(r.OrgID), WorkspaceID: org.WorkspaceID(r.WorkspaceID), Version: int(r.Version), Status: binding.Status(r.Status), CreatedAt: r.CreatedAt, UpdatedAt: r.UpdatedAt, }, nil } // bindingInputs encodes a binding's input assignments for storage. func bindingInputs(b binding.Binding) (string, error) { if len(b.Inputs) == 0 { return "{}", nil } data, err := json.Marshal(b.Inputs) if err != nil { return "", fmt.Errorf("edastore: encode binding inputs: %w", err) } return string(data), nil } // InsertBinding stores a new binding as pending_approval. Any number of // bindings may share a source. func (s *EDA) InsertBinding(ctx context.Context, b binding.Binding) (string, error) { id := newRecordID() inputs, err := bindingInputs(b) if err != nil { return "", err } orgID := string(org.OrgFromContext(ctx)) if err := pgx.BeginFunc(ctx, s.pool, func(tx pgx.Tx) error { q := postgresdb.New(tx) workspace, err := bindingWorkspace(ctx, q, b.Matcher.Source, orgID) if err != nil { return err } if err := q.InsertBinding(ctx, postgresdb.InsertBindingParams{ OrgID: orgID, ID: id, Name: b.Name, Source: b.Matcher.Source, Mapping: b.MappingID, Filter: b.Filter, Workflow: b.Workflow, Owner: b.Owner, Repo: b.Repo, Status: string(binding.StatusPendingApproval), Inputs: inputs, RepoParam: b.RepoParam, }); err != nil { return fmt.Errorf("edastore: insert binding: %w", err) } return insertAuditValues(ctx, q, "bindings", id, "binding", nil, bindingAuditDoc(id, b.Name, b.Matcher.Source, b.MappingID, b.Filter, b.Workflow, b.Owner, b.Repo, b.RepoParam, inputs, string(binding.StatusPendingApproval), workspace, 1), 1, orgID) }); err != nil { return "", err } s.notifyWrite(events.KindBindingChanged, "binding", "create", id) return id, nil } // GetBinding returns (nil, nil) for an absent binding, the 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, postgresdb.GetBindingParams{ID: id, ScopeOrg: scopeOrg(ctx)}) if errors.Is(err, pgx.ErrNoRows) { return nil, nil } if err != nil { return nil, err } b, err := 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, scopeOrg(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 := bindingValue(postgresdb.GetBindingRow(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, postgresdb.ArmedBindingsForSourceParams{Source: source, ScopeOrg: scopeOrg(ctx)}) 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 := bindingValue(postgresdb.GetBindingRow(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. func (s *EDA) UpdateBinding(ctx context.Context, b binding.Binding) error { inputs, err := bindingInputs(b) if err != nil { return err } err = pgx.BeginFunc(ctx, s.pool, func(tx pgx.Tx) error { q := postgresdb.New(tx) if err := q.LockAuditRecord(ctx, postgresdb.LockAuditRecordParams{TableName: "bindings", RecordKey: b.ID}); err != nil { return err } old, err := q.GetBinding(ctx, postgresdb.GetBindingParams{ID: b.ID, ScopeOrg: scopeOrg(ctx)}) if errors.Is(err, pgx.ErrNoRows) { return storecontract.ErrBindingNotFound } if err != nil { return err } // The target workspace comes from the source, so hold the source's lock // until the UPDATE has recomputed it too. Binding then source is the // only order taken, so it cannot cycle. if err := q.LockAuditRecord(ctx, postgresdb.LockAuditRecordParams{TableName: "sources", RecordKey: b.Matcher.Source}); err != nil { return err } targetWorkspace, err := bindingWorkspace(ctx, q, b.Matcher.Source, old.OrgID) if err != nil { return err } if bindingEditableEqual(old, b, inputs) && old.Status == string(binding.StatusPendingApproval) && old.WorkspaceID == targetWorkspace { return nil } n, err := q.UpdateBinding(ctx, postgresdb.UpdateBindingParams{ ScopeOrg: scopeOrg(ctx), ID: b.ID, Name: b.Name, Source: b.Matcher.Source, Mapping: b.MappingID, Filter: b.Filter, Workflow: b.Workflow, Owner: b.Owner, Repo: b.Repo, Status: string(binding.StatusPendingApproval), Inputs: inputs, RepoParam: b.RepoParam, }) if err != nil { return err } if n == 0 { return storecontract.ErrBindingNotFound } next := old.Version + 1 return insertAuditValues(ctx, q, "bindings", b.ID, "binding", bindingRowAuditDoc(old), bindingAuditDoc(b.ID, b.Name, b.Matcher.Source, b.MappingID, b.Filter, b.Workflow, b.Owner, b.Repo, b.RepoParam, inputs, string(binding.StatusPendingApproval), targetWorkspace, next), next, old.OrgID) }) if err != nil { return err } s.notifyWrite(events.KindBindingChanged, "binding", "update", b.ID) return nil } func (s *EDA) DeleteBinding(ctx context.Context, id string) error { err := pgx.BeginFunc(ctx, s.pool, func(tx pgx.Tx) error { q := postgresdb.New(tx) if err := q.LockAuditRecord(ctx, postgresdb.LockAuditRecordParams{TableName: "bindings", RecordKey: id}); err != nil { return err } old, err := q.GetBinding(ctx, postgresdb.GetBindingParams{ID: id, ScopeOrg: scopeOrg(ctx)}) if errors.Is(err, pgx.ErrNoRows) { return storecontract.ErrBindingNotFound } if err != nil { return err } n, err := q.DeleteBinding(ctx, postgresdb.DeleteBindingParams{ID: id, ScopeOrg: scopeOrg(ctx)}) if err != nil { return err } if n == 0 { return storecontract.ErrBindingNotFound } return insertAuditValues(ctx, q, "bindings", id, "binding", bindingRowAuditDoc(old), nil, old.Version, old.OrgID) }) if err != nil { return err } s.notifyWrite(events.KindBindingChanged, "binding", "delete", id) return nil } // ApproveBinding is the only transition that arms a binding. func (s *EDA) ApproveBinding(ctx context.Context, id string) error { err := pgx.BeginFunc(ctx, s.pool, func(tx pgx.Tx) error { q := postgresdb.New(tx) if err := q.LockAuditRecord(ctx, postgresdb.LockAuditRecordParams{TableName: "bindings", RecordKey: id}); err != nil { return err } r, err := q.GetBinding(ctx, postgresdb.GetBindingParams{ID: id, ScopeOrg: scopeOrg(ctx)}) 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 := q.SetBindingArmed(ctx, postgresdb.SetBindingArmedParams{ID: id, ScopeOrg: scopeOrg(ctx)}) if err != nil { return err } if n == 0 { return storecontract.ErrBindingNotFound } return insertAuditValues(ctx, q, "bindings", id, "status", string(binding.StatusPendingApproval), string(binding.StatusArmed), r.Version, r.OrgID) }) if err != nil { return err } s.notifyWrite(events.KindBindingChanged, "binding", "approve", id) return nil } // PauseBinding stops an armed binding from dispatching. func (s *EDA) PauseBinding(ctx context.Context, id string) error { return s.transitionBinding(ctx, id, binding.StatusArmed, binding.StatusPaused, "pause") } // ResumeBinding returns a paused binding to pending_approval: it fires again // only once approved. func (s *EDA) ResumeBinding(ctx context.Context, id string) error { return s.transitionBinding(ctx, id, binding.StatusPaused, binding.StatusPendingApproval, "resume") } func (s *EDA) transitionBinding(ctx context.Context, id string, from, to binding.Status, verb string) error { err := pgx.BeginFunc(ctx, s.pool, func(tx pgx.Tx) error { q := postgresdb.New(tx) if err := q.LockAuditRecord(ctx, postgresdb.LockAuditRecordParams{TableName: "bindings", RecordKey: id}); err != nil { return err } n, err := q.TransitionBindingStatus(ctx, postgresdb.TransitionBindingStatusParams{ ID: id, FromStatus: string(from), ToStatus: string(to), ScopeOrg: scopeOrg(ctx), }) if err != nil { return err } if n == 0 { if _, err := q.GetBinding(ctx, postgresdb.GetBindingParams{ID: id, ScopeOrg: scopeOrg(ctx)}); errors.Is(err, pgx.ErrNoRows) { return storecontract.ErrBindingNotFound } return storecontract.ErrBindingTransition } current, err := q.GetBinding(ctx, postgresdb.GetBindingParams{ID: id, ScopeOrg: scopeOrg(ctx)}) if err != nil { return err } return insertAuditValues(ctx, q, "bindings", id, "status", string(from), string(to), current.Version, current.OrgID) }) if err != nil { return err } s.notifyWrite(events.KindBindingChanged, "binding", verb, id) return nil } // --- dispatch ledgers --- // RecordDispatch writes one at-most-once binding dispatch, keyed on the // capture's delivery so a retried delivery is refused like the original. // binding_version is stored but is not part of the key, so a version bump does // not permit re-dispatching the same delivery. A non-empty reason records an // evaluation that ended without a task. func (s *EDA) RecordDispatch(ctx context.Context, bindingID string, bindingVersion int64, captureID string, taskID int64, reason string) error { n, err := s.q.InsertBindingDispatch(ctx, postgresdb.InsertBindingDispatchParams{ Binding: bindingID, BindingVersion: bindingVersion, Capture: captureID, TaskID: taskID, Reason: reason, }) if err == nil && n == 0 { return fmt.Errorf("edastore: record dispatch: capture %q not found", captureID) } return ledgerWrite(err, "edastore: record dispatch") } // ListDispatches returns the newest ledger rows matching filter. func (s *EDA) ListDispatches(ctx context.Context, filter storecontract.DispatchFilter) ([]storecontract.Dispatch, error) { params := postgresdb.ListBindingDispatchesParams{EntryLimit: int32(min(max(filter.Limit, 1), 500)), ScopeOrg: scopeOrg(ctx)} // clamped if filter.BindingID != "" { params.Binding = pgtype.Text{String: filter.BindingID, Valid: true} } if filter.CaptureID != "" { params.Capture = pgtype.Text{String: filter.CaptureID, Valid: true} } if filter.TaskID != 0 { params.TaskID = pgtype.Int8{Int64: filter.TaskID, Valid: true} } rows, err := s.q.ListBindingDispatches(ctx, params) if err != nil { return nil, fmt.Errorf("edastore: list dispatches: %w", err) } out := make([]storecontract.Dispatch, 0, len(rows)) for _, r := range rows { out = append(out, storecontract.Dispatch{ BindingID: r.Binding, BindingVersion: r.BindingVersion, CaptureID: r.Capture, TaskID: r.TaskID, Reason: r.Reason, DispatchedAt: r.DispatchedAt, }) } return out, nil } 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) } } // --- tool calls --- // ToolCall is one completed tool invocation during an agent stage run, as the // tool_call event projection stores it: a tool's output summary in Result, a // failure's detail in Error. type ToolCall struct { ID string TaskID int64 Attempt int Tool string Result string Error string CalledAt time.Time } // InsertToolCall appends one row to the tool_calls transcript. func (s *EDA) InsertToolCall(ctx context.Context, tc 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) ([]ToolCall, error) { rows, err := s.q.TaskToolCalls(ctx, postgresdb.TaskToolCallsParams{TaskID: taskID, ScopeOrg: scopeOrg(ctx)}) if err != nil { return nil, fmt.Errorf("edastore: list tool calls: %w", err) } out := make([]ToolCall, 0, len(rows)) for _, r := range rows { out = append(out, 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 } // refusalRetention is how long a refusal is kept for the source page. const refusalRetention = 24 * time.Hour // RecordCaptureRefusal counts one refused event and drops refusals older // than a day. func (s *EDA) RecordCaptureRefusal(ctx context.Context, source, addr string, at time.Time) error { if err := s.q.InsertCaptureRefusal(ctx, postgresdb.InsertCaptureRefusalParams{Source: source, Addr: addr, RefusedAt: at.UTC()}); err != nil { return fmt.Errorf("store: record capture refusal: %w", err) } if err := s.q.DeleteCaptureRefusalsBefore(ctx, at.Add(-refusalRetention).UTC()); err != nil { return fmt.Errorf("store: prune capture refusals: %w", err) } return nil } // CaptureRefusals summarises refusals since a time for every source that had // one, beside the captures it accepted in the same window. func (s *EDA) CaptureRefusals(ctx context.Context, since time.Time) ([]storecontract.CaptureRefusals, error) { rows, err := s.q.CaptureRefusalSummary(ctx, postgresdb.CaptureRefusalSummaryParams{Since: since.UTC(), ScopeOrg: scopeOrg(ctx)}) if err != nil { return nil, fmt.Errorf("store: capture refusals: %w", err) } out := make([]storecontract.CaptureRefusals, 0, len(rows)) for _, r := range rows { out = append(out, storecontract.CaptureRefusals{Source: r.Source, Refused: r.Refused, Accepted: r.Accepted, Addrs: r.Addrs}) } return out, nil }