fix(publish): export app profiles as runtime metadata

Author: wolfy-j

boot/deps/config/config.go

@@ -18,21 +18,31 @@ const (
 
 type ModuleConfig struct {
 	ExcludeMeta  map[string][]string `yaml:"exclude_meta,omitempty"`
-	Organization string              `yaml:"organization"`
-	ModuleName   string              `yaml:"module"`
-	Version      string              `yaml:"version"`
+	Metadata     map[string]any      `yaml:"metadata,omitempty"`
+	Runtime      RuntimeConfig       `yaml:"runtime,omitempty"`
+	Repository   string              `yaml:"repository,omitempty"`
 	Description  string              `yaml:"description,omitempty"`
 	License      string              `yaml:"license,omitempty"`
-	Repository   string              `yaml:"repository,omitempty"`
+	Version      string              `yaml:"version"`
 	Homepage     string              `yaml:"homepage,omitempty"`
+	ModuleName   string              `yaml:"module"`
+	Organization string              `yaml:"organization"`
 	Keywords     []string            `yaml:"keywords,omitempty"`
 	Authors      []string            `yaml:"authors,omitempty"`
 	Include      []string            `yaml:"include,omitempty"`
 	Exclude      []string            `yaml:"exclude,omitempty"`
-	Metadata     map[string]any      `yaml:"metadata,omitempty"`
 	Embed        []string            `yaml:"embed,omitempty"`
 }
 
+type RuntimeConfig struct {
+	Profiles RuntimeProfilesConfig `yaml:"profiles,omitempty"`
+}
+
+type RuntimeProfilesConfig struct {
+	Publish *bool  `yaml:"publish,omitempty"`
+	Source  string `yaml:"source,omitempty"`
+}
+
 func Load(dir string) (*ModuleConfig, error) {
 	path := filepath.Join(dir, DefaultConfigFile)
 	return LoadFrom(path)

boot/deps/config/config_test.go

@@ -294,6 +294,25 @@ metadata:
 	assert.Equal(t, "debug", loggerMap["level"])
 }
 
+func TestLoad_WithRuntimeProfilePublishConfig(t *testing.T) {
+	dir := t.TempDir()
+	content := `
+organization: myorg
+module: mymod
+runtime:
+  profiles:
+    publish: false
+    source: config/profiles.yaml
+`
+	require.NoError(t, os.WriteFile(filepath.Join(dir, DefaultConfigFile), []byte(content), 0644))
+
+	cfg, err := Load(dir)
+	require.NoError(t, err)
+	require.NotNil(t, cfg.Runtime.Profiles.Publish)
+	assert.False(t, *cfg.Runtime.Profiles.Publish)
+	assert.Equal(t, "config/profiles.yaml", cfg.Runtime.Profiles.Source)
+}
+
 // --- EntryExcludes ---
 
 func TestEntryExcludes(t *testing.T) {

cmd/wippy/cmd/publish.go

@@ -514,6 +514,9 @@ func packModule(ctx context.Context, app *appinit.Context, cfg *config.ModuleCon
 		}
 		metadata[trimmed] = value
 	}
+	if err := addPublishedRuntimeProfileMetadata(metadata, srcDir, cfg.Runtime.Profiles); err != nil {
+		return nil, NewPublishConfigError(err)
+	}
 
 	packWriter := wapp.NewWriter()
 

cmd/wippy/cmd/publish_profiles.go

@@ -0,0 +1,217 @@
+// SPDX-License-Identifier: MPL-2.0
+
+package cmd
+
+import (
+	"fmt"
+	"path/filepath"
+	"strings"
+
+	"github.com/wippyai/runtime/api/attrs"
+	"github.com/wippyai/runtime/api/boot"
+	"github.com/wippyai/runtime/boot/deps/config"
+	"github.com/wippyai/runtime/cmd/internal/bootconfig"
+)
+
+const (
+	publishRuntimeMetadataKey         = "runtime"
+	publishRuntimeProfilesMetadataKey = "profiles"
+	publishRuntimeVarsMetadataKey     = "vars"
+)
+
+func addPublishedRuntimeProfileMetadata(metadata attrs.Bag, configDir string, profileCfg config.RuntimeProfilesConfig) error {
+	if profileCfg.Publish != nil && !*profileCfg.Publish {
+		return nil
+	}
+
+	source := strings.TrimSpace(profileCfg.Source)
+	if source == "" {
+		source = defaultConfigFile
+	}
+	if !filepath.IsAbs(source) {
+		source = filepath.Join(configDir, source)
+	}
+
+	cfg, err := bootconfig.Load(source)
+	if err != nil {
+		return fmt.Errorf("load runtime profile source %s: %w", source, err)
+	}
+	if cfg == nil {
+		return nil
+	}
+
+	profiles, err := runtimeProfilesFromConfig(cfg)
+	if err != nil {
+		return err
+	}
+	if len(profiles) == 0 {
+		return nil
+	}
+
+	if hasRuntimeProfilesMetadata(metadata) {
+		return fmt.Errorf("runtime profiles are defined in both %s and wippy.yaml metadata; keep profile definitions in one layer", source)
+	}
+
+	runtime, err := runtimeMetadataMap(metadata)
+	if err != nil {
+		return err
+	}
+	runtime[publishRuntimeProfilesMetadataKey] = profiles
+
+	vars := runtimeSectionFromConfig(cfg, publishRuntimeVarsMetadataKey)
+	if len(vars) > 0 {
+		if err := mergeRuntimeVarsMetadata(metadata, runtime, vars, source); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func runtimeProfilesFromConfig(cfg boot.Config) (map[string]any, error) {
+	profiles := make(map[string]any)
+	if cfg == nil {
+		return profiles, nil
+	}
+
+	for _, key := range cfg.Keys() {
+		if !strings.HasPrefix(key, "profiles.") {
+			continue
+		}
+
+		rest := strings.TrimPrefix(key, "profiles.")
+		profileName, rest, ok := strings.Cut(rest, ".")
+		if !ok || profileName == "" || rest == "" {
+			return nil, fmt.Errorf("invalid runtime profile key %q", key)
+		}
+		section, subkey, ok := strings.Cut(rest, ".")
+		if !ok || section == "" || subkey == "" {
+			return nil, fmt.Errorf("invalid runtime profile key %q", key)
+		}
+
+		profileMap, ok := profiles[profileName].(map[string]any)
+		if !ok {
+			profileMap = make(map[string]any)
+			profiles[profileName] = profileMap
+		}
+
+		sectionMap, ok := profileMap[section].(map[string]any)
+		if !ok {
+			sectionMap = make(map[string]any)
+			profileMap[section] = sectionMap
+		}
+
+		value, _ := cfg.Get(key)
+		sectionMap[subkey] = value
+	}
+
+	return profiles, nil
+}
+
+func runtimeSectionFromConfig(cfg boot.Config, section string) map[string]any {
+	values := make(map[string]any)
+	if cfg == nil {
+		return values
+	}
+
+	prefix := section + "."
+	for _, key := range cfg.Keys() {
+		if !strings.HasPrefix(key, prefix) {
+			continue
+		}
+		value, _ := cfg.Get(key)
+		values[strings.TrimPrefix(key, prefix)] = value
+	}
+	return values
+}
+
+func runtimeMetadataMap(metadata attrs.Bag) (map[string]any, error) {
+	if metadata == nil {
+		return nil, fmt.Errorf("metadata bag is nil")
+	}
+
+	raw, exists := metadata[publishRuntimeMetadataKey]
+	if !exists {
+		runtime := make(map[string]any)
+		metadata[publishRuntimeMetadataKey] = runtime
+		return runtime, nil
+	}
+
+	switch typed := raw.(type) {
+	case map[string]any:
+		return typed, nil
+	case attrs.Bag:
+		runtime := map[string]any(typed)
+		metadata[publishRuntimeMetadataKey] = runtime
+		return runtime, nil
+	default:
+		return nil, fmt.Errorf("wippy.yaml metadata.runtime must be a map when publishing runtime profiles")
+	}
+}
+
+func hasRuntimeProfilesMetadata(metadata attrs.Bag) bool {
+	return hasNestedRuntimeMetadata(metadata, publishRuntimeProfilesMetadataKey)
+}
+
+func mergeRuntimeVarsMetadata(metadata attrs.Bag, runtime map[string]any, vars map[string]any, source string) error {
+	existing := make(map[string]any)
+	if raw, exists := runtime[publishRuntimeVarsMetadataKey]; exists {
+		switch typed := raw.(type) {
+		case map[string]any:
+			existing = typed
+		case attrs.Bag:
+			existing = map[string]any(typed)
+		default:
+			return fmt.Errorf("wippy.yaml metadata.runtime.vars must be a map when publishing runtime profiles")
+		}
+	}
+
+	dottedPrefix := publishRuntimeMetadataKey + "." + publishRuntimeVarsMetadataKey + "."
+	dottedVars := make(map[string]struct{})
+	for key := range metadata {
+		if strings.HasPrefix(key, dottedPrefix) {
+			dottedVars[strings.TrimPrefix(key, dottedPrefix)] = struct{}{}
+		}
+	}
+
+	for key, value := range vars {
+		if _, exists := existing[key]; exists {
+			return fmt.Errorf("runtime var %q is defined in both %s and wippy.yaml metadata", key, source)
+		}
+		if _, exists := dottedVars[key]; exists {
+			return fmt.Errorf("runtime var %q is defined in both %s and wippy.yaml metadata", key, source)
+		}
+		existing[key] = value
+	}
+
+	runtime[publishRuntimeVarsMetadataKey] = existing
+	return nil
+}
+
+func hasNestedRuntimeMetadata(metadata attrs.Bag, nestedKey string) bool {
+	if metadata == nil {
+		return false
+	}
+
+	dotted := publishRuntimeMetadataKey + "." + nestedKey
+	for key := range metadata {
+		if key == dotted || strings.HasPrefix(key, dotted+".") {
+			return true
+		}
+	}
+
+	raw, exists := metadata[publishRuntimeMetadataKey]
+	if !exists {
+		return false
+	}
+	switch typed := raw.(type) {
+	case map[string]any:
+		_, exists = typed[nestedKey]
+		return exists
+	case attrs.Bag:
+		_, exists = typed[nestedKey]
+		return exists
+	default:
+		return false
+	}
+}