dtoro
e074f04bdf
Problem: the hexagonal-architecture plan (plans/2026-08-15-hexagonal-
architecture.md) needs its foundation — an accepted ADR, the target
directory tree, and machine-checked dependency rules — before any
service extraction starts. Also folds the four outstanding review
findings (F3.1/F5/F6/F7) into the plan: ObservationService owns the
bounded probe-concurrency contract (scheduler.go:133), Phase 9 gates
ExecutionService+PolicyService ≥ 90% with a gating-matrix test,
per-phase abort criteria, and the §3.2 internal/config note.
Change:
- docs/adr/0016-hexagonal-ports-adapters.md records context, decision,
and consequences of the ports & adapters migration.
- internal/domain → internal/core/domain (mechanical import rewrite,
20 files), new internal/core/{ports,app}, internal/adapters trees
with package docs.
- .golangci.yml: depguard rules for §3.1 (core purity, no agent-client
tech in core, nomos isolation — the nomos rules self-activate when
internal/nomos exists in Phase 8). Config migrated to golangci-lint
v2 format so it loads at all (the v1 config errored under v2, masked
by CI's advisory continue-on-error). Verified depguard fires on a
planted openai-go import in internal/core/app.
- CONTRIBUTING.md layout section now shows the core/adapters tree.
Risk: import path churn is mechanical and tests pass unchanged; the
lint config migration surfaces the pre-existing 400-issue baseline
(advisory in CI, unchanged policy) — new/moved packages lint clean.
Verification: go vet ./..., make test (race, core/domain at 100%
coverage), make generate-check, golangci-lint on internal/core/... and
internal/adapters/... — 0 issues; depguard violation probe confirmed.
72 lines
2.5 KiB
Go
72 lines
2.5 KiB
Go
package httpapi
|
|
|
|
import (
|
|
"encoding/json"
|
|
"errors"
|
|
"log/slog"
|
|
"net/http"
|
|
|
|
"github.com/dtoro/oikos/internal/core/domain"
|
|
"github.com/dtoro/oikos/internal/httpapi/gen"
|
|
)
|
|
|
|
// errNotImplemented marks endpoints stubbed for later phases.
|
|
var errNotImplemented = errors.New("not implemented yet")
|
|
|
|
// statusFor maps domain sentinel errors to HTTP status codes (plan SG11).
|
|
func statusFor(err error) (status int, title string) {
|
|
switch {
|
|
case errors.Is(err, domain.ErrNotFound):
|
|
return http.StatusNotFound, "not found"
|
|
case errors.Is(err, domain.ErrInvalidTransition):
|
|
return http.StatusConflict, "invalid lifecycle transition"
|
|
case errors.Is(err, domain.ErrConflict), errors.Is(err, domain.ErrAlreadyExists):
|
|
return http.StatusConflict, "conflict"
|
|
case errors.Is(err, domain.ErrCardinality):
|
|
return http.StatusConflict, "relationship cardinality violation"
|
|
case errors.Is(err, domain.ErrAbstractType), errors.Is(err, domain.ErrInvalidEdge):
|
|
return http.StatusUnprocessableEntity, "ontology validation failed"
|
|
case errors.Is(err, domain.ErrInvalidInput):
|
|
return http.StatusBadRequest, "invalid input"
|
|
case errors.Is(err, domain.ErrApprovalRequired):
|
|
return http.StatusForbidden, "operator approval required"
|
|
case errors.Is(err, domain.ErrAutonomyBlocked):
|
|
return http.StatusForbidden, "autonomy policy blocks this action"
|
|
case errors.Is(err, domain.ErrCircuitOpen):
|
|
return http.StatusServiceUnavailable, "circuit breaker open"
|
|
case errors.Is(err, errNotImplemented):
|
|
return http.StatusNotImplemented, "not implemented"
|
|
default:
|
|
return http.StatusInternalServerError, "internal error"
|
|
}
|
|
}
|
|
|
|
// writeProblem writes an RFC 9457 problem+json response.
|
|
func writeProblem(w http.ResponseWriter, r *http.Request, status int, title, detail string) {
|
|
instance := r.URL.Path
|
|
p := gen.Problem{
|
|
Status: status,
|
|
Title: title,
|
|
Instance: &instance,
|
|
}
|
|
if detail != "" {
|
|
p.Detail = &detail
|
|
}
|
|
w.Header().Set("Content-Type", "application/problem+json")
|
|
w.WriteHeader(status)
|
|
json.NewEncoder(w).Encode(p)
|
|
}
|
|
|
|
// writeProblemFromErr maps an error to a problem+json response. Internal
|
|
// error details are logged server-side, never leaked to clients.
|
|
func writeProblemFromErr(w http.ResponseWriter, r *http.Request, err error) {
|
|
status, title := statusFor(err)
|
|
detail := ""
|
|
if status != http.StatusInternalServerError {
|
|
detail = err.Error()
|
|
} else {
|
|
slog.Error("internal error", "method", r.Method, "path", r.URL.Path, "error", err)
|
|
}
|
|
writeProblem(w, r, status, title, detail)
|
|
}
|