codegen: remove CLI flags and provide error on their usage

.github/workflows/test.yml

@@ -71,19 +71,6 @@ jobs:
           mkdir -p cmp && cp -R ../grafana-app-sdk/codegen/testing/golden_generated/* cmp/
           mv cmp/manifest/*.txt cmp/crd/
           find ./cmp -iname '*.txt' -exec bash -c 'mv -- "$1" "${1%.txt}"' bash {} \;
-      - name: Generate code (backwards compatibility)
-        run: |
-          cd codegen-tests
-          # NOTE: These four are here for backwards compatibility testing using now deprecated cli flags
-          grafana-app-sdk generate --grouping=kind --gogenpath=pkg/gen1 --tsgenpath=ts/gen1 --gomodgenpath="pkg/generated" --defencoding=json --manifest=customManifest --crdmanifest
-          grafana-app-sdk generate --grouping=kind --gogenpath=pkg/gen1 --tsgenpath=ts/gen1 --gomodgenpath="pkg/generated" --defencoding=json --manifest=testManifest --crdmanifest
-          grafana-app-sdk generate --grouping=group --gogenpath=pkg/gen2 --tsgenpath=ts/gen2 --gomodgenpath="pkg/generated" --defencoding=yaml --manifest=customManifest --crdmanifest
-          grafana-app-sdk generate --grouping=group --gogenpath=pkg/gen2 --tsgenpath=ts/gen2 --gomodgenpath="pkg/generated" --defencoding=yaml --manifest=testManifest --crdmanifest
-          sed -i 's/codegen\-tests\/pkg\/gen2/codegen\-tests\/pkg\/generated/g' pkg/gen2/manifestdata/*.go
-          diff pkg/gen1/customkind cmp/go/groupbykind/customkind > diff.txt
-          sed -i '/^Common subdirectories/d' diff.txt
-          difflines=$(wc -l diff.txt | awk '{ print $1 }')
-          echo "GoGroupByKindDiff=${difflines}" >> $GITHUB_ENV
       - name: Generate code
         run: |
           cd codegen-tests
@@ -121,22 +108,22 @@ jobs:
             }
             diff = '';
 
-            core.startGroup('Go --grouping=kind Diff');
+            core.startGroup('Go kind-grouping Diff');
             await exec.exec('diff', ['codegen-tests/cmp/go/groupbykind/customkind', 'codegen-tests/pkg/gen1/customkind'], options);
             console.log(diff);
             core.endGroup();
             if(diff.replace(/^Common subdirectories.*$/gm, '').trim().length > 0) {
-              core.error('Generated go with --groupbykind=kind comparison to codegen/testing/golden_generated failed, see diff for details');
+              core.error('Generated go with kind grouping comparison to codegen/testing/golden_generated failed, see diff for details');
               anyFailed = true;
             }
             diff = '';
 
-            core.startGroup('Go --grouping=group Diff');
+            core.startGroup('Go group-grouping Diff');
             await exec.exec('diff', ['codegen-tests/cmp/go/groupbygroup', 'codegen-tests/pkg/gen2'], options);
             console.log(diff);
             core.endGroup();
             if(diff.replace(/^Common subdirectories.*$/gm, '').trim().length > 0) {
-              core.error('Generated go with --groupbykind=group comparison to codegen/testing/golden_generated failed, see diff for details');
+              core.error('Generated go with group grouping comparison to codegen/testing/golden_generated failed, see diff for details');
               anyFailed = true;
             }
             diff = '';

cmd/grafana-app-sdk/generate.go

@@ -13,7 +13,6 @@ import (
 	"github.com/grafana/grafana-app-sdk/codegen"
 	"github.com/grafana/grafana-app-sdk/codegen/config"
 	"github.com/grafana/grafana-app-sdk/codegen/cuekind"
-	"github.com/grafana/grafana-app-sdk/codegen/jennies"
 )
 
 const (
@@ -27,48 +26,6 @@ var generateCmd = &cobra.Command{
 
 //nolint:goconst
 func setupGenerateCmd() {
-	generateCmd.PersistentFlags().StringP("gogenpath", "g", "pkg/generated/",
-		"Path to directory where generated go code will reside")
-	_ = generateCmd.PersistentFlags().MarkDeprecated("gogenpath", fmt.Sprintf(deprecationMessage, "codegen.goGenPath"))
-
-	generateCmd.PersistentFlags().StringP("tsgenpath", "t", "plugin/src/generated/",
-		"Path to directory where generated TypeScript code will reside")
-	_ = generateCmd.PersistentFlags().MarkDeprecated("tsgenpath", fmt.Sprintf(deprecationMessage, "codegen.tsGenPath"))
-
-	generateCmd.Flags().String("defencoding", "json", `Encoding for Custom Resource Definition 
-files. Allowed values are 'json', 'yaml', and 'none'. Use 'none' to turn off CRD generation.`)
-	_ = generateCmd.Flags().MarkDeprecated("defencoding", fmt.Sprintf(deprecationMessage, "definitions.encoding"))
-
-	generateCmd.Flags().String("defpath", "definitions", `Path where Custom Resource 
-Definitions will be created. Only applicable if type=kubernetes`)
-	_ = generateCmd.Flags().MarkDeprecated("defpath", fmt.Sprintf(deprecationMessage, "definitions.path"))
-
-	generateCmd.Flags().String("grouping", config.KindGroupingKind, `Kind go package grouping.
-Allowed values are 'group' and 'kind'. Dictates the packaging of go kinds, where 'group' places all kinds with the same group in the same package, and 'kind' creates separate packages per kind (packaging will always end with the version)`)
-	_ = generateCmd.Flags().MarkDeprecated("grouping", fmt.Sprintf(deprecationMessage, "kinds.grouping"))
-
-	generateCmd.Flags().Bool("postprocess", false, "Whether to run post-processing on the generated files after they are written to disk. Post-processing includes code generation based on +k8s comments on types. Post-processing will fail if the dependencies required by the generated code are absent from go.mod.")
-	generateCmd.Flags().Lookup("postprocess").NoOptDefVal = "true"
-	_ = generateCmd.Flags().MarkDeprecated("postprocess", fmt.Sprintf(deprecationMessage, "codegen.enableK8sPostProcessing"))
-
-	generateCmd.Flags().Bool("noschemasinmanifest", false, "Whether to exclude kind schemas from the generated app manifest. This flag exists to allow for codegen with recursive types in CUE until github.com/grafana/grafana-app-sdk/issues/460 is resolved.")
-	generateCmd.Flags().Lookup("noschemasinmanifest").NoOptDefVal = "true"
-	_ = generateCmd.Flags().MarkDeprecated("noschemasinmanifest", fmt.Sprintf(deprecationMessage, "definitions.manifestSchemas"))
-
-	generateCmd.Flags().String("gomodule", "", `module name found in go.mod. If absent it will be inferred from ./go.mod`)
-	_ = generateCmd.Flags().MarkDeprecated("gomodule", fmt.Sprintf(deprecationMessage, "codegen.goModule"))
-
-	generateCmd.Flags().String("gomodgenpath", "", `This argument is used as a relative path for generated go code from the go module root. It only needs to be present if gogenpath is an absolute path, or is not a relative path from the go module root.`)
-	_ = generateCmd.Flags().MarkDeprecated("gomodgenpath", fmt.Sprintf(deprecationMessage, "codegen.goModGenPath"))
-
-	generateCmd.Flags().Bool("useoldmanifestkinds", false, "Whether to use the legacy manifest style of 'kinds' in the manifest, and 'versions' in each kind. This is a deprecated feature that will be removed in a future release.")
-	generateCmd.Flags().Lookup("useoldmanifestkinds").NoOptDefVal = "true"
-	_ = generateCmd.Flags().MarkDeprecated("useoldmanifestkinds", fmt.Sprintf(deprecationMessage, "kinds.perKindVersion"))
-
-	generateCmd.Flags().Bool("crdmanifest", false, "Whether the generated manifest JSON/YAML has CRD-compatible schemas or the default OpenAPI documents. Use this flag to keep legacy behavior (CRD schemas in the manifest)")
-	generateCmd.Flags().Lookup("crdmanifest").NoOptDefVal = "true"
-	_ = generateCmd.Flags().MarkDeprecated("crdmanifest", fmt.Sprintf(deprecationMessage, "definitions.manfiestVersion"))
-
 	// Don't show "usage" information when an error is returned form the command,
 	// because our errors are not command-usage-based
 	generateCmd.SilenceUsage = true
@@ -89,93 +46,6 @@ func generateCmdFunc(cmd *cobra.Command, _ []string) error {
 	if err != nil {
 		return err
 	}
-	manifestSelector, err := cmd.Flags().GetString(selectorFlag)
-	if err != nil {
-		return err
-	}
-
-	// command-specific flags
-	goGenPath, err := cmd.Flags().GetString("gogenpath")
-	if err != nil {
-		return err
-	}
-
-	tsGenPath, err := cmd.Flags().GetString("tsgenpath")
-	if err != nil {
-		return err
-	}
-
-	encType, err := cmd.Flags().GetString("defencoding")
-	if err != nil {
-		return err
-	}
-
-	defPath, err := cmd.Flags().GetString("defpath")
-	if err != nil {
-		return err
-	}
-
-	grouping, err := cmd.Flags().GetString("grouping")
-	if err != nil {
-		return err
-	}
-	postProcess, err := cmd.Flags().GetBool("postprocess")
-	if err != nil {
-		return err
-	}
-	noSchemasInManifest, err := cmd.Flags().GetBool("noschemasinmanifest")
-	if err != nil {
-		return err
-	}
-	genOperatorState, err := cmd.Flags().GetBool(genOperatorStateFlag)
-	if err != nil {
-		return err
-	}
-	goModule, err := cmd.Flags().GetString("gomodule")
-	if err != nil {
-		return err
-	}
-	goModGenPath, err := cmd.Flags().GetString("gomodgenpath")
-	if err != nil {
-		return err
-	}
-	useOldManifestKinds, err := cmd.Flags().GetBool("useoldmanifestkinds")
-	if err != nil {
-		return err
-	}
-	crdCompatibleManifest, err := cmd.Flags().GetBool("crdmanifest")
-	if err != nil {
-		return err
-	}
-
-	// HACK: Use flags for a base config for backwards-compatibility
-	baseConfig := &config.Config{
-		Codegen: &config.CodegenConfig{
-			GoModule:                       goModule,
-			GoModGenPath:                   goModGenPath,
-			GoGenPath:                      goGenPath,
-			TsGenPath:                      tsGenPath,
-			EnableK8sPostProcessing:        postProcess,
-			EnableOperatorStatusGeneration: genOperatorState,
-		},
-		Definitions: &config.DefinitionsConfig{
-			GenManifest:     encType != "none",
-			GenCRDs:         encType != "none",
-			ManifestSchemas: !noSchemasInManifest,
-			Encoding:        encType,
-			Path:            defPath,
-			ManifestVersion: jennies.VersionV1Alpha2,
-		},
-		Kinds: &config.KindsConfig{
-			Grouping:       grouping,
-			PerKindVersion: useOldManifestKinds,
-		},
-		ManifestSelectors: []string{manifestSelector},
-	}
-
-	if crdCompatibleManifest {
-		baseConfig.Definitions.ManifestVersion = jennies.VersionV1Alpha1
-	}
 
 	var genSrc any
 
@@ -191,7 +61,7 @@ func generateCmdFunc(cmd *cobra.Command, _ []string) error {
 	}
 
 	// Load config
-	cfg, err := config.Load(genSrc, configSelector, baseConfig)
+	cfg, err := config.Load(genSrc, configSelector)
 	if err != nil {
 		return err
 	}

cmd/grafana-app-sdk/main.go

@@ -1,7 +1,6 @@
 package main
 
 import (
-	"fmt"
 	"os"
 
 	"github.com/spf13/cobra"
@@ -22,25 +21,17 @@ var rootCmd = &cobra.Command{
 const (
 	sourceFlag           = "source"
 	formatFlag           = "format"
-	selectorFlag         = "manifest"
 	genOperatorStateFlag = "genoperatorstate"
 	configFlag           = "config"
 )
 
-// Deprecation message template
-const deprecationMessage = "this flag is deprecated and will be removed soon, please modify your manifest config and set %s instead"
-
 func main() {
+	rootCmd.SetFlagErrorFunc(errorOnDeprecatedFlags)
+
 	rootCmd.PersistentFlags().StringP(configFlag, "c", "config", "Path selector of the config object within the manifest")
 	rootCmd.PersistentFlags().StringP(sourceFlag, "s", "kinds", "Path to directory with your codegen source files (such as a CUE module)")
 	rootCmd.PersistentFlags().StringP(formatFlag, "f", FormatCUE, "Format in which kinds are written for this project (currently allowed values are 'cue')")
 
-	rootCmd.PersistentFlags().String(selectorFlag, "manifest", "Path selector to use for the manifest")
-	_ = rootCmd.PersistentFlags().MarkDeprecated(selectorFlag, fmt.Sprintf(deprecationMessage, "manifestSelectors"))
-
-	rootCmd.PersistentFlags().Bool(genOperatorStateFlag, true, "Generate operator state code")
-	_ = rootCmd.PersistentFlags().MarkDeprecated(genOperatorStateFlag, fmt.Sprintf(deprecationMessage, "codegen.enableOperatorStatusGeneration"))
-
 	setupVersionCmd()
 	setupGenerateCmd()
 	setupProjectCmd()

cmd/grafana-app-sdk/project.go

@@ -87,14 +87,6 @@ func setupProjectCmd() {
 	projectCmd.PersistentFlags().Bool("overwrite", false, "Overwrite existing files instead of prompting")
 	projectCmd.PersistentFlags().Lookup("overwrite").NoOptDefVal = "true"
 
-	projectAddComponentCmd.Flags().String("grouping", config.KindGroupingKind, `Kind go package grouping.
-Allowed values are 'group' and 'kind'. This should match the flag used in the 'generate' command`)
-	_ = projectAddComponentCmd.Flags().MarkDeprecated("grouping", fmt.Sprintf(deprecationMessage, "kinds.grouping"))
-
-	projectLocalGenerateCmd.Flags().Bool("useoldmanifestkinds", false, "Whether to use the legacy manifest style of 'kinds' in the manifest, and 'versions' in each kind. This is a deprecated feature that will be removed in a future release.")
-	projectLocalGenerateCmd.Flags().Lookup("useoldmanifestkinds").NoOptDefVal = "true"
-	_ = projectLocalGenerateCmd.Flags().MarkDeprecated("useoldmanifestkinds", fmt.Sprintf(deprecationMessage, "kinds.perKindVersion"))
-
 	projectCmd.AddCommand(projectInitCmd)
 	projectCmd.AddCommand(projectComponentCmd)
 	projectCmd.AddCommand(projectKindCmd)
@@ -523,12 +515,6 @@ func projectAddComponent(cmd *cobra.Command, args []string) error {
 		return err
 	}
 
-	// Selector (optional)
-	selector, err := cmd.Flags().GetString(selectorFlag)
-	if err != nil {
-		return err
-	}
-
 	// Name of the cue object containing the config (optional)
 	configName, err := cmd.Flags().GetString(configFlag)
 	if err != nil {
@@ -547,16 +533,6 @@ func projectAddComponent(cmd *cobra.Command, args []string) error {
 		return err
 	}
 
-	genOperatorState, err := cmd.Flags().GetBool(genOperatorStateFlag)
-	if err != nil {
-		return err
-	}
-
-	kindGrouping, err := cmd.Flags().GetString("grouping")
-	if err != nil {
-		return err
-	}
-
 	var genSrc any
 
 	switch format {
@@ -570,18 +546,7 @@ func projectAddComponent(cmd *cobra.Command, args []string) error {
 		return fmt.Errorf("unknown format '%s'", format)
 	}
 
-	// HACK: Load base config from CLI flags which will eventually be removed
-	baseConfig := &config.Config{
-		Kinds: &config.KindsConfig{
-			Grouping: kindGrouping,
-		},
-		Codegen: &config.CodegenConfig{
-			EnableOperatorStatusGeneration: genOperatorState,
-		},
-		ManifestSelectors: []string{selector},
-	}
-
-	cfg, err := config.Load(genSrc, configName, baseConfig)
+	cfg, err := config.Load(genSrc, configName)
 	if err != nil {
 		return err
 	}

cmd/grafana-app-sdk/project_local.go

@@ -186,22 +186,10 @@ func projectLocalEnvGenerate(cmd *cobra.Command, _ []string) error {
 	if err != nil {
 		return err
 	}
-	selector, err := cmd.Flags().GetString(selectorFlag)
-	if err != nil {
-		return err
-	}
 	configName, err := cmd.Flags().GetString(configFlag)
 	if err != nil {
 		return err
 	}
-	genOperatorState, err := cmd.Flags().GetBool(genOperatorStateFlag)
-	if err != nil {
-		return err
-	}
-	useOldManifestKinds, err := cmd.Flags().GetBool("useoldmanifestkinds")
-	if err != nil {
-		return err
-	}
 	localPath := filepath.Join(path, "local")
 	localGenPath := filepath.Join(localPath, "generated")
 	absPath, err := filepath.Abs(path)
@@ -240,18 +228,7 @@ func projectLocalEnvGenerate(cmd *cobra.Command, _ []string) error {
 		return err
 	}
 
-	// HACK: Load base config from CLI flags which will eventually be removed
-	baseConfig := &config.Config{
-		Kinds: &config.KindsConfig{
-			PerKindVersion: useOldManifestKinds,
-		},
-		Codegen: &config.CodegenConfig{
-			EnableOperatorStatusGeneration: genOperatorState,
-		},
-		ManifestSelectors: []string{selector},
-	}
-
-	err = updateLocalConfigFromManifest(envCfg, baseConfig, format, sourcePath, configName)
+	err = updateLocalConfigFromManifest(envCfg, format, sourcePath, configName)
 	if err != nil {
 		return err
 	}
@@ -264,7 +241,7 @@ func projectLocalEnvGenerate(cmd *cobra.Command, _ []string) error {
 			if err != nil {
 				return nil, err
 			}
-			cfg, err := config.Load(cue, configName, baseConfig)
+			cfg, err := config.Load(cue, configName)
 			if err != nil {
 				return nil, err
 			}
@@ -888,7 +865,7 @@ func generateCerts(dnsName string) (*certBundle, error) {
 	}, nil
 }
 
-func updateLocalConfigFromManifest(envCfg *localEnvConfig, baseConfig *config.Config, format, cuePath, configName string) error {
+func updateLocalConfigFromManifest(envCfg *localEnvConfig, format, cuePath, configName string) error {
 	type manifest struct {
 		Kind string           `json:"kind"`
 		Spec app.ManifestData `json:"spec"`
@@ -898,7 +875,7 @@ func updateLocalConfigFromManifest(envCfg *localEnvConfig, baseConfig *config.Co
 		if err != nil {
 			return err
 		}
-		cfg, err := config.Load(cue, configName, baseConfig)
+		cfg, err := config.Load(cue, configName)
 		if err != nil {
 			return err
 		}