report

type Compilation ¶

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

Compilation is a complete, unpublished base-and-report artifact set.

func (c *Compilation) Artifacts() []*ComponentArtifact

func (c *Compilation) RuntimeComponents(ctx context.Context, configurator RuntimeConfigurator) ([]*registry.RegisteredComponent, error)

func (c *Compilation) Types() (*typecatalog.Catalog, error)

type ComponentArtifact ¶

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

ComponentArtifact is one compiled component awaiting concrete runtime capabilities such as a SQL reader or custom handler.

func (a *ComponentArtifact) Component() *spec.Component

func (a *ComponentArtifact) HasLinkedHandler() bool

func (a *ComponentArtifact) InputContract() *registry.InputContract

func (a *ComponentArtifact) InputType() reflect.Type

func (a *ComponentArtifact) IsReport() bool

func (a *ComponentArtifact) NewViewProvider(config bootstrap.ViewRuntimeConfig) (locator.Provider, error)

func (a *ComponentArtifact) OutputType() reflect.Type

func (a *ComponentArtifact) ReaderCompilation() *bootstrap.CompiledReader

type ComposeResponse ¶

type ComposeResponse struct {
	Columns []cubecompose.Column `json:"columns"`
	Data    any                  `json:"data"`
}

type Derived ¶

type Derived struct {
	Component  *spec.Component
	InputType  reflect.Type
	OutputType reflect.Type
	Handler    handler.Handler
	Plan       *Plan
	Type       *x.Type
}

Derived is one ordinary cube component ready for normal artifact compilation and runtime registration.

type Handler ¶

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

Handler translates one typed report input into selector and filter providers, then delegates to the exact source component.

func NewHandler(plan *Plan) *Handler

func (h *Handler) Execute(ctx context.Context, invocation rhandler.Invocation) (any, error)

type Plan ¶

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

Plan is immutable execution metadata for one derived cube route.

func (p *Plan) InputType() reflect.Type

func (p *Plan) OutputType() reflect.Type

func (p *Plan) Target() exec.ComponentTarget

type Project ¶

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

Project contains the detached base metadata and newly derived components.

func (p *Project) Components() []*spec.Component

func (p *Project) Derived() []*Derived

type ProjectCompiler ¶

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

ProjectCompiler derives cube components from base components whose exact input contracts have already been compiled.

func NewProjectCompiler(config ProjectConfig) *ProjectCompiler

func (c *ProjectCompiler) Compile(sources []Source) (*Project, error)

func (c *ProjectCompiler) CompileArtifacts(inputs []bootstrap.ArtifactInput) (*Compilation, error)

type ProjectConfig ¶

type ProjectConfig struct {
	// Registry supplies compiled package exports; CompileArtifacts snapshots it
	// once for the whole unpublished component generation.
	Registry  *x.Registry
	Types     *typecatalog.Catalog
	Authority typecatalog.Authority
}

type ProjectedComponent ¶

type ProjectedComponent struct {
	Name        string
	Method      string
	Path        string
	MCPEnabled  bool
	Description string
}

ProjectedComponent describes one derived runtime component produced from a grouped reader. It is the catalog-level identity used by hosts and authoring tools; compilation remains owned by ProjectCompiler.

func ProjectedComponents(component *spec.Component) []ProjectedComponent

type RuntimeCapabilities ¶

type RuntimeCapabilities struct {
	Handler    handler.Handler
	Reader     exec.Reader
	Invocation handler.InvocationCapabilities
	Providers  []locator.Provider
	DataSource exec.DataSource
}

RuntimeCapabilities contains only the concrete runtime attachments that project composition permits an application to supply.

type RuntimeConfigurator ¶

type RuntimeConfigurator interface {
	Configure(context.Context, *ComponentArtifact) (RuntimeCapabilities, error)
}

RuntimeConfigurator resolves concrete runtime capabilities from a compiled artifact without receiving the canonical registration carrier.

type RuntimeConfigureFunc ¶

type RuntimeConfigureFunc func(context.Context, *ComponentArtifact) (RuntimeCapabilities, error)

func (f RuntimeConfigureFunc) Configure(ctx context.Context, artifact *ComponentArtifact) (RuntimeCapabilities, error)

type Source ¶

type Source struct {
	Component  *spec.Component
	Input      *registry.InputContract
	OutputType reflect.Type
}

Source is an authority-resolved base component after its canonical input contract has been compiled and before runtime registration.