Archie runs its own agent loop only. Removes Kit resolution and launch, the harness runner and adapters, the setup terminal and sandbox view, harness secrets and OAuth capture (table dropped in migration 0075), the task-tools contract that only Kit containers reached, and the sandbox-kit-spec dependency. Agent profiles carry image and tools only. The egress proxy keeps the model-session path; the sandbox relay code stays for #1867.
882 lines
30 KiB
Go
882 lines
30 KiB
Go
// 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.CaptureRefusalStore = (*EDA)(nil)
|
|
_ storecontract.MappingStore = (*EDA)(nil)
|
|
_ storecontract.MappingMatchRecorder = (*EDA)(nil)
|
|
_ storecontract.EventTypeStore = (*EDA)(nil)
|
|
_ storecontract.BindingStore = (*EDA)(nil)
|
|
_ storecontract.SourceStore = (*EDA)(nil)
|
|
_ storecontract.DispatchLedger = (*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 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),
|
|
ScheduleOrg: c.OrgID,
|
|
}); 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
|
|
}
|
|
|
|
// 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
|
|
}
|