Files
archie/internal/infrastructure/staterpc/access_client.go
T
sam a971947c39 refactor(state)!: split StateStoreService into per-domain services
One gRPC service per domain in state.v1 (tasks, executions, accounts, identities, packages, captures, bindings, access, orgs, alerts and so on), each with its own server type in staterpc. RPC and message names and numbers are unchanged.
2026-10-25 19:54:27 +11:00

85 lines
2.9 KiB
Go

// Access: the client half of the policy-chain and denial-record RPCs.
// The reset surface is deliberately absent:
// `archie-state-store access reset` runs on the State Store host, never over the wire.
package staterpc
import (
"context"
pb "github.com/samcharles93/archie-core/internal/contracts/state/v1"
"github.com/samcharles93/archie-core/internal/domain/access"
"github.com/samcharles93/archie-core/internal/domain/identity"
"github.com/samcharles93/archie-core/internal/domain/org"
)
// The Client satisfies the access contracts the two callers depend on.
var (
_ access.PolicyStore = (*Client)(nil)
_ access.DenialRecorder = (*Client)(nil)
_ access.PrincipalSource = (*Client)(nil)
)
func (c *Client) PrincipalFor(ctx context.Context, id identity.IdentityID) (access.Principal, error) {
r, err := c.access.GetPrincipal(ctx, &pb.GetPrincipalRequest{IdentityId: string(id)})
if err != nil {
return access.Principal{}, unmapError(err)
}
value := r.GetPrincipal()
memberships := mapValues(value.GetMemberships(), func(m *pb.PrincipalMembership) org.Membership {
return org.Membership{
IdentityID: id,
OrgID: org.OrgID(m.GetOrgId()),
WorkspaceID: org.WorkspaceID(m.GetWorkspaceId()),
Role: org.Role(m.GetRole()),
}
})
orgID := org.OrgID(value.GetOrgId())
return access.Principal{
IdentityID: identity.IdentityID(value.GetIdentityId()),
Org: orgID,
Memberships: memberships,
Workspaces: mapValues(value.GetWorkspaces(), func(w *pb.PrincipalWorkspace) org.Workspace {
return org.Workspace{ID: org.WorkspaceID(w.GetWorkspaceId()), OrgID: orgID, Environment: w.GetEnvironment()}
}),
}, nil
}
func (c *Client) ListPolicies(ctx context.Context) ([]access.Policy, error) {
r, err := c.access.ListPolicies(ctx, &pb.ListPoliciesRequest{})
if err != nil {
return nil, unmapError(err)
}
return mapValues(r.Policies, accessPolicyValue), nil
}
func (c *Client) PoliciesVersion(ctx context.Context) (int64, error) {
r, err := c.access.GetPoliciesVersion(ctx, &pb.GetPoliciesVersionRequest{})
if err != nil {
return 0, unmapError(err)
}
return r.GetVersion(), nil
}
func (c *Client) PutPolicy(ctx context.Context, p access.Policy) (int64, error) {
r, err := c.access.PutPolicy(ctx, &pb.PutPolicyRequest{Policy: accessPolicyProto(p)})
if err != nil {
return 0, unmapError(err)
}
return r.Version, nil
}
func (c *Client) DeletePolicy(ctx context.Context, p access.Policy) error {
_, err := c.access.DeletePolicy(ctx, &pb.DeletePolicyRequest{Policy: accessPolicyProto(p)})
return unmapError(err)
}
func (c *Client) EnsureShippedOrgPolicies(ctx context.Context, orgID org.OrgID) error {
_, err := c.access.EnsureShippedOrgPolicies(ctx, &pb.EnsureShippedOrgPoliciesRequest{OrgId: string(orgID)})
return unmapError(err)
}
func (c *Client) RecordDenial(ctx context.Context, d access.Denial) error {
_, err := c.access.RecordDenial(ctx, &pb.RecordDenialRequest{Denial: accessDenialProto(d)})
return unmapError(err)
}