feat(staterpc): event type RPCs and capture event_type on the wire

This commit is contained in:
sam committed 2026-09-24 14:21:21 +10:00
1 parent 79b352dc44
commit 0ea59bb211
8 files changed
+1824 -726

No files matched your search

+4
View File
@@ -258,6 +258,10 @@ func (b *boot) stateStoreDeps(grants *staterpc.TaskGrants) staterpc.Deps {
deps.Bindings = b.eda
deps.BindingDispatcher = b.eda
deps.PlaybookDispatcher = b.eda
// Only the Postgres EDA store holds event types.
if eventTypes, ok := any(b.eda).(storecontract.EventTypeStore); ok {
deps.EventTypes = eventTypes
}
}
// tool_call events project into the tool_calls collection on the same
// event-capture store: this process legitimately owns both, so the
File diff suppressed because it is too large. Load diff
@@ -73,6 +73,10 @@ const (
StateStoreService_ListMappings_FullMethodName = "/state.v1.StateStoreService/ListMappings"
StateStoreService_UpdateMapping_FullMethodName = "/state.v1.StateStoreService/UpdateMapping"
StateStoreService_DeleteMapping_FullMethodName = "/state.v1.StateStoreService/DeleteMapping"
StateStoreService_InsertEventType_FullMethodName = "/state.v1.StateStoreService/InsertEventType"
StateStoreService_UpdateEventType_FullMethodName = "/state.v1.StateStoreService/UpdateEventType"
StateStoreService_DeleteEventType_FullMethodName = "/state.v1.StateStoreService/DeleteEventType"
StateStoreService_ListEventTypes_FullMethodName = "/state.v1.StateStoreService/ListEventTypes"
StateStoreService_InsertBinding_FullMethodName = "/state.v1.StateStoreService/InsertBinding"
StateStoreService_GetBinding_FullMethodName = "/state.v1.StateStoreService/GetBinding"
StateStoreService_ListBindings_FullMethodName = "/state.v1.StateStoreService/ListBindings"
@@ -197,6 +201,12 @@ type StateStoreServiceClient interface {
ListMappings(ctx context.Context, in *ListMappingsRequest, opts ...grpc.CallOption) (*ListMappingsResponse, error)
UpdateMapping(ctx context.Context, in *UpdateMappingRequest, opts ...grpc.CallOption) (*UpdateMappingResponse, error)
DeleteMapping(ctx context.Context, in *DeleteMappingRequest, opts ...grpc.CallOption) (*DeleteMappingResponse, error)
// EventType (docs/prds/event-automation.md, "Event types"). Insert and
// Update refuse an overlapping or malformed type.
InsertEventType(ctx context.Context, in *InsertEventTypeRequest, opts ...grpc.CallOption) (*InsertEventTypeResponse, error)
UpdateEventType(ctx context.Context, in *UpdateEventTypeRequest, opts ...grpc.CallOption) (*UpdateEventTypeResponse, error)
DeleteEventType(ctx context.Context, in *DeleteEventTypeRequest, opts ...grpc.CallOption) (*DeleteEventTypeResponse, error)
ListEventTypes(ctx context.Context, in *ListEventTypesRequest, opts ...grpc.CallOption) (*ListEventTypesResponse, error)
// Binding
InsertBinding(ctx context.Context, in *InsertBindingRequest, opts ...grpc.CallOption) (*InsertBindingResponse, error)
GetBinding(ctx context.Context, in *GetBindingRequest, opts ...grpc.CallOption) (*GetBindingResponse, error)
@@ -789,6 +799,46 @@ func (c *stateStoreServiceClient) DeleteMapping(ctx context.Context, in *DeleteM
return out, nil
}
func (c *stateStoreServiceClient) InsertEventType(ctx context.Context, in *InsertEventTypeRequest, opts ...grpc.CallOption) (*InsertEventTypeResponse, error) {
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
out := new(InsertEventTypeResponse)
err := c.cc.Invoke(ctx, StateStoreService_InsertEventType_FullMethodName, in, out, cOpts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *stateStoreServiceClient) UpdateEventType(ctx context.Context, in *UpdateEventTypeRequest, opts ...grpc.CallOption) (*UpdateEventTypeResponse, error) {
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
out := new(UpdateEventTypeResponse)
err := c.cc.Invoke(ctx, StateStoreService_UpdateEventType_FullMethodName, in, out, cOpts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *stateStoreServiceClient) DeleteEventType(ctx context.Context, in *DeleteEventTypeRequest, opts ...grpc.CallOption) (*DeleteEventTypeResponse, error) {
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
out := new(DeleteEventTypeResponse)
err := c.cc.Invoke(ctx, StateStoreService_DeleteEventType_FullMethodName, in, out, cOpts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *stateStoreServiceClient) ListEventTypes(ctx context.Context, in *ListEventTypesRequest, opts ...grpc.CallOption) (*ListEventTypesResponse, error) {
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
out := new(ListEventTypesResponse)
err := c.cc.Invoke(ctx, StateStoreService_ListEventTypes_FullMethodName, in, out, cOpts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *stateStoreServiceClient) InsertBinding(ctx context.Context, in *InsertBindingRequest, opts ...grpc.CallOption) (*InsertBindingResponse, error) {
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
out := new(InsertBindingResponse)
@@ -1038,6 +1088,12 @@ type StateStoreServiceServer interface {
ListMappings(context.Context, *ListMappingsRequest) (*ListMappingsResponse, error)
UpdateMapping(context.Context, *UpdateMappingRequest) (*UpdateMappingResponse, error)
DeleteMapping(context.Context, *DeleteMappingRequest) (*DeleteMappingResponse, error)
// EventType (docs/prds/event-automation.md, "Event types"). Insert and
// Update refuse an overlapping or malformed type.
InsertEventType(context.Context, *InsertEventTypeRequest) (*InsertEventTypeResponse, error)
UpdateEventType(context.Context, *UpdateEventTypeRequest) (*UpdateEventTypeResponse, error)
DeleteEventType(context.Context, *DeleteEventTypeRequest) (*DeleteEventTypeResponse, error)
ListEventTypes(context.Context, *ListEventTypesRequest) (*ListEventTypesResponse, error)
// Binding
InsertBinding(context.Context, *InsertBindingRequest) (*InsertBindingResponse, error)
GetBinding(context.Context, *GetBindingRequest) (*GetBindingResponse, error)
@@ -1233,6 +1289,18 @@ func (UnimplementedStateStoreServiceServer) UpdateMapping(context.Context, *Upda
func (UnimplementedStateStoreServiceServer) DeleteMapping(context.Context, *DeleteMappingRequest) (*DeleteMappingResponse, error) {
return nil, status.Error(codes.Unimplemented, "method DeleteMapping not implemented")
}
func (UnimplementedStateStoreServiceServer) InsertEventType(context.Context, *InsertEventTypeRequest) (*InsertEventTypeResponse, error) {
return nil, status.Error(codes.Unimplemented, "method InsertEventType not implemented")
}
func (UnimplementedStateStoreServiceServer) UpdateEventType(context.Context, *UpdateEventTypeRequest) (*UpdateEventTypeResponse, error) {
return nil, status.Error(codes.Unimplemented, "method UpdateEventType not implemented")
}
func (UnimplementedStateStoreServiceServer) DeleteEventType(context.Context, *DeleteEventTypeRequest) (*DeleteEventTypeResponse, error) {
return nil, status.Error(codes.Unimplemented, "method DeleteEventType not implemented")
}
func (UnimplementedStateStoreServiceServer) ListEventTypes(context.Context, *ListEventTypesRequest) (*ListEventTypesResponse, error) {
return nil, status.Error(codes.Unimplemented, "method ListEventTypes not implemented")
}
func (UnimplementedStateStoreServiceServer) InsertBinding(context.Context, *InsertBindingRequest) (*InsertBindingResponse, error) {
return nil, status.Error(codes.Unimplemented, "method InsertBinding not implemented")
}
@@ -2251,6 +2319,78 @@ func _StateStoreService_DeleteMapping_Handler(srv interface{}, ctx context.Conte
return interceptor(ctx, in, info, handler)
}
func _StateStoreService_InsertEventType_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(InsertEventTypeRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(StateStoreServiceServer).InsertEventType(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: StateStoreService_InsertEventType_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(StateStoreServiceServer).InsertEventType(ctx, req.(*InsertEventTypeRequest))
}
return interceptor(ctx, in, info, handler)
}
func _StateStoreService_UpdateEventType_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(UpdateEventTypeRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(StateStoreServiceServer).UpdateEventType(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: StateStoreService_UpdateEventType_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(StateStoreServiceServer).UpdateEventType(ctx, req.(*UpdateEventTypeRequest))
}
return interceptor(ctx, in, info, handler)
}
func _StateStoreService_DeleteEventType_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(DeleteEventTypeRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(StateStoreServiceServer).DeleteEventType(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: StateStoreService_DeleteEventType_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(StateStoreServiceServer).DeleteEventType(ctx, req.(*DeleteEventTypeRequest))
}
return interceptor(ctx, in, info, handler)
}
func _StateStoreService_ListEventTypes_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ListEventTypesRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(StateStoreServiceServer).ListEventTypes(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: StateStoreService_ListEventTypes_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(StateStoreServiceServer).ListEventTypes(ctx, req.(*ListEventTypesRequest))
}
return interceptor(ctx, in, info, handler)
}
func _StateStoreService_InsertBinding_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(InsertBindingRequest)
if err := dec(in); err != nil {
@@ -2693,6 +2833,22 @@ var StateStoreService_ServiceDesc = grpc.ServiceDesc{
MethodName: "DeleteMapping",
Handler: _StateStoreService_DeleteMapping_Handler,
},
{
MethodName: "InsertEventType",
Handler: _StateStoreService_InsertEventType_Handler,
},
{
MethodName: "UpdateEventType",
Handler: _StateStoreService_UpdateEventType_Handler,
},
{
MethodName: "DeleteEventType",
Handler: _StateStoreService_DeleteEventType_Handler,
},
{
MethodName: "ListEventTypes",
Handler: _StateStoreService_ListEventTypes_Handler,
},
{
MethodName: "InsertBinding",
Handler: _StateStoreService_InsertBinding_Handler,
@@ -0,0 +1,116 @@
package staterpc
import (
"context"
"errors"
"net"
"reflect"
"testing"
"time"
"google.golang.org/grpc"
"google.golang.org/grpc/credentials/insecure"
"google.golang.org/grpc/test/bufconn"
"github.com/samcharles93/archie-core/internal/domain/eventtype"
"github.com/samcharles93/archie-core/internal/domain/storecontract"
)
// fakeEventTypes records what crossed the wire and answers with err.
type fakeEventTypes struct {
saved eventtype.EventType
list []eventtype.EventType
err error
}
func (f *fakeEventTypes) InsertEventType(_ context.Context, t eventtype.EventType) (string, error) {
f.saved = t
return "et-1", f.err
}
func (f *fakeEventTypes) UpdateEventType(_ context.Context, t eventtype.EventType) error {
f.saved = t
return f.err
}
func (f *fakeEventTypes) DeleteEventType(context.Context, string) error { return f.err }
func (f *fakeEventTypes) ListEventTypes(context.Context) ([]eventtype.EventType, error) {
return f.list, f.err
}
func remoteEventTypes(t *testing.T, store storecontract.EventTypeStore) *Client {
t.Helper()
listener := bufconn.Listen(1 << 20)
server := grpc.NewServer()
RegisterServer(server, Deps{EventTypes: store})
go func() { _ = server.Serve(listener) }()
t.Cleanup(func() { server.Stop(); _ = listener.Close() })
conn, err := grpc.NewClient("passthrough:///state",
grpc.WithTransportCredentials(insecure.NewCredentials()),
grpc.WithContextDialer(func(ctx context.Context, _ string) (net.Conn, error) { return listener.DialContext(ctx) }))
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _ = conn.Close() })
return NewClient(conn)
}
func TestEventTypeRoundTrip(t *testing.T) {
stamp := time.Date(2026, 9, 24, 9, 0, 0, 0, time.UTC)
want := eventtype.EventType{
ID: "et-1", Source: "gh", Name: "pull_request",
Rule: eventtype.Rule{
Headers: []eventtype.HeaderCondition{{Name: "x-github-event", Value: "pull_request"}},
Payload: []eventtype.PayloadCondition{{Path: "action", Op: eventtype.OpEquals, Value: "opened"}},
},
Schema: map[string]eventtype.ValueType{"action": eventtype.TypeString},
CreatedAt: stamp, UpdatedAt: stamp.Add(time.Hour),
}
fake := &fakeEventTypes{list: []eventtype.EventType{want}}
c := remoteEventTypes(t, fake)
got, err := c.ListEventTypes(t.Context())
if err != nil || len(got) != 1 || !reflect.DeepEqual(got[0], want) {
t.Fatalf("ListEventTypes() = %+v (err %v), want %+v", got, err, want)
}
id, err := c.InsertEventType(t.Context(), want)
if err != nil || id != "et-1" {
t.Fatalf("InsertEventType() = %q, %v", id, err)
}
if !reflect.DeepEqual(fake.saved, want) {
t.Fatalf("server received %+v, want %+v", fake.saved, want)
}
}
func TestEventTypeErrorsCrossTheWire(t *testing.T) {
tests := []struct {
name string
err error
}{
{"overlap", eventtype.ErrOverlap},
{"invalid", eventtype.ErrInvalid},
{"not found", storecontract.ErrEventTypeNotFound},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
c := remoteEventTypes(t, &fakeEventTypes{err: tt.err})
if _, err := c.InsertEventType(t.Context(), eventtype.EventType{}); !errors.Is(err, tt.err) {
t.Errorf("InsertEventType error = %v, want %v", err, tt.err)
}
if err := c.UpdateEventType(t.Context(), eventtype.EventType{}); !errors.Is(err, tt.err) {
t.Errorf("UpdateEventType error = %v, want %v", err, tt.err)
}
if err := c.DeleteEventType(t.Context(), "x"); !errors.Is(err, tt.err) {
t.Errorf("DeleteEventType error = %v, want %v", err, tt.err)
}
})
}
}
func TestCapturedEventCarriesEventType(t *testing.T) {
in := storecontract.CapturedEvent{ID: "c", Source: "gh", EventType: "et-1"}
if got := capturedEventValue(capturedEventProto(in)); got.EventType != "et-1" {
t.Fatalf("EventType after round trip = %q, want et-1", got.EventType)
}
}
@@ -0,0 +1,144 @@
package staterpc
import (
"context"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
pb "github.com/samcharles93/archie-core/internal/contracts/state/v1"
"github.com/samcharles93/archie-core/internal/domain/eventtype"
"github.com/samcharles93/archie-core/internal/domain/storecontract"
)
var (
_ storecontract.EventTypeStore = (*Client)(nil)
errEventTypeUnavailable = status.Error(codes.Unavailable, "event type store unavailable")
)
func eventTypeProto(t eventtype.EventType) *pb.EventType {
out := &pb.EventType{
Id: t.ID, Source: t.Source, Name: t.Name,
CreatedAt: timestamp(t.CreatedAt), UpdatedAt: timestamp(t.UpdatedAt),
}
for _, h := range t.Rule.Headers {
out.HeaderConditions = append(out.HeaderConditions, &pb.EventTypeHeaderCondition{Name: h.Name, Value: h.Value})
}
for _, p := range t.Rule.Payload {
out.PayloadConditions = append(out.PayloadConditions, &pb.EventTypePayloadCondition{Path: p.Path, Op: string(p.Op), Value: p.Value})
}
if len(t.Schema) > 0 {
out.Schema = make(map[string]string, len(t.Schema))
for path, vt := range t.Schema {
out.Schema[path] = string(vt)
}
}
return out
}
func eventTypeValue(t *pb.EventType) eventtype.EventType {
if t == nil {
return eventtype.EventType{}
}
out := eventtype.EventType{
ID: t.Id, Source: t.Source, Name: t.Name,
CreatedAt: timeValue(t.CreatedAt), UpdatedAt: timeValue(t.UpdatedAt),
}
for _, h := range t.HeaderConditions {
out.Rule.Headers = append(out.Rule.Headers, eventtype.HeaderCondition{Name: h.Name, Value: h.Value})
}
for _, p := range t.PayloadConditions {
out.Rule.Payload = append(out.Rule.Payload, eventtype.PayloadCondition{Path: p.Path, Op: eventtype.Operator(p.Op), Value: p.Value})
}
if len(t.Schema) > 0 {
out.Schema = make(map[string]eventtype.ValueType, len(t.Schema))
for path, vt := range t.Schema {
out.Schema[path] = eventtype.ValueType(vt)
}
}
return out
}
// Server
func (s *server) eventTypes() (storecontract.EventTypeStore, error) {
if s.deps.EventTypes == nil {
return nil, errEventTypeUnavailable
}
return s.deps.EventTypes, nil
}
func (s *server) InsertEventType(ctx context.Context, r *pb.InsertEventTypeRequest) (*pb.InsertEventTypeResponse, error) {
et, err := s.eventTypes()
if err != nil {
return nil, err
}
id, err := et.InsertEventType(ctx, eventTypeValue(r.EventType))
if err != nil {
return nil, s.logErr("InsertEventType", err)
}
return &pb.InsertEventTypeResponse{Id: id}, nil
}
func (s *server) UpdateEventType(ctx context.Context, r *pb.UpdateEventTypeRequest) (*pb.UpdateEventTypeResponse, error) {
et, err := s.eventTypes()
if err != nil {
return nil, err
}
if err := et.UpdateEventType(ctx, eventTypeValue(r.EventType)); err != nil {
return nil, s.logErr("UpdateEventType", err)
}
return &pb.UpdateEventTypeResponse{}, nil
}
func (s *server) DeleteEventType(ctx context.Context, r *pb.DeleteEventTypeRequest) (*pb.DeleteEventTypeResponse, error) {
et, err := s.eventTypes()
if err != nil {
return nil, err
}
if err := et.DeleteEventType(ctx, r.Id); err != nil {
return nil, s.logErr("DeleteEventType", err)
}
return &pb.DeleteEventTypeResponse{}, nil
}
func (s *server) ListEventTypes(ctx context.Context, _ *pb.ListEventTypesRequest) (*pb.ListEventTypesResponse, error) {
et, err := s.eventTypes()
if err != nil {
return nil, err
}
types, err := et.ListEventTypes(ctx)
if err != nil {
return nil, s.logErr("ListEventTypes", err)
}
return &pb.ListEventTypesResponse{EventTypes: mapValues(types, eventTypeProto)}, nil
}
// Client
func (c *Client) InsertEventType(ctx context.Context, t eventtype.EventType) (string, error) {
r, err := c.client.InsertEventType(ctx, &pb.InsertEventTypeRequest{EventType: eventTypeProto(t)})
if err != nil {
return "", unmapError(err)
}
return r.Id, nil
}
func (c *Client) UpdateEventType(ctx context.Context, t eventtype.EventType) error {
_, err := c.client.UpdateEventType(ctx, &pb.UpdateEventTypeRequest{EventType: eventTypeProto(t)})
return unmapError(err)
}
func (c *Client) DeleteEventType(ctx context.Context, id string) error {
_, err := c.client.DeleteEventType(ctx, &pb.DeleteEventTypeRequest{Id: id})
return unmapError(err)
}
func (c *Client) ListEventTypes(ctx context.Context) ([]eventtype.EventType, error) {
r, err := c.client.ListEventTypes(ctx, &pb.ListEventTypesRequest{})
if err != nil {
return nil, unmapError(err)
}
return mapValues(r.EventTypes, eventTypeValue), nil
}
@@ -76,6 +76,7 @@ type Deps struct {
ChannelStatus storecontract.ChannelStatusStore
ApplyStatus storecontract.ApplyStatusStore
Mappings storecontract.MappingStore
EventTypes storecontract.EventTypeStore
Bindings storecontract.BindingStore
BindingDispatcher storecontract.BindingDispatcher
BindingTaskCreator storecontract.BindingTaskCreator
+33 -29
View File
@@ -13,6 +13,7 @@ import (
pb "github.com/samcharles93/archie-core/internal/contracts/state/v1"
"github.com/samcharles93/archie-core/internal/domain/binding"
"github.com/samcharles93/archie-core/internal/domain/eventtype"
"github.com/samcharles93/archie-core/internal/domain/mapping"
"github.com/samcharles93/archie-core/internal/domain/storecontract"
"github.com/samcharles93/archie-core/internal/domain/workflow/task"
@@ -149,7 +150,7 @@ func capturedEventProto(c storecontract.CapturedEvent) *pb.CapturedEvent {
return &pb.CapturedEvent{
Id: c.ID, ReceivedAt: timestamp(c.ReceivedAt), Source: c.Source,
RemoteAddr: c.RemoteAddr, ContentType: c.ContentType, Headers: c.Headers,
Body: c.Body, Authenticated: c.Authenticated,
Body: c.Body, Authenticated: c.Authenticated, EventType: c.EventType,
}
}
@@ -160,7 +161,7 @@ func capturedEventValue(c *pb.CapturedEvent) storecontract.CapturedEvent {
return storecontract.CapturedEvent{
ID: c.Id, ReceivedAt: timeValue(c.ReceivedAt), Source: c.Source,
RemoteAddr: c.RemoteAddr, ContentType: c.ContentType, Headers: c.Headers,
Body: c.Body, Authenticated: c.Authenticated,
Body: c.Body, Authenticated: c.Authenticated, EventType: c.EventType,
}
}
@@ -267,6 +268,9 @@ const (
msgStaleTransition = "stale transition"
msgBindingNotFound = "binding not found"
msgMappingNotFound = "mapping not found"
msgEventTypeNotFound = "event type not found"
msgEventTypeOverlap = "event type overlap"
msgEventTypeInvalid = "event type invalid"
msgBindingOverlap = "binding overlap"
msgBindingTransition = "binding transition rejected"
msgAlreadyDispatched = "already dispatched"
@@ -309,6 +313,12 @@ func mapError(err error) error {
return status.Error(codes.NotFound, msgBindingNotFound)
case errors.Is(err, storecontract.ErrMappingNotFound):
return status.Error(codes.NotFound, msgMappingNotFound)
case errors.Is(err, storecontract.ErrEventTypeNotFound):
return status.Error(codes.NotFound, msgEventTypeNotFound)
case errors.Is(err, eventtype.ErrOverlap):
return status.Error(codes.FailedPrecondition, msgEventTypeOverlap)
case errors.Is(err, eventtype.ErrInvalid):
return status.Error(codes.InvalidArgument, msgEventTypeInvalid)
case errors.Is(err, storecontract.ErrBindingOverlap):
return status.Error(codes.FailedPrecondition, msgBindingOverlap)
case errors.Is(err, storecontract.ErrBindingTransition):
@@ -364,33 +374,27 @@ func unmapError(err error) error {
// are part of the wire contract (§4). A code whose message is not one this
// package defines returns nil, so the caller falls back to the wrapped form.
func sentinelForStatus(st *status.Status) error {
switch st.Code() {
case codes.FailedPrecondition:
switch st.Message() {
case msgStaleTransition:
return storecontract.ErrStaleTransition
case msgBindingOverlap:
return storecontract.ErrBindingOverlap
case msgBindingTransition:
return storecontract.ErrBindingTransition
}
case codes.NotFound:
switch st.Message() {
case msgBindingNotFound:
return storecontract.ErrBindingNotFound
case msgMappingNotFound:
return storecontract.ErrMappingNotFound
}
case codes.AlreadyExists:
if st.Message() == msgAlreadyDispatched {
return storecontract.ErrAlreadyDispatched
}
case codes.Unavailable:
if st.Message() == msgTaskLogsUnavailable {
return logging.ErrTaskLogsUnavailable
}
}
return nil
return wireSentinels[wireStatus{st.Code(), st.Message()}]
}
type wireStatus struct {
code codes.Code
message string
}
// wireSentinels is the (code, canonical message) to sentinel table
// sentinelForStatus reads.
var wireSentinels = map[wireStatus]error{
{codes.FailedPrecondition, msgStaleTransition}: storecontract.ErrStaleTransition,
{codes.FailedPrecondition, msgBindingOverlap}: storecontract.ErrBindingOverlap,
{codes.FailedPrecondition, msgBindingTransition}: storecontract.ErrBindingTransition,
{codes.FailedPrecondition, msgEventTypeOverlap}: eventtype.ErrOverlap,
{codes.InvalidArgument, msgEventTypeInvalid}: eventtype.ErrInvalid,
{codes.NotFound, msgBindingNotFound}: storecontract.ErrBindingNotFound,
{codes.NotFound, msgMappingNotFound}: storecontract.ErrMappingNotFound,
{codes.NotFound, msgEventTypeNotFound}: storecontract.ErrEventTypeNotFound,
{codes.AlreadyExists, msgAlreadyDispatched}: storecontract.ErrAlreadyDispatched,
{codes.Unavailable, msgTaskLogsUnavailable}: logging.ErrTaskLogsUnavailable,
}
// configSnapshotProto and configSnapshotValue carry the dashboard's
+48
View File
@@ -120,6 +120,13 @@ service StateStoreService {
rpc UpdateMapping(UpdateMappingRequest) returns (UpdateMappingResponse);
rpc DeleteMapping(DeleteMappingRequest) returns (DeleteMappingResponse);
// EventType (docs/prds/event-automation.md, "Event types"). Insert and
// Update refuse an overlapping or malformed type.
rpc InsertEventType(InsertEventTypeRequest) returns (InsertEventTypeResponse);
rpc UpdateEventType(UpdateEventTypeRequest) returns (UpdateEventTypeResponse);
rpc DeleteEventType(DeleteEventTypeRequest) returns (DeleteEventTypeResponse);
rpc ListEventTypes(ListEventTypesRequest) returns (ListEventTypesResponse);
// Binding
rpc InsertBinding(InsertBindingRequest) returns (InsertBindingResponse);
rpc GetBinding(GetBindingRequest) returns (GetBindingResponse);
@@ -308,6 +315,35 @@ message CapturedEvent {
string headers = 6;
string body = 7;
bool authenticated = 8;
// event_type is the ID of the event type the capture was identified as on
// arrival; empty is unidentified.
string event_type = 9;
}
// EventTypeHeaderCondition mirrors internal/domain/eventtype.HeaderCondition.
message EventTypeHeaderCondition {
string name = 1;
string value = 2;
}
// EventTypePayloadCondition mirrors internal/domain/eventtype.PayloadCondition.
message EventTypePayloadCondition {
string path = 1;
string op = 2;
string value = 3;
}
// EventType mirrors internal/domain/eventtype.EventType. header_conditions and
// payload_conditions are its rule; schema maps each payload path to its type.
message EventType {
string id = 1;
string source = 2;
string name = 3;
repeated EventTypeHeaderCondition header_conditions = 4;
repeated EventTypePayloadCondition payload_conditions = 5;
map<string, string> schema = 6;
google.protobuf.Timestamp created_at = 7;
google.protobuf.Timestamp updated_at = 8;
}
// MappingField mirrors internal/domain/mapping.Field.
@@ -688,6 +724,18 @@ message UpdateMappingResponse {}
message DeleteMappingRequest { string id = 1; }
message DeleteMappingResponse {}
message InsertEventTypeRequest { EventType event_type = 1; }
message InsertEventTypeResponse { string id = 1; }
message UpdateEventTypeRequest { EventType event_type = 1; }
message UpdateEventTypeResponse {}
message DeleteEventTypeRequest { string id = 1; }
message DeleteEventTypeResponse {}
message ListEventTypesRequest {}
message ListEventTypesResponse { repeated EventType event_types = 1; }
message InsertBindingRequest { Binding binding = 1; }
message InsertBindingResponse { string id = 1; }