Files
archie/internal/infrastructure/staterpc/authentication.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

142 lines
5.4 KiB
Go

package staterpc
import (
"context"
"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"
)
func authenticationProto(v identity.AuthenticationSettings) *pb.AuthenticationSettings {
return &pb.AuthenticationSettings{PublicUrl: v.PublicURL, OidcIssuer: v.OIDCIssuer, OidcAudience: v.OIDCAudience, OidcClientId: v.OIDCClientID}
}
func authenticationValue(v *pb.AuthenticationSettings) identity.AuthenticationSettings {
return identity.AuthenticationSettings{PublicURL: v.GetPublicUrl(), OIDCIssuer: v.GetOidcIssuer(), OIDCAudience: v.GetOidcAudience(), OIDCClientID: v.GetOidcClientId()}
}
func (s *accountServer) GetAuthenticationSettings(ctx context.Context, _ *pb.GetAuthenticationSettingsRequest) (*pb.GetAuthenticationSettingsResponse, error) {
store, ok := s.deps.Accounts.(identity.AuthenticationSettingsStore)
if !ok {
return nil, status.Error(codes.Unavailable, "authentication settings unavailable")
}
value, err := store.AuthenticationSettings(ctx)
if err != nil {
return nil, accountStatus(err)
}
return &pb.GetAuthenticationSettingsResponse{Settings: authenticationProto(value)}, nil
}
func (s *accountServer) SaveAuthenticationSettings(ctx context.Context, r *pb.SaveAuthenticationSettingsRequest) (*pb.SaveAuthenticationSettingsResponse, error) {
store, ok := s.deps.Accounts.(identity.AuthenticationSettingsStore)
if !ok {
return nil, status.Error(codes.Unavailable, "authentication settings unavailable")
}
return &pb.SaveAuthenticationSettingsResponse{}, accountStatus(store.SaveAuthenticationSettings(ctx, authenticationValue(r.Settings)))
}
func (c *Client) AuthenticationSettings(ctx context.Context) (identity.AuthenticationSettings, error) {
r, err := c.account.GetAuthenticationSettings(ctx, &pb.GetAuthenticationSettingsRequest{})
if err != nil {
return identity.AuthenticationSettings{}, accountClientError(err)
}
return authenticationValue(r.Settings), nil
}
func (c *Client) SaveAuthenticationSettings(ctx context.Context, v identity.AuthenticationSettings) error {
_, err := c.account.SaveAuthenticationSettings(ctx, &pb.SaveAuthenticationSettingsRequest{Settings: authenticationProto(v)})
return accountClientError(err)
}
func (s *server) passkeyStore() (identity.Passkeys, error) {
v, ok := s.deps.Accounts.(identity.Passkeys)
if !ok {
return nil, status.Error(codes.Unavailable, "passkeys unavailable")
}
return v, nil
}
func (s *accountServer) BeginPasskey(ctx context.Context, r *pb.BeginPasskeyRequest) (*pb.BeginPasskeyResponse, error) {
store, err := s.passkeyStore()
if err != nil {
return nil, err
}
value, err := store.BeginPasskey(ctx, r.Registration)
if err != nil {
return nil, accountStatus(err)
}
return &pb.BeginPasskeyResponse{Token: value.Token, Options: value.Options}, nil
}
func (s *accountServer) FinishPasskey(ctx context.Context, r *pb.FinishPasskeyRequest) (*pb.FinishPasskeyResponse, error) {
store, err := s.passkeyStore()
if err != nil {
return nil, err
}
value, err := store.FinishPasskey(ctx, r.Token, r.Credential, r.Registration, r.Name)
if err != nil {
return nil, accountStatus(err)
}
return &pb.FinishPasskeyResponse{Identity: identityProto(value.Identity), Token: value.Token, ExpiresAt: timestamp(value.Expires)}, nil
}
func (s *accountServer) ListPasskeys(ctx context.Context, _ *pb.ListPasskeysRequest) (*pb.ListPasskeysResponse, error) {
store, err := s.passkeyStore()
if err != nil {
return nil, err
}
values, err := store.ListPasskeys(ctx)
if err != nil {
return nil, accountStatus(err)
}
out := &pb.ListPasskeysResponse{}
for _, value := range values {
out.Passkeys = append(out.Passkeys, &pb.Passkey{Id: value.ID, Name: value.Name})
}
return out, nil
}
func (s *accountServer) DeletePasskey(ctx context.Context, r *pb.DeletePasskeyRequest) (*pb.DeletePasskeyResponse, error) {
store, err := s.passkeyStore()
if err != nil {
return nil, err
}
return &pb.DeletePasskeyResponse{}, accountStatus(store.DeletePasskey(ctx, r.Id))
}
func (c *Client) BeginPasskey(ctx context.Context, registration bool) (identity.PasskeyCeremony, error) {
r, err := c.account.BeginPasskey(ctx, &pb.BeginPasskeyRequest{Registration: registration})
if err != nil {
return identity.PasskeyCeremony{}, accountClientError(err)
}
return identity.PasskeyCeremony{Token: r.Token, Options: r.Options}, nil
}
func (c *Client) FinishPasskey(ctx context.Context, token string, credential []byte, registration bool, name string) (identity.AccountSession, error) {
r, err := c.account.FinishPasskey(ctx, &pb.FinishPasskeyRequest{Token: token, Credential: credential, Registration: registration, Name: name})
if err != nil {
return identity.AccountSession{}, accountClientError(err)
}
return identity.AccountSession{Identity: identityValue(r.Identity), Token: r.Token, Expires: timeValue(r.ExpiresAt)}, nil
}
func (c *Client) ListPasskeys(ctx context.Context) ([]identity.Passkey, error) {
r, err := c.account.ListPasskeys(ctx, &pb.ListPasskeysRequest{})
if err != nil {
return nil, accountClientError(err)
}
out := []identity.Passkey{}
for _, v := range r.Passkeys {
out = append(out, identity.Passkey{ID: v.Id, Name: v.Name})
}
return out, nil
}
func (c *Client) DeletePasskey(ctx context.Context, id string) error {
_, err := c.account.DeletePasskey(ctx, &pb.DeletePasskeyRequest{Id: id})
return accountClientError(err)
}