feat(org): org, workspace and membership API

This commit is contained in:
sam committed 2026-10-05 20:44:49 +11:00
1 parent 0788f5ab8a
commit fb05189e42
20 files changed
+2960 -271

No files matched your search

+10
View File
@@ -10,6 +10,7 @@ import (
"github.com/samcharles93/archie-core/internal/domain/health"
"github.com/samcharles93/archie-core/internal/domain/identity"
"github.com/samcharles93/archie-core/internal/domain/messaging"
"github.com/samcharles93/archie-core/internal/domain/org"
"github.com/samcharles93/archie-core/internal/domain/storecontract"
"github.com/samcharles93/archie-core/internal/domain/storepkg"
"github.com/samcharles93/archie-core/internal/events"
@@ -84,6 +85,7 @@ func compose(d deps) *webui.Server {
if policies, ok := d.Store.(access.PolicyStore); ok {
srv.Policies = policies
}
wireOrgSurface(srv, d.Store)
if presence, ok := d.Store.(storecontract.PresenceStore); ok {
srv.Presence = presence
}
@@ -121,6 +123,14 @@ func compose(d deps) *webui.Server {
return srv
}
// wireOrgSurface attaches the dashboard's org surface when the state client
// carries it.
func wireOrgSurface(srv *webui.Server, store storecontract.TaskStore) {
if orgs, ok := store.(org.API); ok {
srv.Orgs = orgs
}
}
// wireCatalog attaches the Gateway-owned surfaces the dashboard reads over the
// chat client: the skill catalogue and the curator registry. A client that
// cannot answer them leaves those pages empty rather than fabricating a set.
+3
View File
@@ -424,6 +424,9 @@ func (b *server) accessDeps(deps *staterpc.Deps) {
if ds, ok := b.st.(access.DenialStore); ok {
deps.Denials = ds
}
if os, ok := b.st.(org.Repository); ok {
deps.Orgs = os
}
}
// serveStateStore registers the StateStore gRPC service and serves it until
File diff suppressed because it is too large. Load diff
@@ -127,6 +127,15 @@ const (
StateStoreService_EnsureShippedOrgPolicies_FullMethodName = "/state.v1.StateStoreService/EnsureShippedOrgPolicies"
StateStoreService_RecordDenial_FullMethodName = "/state.v1.StateStoreService/RecordDenial"
StateStoreService_ListDenials_FullMethodName = "/state.v1.StateStoreService/ListDenials"
StateStoreService_ListOrgs_FullMethodName = "/state.v1.StateStoreService/ListOrgs"
StateStoreService_GetOrg_FullMethodName = "/state.v1.StateStoreService/GetOrg"
StateStoreService_CreateOrg_FullMethodName = "/state.v1.StateStoreService/CreateOrg"
StateStoreService_ListWorkspaces_FullMethodName = "/state.v1.StateStoreService/ListWorkspaces"
StateStoreService_CreateWorkspace_FullMethodName = "/state.v1.StateStoreService/CreateWorkspace"
StateStoreService_ListMembers_FullMethodName = "/state.v1.StateStoreService/ListMembers"
StateStoreService_SetMembership_FullMethodName = "/state.v1.StateStoreService/SetMembership"
StateStoreService_RemoveMembership_FullMethodName = "/state.v1.StateStoreService/RemoveMembership"
StateStoreService_AssignAgent_FullMethodName = "/state.v1.StateStoreService/AssignAgent"
)
// StateStoreServiceClient is the client API for StateStoreService service.
@@ -339,6 +348,20 @@ type StateStoreServiceClient interface {
EnsureShippedOrgPolicies(ctx context.Context, in *EnsureShippedOrgPoliciesRequest, opts ...grpc.CallOption) (*EnsureShippedOrgPoliciesResponse, error)
RecordDenial(ctx context.Context, in *RecordDenialRequest, opts ...grpc.CallOption) (*RecordDenialResponse, error)
ListDenials(ctx context.Context, in *ListDenialsRequest, opts ...grpc.CallOption) (*ListDenialsResponse, error)
// Orgs, workspaces, memberships and agent assignments
// (docs/prds/orgs-and-access.md). Every request names an org, but the
// State Store acts in the org the caller's principal carries: a request
// org that is not the caller's is ignored, so the contract cannot reach
// another tenant. Instance-admin widening is a later change.
ListOrgs(ctx context.Context, in *ListOrgsRequest, opts ...grpc.CallOption) (*ListOrgsResponse, error)
GetOrg(ctx context.Context, in *GetOrgRequest, opts ...grpc.CallOption) (*GetOrgResponse, error)
CreateOrg(ctx context.Context, in *CreateOrgRequest, opts ...grpc.CallOption) (*CreateOrgResponse, error)
ListWorkspaces(ctx context.Context, in *ListWorkspacesRequest, opts ...grpc.CallOption) (*ListWorkspacesResponse, error)
CreateWorkspace(ctx context.Context, in *CreateWorkspaceRequest, opts ...grpc.CallOption) (*CreateWorkspaceResponse, error)
ListMembers(ctx context.Context, in *ListMembersRequest, opts ...grpc.CallOption) (*ListMembersResponse, error)
SetMembership(ctx context.Context, in *SetMembershipRequest, opts ...grpc.CallOption) (*SetMembershipResponse, error)
RemoveMembership(ctx context.Context, in *RemoveMembershipRequest, opts ...grpc.CallOption) (*RemoveMembershipResponse, error)
AssignAgent(ctx context.Context, in *AssignAgentRequest, opts ...grpc.CallOption) (*AssignAgentResponse, error)
}
type stateStoreServiceClient struct {
@@ -1456,6 +1479,96 @@ func (c *stateStoreServiceClient) ListDenials(ctx context.Context, in *ListDenia
return out, nil
}
func (c *stateStoreServiceClient) ListOrgs(ctx context.Context, in *ListOrgsRequest, opts ...grpc.CallOption) (*ListOrgsResponse, error) {
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
out := new(ListOrgsResponse)
err := c.cc.Invoke(ctx, StateStoreService_ListOrgs_FullMethodName, in, out, cOpts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *stateStoreServiceClient) GetOrg(ctx context.Context, in *GetOrgRequest, opts ...grpc.CallOption) (*GetOrgResponse, error) {
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
out := new(GetOrgResponse)
err := c.cc.Invoke(ctx, StateStoreService_GetOrg_FullMethodName, in, out, cOpts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *stateStoreServiceClient) CreateOrg(ctx context.Context, in *CreateOrgRequest, opts ...grpc.CallOption) (*CreateOrgResponse, error) {
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
out := new(CreateOrgResponse)
err := c.cc.Invoke(ctx, StateStoreService_CreateOrg_FullMethodName, in, out, cOpts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *stateStoreServiceClient) ListWorkspaces(ctx context.Context, in *ListWorkspacesRequest, opts ...grpc.CallOption) (*ListWorkspacesResponse, error) {
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
out := new(ListWorkspacesResponse)
err := c.cc.Invoke(ctx, StateStoreService_ListWorkspaces_FullMethodName, in, out, cOpts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *stateStoreServiceClient) CreateWorkspace(ctx context.Context, in *CreateWorkspaceRequest, opts ...grpc.CallOption) (*CreateWorkspaceResponse, error) {
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
out := new(CreateWorkspaceResponse)
err := c.cc.Invoke(ctx, StateStoreService_CreateWorkspace_FullMethodName, in, out, cOpts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *stateStoreServiceClient) ListMembers(ctx context.Context, in *ListMembersRequest, opts ...grpc.CallOption) (*ListMembersResponse, error) {
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
out := new(ListMembersResponse)
err := c.cc.Invoke(ctx, StateStoreService_ListMembers_FullMethodName, in, out, cOpts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *stateStoreServiceClient) SetMembership(ctx context.Context, in *SetMembershipRequest, opts ...grpc.CallOption) (*SetMembershipResponse, error) {
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
out := new(SetMembershipResponse)
err := c.cc.Invoke(ctx, StateStoreService_SetMembership_FullMethodName, in, out, cOpts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *stateStoreServiceClient) RemoveMembership(ctx context.Context, in *RemoveMembershipRequest, opts ...grpc.CallOption) (*RemoveMembershipResponse, error) {
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
out := new(RemoveMembershipResponse)
err := c.cc.Invoke(ctx, StateStoreService_RemoveMembership_FullMethodName, in, out, cOpts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *stateStoreServiceClient) AssignAgent(ctx context.Context, in *AssignAgentRequest, opts ...grpc.CallOption) (*AssignAgentResponse, error) {
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
out := new(AssignAgentResponse)
err := c.cc.Invoke(ctx, StateStoreService_AssignAgent_FullMethodName, in, out, cOpts...)
if err != nil {
return nil, err
}
return out, nil
}
// StateStoreServiceServer is the server API for StateStoreService service.
// All implementations must embed UnimplementedStateStoreServiceServer
// for forward compatibility.
@@ -1666,6 +1779,20 @@ type StateStoreServiceServer interface {
EnsureShippedOrgPolicies(context.Context, *EnsureShippedOrgPoliciesRequest) (*EnsureShippedOrgPoliciesResponse, error)
RecordDenial(context.Context, *RecordDenialRequest) (*RecordDenialResponse, error)
ListDenials(context.Context, *ListDenialsRequest) (*ListDenialsResponse, error)
// Orgs, workspaces, memberships and agent assignments
// (docs/prds/orgs-and-access.md). Every request names an org, but the
// State Store acts in the org the caller's principal carries: a request
// org that is not the caller's is ignored, so the contract cannot reach
// another tenant. Instance-admin widening is a later change.
ListOrgs(context.Context, *ListOrgsRequest) (*ListOrgsResponse, error)
GetOrg(context.Context, *GetOrgRequest) (*GetOrgResponse, error)
CreateOrg(context.Context, *CreateOrgRequest) (*CreateOrgResponse, error)
ListWorkspaces(context.Context, *ListWorkspacesRequest) (*ListWorkspacesResponse, error)
CreateWorkspace(context.Context, *CreateWorkspaceRequest) (*CreateWorkspaceResponse, error)
ListMembers(context.Context, *ListMembersRequest) (*ListMembersResponse, error)
SetMembership(context.Context, *SetMembershipRequest) (*SetMembershipResponse, error)
RemoveMembership(context.Context, *RemoveMembershipRequest) (*RemoveMembershipResponse, error)
AssignAgent(context.Context, *AssignAgentRequest) (*AssignAgentResponse, error)
mustEmbedUnimplementedStateStoreServiceServer()
}
@@ -2000,6 +2127,33 @@ func (UnimplementedStateStoreServiceServer) RecordDenial(context.Context, *Recor
func (UnimplementedStateStoreServiceServer) ListDenials(context.Context, *ListDenialsRequest) (*ListDenialsResponse, error) {
return nil, status.Error(codes.Unimplemented, "method ListDenials not implemented")
}
func (UnimplementedStateStoreServiceServer) ListOrgs(context.Context, *ListOrgsRequest) (*ListOrgsResponse, error) {
return nil, status.Error(codes.Unimplemented, "method ListOrgs not implemented")
}
func (UnimplementedStateStoreServiceServer) GetOrg(context.Context, *GetOrgRequest) (*GetOrgResponse, error) {
return nil, status.Error(codes.Unimplemented, "method GetOrg not implemented")
}
func (UnimplementedStateStoreServiceServer) CreateOrg(context.Context, *CreateOrgRequest) (*CreateOrgResponse, error) {
return nil, status.Error(codes.Unimplemented, "method CreateOrg not implemented")
}
func (UnimplementedStateStoreServiceServer) ListWorkspaces(context.Context, *ListWorkspacesRequest) (*ListWorkspacesResponse, error) {
return nil, status.Error(codes.Unimplemented, "method ListWorkspaces not implemented")
}
func (UnimplementedStateStoreServiceServer) CreateWorkspace(context.Context, *CreateWorkspaceRequest) (*CreateWorkspaceResponse, error) {
return nil, status.Error(codes.Unimplemented, "method CreateWorkspace not implemented")
}
func (UnimplementedStateStoreServiceServer) ListMembers(context.Context, *ListMembersRequest) (*ListMembersResponse, error) {
return nil, status.Error(codes.Unimplemented, "method ListMembers not implemented")
}
func (UnimplementedStateStoreServiceServer) SetMembership(context.Context, *SetMembershipRequest) (*SetMembershipResponse, error) {
return nil, status.Error(codes.Unimplemented, "method SetMembership not implemented")
}
func (UnimplementedStateStoreServiceServer) RemoveMembership(context.Context, *RemoveMembershipRequest) (*RemoveMembershipResponse, error) {
return nil, status.Error(codes.Unimplemented, "method RemoveMembership not implemented")
}
func (UnimplementedStateStoreServiceServer) AssignAgent(context.Context, *AssignAgentRequest) (*AssignAgentResponse, error) {
return nil, status.Error(codes.Unimplemented, "method AssignAgent not implemented")
}
func (UnimplementedStateStoreServiceServer) mustEmbedUnimplementedStateStoreServiceServer() {}
func (UnimplementedStateStoreServiceServer) testEmbeddedByValue() {}
@@ -3944,6 +4098,168 @@ func _StateStoreService_ListDenials_Handler(srv interface{}, ctx context.Context
return interceptor(ctx, in, info, handler)
}
func _StateStoreService_ListOrgs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ListOrgsRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(StateStoreServiceServer).ListOrgs(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: StateStoreService_ListOrgs_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(StateStoreServiceServer).ListOrgs(ctx, req.(*ListOrgsRequest))
}
return interceptor(ctx, in, info, handler)
}
func _StateStoreService_GetOrg_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetOrgRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(StateStoreServiceServer).GetOrg(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: StateStoreService_GetOrg_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(StateStoreServiceServer).GetOrg(ctx, req.(*GetOrgRequest))
}
return interceptor(ctx, in, info, handler)
}
func _StateStoreService_CreateOrg_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(CreateOrgRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(StateStoreServiceServer).CreateOrg(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: StateStoreService_CreateOrg_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(StateStoreServiceServer).CreateOrg(ctx, req.(*CreateOrgRequest))
}
return interceptor(ctx, in, info, handler)
}
func _StateStoreService_ListWorkspaces_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ListWorkspacesRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(StateStoreServiceServer).ListWorkspaces(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: StateStoreService_ListWorkspaces_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(StateStoreServiceServer).ListWorkspaces(ctx, req.(*ListWorkspacesRequest))
}
return interceptor(ctx, in, info, handler)
}
func _StateStoreService_CreateWorkspace_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(CreateWorkspaceRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(StateStoreServiceServer).CreateWorkspace(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: StateStoreService_CreateWorkspace_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(StateStoreServiceServer).CreateWorkspace(ctx, req.(*CreateWorkspaceRequest))
}
return interceptor(ctx, in, info, handler)
}
func _StateStoreService_ListMembers_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ListMembersRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(StateStoreServiceServer).ListMembers(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: StateStoreService_ListMembers_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(StateStoreServiceServer).ListMembers(ctx, req.(*ListMembersRequest))
}
return interceptor(ctx, in, info, handler)
}
func _StateStoreService_SetMembership_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(SetMembershipRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(StateStoreServiceServer).SetMembership(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: StateStoreService_SetMembership_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(StateStoreServiceServer).SetMembership(ctx, req.(*SetMembershipRequest))
}
return interceptor(ctx, in, info, handler)
}
func _StateStoreService_RemoveMembership_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(RemoveMembershipRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(StateStoreServiceServer).RemoveMembership(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: StateStoreService_RemoveMembership_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(StateStoreServiceServer).RemoveMembership(ctx, req.(*RemoveMembershipRequest))
}
return interceptor(ctx, in, info, handler)
}
func _StateStoreService_AssignAgent_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(AssignAgentRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(StateStoreServiceServer).AssignAgent(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: StateStoreService_AssignAgent_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(StateStoreServiceServer).AssignAgent(ctx, req.(*AssignAgentRequest))
}
return interceptor(ctx, in, info, handler)
}
// StateStoreService_ServiceDesc is the grpc.ServiceDesc for StateStoreService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
@@ -4371,6 +4687,42 @@ var StateStoreService_ServiceDesc = grpc.ServiceDesc{
MethodName: "ListDenials",
Handler: _StateStoreService_ListDenials_Handler,
},
{
MethodName: "ListOrgs",
Handler: _StateStoreService_ListOrgs_Handler,
},
{
MethodName: "GetOrg",
Handler: _StateStoreService_GetOrg_Handler,
},
{
MethodName: "CreateOrg",
Handler: _StateStoreService_CreateOrg_Handler,
},
{
MethodName: "ListWorkspaces",
Handler: _StateStoreService_ListWorkspaces_Handler,
},
{
MethodName: "CreateWorkspace",
Handler: _StateStoreService_CreateWorkspace_Handler,
},
{
MethodName: "ListMembers",
Handler: _StateStoreService_ListMembers_Handler,
},
{
MethodName: "SetMembership",
Handler: _StateStoreService_SetMembership_Handler,
},
{
MethodName: "RemoveMembership",
Handler: _StateStoreService_RemoveMembership_Handler,
},
{
MethodName: "AssignAgent",
Handler: _StateStoreService_AssignAgent_Handler,
},
},
Streams: []grpc.StreamDesc{
{
+10
View File
@@ -101,6 +101,16 @@ type Membership struct {
Role Role `json:"role"`
}
// Member is one identity's membership in an org or workspace, with the
// identity's display name and kind for the dashboard.
type Member struct {
IdentityID identity.IdentityID `json:"identity_id"`
Kind identity.Kind `json:"kind"`
DisplayName string `json:"display_name"`
WorkspaceID WorkspaceID `json:"workspace_id,omitempty"`
Role Role `json:"role"`
}
// Validate requires an identity, an org and a shipped role.
func (m Membership) Validate() error {
if m.IdentityID == "" {
+23 -2
View File
@@ -11,7 +11,7 @@ import (
// Repository persists the tenant boundary. A store that implements it owns
// ID conflict rules (org and workspace IDs are caller-provided and unique).
type Repository interface {
type Repository interface { //nolint:interfacebloat // one tenant-boundary store contract: orgs, workspaces, memberships and agent assignments
// CreateOrg inserts a new org; re-creating an existing ID is an error.
CreateOrg(context.Context, Org) (Org, error)
// GetOrg returns one org by ID, or ErrOrgNotFound.
@@ -23,8 +23,15 @@ type Repository interface {
// ListWorkspaces returns an org's workspaces, oldest first.
ListWorkspaces(context.Context, OrgID) ([]Workspace, error)
// EnsureMembership grants an identity a role in an org, or in one
// workspace of it; an identical existing membership is not an error.
// workspace of it, changing the role of an existing membership; an
// identical existing membership is not an error.
EnsureMembership(context.Context, Membership) error
// ListMembers returns an org's memberships with the identity each names.
ListMembers(context.Context, OrgID) ([]Member, error)
// RemoveMembership revokes one membership; a missing one is not an error.
RemoveMembership(context.Context, Membership) error
// ListOrgAgents returns the agent and service identities assigned to an org.
ListOrgAgents(context.Context, OrgID) ([]AgentAssignment, error)
// AssignAgent records the one org an agent or service identity serves,
// replacing any prior assignment for that identity.
AssignAgent(context.Context, AgentAssignment) error
@@ -34,6 +41,20 @@ type Repository interface {
OrgForIdentity(context.Context, identity.IdentityID) (OrgID, error)
}
// API is the org surface a remote caller uses: the subset of Repository the
// State Store contract carries. It is the dashboard's read and write surface;
// the assignment list has no RPC and stays off it.
type API interface {
ListOrgs(context.Context) ([]Org, error)
GetOrg(context.Context, OrgID) (Org, error)
ListWorkspaces(context.Context, OrgID) ([]Workspace, error)
CreateWorkspace(context.Context, Workspace) (Workspace, error)
ListMembers(context.Context, OrgID) ([]Member, error)
EnsureMembership(context.Context, Membership) error
RemoveMembership(context.Context, Membership) error
AssignAgent(context.Context, AgentAssignment) error
}
// Upgrader performs the resumable default org/workspace upgrade.
// It runs in
// the State Store first, then in the event store, each phase resumable from
+43
View File
@@ -142,6 +142,49 @@ func (s *Store) AssignAgent(ctx context.Context, value org.AgentAssignment) erro
})
}
// ListMembers returns an org's memberships with the identity each names.
func (s *Store) ListMembers(ctx context.Context, id org.OrgID) ([]org.Member, error) {
rows, err := s.queries().ListMembers(ctx, string(id))
if err != nil {
return nil, err
}
out := make([]org.Member, 0, len(rows))
for _, r := range rows {
var ws org.WorkspaceID
if r.WorkspaceID.Valid {
ws = org.WorkspaceID(r.WorkspaceID.String)
}
out = append(out, org.Member{
IdentityID: identity.IdentityID(r.IdentityID), Kind: identity.Kind(r.Kind),
DisplayName: r.DisplayName, WorkspaceID: ws, Role: org.Role(r.Role),
})
}
return out, nil
}
// RemoveMembership revokes one membership; a missing one is not an error.
func (s *Store) RemoveMembership(ctx context.Context, value org.Membership) error {
if value.IdentityID == "" || value.OrgID == "" {
return fmt.Errorf("%w: identity and org are required", org.ErrInvalidMembership)
}
return s.queries().RemoveMembership(ctx, postgresdb.RemoveMembershipParams{
IdentityID: string(value.IdentityID), OrgID: string(value.OrgID), WorkspaceID: string(value.WorkspaceID),
})
}
// ListOrgAgents returns the agent and service identities assigned to an org.
func (s *Store) ListOrgAgents(ctx context.Context, id org.OrgID) ([]org.AgentAssignment, error) {
rows, err := s.queries().ListOrgAgents(ctx, string(id))
if err != nil {
return nil, err
}
out := make([]org.AgentAssignment, 0, len(rows))
for _, r := range rows {
out = append(out, org.AgentAssignment{IdentityID: identity.IdentityID(r.IdentityID), OrgID: org.OrgID(r.OrgID)})
}
return out, nil
}
// EnsureAgentOrgMembership grants every agent identity the shipped developer
// role in the org it serves. It runs at the State Store's boot, after the
// default-org upgrade, so dispatch's chain has a principal to evaluate.
@@ -0,0 +1,75 @@
package postgres_test
import (
"errors"
"testing"
"github.com/samcharles93/archie-core/internal/domain/identity"
"github.com/samcharles93/archie-core/internal/domain/org"
"github.com/samcharles93/archie-core/internal/infrastructure/postgres/pgstore"
)
// TestOrgStoreMembers pins the org membership queries: a role change updates
// the existing membership, the list joins the identity, removal deletes, agent
// assignment lists, and an unknown role is refused naming it.
func TestOrgStoreMembers(t *testing.T) {
ctx := t.Context()
db := pgstore.Open(t)
if _, err := db.CreateOrg(ctx, org.Org{ID: "acme", Name: "Acme"}); err != nil {
t.Fatalf("create org: %v", err)
}
for _, id := range []string{"sam", "bot"} {
kind := identity.KindUser
name := "Sam"
if id == "bot" {
kind, name = identity.KindBot, "Bot"
}
if _, err := db.Create(ctx, identity.Identity{ID: identity.IdentityID(id), Kind: kind, DisplayName: name, Lifecycle: identity.LifecycleActive}, identity.Audit{ActorID: identity.SystemID, Source: "test", RequestID: "id-" + id}); err != nil {
t.Fatalf("create identity %s: %v", id, err)
}
}
if err := db.EnsureMembership(ctx, org.Membership{IdentityID: "sam", OrgID: "acme", Role: org.RoleDeveloper}); err != nil {
t.Fatalf("ensure membership: %v", err)
}
if err := db.EnsureMembership(ctx, org.Membership{IdentityID: "sam", OrgID: "acme", Role: org.RoleAdmin}); err != nil {
t.Fatalf("change membership: %v", err)
}
members, err := db.ListMembers(ctx, "acme")
if err != nil {
t.Fatalf("list members: %v", err)
}
if len(members) != 1 {
t.Fatalf("members = %d, want 1", len(members))
}
got := members[0]
if got.IdentityID != "sam" || got.Kind != identity.KindUser || got.DisplayName != "Sam" || got.Role != org.RoleAdmin {
t.Fatalf("member = %#v", got)
}
if err := db.RemoveMembership(ctx, org.Membership{IdentityID: "sam", OrgID: "acme"}); err != nil {
t.Fatalf("remove membership: %v", err)
}
if members, err = db.ListMembers(ctx, "acme"); err != nil || len(members) != 0 {
t.Fatalf("after remove: members = %d, err %v", len(members), err)
}
// Removing again is not an error: the target is simply gone.
if err := db.RemoveMembership(ctx, org.Membership{IdentityID: "sam", OrgID: "acme"}); err != nil {
t.Fatalf("second remove: %v", err)
}
if err := db.AssignAgent(ctx, org.AgentAssignment{IdentityID: "bot", OrgID: "acme"}); err != nil {
t.Fatalf("assign agent: %v", err)
}
agents, err := db.ListOrgAgents(ctx, "acme")
if err != nil {
t.Fatalf("list agents: %v", err)
}
if len(agents) != 1 || agents[0].IdentityID != "bot" {
t.Fatalf("agents = %#v", agents)
}
if err := db.EnsureMembership(ctx, org.Membership{IdentityID: "sam", OrgID: "acme", Role: "superuser"}); !errors.Is(err, org.ErrInvalidRole) {
t.Fatalf("unknown role err = %v, want ErrInvalidRole", err)
}
}
@@ -30,7 +30,7 @@ func (q *Queries) EnsureAgentOrgMembership(ctx context.Context) error {
const ensureMembership = `-- name: EnsureMembership :exec
INSERT INTO memberships (identity_id, org_id, workspace_id, role)
VALUES ($1, $2, $3, $4)
ON CONFLICT DO NOTHING
ON CONFLICT (identity_id, org_id, COALESCE(workspace_id, '')) DO UPDATE SET role = excluded.role
`
type EnsureMembershipParams struct {
@@ -40,6 +40,8 @@ type EnsureMembershipParams struct {
Role string
}
// Grant or change a role: a membership that already exists moves to the
// supplied role, so the same call is both create and update.
func (q *Queries) EnsureMembership(ctx context.Context, arg EnsureMembershipParams) error {
_, err := q.db.Exec(ctx, ensureMembership,
arg.IdentityID,
@@ -106,6 +108,48 @@ func (q *Queries) InsertWorkspace(ctx context.Context, arg InsertWorkspaceParams
return err
}
const listMembers = `-- name: ListMembers :many
SELECT m.identity_id, i.kind, i.display_name, m.workspace_id, m.role
FROM memberships m
JOIN identities i ON i.id = m.identity_id
WHERE m.org_id = $1
ORDER BY m.created_at, m.identity_id, m.workspace_id
`
type ListMembersRow struct {
IdentityID string
Kind string
DisplayName string
WorkspaceID pgtype.Text
Role string
}
func (q *Queries) ListMembers(ctx context.Context, orgID string) ([]ListMembersRow, error) {
rows, err := q.db.Query(ctx, listMembers, orgID)
if err != nil {
return nil, err
}
defer rows.Close()
var items []ListMembersRow
for rows.Next() {
var i ListMembersRow
if err := rows.Scan(
&i.IdentityID,
&i.Kind,
&i.DisplayName,
&i.WorkspaceID,
&i.Role,
); err != nil {
return nil, err
}
items = append(items, i)
}
if err := rows.Err(); err != nil {
return nil, err
}
return items, nil
}
const listMembershipsByIdentity = `-- name: ListMembershipsByIdentity :many
SELECT identity_id, org_id, workspace_id, role, created_at
FROM memberships WHERE identity_id = $1 ORDER BY created_at, org_id
@@ -137,6 +181,35 @@ func (q *Queries) ListMembershipsByIdentity(ctx context.Context, identityID stri
return items, nil
}
const listOrgAgents = `-- name: ListOrgAgents :many
SELECT identity_id, org_id FROM org_agents WHERE org_id = $1 ORDER BY identity_id
`
type ListOrgAgentsRow struct {
IdentityID string
OrgID string
}
func (q *Queries) ListOrgAgents(ctx context.Context, orgID string) ([]ListOrgAgentsRow, error) {
rows, err := q.db.Query(ctx, listOrgAgents, orgID)
if err != nil {
return nil, err
}
defer rows.Close()
var items []ListOrgAgentsRow
for rows.Next() {
var i ListOrgAgentsRow
if err := rows.Scan(&i.IdentityID, &i.OrgID); err != nil {
return nil, err
}
items = append(items, i)
}
if err := rows.Err(); err != nil {
return nil, err
}
return items, nil
}
const listOrgOwners = `-- name: ListOrgOwners :many
SELECT identity_id FROM memberships
WHERE org_id = $1 AND workspace_id IS NULL AND role = 'owner'
@@ -224,6 +297,24 @@ func (q *Queries) ListWorkspaces(ctx context.Context, orgID string) ([]Workspace
return items, nil
}
const removeMembership = `-- name: RemoveMembership :exec
DELETE FROM memberships
WHERE identity_id = $1 AND org_id = $2 AND COALESCE(workspace_id, '') = $3::text
`
type RemoveMembershipParams struct {
IdentityID string
OrgID string
WorkspaceID string
}
// The workspace is matched through the same COALESCE the unique index uses, so
// an org-wide membership (NULL) and the empty string are the same target.
func (q *Queries) RemoveMembership(ctx context.Context, arg RemoveMembershipParams) error {
_, err := q.db.Exec(ctx, removeMembership, arg.IdentityID, arg.OrgID, arg.WorkspaceID)
return err
}
const resolveIdentityOrg = `-- name: ResolveIdentityOrg :one
SELECT COALESCE(
(SELECT a.org_id FROM org_agents a WHERE a.identity_id = $1),
@@ -20,9 +20,27 @@ SELECT id, org_id, name, environment, created_at, updated_at
FROM workspaces WHERE org_id = $1 ORDER BY created_at, id;
-- name: EnsureMembership :exec
-- Grant or change a role: a membership that already exists moves to the
-- supplied role, so the same call is both create and update.
INSERT INTO memberships (identity_id, org_id, workspace_id, role)
VALUES ($1, $2, $3, $4)
ON CONFLICT DO NOTHING;
ON CONFLICT (identity_id, org_id, COALESCE(workspace_id, '')) DO UPDATE SET role = excluded.role;
-- name: ListMembers :many
SELECT m.identity_id, i.kind, i.display_name, m.workspace_id, m.role
FROM memberships m
JOIN identities i ON i.id = m.identity_id
WHERE m.org_id = $1
ORDER BY m.created_at, m.identity_id, m.workspace_id;
-- name: RemoveMembership :exec
-- The workspace is matched through the same COALESCE the unique index uses, so
-- an org-wide membership (NULL) and the empty string are the same target.
DELETE FROM memberships
WHERE identity_id = $1 AND org_id = $2 AND COALESCE(workspace_id, '') = sqlc.arg(workspace_id)::text;
-- name: ListOrgAgents :many
SELECT identity_id, org_id FROM org_agents WHERE org_id = $1 ORDER BY identity_id;
-- name: ListMembershipsByIdentity :many
SELECT identity_id, org_id, workspace_id, role, created_at
+190
View File
@@ -0,0 +1,190 @@
package staterpc
import (
"context"
"errors"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
pb "github.com/samcharles93/archie-core/internal/contracts/state/v1"
"github.com/samcharles93/archie-core/internal/domain/identity"
"github.com/samcharles93/archie-core/internal/domain/org"
)
// errOrgsUnavailable reports that this process hosts no org store.
var errOrgsUnavailable = status.Error(codes.Unavailable, "org store unavailable")
// orgStatus maps the org domain's errors onto the wire, keeping the message
// that names the offending role, org or workspace.
func orgStatus(err error) error {
switch {
case errors.Is(err, org.ErrOrgNotFound):
return status.Error(codes.NotFound, err.Error())
case errors.Is(err, org.ErrOrgExists), errors.Is(err, org.ErrWorkspaceExists), errors.Is(err, org.ErrMembershipExists):
return status.Error(codes.Aborted, err.Error())
case errors.Is(err, org.ErrInvalidRole), errors.Is(err, org.ErrInvalidOrg),
errors.Is(err, org.ErrInvalidMembership), errors.Is(err, org.ErrInvalidWorkspace),
errors.Is(err, org.ErrInvalidAssignment), errors.Is(err, org.ErrUpgradeIncomplete):
return status.Error(codes.InvalidArgument, err.Error())
}
return mapError(err)
}
// orgErr logs and maps one org RPC's failure.
func (s *server) orgErr(rpc string, err error) error {
if err != nil {
s.deps.Log.Error("staterpc call failed", "rpc", rpc, "err", err)
}
return orgStatus(err)
}
func orgProto(o org.Org) *pb.Org { return &pb.Org{Id: string(o.ID), Name: o.Name} }
func orgValue(o *pb.Org) org.Org { return org.Org{ID: org.OrgID(o.GetId()), Name: o.GetName()} }
func workspaceProto(w org.Workspace) *pb.Workspace {
return &pb.Workspace{Id: string(w.ID), OrgId: string(w.OrgID), Name: w.Name, Environment: w.Environment}
}
func workspaceValue(w *pb.Workspace) org.Workspace {
return org.Workspace{
ID: org.WorkspaceID(w.GetId()), OrgID: org.OrgID(w.GetOrgId()),
Name: w.GetName(), Environment: w.GetEnvironment(),
}
}
func memberProto(m org.Member) *pb.Member {
return &pb.Member{
IdentityId: string(m.IdentityID), Kind: string(m.Kind), DisplayName: m.DisplayName,
WorkspaceId: string(m.WorkspaceID), Role: string(m.Role),
}
}
func (s *server) ListOrgs(ctx context.Context, _ *pb.ListOrgsRequest) (*pb.ListOrgsResponse, error) {
if s.deps.Orgs == nil {
return nil, errOrgsUnavailable
}
values, err := s.deps.Orgs.ListOrgs(ctx)
if err != nil {
return nil, s.orgErr("ListOrgs", err)
}
out := make([]*pb.Org, len(values))
for i := range values {
out[i] = orgProto(values[i])
}
return &pb.ListOrgsResponse{Orgs: out}, nil
}
// orgInForce is the org a request is served for: the one the caller's
// principal carries. A request field cannot choose another tenant.
func orgInForce(ctx context.Context) org.OrgID { return org.OrgFromContext(ctx) }
func (s *server) GetOrg(ctx context.Context, _ *pb.GetOrgRequest) (*pb.GetOrgResponse, error) {
if s.deps.Orgs == nil {
return nil, errOrgsUnavailable
}
value, err := s.deps.Orgs.GetOrg(ctx, orgInForce(ctx))
if err != nil {
return nil, s.orgErr("GetOrg", err)
}
return &pb.GetOrgResponse{Org: orgProto(value)}, nil
}
func (s *server) CreateOrg(ctx context.Context, r *pb.CreateOrgRequest) (*pb.CreateOrgResponse, error) {
if s.deps.Orgs == nil {
return nil, errOrgsUnavailable
}
value, err := s.deps.Orgs.CreateOrg(ctx, orgValue(&pb.Org{Id: r.GetId(), Name: r.GetName()}))
if err != nil {
return nil, s.orgErr("CreateOrg", err)
}
return &pb.CreateOrgResponse{Org: orgProto(value)}, nil
}
func (s *server) ListWorkspaces(ctx context.Context, _ *pb.ListWorkspacesRequest) (*pb.ListWorkspacesResponse, error) {
if s.deps.Orgs == nil {
return nil, errOrgsUnavailable
}
values, err := s.deps.Orgs.ListWorkspaces(ctx, orgInForce(ctx))
if err != nil {
return nil, s.orgErr("ListWorkspaces", err)
}
out := make([]*pb.Workspace, len(values))
for i := range values {
out[i] = workspaceProto(values[i])
}
return &pb.ListWorkspacesResponse{Workspaces: out}, nil
}
func (s *server) CreateWorkspace(ctx context.Context, r *pb.CreateWorkspaceRequest) (*pb.CreateWorkspaceResponse, error) {
if s.deps.Orgs == nil {
return nil, errOrgsUnavailable
}
value := workspaceValue(&pb.Workspace{Id: r.GetId(), OrgId: string(orgInForce(ctx)), Name: r.GetName(), Environment: r.GetEnvironment()})
created, err := s.deps.Orgs.CreateWorkspace(ctx, value)
if err != nil {
return nil, s.orgErr("CreateWorkspace", err)
}
return &pb.CreateWorkspaceResponse{Workspace: workspaceProto(created)}, nil
}
func (s *server) ListMembers(ctx context.Context, _ *pb.ListMembersRequest) (*pb.ListMembersResponse, error) {
if s.deps.Orgs == nil {
return nil, errOrgsUnavailable
}
values, err := s.deps.Orgs.ListMembers(ctx, orgInForce(ctx))
if err != nil {
return nil, s.orgErr("ListMembers", err)
}
out := make([]*pb.Member, len(values))
for i := range values {
out[i] = memberProto(values[i])
}
return &pb.ListMembersResponse{Members: out}, nil
}
func (s *server) SetMembership(ctx context.Context, r *pb.SetMembershipRequest) (*pb.SetMembershipResponse, error) {
if s.deps.Orgs == nil {
return nil, errOrgsUnavailable
}
err := s.deps.Orgs.EnsureMembership(ctx, org.Membership{
IdentityID: identity.IdentityID(r.GetIdentityId()),
OrgID: orgInForce(ctx),
WorkspaceID: org.WorkspaceID(r.GetWorkspaceId()),
Role: org.Role(r.GetRole()),
})
if err != nil {
return nil, s.orgErr("SetMembership", err)
}
return &pb.SetMembershipResponse{}, nil
}
func (s *server) RemoveMembership(ctx context.Context, r *pb.RemoveMembershipRequest) (*pb.RemoveMembershipResponse, error) {
if s.deps.Orgs == nil {
return nil, errOrgsUnavailable
}
err := s.deps.Orgs.RemoveMembership(ctx, org.Membership{
IdentityID: identity.IdentityID(r.GetIdentityId()),
OrgID: orgInForce(ctx),
WorkspaceID: org.WorkspaceID(r.GetWorkspaceId()),
})
if err != nil {
return nil, s.orgErr("RemoveMembership", err)
}
return &pb.RemoveMembershipResponse{}, nil
}
func (s *server) AssignAgent(ctx context.Context, r *pb.AssignAgentRequest) (*pb.AssignAgentResponse, error) {
if s.deps.Orgs == nil {
return nil, errOrgsUnavailable
}
err := s.deps.Orgs.AssignAgent(ctx, org.AgentAssignment{
IdentityID: identity.IdentityID(r.GetIdentityId()),
OrgID: orgInForce(ctx),
})
if err != nil {
return nil, s.orgErr("AssignAgent", err)
}
return &pb.AssignAgentResponse{}, nil
}
@@ -0,0 +1,87 @@
package staterpc
import (
"context"
pb "github.com/samcharles93/archie-core/internal/contracts/state/v1"
"github.com/samcharles93/archie-core/internal/domain/identity"
"github.com/samcharles93/archie-core/internal/domain/org"
)
// The Client serves the dashboard's org surface over the contract.
var _ org.API = (*Client)(nil)
func (c *Client) CreateOrg(ctx context.Context, value org.Org) (org.Org, error) {
r, err := c.client.CreateOrg(ctx, &pb.CreateOrgRequest{Id: string(value.ID), Name: value.Name})
if err != nil {
return org.Org{}, unmapError(err)
}
return orgValue(r.Org), nil
}
func (c *Client) GetOrg(ctx context.Context, id org.OrgID) (org.Org, error) {
r, err := c.client.GetOrg(ctx, &pb.GetOrgRequest{OrgId: string(id)})
if err != nil {
return org.Org{}, unmapError(err)
}
return orgValue(r.Org), nil
}
func (c *Client) ListOrgs(ctx context.Context) ([]org.Org, error) {
r, err := c.client.ListOrgs(ctx, &pb.ListOrgsRequest{})
if err != nil {
return nil, unmapError(err)
}
return mapValues(r.Orgs, orgValue), nil
}
func (c *Client) CreateWorkspace(ctx context.Context, value org.Workspace) (org.Workspace, error) {
r, err := c.client.CreateWorkspace(ctx, &pb.CreateWorkspaceRequest{
OrgId: string(value.OrgID), Id: string(value.ID), Name: value.Name, Environment: value.Environment,
})
if err != nil {
return org.Workspace{}, unmapError(err)
}
return workspaceValue(r.Workspace), nil
}
func (c *Client) ListWorkspaces(ctx context.Context, id org.OrgID) ([]org.Workspace, error) {
r, err := c.client.ListWorkspaces(ctx, &pb.ListWorkspacesRequest{OrgId: string(id)})
if err != nil {
return nil, unmapError(err)
}
return mapValues(r.Workspaces, workspaceValue), nil
}
func (c *Client) EnsureMembership(ctx context.Context, value org.Membership) error {
_, err := c.client.SetMembership(ctx, &pb.SetMembershipRequest{
OrgId: string(value.OrgID), IdentityId: string(value.IdentityID),
WorkspaceId: string(value.WorkspaceID), Role: string(value.Role),
})
return unmapError(err)
}
func (c *Client) ListMembers(ctx context.Context, id org.OrgID) ([]org.Member, error) {
r, err := c.client.ListMembers(ctx, &pb.ListMembersRequest{OrgId: string(id)})
if err != nil {
return nil, unmapError(err)
}
return mapValues(r.Members, func(m *pb.Member) org.Member {
return org.Member{
IdentityID: identity.IdentityID(m.GetIdentityId()), Kind: identity.Kind(m.GetKind()),
DisplayName: m.GetDisplayName(), WorkspaceID: org.WorkspaceID(m.GetWorkspaceId()), Role: org.Role(m.GetRole()),
}
}), nil
}
func (c *Client) RemoveMembership(ctx context.Context, value org.Membership) error {
_, err := c.client.RemoveMembership(ctx, &pb.RemoveMembershipRequest{
OrgId: string(value.OrgID), IdentityId: string(value.IdentityID), WorkspaceId: string(value.WorkspaceID),
})
return unmapError(err)
}
func (c *Client) AssignAgent(ctx context.Context, value org.AgentAssignment) error {
_, err := c.client.AssignAgent(ctx, &pb.AssignAgentRequest{OrgId: string(value.OrgID), IdentityId: string(value.IdentityID)})
return unmapError(err)
}
@@ -0,0 +1,113 @@
package staterpc
import (
"context"
"log/slog"
"strings"
"testing"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
pb "github.com/samcharles93/archie-core/internal/contracts/state/v1"
"github.com/samcharles93/archie-core/internal/domain/identity"
"github.com/samcharles93/archie-core/internal/domain/org"
)
// fakeOrgs records the calls the org RPCs make, validating memberships the way
// the store does.
type fakeOrgs struct {
workspaces []org.Workspace
members []org.Membership
agents []org.AgentAssignment
}
func (*fakeOrgs) CreateOrg(_ context.Context, value org.Org) (org.Org, error) { return value, nil }
func (*fakeOrgs) GetOrg(_ context.Context, id org.OrgID) (org.Org, error) {
return org.Org{ID: id, Name: "Acme"}, nil
}
func (*fakeOrgs) ListOrgs(context.Context) ([]org.Org, error) { return nil, nil }
func (f *fakeOrgs) CreateWorkspace(_ context.Context, value org.Workspace) (org.Workspace, error) {
f.workspaces = append(f.workspaces, value)
return value, nil
}
func (*fakeOrgs) ListWorkspaces(context.Context, org.OrgID) ([]org.Workspace, error) { return nil, nil }
func (f *fakeOrgs) EnsureMembership(_ context.Context, value org.Membership) error {
if err := value.Validate(); err != nil {
return err
}
f.members = append(f.members, value)
return nil
}
func (*fakeOrgs) ListMembers(context.Context, org.OrgID) ([]org.Member, error) { return nil, nil }
func (f *fakeOrgs) RemoveMembership(_ context.Context, value org.Membership) error {
f.members = append(f.members, value)
return nil
}
func (*fakeOrgs) ListOrgAgents(context.Context, org.OrgID) ([]org.AgentAssignment, error) {
return nil, nil
}
func (f *fakeOrgs) AssignAgent(_ context.Context, value org.AgentAssignment) error {
f.agents = append(f.agents, value)
return nil
}
func (*fakeOrgs) OrgForIdentity(context.Context, identity.IdentityID) (org.OrgID, error) {
return "", nil
}
// TestOrgRPCsActInTheCallersOrg pins the tenant guard: a request field cannot
// move a call into another org.
func TestOrgRPCsActInTheCallersOrg(t *testing.T) {
repo := &fakeOrgs{}
s := &server{deps: Deps{Orgs: repo, Log: slog.New(slog.DiscardHandler)}}
ctx := org.WithOrg(context.Background(), "acme")
got, err := s.GetOrg(ctx, &pb.GetOrgRequest{OrgId: "other"})
if err != nil || got.GetOrg().GetId() != "acme" {
t.Fatalf("GetOrg acted in %q, err %v", got.GetOrg().GetId(), err)
}
if _, err := s.SetMembership(ctx, &pb.SetMembershipRequest{OrgId: "other", IdentityId: "sam", Role: string(org.RoleDeveloper)}); err != nil {
t.Fatal(err)
}
if _, err := s.RemoveMembership(ctx, &pb.RemoveMembershipRequest{OrgId: "other", IdentityId: "sam"}); err != nil {
t.Fatal(err)
}
if _, err := s.AssignAgent(ctx, &pb.AssignAgentRequest{OrgId: "other", IdentityId: "bot"}); err != nil {
t.Fatal(err)
}
if _, err := s.CreateWorkspace(ctx, &pb.CreateWorkspaceRequest{OrgId: "other", Id: "ws", Name: "Workspace"}); err != nil {
t.Fatal(err)
}
for _, membership := range repo.members {
if membership.OrgID != "acme" {
t.Fatalf("membership acted in %q, want acme", membership.OrgID)
}
}
if len(repo.agents) != 1 || repo.agents[0].OrgID != "acme" {
t.Fatalf("agents = %#v", repo.agents)
}
if len(repo.workspaces) != 1 || repo.workspaces[0].OrgID != "acme" {
t.Fatalf("workspaces = %#v", repo.workspaces)
}
}
// TestSetMembershipRefusesUnknownRole pins that the store's role validation
// reaches the wire as InvalidArgument and names the role.
func TestSetMembershipRefusesUnknownRole(t *testing.T) {
s := &server{deps: Deps{Orgs: &fakeOrgs{}, Log: slog.New(slog.DiscardHandler)}}
_, err := s.SetMembership(org.WithOrg(context.Background(), "acme"), &pb.SetMembershipRequest{IdentityId: "sam", Role: "superuser"})
if status.Code(err) != codes.InvalidArgument || !strings.Contains(status.Convert(err).Message(), "superuser") {
t.Fatalf("err = %v, want InvalidArgument naming the role", err)
}
}
@@ -20,6 +20,7 @@ import (
"github.com/samcharles93/archie-core/internal/domain/binding"
"github.com/samcharles93/archie-core/internal/domain/identity"
"github.com/samcharles93/archie-core/internal/domain/mapping"
"github.com/samcharles93/archie-core/internal/domain/org"
"github.com/samcharles93/archie-core/internal/domain/source"
"github.com/samcharles93/archie-core/internal/domain/storecontract"
"github.com/samcharles93/archie-core/internal/domain/storepkg"
@@ -133,6 +134,9 @@ type Deps struct {
// Denials records and lists denial records. Optional: nil disables the
// pair with codes.Unavailable.
Denials access.DenialStore
// Orgs persists orgs, workspaces, memberships and agent assignments.
// Optional: nil answers the org RPCs with codes.Unavailable.
Orgs org.Repository
// TaskLogs reads task attempt logs. Nil answers ReadTaskLog with
// Unavailable.
TaskLogs storecontract.TaskLogStore
+221
View File
@@ -0,0 +1,221 @@
package webui
import (
"encoding/json"
"errors"
"net/http"
"github.com/samcharles93/archie-core/internal/domain/identity"
"github.com/samcharles93/archie-core/internal/domain/org"
)
// orgReady answers Unavailable when this process hosts no org store.
func (s *Server) orgReady(w http.ResponseWriter) bool {
if s.Orgs == nil {
http.Error(w, "orgs unavailable", http.StatusServiceUnavailable)
return false
}
return true
}
// orgInPath resolves the route's {id}, requiring it to be the caller's own
// org: the dashboard has no instance-admin view yet, so a path that names
// another tenant reads as not found rather than leaking it.
func (s *Server) orgInPath(w http.ResponseWriter, r *http.Request) (org.OrgID, bool) {
caller := policyOrg(r)
if r.PathValue("id") != string(caller) {
http.Error(w, "org not found", http.StatusNotFound)
return "", false
}
return caller, true
}
// handleOrgsList lists the caller's org only. The State Store contract lists
// every org; instance-admin widening is a later change.
func (s *Server) handleOrgsList(w http.ResponseWriter, r *http.Request) {
if !s.orgReady(w) {
return
}
values, err := s.Orgs.ListOrgs(r.Context())
if err != nil {
writeOrgError(w, err)
return
}
caller := policyOrg(r)
out := []org.Org{}
for _, value := range values {
if value.ID == caller {
out = append(out, value)
}
}
writeJSON(w, map[string]any{"orgs": out})
}
func (s *Server) handleOrgGet(w http.ResponseWriter, r *http.Request) {
if !s.orgReady(w) {
return
}
id, ok := s.orgInPath(w, r)
if !ok {
return
}
value, err := s.Orgs.GetOrg(r.Context(), id)
if err != nil {
writeOrgError(w, err)
return
}
writeJSON(w, map[string]any{"org": value})
}
func (s *Server) handleOrgWorkspacesList(w http.ResponseWriter, r *http.Request) {
if !s.orgReady(w) {
return
}
id, ok := s.orgInPath(w, r)
if !ok {
return
}
values, err := s.Orgs.ListWorkspaces(r.Context(), id)
if err != nil {
writeOrgError(w, err)
return
}
if values == nil {
values = []org.Workspace{}
}
writeJSON(w, map[string]any{"workspaces": values})
}
func (s *Server) handleOrgWorkspaceCreate(w http.ResponseWriter, r *http.Request) {
if !s.orgReady(w) {
return
}
id, ok := s.orgInPath(w, r)
if !ok {
return
}
var request struct {
ID string `json:"id"`
Name string `json:"name"`
Environment string `json:"environment"`
}
if err := json.NewDecoder(http.MaxBytesReader(w, r.Body, 16<<10)).Decode(&request); err != nil {
http.Error(w, "invalid workspace: "+err.Error(), http.StatusBadRequest)
return
}
value, err := s.Orgs.CreateWorkspace(r.Context(), org.Workspace{
ID: org.WorkspaceID(request.ID), OrgID: id, Name: request.Name, Environment: request.Environment,
})
if err != nil {
writeOrgError(w, err)
return
}
w.WriteHeader(http.StatusCreated)
writeJSON(w, map[string]any{"workspace": value})
}
func (s *Server) handleOrgMembersList(w http.ResponseWriter, r *http.Request) {
if !s.orgReady(w) {
return
}
id, ok := s.orgInPath(w, r)
if !ok {
return
}
values, err := s.Orgs.ListMembers(r.Context(), id)
if err != nil {
writeOrgError(w, err)
return
}
if values == nil {
values = []org.Member{}
}
writeJSON(w, map[string]any{"members": values})
}
// handleOrgMemberSet grants or moves one identity's role in the caller's org,
// or in one workspace when the body names one.
func (s *Server) handleOrgMemberSet(w http.ResponseWriter, r *http.Request) {
if !s.orgReady(w) {
return
}
id, ok := s.orgInPath(w, r)
if !ok {
return
}
var request struct {
Role string `json:"role"`
Workspace string `json:"workspace"`
}
if err := json.NewDecoder(http.MaxBytesReader(w, r.Body, 16<<10)).Decode(&request); err != nil {
http.Error(w, "invalid membership: "+err.Error(), http.StatusBadRequest)
return
}
membership := org.Membership{
IdentityID: identity.IdentityID(r.PathValue("identity")),
OrgID: id,
WorkspaceID: org.WorkspaceID(request.Workspace),
Role: org.Role(request.Role),
}
if err := s.Orgs.EnsureMembership(r.Context(), membership); err != nil {
writeOrgError(w, err)
return
}
writeJSON(w, map[string]any{"membership": membership})
}
func (s *Server) handleOrgMemberRemove(w http.ResponseWriter, r *http.Request) {
if !s.orgReady(w) {
return
}
id, ok := s.orgInPath(w, r)
if !ok {
return
}
membership := org.Membership{
IdentityID: identity.IdentityID(r.PathValue("identity")),
OrgID: id,
WorkspaceID: org.WorkspaceID(r.URL.Query().Get("workspace")),
}
if err := s.Orgs.RemoveMembership(r.Context(), membership); err != nil {
writeOrgError(w, err)
return
}
w.WriteHeader(http.StatusNoContent)
}
func (s *Server) handleOrgAgentAssign(w http.ResponseWriter, r *http.Request) {
if !s.orgReady(w) {
return
}
id, ok := s.orgInPath(w, r)
if !ok {
return
}
err := s.Orgs.AssignAgent(r.Context(), org.AgentAssignment{
IdentityID: identity.IdentityID(r.PathValue("identity")), OrgID: id,
})
if err != nil {
writeOrgError(w, err)
return
}
writeJSON(w, map[string]any{"assigned": true})
}
// writeOrgError maps the org domain's errors, and their gRPC statuses, onto
// HTTP. The remote-client path keeps the status code through unmapError's
// wrapping, so writeControlPlaneError names the same code the store sent.
func writeOrgError(w http.ResponseWriter, err error) {
switch {
case errors.Is(err, org.ErrInvalidRole), errors.Is(err, org.ErrInvalidOrg),
errors.Is(err, org.ErrInvalidMembership), errors.Is(err, org.ErrInvalidWorkspace),
errors.Is(err, org.ErrInvalidAssignment):
http.Error(w, err.Error(), http.StatusBadRequest)
case errors.Is(err, org.ErrOrgNotFound):
http.Error(w, err.Error(), http.StatusNotFound)
case errors.Is(err, org.ErrOrgExists), errors.Is(err, org.ErrWorkspaceExists), errors.Is(err, org.ErrMembershipExists):
http.Error(w, err.Error(), http.StatusConflict)
default:
writeControlPlaneError(w, err)
}
}
+155
View File
@@ -0,0 +1,155 @@
package webui
import (
"context"
"io"
"net/http"
"net/http/httptest"
"strings"
"testing"
"github.com/samcharles93/archie-core/internal/domain/identity"
"github.com/samcharles93/archie-core/internal/domain/org"
)
// fakeOrgs is an in-memory org.API that validates memberships the way the
// store does.
type fakeOrgs struct {
orgs []org.Org
workspaces map[org.OrgID][]org.Workspace
members map[org.OrgID][]org.Member
agents []org.AgentAssignment
}
func newFakeOrgs() *fakeOrgs {
return &fakeOrgs{
orgs: []org.Org{{ID: org.DefaultOrgID, Name: "System"}},
workspaces: map[org.OrgID][]org.Workspace{},
members: map[org.OrgID][]org.Member{
org.DefaultOrgID: {{IdentityID: "seed", Kind: identity.KindUser, DisplayName: "Seed", Role: org.RoleDeveloper}},
},
}
}
func (f *fakeOrgs) ListOrgs(context.Context) ([]org.Org, error) { return f.orgs, nil }
func (f *fakeOrgs) GetOrg(_ context.Context, id org.OrgID) (org.Org, error) {
for _, o := range f.orgs {
if o.ID == id {
return o, nil
}
}
return org.Org{}, org.ErrOrgNotFound
}
func (f *fakeOrgs) ListWorkspaces(_ context.Context, id org.OrgID) ([]org.Workspace, error) {
return f.workspaces[id], nil
}
func (f *fakeOrgs) CreateWorkspace(_ context.Context, value org.Workspace) (org.Workspace, error) {
if err := value.Validate(); err != nil {
return org.Workspace{}, err
}
f.workspaces[value.OrgID] = append(f.workspaces[value.OrgID], value)
return value, nil
}
func (f *fakeOrgs) ListMembers(_ context.Context, id org.OrgID) ([]org.Member, error) {
return f.members[id], nil
}
func (f *fakeOrgs) EnsureMembership(_ context.Context, value org.Membership) error {
if err := value.Validate(); err != nil {
return err
}
list := f.members[value.OrgID]
for i := range list {
if list[i].IdentityID == value.IdentityID && list[i].WorkspaceID == value.WorkspaceID {
list[i].Role = value.Role
return nil
}
}
f.members[value.OrgID] = append(list, org.Member{IdentityID: value.IdentityID, WorkspaceID: value.WorkspaceID, Role: value.Role})
return nil
}
func (f *fakeOrgs) RemoveMembership(_ context.Context, value org.Membership) error {
kept := f.members[value.OrgID][:0]
for _, m := range f.members[value.OrgID] {
if m.IdentityID == value.IdentityID && m.WorkspaceID == value.WorkspaceID {
continue
}
kept = append(kept, m)
}
f.members[value.OrgID] = kept
return nil
}
func (f *fakeOrgs) AssignAgent(_ context.Context, value org.AgentAssignment) error {
f.agents = append(f.agents, value)
return nil
}
// orgRoutes is the org mux behind the same credential and authorize wrappers
// the real server mounts.
func orgRoutes(s *Server) http.Handler {
mux := http.NewServeMux()
mux.HandleFunc("GET /api/orgs", s.handleOrgsList)
mux.HandleFunc("GET /api/orgs/{id}", s.handleOrgGet)
mux.HandleFunc("GET /api/orgs/{id}/workspaces", s.handleOrgWorkspacesList)
mux.HandleFunc("POST /api/orgs/{id}/workspaces", s.handleOrgWorkspaceCreate)
mux.HandleFunc("GET /api/orgs/{id}/members", s.handleOrgMembersList)
mux.HandleFunc("PUT /api/orgs/{id}/members/{identity}", s.handleOrgMemberSet)
mux.HandleFunc("DELETE /api/orgs/{id}/members/{identity}", s.handleOrgMemberRemove)
mux.HandleFunc("PUT /api/orgs/{id}/agents/{identity}", s.handleOrgAgentAssign)
return s.requireToken(s.authorize(mux))
}
// TestOrgRoutes drives the dashboard's org API through its HTTP handlers: the
// shared-token session lists its own org, its workspaces and members, adds a
// membership, changes its role and removes it, and an unknown role is refused
// naming the role.
func TestOrgRoutes(t *testing.T) {
tests := []struct {
name string
method string
path string
body string
wantStatus int
wantBody string
}{
{"lists the caller's org", http.MethodGet, "/api/orgs", "", http.StatusOK, string(org.DefaultOrgID)},
{"another org reads as not found", http.MethodGet, "/api/orgs/other", "", http.StatusNotFound, ""},
{"reads the caller's org", http.MethodGet, "/api/orgs/" + string(org.DefaultOrgID), "", http.StatusOK, "System"},
{"lists workspaces", http.MethodGet, "/api/orgs/" + string(org.DefaultOrgID) + "/workspaces", "", http.StatusOK, "workspaces"},
{"creates a workspace", http.MethodPost, "/api/orgs/" + string(org.DefaultOrgID) + "/workspaces", `{"id":"ops","name":"Ops"}`, http.StatusCreated, "ops"},
{"lists members", http.MethodGet, "/api/orgs/" + string(org.DefaultOrgID) + "/members", "", http.StatusOK, "seed"},
{"adds a membership", http.MethodPut, "/api/orgs/" + string(org.DefaultOrgID) + "/members/sam", `{"role":"developer"}`, http.StatusOK, "developer"},
{"changes a membership's role", http.MethodPut, "/api/orgs/" + string(org.DefaultOrgID) + "/members/seed", `{"role":"admin"}`, http.StatusOK, "admin"},
{"removes a membership", http.MethodDelete, "/api/orgs/" + string(org.DefaultOrgID) + "/members/seed", "", http.StatusNoContent, ""},
{"assigns an agent", http.MethodPut, "/api/orgs/" + string(org.DefaultOrgID) + "/agents/bot", "", http.StatusOK, "true"},
{"an unknown role is refused naming it", http.MethodPut, "/api/orgs/" + string(org.DefaultOrgID) + "/members/sam", `{"role":"superuser"}`, http.StatusBadRequest, "superuser"},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
s := &Server{Token: "shared", Access: allowAll{}, Principals: stubPrincipals(true), Orgs: newFakeOrgs()}
var body io.Reader
if tt.body != "" {
body = strings.NewReader(tt.body)
}
req := httptest.NewRequestWithContext(t.Context(), tt.method, tt.path, body)
req.Header.Set("Authorization", "Bearer shared")
if tt.body != "" {
req.Header.Set("Content-Type", "application/json")
}
rec := httptest.NewRecorder()
orgRoutes(s).ServeHTTP(rec, req)
if rec.Code != tt.wantStatus {
t.Fatalf("status = %d, body %s", rec.Code, rec.Body.String())
}
if tt.wantBody != "" && !strings.Contains(rec.Body.String(), tt.wantBody) {
t.Fatalf("body = %s, want it to contain %q", rec.Body.String(), tt.wantBody)
}
})
}
}
+22 -4
View File
@@ -136,6 +136,8 @@ func routeOverride(action access.Action, path string) (access.Action, access.Res
return policyAction(action), access.KindPolicy, "", true
case matchPrefix(path, "/api/identities"):
return actionManage(action), access.KindIdentity, segmentValue(path, 2), true
case matchPrefix(path, "/api/orgs"):
return orgRouteAction(action), access.KindOrg, segmentValue(path, 2), true
case matchPrefix(path, "/api/extensions"):
// Installing and enabling an extension runs a process on the host, so it
// is the same administration as editing a control-plane resource.
@@ -143,10 +145,7 @@ func routeOverride(action access.Action, path string) (access.Action, access.Res
case matchPrefix(path, "/api/control-plane/resources"):
return actionManage(action), access.KindPolicy, segmentValue(path, 3), true
case matchPrefix(path, "/api/chat"):
if action == access.ActionCreate {
return access.ActionRun, access.KindWorkflow, "", true
}
return access.ActionRead, access.KindDashboard, "", true
return chatRoute(action)
case matchSegment(path, "/api/sources/", "/secret"):
return access.ActionUpdate, access.KindSecret, segmentValue(path, 2), true
case matchPrefix(path, "/api/harness/terminal"):
@@ -179,6 +178,25 @@ func bindingCommand(action access.Action, path string) (access.Action, bool) {
return action, false
}
// orgRouteAction maps an org request: reads are org reads, and every mutation
// of the org's workspaces, members or agents is an update of the org itself,
// so the read/edit role policies decide it.
func orgRouteAction(action access.Action) access.Action {
if action == access.ActionRead {
return access.ActionRead
}
return access.ActionUpdate
}
// chatRoute maps a chat request: posting runs a workflow, anything else reads
// the dashboard.
func chatRoute(action access.Action) (access.Action, access.ResourceKind, string, bool) {
if action == access.ActionCreate {
return access.ActionRun, access.KindWorkflow, "", true
}
return access.ActionRead, access.KindDashboard, "", true
}
// kindOf maps a collection route onto the resource kind it addresses.
func kindOf(path string) access.ResourceKind {
switch {
+13
View File
@@ -15,6 +15,7 @@ import (
"github.com/samcharles93/archie-core/internal/domain/access"
"github.com/samcharles93/archie-core/internal/domain/health"
"github.com/samcharles93/archie-core/internal/domain/identity"
"github.com/samcharles93/archie-core/internal/domain/org"
"github.com/samcharles93/archie-core/internal/domain/storecontract"
"github.com/samcharles93/archie-core/internal/domain/storepkg"
"github.com/samcharles93/archie-core/internal/events"
@@ -126,6 +127,10 @@ type Server struct {
Principals access.PrincipalSource
Denials access.DenialRecorder
// Orgs serves the org pages: the caller's org, its workspaces, members and
// agent assignments. Nil answers the org routes Unavailable.
Orgs org.API
// Events publishes operator actions so they reach the task timeline and
// the live activity stream. Optional: nil means the action is recorded
// in the store but invisible to anyone watching.
@@ -323,6 +328,14 @@ func (s *Server) registerConfigAndLogRoutes(mux *http.ServeMux) {
mux.HandleFunc("POST /api/control-plane/resources/{kind}/commands/{command}", s.handleControlPlaneCommand)
mux.HandleFunc("GET /api/control-plane/audit", s.handleAudit)
mux.HandleFunc("GET /api/identities", s.handleIdentitiesList)
mux.HandleFunc("GET /api/orgs", s.handleOrgsList)
mux.HandleFunc("GET /api/orgs/{id}", s.handleOrgGet)
mux.HandleFunc("GET /api/orgs/{id}/workspaces", s.handleOrgWorkspacesList)
mux.HandleFunc("POST /api/orgs/{id}/workspaces", s.handleOrgWorkspaceCreate)
mux.HandleFunc("GET /api/orgs/{id}/members", s.handleOrgMembersList)
mux.HandleFunc("PUT /api/orgs/{id}/members/{identity}", s.handleOrgMemberSet)
mux.HandleFunc("DELETE /api/orgs/{id}/members/{identity}", s.handleOrgMemberRemove)
mux.HandleFunc("PUT /api/orgs/{id}/agents/{identity}", s.handleOrgAgentAssign)
mux.HandleFunc("GET /api/tokens", s.handlePersonalTokensList)
mux.HandleFunc("POST /api/tokens", s.handlePersonalTokenCreate)
mux.HandleFunc("DELETE /api/tokens/{id}", s.handlePersonalTokenRevoke)
+75
View File
@@ -227,6 +227,21 @@ service StateStoreService {
rpc EnsureShippedOrgPolicies(EnsureShippedOrgPoliciesRequest) returns (EnsureShippedOrgPoliciesResponse);
rpc RecordDenial(RecordDenialRequest) returns (RecordDenialResponse);
rpc ListDenials(ListDenialsRequest) returns (ListDenialsResponse);
// Orgs, workspaces, memberships and agent assignments
// (docs/prds/orgs-and-access.md). Every request names an org, but the
// State Store acts in the org the caller's principal carries: a request
// org that is not the caller's is ignored, so the contract cannot reach
// another tenant. Instance-admin widening is a later change.
rpc ListOrgs(ListOrgsRequest) returns (ListOrgsResponse);
rpc GetOrg(GetOrgRequest) returns (GetOrgResponse);
rpc CreateOrg(CreateOrgRequest) returns (CreateOrgResponse);
rpc ListWorkspaces(ListWorkspacesRequest) returns (ListWorkspacesResponse);
rpc CreateWorkspace(CreateWorkspaceRequest) returns (CreateWorkspaceResponse);
rpc ListMembers(ListMembersRequest) returns (ListMembersResponse);
rpc SetMembership(SetMembershipRequest) returns (SetMembershipResponse);
rpc RemoveMembership(RemoveMembershipRequest) returns (RemoveMembershipResponse);
rpc AssignAgent(AssignAgentRequest) returns (AssignAgentResponse);
}
message RegisterTaskGrantRequest {
@@ -1335,3 +1350,63 @@ message ListDenialsRequest {
int32 limit = 2;
}
message ListDenialsResponse { repeated AccessDenial denials = 1; }
// Org mirrors internal/domain/org.Org: one tenant.
message Org {
string id = 1;
string name = 2;
}
// Workspace mirrors internal/domain/org.Workspace: a division of an org.
message Workspace {
string id = 1;
string org_id = 2;
string name = 3;
string environment = 4;
}
// Member mirrors internal/domain/org.Member: a membership with the identity
// it names, as the dashboard lists it.
message Member {
string identity_id = 1;
string kind = 2;
string display_name = 3;
string workspace_id = 4;
string role = 5;
}
message ListOrgsRequest {}
message ListOrgsResponse { repeated Org orgs = 1; }
message GetOrgRequest { string org_id = 1; }
message GetOrgResponse { Org org = 1; }
message CreateOrgRequest {
string id = 1;
string name = 2;
}
message CreateOrgResponse { Org org = 1; }
message ListWorkspacesRequest { string org_id = 1; }
message ListWorkspacesResponse { repeated Workspace workspaces = 1; }
message CreateWorkspaceRequest {
string org_id = 1;
string id = 2;
string name = 3;
string environment = 4;
}
message CreateWorkspaceResponse { Workspace workspace = 1; }
message ListMembersRequest { string org_id = 1; }
message ListMembersResponse { repeated Member members = 1; }
message SetMembershipRequest {
string org_id = 1;
string identity_id = 2;
string workspace_id = 3;
string role = 4;
}
message SetMembershipResponse {}
message RemoveMembershipRequest {
string org_id = 1;
string identity_id = 2;
string workspace_id = 3;
}
message RemoveMembershipResponse {}
message AssignAgentRequest {
string org_id = 1;
string identity_id = 2;
}
message AssignAgentResponse {}
+34
View File
@@ -145,6 +145,40 @@ export const api = {
request<{ version: number }>("/api/access/policies", { method: "PUT", body: policy }),
deletePolicy: (policy: unknown) =>
request<void>("/api/access/policies", { method: "DELETE", body: policy, parse: false }),
orgs: <T = unknown>() => request<T>("/api/orgs"),
org: <T = unknown>(id: string) => request<T>(`/api/orgs/${encodeURIComponent(id)}`),
orgWorkspaces: <T = unknown>(id: string) =>
request<T>(`/api/orgs/${encodeURIComponent(id)}/workspaces`),
createOrgWorkspace: <T = unknown>(
id: string,
workspace: { id: string; name: string; environment?: string },
) =>
request<T>(`/api/orgs/${encodeURIComponent(id)}/workspaces`, {
method: "POST",
body: workspace,
}),
orgMembers: <T = unknown>(id: string) =>
request<T>(`/api/orgs/${encodeURIComponent(id)}/members`),
setOrgMember: <T = unknown>(
id: string,
identity: string,
member: { role: string; workspace?: string },
) =>
request<T>(
`/api/orgs/${encodeURIComponent(id)}/members/${encodeURIComponent(identity)}`,
{ method: "PUT", body: member },
),
removeOrgMember: (id: string, identity: string, workspace?: string) =>
request<void>(
`/api/orgs/${encodeURIComponent(id)}/members/${encodeURIComponent(identity)}` +
qs({ workspace }),
{ method: "DELETE", parse: false },
),
assignOrgAgent: <T = unknown>(id: string, identity: string) =>
request<T>(
`/api/orgs/${encodeURIComponent(id)}/agents/${encodeURIComponent(identity)}`,
{ method: "PUT" },
),
summary: <T = unknown>() => request<T>("/api/summary"),
tasks: <T = unknown>() => request<T>("/api/tasks"),
// taskPage reads one page of the board; next is the cursor for the page