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)) } }