package webui import ( "errors" "log/slog" "net/http" "github.com/samcharles93/archie-core/internal/domain/eventtype" "github.com/samcharles93/archie-core/internal/domain/storecontract" ) // eventTypesAPI owns the /api/event-types routes. eventTypes and captures stay // optional: the list answers {"enabled": false} with no store, and proposals // are empty without captures, as before. type eventTypesAPI struct { eventTypes storecontract.EventTypeStore captures storecontract.CaptureStore log *slog.Logger authorize func(http.ResponseWriter, *http.Request) bool } func newEventTypesAPI(s *Server) *eventTypesAPI { return &eventTypesAPI{ eventTypes: s.EventTypes, captures: s.Captures, log: s.Log, authorize: s.authorizeTaskMutation, } } func (a *eventTypesAPI) register(mux *http.ServeMux) { mux.HandleFunc("GET /api/event-types", a.handleEventTypes) mux.HandleFunc("POST /api/event-types", a.handleEventTypeCreate) mux.HandleFunc("PUT /api/event-types/{id}", a.handleEventTypeUpdate) mux.HandleFunc("DELETE /api/event-types/{id}", a.handleEventTypeDelete) } // proposalScanLimit bounds how many recent captures are grouped into // proposals on one read. const proposalScanLimit = 500 // eventTypeExample is a pasted (or sampled) event: headers by name and the // raw body. The type's schema is inferred from it. type eventTypeExample struct { Headers map[string]string `json:"headers"` Body string `json:"body"` } // eventTypeRequest is POST /api/event-types. Rule, when absent, is the one // inferred from the example. type eventTypeRequest struct { Source string `json:"source"` Name string `json:"name"` Rule *eventtype.Rule `json:"rule"` Example eventTypeExample `json:"example"` } // eventTypeUpdate is PUT /api/event-types/{id}: the name and rule are the // editable parts of a type. type eventTypeUpdate struct { Name string `json:"name"` Rule eventtype.Rule `json:"rule"` } // handleEventTypes lists the named event types and the proposals grouped from // recent captures that were unidentified on arrival and still match no type. func (a *eventTypesAPI) handleEventTypes(w http.ResponseWriter, r *http.Request) { if a.eventTypes == nil { writeJSON(w, map[string]any{"enabled": false, "event_types": []any{}, "proposals": []any{}}) return } types, err := a.eventTypes.ListEventTypes(r.Context()) if err != nil { a.log.ErrorContext(r.Context(), "list event types", "err", err) http.Error(w, "list event types failed", http.StatusInternalServerError) return } proposals := []eventtype.Proposal{} if a.captures != nil { captures, err := a.captures.ListCaptures(r.Context(), "", proposalScanLimit) if err != nil { a.log.ErrorContext(r.Context(), "list captures for proposals", "err", err) http.Error(w, "list captures failed", http.StatusInternalServerError) return } proposals = append(proposals, eventtype.Propose(unmatchedCaptures(types, captures))...) } listed := []eventtype.EventType{} for _, t := range types { if listedIn(r, t.WorkspaceID) { listed = append(listed, t) } } writeJSON(w, map[string]any{"enabled": true, "event_types": listed, "proposals": proposals}) } // unmatchedCaptures keeps the captures that were unidentified on arrival and // that no current type would identify either. A capture a newer type now // matches stays unidentified (it was never dispatched) but is no longer // proposed. func unmatchedCaptures(types []eventtype.EventType, captures []storecontract.CapturedEvent) []eventtype.Capture { var out []eventtype.Capture for _, c := range captures { if c.EventType != "" { continue } sample := eventtype.Sample{Headers: eventtype.ParseHeaders(c.Headers), Body: []byte(c.Body)} if _, ok := eventtype.Identify(types, c.Source, sample); ok { continue } out = append(out, eventtype.Capture{ID: c.ID, Source: c.Source, ReceivedAt: c.ReceivedAt, Sample: sample}) } return out } func (a *eventTypesAPI) handleEventTypeCreate(w http.ResponseWriter, r *http.Request) { if !a.authorize(w, r) { return } if a.eventTypes == nil { http.Error(w, "event types not configured", http.StatusServiceUnavailable) return } req, ok := decodeBody[eventTypeRequest](w, r) if !ok { return } t := eventtype.FromExample(req.Source, req.Name, eventtype.Sample{ Headers: req.Example.Headers, Body: []byte(req.Example.Body), }) if req.Rule != nil { t.Rule = *req.Rule } id, err := a.eventTypes.InsertEventType(r.Context(), t) if err != nil { a.writeEventTypeError(w, "create", err) return } t.ID = id w.WriteHeader(http.StatusCreated) writeJSON(w, t) } func (a *eventTypesAPI) handleEventTypeUpdate(w http.ResponseWriter, r *http.Request) { if !a.authorize(w, r) { return } if a.eventTypes == nil { http.Error(w, "event types not configured", http.StatusServiceUnavailable) return } req, ok := decodeBody[eventTypeUpdate](w, r) if !ok { return } // Source is not editable: the store validates against the stored one. t := eventtype.EventType{ID: r.PathValue("id"), Name: req.Name, Rule: req.Rule} if err := a.eventTypes.UpdateEventType(r.Context(), t); err != nil { a.writeEventTypeError(w, "update", err) return } writeJSON(w, map[string]string{"id": t.ID}) } func (a *eventTypesAPI) handleEventTypeDelete(w http.ResponseWriter, r *http.Request) { if !a.authorize(w, r) { return } if a.eventTypes == nil { http.Error(w, "event types not configured", http.StatusServiceUnavailable) return } if err := a.eventTypes.DeleteEventType(r.Context(), r.PathValue("id")); err != nil { a.writeEventTypeError(w, "delete", err) return } w.WriteHeader(http.StatusNoContent) } func (a *eventTypesAPI) writeEventTypeError(w http.ResponseWriter, action string, err error) { switch { case errors.Is(err, eventtype.ErrOverlap): http.Error(w, "this rule can match events another type on the source already matches", http.StatusConflict) case errors.Is(err, eventtype.ErrInvalid): http.Error(w, err.Error(), http.StatusBadRequest) case errors.Is(err, storecontract.ErrEventTypeNotFound): http.Error(w, "event type not found", http.StatusNotFound) default: a.log.Error(action+" event type", "err", err) http.Error(w, action+" event type failed", http.StatusInternalServerError) } }