registry

Documentation

Overview

Example (CreateTagScanner)

type Foo struct {
	A string  `tag:"a"`
	B int     `tag:"b"`
	C float64 `tag:"c"`
	D bool    `tag:"d"`
	E bool    `tag:"flags:e"`
	F bool    `tag:"flags:f"`
	G bool    `tag:"flags:g"`
}

reg := NewRegistry()

scan, err := reg.createTagScanner(reflect.TypeFor[Foo]())

if err != nil {
	panic(err)
}

tags := reflect.StructTag(`a:"foobar" b:"123" c:"456.789" d:"true" h:"nothing" flags:"f,g,x"`)

var foo Foo

if err = scan(unsafe.Pointer(&foo), string(tags)); err != nil {
	return
}

fmt.Printf("%#v\n", foo)

Output:

registry.Foo{A:"foobar", B:123, C:456.789, D:true, E:false, F:true, G:true}

Index

• Variables
• func ScanTags[T any](reg *Registry, dst *T, tags reflect.StructTag) (err error)
• type Binder
• type Parser
• type Registry
  • func NewRegistry(gatekeeper ...security.Gatekeeper) (r *Registry)
  • func (r *Registry) Binder(typ reflect.Type, fieldName string, tags reflect.StructTag) (_ Binder, err error)
  • func (r *Registry) CreateBinder(typ reflect.Type, paramKeys []string, caller *runtime.Func) (bind Binder, perm string, err error)
  • func (s *Registry) DescribeOperation(op *openapi.Operation, in, out reflect.Type) (err error)
  • func (r *Registry) Gatekeeper() security.Gatekeeper
  • func (r *Registry) OptionalPermTag() bool
  • func (r *Registry) Parser(typ reflect.Type, tags reflect.StructTag) (dec Parser, err error)
  • func (r *Registry) Policies() *security.PolicyStore
  • func (r *Registry) RegisterType(typs ...TypeRegistrar) (err error)
  • func (r *Registry) Responder(typ reflect.Type) (scan Responder, err error)
  • func (r *Registry) Schema(typ reflect.Type, tag ...reflect.StructTag) (schema openapi.Schema, err error)
• type Responder
• type TypeDescriber
• type TypeDescription
  • func (t TypeDescription) IsZero() bool
• type TypeRegistrar

Examples

• Package (CreateTagScanner)

Variables

var (
	ErrFailedDecodeBody  = errors.NewFrozenError("FAILED_DECODE_BODY", "Could not decode JSON body", 400)
	ErrFailedDecodeParam = errors.NewFrozenError("FAILED_DECODE_PARAM", "Could not decode URL param", 400)
	ErrFailedDecodeQuery = errors.NewFrozenError("FAILED_DECODE_QUERY", "Could not decode query param", 400)
)

var (
	NoParser = func(reflect.StructTag) (Parser, error) {
		return nil, nil
	}
)

Functions

func ScanTags

func ScanTags[T any](reg *Registry, dst *T, tags reflect.StructTag) (err error)

Types

type Binder

type Binder func(c *fasthttp.RequestCtx, ptr unsafe.Pointer) error

Binder populates a value from the request context (body, multipart, streaming). Input-only; runs before user handler; may short-circuit.

type Parser

type Parser = scanner.Scanner

Parser converts a single string (e.g. from query, path, header) into a value. Input-only; no ctx access, no response writes.

type Registry

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

func NewRegistry

func NewRegistry(gatekeeper ...security.Gatekeeper) (r *Registry)

func (*Registry) Binder

func (r *Registry) Binder(typ reflect.Type, fieldName string, tags reflect.StructTag) (_ Binder, err error)

func (*Registry) CreateBinder

func (r *Registry) CreateBinder(typ reflect.Type, paramKeys []string, caller *runtime.Func) (bind Binder, perm string, err error)

func (*Registry) DescribeOperation

func (s *Registry) DescribeOperation(op *openapi.Operation, in, out reflect.Type) (err error)

func (*Registry) Gatekeeper

func (r *Registry) Gatekeeper() security.Gatekeeper

Could be nil.

func (*Registry) OptionalPermTag

func (r *Registry) OptionalPermTag() bool

func (*Registry) Parser

func (r *Registry) Parser(typ reflect.Type, tags reflect.StructTag) (dec Parser, err error)

Get a parser, or create one.

func (*Registry) Policies

func (r *Registry) Policies() *security.PolicyStore

func (*Registry) RegisterType

func (r *Registry) RegisterType(typs ...TypeRegistrar) (err error)

func (*Registry) Responder

func (r *Registry) Responder(typ reflect.Type) (scan Responder, err error)

func (*Registry) Schema

func (r *Registry) Schema(typ reflect.Type, tag ...reflect.StructTag) (schema openapi.Schema, err error)

type Responder

type Responder func(c *fasthttp.RequestCtx, ptr unsafe.Pointer, next func() error) error

Responder shapes/streams the response around user code. Output-only; must call next() exactly once (unless short-circuiting).

type TypeDescriber

type TypeDescriber interface {
	TypeDescription(reg *Registry) TypeDescription
}

type TypeDescription

type TypeDescription struct {

	// Schema describes the type for OpenAPI (structure, format, content-type).
	Schema func(tags reflect.StructTag) (openapi.Schema, error)

	// Parser provides a string→value parser for this type (query/param/header).
	Parser func(tags reflect.StructTag) (Parser, error)

	// Binder provides a ctx-aware binder for this type (body, multipart, etc.).
	// Preferred over Parser if both are defined.
	Binder func(fieldName string, tags reflect.StructTag) (Binder, error)

	// Responder provides an output wrapper/encoder for this type.
	// Runs after user handler to write/stream the response.
	Responder func() (Responder, error)
}

TypeDescription declares how a type behaves in the API framework. A type may implement any subset depending on if it's used for input, output, or both.

func (TypeDescription) IsZero

func (t TypeDescription) IsZero() bool

type TypeRegistrar

type TypeRegistrar interface {
	Type() reflect.Type
	TypeDescriber
}