Files
sam 66862a1bab
Quality / check (push) Successful in 4m2s
deploy / gate (push) Successful in 4m39s
deploy / archied-image (push) Successful in 2m51s
deploy / agent-image (push) Successful in 11s
deploy / dist-zip (push) Skipped
refactor(webui): extract the orgs resource module (#1778)
2026-11-03 08:28:36 +11:00

472 lines
14 KiB
Go

package webui
import (
"cmp"
"encoding/json"
"errors"
"net/http"
"strings"
"github.com/samcharles93/archie-core/internal/domain/access"
"github.com/samcharles93/archie-core/internal/domain/identity"
"github.com/samcharles93/archie-core/internal/domain/org"
)
// orgsAPI owns the /api/orgs routes except selecting the current org, which
// sets a cookie and stays with the session code. memberIssuer is the provider
// the add-member route binds subjects under.
type orgsAPI struct {
orgs org.API
identities identity.Repository
subjects identity.SubjectBinding
memberIssuer func(*http.Request) string
}
func newOrgsAPI(s *Server) *orgsAPI {
return &orgsAPI{orgs: s.Orgs, identities: s.Identities, subjects: s.Subjects, memberIssuer: s.memberIssuer}
}
func (a *orgsAPI) register(mux *http.ServeMux) {
mux.HandleFunc("GET /api/orgs", a.handleOrgsList)
mux.HandleFunc("POST /api/orgs", a.handleOrgCreate)
mux.HandleFunc("GET /api/orgs/{id}", a.handleOrgGet)
mux.HandleFunc("GET /api/orgs/{id}/workspaces", a.handleOrgWorkspacesList)
mux.HandleFunc("POST /api/orgs/{id}/workspaces", a.handleOrgWorkspaceCreate)
mux.HandleFunc("GET /api/orgs/{id}/members", a.handleOrgMembersList)
mux.HandleFunc("POST /api/orgs/{id}/members", a.handleOrgMemberAdd)
mux.HandleFunc("PUT /api/orgs/{id}/members/{identity}", a.handleOrgMemberSet)
mux.HandleFunc("DELETE /api/orgs/{id}/members/{identity}", a.handleOrgMemberRemove)
mux.HandleFunc("GET /api/orgs/{id}/agents", a.handleOrgAgentsList)
mux.HandleFunc("PUT /api/orgs/{id}/agents/{identity}", instanceOnly(a.handleOrgAgentAssign))
}
// orgReady answers Unavailable when this process hosts no org store.
func (a *orgsAPI) orgReady(w http.ResponseWriter) bool {
if a.orgs == nil {
http.Error(w, "orgs unavailable", http.StatusServiceUnavailable)
return false
}
return true
}
// orgInPath resolves the route's {id}: the caller's own org, or any org for
// an instance admin. Another tenant reads as not found rather than leaking.
func (a *orgsAPI) orgInPath(w http.ResponseWriter, r *http.Request) (org.OrgID, bool) {
id := org.OrgID(r.PathValue("id"))
if id != policyOrg(r) && !instanceOwner(r) {
http.Error(w, "org not found", http.StatusNotFound)
return "", false
}
return id, true
}
// handleOrgsList lists every org to an instance admin and the caller's own
// and member orgs to anyone else, naming the org the caller acts in and the
// ones it may select.
func (a *orgsAPI) handleOrgsList(w http.ResponseWriter, r *http.Request) {
if !a.orgReady(w) {
return
}
values, err := a.orgs.ListOrgs(r.Context())
if err != nil {
writeOrgError(w, err)
return
}
caller, admin := policyOrg(r), instanceOwner(r)
principal, _ := access.PrincipalFromContext(r.Context())
out, member := []org.Org{}, []org.OrgID{}
for _, value := range values {
if value.ID == caller || admin || principal.Member(value.ID) {
out = append(out, value)
}
if value.ID == caller || principal.Member(value.ID) {
member = append(member, value.ID)
}
}
writeJSON(w, map[string]any{"orgs": out, "current": caller, "instance_admin": admin, "member_orgs": member})
}
// handleOrgCreate creates an org with its default workspace and first owner.
// Only an instance admin may.
func (a *orgsAPI) handleOrgCreate(w http.ResponseWriter, r *http.Request) {
if !a.orgReady(w) {
return
}
if !instanceOwner(r) {
http.Error(w, "only an instance admin creates orgs", http.StatusForbidden)
return
}
creator, ok := a.orgs.(org.Creator)
if !ok {
http.Error(w, "org creation unavailable", http.StatusServiceUnavailable)
return
}
var request struct {
ID string `json:"id"`
Name string `json:"name"`
OwnerIdentity string `json:"owner_identity"`
}
if err := json.NewDecoder(http.MaxBytesReader(w, r.Body, 16<<10)).Decode(&request); err != nil {
http.Error(w, "invalid org: "+err.Error(), http.StatusBadRequest)
return
}
created, err := creator.CreateOrg(r.Context(), org.Org{ID: org.OrgID(request.ID), Name: request.Name}, identity.IdentityID(request.OwnerIdentity))
if err != nil {
writeOrgError(w, err)
return
}
w.WriteHeader(http.StatusCreated)
writeJSON(w, map[string]any{"org": created})
}
func (a *orgsAPI) handleOrgGet(w http.ResponseWriter, r *http.Request) {
if !a.orgReady(w) {
return
}
id, ok := a.orgInPath(w, r)
if !ok {
return
}
value, err := a.orgs.GetOrg(r.Context(), id)
if err != nil {
writeOrgError(w, err)
return
}
writeJSON(w, map[string]any{"org": value})
}
func (a *orgsAPI) handleOrgWorkspacesList(w http.ResponseWriter, r *http.Request) {
if !a.orgReady(w) {
return
}
id, ok := a.orgInPath(w, r)
if !ok {
return
}
values, err := a.orgs.ListWorkspaces(r.Context(), id)
if err != nil {
writeOrgError(w, err)
return
}
if values == nil {
values = []org.Workspace{}
}
writeJSON(w, map[string]any{"workspaces": values})
}
func (a *orgsAPI) handleOrgWorkspaceCreate(w http.ResponseWriter, r *http.Request) {
if !a.orgReady(w) {
return
}
id, ok := a.orgInPath(w, r)
if !ok {
return
}
var request struct {
ID string `json:"id"`
Name string `json:"name"`
Environment string `json:"environment"`
}
if err := json.NewDecoder(http.MaxBytesReader(w, r.Body, 16<<10)).Decode(&request); err != nil {
http.Error(w, "invalid workspace: "+err.Error(), http.StatusBadRequest)
return
}
value, err := a.orgs.CreateWorkspace(r.Context(), org.Workspace{
ID: org.WorkspaceID(request.ID), OrgID: id, Name: request.Name, Environment: request.Environment,
})
if err != nil {
writeOrgError(w, err)
return
}
w.WriteHeader(http.StatusCreated)
writeJSON(w, map[string]any{"workspace": value})
}
func (a *orgsAPI) handleOrgMembersList(w http.ResponseWriter, r *http.Request) {
if !a.orgReady(w) {
return
}
id, ok := a.orgInPath(w, r)
if !ok {
return
}
values, err := a.orgs.ListMembers(r.Context(), id)
if err != nil {
writeOrgError(w, err)
return
}
if values == nil {
values = []org.Member{}
}
writeJSON(w, map[string]any{"members": values})
}
// handleOrgMemberSet grants or moves one identity's role in the caller's org,
// or in one workspace when the body names one.
func (a *orgsAPI) handleOrgMemberSet(w http.ResponseWriter, r *http.Request) {
if !a.orgReady(w) {
return
}
id, ok := a.orgInPath(w, r)
if !ok {
return
}
var request struct {
Role string `json:"role"`
Workspace string `json:"workspace"`
}
if err := json.NewDecoder(http.MaxBytesReader(w, r.Body, 16<<10)).Decode(&request); err != nil {
http.Error(w, "invalid membership: "+err.Error(), http.StatusBadRequest)
return
}
membership := org.Membership{
IdentityID: identity.IdentityID(r.PathValue("identity")),
OrgID: id,
WorkspaceID: org.WorkspaceID(request.Workspace),
Role: org.Role(request.Role),
}
if !a.mayChangeMembership(w, r, membership, membership.Role) {
return
}
if err := a.orgs.EnsureMembership(r.Context(), membership); err != nil {
writeOrgError(w, err)
return
}
writeJSON(w, map[string]any{"membership": membership})
}
// handleOrgMemberAdd adds a person by the subject their provider asserts or by
// their email, creating the identity and binding it so that person's next
// sign-in resolves to it with this role. An already-bound subject keeps its
// identity and only gains the membership.
func (a *orgsAPI) handleOrgMemberAdd(w http.ResponseWriter, r *http.Request) {
if !a.orgReady(w) {
return
}
id, ok := a.orgInPath(w, r)
if !ok {
return
}
if a.subjects == nil || a.identities == nil || a.memberIssuer(r) == "" {
http.Error(w, "adding a person needs a configured identity provider", http.StatusServiceUnavailable)
return
}
request, bound, name, ok := a.decodeMemberAdd(w, r)
if !ok {
return
}
existing, err := a.subjects.ResolveSubject(r.Context(), bound)
if err != nil && !errors.Is(err, identity.ErrNotFound) {
writeIdentityError(w, err)
return
}
unbound := err != nil
membership := org.Membership{
IdentityID: existing.ID, OrgID: id,
WorkspaceID: org.WorkspaceID(request.Workspace), Role: org.Role(request.Role),
}
if unbound {
if membership.IdentityID, err = randomIdentityID(); err != nil {
http.Error(w, "cannot create identity ID", http.StatusInternalServerError)
return
}
}
if !a.mayChangeMembership(w, r, membership, membership.Role) {
return
}
if unbound && !a.createBoundIdentity(w, r, membership.IdentityID, name, bound) {
return
}
if err := a.orgs.EnsureMembership(r.Context(), membership); err != nil {
writeOrgError(w, err)
return
}
w.WriteHeader(http.StatusCreated)
writeJSON(w, map[string]any{"membership": membership})
}
type memberAddRequest struct {
Subject string `json:"subject"`
Email string `json:"email"`
DisplayName string `json:"display_name"`
Role string `json:"role"`
Workspace string `json:"workspace"`
}
// decodeMemberAdd reads and validates an add-member body, returning the
// provider subject it names and the display name to give a new identity. It
// has written the error when ok is false.
func (a *orgsAPI) decodeMemberAdd(w http.ResponseWriter, r *http.Request) (request memberAddRequest, bound identity.Subject, name string, ok bool) {
request, ok = decodeBody[memberAddRequest](w, r)
if !ok {
return
}
name = strings.TrimSpace(request.DisplayName)
subject, email := strings.TrimSpace(request.Subject), strings.TrimSpace(request.Email)
switch {
case (subject == "") == (email == ""):
http.Error(w, "give either a subject or an email", http.StatusBadRequest)
return request, bound, name, false
case subject != "":
bound, name = identity.Subject{Issuer: a.memberIssuer(r), Subject: subject}, cmp.Or(name, subject)
default:
bound, name = identity.EmailSubject(a.memberIssuer(r), email), cmp.Or(name, email)
}
if err := org.Role(request.Role).Validate(); err != nil {
writeOrgError(w, err)
return request, bound, name, false
}
return request, bound, name, true
}
// createBoundIdentity makes a user identity and binds subject to it, having
// written the error and returned false when either step fails.
func (a *orgsAPI) createBoundIdentity(w http.ResponseWriter, r *http.Request, id identity.IdentityID, name string, subject identity.Subject) bool {
audit, err := webAudit(r.Context())
if err != nil {
http.Error(w, "cannot create request ID", http.StatusInternalServerError)
return false
}
value, err := identity.New(id, identity.KindUser, name)
if err == nil {
_, err = a.identities.Create(r.Context(), value, audit)
}
if err == nil {
err = a.subjects.BindSubject(r.Context(), id, subject, audit)
}
if err != nil {
writeIdentityError(w, err)
return false
}
return true
}
func (a *orgsAPI) handleOrgMemberRemove(w http.ResponseWriter, r *http.Request) {
if !a.orgReady(w) {
return
}
id, ok := a.orgInPath(w, r)
if !ok {
return
}
membership := org.Membership{
IdentityID: identity.IdentityID(r.PathValue("identity")),
OrgID: id,
WorkspaceID: org.WorkspaceID(r.URL.Query().Get("workspace")),
}
if !a.mayChangeMembership(w, r, membership, "") {
return
}
if err := a.orgs.RemoveMembership(r.Context(), membership); err != nil {
writeOrgError(w, err)
return
}
w.WriteHeader(http.StatusNoContent)
}
func (a *orgsAPI) handleOrgAgentAssign(w http.ResponseWriter, r *http.Request) {
if !a.orgReady(w) {
return
}
id, ok := a.orgInPath(w, r)
if !ok {
return
}
err := a.orgs.AssignAgent(r.Context(), org.AgentAssignment{
IdentityID: identity.IdentityID(r.PathValue("identity")), OrgID: id,
})
if err != nil {
writeOrgError(w, err)
return
}
writeJSON(w, map[string]any{"assigned": true})
}
// writeOrgError maps the org domain's errors, and their gRPC statuses, onto
// HTTP. The remote-client path keeps the status code through unmapError's
// wrapping, so writeControlPlaneError names the same code the store sent.
// mayChangeMembership refuses, having written the error, a change that grants
// the owner role or alters an owner's membership unless the caller is an owner
// of the org: member management is an admin's grant, and without this an
// admin could make themselves owner -- and an owner of org-sys owns the
// instance.
func (a *orgsAPI) mayChangeMembership(w http.ResponseWriter, r *http.Request, target org.Membership, grant org.Role) bool {
principal, ok := access.PrincipalFromContext(r.Context())
if !ok {
principal = access.SharedTokenOwner()
}
if principal.Role("") == org.RoleOwner {
return true
}
touchesOwner := grant == org.RoleOwner
if !touchesOwner {
members, err := a.orgs.ListMembers(r.Context(), target.OrgID)
if err != nil {
writeOrgError(w, err)
return false
}
for _, m := range members {
if m.IdentityID == target.IdentityID && m.WorkspaceID == target.WorkspaceID && m.Role == org.RoleOwner {
touchesOwner = true
}
}
}
if touchesOwner {
http.Error(w, "only an owner may grant or change the owner role", http.StatusForbidden)
return false
}
return true
}
func writeOrgError(w http.ResponseWriter, err error) {
switch {
case errors.Is(err, org.ErrInvalidRole), errors.Is(err, org.ErrInvalidOrg),
errors.Is(err, org.ErrInvalidMembership), errors.Is(err, org.ErrInvalidWorkspace),
errors.Is(err, org.ErrInvalidAssignment):
http.Error(w, err.Error(), http.StatusBadRequest)
case errors.Is(err, org.ErrOrgNotFound):
http.Error(w, err.Error(), http.StatusNotFound)
case errors.Is(err, org.ErrOrgExists), errors.Is(err, org.ErrWorkspaceExists), errors.Is(err, org.ErrMembershipExists),
errors.Is(err, org.ErrLastOwner):
http.Error(w, err.Error(), http.StatusConflict)
default:
writeControlPlaneError(w, err)
}
}
func (a *orgsAPI) handleOrgAgentsList(w http.ResponseWriter, r *http.Request) {
if !a.orgReady(w) {
return
}
id, ok := a.orgInPath(w, r)
if !ok {
return
}
reader, ok := a.orgs.(org.AgentAssignments)
if !ok {
http.Error(w, "agent assignments unavailable", http.StatusServiceUnavailable)
return
}
values, err := reader.ListOrgAgents(r.Context(), id)
if err != nil {
writeOrgError(w, err)
return
}
agents := make([]identity.Identity, 0, len(values))
if a.identities == nil {
http.Error(w, "identity authority unavailable", http.StatusServiceUnavailable)
return
}
for _, assignment := range values {
value, err := a.identities.Get(r.Context(), assignment.IdentityID)
if err != nil {
writeIdentityError(w, err)
return
}
if value.Kind.Agent() {
agents = append(agents, value)
}
}
writeJSON(w, map[string]any{"agents": agents})
}