provisioning-core/nulib/domain/config/export.nu

329 lines
10 KiB
Text
Raw Normal View History

# Configuration Export Script
# Converts Nickel config.ncl to service-specific TOML files
# Usage: export-all-configs [workspace_path]
# export-platform-config <service> [workspace_path]
use tools/nickel/process.nu [ncl-eval-soft]
use platform/user/config.nu [get-user-config-path]
# Logging functions - not using std/log due to compatibility
# Export all configuration sections from Nickel config
export def export-all-configs [workspace_path?: string] {
let workspace = if ($workspace_path | is-empty) {
get-active-workspace
} else {
{ path: $workspace_path }
}
let config_file = $"($workspace.path)/config/config.ncl"
# Validate that config file exists
if not ($config_file | path exists) {
return
}
# Create generated directory
(do { mkdir ($"($workspace.path)/config/generated") } | ignore)
# Skip verbose output during initialization (controlled by env var)
let quiet_mode = ($env.PROVISIONING_QUIET_EXPORT? | default "false") == "true"
if (not $quiet_mode) {
print $"📥 Exporting configuration from: ($config_file)"
}
# Step 1: Typecheck the Nickel file
let typecheck_result = (do { nickel typecheck $config_file } | complete)
if $typecheck_result.exit_code != 0 {
print "❌ Nickel configuration validation failed"
print $typecheck_result.stderr
return
}
# Step 2: Export to JSON
let json_output = (ncl-eval-soft $config_file [] null)
if ($json_output | is-empty) {
print "❌ Failed to export Nickel to JSON"
return
}
# Step 3: Export workspace section
if ($json_output | get -o workspace | is-not-empty) {
print "📝 Exporting workspace configuration"
$json_output.workspace | to toml | save -f $"($workspace.path)/config/generated/workspace.toml"
}
# Step 4: Export provider sections
if ($json_output | get -o providers | is-not-empty) {
(do { mkdir $"($workspace.path)/config/generated/providers" } | ignore)
($json_output.providers | to json | from json) | transpose name value | each {|provider|
if ($provider.value | get -o enabled | default false) {
print $"📝 Exporting provider: ($provider.name)"
$provider.value | to toml | save -f $"($workspace.path)/config/generated/providers/($provider.name).toml"
}
}
}
# Step 5: Export platform service sections
if ($json_output | get -o platform | is-not-empty) {
(do { mkdir $"($workspace.path)/config/generated/platform" } | ignore)
($json_output.platform | to json | from json) | transpose name value | each {|service|
if ($service.value | type) == 'record' and ($service.value | get -o enabled | is-not-empty) {
if ($service.value | get enabled) {
print $"📝 Exporting platform service: ($service.name)"
$service.value | to toml | save -f $"($workspace.path)/config/generated/platform/($service.name).toml"
}
}
}
}
# Skip verbose output during initialization
let quiet_mode = ($env.PROVISIONING_QUIET_EXPORT? | default "false") == "true"
if (not $quiet_mode) {
print "✅ Configuration export complete"
}
}
# Export a single platform service configuration
export def export-platform-config [service: string, workspace_path?: string] {
let workspace = if ($workspace_path | is-empty) {
get-active-workspace
} else {
{ path: $workspace_path }
}
let config_file = $"($workspace.path)/config/config.ncl"
# Validate that config file exists
if not ($config_file | path exists) {
print $"❌ Configuration file not found: ($config_file)"
return
}
# Create generated directory
(do { mkdir ($"($workspace.path)/config/generated/platform") } | ignore)
print $"📝 Exporting platform service: ($service)"
# Step 1: Typecheck the Nickel file
let typecheck_result = (do { nickel typecheck $config_file } | complete)
if $typecheck_result.exit_code != 0 {
print "❌ Nickel configuration validation failed"
print $typecheck_result.stderr
return
}
# Step 2: Export to JSON and extract platform section
let json_output = (ncl-eval-soft $config_file [] null)
if ($json_output | is-empty) {
print "❌ Failed to export Nickel to JSON"
return
}
# Step 3: Export specific service
if ($json_output | get -o platform | is-not-empty) and ($json_output.platform | get -o $service | is-not-empty) {
let service_config = $json_output.platform | get $service
if ($service_config | type) == 'record' {
$service_config | to toml | save -f $"($workspace.path)/config/generated/platform/($service).toml"
print $"✅ Successfully exported: ($service).toml"
}
} else {
print $"❌ Service not found in configuration: ($service)"
}
}
# Export all provider configurations
export def export-all-providers [workspace_path?: string] {
let workspace = if ($workspace_path | is-empty) {
get-active-workspace
} else {
{ path: $workspace_path }
}
let config_file = $"($workspace.path)/config/config.ncl"
# Validate that config file exists
if not ($config_file | path exists) {
print $"❌ Configuration file not found: ($config_file)"
return
}
# Create generated directory
(do { mkdir ($"($workspace.path)/config/generated/providers") } | ignore)
print "📥 Exporting all provider configurations"
# Step 1: Typecheck the Nickel file
let typecheck_result = (do { nickel typecheck $config_file } | complete)
if $typecheck_result.exit_code != 0 {
print "❌ Nickel configuration validation failed"
print $typecheck_result.stderr
return
}
# Step 2: Export to JSON
let json_output = (ncl-eval-soft $config_file [] null)
if ($json_output | is-empty) {
print "❌ Failed to export Nickel to JSON"
return
}
# Step 3: Export provider sections
if ($json_output | get -o providers | is-not-empty) {
($json_output.providers | to json | from json) | transpose name value | each {|provider|
# Exporting provider: ($provider.name)
$provider.value | to toml | save -f $"($workspace.path)/config/generated/providers/($provider.name).toml"
}
print "✅ Provider export complete"
} else {
print "⚠️ No providers found in configuration"
}
}
# Validate Nickel configuration without exporting
export def validate-config [workspace_path?: string] {
let workspace = if ($workspace_path | is-empty) {
get-active-workspace
} else {
{ path: $workspace_path }
}
let config_file = $"($workspace.path)/config/config.ncl"
# Validate that config file exists
if not ($config_file | path exists) {
print $"❌ Configuration file not found: ($config_file)"
return { valid: false, error: "Configuration file not found" }
}
print $"🔍 Validating configuration: ($config_file)"
# Run typecheck
let check_result = (do { nickel typecheck $config_file } | complete)
if $check_result.exit_code == 0 {
{ valid: true, error: null }
} else {
print $"❌ Configuration validation failed"
print $check_result.stderr
{ valid: false, error: $check_result.stderr }
}
}
# Show configuration structure without exporting
export def show-config [workspace_path?: string] {
let workspace = if ($workspace_path | is-empty) {
get-active-workspace
} else {
{ path: $workspace_path }
}
let config_file = $"($workspace.path)/config/config.ncl"
# Validate that config file exists
if not ($config_file | path exists) {
print $"❌ Configuration file not found: ($config_file)"
return
}
print "📋 Loading configuration structure"
let json_output = (ncl-eval-soft $config_file [] null)
if ($json_output | is-not-empty) {
print ($json_output | to json --indent 2)
} else {
print $"❌ Failed to load configuration"
}
}
# List all configured providers
export def list-providers [workspace_path?: string] {
let workspace = if ($workspace_path | is-empty) {
get-active-workspace
} else {
{ path: $workspace_path }
}
let config_file = $"($workspace.path)/config/config.ncl"
# Validate that config file exists
if not ($config_file | path exists) {
print $"❌ Configuration file not found: ($config_file)"
return
}
let config = (ncl-eval-soft $config_file [] null)
if ($config | is-empty) {
print $"❌ Failed to list providers"
return
}
if ($config | get -o providers | is-not-empty) {
print "☁️ Configured Providers:"
($config.providers | to json | from json) | transpose name value | each {|provider|
let status = if ($provider.value | get -o enabled | default false) { "✓ enabled" } else { "✗ disabled" }
print $" ($provider.name): ($status)"
}
} else {
print "⚠️ No providers found in configuration"
}
}
# List all configured platform services
export def list-platform-services [workspace_path?: string] {
let workspace = if ($workspace_path | is-empty) {
get-active-workspace
} else {
{ path: $workspace_path }
}
let config_file = $"($workspace.path)/config/config.ncl"
# Validate that config file exists
if not ($config_file | path exists) {
print $"❌ Configuration file not found: ($config_file)"
return
}
let config = (ncl-eval-soft $config_file [] null)
if ($config | is-empty) {
print $"❌ Failed to list platform services"
return
}
if ($config | get -o platform | is-not-empty) {
print "⚙️ Configured Platform Services:"
($config.platform | to json | from json) | transpose name value | each {|service|
if ($service.value | type) == 'record' and ($service.value | get -o enabled | is-not-empty) {
let status = if ($service.value | get enabled) { "✓ enabled" } else { "✗ disabled" }
print $" ($service.name): ($status)"
}
}
} else {
print "⚠️ No platform services found in configuration"
}
}
# Helper function to get active workspace
def get-active-workspace [] {
let user_config_file = (get-user-config-path)
if ($user_config_file | path exists) {
let open_result = (do { open $user_config_file } | complete)
if $open_result.exit_code == 0 {
let user_config = ($open_result.stdout | from yaml)
if ($user_config | get -o active_workspace | is-not-empty) {
let ws_name = $user_config.active_workspace
let ws = $user_config.workspaces | where name == $ws_name | get -o 0
if ($ws | length) > 0 {
return { name: $ws.name, path: $ws.path }
}
}
}
}
# Fallback to current directory
{ name: "current", path: (pwd) }
}