action

package

Go to main page

Versions in this module

v0

v0.10.1

Sep 14, 2026

v0.10.0

Sep 14, 2026

v0.9.3

Sep 14, 2026

v0.9.2

Sep 14, 2026

v0.9.1

Sep 14, 2026

v0.9.0

Sep 14, 2026

Changes in this version

+ var DefaultTextFields = []string

+ func Assign(target any, source any) error

v0.8.0

Sep 14, 2026

v0.7.4

Sep 13, 2026

v0.7.3

Sep 13, 2026

v0.7.2

Sep 13, 2026

v0.7.1

Sep 13, 2026

v0.7.0

Sep 13, 2026

Changes in this version

type AnyAction

+ func FilterByNode(actions []AnyAction, policy NodeFilterPolicy) []AnyAction

type Builder

+ func (b *Builder[Req, Res]) WithDSL(m DSLModifiers) *Builder[Req, Res]

type BuiltAction

+ func (a *BuiltAction[Req, Res]) ApplyDSL(m DSLModifiers) AnyAction

+ type DSLApplier interface

+ ApplyDSL func(m DSLModifiers) AnyAction

+ type DSLModifiers struct

+ Burst int

+ CacheKeyFnRaw any

+ CacheTTL time.Duration

+ Concurrency int32

+ Features []string

+ Hooks []AnyHook

+ Idempotency *IdempotencyConfig

+ Idempotent bool

+ Permissions []string

+ RateLimit float64

+ RequiresAuth bool

+ RetryBackoff func(attempt int) time.Duration

+ RetryIf RetryPredicate

+ RetryMax int

+ Roles []string

+ Scope string

+ SuccessStatus int

+ Tags []string

+ Timeout time.Duration

type Meta

+ func (m *Meta) MatchesNode(policy NodeFilterPolicy) bool

+ type NodeFilterPolicy struct

+ ActiveNode string

+ AllowUntaggedEverywhere bool

+ DefaultNode string

v0.6.0

Sep 9, 2026

Changes in this version

+ const DefaultMaxTreeDepth

+ func ApplyTreeHook(act AnyAction, hooks ...AnyHook) error

+ func ApplyTreeHookOpts(act AnyAction, opts TreeHookOptions, hooks ...AnyHook) error

+ type Composite interface

+ Children func() []AnyAction

+ type Proxy struct

+ func NewProxy(initial AnyAction) *Proxy

+ func (p *Proxy) AddAnyHook(hooks ...AnyHook)

+ func (p *Proxy) Children() []AnyAction

+ func (p *Proxy) Current() AnyAction

+ func (p *Proxy) Describe() *Meta

+ func (p *Proxy) DoAny(ctx context.Context, req any) (any, error)

+ func (p *Proxy) ExecuteDecoded(ctx context.Context, decodeFn DecodeFunc) (any, error)

+ func (p *Proxy) GetAnyHooks() []AnyHook

+ func (p *Proxy) GetBindings() []Binding

+ func (p *Proxy) Swap(newAction AnyAction)

+ type TreeHookOptions struct

+ MaxDepth int

v0.5.1

Sep 9, 2026

v0.5.0

Sep 8, 2026

Changes in this version

type BuiltAction

+ func (a *BuiltAction[Req, Res]) Close()

v0.4.0

Sep 6, 2026

Changes in this version

+ func Coerce[T any](input any) (T, error)

+ func InvokeAny(ctx context.Context, act any, req any) (any, error)

+ type AnyDoer interface

+ DoAny func(ctx context.Context, req any) (any, error)

type Builder

+ func BranchAny(name string, routes map[string]AnyAction, ...) *Builder[any, any]

+ func Dynamic(act AnyAction) *Builder[any, any]

+ func ParallelMap[Req any](name string, actions ...AnyAction) *Builder[Req, map[string]any]

+ func ParallelNamed[Req any](name string, routes map[string]AnyAction) *Builder[Req, map[string]any]

+ func PipeWith[Req, Mid1, Mid2, Res any](name string, first *BuiltAction[Req, Mid1], ...) *Builder[Req, Res]

type BuiltAction

+ func (a *BuiltAction[Req, Res]) DoAny(ctx context.Context, req any) (any, error)

+ func (a *BuiltAction[Req, Res]) ToBuilder() *Builder[Req, Res]

type BuiltSaga

+ func (s *BuiltSaga[Req, Res]) AsAction() *BuiltAction[Req, SagaResult[Res]]

v0.3.2

Sep 3, 2026

v0.3.1

Sep 3, 2026

v0.3.0

Sep 3, 2026

Changes in this version

+ func AlwaysRetryPredicate(err error) bool

+ func DefaultRetryPredicate(err error) bool

type Builder

+ func (b *Builder[Req, Res]) RetryAll(maxRetry int, backoff func(attempt int) time.Duration) *Builder[Req, Res]

+ func (b *Builder[Req, Res]) RetryIf(maxRetry int, backoff func(attempt int) time.Duration, ...) *Builder[Req, Res]

type DispatcherMiddleware

+ func RetryWithPredicateMiddleware[Req, Res any](maxRetry int, backoff func(attempt int) time.Duration, ...) DispatcherMiddleware[Req, Res]

type ResilienceConfig

+ Predicate RetryPredicate

+ type RetryPredicate func(err error) bool

v0.2.0

Aug 31, 2026

Changes in this version

type CacheConfig

+ Timeout time.Duration

type LockLease

+ func LeaseFromContext(ctx context.Context) (LockLease, bool)

type MemoryIdempotencyStore

+ func (s *MemoryIdempotencyStore) Claim(ctx context.Context, key, requestHash string, leaseTTL time.Duration) (IdempotencyClaim, error)

+ func (s *MemoryIdempotencyStore) Complete(_ context.Context, key, token string, entry IdempotencyEntry, ...) error

+ func (s *MemoryIdempotencyStore) Release(_ context.Context, key, token string) error

type Middleware

+ func SlowLogMiddleware[Req, Res any](threshold time.Duration, actionName string) Middleware[Req, Res]

v0.1.0

Aug 30, 2026

Changes in this version

+ const DefaultIdempotencyLeaseTTL

+ const DefaultIdempotencyTTL

+ var ErrConcurrencyLimit = errors.New("concurrency limit exceeded")

+ var ErrLocked = xerr.Conflict("resource is currently locked by another instance")

+ var ErrTypeAssertion = errors.New("critical type assertion failure")

+ func Async[Req, Res any](ctx context.Context, act *BuiltAction[Req, Res], req Req) <-chan AsyncResult[Res]

+ func CollectStream[Req, T any](ctx context.Context, a *StreamAction[Req, T], req Req) ([]T, error)

+ func ConstantBackoff(d time.Duration) func(attempt int) time.Duration

+ func ExecutionIDFrom(ctx context.Context) string

+ func ExponentialBackoff(base, maxDuration time.Duration) func(attempt int) time.Duration

+ func ExponentialJitter(base, maxDuration time.Duration) func(attempt int) time.Duration

+ func LinearBackoff(step time.Duration) func(attempt int) time.Duration

+ func Race[Req, Res any](ctx context.Context, act *BuiltAction[Req, Res], reqs []Req) (Res, error)

+ func SpanIDFrom(ctx context.Context) string

+ func TraceIDFrom(ctx context.Context) string

+ func WithExecutionID(ctx context.Context, id string) context.Context

+ func WithTraceContext(ctx context.Context, traceID, spanID string) context.Context

+ type ActionProvider interface

+ Actions func() []AnyAction

+ type ActionScope string

+ const ScopeInternal

+ const ScopePublic

+ const ScopeSystem

+ type AdaptiveConfig struct

+ FailureThreshold int

+ InitialTimeout time.Duration

+ ResetTimeout time.Duration

+ func (c *AdaptiveConfig) SetDefaults()

+ type Admission interface

+ Acquire func(context.Context) error

+ Release func()

+ type AnyAction interface

+ AddAnyHook func(h ...AnyHook)

+ GetAnyHooks func() []AnyHook

+ GetBindings func() []Binding

+ type AnyHook struct

+ After func(ctx context.Context, req any, res any, err error, meta *Meta)

+ Before func(ctx context.Context, req any, meta *Meta) (context.Context, error)

+ OnCacheHit func(ctx context.Context, req any, res any, meta *Meta)

+ OnCacheMiss func(ctx context.Context, req any, meta *Meta)

+ OnCancel func(ctx context.Context, req any, meta *Meta)

+ OnCoalesced func(ctx context.Context, req any, meta *Meta)

+ OnDeduplicated func(ctx context.Context, req any, meta *Meta)

+ OnError func(ctx context.Context, req any, err error, meta *Meta)

+ OnExecuted func(ctx context.Context, req any, res any, err error, meta *Meta)

+ OnPanic func(ctx context.Context, req any, recovered any, meta *Meta)

+ OnRegister func(meta *Meta)

+ OnRetry func(ctx context.Context, req any, attempt int, err error, meta *Meta)

+ func Adapt[Req, Res any](h Hook[Req, Res]) AnyHook

+ type AsyncResult struct

+ Err error

+ Value Res

+ func FanOut[Req, Res any](ctx context.Context, act *BuiltAction[Req, Res], reqs []Req, ...) []AsyncResult[Res]

+ type AuditLogger interface

+ Log func(ctx context.Context, category string, actionName string, details string)

+ type Binding any

+ type Bootstrapper interface

+ OnBoot func(app ActionProvider) error

+ type Builder struct

+ func Branch[Req, Res any](name string, routes map[string]*Builder[Req, Res], ...) *Builder[Req, Res]

+ func Chain[T any](name string, builders ...*Builder[T, T]) *Builder[T, T]

+ func FirstSuccess[Req, Res any](name string, builders ...*Builder[Req, Res]) *Builder[Req, Res]

+ func New[Req, Res any](name string, exec Fn[Req, Res]) *Builder[Req, Res]

+ func Parallel[Req, Res any](name string, builders ...*Builder[Req, Res]) *Builder[Req, []Res]

+ func Pipe[Req, Mid, Res any](name string, first *BuiltAction[Req, Mid], second *BuiltAction[Mid, Res]) *Builder[Req, Res]

+ func (b *Builder[Req, Res]) Add(others ...AnyAction) *Builder[Req, Res]

+ func (b *Builder[Req, Res]) AnyHook(h ...AnyHook) *Builder[Req, Res]

+ func (b *Builder[Req, Res]) Audited(logger AuditLogger, category string, detailsFn func(req Req, res Res) string) *Builder[Req, Res]

+ func (b *Builder[Req, Res]) Build() *BuiltAction[Req, Res]

+ func (b *Builder[Req, Res]) Cache(ttl time.Duration, keyFn func(Req) string, layers ...CacheLayer[Res]) *Builder[Req, Res]

+ func (b *Builder[Req, Res]) Coalesce(c *Coalescer, keyFn func(Req) string) *Builder[Req, Res]

+ func (b *Builder[Req, Res]) Compose(other *BuiltAction[Req, Res]) *Builder[Req, Res]

+ func (b *Builder[Req, Res]) ConcurrencyLimit(limit int32) *Builder[Req, Res]

+ func (b *Builder[Req, Res]) Dedup(keyFn func(Req) string) *Builder[Req, Res]

+ func (b *Builder[Req, Res]) Describe() *Meta

+ func (b *Builder[Req, Res]) Description(d string) *Builder[Req, Res]

+ func (b *Builder[Req, Res]) Emits(subject string, mapper func(res Res) any) *Builder[Req, Res]

+ func (b *Builder[Req, Res]) Exclusive(m Mutex, ttl time.Duration, keyFn func(Req) string) *Builder[Req, Res]

+ func (b *Builder[Req, Res]) ExclusiveFenced(m FencedMutex, ttl time.Duration, keyFn func(Req) string) *Builder[Req, Res]

+ func (b *Builder[Req, Res]) Hook(h ...Hook[Req, Res]) *Builder[Req, Res]

+ func (b *Builder[Req, Res]) HookAfter(fn func(ctx context.Context, req Req, res Res, err error, meta *Meta)) *Builder[Req, Res]

+ func (b *Builder[Req, Res]) HookBefore(fn func(ctx context.Context, req Req, meta *Meta) (context.Context, error)) *Builder[Req, Res]

+ func (b *Builder[Req, Res]) HookCacheHit(fn func(ctx context.Context, req Req, res Res, meta *Meta)) *Builder[Req, Res]

+ func (b *Builder[Req, Res]) HookCacheMiss(fn func(ctx context.Context, req Req, meta *Meta)) *Builder[Req, Res]

+ func (b *Builder[Req, Res]) HookCancel(fn func(ctx context.Context, req Req, meta *Meta)) *Builder[Req, Res]

+ func (b *Builder[Req, Res]) HookError(fn func(ctx context.Context, req Req, err error, meta *Meta)) *Builder[Req, Res]

+ func (b *Builder[Req, Res]) HookExecuted(fn func(ctx context.Context, req Req, res Res, meta *Meta)) *Builder[Req, Res]

+ func (b *Builder[Req, Res]) HookRegister(fn func(meta *Meta)) *Builder[Req, Res]

+ func (b *Builder[Req, Res]) HookRetry(fn func(ctx context.Context, req Req, attempt int, err error, meta *Meta)) *Builder[Req, Res]

+ func (b *Builder[Req, Res]) Idempotent() *Builder[Req, Res]

+ func (b *Builder[Req, Res]) IdempotentWithConfig(cfg IdempotencyConfig) *Builder[Req, Res]

+ func (b *Builder[Req, Res]) ImmutableWhen(guard func(ctx context.Context, req Req) (bool, error), reason string) *Builder[Req, Res]

+ func (b *Builder[Req, Res]) InferredResilient() *Builder[Req, Res]

+ func (b *Builder[Req, Res]) Instrument(incCall func(actionName string), incError func(actionName string), ...) *Builder[Req, Res]

+ func (b *Builder[Req, Res]) Internal() *Builder[Req, Res]

+ func (b *Builder[Req, Res]) LeaderOnly(m Mutex, ttl time.Duration) *Builder[Req, Res]

+ func (b *Builder[Req, Res]) LeaderOnlyFenced(m FencedMutex, ttl time.Duration) *Builder[Req, Res]

+ func (b *Builder[Req, Res]) LogCalls(log *slog.Logger) *Builder[Req, Res]

+ func (b *Builder[Req, Res]) LogSlowWhen(d time.Duration) *Builder[Req, Res]

+ func (b *Builder[Req, Res]) Name(name string) *Builder[Req, Res]

+ func (b *Builder[Req, Res]) Node(nodeName string) *Builder[Req, Res]

+ func (b *Builder[Req, Res]) Once() *Builder[Req, Res]

+ func (b *Builder[Req, Res]) Public() *Builder[Req, Res]

+ func (b *Builder[Req, Res]) RateLimit(requestsPerSecond float64, burst int) *Builder[Req, Res]

+ func (b *Builder[Req, Res]) RateLimitDistributed(limiter RateLimiter, keyFn func(context.Context) string) *Builder[Req, Res]

+ func (b *Builder[Req, Res]) RateLimitWithKey(rps float64, burst int, keyFn func(context.Context) string) *Builder[Req, Res]

+ func (b *Builder[Req, Res]) RecordHistory(capacity int) *Builder[Req, Res]

+ func (b *Builder[Req, Res]) RequireAnyFeature(keys ...string) *Builder[Req, Res]

+ func (b *Builder[Req, Res]) RequireAnyRole(roles ...string) *Builder[Req, Res]

+ func (b *Builder[Req, Res]) RequireAuth() *Builder[Req, Res]

+ func (b *Builder[Req, Res]) RequireCreationLimit(resourceName string, checkFn QuotaCheckFunc) *Builder[Req, Res]

+ func (b *Builder[Req, Res]) RequireFeature(keys ...string) *Builder[Req, Res]

+ func (b *Builder[Req, Res]) RequirePermission(perm string) *Builder[Req, Res]

+ func (b *Builder[Req, Res]) RequireRole(role string) *Builder[Req, Res]

+ func (b *Builder[Req, Res]) RequireTenant() *Builder[Req, Res]

+ func (b *Builder[Req, Res]) Resilient(cfg ResilienceConfig) *Builder[Req, Res]

+ func (b *Builder[Req, Res]) Retry(maxRetry int, backoff func(attempt int) time.Duration) *Builder[Req, Res]

+ func (b *Builder[Req, Res]) Route(bs ...Binding) *Builder[Req, Res]

+ func (b *Builder[Req, Res]) SuccessStatus(code int) *Builder[Req, Res]

+ func (b *Builder[Req, Res]) System() *Builder[Req, Res]

+ func (b *Builder[Req, Res]) Tag(tags ...string) *Builder[Req, Res]

+ func (b *Builder[Req, Res]) Timeout(d time.Duration) *Builder[Req, Res]

+ func (b *Builder[Req, Res]) TrackPIIAccess(tracker PIITracker, purpose string) *Builder[Req, Res]

+ func (b *Builder[Req, Res]) Transactional(runner TxRunner) *Builder[Req, Res]

+ func (b *Builder[Req, Res]) Use(m Middleware[Req, Res]) *Builder[Req, Res]

+ func (b *Builder[Req, Res]) UseWithDispatcher(m DispatcherMiddleware[Req, Res]) *Builder[Req, Res]

+ func (b *Builder[Req, Res]) Validate(fn func(ctx context.Context, req Req) error) *Builder[Req, Res]

+ func (b *Builder[Req, Res]) WithHistory(capacity int) (*Builder[Req, Res], *History[Req, Res])

+ func (b *Builder[Req, Res]) WithProfile(profile Profile) *Builder[Req, Res]

+ type BuiltAction struct

+ func (a *BuiltAction[Req, Res]) AddAnyHook(h ...AnyHook)

+ func (a *BuiltAction[Req, Res]) Describe() *Meta

+ func (a *BuiltAction[Req, Res]) Do(ctx context.Context, req Req) (res Res, err error)

+ func (a *BuiltAction[Req, Res]) ExecuteDecoded(ctx context.Context, decode DecodeFunc) (any, error)

+ func (a *BuiltAction[Req, Res]) GetAnyHooks() []AnyHook

+ func (a *BuiltAction[Req, Res]) GetBindings() []Binding

+ func (a *BuiltAction[Req, Res]) GetMeta() *Meta

+ func (a *BuiltAction[Req, Res]) History() *History[Req, Res]

+ func (a *BuiltAction[Req, Res]) OnCacheHit(ctx context.Context, req Req, res Res)

+ func (a *BuiltAction[Req, Res]) OnCacheMiss(ctx context.Context, req Req)

+ func (a *BuiltAction[Req, Res]) OnCoalesced(ctx context.Context, req Req)

+ func (a *BuiltAction[Req, Res]) OnDeduplicated(ctx context.Context, req Req)

+ func (a *BuiltAction[Req, Res]) OnRetry(ctx context.Context, req Req, attempt int, err error)

+ func (a *BuiltAction[Req, Res]) ReqPayload() any

+ func (a *BuiltAction[Req, Res]) ResPayload() any

+ func (a *BuiltAction[Req, Res]) String() string

+ type BuiltSaga struct

+ func (s *BuiltSaga[Req, Res]) Do(ctx context.Context, req Req) (SagaResult[Res], error)

+ type CacheConfig struct

+ KeyFunc func(Req) string

+ Layers []CacheLayer[Res]

+ TTL time.Duration

+ type CacheLayer interface

+ Get func(ctx context.Context, key string) (val V, hit bool, err error)

+ Set func(ctx context.Context, key string, val V, ttl time.Duration) error

+ type Coalescer struct

+ func NewCoalescer() *Coalescer

+ func (c *Coalescer) Do(ctx context.Context, key string, fn func(context.Context) (any, error)) (val any, shared bool, err error)

+ type DecodeFunc func(v any) error

+ type Describable interface

+ Describe func() *Meta

+ type DispatcherMiddleware func(next Fn[Req, Res], hooks HookDispatcher[Req, Res]) Fn[Req, Res]

+ func AdmissionMiddleware[Req, Res any](admission Admission) DispatcherMiddleware[Req, Res]

+ func CacheMiddleware[Req, Res any](cfg CacheConfig[Req, Res]) DispatcherMiddleware[Req, Res]

+ func CoalesceMiddleware[Req, Res any](coalescer *Coalescer, actionName string, keyFn func(Req) string) DispatcherMiddleware[Req, Res]

+ func Deduplicate[Req, Res any](keyFn func(Req) string) DispatcherMiddleware[Req, Res]

+ func RetryMiddleware[Req, Res any](maxRetry int, backoff func(attempt int) time.Duration) DispatcherMiddleware[Req, Res]

+ type Executable interface

+ ExecuteDecoded func(ctx context.Context, decode DecodeFunc) (any, error)

+ type FencedMutex interface

+ Acquire func(ctx context.Context, key string, ttl time.Duration) (lease LockLease, acquired bool, err error)

+ Release func(ctx context.Context, lease LockLease) (released bool, err error)

+ Renew func(ctx context.Context, lease LockLease, ttl time.Duration) (renewed bool, err error)

+ type Fn func(context.Context, Req) (Res, error)

+ type History struct

+ func NewHistory[Req, Res any](capacity int) *History[Req, Res]

+ func (h *History[Req, Res]) Push(rec Record[Req, Res])

+ func (h *History[Req, Res]) Snapshot() []Record[Req, Res]

+ type Hook struct

+ After func(ctx context.Context, req Req, res Res, err error, meta *Meta)

+ Before func(ctx context.Context, req Req, meta *Meta) (context.Context, error)

+ OnCacheHit func(ctx context.Context, req Req, res Res, meta *Meta)

+ OnCacheMiss func(ctx context.Context, req Req, meta *Meta)

+ OnCancel func(ctx context.Context, req Req, meta *Meta)

+ OnCoalesced func(ctx context.Context, req Req, meta *Meta)

+ OnDeduplicated func(ctx context.Context, req Req, meta *Meta)

+ OnError func(ctx context.Context, req Req, err error, meta *Meta)

+ OnExecuted func(ctx context.Context, req Req, res Res, err error, meta *Meta)

+ OnRegister func(meta *Meta)

+ OnRetry func(ctx context.Context, req Req, attempt int, err error, meta *Meta)

+ type HookDispatcher interface

+ OnCacheHit func(ctx context.Context, req Req, res Res)

+ OnCacheMiss func(ctx context.Context, req Req)

+ OnCoalesced func(ctx context.Context, req Req)

+ OnDeduplicated func(ctx context.Context, req Req)

+ OnRetry func(ctx context.Context, req Req, attempt int, err error)

+ type HookProvider interface

+ GetAnyHooks func() []AnyHook

+ type IdempotencyClaim struct

+ Entry IdempotencyEntry

+ State IdempotencyClaimState

+ Token string

+ type IdempotencyClaimState uint8

+ const IdempotencyClaimAcquired

+ const IdempotencyClaimCompleted

+ const IdempotencyClaimConflict

+ const IdempotencyClaimInProgress

+ type IdempotencyConfig struct

+ Enabled bool

+ KeyFunc func(body []byte) string

+ KeyHeader string

+ LeaseTTL time.Duration

+ TTL time.Duration

+ func (c IdempotencyConfig) EffectiveLeaseTTL() time.Duration

+ func (c IdempotencyConfig) Header() string

+ type IdempotencyCoordinator interface

+ Claim func(ctx context.Context, key, requestHash string, leaseTTL time.Duration) (IdempotencyClaim, error)

+ Complete func(ctx context.Context, key, token string, entry IdempotencyEntry, ...) error

+ Release func(ctx context.Context, key, token string) error

+ type IdempotencyEntry struct

+ Body []byte

+ Headers map[string]string

+ RequestHash string

+ Status int

+ StoredAt time.Time

+ type IdempotencyStore interface

+ Get func(ctx context.Context, key string) (IdempotencyEntry, bool)

+ Set func(ctx context.Context, key string, entry IdempotencyEntry, ttl time.Duration)

+ type LoadShedConfig struct

+ MaxCPU float64

+ MaxGoroutines int

+ type LockLease struct

+ Fence int64

+ Key string

+ Owner string

+ type MemoryIdempotencyStore struct

+ func NewMemoryIdempotencyStore(defTTL time.Duration) *MemoryIdempotencyStore

+ func (s *MemoryIdempotencyStore) Close()

+ func (s *MemoryIdempotencyStore) Get(_ context.Context, key string) (IdempotencyEntry, bool)

+ func (s *MemoryIdempotencyStore) Set(_ context.Context, key string, entry IdempotencyEntry, ttl time.Duration)

+ type MessageRes struct

+ Message string

+ type Meta struct

+ CacheTTL time.Duration

+ Coalesced bool

+ ConcurrencyLimit int32

+ Deduplicated bool

+ Description string

+ Idempotency IdempotencyConfig

+ LogSlowThreshold time.Duration

+ Name string

+ Node string

+ RateLimit string

+ RequiredFeatures []string

+ RequiredPermissions []string

+ RequiredRoles []string

+ RequiresAuth bool

+ RetryMax int

+ Scope ActionScope

+ SuccessStatus int

+ Tags []string

+ Timeout time.Duration

+ func (m *Meta) IsInternal() bool

+ func (m *Meta) IsPublic() bool

+ func (m *Meta) IsSystem() bool

+ func (m Meta) String() string

+ type Middleware func(Fn[Req, Res]) Fn[Req, Res]

+ func AdaptiveLoadShedding[Req, Res any](stats SystemStats, cfg LoadShedConfig, p Priority) Middleware[Req, Res]

+ func Adaptive[Req, Res any](name string, cfg AdaptiveConfig) Middleware[Req, Res]

+ func ConcurrencyLimitMiddleware[Req, Res any](limit int32) Middleware[Req, Res]

+ func HistoryMiddleware[Req, Res any](hist *History[Req, Res]) Middleware[Req, Res]

+ func SmartResilience[Req, Res any](name string) Middleware[Req, Res]

+ func TimeoutMiddleware[Req, Res any](d time.Duration) Middleware[Req, Res]

+ type Mutex interface

+ TryLock func(ctx context.Context, key string, ttl time.Duration) (bool, error)

+ Unlock func(ctx context.Context, key string) error

+ type PIITracker interface

+ TrackPIIAccess func(ctx context.Context, purpose string, actionName string)

+ type Plugin interface

+ type Priority uint8

+ const PriorityCritical

+ const PriorityLow

+ const PriorityNormal

+ type Profile struct

+ ConcurrencyLimit int32

+ Idempotency *IdempotencyConfig

+ RequireAuth bool

+ RequiredPermissions []string

+ Scope ActionScope

+ SuccessStatus int

+ Tags []string

+ Timeout time.Duration

+ func AuthenticatedReadProfile(permission string, tags ...string) Profile

+ func IdempotentCommandProfile(permission string, tags ...string) Profile

+ func InternalEventProfile(tags ...string) Profile

+ type QuotaCheckFunc func(ctx context.Context, tenantID string) (current int64, limit int64, err error)

+ type RateLimiter interface

+ Allow func(ctx context.Context, key string) (bool, error)

+ type Record struct

+ Duration time.Duration

+ Err error

+ Req Req

+ Res Res

+ Time time.Time

+ type ResilienceConfig struct

+ Adaptive *AdaptiveConfig

+ Backoff func(attempt int) time.Duration

+ MaxConcurrent int32

+ MaxRetries int

+ Timeout time.Duration

+ type SagaBuilder struct

+ func NewSaga[Req, Res any](name string) *SagaBuilder[Req, Res]

+ func (s *SagaBuilder[Req, Res]) AddOptionalStep(name string, do func(context.Context, Req) (Res, error), ...) *SagaBuilder[Req, Res]

+ func (s *SagaBuilder[Req, Res]) AddStep(name string, do func(context.Context, Req) (Res, error), ...) *SagaBuilder[Req, Res]

+ func (s *SagaBuilder[Req, Res]) Build() *BuiltSaga[Req, Res]

+ type SagaResult struct

+ DurationMs int64

+ Error string

+ Output Res

+ RolledBack bool

+ Saga string

+ Steps []StepResult

+ Success bool

+ type SagaStep struct

+ Do func(context.Context, Req) (Res, error)

+ Name string

+ Optional bool

+ Undo func(context.Context, Req) error

+ type StateEntity interface

+ GetState func() string

+ SetState func(string)

+ type StateMachineBuilder struct

+ func NewStateMachine[Req StateEntity, Res any](name string, exec Fn[Req, Res]) *StateMachineBuilder[Req, Res]

+ func (sm *StateMachineBuilder[Req, Res]) Allow(from string, to ...string) *StateMachineBuilder[Req, Res]

+ func (sm *StateMachineBuilder[Req, Res]) Build() *BuiltAction[Req, Res]

+ type StepResult struct

+ DurationMs int64

+ Error string

+ Skipped bool

+ Step string

+ Success bool

+ type StreamAction struct

+ func NewStream[Req, T any](name string, h StreamHandler[Req, T]) *StreamAction[Req, T]

+ func (a *StreamAction[Req, T]) Do(ctx context.Context, req Req) (iter.Seq2[T, error], error)

+ func (a *StreamAction[Req, T]) Use(h ...Hook[Req, iter.Seq2[T, error]]) *StreamAction[Req, T]

+ type StreamHandler func(context.Context, Req) (iter.Seq2[T, error], error)

+ type SystemStats interface

+ CPUPercent func() float64

+ Goroutines func() int

+ type Testable struct

+ func TestFromAction[Req, Res any](act *BuiltAction[Req, Res]) *Testable[Req, Res]

+ func TestFrom[Req, Res any](b *Builder[Req, Res]) *Testable[Req, Res]

+ func (t *Testable[Req, Res]) CaptureReq(ctx context.Context, input Req) (captured Req, res Res, err error)

+ func (t *Testable[Req, Res]) Do(ctx context.Context, req Req) (Res, error)

+ func (t *Testable[Req, Res]) DoRaw(ctx context.Context, req Req) (Res, error)

+ func (t *Testable[Req, Res]) ExpectErr(ctx context.Context, req Req, expected string) error

+ type TransientChecker interface

+ IsTransient func() bool

+ type TxRunner interface

+ RunInTx func(ctx context.Context, fn func(txCtx context.Context) error) error

+ type TypedPayload interface

+ ReqPayload func() any

+ ResPayload func() any

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL