clconnect

Documentation

Overview

Package clconnect provides generic fx dependency for standard ConnectRPC services.

Index

• Variables
• func IdentityFromContext(ctx context.Context) openid.Token
• func New[RO, RW any](cfg Config, logs *zap.Logger, ro RO, roc ConstructHandler[RO], rw RW, ...) http.Handler
• func Provide[RO, RW any](name string) fx.Option
• func ProvideEntTransactors[TX EntModelTx, MC EntModelClient[TX]]() fx.Option
• func ProvideOryAuth() fx.Option
• func ProvidePgxTransactors() fx.Option
• func TestProvide[RO, RW, ROC, ROW any](name string) fx.Option
• func WithIdentity(ctx context.Context, tok openid.Token) context.Context
• type AuthzInput
• type Config
• type ConstructClient
• type ConstructHandler
• type EntModelClient
• type EntModelTx
• type EntROTransactor
  • func NewEntROTransactor[TX EntModelTx, MC EntModelClient[TX]](logs *zap.Logger, mc MC) *EntROTransactor[TX, MC]
• type EntRWTransactor
  • func NewEntRWTransactor[TX EntModelTx, MC EntModelClient[TX]](logs *zap.Logger, mc MC) *EntRWTransactor[TX, MC]
• type JWTOPAAuth
  • func NewJWTOPAAuth(cfg Config, logs *zap.Logger, authn *clauthn.Authn, authz *clauthz.Authz) (lgr *JWTOPAAuth, err error)
• type Logger
  • func NewLogger(cfg Config, logs *zap.Logger) *Logger
• type Ory
• type OryAuth
  • func NewOryAuth(cfg Config, logs *zap.Logger, ory Ory) (inj *OryAuth, err error)
  • func (l OryAuth) IsPublicRPCMethod(spec connect.Spec) bool
• type PgxROTransacter
  • func NewPgxROTransacter(cfg Config, logs *zap.Logger, ro *pgxpool.Pool) *PgxROTransacter
• type PgxRWTransacter
  • func NewPgxRWTransacter(cfg Config, logs *zap.Logger, rw *pgxpool.Pool) *PgxRWTransacter
• type ROTransacter
• type RWTransacter
• type Recoverer
  • func NewRecoverer(cfg Config, logs *zap.Logger) *Recoverer
• type TestMiddleware

Variables

var ErrServerPanic = errors.New("server panic")

ErrServerPanic is returned when the server panicked.

Functions

func IdentityFromContext

func IdentityFromContext(ctx context.Context) openid.Token

IdentityFromContext returns the identity from context as an OpenID token. If there is no token in the context it returns an empty (anonymous) openid token.

func New

func New[RO, RW any](
	cfg Config,
	logs *zap.Logger,
	ro RO, roc ConstructHandler[RO],
	rw RW, rwc ConstructHandler[RW],
	rcvr *Recoverer,

	logr *Logger,
	valr *validate.Interceptor,

	roTx ROTransacter,
	rwTx RWTransacter,
	joAuth *JWTOPAAuth,
	oryAuth *OryAuth,
) http.Handler

New inits an http handler for the full RPC api.

func Provide

func Provide[RO, RW any](name string) fx.Option

Provide the package components for the DI container.

func ProvideEntTransactors

func ProvideEntTransactors[TX EntModelTx, MC EntModelClient[TX]]() fx.Option

ProvideEntTransactors provides the RO transactor.

func ProvideOryAuth

func ProvideOryAuth() fx.Option

ProvideOryAuth provides injector for ory-based auth.

func ProvidePgxTransactors

func ProvidePgxTransactors() fx.Option

ProvidePgxTransactors provides transactors for pgx transactions.

func TestProvide

func TestProvide[RO, RW, ROC, ROW any](name string) fx.Option

TestProvide provides dependencies for testing.

func WithIdentity

func WithIdentity(ctx context.Context, tok openid.Token) context.Context

WithIdentity returns a context with the openid token.

Types

type AuthzInput

type AuthzInput struct {
	// Input from the process environment
	Env map[string]any `json:"env"`
	// OpenID token as claims
	Claims openid.Token `json:"claims"`
	// Procedure encodes the full RPC procedure name. e.g: /acme.foo.v1.FooService/Bar
	Procedure string `json:"procedure"`
}

AuthzInput encodes the full input into the authorization (AuthZ) policy system OPA. It should provide ALL data required to make authorization decisions. It should be fully serializable to JSON.

type Config

type Config struct {
	// disables stack trace information in error details
	DisableStackTraceErrorDetails bool `env:"DISABLE_STACK_TRACE_ERROR_DETAILS"`
	// allows configuring the 'env' input field send to the policy, allows for configuring input
	// invariant to the environment
	AuthzPolicyEnvInput string `env:"AUTHZ_POLICY_ENV_INPUT,expand" envDefault:"{}"`

	// PublicRPCProcedures configures the ConnectRPC methods that are plublic. For these procedures a special
	// "anonymous" session will be passed to other middleware.
	PublicRPCProcedures map[string]bool `env:"PUBLIC_RPC_PROCEDURES"`
}

Config configures the components.

type ConstructClient

type ConstructClient[SC any] func(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) SC

ConstructClient is a funct signature that constructs a client.

type ConstructHandler

type ConstructHandler[SH any] func(svc SH, opts ...connect.HandlerOption) (string, http.Handler)

ConstructHandler defines the type for constructing a connectrpc service handler.

type EntModelClient

type EntModelClient[TX EntModelTx] interface {
	BeginTx(ctx context.Context, opts *entsql.TxOptions) (TX, error)
}

EntModelClient is a generic type to constraint the model client to those generated by Ent.

type EntModelTx

type EntModelTx interface {
	Commit() error
	Rollback() error
}

EntModelTx is a generic type to constraint the tx to those generated by Ent.

type EntROTransactor

type EntROTransactor[TX EntModelTx, MC EntModelClient[TX]] struct {
	connect.Interceptor
	// contains filtered or unexported fields
}

EntROTransactor provides an ent tx to the context.

func NewEntROTransactor

func NewEntROTransactor[TX EntModelTx, MC EntModelClient[TX]](logs *zap.Logger, mc MC) *EntROTransactor[TX, MC]

NewEntROTransactor its a RO transactor for the model client type.

type EntRWTransactor

type EntRWTransactor[TX EntModelTx, MC EntModelClient[TX]] struct {
	connect.Interceptor
	// contains filtered or unexported fields
}

EntRWTransactor provides an ent tx to the context.

func NewEntRWTransactor

func NewEntRWTransactor[TX EntModelTx, MC EntModelClient[TX]](logs *zap.Logger, mc MC) *EntRWTransactor[TX, MC]

NewEntRWTransactor its a RW transactor for the model client type.

type JWTOPAAuth

type JWTOPAAuth struct {
	connect.Interceptor
	// contains filtered or unexported fields
}

JWTOPAAuth provides authn and authz as an injector.

func NewJWTOPAAuth

func NewJWTOPAAuth(
	cfg Config, logs *zap.Logger, authn *clauthn.Authn, authz *clauthz.Authz,
) (lgr *JWTOPAAuth, err error)

NewJWTOPAAuth inits an interceptor that uses JWT for Authn and OPA for Authz.

type Logger

type Logger struct {
	connect.Interceptor
	// contains filtered or unexported fields
}

Logger logs RPC calls as an interceptor.

func NewLogger

func NewLogger(cfg Config, logs *zap.Logger) *Logger

NewLogger inits the logger.

type Ory

type Ory interface {
	// Authenticate implements the authentication logic.
	Authenticate(ctx context.Context, cookie string, allowAnonymous bool) (*orysdk.Session, error)
}

Ory interface provides our interface onto ory.

type OryAuth

type OryAuth struct {
	connect.Interceptor
	// contains filtered or unexported fields
}

OryAuth provides authn and authz as an injector.

func NewOryAuth

func NewOryAuth(
	cfg Config, logs *zap.Logger, ory Ory,
) (inj *OryAuth, err error)

NewOryAuth inits an interceptor that uses JWT for Authn and OPA for Authz.

func (OryAuth) IsPublicRPCMethod

func (l OryAuth) IsPublicRPCMethod(spec connect.Spec) bool

IsPublicRPCProcedure returns true if a request is done to public rpc method.

type PgxROTransacter

type PgxROTransacter struct {
	connect.Interceptor
	// contains filtered or unexported fields
}

PgxROTransacter provides a database transaction in the context.

func NewPgxROTransacter

func NewPgxROTransacter(cfg Config, logs *zap.Logger, ro *pgxpool.Pool) *PgxROTransacter

NewPgxROTransacter inits the Transacter.

type PgxRWTransacter

type PgxRWTransacter struct {
	connect.Interceptor
	// contains filtered or unexported fields
}

PgxRWTransacter provides a database transaction in the context.

func NewPgxRWTransacter

func NewPgxRWTransacter(cfg Config, logs *zap.Logger, rw *pgxpool.Pool) *PgxRWTransacter

NewPgxRWTransacter inits the Transacter.

type ROTransacter

type ROTransacter interface {
	connect.Interceptor
	// contains filtered or unexported methods
}

ROTransacter is an interceptor that add read-only transactions to the context.

type RWTransacter

type RWTransacter interface {
	connect.Interceptor
	// contains filtered or unexported methods
}

RWTransacter is an interceptor that add read-write transactions to the context.

type Recoverer

type Recoverer struct {
	// contains filtered or unexported fields
}

Recoverer allows recovering from panics.

func NewRecoverer

func NewRecoverer(cfg Config, logs *zap.Logger) *Recoverer

NewRecoverer inits the recoverer.

type TestMiddleware

type TestMiddleware func(next http.Handler) http.Handler

TestMiddleware can be provided in tests to wrap the test http.Handler with middleware.