fix(chart): refactor v3 chart handling and revert Settings export scope

- Rename imports: helmchartiface→helmchart, helmchart→v2chart
- Inline chartAccessor.Name() (remove chartName variable)
- Deduplicate CRD loop with crdRef struct
- Add convertV3ToV2() for v3→v2 chart conversion
- Enable TS rendering for v3 charts via v3→v2 conversion
- RenderChartResult.Chart always returns *v2chart.Chart
- Revert Settings→settings in 30+ cmd files, add exported alias instead

Signed-off-by: Ilya Lesikov <ilya@lesikov.com>

Author: ilya-lesikov

pkg/chart/chart_render.go

@@ -21,11 +21,11 @@ import (
 	v3chart "github.com/werf/nelm/pkg/helm/intern/chart/v3"
 	chartv3util "github.com/werf/nelm/pkg/helm/intern/chart/v3/util"
 	"github.com/werf/nelm/pkg/helm/pkg/action"
-	helmchartiface "github.com/werf/nelm/pkg/helm/pkg/chart"
+	helmchart "github.com/werf/nelm/pkg/helm/pkg/chart"
 	chartcommon "github.com/werf/nelm/pkg/helm/pkg/chart/common"
 	chartcommonutil "github.com/werf/nelm/pkg/helm/pkg/chart/common/util"
 	"github.com/werf/nelm/pkg/helm/pkg/chart/loader"
-	helmchart "github.com/werf/nelm/pkg/helm/pkg/chart/v2"
+	v2chart "github.com/werf/nelm/pkg/helm/pkg/chart/v2"
 	chartv2util "github.com/werf/nelm/pkg/helm/pkg/chart/v2/util"
 	"github.com/werf/nelm/pkg/helm/pkg/cli/values"
 	helmdownloader "github.com/werf/nelm/pkg/helm/pkg/downloader"
@@ -60,7 +60,7 @@ type RenderChartOptions struct {
 }
 
 type RenderChartResult struct {
-	Chart         *helmchart.Chart
+	Chart         *v2chart.Chart
 	Notes         string
 	ReleaseConfig map[string]interface{}
 	ResourceSpecs []*spec.ResourceSpec
@@ -128,20 +128,20 @@ func RenderChart(ctx context.Context, chartPath, releaseName, releaseNamespace s
 	}
 
 	var (
-		chartV2 *helmchart.Chart
+		chartV2 *v2chart.Chart
 		chartV3 *v3chart.Chart
 	)
 
 	switch c := loadedChart.(type) {
-	case *helmchart.Chart:
+	case *v2chart.Chart:
 		chartV2 = c
 	case *v3chart.Chart:
 		chartV3 = c
 	default:
 		return nil, fmt.Errorf("loaded chart has unexpected type %T", loadedChart)
 	}
 
-	chartAccessor, err := helmchartiface.NewAccessor(loadedChart)
+	chartAccessor, err := helmchart.NewAccessor(loadedChart)
 	if err != nil {
 		return nil, fmt.Errorf("create chart accessor: %w", err)
 	}
@@ -165,8 +165,6 @@ func RenderChart(ctx context.Context, chartPath, releaseName, releaseNamespace s
 	log.Default.TraceStruct(ctx, loadedChart, "Chart after processing dependencies:")
 	log.Default.TraceStruct(ctx, overrideValues, "Merged override values after processing dependencies:")
 
-	chartName := chartAccessor.Name()
-
 	var chartKubeVersion string
 	if chartV2 != nil {
 		chartKubeVersion = chartV2.Metadata.KubeVersion
@@ -180,7 +178,7 @@ func RenderChart(ctx context.Context, chartPath, releaseName, releaseNamespace s
 		Remote:           opts.Remote,
 	})
 	if err != nil {
-		return nil, fmt.Errorf("build capabilities for chart %q: %w", chartName, err)
+		return nil, fmt.Errorf("build capabilities for chart %q: %w", chartAccessor.Name(), err)
 	}
 
 	log.Default.TraceStruct(ctx, caps, "Capabilities:")
@@ -224,7 +222,7 @@ func RenderChart(ctx context.Context, chartPath, releaseName, releaseNamespace s
 		IsUpgrade: isUpgrade,
 	}, caps)
 	if err != nil {
-		return nil, fmt.Errorf("build rendered values for chart %q: %w", chartName, err)
+		return nil, fmt.Errorf("build rendered values for chart %q: %w", chartAccessor.Name(), err)
 	}
 
 	renderedValues["Runtime"] = runtime
@@ -251,52 +249,58 @@ func RenderChart(ctx context.Context, chartPath, releaseName, releaseNamespace s
 	var resources []*spec.ResourceSpec
 
 	if !opts.NoStandaloneCRDs {
+		type crdRef struct {
+			data     []byte
+			filename string
+		}
+
+		var crds []crdRef
+
 		if chartV2 != nil {
 			for _, crd := range chartV2.CRDObjects() {
-				for _, manifest := range util.SplitManifests(string(crd.File.Data)) {
-					if res, err := spec.NewResourceSpecFromManifest(manifest, releaseNamespace, spec.ResourceSpecOptions{
-						StoreAs:  common.StoreAsNone,
-						FilePath: crd.Filename,
-					}); err != nil {
-						return nil, fmt.Errorf("construct standalone CRD for chart at %q: %w", chartPath, err)
-					} else {
-						resources = append(resources, res)
-					}
-				}
+				crds = append(crds, crdRef{data: crd.File.Data, filename: crd.Filename})
 			}
 		} else {
 			for _, crd := range chartV3.CRDObjects() {
-				for _, manifest := range util.SplitManifests(string(crd.File.Data)) {
-					if res, err := spec.NewResourceSpecFromManifest(manifest, releaseNamespace, spec.ResourceSpecOptions{
-						StoreAs:  common.StoreAsNone,
-						FilePath: crd.Filename,
-					}); err != nil {
-						return nil, fmt.Errorf("construct standalone CRD for chart at %q: %w", chartPath, err)
-					} else {
-						resources = append(resources, res)
-					}
+				crds = append(crds, crdRef{data: crd.File.Data, filename: crd.Filename})
+			}
+		}
+
+		for _, crd := range crds {
+			for _, manifest := range util.SplitManifests(string(crd.data)) {
+				if res, err := spec.NewResourceSpecFromManifest(manifest, releaseNamespace, spec.ResourceSpecOptions{
+					StoreAs:  common.StoreAsNone,
+					FilePath: crd.filename,
+				}); err != nil {
+					return nil, fmt.Errorf("construct standalone CRD for chart at %q: %w", chartPath, err)
+				} else {
+					resources = append(resources, res)
 				}
 			}
 		}
 	}
 
 	renderedTemplates, err := engine.Render(ctx, loadedChart, renderedValues)
 	if err != nil {
-		return nil, fmt.Errorf("render resources for chart %q: %w", chartName, err)
+		return nil, fmt.Errorf("render resources for chart %q: %w", chartAccessor.Name(), err)
 	}
 
 	if featgate.FeatGateTypescript.Enabled() {
+		var tsChart *v2chart.Chart
 		if chartV2 != nil {
-			jsRenderedTemplates, err := renderJSTemplates(ctx, chartPath, chartV2, renderedValues)
-			if err != nil {
-				return nil, fmt.Errorf("render ts chart templates for chart %q: %w", chartName, err)
-			}
-
-			if len(jsRenderedTemplates) > 0 {
-				maps.Copy(renderedTemplates, jsRenderedTemplates)
-			}
+			tsChart = chartV2
 		} else {
-			log.Default.Debug(ctx, "Skipping TypeScript rendering for v3 chart")
+			// TODO(major): refactor to allow native v3 chart handling in TypeScript rendering
+			tsChart = convertV3ToV2(chartV3)
+		}
+
+		jsRenderedTemplates, err := renderJSTemplates(ctx, chartPath, tsChart, renderedValues)
+		if err != nil {
+			return nil, fmt.Errorf("render ts chart templates for chart %q: %w", chartAccessor.Name(), err)
+		}
+
+		if len(jsRenderedTemplates) > 0 {
+			maps.Copy(renderedTemplates, jsRenderedTemplates)
 		}
 	}
 
@@ -308,23 +312,108 @@ func RenderChart(ctx context.Context, chartPath, releaseName, releaseNamespace s
 		resources = append(resources, r...)
 	}
 
-	notes := buildChartNotes(chartName, renderedTemplates, opts.SubchartNotes)
+	notes := buildChartNotes(chartAccessor.Name(), renderedTemplates, opts.SubchartNotes)
 
 	log.Default.TraceStruct(ctx, notes, "Rendered notes:")
 
 	sort.SliceStable(resources, func(i, j int) bool {
 		return spec.ResourceSpecSortHandler(resources[i], resources[j])
 	})
 
+	var resultChart *v2chart.Chart
+	if chartV2 != nil {
+		resultChart = chartV2
+	} else {
+		// TODO(major): refactor to allow native v3 chart handling in nelm
+		resultChart = convertV3ToV2(chartV3)
+	}
+
 	return &RenderChartResult{
-		Chart:         chartV2,
+		Chart:         resultChart,
 		Notes:         notes,
 		ReleaseConfig: overrideValues,
 		ResourceSpecs: resources,
 		Values:        renderedValues.AsMap(),
 	}, nil
 }
 
+func convertV3ToV2(src *v3chart.Chart) *v2chart.Chart {
+	dst := &v2chart.Chart{
+		Raw:                src.Raw,
+		Templates:          src.Templates,
+		Values:             src.Values,
+		Schema:             src.Schema,
+		SchemaModTime:      src.SchemaModTime,
+		Files:              src.Files,
+		ModTime:            src.ModTime,
+		RuntimeFiles:       src.RuntimeFiles,
+		RuntimeDepsFiles:   src.RuntimeDepsFiles,
+		ExtraValues:        src.ExtraValues,
+		SecretsRuntimeData: src.SecretsRuntimeData,
+	}
+
+	if src.Metadata != nil {
+		dst.Metadata = convertV3MetadataToV2(src.Metadata)
+	}
+
+	if src.Lock != nil {
+		dst.Lock = convertV3LockToV2(src.Lock)
+	}
+
+	for _, dep := range src.Dependencies() {
+		dst.AddDependency(convertV3ToV2(dep))
+	}
+
+	return dst
+}
+
+func convertV3LockToV2(src *v3chart.Lock) *v2chart.Lock {
+	dst := &v2chart.Lock{
+		Generated: src.Generated,
+		Digest:    src.Digest,
+	}
+
+	for _, dependency := range src.Dependencies {
+		dst.Dependencies = append(dst.Dependencies, convertV3DependencyToV2(dependency))
+	}
+
+	return dst
+}
+
+func convertV3MetadataToV2(src *v3chart.Metadata) *v2chart.Metadata {
+	dst := &v2chart.Metadata{
+		Name:        src.Name,
+		Home:        src.Home,
+		Sources:     src.Sources,
+		Version:     src.Version,
+		Description: src.Description,
+		Keywords:    src.Keywords,
+		Icon:        src.Icon,
+		APIVersion:  src.APIVersion,
+		Condition:   src.Condition,
+		Tags:        src.Tags,
+		AppVersion:  src.AppVersion,
+		Deprecated:  src.Deprecated,
+		Annotations: src.Annotations,
+		KubeVersion: src.KubeVersion,
+		Type:        src.Type,
+	}
+
+	for _, maintainer := range src.Maintainers {
+		dst.Maintainers = append(dst.Maintainers, &v2chart.Maintainer{
+			Name:  maintainer.Name,
+			Email: maintainer.Email,
+			URL:   maintainer.URL,
+		})
+	}
+
+	for _, dependency := range src.Dependencies {
+		dst.Dependencies = append(dst.Dependencies, convertV3DependencyToV2(dependency))
+	}
+
+	return dst
+}
+
 func buildChartCapabilities(ctx context.Context, clientFactory kube.ClientFactorier, opts buildChartCapabilitiesOptions) (*chartcommon.Capabilities, error) {
 	capabilities := &chartcommon.Capabilities{
 		HelmVersion: chartcommon.DefaultCapabilities.HelmVersion,
@@ -417,6 +506,19 @@ func buildContextFromJSONSets(jsonSets []string) (map[string]interface{}, error)
 	return context, nil
 }
 
+func convertV3DependencyToV2(src *v3chart.Dependency) *v2chart.Dependency {
+	return &v2chart.Dependency{
+		Name:         src.Name,
+		Version:      src.Version,
+		Repository:   src.Repository,
+		Condition:    src.Condition,
+		Tags:         src.Tags,
+		Enabled:      src.Enabled,
+		ImportValues: src.ImportValues,
+		Alias:        src.Alias,
+	}
+}
+
 func envOr(envVar, defaultVal string) string {
 	if v := os.Getenv(envVar); v != "" {
 		return v
@@ -442,7 +544,7 @@ func parseVerificationStrategy(s string) helmdownloader.VerificationStrategy {
 	}
 }
 
-func renderJSTemplates(ctx context.Context, chartPath string, chart *helmchart.Chart, renderedValues chartcommon.Values) (map[string]string, error) {
+func renderJSTemplates(ctx context.Context, chartPath string, chart *v2chart.Chart, renderedValues chartcommon.Values) (map[string]string, error) {
 	log.Default.Debug(ctx, "Rendering TypeScript resources for chart %q and its dependencies", chart.Name())
 
 	result, err := ts.RenderChart(ctx, chart, renderedValues)
@@ -484,7 +586,7 @@ func renderedTemplatesToResourceSpecs(renderedTemplates map[string]string, relea
 	return resources, nil
 }
 
-func validateChart(ctx context.Context, chrt helmchartiface.Charter, acc helmchartiface.Accessor) error {
+func validateChart(ctx context.Context, chrt helmchart.Charter, acc helmchart.Accessor) error {
 	if chrt == nil {
 		return fmt.Errorf("load chart: missing chart")
 	}

pkg/helm/pkg/cmd/dependency_build.go

@@ -66,12 +66,12 @@ func newDependencyBuildCmd(out io.Writer) *cobra.Command {
 				ChartPath:        chartpath,
 				Keyring:          client.Keyring,
 				SkipUpdate:       client.SkipRefresh,
-				Getters:          getter.All(Settings),
+				Getters:          getter.All(settings),
 				RegistryClient:   registryClient,
-				RepositoryConfig: Settings.RepositoryConfig,
-				RepositoryCache:  Settings.RepositoryCache,
-				ContentCache:     Settings.ContentCache,
-				Debug:            Settings.Debug,
+				RepositoryConfig: settings.RepositoryConfig,
+				RepositoryCache:  settings.RepositoryCache,
+				ContentCache:     settings.ContentCache,
+				Debug:            settings.Debug,
 			}
 			if client.Verify {
 				man.Verify = downloader.VerifyIfPossible

pkg/helm/pkg/cmd/dependency_update.go

@@ -70,12 +70,12 @@ func newDependencyUpdateCmd(_ *action.Configuration, out io.Writer) *cobra.Comma
 				ChartPath:        chartpath,
 				Keyring:          client.Keyring,
 				SkipUpdate:       client.SkipRefresh,
-				Getters:          getter.All(Settings),
+				Getters:          getter.All(settings),
 				RegistryClient:   registryClient,
-				RepositoryConfig: Settings.RepositoryConfig,
-				RepositoryCache:  Settings.RepositoryCache,
-				ContentCache:     Settings.ContentCache,
-				Debug:            Settings.Debug,
+				RepositoryConfig: settings.RepositoryConfig,
+				RepositoryCache:  settings.RepositoryCache,
+				ContentCache:     settings.ContentCache,
+				Debug:            settings.Debug,
 			}
 			if client.Verify {
 				man.Verify = downloader.VerifyAlways

pkg/helm/pkg/cmd/env.go

@@ -45,7 +45,7 @@ func newEnvCmd(out io.Writer) *cobra.Command {
 			return noMoreArgsComp()
 		},
 		Run: func(_ *cobra.Command, args []string) {
-			envVars := Settings.EnvVars()
+			envVars := settings.EnvVars()
 
 			if len(args) == 0 {
 				// Sort the variables by alphabetical order.
@@ -64,7 +64,7 @@ func newEnvCmd(out io.Writer) *cobra.Command {
 }
 
 func getSortedEnvVarKeys() []string {
-	envVars := Settings.EnvVars()
+	envVars := settings.EnvVars()
 
 	var keys []string
 	for k := range envVars {

pkg/helm/pkg/cmd/flags.go

@@ -259,7 +259,7 @@ func compVersionFlag(chartRef string, _ string) ([]string, cobra.ShellCompDirect
 	repoName := chartInfo[0]
 	chartName := chartInfo[1]
 
-	path := filepath.Join(Settings.RepositoryCache, helmpath.CacheIndexFile(repoName))
+	path := filepath.Join(settings.RepositoryCache, helmpath.CacheIndexFile(repoName))
 
 	var versions []string
 	if indexFile, err := repo.LoadIndexFile(path); err == nil {

pkg/helm/pkg/cmd/flags_test.go

@@ -102,11 +102,11 @@ func outputFlagCompletionTest(t *testing.T, cmdName string) {
 func TestPostRendererFlagSetOnce(t *testing.T) {
 	cfg := action.Configuration{}
 	client := action.NewInstall(&cfg)
-	Settings.PluginsDirectory = "testdata/helmhome/helm/plugins"
+	settings.PluginsDirectory = "testdata/helmhome/helm/plugins"
 	str := postRendererString{
 		options: &postRendererOptions{
 			renderer: &client.PostRenderer,
-			settings: Settings,
+			settings: settings,
 		},
 	}
 	// Set the plugin name once

pkg/helm/pkg/cmd/get_all.go

@@ -63,7 +63,7 @@ func newGetAllCmd(cfg *action.Configuration, out io.Writer) *cobra.Command {
 				debug:        true,
 				showMetadata: true,
 				hideNotes:    false,
-				noColor:      Settings.ShouldDisableColor(),
+				noColor:      settings.ShouldDisableColor(),
 			})
 		},
 	}