helpers

type ApiRouteConfig ¶

type ApiRouteConfig struct {
	Type            ConfigType
	HttpMethod      HttpMethod
	RevalidateInSec int
}

func (config *ApiRouteConfig) RegisterRoute(r chi.Router, httpPath string, fn func(w http.ResponseWriter, r *http.Request))

type AppConfig ¶

type AppConfig = config.RuntimeConfig

The routing/caching config types and enums are defined canonically in the lightweight, user-facing pkg/config package (so a project can write them as gothic.* in gothic.config.go). They are re-exported here as aliases so the rest of this package — and existing user code — keeps using the gothicRoutes.* names unchanged, while there is exactly one definition.

type CacheConfig ¶

type CacheConfig = config.CacheConfig

The routing/caching config types and enums are defined canonically in the lightweight, user-facing pkg/config package (so a project can write them as gothic.* in gothic.config.go). They are re-exported here as aliases so the rest of this package — and existing user code — keeps using the gothicRoutes.* names unchanged, while there is exactly one definition.

type CacheStore ¶

type CacheStore interface {
	Get(key string) ([]byte, bool)
	Set(key string, value []byte, ttl time.Duration)
	Flush() error
	Close() error
}

type CacheType ¶

type CacheType = config.CacheType

The routing/caching config types and enums are defined canonically in the lightweight, user-facing pkg/config package (so a project can write them as gothic.* in gothic.config.go). They are re-exported here as aliases so the rest of this package — and existing user code — keeps using the gothicRoutes.* names unchanged, while there is exactly one definition.

type CompressionMethod ¶

type CompressionMethod = config.CompressionMethod

The routing/caching config types and enums are defined canonically in the lightweight, user-facing pkg/config package (so a project can write them as gothic.* in gothic.config.go). They are re-exported here as aliases so the rest of this package — and existing user code — keeps using the gothicRoutes.* names unchanged, while there is exactly one definition.

type ConfigType ¶

type ConfigType int

const (
	ISR ConfigType = iota
	STATIC
	DYNAMIC
)

type FileBasedRouteHelper ¶

type FileBasedRouteHelper struct {
	TemplateInfo          TemplateInfo
	OutputFile            string
	TemplateFile          string
	ApiRoutesFolder       string
	ComponentRoutesFolder string
	PageRoutesFolder      string
	Template              helpers.TemplateHelper
}

func NewFileBasedRouteHelper() FileBasedRouteHelper

func (helper *FileBasedRouteHelper) Initialize(goModName string)

func (helper *FileBasedRouteHelper) RemoveDuplicates()

func (helper *FileBasedRouteHelper) Render(goModName string) error

type HttpMethod ¶

type HttpMethod int

const (
	GET HttpMethod = iota
	POST
	PUT
	PATCH
	DELETE
)

type Imports ¶

type Imports struct {
	Package     string
	PackagePath string
}

type InMemoryCacheStore ¶

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

func NewInMemoryCacheStore(config *CacheConfig) *InMemoryCacheStore

func (s *InMemoryCacheStore) Close() error

func (s *InMemoryCacheStore) Flush() error

func (s *InMemoryCacheStore) Get(key string) ([]byte, bool)

func (s *InMemoryCacheStore) Set(key string, value []byte, ttl time.Duration)

type LocalFilesCacheStore ¶

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

func NewLocalFilesCacheStore(config *CacheConfig) (*LocalFilesCacheStore, error)

func (s *LocalFilesCacheStore) Close() error

func (s *LocalFilesCacheStore) Flush() error

func (s *LocalFilesCacheStore) Get(key string) ([]byte, bool)

func (s *LocalFilesCacheStore) Set(key string, value []byte, ttl time.Duration)

type RedisCacheStore ¶

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

func NewRedisCacheStore(config *CacheConfig) (*RedisCacheStore, error)

func (s *RedisCacheStore) Close() error

func (s *RedisCacheStore) Flush() error

func (s *RedisCacheStore) Get(key string) ([]byte, bool)

func (s *RedisCacheStore) Set(key string, value []byte, ttl time.Duration)

type RouteConfig ¶

type RouteConfig[T any] struct {
	Type            ConfigType
	HttpMethod      HttpMethod
	RevalidateInSec int
	Middleware      func(w http.ResponseWriter, r *http.Request) T
	// ClientSideState, if non-nil, marks this route as having a WASM reactive state
	// function.  The CLI extracts the function body and compiles it with TinyGo.
	// The function is never called server-side; it only needs to compile.
	ClientSideState func()
	// WasmCompression sets the compression algorithm for the compiled WASM output.
	// Defaults to GZIP (zero value). Options: GZIP, BROTLI.
	WasmCompression CompressionMethod
	// WasmCompiler selects the WASM build toolchain. Defaults to GothicTinyGo.
	WasmCompiler WasmCompiler
	// Multiplexed, when true, makes every placement of this component type on a
	// page share ONE WASM instance via scope register/unregister instead of
	// instantiating the binary once per placement. Opt-in and additive: the
	// default (false) path is byte-identical to the per-placement behavior.
	// Collapses the N-per-row leak case (N per-row WASM instances → 1 instance).
	// Topic managers are never multiplexed.
	Multiplexed bool
	// Path is the HTTP route path, set automatically by RegisterRoute.
	// Use it with StatefulComponentOf to avoid hardcoding path strings.
	Path string
}

func (config *RouteConfig[T]) RegisterRoute(r chi.Router, httpPath string, component func(T) templ.Component)

func (config *RouteConfig[T]) Render(r *http.Request, w http.ResponseWriter, component templ.Component) error

type RouteTemplate ¶

type RouteTemplate struct {
	FunctionName      string
	ConfigName        string
	PackageName       string
	ConfigPackageName string
	HttpPath          string
	OriginFile        string
}

type StaticFilesMode ¶

type StaticFilesMode = config.StaticFilesMode

The routing/caching config types and enums are defined canonically in the lightweight, user-facing pkg/config package (so a project can write them as gothic.* in gothic.config.go). They are re-exported here as aliases so the rest of this package — and existing user code — keeps using the gothicRoutes.* names unchanged, while there is exactly one definition.

type TemplateInfo ¶

type TemplateInfo struct {
	GoModName     string
	ImportDefault bool
	Imports       []Imports
	Routes        []RouteTemplate
	ApiRoutes     []RouteTemplate
}

type WasmCompiler ¶

type WasmCompiler int

WasmCompiler selects the WASM build toolchain for a route.

const (
	GothicTinyGo WasmCompiler = iota // default: embedded TinyGo binary
	LocalTinyGo                      // system tinygo binary in PATH
	Golang                           // GOOS=js GOARCH=wasm standard Go compiler
)