feat(governance): serve members, access policies and denials (#2023)

This commit is contained in:
sam committed 2026-11-22 02:43:06 +11:00
1 parent 81dcc7d94e
commit 5004e8b40b
16 files changed
+1531 -14

No files matched your search

+536
View File
@@ -1,5 +1,26 @@
components:
schemas:
AddMemberInputBody:
additionalProperties: false
properties:
display_name:
description: Name shown for a new person; defaults to the email or subject
type: string
email:
description: The person's email; give this or a subject
type: string
role:
description: The role to hold
type: string
subject:
description: The subject the identity provider asserts; give this or an email
type: string
workspace:
description: Scope the membership to this workspace; empty is organisation-wide
type: string
required:
- role
type: object
AnswerInputBody:
additionalProperties: false
properties:
@@ -1286,6 +1307,60 @@ components:
- id
- token
type: object
GovernanceDenial:
additionalProperties: false
properties:
action:
type: string
at:
format: date-time
type: string
count:
format: int64
type: integer
kind:
type: string
level:
type: string
org:
type: string
policies:
items:
type: string
type:
- array
- "null"
principal:
type: string
resource:
type: string
required:
- principal
- org
- action
- kind
- resource
- level
- policies
- at
- count
type: object
GovernanceDenialsBody:
additionalProperties: false
properties:
denials:
items:
$ref: "#/components/schemas/GovernanceDenial"
type:
- array
- "null"
more:
description: Whether older refusals match beyond this page
type: boolean
required:
- denials
- more
type: object
GovernanceIdentity:
additionalProperties: false
properties:
@@ -1327,6 +1402,67 @@ components:
- url
- expires_at
type: object
GovernanceMember:
additionalProperties: false
properties:
display_name:
type: string
identity_id:
type: string
kind:
type: string
last_sign_in:
format: date-time
type: string
role:
type: string
status:
type: string
workspace_id:
type: string
required:
- identity_id
- kind
- display_name
- role
- status
type: object
GovernanceMembersBody:
additionalProperties: false
properties:
members:
items:
$ref: "#/components/schemas/GovernanceMember"
type:
- array
- "null"
required:
- members
type: object
GovernanceMembership:
additionalProperties: false
properties:
identity_id:
type: string
org_id:
type: string
role:
type: string
workspace_id:
type: string
required:
- identity_id
- org_id
- role
type: object
GovernanceMembershipBody:
additionalProperties: false
properties:
membership:
$ref: "#/components/schemas/GovernanceMembership"
required:
- membership
type: object
GovernanceModel:
additionalProperties: false
properties:
@@ -1505,6 +1641,58 @@ components:
- expires_at
- last_used_at
type: object
GovernancePoliciesBody:
additionalProperties: false
properties:
policies:
items:
$ref: "#/components/schemas/GovernancePolicy"
type:
- array
- "null"
shipped:
description: IDs of the policies Archie ships, which a reset restores
items:
type: string
type:
- array
- "null"
required:
- policies
- shipped
type: object
GovernancePolicy:
additionalProperties: false
properties:
id:
type: string
level:
type: string
object_id:
type: string
object_kind:
type: string
org_id:
type: string
text:
type: string
workspace_id:
type: string
required:
- id
- level
- text
type: object
GovernancePolicyVersionBody:
additionalProperties: false
properties:
version:
description: The policy chain's new revision
format: int64
type: integer
required:
- version
type: object
GovernanceRegistration:
additionalProperties: false
properties:
@@ -2855,6 +3043,18 @@ components:
required:
- text
type: object
SetMemberInputBody:
additionalProperties: false
properties:
role:
description: The role to hold
type: string
workspace:
description: Scope the membership to this workspace; empty is organisation-wide
type: string
required:
- role
type: object
SignInInputBody:
additionalProperties: false
properties:
@@ -2946,6 +3146,147 @@ info:
version: dev
openapi: 3.1.0
paths:
/api/access/denials:
get:
operationId: list-access-denials
parameters:
- description: Only refusals of this identity
explode: false
in: query
name: principal
schema:
description: Only refusals of this identity
type: string
- description: Only refusals of this action
explode: false
in: query
name: action
schema:
description: Only refusals of this action
type: string
- description: Only refusals on this resource kind
explode: false
in: query
name: kind
schema:
description: Only refusals on this resource kind
type: string
- description: Only refusals first recorded at or after this time
explode: false
in: query
name: since
schema:
description: Only refusals first recorded at or after this time
format: date-time
type: string
- description: Only refusals first recorded before this time
explode: false
in: query
name: until
schema:
description: Only refusals first recorded before this time
format: date-time
type: string
- description: How many refusals to return
explode: false
in: query
name: limit
schema:
default: 100
description: How many refusals to return
format: int64
maximum: 1000
minimum: 1
type: integer
- description: How many of the newest matching refusals to skip
explode: false
in: query
name: offset
schema:
default: 0
description: How many of the newest matching refusals to skip
format: int64
minimum: 0
type: integer
responses:
"200":
content:
application/json:
schema:
$ref: "#/components/schemas/GovernanceDenialsBody"
description: OK
default:
content:
application/problem+json:
schema:
$ref: "#/components/schemas/ErrorModel"
description: Error
summary: List the requests access policies refused
tags:
- Access
/api/access/policies:
delete:
operationId: delete-access-policy
requestBody:
content:
application/json:
schema:
$ref: "#/components/schemas/GovernancePolicy"
required: true
responses:
"204":
description: No Content
default:
content:
application/problem+json:
schema:
$ref: "#/components/schemas/ErrorModel"
description: Error
summary: Delete an access policy
tags:
- Access
get:
operationId: list-access-policies
responses:
"200":
content:
application/json:
schema:
$ref: "#/components/schemas/GovernancePoliciesBody"
description: OK
default:
content:
application/problem+json:
schema:
$ref: "#/components/schemas/ErrorModel"
description: Error
summary: List the organisation's access policies
tags:
- Access
put:
operationId: put-access-policy
requestBody:
content:
application/json:
schema:
$ref: "#/components/schemas/GovernancePolicy"
required: true
responses:
"200":
content:
application/json:
schema:
$ref: "#/components/schemas/GovernancePolicyVersionBody"
description: OK
default:
content:
application/problem+json:
schema:
$ref: "#/components/schemas/ErrorModel"
description: Error
summary: Create or replace an access policy
tags:
- Access
/api/account/channels:
get:
operationId: list-channel-links
@@ -5084,6 +5425,201 @@ paths:
summary: List the organisation's name changes
tags:
- Organisations
/api/orgs/{id}/members:
get:
operationId: list-org-members
parameters:
- description: Organisation ID
in: path
name: id
required: true
schema:
description: Organisation ID
type: string
responses:
"200":
content:
application/json:
schema:
$ref: "#/components/schemas/GovernanceMembersBody"
description: OK
default:
content:
application/problem+json:
schema:
$ref: "#/components/schemas/ErrorModel"
description: Error
summary: List an organisation's members
tags:
- Access
post:
operationId: add-org-member
parameters:
- description: Organisation ID
in: path
name: id
required: true
schema:
description: Organisation ID
type: string
requestBody:
content:
application/json:
schema:
$ref: "#/components/schemas/AddMemberInputBody"
required: true
responses:
"201":
content:
application/json:
schema:
$ref: "#/components/schemas/GovernanceMembershipBody"
description: Created
default:
content:
application/problem+json:
schema:
$ref: "#/components/schemas/ErrorModel"
description: Error
summary: Add a person by email or provider subject
tags:
- Access
/api/orgs/{id}/members/{identity}:
delete:
operationId: remove-org-member
parameters:
- description: Organisation ID
in: path
name: id
required: true
schema:
description: Organisation ID
type: string
- description: Identity ID of the member
in: path
name: identity
required: true
schema:
description: Identity ID of the member
type: string
- description: Remove the membership scoped to this workspace; empty removes the organisation-wide one
explode: false
in: query
name: workspace
schema:
description: Remove the membership scoped to this workspace; empty removes the organisation-wide one
type: string
responses:
"204":
description: No Content
default:
content:
application/problem+json:
schema:
$ref: "#/components/schemas/ErrorModel"
description: Error
summary: Remove a membership
tags:
- Access
put:
operationId: set-org-member
parameters:
- description: Organisation ID
in: path
name: id
required: true
schema:
description: Organisation ID
type: string
- description: Identity ID of the member
in: path
name: identity
required: true
schema:
description: Identity ID of the member
type: string
requestBody:
content:
application/json:
schema:
$ref: "#/components/schemas/SetMemberInputBody"
required: true
responses:
"200":
content:
application/json:
schema:
$ref: "#/components/schemas/GovernanceMembershipBody"
description: OK
default:
content:
application/problem+json:
schema:
$ref: "#/components/schemas/ErrorModel"
description: Error
summary: Give a member a role
tags:
- Access
/api/orgs/{id}/members/{identity}/reactivate:
post:
operationId: reactivate-org-member
parameters:
- description: Organisation ID
in: path
name: id
required: true
schema:
description: Organisation ID
type: string
- description: Identity ID of the member
in: path
name: identity
required: true
schema:
description: Identity ID of the member
type: string
responses:
"204":
description: No Content
default:
content:
application/problem+json:
schema:
$ref: "#/components/schemas/ErrorModel"
description: Error
summary: Reactivate a member's identity
tags:
- Access
/api/orgs/{id}/members/{identity}/suspend:
post:
operationId: suspend-org-member
parameters:
- description: Organisation ID
in: path
name: id
required: true
schema:
description: Organisation ID
type: string
- description: Identity ID of the member
in: path
name: identity
required: true
schema:
description: Identity ID of the member
type: string
responses:
"204":
description: No Content
default:
content:
application/problem+json:
schema:
$ref: "#/components/schemas/ErrorModel"
description: Error
summary: Suspend a member's identity
tags:
- Access
/api/orgs/{id}/workspaces:
get:
operationId: list-org-workspaces
+1
View File
@@ -44,6 +44,7 @@ func (m apiModules) register(api huma.API) {
m.settings.Register(api)
m.settings.RegisterAccounts(api)
m.settings.RegisterOrganisations(api)
m.settings.RegisterAccess(api)
m.conns.Register(api)
m.system.Register(api)
m.tell.Register(api)
@@ -0,0 +1,15 @@
-- +goose Up
-- The members page shows when each person last signed in. Sessions expire and
-- are purged, so the time is kept on the account.
ALTER TABLE governance.accounts ADD COLUMN last_sign_in_at timestamptz;
UPDATE governance.accounts a
SET last_sign_in_at = s.last
FROM (
SELECT identity_id, max(issued_at) AS last
FROM governance.account_sessions GROUP BY identity_id
) s
WHERE s.identity_id = a.identity_id;
-- +goose Down
ALTER TABLE governance.accounts DROP COLUMN last_sign_in_at;
+173
View File
@@ -0,0 +1,173 @@
package governance
import (
"context"
"errors"
"log/slog"
"net/http"
"time"
"github.com/danielgtaylor/huma/v2"
"github.com/samcharles93/archie-core/internal/platform/httpapi"
)
// policyAdmin is the stored policy chain the routes edit. PutPolicy and
// DeletePolicy refuse a change that leaves an org with nobody able to manage
// policies.
type policyAdmin interface {
ListPolicies(context.Context) ([]Policy, error)
PutPolicy(context.Context, Policy) (int64, error)
DeletePolicy(context.Context, Policy) error
}
// denialSearch reads the recorded refusals.
type denialSearch interface {
SearchDenials(context.Context, DenialQuery) ([]Denial, error)
}
// accessAPI serves the access policies and the record of refused requests.
type accessAPI struct {
policies policyAdmin
denials denialSearch
log *slog.Logger
}
func (m *Module) access() *accessAPI {
return &accessAPI{policies: m, denials: m, log: m.log}
}
type policiesBody struct {
Policies []Policy `json:"policies"`
Shipped []string `json:"shipped" doc:"IDs of the policies Archie ships, which a reset restores"`
}
type policyVersionBody struct {
Version int64 `json:"version" doc:"The policy chain's new revision"`
}
type policyInput struct {
Body Policy
}
type denialsInput struct {
Principal string `query:"principal" doc:"Only refusals of this identity"`
Action string `query:"action" doc:"Only refusals of this action"`
Kind string `query:"kind" doc:"Only refusals on this resource kind"`
Since time.Time `query:"since" doc:"Only refusals first recorded at or after this time"`
Until time.Time `query:"until" doc:"Only refusals first recorded before this time"`
Limit int `query:"limit" default:"100" minimum:"1" maximum:"1000" doc:"How many refusals to return"`
Offset int `query:"offset" default:"0" minimum:"0" doc:"How many of the newest matching refusals to skip"`
}
type denialsBody struct {
Denials []Denial `json:"denials"`
More bool `json:"more" doc:"Whether older refusals match beyond this page"`
}
func (m *Module) registerPolicies(api huma.API, op func(id, method, path, summary string, status int) huma.Operation) {
a := m.access()
httpapi.Register(api, httpapi.Authorized(ActionRead, KindPolicy), op("list-access-policies", http.MethodGet, "/api/access/policies", "List the organisation's access policies", 0), a.listPolicies)
httpapi.Register(api, httpapi.Authorized(ActionManagePolicies, KindPolicy), op("put-access-policy", http.MethodPut, "/api/access/policies", "Create or replace an access policy", 0), a.putPolicy)
httpapi.Register(api, httpapi.Authorized(ActionManagePolicies, KindPolicy), op("delete-access-policy", http.MethodDelete, "/api/access/policies", "Delete an access policy", http.StatusNoContent), a.deletePolicy)
}
func (m *Module) registerDenials(api huma.API, op func(id, method, path, summary string, status int) huma.Operation) {
a := m.access()
httpapi.Register(api, httpapi.Authorized(ActionReadAudit, KindAudit), op("list-access-denials", http.MethodGet, "/api/access/denials", "List the requests access policies refused", 0), a.listDenials)
}
func (a *accessAPI) listPolicies(ctx context.Context, _ *struct{}) (*httpapi.Reply[policiesBody], error) {
p, err := caller(ctx)
if err != nil {
return nil, err
}
stored, err := a.policies.ListPolicies(ctx)
if err != nil {
return nil, a.failed(ctx, "read the policies", err)
}
out := make([]Policy, 0, len(stored))
for _, s := range stored {
if s.Level == LevelInstance && p.InstanceAdmin() || s.Level != LevelInstance && s.OrgID == p.Org {
out = append(out, s)
}
}
return httpapi.OK(policiesBody{Policies: out, Shipped: shippedOrgPolicyIDs()}), nil
}
func (a *accessAPI) putPolicy(ctx context.Context, in *policyInput) (*httpapi.Reply[policyVersionBody], error) {
value, err := a.scoped(ctx, in.Body)
if err != nil {
return nil, err
}
if err := NewEngine(nil).Validate(value); err != nil {
return nil, a.failed(ctx, "save the policy", err)
}
version, err := a.policies.PutPolicy(ctx, value)
if err != nil {
return nil, a.failed(ctx, "save the policy", err)
}
return httpapi.OK(policyVersionBody{Version: version}), nil
}
func (a *accessAPI) deletePolicy(ctx context.Context, in *policyInput) (*struct{}, error) {
value, err := a.scoped(ctx, in.Body)
if err != nil {
return nil, err
}
if err := a.policies.DeletePolicy(ctx, value); err != nil {
return nil, a.failed(ctx, "delete the policy", err)
}
return nil, nil
}
// scoped pins a policy to the caller's organisation, since no request field
// chooses where a policy applies. Instance policies span every organisation, so
// only an instance administrator edits them.
func (a *accessAPI) scoped(ctx context.Context, value Policy) (Policy, error) {
p, err := caller(ctx)
if err != nil {
return Policy{}, err
}
if value.Level == LevelInstance {
if !p.InstanceAdmin() {
return Policy{}, huma.Error403Forbidden("Only an instance owner can change instance policies.")
}
value.OrgID, value.WorkspaceID, value.ObjectKind, value.ObjectID = "", "", "", ""
return value, nil
}
value.OrgID = p.Org
return value, nil
}
func (a *accessAPI) listDenials(ctx context.Context, in *denialsInput) (*httpapi.Reply[denialsBody], error) {
p, err := caller(ctx)
if err != nil {
return nil, err
}
found, err := a.denials.SearchDenials(ctx, DenialQuery{
Org: p.Org, Principal: IdentityID(in.Principal), Action: Action(in.Action), Kind: ResourceKind(in.Kind),
Since: in.Since, Until: in.Until, Limit: in.Limit + 1, Offset: in.Offset,
})
if err != nil {
return nil, a.failed(ctx, "read the denials", err)
}
more := len(found) > in.Limit
return httpapi.OK(denialsBody{Denials: found[:min(len(found), in.Limit)], More: more}), nil
}
// failed answers a policy failure with the status a person can act on: the
// Cedar error for a policy that does not compile, a conflict for a change that
// would lock every owner out.
func (a *accessAPI) failed(ctx context.Context, what string, err error) error {
switch {
case errors.Is(err, ErrPolicyLockout):
return huma.Error409Conflict("That change would leave no owner able to manage policies.")
case errors.Is(err, ErrPolicyNotFound):
return huma.Error404NotFound("That policy does not exist.")
case errors.Is(err, ErrInvalidPolicy), errors.Is(err, ErrInvalidLevel), errors.Is(err, ErrPolicyInvalidText):
return huma.Error400BadRequest(err.Error())
}
a.log.ErrorContext(ctx, "access operation failed", "operation", what, "err", err)
return huma.Error503ServiceUnavailable("Couldn't " + what + ". Try again shortly.")
}
+91
View File
@@ -0,0 +1,91 @@
package governance
import (
"context"
"log/slog"
"net/http"
"slices"
"strings"
"testing"
)
// fakePolicies applies the same validation and lockout rule as the module's
// store-backed methods, against policies held in memory.
type fakePolicies struct {
stored []Policy
puts []Policy
org []Principal
}
func (f *fakePolicies) ListPolicies(context.Context) ([]Policy, error) { return f.stored, nil }
func (f *fakePolicies) PutPolicy(ctx context.Context, p Policy) (int64, error) {
err := CheckPolicyChange(ctx, f.stored, func(cur []Policy) []Policy {
return append(slices.DeleteFunc(cur, func(c Policy) bool { return samePolicy(c, p) }), p)
}, []Org{{ID: DefaultOrgID}}, func(context.Context, OrgID) ([]Principal, error) { return f.org, nil })
if err != nil {
return 0, err
}
f.puts = append(f.puts, p)
return 1, nil
}
func (f *fakePolicies) DeletePolicy(context.Context, Policy) error { return nil }
func policyRoutes(f *fakePolicies) *accessAPI {
return &accessAPI{policies: f, log: slog.New(slog.DiscardHandler)}
}
// TestPolicyEdits guards what a policy edit may do: an invalid policy is
// refused with the Cedar error and never stored, a change that leaves no owner
// able to manage policies is refused, and a policy lands in the caller's own
// organisation, with instance policies reserved for the instance owner.
func TestPolicyEdits(t *testing.T) {
owner := actor("root", RoleOwner)
otherOrgOwner := Principal{
IdentityID: "pat", Kind: KindUser, Org: "acme",
Memberships: []Membership{{IdentityID: "pat", OrgID: "acme", Role: RoleOwner}},
}
withOwner := func() *fakePolicies {
return &fakePolicies{stored: ShippedOrgPolicies(DefaultOrgID), org: []Principal{owner}}
}
policy := func(level Level, id, text string) Policy {
return Policy{ID: id, Level: level, OrgID: "elsewhere", Text: text}
}
const harmless = `permit(principal, action == Archie::Action::"read", resource);`
tests := []struct {
name string
by Principal
policy Policy
want int
wantError string
stored bool
wantOrg OrgID
}{
{name: "a valid policy", by: owner, policy: policy(LevelOrg, "p", harmless), want: http.StatusOK, stored: true, wantOrg: DefaultOrgID},
{name: "text that does not compile", by: owner, policy: policy(LevelOrg, "p", `permit(principal, action == Archie::Action::"nope", resource);`), want: http.StatusBadRequest, wantError: "nope"},
{name: "no policy text", by: owner, policy: policy(LevelOrg, "p", " "), want: http.StatusBadRequest, wantError: "no text"},
{name: "a forbid that locks owners out", by: owner, policy: policy(LevelOrg, "lock", `forbid(principal, action == Archie::Action::"manage_policies", resource);`), want: http.StatusConflict},
{name: "an instance policy by an instance owner", by: owner, policy: policy(LevelInstance, "i", `permit(principal, action, resource);`), want: http.StatusOK, stored: true},
{name: "an instance policy by another organisation's owner", by: otherOrgOwner, policy: policy(LevelInstance, "i", harmless), want: http.StatusForbidden},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
f := withOwner()
_, err := policyRoutes(f).putPolicy(WithPrincipal(t.Context(), tt.by), &policyInput{Body: tt.policy})
if got := status(t, err); got != tt.want {
t.Fatalf("status = %d (%v), want %d", got, err, tt.want)
}
if tt.wantError != "" && !strings.Contains(err.Error(), tt.wantError) {
t.Fatalf("error %q does not carry the Cedar error %q", err, tt.wantError)
}
if stored := len(f.puts) > 0; stored != tt.stored {
t.Fatalf("stored = %v, want %v", stored, tt.stored)
}
if tt.wantOrg != "" && f.puts[0].OrgID != tt.wantOrg {
t.Fatalf("policy stored for org %q, want %q", f.puts[0].OrgID, tt.wantOrg)
}
})
}
}
+5 -1
View File
@@ -615,10 +615,14 @@ func (m *Module) capabilities(ctx context.Context, _ *struct{}) (*httpapi.Reply[
"home", "tasks", "work_requests", "logs", "skills", "curators", "channels",
"captures", "mappings", "bindings", "workflow_editor", "extension_catalogue", "model_aliases",
"system_status", "task_execution", "organisations", "tools", "plugins", "container_runtime", "agent_profiles",
"org_members", "org_agents", "org_policies", "org_denials", "org_audit", "org_usage", "org_config",
"org_agents", "org_audit", "org_usage", "org_config",
} {
sections[name] = false
}
// The access pages are offered to those the policy chain lets use them.
sections["org_members"] = m.mayUse(ctx, p, ActionManageMembers, KindMember)
sections["org_policies"] = m.mayUse(ctx, p, ActionManagePolicies, KindPolicy)
sections["org_denials"] = m.mayUse(ctx, p, ActionReadAudit, KindAudit)
// Every member reads the organisation they belong to and its workspaces.
sections["org"] = signedIn
sections["org_workspaces"] = signedIn
+14
View File
@@ -97,3 +97,17 @@ func (m *Module) Allow(ctx context.Context, action, kind string) error {
}
return httpapi.ErrUnavailable
}
// mayUse reports whether p's grants cover action on a kind of resource in its
// org. It asks the chain without recording a denial, since a dashboard probing
// which pages to offer has not been refused anything.
func (m *Module) mayUse(ctx context.Context, p Principal, action Action, kind ResourceKind) bool {
chain := m.authz()
if r, ok := chain.(recording); ok {
chain = r.Authorizer
}
if chain == nil || p.IdentityID == "" {
return false
}
return chain.Authorize(ctx, p, action, Resource{Kind: kind, Org: p.Org}, AccessContext{Time: time.Now()}).Allowed
}
+5 -3
View File
@@ -61,6 +61,11 @@ func buildEntities(p Principal, r Resource) cedar.EntityMap {
attrs := types.RecordMap{
"org": types.String(resOrg),
"kind": types.String(string(r.Kind)),
// Always present: a policy that compares the state of a resource that
// has none would otherwise error and never match, so a shipped rule
// such as "not an owner's membership" would refuse the route guard's
// request, which names no state.
"state": types.String(r.State),
}
if r.Workspace != "" {
wsUID := types.NewEntityUID(EntityTypeWorkspace, types.String(r.Workspace))
@@ -78,9 +83,6 @@ func buildEntities(p Principal, r Resource) cedar.EntityMap {
if r.Owner != "" {
attrs["owner"] = types.String(string(r.Owner))
}
if r.State != "" {
attrs["state"] = types.String(r.State)
}
entities[resUID] = cedar.Entity{
UID: resUID,
Parents: cedar.NewEntityUIDSet(parents...),
@@ -306,6 +306,43 @@ func (s *Store) ListDenials(ctx context.Context, orgID string, limit int) ([]Den
return out, nil
}
// DenialFilter narrows SearchDenials. A zero field matches everything.
type DenialFilter struct {
OrgID string
Principal string
Action string
ResourceKind string
Since, Until time.Time
Limit int
Offset int
}
// SearchDenials returns an org's denials matching f, newest first.
func (s *Store) SearchDenials(ctx context.Context, f DenialFilter) ([]DenialRow, error) {
var out []DenialRow
if err := s.db.SelectContext(ctx, &out, `
SELECT id, org_id, principal, action, resource_kind, resource_id, level, policies, minute_at, count, created_at, updated_at
FROM governance.access_denials
WHERE org_id = $1
AND ($2 = '' OR principal = $2)
AND ($3 = '' OR action = $3)
AND ($4 = '' OR resource_kind = $4)
AND ($5::timestamptz IS NULL OR created_at >= $5)
AND ($6::timestamptz IS NULL OR created_at < $6)
ORDER BY id DESC LIMIT $7 OFFSET $8`,
f.OrgID, f.Principal, f.Action, f.ResourceKind, nullTime(f.Since), nullTime(f.Until), f.Limit, f.Offset); err != nil {
return nil, fmt.Errorf("search denials: %w", err)
}
return out, nil
}
func nullTime(t time.Time) *time.Time {
if t.IsZero() {
return nil
}
return &t
}
// PruneDenials deletes up to batch denial rows created before cutoff.
func (s *Store) PruneDenials(ctx context.Context, cutoff time.Time, batch int) (int64, error) {
res, err := s.db.ExecContext(ctx, `
@@ -206,7 +206,8 @@ func recordFailedLogin(ctx context.Context, tx *sqlx.Tx, acc AccountRow) error {
func openSignInSessionTx(ctx context.Context, tx *sqlx.Tx, identityID, tokenHash string, expires time.Time) error {
if _, err := tx.ExecContext(ctx, `
UPDATE governance.accounts SET failed_attempts = 0, locked_until = NULL WHERE identity_id = $1`,
UPDATE governance.accounts SET failed_attempts = 0, locked_until = NULL, last_sign_in_at = now()
WHERE identity_id = $1`,
identityID); err != nil {
return err
}
@@ -278,6 +279,10 @@ func (s *Store) OpenAccountSession(ctx context.Context, identityID, tokenHash st
tokenHash, identityID, expires); err != nil {
return IdentityRow{}, err
}
if _, err := s.db.ExecContext(ctx, `
UPDATE governance.accounts SET last_sign_in_at = now() WHERE identity_id = $1`, identityID); err != nil {
return IdentityRow{}, err
}
return row, nil
}
+4 -1
View File
@@ -61,6 +61,8 @@ type MemberRow struct {
DisplayName string `db:"display_name"`
WorkspaceID sql.NullString `db:"workspace_id"`
Role string `db:"role"`
Lifecycle string `db:"lifecycle"`
LastSignIn sql.NullTime `db:"last_sign_in_at"`
}
// AgentAssignmentRow is an agent's owning org in governance.org_agents.
@@ -300,9 +302,10 @@ func (s *Store) EnsureMembership(ctx context.Context, m MembershipRow) error {
func (s *Store) ListMembers(ctx context.Context, orgID string) ([]MemberRow, error) {
var out []MemberRow
if err := s.db.SelectContext(ctx, &out, `
SELECT m.identity_id, i.kind, i.display_name, m.workspace_id, m.role
SELECT m.identity_id, i.kind, i.display_name, m.workspace_id, m.role, i.lifecycle, a.last_sign_in_at
FROM governance.memberships m
JOIN governance.identities i ON i.id = m.identity_id
LEFT JOIN governance.accounts a ON a.identity_id = m.identity_id
WHERE m.org_id = $1
ORDER BY m.created_at, m.identity_id, m.workspace_id`, orgID); err != nil {
return nil, fmt.Errorf("list members: %w", err)
+382
View File
@@ -0,0 +1,382 @@
package governance
import (
"context"
"crypto/rand"
"errors"
"log/slog"
"net/http"
"strings"
"time"
"github.com/danielgtaylor/huma/v2"
"github.com/samcharles93/archie-core/internal/platform/httpapi"
)
// memberDirectory is what the members routes read and change.
type memberDirectory interface {
ListMembers(context.Context, OrgID) ([]Member, error)
EnsureMembership(context.Context, Membership) error
RemoveMembership(context.Context, Membership) error
Get(context.Context, IdentityID) (Identity, error)
Apply(context.Context, IdentityID, int64, IdentityCommand, IdentityAudit) (Identity, error)
}
// personInviter creates the identity of a person who has not signed in yet and
// binds it to the subject their identity provider will assert.
type personInviter interface {
ResolveSubject(context.Context, Subject) (Identity, error)
Create(context.Context, Identity, IdentityAudit) (Identity, error)
BindSubject(context.Context, IdentityID, Subject, IdentityAudit) error
AuthenticationSettings(context.Context) (AuthenticationSettings, error)
}
// memberAPI serves the organisation's members. The route guard decides whether
// the caller may manage members at all; each handler then asks the policy chain
// again with the role being granted or changed, which is how the shipped
// policies keep an admin from creating or altering an owner.
type memberAPI struct {
dir memberDirectory
people personInviter
authz func() Authorizer
log *slog.Logger
}
func (m *Module) members() *memberAPI {
return &memberAPI{dir: m, people: m, authz: m.authz, log: m.log}
}
type membersBody struct {
Members []Member `json:"members"`
}
type membershipBody struct {
Membership Membership `json:"membership"`
}
type memberPath struct {
ID string `path:"id" doc:"Organisation ID"`
Identity string `path:"identity" doc:"Identity ID of the member"`
}
type setMemberInput struct {
ID string `path:"id" doc:"Organisation ID"`
Identity string `path:"identity" doc:"Identity ID of the member"`
Body struct {
Role string `json:"role" doc:"The role to hold"`
Workspace string `json:"workspace,omitempty" doc:"Scope the membership to this workspace; empty is organisation-wide"`
}
}
type removeMemberInput struct {
ID string `path:"id" doc:"Organisation ID"`
Identity string `path:"identity" doc:"Identity ID of the member"`
Workspace string `query:"workspace" doc:"Remove the membership scoped to this workspace; empty removes the organisation-wide one"`
}
type addMemberInput struct {
ID string `path:"id" doc:"Organisation ID"`
Body struct {
Subject string `json:"subject,omitempty" doc:"The subject the identity provider asserts; give this or an email"`
Email string `json:"email,omitempty" doc:"The person's email; give this or a subject"`
DisplayName string `json:"display_name,omitempty" doc:"Name shown for a new person; defaults to the email or subject"`
Role string `json:"role" doc:"The role to hold"`
Workspace string `json:"workspace,omitempty" doc:"Scope the membership to this workspace; empty is organisation-wide"`
}
}
// RegisterAccess adds the organisation's members, its access policies and the
// record of refused requests.
func (m *Module) RegisterAccess(api huma.API) {
tags := []string{"Access"}
op := func(id, method, path, summary string, status int) huma.Operation {
return huma.Operation{
OperationID: id, Method: method, Path: path, Summary: summary,
Tags: tags, DefaultStatus: status, MaxBodyBytes: 64 << 10,
}
}
a := m.members()
httpapi.Register(api, httpapi.Authorized(ActionRead, KindMember), op("list-org-members", http.MethodGet, "/api/orgs/{id}/members", "List an organisation's members", 0), a.list)
httpapi.Register(api, httpapi.Authorized(ActionManageMembers, KindMember), op("add-org-member", http.MethodPost, "/api/orgs/{id}/members", "Add a person by email or provider subject", http.StatusCreated), a.add)
httpapi.Register(api, httpapi.Authorized(ActionManageMembers, KindMember), op("set-org-member", http.MethodPut, "/api/orgs/{id}/members/{identity}", "Give a member a role", 0), a.set)
httpapi.Register(api, httpapi.Authorized(ActionManageMembers, KindMember), op("remove-org-member", http.MethodDelete, "/api/orgs/{id}/members/{identity}", "Remove a membership", http.StatusNoContent), a.remove)
httpapi.Register(api, httpapi.Authorized(ActionManageMembers, KindMember), op("suspend-org-member", http.MethodPost, "/api/orgs/{id}/members/{identity}/suspend", "Suspend a member's identity", http.StatusNoContent), a.suspend)
httpapi.Register(api, httpapi.Authorized(ActionManageMembers, KindMember), op("reactivate-org-member", http.MethodPost, "/api/orgs/{id}/members/{identity}/reactivate", "Reactivate a member's identity", http.StatusNoContent), a.reactivate)
m.registerPolicies(api, op)
m.registerDenials(api, op)
}
func (a *memberAPI) list(ctx context.Context, in *orgPath) (*httpapi.Reply[membersBody], error) {
if _, err := actingOrg(ctx, OrgID(in.ID)); err != nil {
return nil, err
}
values, err := a.dir.ListMembers(ctx, OrgID(in.ID))
if err != nil {
return nil, a.failed(ctx, "read the members", err)
}
return httpapi.OK(membersBody{Members: values}), nil
}
func (a *memberAPI) set(ctx context.Context, in *setMemberInput) (*httpapi.Reply[membershipBody], error) {
org, target := OrgID(in.ID), IdentityID(in.Identity)
p, err := actingOrg(ctx, org)
if err != nil {
return nil, err
}
want := Membership{IdentityID: target, OrgID: org, WorkspaceID: WorkspaceID(in.Body.Workspace), Role: Role(in.Body.Role)}
if err := checkGrantable(want); err != nil {
return nil, err
}
members, err := a.dir.ListMembers(ctx, org)
if err != nil {
return nil, a.failed(ctx, "read the members", err)
}
current, held := roleHeld(members, target, want.WorkspaceID)
if held && current != want.Role && strandsOwner(members, target, want.WorkspaceID, want.Role) {
return nil, a.failed(ctx, "change the role", ErrLastOwner)
}
if err := a.mayManage(ctx, p, org, want.Role); err != nil {
return nil, err
}
if held && current != want.Role {
if err := a.mayManage(ctx, p, org, current); err != nil {
return nil, err
}
}
if _, err := a.dir.Get(ctx, target); err != nil {
return nil, a.failed(ctx, "read the member", err)
}
if err := a.dir.EnsureMembership(ctx, want); err != nil {
return nil, a.failed(ctx, "change the role", err)
}
return httpapi.OK(membershipBody{Membership: want}), nil
}
func (a *memberAPI) remove(ctx context.Context, in *removeMemberInput) (*struct{}, error) {
org, target := OrgID(in.ID), IdentityID(in.Identity)
p, err := actingOrg(ctx, org)
if err != nil {
return nil, err
}
if target == SystemID {
return nil, a.failed(ctx, "remove the member", ErrSystemImmutable)
}
scope := WorkspaceID(in.Workspace)
members, err := a.dir.ListMembers(ctx, org)
if err != nil {
return nil, a.failed(ctx, "read the members", err)
}
current, held := roleHeld(members, target, scope)
if !held {
return nil, huma.Error404NotFound("That person is not a member.")
}
if strandsOwner(members, target, scope, "") {
return nil, a.failed(ctx, "remove the member", ErrLastOwner)
}
if err := a.mayManage(ctx, p, org, current); err != nil {
return nil, err
}
if err := a.dir.RemoveMembership(ctx, Membership{IdentityID: target, OrgID: org, WorkspaceID: scope}); err != nil {
return nil, a.failed(ctx, "remove the member", err)
}
return nil, nil
}
func (a *memberAPI) suspend(ctx context.Context, in *memberPath) (*struct{}, error) {
return a.transition(ctx, in, CommandSuspend)
}
func (a *memberAPI) reactivate(ctx context.Context, in *memberPath) (*struct{}, error) {
return a.transition(ctx, in, CommandReactivate)
}
// transition suspends or reactivates a member's identity. A suspended identity
// stops acting at once and keeps its memberships.
func (a *memberAPI) transition(ctx context.Context, in *memberPath, command CommandType) (*struct{}, error) {
org, target := OrgID(in.ID), IdentityID(in.Identity)
p, err := actingOrg(ctx, org)
if err != nil {
return nil, err
}
if target == SystemID {
return nil, a.failed(ctx, "change the member", ErrSystemImmutable)
}
members, err := a.dir.ListMembers(ctx, org)
if err != nil {
return nil, a.failed(ctx, "read the members", err)
}
current, held := roleHeld(members, target, "")
if !held {
return nil, huma.Error404NotFound("That person is not a member.")
}
if command == CommandSuspend && strandsOwner(members, target, "", "") {
return nil, a.failed(ctx, "suspend the member", ErrLastOwner)
}
if err := a.mayManage(ctx, p, org, current); err != nil {
return nil, err
}
value, err := a.dir.Get(ctx, target)
if err != nil {
return nil, a.failed(ctx, "read the member", err)
}
if _, err := a.dir.Apply(ctx, target, value.Version, IdentityCommand{Type: command}, memberAudit(p)); err != nil {
return nil, a.failed(ctx, "change the member", err)
}
return nil, nil
}
func (a *memberAPI) add(ctx context.Context, in *addMemberInput) (*httpapi.Reply[membershipBody], error) {
org := OrgID(in.ID)
p, err := actingOrg(ctx, org)
if err != nil {
return nil, err
}
subject, email := strings.TrimSpace(in.Body.Subject), strings.TrimSpace(in.Body.Email)
if (subject == "") == (email == "") {
return nil, huma.Error400BadRequest("Give either an email or a provider subject.")
}
want := Membership{IdentityID: "new", OrgID: org, WorkspaceID: WorkspaceID(in.Body.Workspace), Role: Role(in.Body.Role)}
if err := checkGrantable(want); err != nil {
return nil, err
}
if err := a.mayManage(ctx, p, org, want.Role); err != nil {
return nil, err
}
settings, err := a.people.AuthenticationSettings(ctx)
if err != nil {
return nil, a.failed(ctx, "read the authentication settings", err)
}
if settings.OIDCIssuer == "" {
return nil, huma.Error409Conflict("Adding a person by email needs an identity provider. Set one in the authentication settings, or create a local account.")
}
bound, name := Subject{Issuer: settings.OIDCIssuer, Subject: subject}, subject
if email != "" {
bound, name = EmailSubject(settings.OIDCIssuer, email), email
}
if display := strings.TrimSpace(in.Body.DisplayName); display != "" {
name = display
}
want.IdentityID, err = a.person(ctx, p, bound, name)
if err != nil {
return nil, err
}
if err := a.dir.EnsureMembership(ctx, want); err != nil {
return nil, a.failed(ctx, "add the member", err)
}
return httpapi.OK(membershipBody{Membership: want}), nil
}
// person returns the identity bound to subject, creating and binding a user
// identity when no one holds it yet.
func (a *memberAPI) person(ctx context.Context, p Principal, subject Subject, name string) (IdentityID, error) {
existing, err := a.people.ResolveSubject(ctx, subject)
switch {
case err == nil:
return existing.ID, nil
case !errors.Is(err, ErrIdentityNotFound):
return "", a.failed(ctx, "look up the person", err)
}
value, err := NewIdentity(IdentityID(rand.Text()), KindUser, name)
if err != nil {
return "", huma.Error400BadRequest("Give the person a name.")
}
audit := memberAudit(p)
if _, err := a.people.Create(ctx, value, audit); err != nil {
return "", a.failed(ctx, "create the person", err)
}
if err := a.people.BindSubject(ctx, value.ID, subject, audit); err != nil {
return "", a.failed(ctx, "create the person", err)
}
return value.ID, nil
}
func memberAudit(p Principal) IdentityAudit {
return IdentityAudit{ActorID: p.IdentityID, Source: "members api", RequestID: newRequestID("member")}
}
// checkGrantable refuses a membership no member can hold: the system
// identity's, the workload role, and an invalid role.
func checkGrantable(m Membership) error {
switch {
case m.IdentityID == SystemID:
return huma.Error400BadRequest("The system identity can't be changed.")
case m.Role == RoleWorkload:
return huma.Error400BadRequest("The workload role belongs to background work and can't be given to a member.")
}
if err := m.Validate(); err != nil {
return huma.Error400BadRequest("Choose a role: lowercase letters, digits, dots, dashes or underscores.")
}
return nil
}
// mayManage asks the policy chain whether p may manage a member holding role.
// The resource state carries the role, so a policy can reserve the owner role
// for owners.
func (a *memberAPI) mayManage(ctx context.Context, p Principal, org OrgID, role Role) error {
chain := a.authz()
if chain == nil {
return huma.Error503ServiceUnavailable("Access policies are unavailable.")
}
scoped := p
scoped.Org = org
decision := chain.Authorize(ctx, scoped, ActionManageMembers, Resource{Kind: KindMember, Org: org, State: string(role)}, AccessContext{Time: time.Now()})
switch {
case decision.Err != nil:
return huma.Error503ServiceUnavailable("Access policies are unavailable.")
case !decision.Allowed && role == RoleOwner:
return huma.Error403Forbidden("Only an owner may grant or change the owner role.")
case !decision.Allowed:
return huma.Error403Forbidden("An access policy refuses this change.")
}
return nil
}
// roleHeld returns the role identity holds in scope, an empty scope being the
// organisation-wide membership.
func roleHeld(members []Member, identity IdentityID, scope WorkspaceID) (Role, bool) {
for _, m := range members {
if m.IdentityID == identity && m.WorkspaceID == scope {
return m.Role, true
}
}
return "", false
}
// strandsOwner reports whether giving identity role next (empty to remove or
// suspend) in scope would leave the organisation without an active owner. The
// store enforces the same rule inside its transaction; checking here answers
// before any change and names the cause.
func strandsOwner(members []Member, identity IdentityID, scope WorkspaceID, next Role) bool {
if scope != "" || next == RoleOwner {
return false
}
if role, held := roleHeld(members, identity, ""); !held || role != RoleOwner {
return false
}
for _, m := range members {
if m.IdentityID != identity && m.WorkspaceID == "" && m.Role == RoleOwner && m.Status == LifecycleActive {
return false
}
}
return true
}
// failed answers a failure with the status a person can act on, logging the
// ones it cannot explain.
func (a *memberAPI) failed(ctx context.Context, what string, err error) error {
switch {
case errors.Is(err, ErrLastOwner):
return huma.Error409Conflict("This is the organisation's last active owner. Make another member an owner first.")
case errors.Is(err, ErrIdentityNotFound), errors.Is(err, ErrOrgNotFound):
return huma.Error404NotFound("That person or organisation was not found.")
case errors.Is(err, ErrSystemImmutable):
return huma.Error400BadRequest("The system identity can't be changed.")
case errors.Is(err, ErrIllegalTransition):
return huma.Error409Conflict("The member is already in that state.")
case errors.Is(err, ErrIdentityConflict):
return huma.Error409Conflict("The member changed after you opened the page. Reload and try again.")
}
a.log.ErrorContext(ctx, "member operation failed", "operation", what, "err", err)
return huma.Error503ServiceUnavailable("Couldn't " + what + ". Try again shortly.")
}
+219
View File
@@ -0,0 +1,219 @@
package governance
import (
"context"
"errors"
"log/slog"
"net/http"
"strings"
"testing"
"github.com/danielgtaylor/huma/v2"
"github.com/samcharles93/archie-core/internal/platform/httpapi"
)
// fakeDirectory records the changes a member route lets through.
type fakeDirectory struct {
members []Member
changes []string
}
func (f *fakeDirectory) ListMembers(context.Context, OrgID) ([]Member, error) { return f.members, nil }
func (f *fakeDirectory) EnsureMembership(_ context.Context, m Membership) error {
f.changes = append(f.changes, "ensure "+string(m.IdentityID)+" "+string(m.Role))
return nil
}
func (f *fakeDirectory) RemoveMembership(_ context.Context, m Membership) error {
f.changes = append(f.changes, "remove "+string(m.IdentityID))
return nil
}
func (f *fakeDirectory) Get(_ context.Context, id IdentityID) (Identity, error) {
return Identity{ID: id, Version: 1}, nil
}
func (f *fakeDirectory) Apply(_ context.Context, id IdentityID, _ int64, c IdentityCommand, _ IdentityAudit) (Identity, error) {
f.changes = append(f.changes, string(c.Type)+" "+string(id))
return Identity{ID: id}, nil
}
func status(t *testing.T, err error) int {
t.Helper()
if err == nil {
return http.StatusOK
}
var se huma.StatusError
if !errors.As(err, &se) {
t.Fatalf("error %v carries no status", err)
}
return se.GetStatus()
}
func actor(id IdentityID, role Role) Principal {
return Principal{
IdentityID: id, Kind: KindUser, Org: DefaultOrgID,
Memberships: []Membership{{IdentityID: id, OrgID: DefaultOrgID, Role: role}},
}
}
func member(id IdentityID, role Role, status Lifecycle) Member {
return Member{IdentityID: id, Kind: KindUser, DisplayName: string(id), Role: role, Status: status}
}
func memberRoutes(dir *fakeDirectory) *memberAPI {
return &memberAPI{
dir: dir,
authz: func() Authorizer { return NewEngine(ShippedOrgPolicies(DefaultOrgID)) },
log: slog.New(slog.DiscardHandler),
}
}
// TestAccessWritesNeedTheirGrant guards the declared access of every route that
// changes members or policies, and the grant the shipped roles give it. A
// viewer or developer who reached a write would let them reassign roles or
// rewrite the access policies.
func TestAccessWritesNeedTheirGrant(t *testing.T) {
api := httpapi.New(http.NewServeMux(), "test", nil, nil)
(&Module{}).RegisterAccess(api)
engine := NewEngine(ShippedOrgPolicies(DefaultOrgID))
writes := 0
for _, route := range httpapi.Routes(api) {
mutates := route.Method != http.MethodGet
action, kind, ok := route.Access.Declared()
if !ok {
t.Errorf("%s declares no access", route.ID)
continue
}
if mutates {
writes++
}
wantAction := string(ActionManageMembers)
if strings.HasPrefix(route.Path, "/api/access/policies") {
wantAction = string(ActionManagePolicies)
}
if mutates && action != wantAction {
t.Errorf("%s declares %q, want %q", route.ID, action, wantAction)
}
if !mutates && route.Path == "/api/access/denials" && action != string(ActionReadAudit) {
t.Errorf("%s declares %q, want read_audit", route.ID, action)
}
resource := Resource{Kind: ResourceKind(kind), Org: DefaultOrgID}
if !engine.Authorize(t.Context(), actor("admin", RoleAdmin), Action(action), resource, AccessContext{}).Allowed {
t.Errorf("%s: an admin is refused %s %s", route.ID, action, kind)
}
if mutates || route.Path == "/api/access/denials" {
for _, role := range []Role{RoleViewer, RoleDeveloper} {
if engine.Authorize(t.Context(), actor("lowly", role), Action(action), resource, AccessContext{}).Allowed {
t.Errorf("%s: a %s is allowed %s %s", route.ID, role, action, kind)
}
}
}
}
if writes != 7 {
t.Errorf("%d write routes registered, want 7", writes)
}
}
// TestLastOwnerIsKept guards the rule that an organisation always keeps an
// active owner: removing, demoting or suspending the only one is refused before
// anything changes.
func TestLastOwnerIsKept(t *testing.T) {
sole := []Member{member("root", RoleOwner, LifecycleActive), member("dev", RoleDeveloper, LifecycleActive)}
pair := []Member{member("root", RoleOwner, LifecycleActive), member("second", RoleOwner, LifecycleActive)}
suspendedPair := []Member{member("root", RoleOwner, LifecycleActive), member("second", RoleOwner, LifecycleSuspended)}
scoped := append(slicesClone(sole), Member{IdentityID: "root", Kind: KindUser, WorkspaceID: "ws", Role: RoleOwner, Status: LifecycleActive})
tests := []struct {
name string
members []Member
act func(*memberAPI, context.Context) error
want int
changed bool
}{
{"demote the only owner", sole, setRole("root", "admin"), http.StatusConflict, false},
{"remove the only owner", sole, removeMember("root", ""), http.StatusConflict, false},
{"suspend the only owner", sole, suspendMember("root"), http.StatusConflict, false},
{"demote when the other owner is suspended", suspendedPair, setRole("root", "viewer"), http.StatusConflict, false},
{"demote one of two owners", pair, setRole("root", "admin"), http.StatusOK, true},
{"remove one of two owners", pair, removeMember("second", ""), http.StatusOK, true},
{"keep the only owner as owner", sole, setRole("root", "owner"), http.StatusOK, true},
{"remove an owner's workspace membership", scoped, removeMember("root", "ws"), http.StatusOK, true},
{"remove the only developer", sole, removeMember("dev", ""), http.StatusOK, true},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
dir := &fakeDirectory{members: tt.members}
ctx := WithPrincipal(t.Context(), actor("root", RoleOwner))
err := tt.act(memberRoutes(dir), ctx)
if got := status(t, err); got != tt.want {
t.Fatalf("status = %d (%v), want %d", got, err, tt.want)
}
if changed := len(dir.changes) > 0; changed != tt.changed {
t.Fatalf("changes = %v, want changed %v", dir.changes, tt.changed)
}
})
}
}
// TestOwnerRoleNeedsAnOwner guards the rule that only an owner grants the owner
// role or alters an owner: an admin who could would promote themselves.
func TestOwnerRoleNeedsAnOwner(t *testing.T) {
members := []Member{
member("root", RoleOwner, LifecycleActive), member("second", RoleOwner, LifecycleActive),
member("dev", RoleDeveloper, LifecycleActive),
}
tests := []struct {
name string
by Principal
act func(*memberAPI, context.Context) error
want int
}{
{"admin grants owner", actor("adm", RoleAdmin), setRole("dev", "owner"), http.StatusForbidden},
{"admin demotes an owner", actor("adm", RoleAdmin), setRole("second", "viewer"), http.StatusForbidden},
{"admin removes an owner", actor("adm", RoleAdmin), removeMember("second", ""), http.StatusForbidden},
{"admin suspends an owner", actor("adm", RoleAdmin), suspendMember("second"), http.StatusForbidden},
{"admin grants developer", actor("adm", RoleAdmin), setRole("dev", "admin"), http.StatusOK},
{"owner grants owner", actor("root", RoleOwner), setRole("dev", "owner"), http.StatusOK},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
dir := &fakeDirectory{members: members}
err := tt.act(memberRoutes(dir), WithPrincipal(t.Context(), tt.by))
if got := status(t, err); got != tt.want {
t.Fatalf("status = %d (%v), want %d", got, err, tt.want)
}
if (tt.want == http.StatusOK) != (len(dir.changes) > 0) {
t.Fatalf("changes = %v with status %d", dir.changes, tt.want)
}
})
}
}
func setRole(identity, role string) func(*memberAPI, context.Context) error {
return func(a *memberAPI, ctx context.Context) error {
in := &setMemberInput{ID: string(DefaultOrgID), Identity: identity}
in.Body.Role = role
_, err := a.set(ctx, in)
return err
}
}
func removeMember(identity, workspace string) func(*memberAPI, context.Context) error {
return func(a *memberAPI, ctx context.Context) error {
_, err := a.remove(ctx, &removeMemberInput{ID: string(DefaultOrgID), Identity: identity, Workspace: workspace})
return err
}
}
func suspendMember(identity string) func(*memberAPI, context.Context) error {
return func(a *memberAPI, ctx context.Context) error {
_, err := a.suspend(ctx, &memberPath{ID: string(DefaultOrgID), Identity: identity})
return err
}
}
func slicesClone(m []Member) []Member { return append([]Member(nil), m...) }
+5
View File
@@ -176,6 +176,11 @@ type Member struct {
DisplayName string `json:"display_name"`
WorkspaceID WorkspaceID `json:"workspace_id,omitempty"`
Role Role `json:"role"`
// Status is the identity's lifecycle: a suspended member keeps the role but
// cannot act.
Status Lifecycle `json:"status"`
// LastSignIn is nil for a member without an account or who never signed in.
LastSignIn *time.Time `json:"last_sign_in,omitempty"`
}
// AgentAssignment records the one org an agent or service identity serves.
+31 -6
View File
@@ -274,15 +274,40 @@ func (m *Module) RecordDenial(ctx context.Context, d Denial) error {
// ListDenials returns an org's most recent denials, newest first.
func (m *Module) ListDenials(ctx context.Context, orgID OrgID, limit int) ([]Denial, error) {
if limit <= 0 {
limit = defaultDenials
} else if limit > maxDenials {
limit = maxDenials
return m.SearchDenials(ctx, DenialQuery{Org: orgID, Limit: limit})
}
// DenialQuery narrows SearchDenials. A zero field matches everything.
type DenialQuery struct {
Org OrgID
Principal IdentityID
Action Action
Kind ResourceKind
Since time.Time
Until time.Time
Limit int
Offset int
}
// SearchDenials returns the denials matching q, newest first, at most
// maxDenials per call.
func (m *Module) SearchDenials(ctx context.Context, q DenialQuery) ([]Denial, error) {
if q.Limit <= 0 {
q.Limit = defaultDenials
} else if q.Limit > maxDenials {
q.Limit = maxDenials
}
rows, err := m.store.ListDenials(ctx, string(orgID), limit)
rows, err := m.store.SearchDenials(ctx, store.DenialFilter{
OrgID: string(q.Org), Principal: string(q.Principal), Action: string(q.Action),
ResourceKind: string(q.Kind), Since: q.Since, Until: q.Until, Limit: q.Limit, Offset: max(q.Offset, 0),
})
if err != nil {
return nil, err
}
return denialsFromRows(rows), nil
}
func denialsFromRows(rows []store.DenialRow) []Denial {
out := make([]Denial, 0, len(rows))
for _, r := range rows {
out = append(out, Denial{
@@ -297,7 +322,7 @@ func (m *Module) ListDenials(ctx context.Context, orgID OrgID, limit int) ([]Den
Count: r.Count,
})
}
return out, nil
return out
}
// PruneDenials deletes denial rows older than cutoff in bounded batches.
+7 -2
View File
@@ -238,13 +238,18 @@ func (m *Module) ListMembers(ctx context.Context, id OrgID) ([]Member, error) {
if r.WorkspaceID.Valid {
ws = WorkspaceID(r.WorkspaceID.String)
}
out = append(out, Member{
member := Member{
IdentityID: IdentityID(r.IdentityID),
Kind: Kind(r.Kind),
DisplayName: r.DisplayName,
WorkspaceID: ws,
Role: Role(r.Role),
})
Status: Lifecycle(r.Lifecycle),
}
if r.LastSignIn.Valid {
member.LastSignIn = &r.LastSignIn.Time
}
out = append(out, member)
}
return out, nil
}