exec

type CacheInvalidation ¶ added in v1.1.0

type CacheInvalidation struct {
	View       string `json:"view"`
	Scope      string `json:"scope"`
	Generation string `json:"generation,omitempty"`
	Error      string `json:"error,omitempty"`
}

type CacheServiceInvalidator ¶ added in v1.1.0

type CacheServiceInvalidator interface {
	InvalidateCache(context.Context, string) (string, error)
}

CacheServiceInvalidator lets supplied cache services support administration without importing Datly's internal generation implementation.

type ComponentInvoker ¶

type ComponentInvoker interface {
	InvokeComponent(context.Context, ComponentRequest) (any, error)
}

type ComponentRequest ¶

type ComponentRequest struct {
	Target ComponentTarget
	Input  any
	// Replay is a native binding seed, never pre-bound component input.
	Replay *bindly.ReplayBinding
	// BindingOutput supplies the calling output to explicitly declared output bindings.
	BindingOutput any
	Providers     []locator.Provider
	// Completion observes canonical managed-transaction evidence for this root.
	// It is trusted service metadata and never client-bindable.
	Completion func(xhandler.Outcome)
	// PrepareQuery requests a bound root query through the same input lifecycle.
	// It is a trusted component capability, never a transport request option.
	PrepareQuery bool
	// DryRun plans an ordinary reader root without opening a row reader.
	// Input initialization, providers and SQL templates still run.
	DryRun bool
	// ReaderOptions apply after canonical input binding, to the target reader's
	// result graph. Dependency binding retains its own invocation context policy.
	ReaderOptions *ReaderOptions
	// ReportOrdering is explicit report-only ordering permission. It is never
	// inherited by child calls and does not enable pagination or other selectors.
	ReportOrdering *ReportOrdering
	// WarmupOmitInput names trusted warmup-owned inputs that are intentionally
	// absent from canonical transport binding, such as an indexed warmup key.
	WarmupOmitInput []string
	Warmup          *ReaderWarmupRequest
}

ComponentRequest invokes an exact target. Input is reserved for a trusted caller that already owns the canonical typed component input.

type ComponentTarget ¶

type ComponentTarget struct {
	Component spec.Key
	Route     spec.RouteRef
}

ComponentTarget identifies one exact component route.

func (t ComponentTarget) String() string

type ConnectorDataSourceProvider ¶ added in v1.1.0

type ConnectorDataSourceProvider interface {
	ConnectorDataSource(ctx context.Context, name string) (DataSource, error)
}

ConnectorDataSourceProvider supplies a lazy source for an explicitly named connector. The SQL layer owns source construction; the invocation engine owns its transaction lifecycle. Unknown names must not select a default.

type DataSource ¶

type DataSource interface {
	Open(ctx context.Context) (xhandler.Data, error)
}

DataSource opens one lazy handler data capability for an invocation.

type OutputFieldFilter ¶

type OutputFieldFilter interface{ ExcludePath([]string, string) bool }

OutputFieldFilter is an invocation's user projection, independent of loaded columns and per-row read evidence. Paths follow the native JSON encoder.

func SelectedOutputFields(ctx context.Context, value any) OutputFieldFilter

type PanicError ¶

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

PanicError retains recovery diagnostics privately. It deliberately does not unwrap the panic value: panic(response.Error) is not an intentional response. Cause and Stack are for operator diagnostics, never protocol serialization.

func NewPanicError(operation string, cause any) *PanicError

func (e *PanicError) Cause() any

func (e *PanicError) Error() string

func (e *PanicError) Format(s fmt.State, verb rune)

func (e *PanicError) Stack() []byte

type PredicateEvaluator ¶

type PredicateEvaluator interface {
	ContextType() reflect.Type
	NewContext(context.Context, xhandler.Binder, func(...any)) (any, error)
}

PredicateEvaluator supplies a typed template context without exposing the concrete predicate implementation to SQL template compilation.

type PreparedQuery ¶

type PreparedQuery struct {
	SQL        string
	Args       []any
	Projection ProjectionReader
}

PreparedQuery contains bound source SQL and a projection executor owned by that source connection. No database or transaction is exposed to handlers.

type ProjectionReader ¶

type ProjectionReader interface {
	ReadProjection(context.Context, ProjectionRequest) (any, error)
}

type ProjectionRequest ¶

type ProjectionRequest struct {
	SQL     string
	Args    []any
	RowType reflect.Type
}

type ProviderScope ¶

type ProviderScope interface {
	Providers() []locator.Provider
}

ProviderScope supplies invocation-local providers without coupling protocol adapters to the concrete runtime engine.

type QueryPreparer ¶

type QueryPreparer interface {
	PrepareQuery(context.Context, any, xhandler.Binder, sqlx.ParameterResolver) (*PreparedQuery, error)
}

QueryPreparer is an optional capability of a compiled SQL reader.

type ReadPlan ¶

type ReadPlan struct {
	SQL  string
	Args []any
}

ReadPlan contains the bound root query with its effective pagination. It grants no execution capability and does not promise whole-invocation purity.

type ReadPlanner ¶

type ReadPlanner interface {
	PlanRead(context.Context, any, xhandler.Binder, sqlx.ParameterResolver) (*ReadPlan, error)
}

type Reader ¶

type Reader interface {
	Read(ctx context.Context, input any, binder xhandler.Binder, resolver sqlx.ParameterResolver) (any, error)
}

Reader executes one read using input already prepared by the unified handler engine. SQL plans, connections, caches, and mutable reader state remain private to the implementation.

type ReaderCacheManager ¶ added in v1.1.0

type ReaderCacheManager interface {
	CacheViews() []string
	InvalidateCache(context.Context, string, string) ([]CacheInvalidation, error)
}

ReaderCacheManager is a server-owned capability. HTTP callers require an independent administrator policy before this operation is invoked.

type ReaderInput ¶

type ReaderInput struct {
	Input      any
	Binder     xhandler.Binder
	Parameters sqlx.ParameterResolver
}

ReaderInput carries invocation values only. Bindly projections stay owned by the canonical registry contract and its DI adapter.

type ReaderInputPreparer ¶

type ReaderInputPreparer func(context.Context, ...string) (*ReaderInput, error)

type ReaderOptions ¶

type ReaderOptions struct {
	RefreshCache bool
	CacheOnly    bool
	QueryScope   *sqlxread.QueryScope
}

ReaderOptions are trusted invocation controls, shared by nested reader work. Cache ownership and identity remain with SQLX. Transactional views bypass shared caches, including refresh/writeback, and reject CacheOnly rather than silently falling back to SQL execution.

func ReaderOptionsFromContext(ctx context.Context) ReaderOptions

func (o ReaderOptions) Context(ctx context.Context) context.Context

type ReaderWarmer ¶

type ReaderWarmer interface {
	Warmup(context.Context, ReaderWarmupInvocation) (int, error)
}

ReaderWarmer is an optional reader operation; native SQLX owns all cache data.

type ReaderWarmupInvocation ¶

type ReaderWarmupInvocation struct {
	Request    ReaderWarmupRequest
	Input      any
	Binder     xhandler.Binder
	Parameters sqlx.ParameterResolver
}

ReaderWarmupInvocation carries canonical input already bound by the engine.

type ReaderWarmupRequest ¶

type ReaderWarmupRequest struct {
	View     string
	Settings *spec.CacheWarmupSettings
}

ReaderWarmupRequest selects one prepared view and its authored warmup policy. It is a trusted startup/operational request, not a transport parameter.

type ReaderWarmupTarget ¶

type ReaderWarmupTarget struct {
	View     string
	Settings *spec.CacheWarmupSettings
}

ReaderWarmupTarget is one materialized view warmup policy owned by a reader.

type ReaderWarmupTargeter ¶

type ReaderWarmupTargeter interface {
	WarmupTargets() []ReaderWarmupTarget
}

ReaderWarmupTargeter exposes reader-owned warmup targets after compilation.

type ReportOrdering ¶ added in v1.1.0

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

ReportOrdering is a trusted, invocation-local permission, not a selector or transport input. It changes only the ordering gate; SQL validation still runs.

func ForwardReportOrdering(ctx context.Context, target ComponentTarget, view string) *ReportOrdering

func NewReportOrdering(target ComponentTarget, view string, fields ...string) *ReportOrdering