feat(governance): serve members, access policies and denials (#2023)
This commit is contained in:
16 files changed
+1531
-14
No files matched your search
@@ -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
|
||||
|
||||
@@ -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;
|
||||
@@ -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.")
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
@@ -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
|
||||
|
||||
@@ -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
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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.")
|
||||
}
|
||||
@@ -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...) }
|
||||
@@ -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.
|
||||
|
||||
@@ -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.
|
||||
|
||||
@@ -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
|
||||
}
|
||||
|
||||
Reference in new issue
Block a user