Files
narratio/internal/config/document_configkit.go

222 lines
8.6 KiB
Go
Raw Normal View History

package config
import (
"encoding/json"
"fmt"
"os"
"path/filepath"
"strings"
configkit "go.maximumdirect.net/configkit"
)
const maxConfigDocumentBytes int64 = 8 << 20
type documentResolution struct {
campaign *configkit.Result[CampaignConfig]
session *configkit.Result[SessionConfig]
sources map[string]string
}
// ConfigKitResult returns the campaign's actual completed native load result.
// Constructed campaign values have no result.
func (cfg *CampaignConfig) ConfigKitResult() *configkit.Result[CampaignConfig] {
if cfg == nil || cfg.resolution == nil {
return nil
}
return cfg.resolution.campaign
}
// ConfigKitResult returns the session's actual completed native load result.
// Constructed session values have no result.
func (cfg *SessionConfig) ConfigKitResult() *configkit.Result[SessionConfig] {
if cfg == nil || cfg.resolution == nil {
return nil
}
return cfg.resolution.session
}
func sessionFieldExplicit(cfg *SessionConfig, name string) bool {
result := cfg.ConfigKitResult()
return result != nil && result.Metadata().IsExplicit(configkit.Keys("inputs", name))
}
func documentResource(resolution *configkit.Resolution, path configkit.Path, value *string, invocationDir string, sources map[string]string) {
if info, ok := resolution.EntryInfo(path); ok && len(info.Origin.Locations) == 1 {
if source, ok := resolution.Source(info.Origin.Locations[0].SourceID); ok {
name := source.Path
if name == "" {
name = source.Label
}
sources[path.String()] = name
}
}
resolveHostResource(resolution, path, value, invocationDir)
}
func campaignDefinition(invocationDir string, sources map[string]string, expected string) configkit.Definition[CampaignConfig] {
return configkit.Definition[CampaignConfig]{Resolve: func(cfg *CampaignConfig, resolution *configkit.Resolution) error {
documentResource(resolution, configkit.Keys("session_template_file"), &cfg.SessionTemplateFile, invocationDir, sources)
inputs := configkit.Keys("inputs")
for _, field := range []struct {
name string
value *string
}{
{"speakers_file", &cfg.Inputs.SpeakersFile}, {"autocorrect_file", &cfg.Inputs.AutocorrectFile},
{"glossary_file", &cfg.Inputs.GlossaryFile}, {"party_file", &cfg.Inputs.PartyFile},
{"spell_catalog_file", &cfg.Inputs.SpellCatalogFile},
} {
documentResource(resolution, inputs.Key(field.name), field.value, invocationDir, sources)
}
return nil
}, Validate: func(cfg *CampaignConfig, v *configkit.Validation) {
validateCampaignConfigKit(cfg, v)
validateIdentity(v, "campaign_id", expected, CampaignID(cfg))
}}
}
func sessionDefinition(invocationDir string, sources map[string]string, label string, opts SessionLoadOptions) configkit.Definition[SessionConfig] {
hasSource := false
return configkit.Definition[SessionConfig]{Resolve: func(cfg *SessionConfig, resolution *configkit.Resolution) error {
info, ok := resolution.EntryInfo(configkit.Keys())
hasSource = ok && len(info.Origin.Locations) > 0
if !hasSource {
return nil
}
inputs := configkit.Keys("inputs")
for _, field := range []struct {
name string
value *string
}{
{"audio_dir", &cfg.Inputs.AudioDir}, {"speakers_file", &cfg.Inputs.SpeakersFile},
{"autocorrect_file", &cfg.Inputs.AutocorrectFile}, {"glossary_file", &cfg.Inputs.GlossaryFile},
{"spell_catalog_file", &cfg.Inputs.SpellCatalogFile},
} {
documentResource(resolution, inputs.Key(field.name), field.value, invocationDir, sources)
}
for index := range cfg.Inputs.AudioFiles {
documentResource(resolution, inputs.Key("audio_files").Index(index), &cfg.Inputs.AudioFiles[index], invocationDir, sources)
}
applyCampaignSessionDefaults(cfg, resolution, opts)
return nil
}, Validate: func(cfg *SessionConfig, validation *configkit.Validation) {
// Optional discovery with no selected document leaves acquisition to
// the caller's next source. There is no session to validate yet.
if !hasSource {
return
}
validateIdentity(validation, "session_id", strings.TrimSpace(opts.SessionID), strings.TrimSpace(cfg.SessionID))
validateIdentity(validation, "previous_session_id", strings.TrimSpace(opts.PreviousSessionID), strings.TrimSpace(cfg.PreviousSessionID))
if opts.Campaign != nil {
validateIdentity(validation, "campaign", CampaignID(opts.Campaign), cfg.Campaign)
}
data, err := json.Marshal(cfg)
if err != nil {
validation.Error(configkit.Keys(), "cannot inspect session configuration")
return
}
if err := rejectSessionTemplatePlaceholders(label, string(data)); err != nil {
validation.Error(configkit.Keys(), err.Error())
return
}
if path, err := sessionConfigurationError(cfg); err != nil {
validation.Error(path, err.Error())
}
}}
}
func applyCampaignSessionDefaults(cfg *SessionConfig, resolution *configkit.Resolution, opts SessionLoadOptions) {
if opts.Campaign == nil {
return
}
campaign := opts.Campaign
reason := fmt.Sprintf("default from campaign %q (%s)", CampaignID(campaign), opts.CampaignPath)
configkit.Default(resolution, configkit.Keys("campaign"), &cfg.Campaign, CampaignID(campaign), reason)
for _, field := range []struct {
name, value string
target *string
}{
{"speakers_file", campaign.Inputs.SpeakersFile, &cfg.Inputs.SpeakersFile},
{"autocorrect_file", campaign.Inputs.AutocorrectFile, &cfg.Inputs.AutocorrectFile},
{"glossary_file", campaign.Inputs.GlossaryFile, &cfg.Inputs.GlossaryFile},
{"spell_catalog_file", campaign.Inputs.SpellCatalogFile, &cfg.Inputs.SpellCatalogFile},
} {
if field.value != "" {
configkit.Default(resolution, configkit.Keys("inputs", field.name), field.target, field.value, reason)
}
}
}
// LoadCampaignWithIdentity validates an optional asserted identity within the native load.
func LoadCampaignWithIdentity(path, expected string) (*CampaignConfig, error) {
invocationDir, err := os.Getwd()
if err != nil {
return nil, err
}
sources := make(map[string]string)
result, err := configkit.Load(configkit.File(path), configkit.Options[CampaignConfig]{Imports: true, Definition: campaignDefinition(invocationDir, sources, expected)})
if err != nil {
return nil, fmt.Errorf("load campaign config: %w", err)
}
cfg := &result.Config
cfg.resolution = &documentResolution{campaign: result, sources: sources}
return cfg, nil
}
func loadSessionSource(source configkit.Source, label string, opts SessionLoadOptions, imports bool) (*SessionConfig, string, error) {
return loadSessionSourceWithFilesystem(source, label, opts, imports, nil)
}
// LoadSessionAuthoringBytes resolves a rendered local document before moving or
// publishing it. The path supplies its authoring base without writing that file.
func LoadSessionAuthoringBytes(path string, data []byte, opts SessionLoadOptions) (*SessionConfig, error) {
absolute, err := filepath.Abs(path)
if err != nil {
return nil, err
}
filesystem := &configkit.FilesystemContext{BaseDir: filepath.Dir(absolute), Root: string(filepath.Separator)}
cfg, _, err := loadSessionSourceWithFilesystem(configkit.Bytes(absolute, data), absolute, opts, true, filesystem)
return cfg, err
}
func loadSessionSourceWithFilesystem(source configkit.Source, label string, opts SessionLoadOptions, imports bool, filesystem *configkit.FilesystemContext) (*SessionConfig, string, error) {
invocationDir, err := os.Getwd()
if err != nil {
return nil, "", err
}
if filesystem != nil {
invocationDir = filesystem.BaseDir
}
sources := make(map[string]string)
result, err := configkit.Load(source, configkit.Options[SessionConfig]{Imports: imports, Filesystem: filesystem, Definition: sessionDefinition(invocationDir, sources, label, opts)})
if err != nil {
return nil, "", fmt.Errorf("load session config: %w", err)
}
acquired := result.Sources()
if len(acquired) == 0 {
return nil, "", nil
}
selected := acquired[0].Path
if selected == "" {
selected = label
}
cfg := &result.Config
cfg.resolution = &documentResolution{session: result, sources: sources}
return cfg, filepath.Clean(selected), nil
}
// DiscoverSession loads the first selected local candidate, or returns nil when
// none exists. A selected but invalid source is an error.
func DiscoverSession(candidates []string, opts SessionLoadOptions) (*SessionConfig, string, error) {
return loadSessionSource(configkit.SearchConfig("narratio", configkit.SearchPaths(candidates...)), "", opts, true)
}
func validateIdentity(v *configkit.Validation, field, expected, actual string) {
if expected != "" && actual == "" {
v.Error(configkit.Keys(field), fmt.Sprintf("%s is required when %q is selected", field, expected))
} else if expected != "" && actual != expected {
v.Error(configkit.Keys(field), fmt.Sprintf("%s mismatch: selected %q does not match %q", field, expected, actual))
}
}