refactor extensions handling

Author: FilipRudy

internal/cmdcommon/extension.go

@@ -53,34 +53,23 @@ func (kec *KymaExtensionsConfig) GetRawExtensions() ExtensionList {
 func (kec *KymaExtensionsConfig) BuildExtensions(availableTemplateCommands *TemplateCommandsList, availableCoreCommands CoreCommandsMap, cmd *cobra.Command) []*cobra.Command {
 	var cmds []*cobra.Command
 
-	if getBoolFlagValue("--skip-extensions") {
-		// skip extensions fetching
-		return nil
-	}
-
-	var cms, cmsError = getExtensionConfigMaps(kec.kymaConfig.Ctx, kec.kymaConfig.KubeClientConfig)
-	if cmsError != nil {
-		kec.parseErrors = cmsError
-		return nil
-	}
-
 	existingCommands := make(map[string]bool)
 	for _, baseCmd := range cmd.Commands() {
 		existingCommands[baseCmd.Name()] = true
 	}
 
-	for _, cm := range cms.Items {
-		extension, _ := parseResourceExtension(cm.Data)
+	for _, extensionItem := range kec.extensions {
+		extension := extensionItem.Extension
 		if existingCommands[extension.RootCommand.Name] {
 			kec.parseErrors = errors.Join(
 				kec.parseErrors,
 				fmt.Errorf("failed to validate configmap '%s/%s': base command with name='%s' already exists",
-					cm.GetNamespace(), cm.GetName(), extension.RootCommand.Name),
+					extensionItem.ConfigMapNamespace, extensionItem.ConfigMapName, extension.RootCommand.Name),
 			)
 			continue
 		}
 
-		cmds = append(cmds, buildCommandFromExtension(kec.kymaConfig, extension, availableTemplateCommands, availableCoreCommands))
+		cmds = append(cmds, buildCommandFromExtension(kec.kymaConfig, &extension, availableTemplateCommands, availableCoreCommands))
 	}
 
 	return cmds
@@ -117,13 +106,13 @@ func getExtensionConfigMaps(ctx context.Context, clientConfig *KubeClientConfig)
 	return cms, nil
 }
 
-func loadExtensionsFromCluster(ctx context.Context, clientConfig *KubeClientConfig) ([]Extension, error) {
+func loadExtensionsFromCluster(ctx context.Context, clientConfig *KubeClientConfig) (ExtensionList, error) {
 	var cms, cmsError = getExtensionConfigMaps(ctx, clientConfig)
 	if cmsError != nil {
 		return nil, cmsError
 	}
 
-	var extensions []Extension
+	var extensionsItems ExtensionList
 	var parseErrors error
 	for _, cm := range cms.Items {
 		extension, err := parseResourceExtension(cm.Data)
@@ -137,8 +126,8 @@ func loadExtensionsFromCluster(ctx context.Context, clientConfig *KubeClientConf
 			continue
 		}
 
-		if slices.ContainsFunc(extensions, func(e Extension) bool {
-			return e.RootCommand.Name == extension.RootCommand.Name
+		if slices.ContainsFunc(extensionsItems, func(e ExtensionItem) bool {
+			return e.Extension.RootCommand.Name == extension.RootCommand.Name
 		}) {
 			parseErrors = errors.Join(
 				parseErrors,
@@ -148,10 +137,14 @@ func loadExtensionsFromCluster(ctx context.Context, clientConfig *KubeClientConf
 			continue
 		}
 
-		extensions = append(extensions, *extension)
+		extensionsItems = append(extensionsItems, ExtensionItem{
+			ConfigMapName:      cm.GetName(),
+			ConfigMapNamespace: cm.GetNamespace(),
+			Extension:          *extension,
+		})
 	}
 
-	return extensions, parseErrors
+	return extensionsItems, parseErrors
 }
 
 func parseResourceExtension(cmData map[string]string) (*Extension, error) {

internal/cmdcommon/extension_test.go

@@ -129,10 +129,14 @@ descriptionLong: test-description-long
 
 		want := ExtensionList{
 			{
-				RootCommand: types.RootCommand{
-					Name:            "test-command",
-					Description:     "test-description",
-					DescriptionLong: "test-description-long",
+				ConfigMapName:      "bad-data",
+				ConfigMapNamespace: "",
+				Extension: Extension{
+					RootCommand: types.RootCommand{
+						Name:            "test-command",
+						Description:     "test-description",
+						DescriptionLong: "test-description-long",
+					},
 				},
 			},
 		}
@@ -251,70 +255,74 @@ create:
 	}
 }
 
-func fixTestExtension(name string) Extension {
-	return Extension{
-		RootCommand: types.RootCommand{
-			Name:            name,
-			Description:     "test-description",
-			DescriptionLong: "test-description-long",
-		},
-		Resource: &types.ResourceInfo{
-			Scope:   types.NamespaceScope,
-			Kind:    "TestKind",
-			Group:   "test.group",
-			Version: "v1",
-		},
-		TemplateCommands: &TemplateCommands{
-			GetCommand: &types.GetCommand{
-				Description:     "test-get-description",
-				DescriptionLong: "test-get-description-long",
-				Parameters: []types.Parameter{
-					{
-						Path: ".metadata.generation",
-						Name: "generation",
-					},
-				},
-			},
-			ExplainCommand: &types.ExplainCommand{
+func fixTestExtension(name string) ExtensionItem {
+	return ExtensionItem{
+		ConfigMapName:      name,
+		ConfigMapNamespace: "",
+		Extension: Extension{
+			RootCommand: types.RootCommand{
+				Name:            name,
 				Description:     "test-description",
 				DescriptionLong: "test-description-long",
-				Output:          "test-explain-output",
 			},
-			DeleteCommand: &types.DeleteCommand{
-				Description:     "test-delete-description",
-				DescriptionLong: "test-delete-description-long",
+			Resource: &types.ResourceInfo{
+				Scope:   types.NamespaceScope,
+				Kind:    "TestKind",
+				Group:   "test.group",
+				Version: "v1",
 			},
-			CreateCommand: &types.CreateCommand{
-				Description:     "create test resource",
-				DescriptionLong: "use this command to create test resource",
-				CustomFlags: []types.CustomFlag{
-					{
-						Type:         types.StringCustomFlagType,
-						Name:         "test-flag",
-						Description:  "test-flag description",
-						Shorthand:    "t",
-						Path:         ".spec.test.field",
-						DefaultValue: "test-default",
-						Required:     true,
+			TemplateCommands: &TemplateCommands{
+				GetCommand: &types.GetCommand{
+					Description:     "test-get-description",
+					DescriptionLong: "test-get-description-long",
+					Parameters: []types.Parameter{
+						{
+							Path: ".metadata.generation",
+							Name: "generation",
+						},
 					},
-					{
-						Type:         types.PathCustomFlagType,
-						Name:         "test-flag-2",
-						Description:  "test-flag-2 description",
-						Shorthand:    "f",
-						Path:         ".spec.test.field2",
-						DefaultValue: "test-default2",
-						Required:     false,
+				},
+				ExplainCommand: &types.ExplainCommand{
+					Description:     "test-description",
+					DescriptionLong: "test-description-long",
+					Output:          "test-explain-output",
+				},
+				DeleteCommand: &types.DeleteCommand{
+					Description:     "test-delete-description",
+					DescriptionLong: "test-delete-description-long",
+				},
+				CreateCommand: &types.CreateCommand{
+					Description:     "create test resource",
+					DescriptionLong: "use this command to create test resource",
+					CustomFlags: []types.CustomFlag{
+						{
+							Type:         types.StringCustomFlagType,
+							Name:         "test-flag",
+							Description:  "test-flag description",
+							Shorthand:    "t",
+							Path:         ".spec.test.field",
+							DefaultValue: "test-default",
+							Required:     true,
+						},
+						{
+							Type:         types.PathCustomFlagType,
+							Name:         "test-flag-2",
+							Description:  "test-flag-2 description",
+							Shorthand:    "f",
+							Path:         ".spec.test.field2",
+							DefaultValue: "test-default2",
+							Required:     false,
+						},
 					},
 				},
 			},
-		},
-		CoreCommands: []CoreCommandInfo{
-			{
-				ActionID: "test-action-id-1",
-			},
-			{
-				ActionID: "test-action-id-2",
+			CoreCommands: []CoreCommandInfo{
+				{
+					ActionID: "test-action-id-1",
+				},
+				{
+					ActionID: "test-action-id-2",
+				},
 			},
 		},
 	}

internal/cmdcommon/extension_types.go

@@ -27,11 +27,17 @@ type TemplateCommandsList struct {
 	Delete  func(templates.KubeClientGetter, *templates.DeleteOptions) *cobra.Command
 }
 
-type ExtensionList []Extension
+type ExtensionList []ExtensionItem
+
+type ExtensionItem struct {
+	ConfigMapName      string
+	ConfigMapNamespace string
+	Extension          Extension
+}
 
 func (el *ExtensionList) ContainResource(kind string) bool {
-	for _, extension := range *el {
-		if extension.Resource.Kind == kind {
+	for _, item := range *el {
+		if item.Extension.Resource.Kind == kind {
 			return true
 		}
 	}