Add maintained consumer migration examples
This commit is contained in:
331
examples/consumers/consumers.go
Normal file
331
examples/consumers/consumers.go
Normal file
@@ -0,0 +1,331 @@
|
||||
// Package consumers contains small, maintained application shapes that exercise
|
||||
// ConfigKit without making consumer domain policy part of the library API.
|
||||
package consumers
|
||||
|
||||
import (
|
||||
"math"
|
||||
"strconv"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
configkit "gitea.maximumdirect.net/eric/ConfigKit"
|
||||
)
|
||||
|
||||
// Artifact is a Narratio-shaped generated output declaration.
|
||||
type Artifact struct {
|
||||
Output string `yaml:"output"`
|
||||
Timeout time.Duration `yaml:"timeout"`
|
||||
}
|
||||
|
||||
// NarratioConfig demonstrates application defaults, partial imports, and
|
||||
// application-owned model-profile and artifact semantics.
|
||||
type NarratioConfig struct {
|
||||
PollInterval time.Duration `yaml:"poll_interval"`
|
||||
Timeout time.Duration `yaml:"timeout"`
|
||||
ModelProfile string `yaml:"model_profile"`
|
||||
Artifacts map[string]Artifact `yaml:"artifacts"`
|
||||
}
|
||||
|
||||
// LoadNarratio loads the maintained import fixture with Narratio-shaped rules.
|
||||
func LoadNarratio(path string) (*configkit.Result[NarratioConfig], error) {
|
||||
return LoadNarratioProfile(path, "")
|
||||
}
|
||||
|
||||
// LoadNarratioProfile selects a ConfigKit configuration overlay independently
|
||||
// from the application's ModelProfile field.
|
||||
func LoadNarratioProfile(path, profile string) (*configkit.Result[NarratioConfig], error) {
|
||||
return configkit.Load(configkit.File(path), configkit.Options[NarratioConfig]{
|
||||
Imports: true, Profile: profile,
|
||||
Definition: configkit.Definition[NarratioConfig]{
|
||||
Defaults: func() NarratioConfig { return NarratioConfig{PollInterval: time.Minute} },
|
||||
Resolve: resolveNarratio,
|
||||
Validate: validateNarratio,
|
||||
},
|
||||
})
|
||||
}
|
||||
|
||||
func resolveNarratio(configuration *NarratioConfig, resolution *configkit.Resolution) error {
|
||||
configkit.Default(resolution, configkit.Keys("timeout"), &configuration.Timeout,
|
||||
configuration.PollInterval/10, "derived from poll interval", configkit.Keys("poll_interval"))
|
||||
for name, artifact := range configuration.Artifacts {
|
||||
path := configkit.Keys("artifacts", name)
|
||||
configkit.Default(resolution, path.Key("timeout"), &artifact.Timeout,
|
||||
configuration.Timeout, "inherited pipeline timeout", configkit.Keys("timeout"))
|
||||
configkit.Normalize(resolution, path.Key("output"), &artifact.Output,
|
||||
strings.TrimSpace(artifact.Output), "trimmed artifact output")
|
||||
configuration.Artifacts[name] = artifact
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func validateNarratio(configuration *NarratioConfig, validation *configkit.Validation) {
|
||||
if configuration.PollInterval <= 0 {
|
||||
validation.Error(configkit.Keys("poll_interval"), "must be positive")
|
||||
}
|
||||
if configuration.Timeout <= 0 {
|
||||
validation.Error(configkit.Keys("timeout"), "must be positive")
|
||||
}
|
||||
for name, artifact := range configuration.Artifacts {
|
||||
path := configkit.Keys("artifacts", name)
|
||||
if artifact.Output == "" {
|
||||
validation.Error(path.Key("output"), "must be nonempty")
|
||||
}
|
||||
if artifact.Timeout <= 0 {
|
||||
validation.Error(path.Key("timeout"), "must be positive")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ObjectBinding is a Notarius-shaped canonical object binding. Options remain
|
||||
// dynamic because the application catalog selects their schema at runtime.
|
||||
type ObjectBinding struct {
|
||||
Object string `yaml:"object"`
|
||||
Options map[string]any `yaml:"options"`
|
||||
}
|
||||
|
||||
// NotariusConfig demonstrates string versions and dynamic catalog options.
|
||||
type NotariusConfig struct {
|
||||
Version string `yaml:"version"`
|
||||
Bindings []ObjectBinding `yaml:"bindings"`
|
||||
}
|
||||
|
||||
// LoadNotarius loads a Notarius-shaped configuration.
|
||||
func LoadNotarius(path string) (*configkit.Result[NotariusConfig], error) {
|
||||
return configkit.Load(configkit.File(path), configkit.Options[NotariusConfig]{
|
||||
Definition: configkit.Definition[NotariusConfig]{
|
||||
Version: &configkit.VersionRule{Path: configkit.Keys("version"), Check: requireVersion("v1")},
|
||||
Validate: validateNotarius,
|
||||
},
|
||||
})
|
||||
}
|
||||
|
||||
func requireVersion(expected string) func(configkit.Version, *configkit.Validation) error {
|
||||
return func(version configkit.Version, validation *configkit.Validation) error {
|
||||
if !version.Present || version.Null || version.Text != expected {
|
||||
validation.Error(configkit.Keys("version"), "unsupported configuration version")
|
||||
}
|
||||
return nil
|
||||
}
|
||||
}
|
||||
|
||||
func validateNotarius(configuration *NotariusConfig, validation *configkit.Validation) {
|
||||
for index, binding := range configuration.Bindings {
|
||||
path := configkit.Keys("bindings").Index(index)
|
||||
if binding.Object != "summary" && binding.Object != "registry" {
|
||||
validation.Error(path.Key("object"), "unsupported object binding")
|
||||
}
|
||||
for key, value := range binding.Options {
|
||||
optionPath := path.Key("options").Key(key)
|
||||
switch key {
|
||||
case "window_units":
|
||||
units, ok := value.(int64)
|
||||
if !ok || units < 1 {
|
||||
validation.Error(optionPath, "must be a positive integer")
|
||||
}
|
||||
case "format":
|
||||
if _, ok := value.(string); !ok {
|
||||
validation.Error(optionPath, "must be a string")
|
||||
}
|
||||
default:
|
||||
validation.Error(optionPath, "unsupported object option")
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// NotariusWindow converts ConfigKit's portable dynamic integer only at the
|
||||
// application runtime boundary.
|
||||
func NotariusWindow(configuration NotariusConfig, binding int) (int, bool) {
|
||||
if binding < 0 || binding >= len(configuration.Bindings) {
|
||||
return 0, false
|
||||
}
|
||||
value, ok := configuration.Bindings[binding].Options["window_units"].(int64)
|
||||
if !ok || value < 1 || (strconv.IntSize == 32 && value > math.MaxInt32) {
|
||||
return 0, false
|
||||
}
|
||||
return int(value), true
|
||||
}
|
||||
|
||||
// ModuleOptions is a WeatherReporter-shaped union of known module option fields.
|
||||
type ModuleOptions struct {
|
||||
WindowUnits *int `yaml:"window_units"`
|
||||
Sections []string `yaml:"sections"`
|
||||
}
|
||||
|
||||
// ModuleSpec uses the canonical object form instead of a string shorthand.
|
||||
type ModuleSpec struct {
|
||||
Module string `yaml:"module"`
|
||||
Options ModuleOptions `yaml:"options"`
|
||||
}
|
||||
|
||||
// ReportConfig keeps report-specific lists application-owned.
|
||||
type ReportConfig struct {
|
||||
Modules []ModuleSpec `yaml:"modules"`
|
||||
PathTemplates []string `yaml:"path_templates"`
|
||||
}
|
||||
|
||||
// WeatherConfig demonstrates simple defaults, reports, module options, and an
|
||||
// optional typed secret reference.
|
||||
type WeatherConfig struct {
|
||||
Units string `yaml:"units"`
|
||||
Reports map[string]ReportConfig `yaml:"reports"`
|
||||
Token *configkit.Secret `yaml:"token"`
|
||||
}
|
||||
|
||||
// LoadWeather loads a WeatherReporter-shaped source and explicit CLI records.
|
||||
func LoadWeather(source configkit.Source, overrides ...configkit.Override) (*configkit.Result[WeatherConfig], error) {
|
||||
return configkit.Load(source, configkit.Options[WeatherConfig]{
|
||||
Overrides: overrides,
|
||||
Definition: weatherDefinition(func() WeatherConfig {
|
||||
return WeatherConfig{Units: "metric"}
|
||||
}),
|
||||
})
|
||||
}
|
||||
|
||||
// LoadConstructedWeather runs the same rules over a detached constructed value.
|
||||
func LoadConstructedWeather(configuration WeatherConfig) (*configkit.Result[WeatherConfig], error) {
|
||||
return configkit.Load(configkit.NoSource(), configkit.Options[WeatherConfig]{
|
||||
Definition: weatherDefinition(func() WeatherConfig { return configuration }),
|
||||
})
|
||||
}
|
||||
|
||||
func weatherDefinition(defaults func() WeatherConfig) configkit.Definition[WeatherConfig] {
|
||||
return configkit.Definition[WeatherConfig]{
|
||||
Defaults: defaults,
|
||||
Resolve: func(configuration *WeatherConfig, resolution *configkit.Resolution) error {
|
||||
for reportName, report := range configuration.Reports {
|
||||
var modules []ModuleSpec
|
||||
if report.Modules != nil {
|
||||
modules = append(make([]ModuleSpec, 0, len(report.Modules)), report.Modules...)
|
||||
}
|
||||
for index, module := range modules {
|
||||
if module.Options.Sections != nil {
|
||||
sections := append([]string(nil), module.Options.Sections...)
|
||||
for position := range sections {
|
||||
sections[position] = strings.TrimSpace(sections[position])
|
||||
}
|
||||
module.Options.Sections = sections
|
||||
}
|
||||
modules[index] = module
|
||||
}
|
||||
configkit.Normalize(resolution, configkit.Keys("reports", reportName, "modules"),
|
||||
&report.Modules, modules, "normalized module options")
|
||||
configuration.Reports[reportName] = report
|
||||
}
|
||||
return nil
|
||||
},
|
||||
Validate: validateWeather,
|
||||
}
|
||||
}
|
||||
|
||||
func validateWeather(configuration *WeatherConfig, validation *configkit.Validation) {
|
||||
if configuration.Units != "metric" && configuration.Units != "us" {
|
||||
validation.Error(configkit.Keys("units"), "must be metric or us")
|
||||
}
|
||||
for reportName, report := range configuration.Reports {
|
||||
path := configkit.Keys("reports", reportName)
|
||||
if report.Modules != nil && len(report.Modules) == 0 {
|
||||
validation.Error(path.Key("modules"), "must contain at least one module")
|
||||
}
|
||||
if report.PathTemplates != nil && len(report.PathTemplates) == 0 {
|
||||
validation.Error(path.Key("path_templates"), "must contain at least one template")
|
||||
}
|
||||
for index, module := range report.Modules {
|
||||
modulePath := path.Key("modules").Index(index)
|
||||
switch module.Module {
|
||||
case "chunker":
|
||||
if module.Options.WindowUnits == nil || *module.Options.WindowUnits < 1 {
|
||||
validation.Error(modulePath.Key("options").Key("window_units"), "must be a positive integer")
|
||||
}
|
||||
if module.Options.Sections != nil {
|
||||
validation.Error(modulePath.Key("options").Key("sections"), "not supported by this module")
|
||||
}
|
||||
case "discussion":
|
||||
if module.Options.WindowUnits != nil {
|
||||
validation.Error(modulePath.Key("options").Key("window_units"), "not supported by this module")
|
||||
}
|
||||
if len(module.Options.Sections) == 0 {
|
||||
validation.Error(modulePath.Key("options").Key("sections"), "must contain at least one section")
|
||||
}
|
||||
default:
|
||||
validation.Error(modulePath.Key("module"), "unsupported module")
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// SpeakerRule and SpeakerRules preserve declaration order for application matching.
|
||||
type SpeakerRule struct {
|
||||
Prefix string `yaml:"prefix"`
|
||||
Name string `yaml:"name"`
|
||||
}
|
||||
|
||||
type SpeakerRules struct {
|
||||
Rules []SpeakerRule `yaml:"rules"`
|
||||
}
|
||||
|
||||
// AutocorrectRule and AutocorrectRules preserve replacement order.
|
||||
type AutocorrectRule struct {
|
||||
Find string `yaml:"find"`
|
||||
Replace string `yaml:"replace"`
|
||||
}
|
||||
|
||||
type AutocorrectRules struct {
|
||||
Rules []AutocorrectRule `yaml:"rules"`
|
||||
}
|
||||
|
||||
// LoadSpeakerRules loads one independent Seriatim-shaped rule file.
|
||||
func LoadSpeakerRules(path string) (*configkit.Result[SpeakerRules], error) {
|
||||
return configkit.Load(configkit.File(path), configkit.Options[SpeakerRules]{
|
||||
Definition: configkit.Definition[SpeakerRules]{Validate: validateSpeakerRules},
|
||||
})
|
||||
}
|
||||
|
||||
// LoadAutocorrectRules loads another independent ordered rule file.
|
||||
func LoadAutocorrectRules(path string) (*configkit.Result[AutocorrectRules], error) {
|
||||
return configkit.Load(configkit.File(path), configkit.Options[AutocorrectRules]{
|
||||
Definition: configkit.Definition[AutocorrectRules]{Validate: validateAutocorrectRules},
|
||||
})
|
||||
}
|
||||
|
||||
func validateSpeakerRules(configuration *SpeakerRules, validation *configkit.Validation) {
|
||||
seen := make(map[string]int)
|
||||
for index, rule := range configuration.Rules {
|
||||
path := configkit.Keys("rules").Index(index)
|
||||
if rule.Prefix == "" {
|
||||
validation.Error(path.Key("prefix"), "must be nonempty")
|
||||
}
|
||||
if previous, ok := seen[rule.Prefix]; ok {
|
||||
validation.Error(path.Key("prefix"), "prefix must be unique",
|
||||
configkit.Keys("rules").Index(previous).Key("prefix"))
|
||||
}
|
||||
seen[rule.Prefix] = index
|
||||
}
|
||||
}
|
||||
|
||||
func validateAutocorrectRules(configuration *AutocorrectRules, validation *configkit.Validation) {
|
||||
for index, rule := range configuration.Rules {
|
||||
path := configkit.Keys("rules").Index(index)
|
||||
if rule.Find == "" {
|
||||
validation.Error(path.Key("find"), "must be nonempty")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// SpeakerName is application runtime matching, not configuration infrastructure.
|
||||
func SpeakerName(rules SpeakerRules, input string) (string, bool) {
|
||||
for _, rule := range rules.Rules {
|
||||
if strings.HasPrefix(input, rule.Prefix) {
|
||||
return rule.Name, true
|
||||
}
|
||||
}
|
||||
return "", false
|
||||
}
|
||||
|
||||
// ApplyAutocorrect is application runtime replacement in declared order.
|
||||
func ApplyAutocorrect(rules AutocorrectRules, input string) string {
|
||||
for _, rule := range rules.Rules {
|
||||
input = strings.ReplaceAll(input, rule.Find, rule.Replace)
|
||||
}
|
||||
return input
|
||||
}
|
||||
Reference in New Issue
Block a user