diff --git a/cmd/application_env_create.go b/cmd/application_env_create.go index 274b2ebe..044719f4 100644 --- a/cmd/application_env_create.go +++ b/cmd/application_env_create.go @@ -24,7 +24,7 @@ var applicationEnvCreateCmd = &cobra.Command{ } client := utils.GetQoveryClient(tokenType, token) - _, projectId, envId, err := getOrganizationProjectEnvironmentContextResourcesIds(client) + _, _, envId, err := getOrganizationProjectEnvironmentContextResourcesIds(client) if err != nil { utils.PrintlnError(err) @@ -49,20 +49,7 @@ var applicationEnvCreateCmd = &cobra.Command{ panic("unreachable") // staticcheck false positive: https://staticcheck.io/docs/checks#SA5011 } - if utils.IsSecret { - err = utils.CreateSecret(client, projectId, envId, application.Id, utils.Key, utils.Value, utils.ApplicationScope) - - if err != nil { - utils.PrintlnError(err) - os.Exit(1) - panic("unreachable") // staticcheck false positive: https://staticcheck.io/docs/checks#SA5011 - } - - utils.Println(fmt.Sprintf("Secret %s has been created", pterm.FgBlue.Sprintf(utils.Key))) - return - } - - err = utils.CreateEnvironmentVariable(client, projectId, envId, application.Id, utils.Key, utils.Value, utils.ApplicationScope) + err = utils.CreateEnvironmentVariable(client, application.Id, utils.ApplicationScope, utils.Key, utils.Value, utils.IsSecret) if err != nil { utils.PrintlnError(err) diff --git a/cmd/application_env_delete.go b/cmd/application_env_delete.go index 0f4cff7e..b7bfcef8 100644 --- a/cmd/application_env_delete.go +++ b/cmd/application_env_delete.go @@ -24,7 +24,7 @@ var applicationEnvDeleteCmd = &cobra.Command{ } client := utils.GetQoveryClient(tokenType, token) - _, projectId, envId, err := getOrganizationProjectEnvironmentContextResourcesIds(client) + _, _, envId, err := getOrganizationProjectEnvironmentContextResourcesIds(client) if err != nil { utils.PrintlnError(err) @@ -49,7 +49,7 @@ var applicationEnvDeleteCmd = &cobra.Command{ panic("unreachable") // staticcheck false positive: https://staticcheck.io/docs/checks#SA5011 } - err = utils.DeleteByKey(client, projectId, envId, application.Id, utils.ApplicationType, utils.Key) + err = utils.DeleteVariable(client, application.Id, utils.ApplicationType, utils.Key) if err != nil { utils.PrintlnError(err) diff --git a/cmd/application_env_list.go b/cmd/application_env_list.go index 1c9ecd80..8530859a 100644 --- a/cmd/application_env_list.go +++ b/cmd/application_env_list.go @@ -49,21 +49,11 @@ var applicationEnvListCmd = &cobra.Command{ panic("unreachable") // staticcheck false positive: https://staticcheck.io/docs/checks#SA5011 } - envVars, _, err := client.ApplicationEnvironmentVariableAPI.ListApplicationEnvironmentVariable( - context.Background(), + envVars, err := utils.ListEnvironmentVariables( + client, application.Id, - ).Execute() - - if err != nil { - utils.PrintlnError(err) - os.Exit(1) - panic("unreachable") // staticcheck false positive: https://staticcheck.io/docs/checks#SA5011 - } - - secrets, _, err := client.ApplicationSecretAPI.ListApplicationSecrets( - context.Background(), - application.Id, - ).Execute() + utils.ApplicationType, + ) if err != nil { utils.PrintlnError(err) @@ -74,18 +64,12 @@ var applicationEnvListCmd = &cobra.Command{ envVarLines := utils.NewEnvVarLines() var variables []utils.EnvVarLineOutput - for _, envVar := range envVars.GetResults() { + for _, envVar := range envVars { s := utils.FromEnvironmentVariableToEnvVarLineOutput(envVar) variables = append(variables, s) envVarLines.Add(s) } - for _, secret := range secrets.GetResults() { - s := utils.FromSecretToEnvVarLineOutput(secret) - variables = append(variables, s) - envVarLines.Add(s) - } - if jsonFlag { utils.Println(utils.GetEnvVarJsonOutput(variables)) return diff --git a/cmd/application_env_override_create.go b/cmd/application_env_override_create.go index 8cbd9d93..731739f2 100644 --- a/cmd/application_env_override_create.go +++ b/cmd/application_env_override_create.go @@ -49,7 +49,7 @@ var applicationEnvOverrideCreateCmd = &cobra.Command{ panic("unreachable") // staticcheck false positive: https://staticcheck.io/docs/checks#SA5011 } - err = utils.CreateOverride(client, projectId, envId, application.Id, utils.ApplicationType, utils.Key, &utils.Value, utils.ApplicationScope) + err = utils.CreateOverride(client, projectId, envId, application.Id, utils.ApplicationType, utils.Key, utils.Value, utils.ApplicationScope) if err != nil { utils.PrintlnError(err) @@ -73,4 +73,5 @@ func init() { _ = applicationEnvOverrideCreateCmd.MarkFlagRequired("key") _ = applicationEnvOverrideCreateCmd.MarkFlagRequired("application") + _ = applicationEnvOverrideCreateCmd.MarkFlagRequired("value") } diff --git a/cmd/container_env_create.go b/cmd/container_env_create.go index d6dfb738..3c63e8e6 100644 --- a/cmd/container_env_create.go +++ b/cmd/container_env_create.go @@ -24,7 +24,7 @@ var containerEnvCreateCmd = &cobra.Command{ } client := utils.GetQoveryClient(tokenType, token) - _, projectId, envId, err := getOrganizationProjectEnvironmentContextResourcesIds(client) + _, _, envId, err := getOrganizationProjectEnvironmentContextResourcesIds(client) if err != nil { utils.PrintlnError(err) @@ -49,20 +49,7 @@ var containerEnvCreateCmd = &cobra.Command{ panic("unreachable") // staticcheck false positive: https://staticcheck.io/docs/checks#SA5011 } - if utils.IsSecret { - err = utils.CreateSecret(client, projectId, envId, container.Id, utils.Key, utils.Value, utils.ContainerScope) - - if err != nil { - utils.PrintlnError(err) - os.Exit(1) - panic("unreachable") // staticcheck false positive: https://staticcheck.io/docs/checks#SA5011 - } - - utils.Println(fmt.Sprintf("Secret %s has been created", pterm.FgBlue.Sprintf(utils.Key))) - return - } - - err = utils.CreateEnvironmentVariable(client, projectId, envId, container.Id, utils.Key, utils.Value, utils.ContainerScope) + err = utils.CreateEnvironmentVariable(client, container.Id, utils.ContainerScope, utils.Key, utils.Value, utils.IsSecret) if err != nil { utils.PrintlnError(err) diff --git a/cmd/container_env_delete.go b/cmd/container_env_delete.go index 6d05aca7..9f0b4476 100644 --- a/cmd/container_env_delete.go +++ b/cmd/container_env_delete.go @@ -24,7 +24,7 @@ var containerEnvDeleteCmd = &cobra.Command{ } client := utils.GetQoveryClient(tokenType, token) - _, projectId, envId, err := getOrganizationProjectEnvironmentContextResourcesIds(client) + _, _, envId, err := getOrganizationProjectEnvironmentContextResourcesIds(client) if err != nil { utils.PrintlnError(err) @@ -49,7 +49,7 @@ var containerEnvDeleteCmd = &cobra.Command{ panic("unreachable") // staticcheck false positive: https://staticcheck.io/docs/checks#SA5011 } - err = utils.DeleteByKey(client, projectId, envId, container.Id, utils.ContainerType, utils.Key) + err = utils.DeleteVariable(client, container.Id, utils.ContainerType, utils.Key) if err != nil { utils.PrintlnError(err) diff --git a/cmd/container_env_list.go b/cmd/container_env_list.go index c87ed089..61eb4fd8 100644 --- a/cmd/container_env_list.go +++ b/cmd/container_env_list.go @@ -49,21 +49,11 @@ var containerEnvListCmd = &cobra.Command{ panic("unreachable") // staticcheck false positive: https://staticcheck.io/docs/checks#SA5011 } - envVars, _, err := client.ContainerEnvironmentVariableAPI.ListContainerEnvironmentVariable( - context.Background(), + envVars, err := utils.ListEnvironmentVariables( + client, container.Id, - ).Execute() - - if err != nil { - utils.PrintlnError(err) - os.Exit(1) - panic("unreachable") // staticcheck false positive: https://staticcheck.io/docs/checks#SA5011 - } - - secrets, _, err := client.ContainerSecretAPI.ListContainerSecrets( - context.Background(), - container.Id, - ).Execute() + utils.ContainerType, + ) if err != nil { utils.PrintlnError(err) @@ -74,18 +64,12 @@ var containerEnvListCmd = &cobra.Command{ envVarLines := utils.NewEnvVarLines() var variables []utils.EnvVarLineOutput - for _, envVar := range envVars.GetResults() { + for _, envVar := range envVars { s := utils.FromEnvironmentVariableToEnvVarLineOutput(envVar) variables = append(variables, s) envVarLines.Add(s) } - for _, secret := range secrets.GetResults() { - s := utils.FromSecretToEnvVarLineOutput(secret) - variables = append(variables, s) - envVarLines.Add(s) - } - if jsonFlag { utils.Println(utils.GetEnvVarJsonOutput(variables)) return diff --git a/cmd/container_env_override_create.go b/cmd/container_env_override_create.go index da6bf97d..6361b7cc 100644 --- a/cmd/container_env_override_create.go +++ b/cmd/container_env_override_create.go @@ -49,7 +49,7 @@ var containerEnvOverrideCreateCmd = &cobra.Command{ panic("unreachable") // staticcheck false positive: https://staticcheck.io/docs/checks#SA5011 } - err = utils.CreateOverride(client, projectId, envId, container.Id, utils.ContainerType, utils.Key, &utils.Value, utils.ContainerScope) + err = utils.CreateOverride(client, projectId, envId, container.Id, utils.ContainerType, utils.Key, utils.Value, utils.ContainerScope) if err != nil { utils.PrintlnError(err) @@ -73,4 +73,5 @@ func init() { _ = containerEnvOverrideCreateCmd.MarkFlagRequired("key") _ = containerEnvOverrideCreateCmd.MarkFlagRequired("container") + _ = containerEnvOverrideCreateCmd.MarkFlagRequired("value") } diff --git a/cmd/cronjob_env_alias_create.go b/cmd/cronjob_env_alias_create.go index 6cd9050a..6700690a 100644 --- a/cmd/cronjob_env_alias_create.go +++ b/cmd/cronjob_env_alias_create.go @@ -24,7 +24,7 @@ var cronjobEnvAliasCreateCmd = &cobra.Command{ } client := utils.GetQoveryClient(tokenType, token) - _, projectId, envId, err := getOrganizationProjectEnvironmentContextResourcesIds(client) + _, _, envId, err := getOrganizationProjectEnvironmentContextResourcesIds(client) if err != nil { utils.PrintlnError(err) diff --git a/cmd/cronjob_env_create.go b/cmd/cronjob_env_create.go index 9e5bd334..1d7ab7c0 100644 --- a/cmd/cronjob_env_create.go +++ b/cmd/cronjob_env_create.go @@ -24,7 +24,7 @@ var cronjobEnvCreateCmd = &cobra.Command{ } client := utils.GetQoveryClient(tokenType, token) - _, projectId, envId, err := getOrganizationProjectEnvironmentContextResourcesIds(client) + _, _, envId, err := getOrganizationProjectEnvironmentContextResourcesIds(client) if err != nil { utils.PrintlnError(err) @@ -49,20 +49,7 @@ var cronjobEnvCreateCmd = &cobra.Command{ panic("unreachable") // staticcheck false positive: https://staticcheck.io/docs/checks#SA5011 } - if utils.IsSecret { - err = utils.CreateSecret(client, projectId, envId, cronjob.CronJobResponse.Id, utils.Key, utils.Value, utils.JobScope) - - if err != nil { - utils.PrintlnError(err) - os.Exit(1) - panic("unreachable") // staticcheck false positive: https://staticcheck.io/docs/checks#SA5011 - } - - utils.Println(fmt.Sprintf("Secret %s has been created", pterm.FgBlue.Sprintf(utils.Key))) - return - } - - err = utils.CreateEnvironmentVariable(client, projectId, envId, cronjob.CronJobResponse.Id, utils.Key, utils.Value, utils.JobScope) + err = utils.CreateEnvironmentVariable(client, cronjob.CronJobResponse.Id, utils.JobScope, utils.Key, utils.Value, utils.IsSecret) if err != nil { utils.PrintlnError(err) diff --git a/cmd/cronjob_env_delete.go b/cmd/cronjob_env_delete.go index 268e049a..ff8826b7 100644 --- a/cmd/cronjob_env_delete.go +++ b/cmd/cronjob_env_delete.go @@ -24,7 +24,7 @@ var cronjobEnvDeleteCmd = &cobra.Command{ } client := utils.GetQoveryClient(tokenType, token) - _, projectId, envId, err := getOrganizationProjectEnvironmentContextResourcesIds(client) + _, _, envId, err := getOrganizationProjectEnvironmentContextResourcesIds(client) if err != nil { utils.PrintlnError(err) @@ -49,7 +49,7 @@ var cronjobEnvDeleteCmd = &cobra.Command{ panic("unreachable") // staticcheck false positive: https://staticcheck.io/docs/checks#SA5011 } - err = utils.DeleteByKey(client, projectId, envId, cronjob.CronJobResponse.Id, utils.JobType, utils.Key) + err = utils.DeleteVariable(client, cronjob.CronJobResponse.Id, utils.JobType, utils.Key) if err != nil { utils.PrintlnError(err) diff --git a/cmd/cronjob_env_list.go b/cmd/cronjob_env_list.go index 3c5c69dd..4cafd9cc 100644 --- a/cmd/cronjob_env_list.go +++ b/cmd/cronjob_env_list.go @@ -49,21 +49,11 @@ var cronjobEnvListCmd = &cobra.Command{ panic("unreachable") // staticcheck false positive: https://staticcheck.io/docs/checks#SA5011 } - envVars, _, err := client.JobEnvironmentVariableAPI.ListJobEnvironmentVariable( - context.Background(), + envVars, err := utils.ListEnvironmentVariables( + client, cronjob.CronJobResponse.Id, - ).Execute() - - if err != nil { - utils.PrintlnError(err) - os.Exit(1) - panic("unreachable") // staticcheck false positive: https://staticcheck.io/docs/checks#SA5011 - } - - secrets, _, err := client.JobSecretAPI.ListJobSecrets( - context.Background(), - cronjob.CronJobResponse.Id, - ).Execute() + utils.JobType, + ) if err != nil { utils.PrintlnError(err) @@ -74,18 +64,12 @@ var cronjobEnvListCmd = &cobra.Command{ envVarLines := utils.NewEnvVarLines() var variables []utils.EnvVarLineOutput - for _, envVar := range envVars.GetResults() { + for _, envVar := range envVars { s := utils.FromEnvironmentVariableToEnvVarLineOutput(envVar) variables = append(variables, s) envVarLines.Add(s) } - for _, secret := range secrets.GetResults() { - s := utils.FromSecretToEnvVarLineOutput(secret) - variables = append(variables, s) - envVarLines.Add(s) - } - if jsonFlag { utils.Println(utils.GetEnvVarJsonOutput(variables)) return diff --git a/cmd/cronjob_env_override_create.go b/cmd/cronjob_env_override_create.go index f8cdcc2f..408aaae9 100644 --- a/cmd/cronjob_env_override_create.go +++ b/cmd/cronjob_env_override_create.go @@ -49,7 +49,7 @@ var cronjobEnvOverrideCreateCmd = &cobra.Command{ panic("unreachable") // staticcheck false positive: https://staticcheck.io/docs/checks#SA5011 } - err = utils.CreateOverride(client, projectId, envId, cronjob.CronJobResponse.Id, utils.JobType, utils.Key, &utils.Value, utils.JobScope) + err = utils.CreateOverride(client, projectId, envId, cronjob.CronJobResponse.Id, utils.JobType, utils.Key, utils.Value, utils.JobScope) if err != nil { utils.PrintlnError(err) @@ -73,4 +73,5 @@ func init() { _ = cronjobEnvOverrideCreateCmd.MarkFlagRequired("key") _ = cronjobEnvOverrideCreateCmd.MarkFlagRequired("cronjob") + _ = cronjobEnvOverrideCreateCmd.MarkFlagRequired("value") } diff --git a/cmd/helm_env.go b/cmd/helm_env.go new file mode 100644 index 00000000..07fc19f1 --- /dev/null +++ b/cmd/helm_env.go @@ -0,0 +1,24 @@ +package cmd + +import ( + "github.com/qovery/qovery-cli/utils" + "github.com/spf13/cobra" + "os" +) + +var helmEnvCmd = &cobra.Command{ + Use: "env", + Short: "Manage helm environment variables and secrets", + Run: func(cmd *cobra.Command, args []string) { + utils.Capture(cmd) + + if len(args) == 0 { + _ = cmd.Help() + os.Exit(0) + } + }, +} + +func init() { + helmCmd.AddCommand(helmEnvCmd) +} diff --git a/cmd/helm_env_alias.go b/cmd/helm_env_alias.go new file mode 100644 index 00000000..1f34c958 --- /dev/null +++ b/cmd/helm_env_alias.go @@ -0,0 +1,24 @@ +package cmd + +import ( + "github.com/qovery/qovery-cli/utils" + "github.com/spf13/cobra" + "os" +) + +var helmEnvAliasCmd = &cobra.Command{ + Use: "alias", + Short: "Manage helm environment variable and secret aliases", + Run: func(cmd *cobra.Command, args []string) { + utils.Capture(cmd) + + if len(args) == 0 { + _ = cmd.Help() + os.Exit(0) + } + }, +} + +func init() { + helmEnvCmd.AddCommand(helmEnvAliasCmd) +} diff --git a/cmd/helm_env_alias_create.go b/cmd/helm_env_alias_create.go new file mode 100644 index 00000000..7d76ace6 --- /dev/null +++ b/cmd/helm_env_alias_create.go @@ -0,0 +1,77 @@ +package cmd + +import ( + "context" + "fmt" + "os" + + "github.com/pterm/pterm" + "github.com/qovery/qovery-cli/utils" + "github.com/spf13/cobra" +) + +var helmEnvAliasCreateCmd = &cobra.Command{ + Use: "create", + Short: "Create helm environment variable or secret alias", + Run: func(cmd *cobra.Command, args []string) { + utils.Capture(cmd) + + tokenType, token, err := utils.GetAccessToken() + if err != nil { + utils.PrintlnError(err) + os.Exit(1) + panic("unreachable") // staticcheck false positive: https://staticcheck.io/docs/checks#SA5011 + } + + client := utils.GetQoveryClient(tokenType, token) + _, _, envId, err := getOrganizationProjectEnvironmentContextResourcesIds(client) + + if err != nil { + utils.PrintlnError(err) + os.Exit(1) + panic("unreachable") // staticcheck false positive: https://staticcheck.io/docs/checks#SA5011 + } + + helms, _, err := client.HelmsAPI.ListHelms(context.Background(), envId).Execute() + + if err != nil { + utils.PrintlnError(err) + os.Exit(1) + panic("unreachable") // staticcheck false positive: https://staticcheck.io/docs/checks#SA5011 + } + + helm := utils.FindByHelmName(helms.GetResults(), helmName) + + if helm == nil { + utils.PrintlnError(fmt.Errorf("helm %s not found", helmName)) + utils.PrintlnInfo("You can list all helms with: qovery helm list") + os.Exit(1) + panic("unreachable") // staticcheck false positive: https://staticcheck.io/docs/checks#SA5011 + } + + err = utils.CreateAlias(client, projectId, envId, helm.Id, utils.HelmType, utils.Key, utils.Alias, utils.HelmScope) + + if err != nil { + utils.PrintlnError(err) + os.Exit(1) + panic("unreachable") // staticcheck false positive: https://staticcheck.io/docs/checks#SA5011 + } + + utils.Println(fmt.Sprintf("Alias %s has been created", pterm.FgBlue.Sprintf(utils.Alias))) + }, +} + +func init() { + helmEnvAliasCmd.AddCommand(helmEnvAliasCreateCmd) + helmEnvAliasCreateCmd.Flags().StringVarP(&organizationName, "organization", "", "", "Organization Name") + helmEnvAliasCreateCmd.Flags().StringVarP(&projectName, "project", "", "", "Project Name") + helmEnvAliasCreateCmd.Flags().StringVarP(&environmentName, "environment", "", "", "Environment Name") + helmEnvAliasCreateCmd.Flags().StringVarP(&helmName, "helm", "n", "", "helm Name") + helmEnvAliasCreateCmd.Flags().StringVarP(&utils.Key, "key", "k", "", "Environment variable or secret key") + helmEnvAliasCreateCmd.Flags().StringVarP(&utils.Alias, "alias", "", "", "Environment variable or secret alias") + helmEnvAliasCreateCmd.Flags().StringVarP(&utils.HelmScope, "scope", "", "HELM", "Scope of this alias ") + + _ = helmEnvAliasCreateCmd.MarkFlagRequired("key") + _ = helmEnvAliasCreateCmd.MarkFlagRequired("alias") + _ = helmEnvAliasCreateCmd.MarkFlagRequired("helm") +} diff --git a/cmd/helm_env_create.go b/cmd/helm_env_create.go new file mode 100644 index 00000000..77db9243 --- /dev/null +++ b/cmd/helm_env_create.go @@ -0,0 +1,78 @@ +package cmd + +import ( + "context" + "fmt" + "os" + + "github.com/pterm/pterm" + "github.com/qovery/qovery-cli/utils" + "github.com/spf13/cobra" +) + +var helmEnvCreateCmd = &cobra.Command{ + Use: "create", + Short: "Create helm environment variable or secret", + Run: func(cmd *cobra.Command, args []string) { + utils.Capture(cmd) + + tokenType, token, err := utils.GetAccessToken() + if err != nil { + utils.PrintlnError(err) + os.Exit(1) + panic("unreachable") // staticcheck false positive: https://staticcheck.io/docs/checks#SA5011 + } + + client := utils.GetQoveryClient(tokenType, token) + _, _, envId, err := getOrganizationProjectEnvironmentContextResourcesIds(client) + + if err != nil { + utils.PrintlnError(err) + os.Exit(1) + panic("unreachable") // staticcheck false positive: https://staticcheck.io/docs/checks#SA5011 + } + + helms, _, err := client.HelmsAPI.ListHelms(context.Background(), envId).Execute() + + if err != nil { + utils.PrintlnError(err) + os.Exit(1) + panic("unreachable") // staticcheck false positive: https://staticcheck.io/docs/checks#SA5011 + } + + helm := utils.FindByHelmName(helms.GetResults(), helmName) + + if helm == nil { + utils.PrintlnError(fmt.Errorf("helm %s not found", helmName)) + utils.PrintlnInfo("You can list all helms with: qovery helm list") + os.Exit(1) + panic("unreachable") // staticcheck false positive: https://staticcheck.io/docs/checks#SA5011 + } + + err = utils.CreateEnvironmentVariable(client, helm.Id, utils.HelmScope, utils.Key, utils.Value, utils.IsSecret) + + if err != nil { + utils.PrintlnError(err) + os.Exit(1) + panic("unreachable") // staticcheck false positive: https://staticcheck.io/docs/checks#SA5011 + } + + utils.Println(fmt.Sprintf("Environment variable %s has been created", pterm.FgBlue.Sprintf(utils.Key))) + }, +} + +func init() { + helmEnvCmd.AddCommand(helmEnvCreateCmd) + helmEnvCreateCmd.Flags().StringVarP(&organizationName, "organization", "", "", "Organization Name") + helmEnvCreateCmd.Flags().StringVarP(&projectName, "project", "", "", "Project Name") + helmEnvCreateCmd.Flags().StringVarP(&environmentName, "environment", "", "", "Environment Name") + helmEnvCreateCmd.Flags().StringVarP(&helmName, "helm", "n", "", "helm Name") + helmEnvCreateCmd.Flags().StringVarP(&utils.Key, "key", "k", "", "Environment variable or secret key") + helmEnvCreateCmd.Flags().StringVarP(&utils.Value, "value", "v", "", "Environment variable or secret value") + helmEnvCreateCmd.Flags().StringVarP(&utils.HelmScope, "scope", "", "HELM", "Scope of this env var ") + helmEnvCreateCmd.Flags().BoolVarP(&utils.IsSecret, "secret", "", false, "This environment variable is a secret") + + _ = helmEnvCreateCmd.MarkFlagRequired("key") + _ = helmEnvCreateCmd.MarkFlagRequired("value") + _ = helmEnvCreateCmd.MarkFlagRequired("helm") +} diff --git a/cmd/helm_env_delete.go b/cmd/helm_env_delete.go new file mode 100644 index 00000000..6cf77126 --- /dev/null +++ b/cmd/helm_env_delete.go @@ -0,0 +1,74 @@ +package cmd + +import ( + "context" + "fmt" + "os" + + "github.com/pterm/pterm" + "github.com/qovery/qovery-cli/utils" + "github.com/spf13/cobra" +) + +var helmEnvDeleteCmd = &cobra.Command{ + Use: "delete", + Short: "Delete helm environment variable or secret", + Run: func(cmd *cobra.Command, args []string) { + utils.Capture(cmd) + + tokenType, token, err := utils.GetAccessToken() + if err != nil { + utils.PrintlnError(err) + os.Exit(1) + panic("unreachable") // staticcheck false positive: https://staticcheck.io/docs/checks#SA5011 + } + + client := utils.GetQoveryClient(tokenType, token) + _, _, envId, err := getOrganizationProjectEnvironmentContextResourcesIds(client) + + if err != nil { + utils.PrintlnError(err) + os.Exit(1) + panic("unreachable") // staticcheck false positive: https://staticcheck.io/docs/checks#SA5011 + } + + helms, _, err := client.HelmsAPI.ListHelms(context.Background(), envId).Execute() + + if err != nil { + utils.PrintlnError(err) + os.Exit(1) + panic("unreachable") // staticcheck false positive: https://staticcheck.io/docs/checks#SA5011 + } + + helm := utils.FindByHelmName(helms.GetResults(), helmName) + + if helm == nil { + utils.PrintlnError(fmt.Errorf("helm %s not found", helmName)) + utils.PrintlnInfo("You can list all helms with: qovery helm list") + os.Exit(1) + panic("unreachable") // staticcheck false positive: https://staticcheck.io/docs/checks#SA5011 + } + + err = utils.DeleteVariable(client, helm.Id, utils.HelmType, utils.Key) + + if err != nil { + utils.PrintlnError(err) + os.Exit(1) + panic("unreachable") // staticcheck false positive: https://staticcheck.io/docs/checks#SA5011 + } + + utils.Println(fmt.Sprintf("Variable %s has been deleted", pterm.FgBlue.Sprintf(utils.Key))) + }, +} + +func init() { + helmEnvCmd.AddCommand(helmEnvDeleteCmd) + helmEnvDeleteCmd.Flags().StringVarP(&organizationName, "organization", "", "", "Organization Name") + helmEnvDeleteCmd.Flags().StringVarP(&projectName, "project", "", "", "Project Name") + helmEnvDeleteCmd.Flags().StringVarP(&environmentName, "environment", "", "", "Environment Name") + helmEnvDeleteCmd.Flags().StringVarP(&helmName, "helm", "n", "", "helm Name") + helmEnvDeleteCmd.Flags().StringVarP(&utils.Key, "key", "k", "", "Environment variable or secret key") + + _ = helmEnvDeleteCmd.MarkFlagRequired("key") + _ = helmEnvDeleteCmd.MarkFlagRequired("helm") +} diff --git a/cmd/helm_env_list.go b/cmd/helm_env_list.go new file mode 100644 index 00000000..663f3412 --- /dev/null +++ b/cmd/helm_env_list.go @@ -0,0 +1,105 @@ +package cmd + +import ( + "context" + "fmt" + "os" + + "github.com/qovery/qovery-cli/utils" + "github.com/spf13/cobra" +) + +var helmEnvListCmd = &cobra.Command{ + Use: "list", + Short: "List helm environment variables", + Run: func(cmd *cobra.Command, args []string) { + utils.Capture(cmd) + + tokenType, token, err := utils.GetAccessToken() + if err != nil { + utils.PrintlnError(err) + os.Exit(1) + panic("unreachable") // staticcheck false positive: https://staticcheck.io/docs/checks#SA5011 + } + + client := utils.GetQoveryClient(tokenType, token) + + _, _, envId, err := getOrganizationProjectEnvironmentContextResourcesIds(client) + + if err != nil { + utils.PrintlnError(err) + os.Exit(1) + panic("unreachable") // staticcheck false positive: https://staticcheck.io/docs/checks#SA5011 + } + + helms, _, err := client.HelmsAPI.ListHelms(context.Background(), envId).Execute() + + if err != nil { + utils.PrintlnError(err) + os.Exit(1) + panic("unreachable") // staticcheck false positive: https://staticcheck.io/docs/checks#SA5011 + } + + helm := utils.FindByHelmName(helms.GetResults(), helmName) + + if helm == nil { + utils.PrintlnError(fmt.Errorf("helm %s not found", helmName)) + utils.PrintlnInfo("You can list all helms with: qovery helm list") + os.Exit(1) + panic("unreachable") // staticcheck false positive: https://staticcheck.io/docs/checks#SA5011 + } + + envVars, err := utils.ListEnvironmentVariables( + client, + helm.Id, + utils.HelmType, + ) + + if err != nil { + utils.PrintlnError(err) + os.Exit(1) + panic("unreachable") // staticcheck false positive: https://staticcheck.io/docs/checks#SA5011 + } + + if err != nil { + utils.PrintlnError(err) + os.Exit(1) + panic("unreachable") // staticcheck false positive: https://staticcheck.io/docs/checks#SA5011 + } + + envVarLines := utils.NewEnvVarLines() + var variables []utils.EnvVarLineOutput + + for _, envVar := range envVars { + s := utils.FromEnvironmentVariableToEnvVarLineOutput(envVar) + variables = append(variables, s) + envVarLines.Add(s) + } + + if jsonFlag { + utils.Println(utils.GetEnvVarJsonOutput(variables)) + return + } + + err = utils.PrintTable(envVarLines.Header(utils.PrettyPrint), envVarLines.Lines(utils.ShowValues, utils.PrettyPrint)) + + if err != nil { + utils.PrintlnError(err) + os.Exit(1) + panic("unreachable") // staticcheck false positive: https://staticcheck.io/docs/checks#SA5011 + } + }, +} + +func init() { + helmEnvCmd.AddCommand(helmEnvListCmd) + helmEnvListCmd.Flags().StringVarP(&organizationName, "organization", "", "", "Organization Name") + helmEnvListCmd.Flags().StringVarP(&projectName, "project", "", "", "Project Name") + helmEnvListCmd.Flags().StringVarP(&environmentName, "environment", "", "", "Environment Name") + helmEnvListCmd.Flags().StringVarP(&helmName, "helm", "n", "", "helm Name") + helmEnvListCmd.Flags().BoolVarP(&utils.ShowValues, "show-values", "", false, "Show env var values") + helmEnvListCmd.Flags().BoolVarP(&utils.PrettyPrint, "pretty-print", "", false, "Pretty print output") + helmEnvListCmd.Flags().BoolVarP(&jsonFlag, "json", "", false, "JSON output") + + _ = helmEnvListCmd.MarkFlagRequired("helm") +} diff --git a/cmd/helm_env_override.go b/cmd/helm_env_override.go new file mode 100644 index 00000000..4f0f0f86 --- /dev/null +++ b/cmd/helm_env_override.go @@ -0,0 +1,24 @@ +package cmd + +import ( + "github.com/qovery/qovery-cli/utils" + "github.com/spf13/cobra" + "os" +) + +var helmEnvOverrideCmd = &cobra.Command{ + Use: "override", + Short: "Manage helm environment variable and secret overrides", + Run: func(cmd *cobra.Command, args []string) { + utils.Capture(cmd) + + if len(args) == 0 { + _ = cmd.Help() + os.Exit(0) + } + }, +} + +func init() { + helmEnvCmd.AddCommand(helmEnvOverrideCmd) +} diff --git a/cmd/helm_env_override_create.go b/cmd/helm_env_override_create.go new file mode 100644 index 00000000..925720e2 --- /dev/null +++ b/cmd/helm_env_override_create.go @@ -0,0 +1,76 @@ +package cmd + +import ( + "context" + "fmt" + "os" + + "github.com/pterm/pterm" + "github.com/qovery/qovery-cli/utils" + "github.com/spf13/cobra" +) + +var helmEnvOverrideCreateCmd = &cobra.Command{ + Use: "create", + Short: "Override helm environment variable or secret", + Run: func(cmd *cobra.Command, args []string) { + utils.Capture(cmd) + + tokenType, token, err := utils.GetAccessToken() + if err != nil { + utils.PrintlnError(err) + os.Exit(1) + panic("unreachable") // staticcheck false positive: https://staticcheck.io/docs/checks#SA5011 + } + + client := utils.GetQoveryClient(tokenType, token) + _, projectId, envId, err := getOrganizationProjectEnvironmentContextResourcesIds(client) + + if err != nil { + utils.PrintlnError(err) + os.Exit(1) + panic("unreachable") // staticcheck false positive: https://staticcheck.io/docs/checks#SA5011 + } + + helms, _, err := client.HelmsAPI.ListHelms(context.Background(), envId).Execute() + + if err != nil { + utils.PrintlnError(err) + os.Exit(1) + panic("unreachable") // staticcheck false positive: https://staticcheck.io/docs/checks#SA5011 + } + + helm := utils.FindByHelmName(helms.GetResults(), helmName) + + if helm == nil { + utils.PrintlnError(fmt.Errorf("helm %s not found", helmName)) + utils.PrintlnInfo("You can list all helms with: qovery helm list") + os.Exit(1) + panic("unreachable") // staticcheck false positive: https://staticcheck.io/docs/checks#SA5011 + } + + err = utils.CreateOverride(client, projectId, envId, helm.Id, utils.HelmType, utils.Key, utils.Value, utils.HelmScope) + + if err != nil { + utils.PrintlnError(err) + os.Exit(1) + panic("unreachable") // staticcheck false positive: https://staticcheck.io/docs/checks#SA5011 + } + + utils.Println(fmt.Sprintf("%s has been overidden", pterm.FgBlue.Sprintf(utils.Key))) + }, +} + +func init() { + helmEnvOverrideCmd.AddCommand(helmEnvOverrideCreateCmd) + helmEnvOverrideCreateCmd.Flags().StringVarP(&organizationName, "organization", "", "", "Organization Name") + helmEnvOverrideCreateCmd.Flags().StringVarP(&projectName, "project", "", "", "Project Name") + helmEnvOverrideCreateCmd.Flags().StringVarP(&environmentName, "environment", "", "", "Environment Name") + helmEnvOverrideCreateCmd.Flags().StringVarP(&helmName, "helm", "n", "", "helm Name") + helmEnvOverrideCreateCmd.Flags().StringVarP(&utils.Key, "key", "k", "", "Environment variable or secret key") + helmEnvOverrideCreateCmd.Flags().StringVarP(&utils.Value, "value", "", "", "Environment variable or secret value") + helmEnvOverrideCreateCmd.Flags().StringVarP(&utils.HelmScope, "scope", "", "HELM", "Scope of this alias ") + + _ = helmEnvOverrideCreateCmd.MarkFlagRequired("key") + _ = helmEnvOverrideCreateCmd.MarkFlagRequired("helm") +} diff --git a/cmd/lifecycle_env_alias_create.go b/cmd/lifecycle_env_alias_create.go index 583396bb..98a580b5 100644 --- a/cmd/lifecycle_env_alias_create.go +++ b/cmd/lifecycle_env_alias_create.go @@ -24,7 +24,7 @@ var lifecycleEnvAliasCreateCmd = &cobra.Command{ } client := utils.GetQoveryClient(tokenType, token) - _, projectId, envId, err := getOrganizationProjectEnvironmentContextResourcesIds(client) + _, _, envId, err := getOrganizationProjectEnvironmentContextResourcesIds(client) if err != nil { utils.PrintlnError(err) diff --git a/cmd/lifecycle_env_create.go b/cmd/lifecycle_env_create.go index 69aa63c0..4c8521ab 100644 --- a/cmd/lifecycle_env_create.go +++ b/cmd/lifecycle_env_create.go @@ -24,7 +24,7 @@ var lifecycleEnvCreateCmd = &cobra.Command{ } client := utils.GetQoveryClient(tokenType, token) - _, projectId, envId, err := getOrganizationProjectEnvironmentContextResourcesIds(client) + _, _, envId, err := getOrganizationProjectEnvironmentContextResourcesIds(client) if err != nil { utils.PrintlnError(err) @@ -49,20 +49,7 @@ var lifecycleEnvCreateCmd = &cobra.Command{ panic("unreachable") // staticcheck false positive: https://staticcheck.io/docs/checks#SA5011 } - if utils.IsSecret { - err = utils.CreateSecret(client, projectId, envId, lifecycle.LifecycleJobResponse.Id, utils.Key, utils.Value, utils.JobScope) - - if err != nil { - utils.PrintlnError(err) - os.Exit(1) - panic("unreachable") // staticcheck false positive: https://staticcheck.io/docs/checks#SA5011 - } - - utils.Println(fmt.Sprintf("Secret %s has been created", pterm.FgBlue.Sprintf(utils.Key))) - return - } - - err = utils.CreateEnvironmentVariable(client, projectId, envId, lifecycle.LifecycleJobResponse.Id, utils.Key, utils.Value, utils.JobScope) + err = utils.CreateEnvironmentVariable(client, lifecycle.LifecycleJobResponse.Id, utils.JobScope, utils.Key, utils.Value, utils.IsSecret) if err != nil { utils.PrintlnError(err) diff --git a/cmd/lifecycle_env_delete.go b/cmd/lifecycle_env_delete.go index 092d186e..42429766 100644 --- a/cmd/lifecycle_env_delete.go +++ b/cmd/lifecycle_env_delete.go @@ -24,7 +24,7 @@ var lifecycleEnvDeleteCmd = &cobra.Command{ } client := utils.GetQoveryClient(tokenType, token) - _, projectId, envId, err := getOrganizationProjectEnvironmentContextResourcesIds(client) + _, _, envId, err := getOrganizationProjectEnvironmentContextResourcesIds(client) if err != nil { utils.PrintlnError(err) @@ -49,7 +49,7 @@ var lifecycleEnvDeleteCmd = &cobra.Command{ panic("unreachable") // staticcheck false positive: https://staticcheck.io/docs/checks#SA5011 } - err = utils.DeleteByKey(client, projectId, envId, lifecycle.LifecycleJobResponse.Id, utils.JobType, utils.Key) + err = utils.DeleteVariable(client, lifecycle.LifecycleJobResponse.Id, utils.JobType, utils.Key) if err != nil { utils.PrintlnError(err) diff --git a/cmd/lifecycle_env_list.go b/cmd/lifecycle_env_list.go index 1fd640b8..6a7c60a3 100644 --- a/cmd/lifecycle_env_list.go +++ b/cmd/lifecycle_env_list.go @@ -49,21 +49,11 @@ var lifecycleEnvListCmd = &cobra.Command{ panic("unreachable") // staticcheck false positive: https://staticcheck.io/docs/checks#SA5011 } - envVars, _, err := client.JobEnvironmentVariableAPI.ListJobEnvironmentVariable( - context.Background(), + envVars, err := utils.ListEnvironmentVariables( + client, lifecycle.LifecycleJobResponse.Id, - ).Execute() - - if err != nil { - utils.PrintlnError(err) - os.Exit(1) - panic("unreachable") // staticcheck false positive: https://staticcheck.io/docs/checks#SA5011 - } - - secrets, _, err := client.JobSecretAPI.ListJobSecrets( - context.Background(), - lifecycle.LifecycleJobResponse.Id, - ).Execute() + utils.JobType, + ) if err != nil { utils.PrintlnError(err) @@ -74,18 +64,12 @@ var lifecycleEnvListCmd = &cobra.Command{ envVarLines := utils.NewEnvVarLines() var variables []utils.EnvVarLineOutput - for _, envVar := range envVars.GetResults() { + for _, envVar := range envVars { s := utils.FromEnvironmentVariableToEnvVarLineOutput(envVar) variables = append(variables, s) envVarLines.Add(s) } - for _, secret := range secrets.GetResults() { - s := utils.FromSecretToEnvVarLineOutput(secret) - variables = append(variables, s) - envVarLines.Add(s) - } - if jsonFlag { utils.Println(utils.GetEnvVarJsonOutput(variables)) return diff --git a/cmd/lifecycle_env_override_create.go b/cmd/lifecycle_env_override_create.go index 9669752c..dfc66d21 100644 --- a/cmd/lifecycle_env_override_create.go +++ b/cmd/lifecycle_env_override_create.go @@ -49,7 +49,7 @@ var lifecycleEnvOverrideCreateCmd = &cobra.Command{ panic("unreachable") // staticcheck false positive: https://staticcheck.io/docs/checks#SA5011 } - err = utils.CreateOverride(client, projectId, envId, lifecycle.LifecycleJobResponse.Id, utils.JobType, utils.Key, &utils.Value, utils.JobScope) + err = utils.CreateOverride(client, projectId, envId, lifecycle.LifecycleJobResponse.Id, utils.JobType, utils.Key, utils.Value, utils.JobScope) if err != nil { utils.PrintlnError(err) @@ -73,4 +73,5 @@ func init() { _ = lifecycleEnvOverrideCreateCmd.MarkFlagRequired("key") _ = lifecycleEnvOverrideCreateCmd.MarkFlagRequired("lifecycle") + _ = lifecycleEnvOverrideCreateCmd.MarkFlagRequired("value") } diff --git a/go.mod b/go.mod index e5b48845..ff057c4c 100644 --- a/go.mod +++ b/go.mod @@ -19,7 +19,7 @@ require ( github.com/pkg/errors v0.9.1 github.com/posthog/posthog-go v0.0.0-20221221115252-24dfed35d71a github.com/pterm/pterm v0.12.55 - github.com/qovery/qovery-client-go v0.0.0-20231219130711-1b52194296f5 + github.com/qovery/qovery-client-go v0.0.0-20231222093609-d7ae5a912bea github.com/sirupsen/logrus v1.9.0 github.com/spf13/cobra v1.6.1 github.com/spf13/pflag v1.0.5 diff --git a/go.sum b/go.sum index 3cff2815..63ac30e8 100644 --- a/go.sum +++ b/go.sum @@ -192,6 +192,8 @@ github.com/qovery/qovery-client-go v0.0.0-20231218142939-5f77c5a27bb7 h1:FukfJyZ github.com/qovery/qovery-client-go v0.0.0-20231218142939-5f77c5a27bb7/go.mod h1:5QD7sC1Z6XCCYd31c4XKVwGdEOjvtgG0NDcaVDoWb+o= github.com/qovery/qovery-client-go v0.0.0-20231219130711-1b52194296f5 h1:uTmfOdyWH7/Ldf/LT3X/P0OlBg9J8Pe9PWR8MbdaWao= github.com/qovery/qovery-client-go v0.0.0-20231219130711-1b52194296f5/go.mod h1:5QD7sC1Z6XCCYd31c4XKVwGdEOjvtgG0NDcaVDoWb+o= +github.com/qovery/qovery-client-go v0.0.0-20231222093609-d7ae5a912bea h1:/MLgKpXXPqTJBclZ1kFbC42BXQjl77+COijlmiFpnBg= +github.com/qovery/qovery-client-go v0.0.0-20231222093609-d7ae5a912bea/go.mod h1:5QD7sC1Z6XCCYd31c4XKVwGdEOjvtgG0NDcaVDoWb+o= github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc= github.com/rivo/uniseg v0.4.4 h1:8TfxU8dW6PdqD27gjM8MVNuicgxIjxpm4K7x4jp8sis= github.com/rivo/uniseg v0.4.4/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88= diff --git a/utils/env_var.go b/utils/env_var.go index 38664e76..635d78d1 100644 --- a/utils/env_var.go +++ b/utils/env_var.go @@ -18,6 +18,7 @@ var IsSecret bool var ApplicationScope string var JobScope string var ContainerScope string +var HelmScope string var Alias string var Key string var Value string @@ -122,7 +123,7 @@ func (e EnvVarLineOutput) Data(showValues bool) []string { return []string{e.Key, keyType, parentKey, value, e.UpdatedAt.Format(time.RFC822), service, e.Scope} } -func FromEnvironmentVariableToEnvVarLineOutput(envVar qovery.EnvironmentVariable) EnvVarLineOutput { +func FromEnvironmentVariableToEnvVarLineOutput(envVar qovery.VariableResponse) EnvVarLineOutput { var aliasParentKey *string if envVar.AliasedVariable != nil { aliasParentKey = &envVar.AliasedVariable.Key @@ -133,40 +134,20 @@ func FromEnvironmentVariableToEnvVarLineOutput(envVar qovery.EnvironmentVariable overrideParentKey = &envVar.OverriddenVariable.Key } + var value *string + if envVar.Value.IsSet() { + value = envVar.Value.Get() + } + return EnvVarLineOutput{ Id: envVar.Id, Key: envVar.Key, - Value: envVar.Value, + Value: value, CreatedAt: envVar.CreatedAt, UpdatedAt: envVar.UpdatedAt, Service: envVar.ServiceName, Scope: string(envVar.Scope), - IsSecret: false, - AliasParentKey: aliasParentKey, - OverrideParentKey: overrideParentKey, - } -} - -func FromSecretToEnvVarLineOutput(secret qovery.Secret) EnvVarLineOutput { - var aliasParentKey *string - if secret.AliasedSecret != nil { - aliasParentKey = &secret.AliasedSecret.Key - } - - var overrideParentKey *string - if secret.OverriddenSecret != nil { - overrideParentKey = &secret.OverriddenSecret.Key - } - - return EnvVarLineOutput{ - Id: secret.Id, - Key: secret.Key, - Value: nil, - CreatedAt: secret.CreatedAt, - UpdatedAt: secret.UpdatedAt, - Service: secret.ServiceName, - Scope: string(secret.Scope), - IsSecret: true, + IsSecret: envVar.IsSecret, AliasParentKey: aliasParentKey, OverrideParentKey: overrideParentKey, } @@ -174,117 +155,32 @@ func FromSecretToEnvVarLineOutput(secret qovery.Secret) EnvVarLineOutput { func CreateEnvironmentVariable( client *qovery.APIClient, - projectId string, - environmentId string, - serviceId string, + parentId string, + scope string, key string, value string, - scope string, + isSecret bool, ) error { - req := qovery.EnvironmentVariableRequest{ - Key: key, - Value: &value, - MountPath: qovery.NullableString{}, - } - - switch strings.ToUpper(scope) { - case "PROJECT": - _, _, err := client.ProjectEnvironmentVariableAPI.CreateProjectEnvironmentVariable( - context.Background(), - projectId, - ).EnvironmentVariableRequest(req).Execute() - - return err - case "ENVIRONMENT": - _, _, err := client.EnvironmentVariableAPI.CreateEnvironmentEnvironmentVariable( - context.Background(), - environmentId, - ).EnvironmentVariableRequest(req).Execute() - - return err - case "APPLICATION": - _, _, err := client.ApplicationEnvironmentVariableAPI.CreateApplicationEnvironmentVariable( - context.Background(), - serviceId, - ).EnvironmentVariableRequest(req).Execute() - - return err - case "JOB": - _, _, err := client.JobEnvironmentVariableAPI.CreateJobEnvironmentVariable( - context.Background(), - serviceId, - ).EnvironmentVariableRequest(req).Execute() - - return err - case "CONTAINER": - _, _, err := client.ContainerEnvironmentVariableAPI.CreateContainerEnvironmentVariable( - context.Background(), - serviceId, - ).EnvironmentVariableRequest(req).Execute() + variableScope, err := VariableScopeFrom(scope) + if err != nil { return err } - return errors.New("invalid scope") -} - -func CreateSecret( - client *qovery.APIClient, - projectId string, - environmentId string, - serviceId string, - key string, - value string, - scope string, -) error { - req := qovery.SecretRequest{ + variableRequest := qovery.VariableRequest{ Key: key, - Value: &value, + Value: value, MountPath: qovery.NullableString{}, + IsSecret: isSecret, + VariableScope: variableScope, + VariableParentId: parentId, } - switch strings.ToUpper(scope) { - case "PROJECT": - _, _, err := client.ProjectSecretAPI.CreateProjectSecret( - context.Background(), - projectId, - ).SecretRequest(req).Execute() - - return err - case "ENVIRONMENT": - _, _, err := client.EnvironmentSecretAPI.CreateEnvironmentSecret( - context.Background(), - environmentId, - ).SecretRequest(req).Execute() - - return err - case "APPLICATION": - _, _, err := client.ApplicationSecretAPI.CreateApplicationSecret( - context.Background(), - serviceId, - ).SecretRequest(req).Execute() - - return err - case "JOB": - _, _, err := client.JobSecretAPI.CreateJobSecret( - context.Background(), - serviceId, - ).SecretRequest(req).Execute() - - return err - case "CONTAINER": - _, _, err := client.ContainerSecretAPI.CreateContainerSecret( - context.Background(), - serviceId, - ).SecretRequest(req).Execute() - - return err - } - - return errors.New("invalid scope") + _, _, err = client.VariableMainCallsAPI.CreateVariable(context.Background()).VariableRequest(variableRequest).Execute() + return err } -func FindEnvironmentVariableByKey(key string, envVars []qovery.EnvironmentVariable) *qovery.EnvironmentVariable { +func FindEnvironmentVariableByKey(key string, envVars []qovery.VariableResponse) *qovery.VariableResponse { for _, envVar := range envVars { if envVar.Key == key { return &envVar @@ -294,355 +190,118 @@ func FindEnvironmentVariableByKey(key string, envVars []qovery.EnvironmentVariab return nil } -func FindSecretByKey(key string, secrets []qovery.Secret) *qovery.Secret { - for _, secret := range secrets { - if secret.Key == key { - return &secret - } - } - - return nil -} - func ListEnvironmentVariables( client *qovery.APIClient, serviceId string, serviceType ServiceType, -) ([]qovery.EnvironmentVariable, error) { - var res *qovery.EnvironmentVariableResponseList - - switch serviceType { - case ApplicationType: - r, _, err := client.ApplicationEnvironmentVariableAPI.ListApplicationEnvironmentVariable(context.Background(), serviceId).Execute() - if err != nil { - return nil, err - } - - res = r - case ContainerType: - r, _, err := client.ContainerEnvironmentVariableAPI.ListContainerEnvironmentVariable(context.Background(), serviceId).Execute() - if err != nil { - return nil, err - } - - res = r - case JobType: - r, _, err := client.JobEnvironmentVariableAPI.ListJobEnvironmentVariable(context.Background(), serviceId).Execute() - if err != nil { - return nil, err - } +) ([]qovery.VariableResponse, error) { + scope, err := ServiceTypeToScope(serviceType) + if err != nil { + return nil, err + } - res = r + request := client.VariableMainCallsAPI.ListVariables(context.Background()) + res, _, err := request.ParentId(serviceId).Scope(scope).Execute() + if err != nil { + return nil, err } if res == nil { return nil, errors.New("invalid service type") } - - return res.Results, nil + + return res.GetResults(), nil } -func ListSecrets( - client *qovery.APIClient, - serviceId string, - serviceType ServiceType, -) ([]qovery.Secret, error) { - var res *qovery.SecretResponseList - +func ServiceTypeToScope(serviceType ServiceType) (qovery.APIVariableScopeEnum, error) { switch serviceType { case ApplicationType: - r, _, err := client.ApplicationSecretAPI.ListApplicationSecrets(context.Background(), serviceId).Execute() - if err != nil { - return nil, err - } - - res = r + return qovery.APIVARIABLESCOPEENUM_APPLICATION, nil case ContainerType: - r, _, err := client.ContainerSecretAPI.ListContainerSecrets(context.Background(), serviceId).Execute() - if err != nil { - return nil, err - } - - res = r + return qovery.APIVARIABLESCOPEENUM_CONTAINER, nil case JobType: - r, _, err := client.JobSecretAPI.ListJobSecrets(context.Background(), serviceId).Execute() - if err != nil { - return nil, err - } - - res = r + return qovery.APIVARIABLESCOPEENUM_JOB, nil + case HelmType: + return qovery.APIVARIABLESCOPEENUM_HELM, nil } - if res == nil { - return nil, errors.New("invalid service type") - } - - return res.Results, nil + return qovery.APIVARIABLESCOPEENUM_BUILT_IN, fmt.Errorf("the service type %s is not supported", serviceType) } -func DeleteEnvironmentVariableByKey( - client *qovery.APIClient, - projectId string, - environmentId string, - serviceId string, - serviceType ServiceType, - key string, -) error { - envVars, err := ListEnvironmentVariables(client, serviceId, serviceType) - if err != nil { - return err - } - - envVar := FindEnvironmentVariableByKey(key, envVars) - - if envVar == nil { - return fmt.Errorf("environment variable %s not found", pterm.FgRed.Sprintf(key)) - } - - switch string(envVar.Scope) { - case "PROJECT": - _, err := client.ProjectEnvironmentVariableAPI.DeleteProjectEnvironmentVariable( - context.Background(), - projectId, - envVar.Id, - ).Execute() - - return err - case "ENVIRONMENT": - _, err := client.EnvironmentVariableAPI.DeleteEnvironmentEnvironmentVariable( - context.Background(), - environmentId, - envVar.Id, - ).Execute() - - return err +func VariableScopeFrom(scope string) (qovery.APIVariableScopeEnum, error) { + switch scope { case "APPLICATION": - _, err := client.ApplicationEnvironmentVariableAPI.DeleteApplicationEnvironmentVariable( - context.Background(), - serviceId, - envVar.Id, - ).Execute() - - return err - case "JOB": - _, err := client.JobEnvironmentVariableAPI.DeleteJobEnvironmentVariable( - context.Background(), - serviceId, - envVar.Id, - ).Execute() - - return err + return qovery.APIVARIABLESCOPEENUM_APPLICATION, nil + case "BUILT_IN": + return qovery.APIVARIABLESCOPEENUM_BUILT_IN, nil + case "ENVIRONMENT": + return qovery.APIVARIABLESCOPEENUM_ENVIRONMENT, nil + case "PROJECT": + return qovery.APIVARIABLESCOPEENUM_PROJECT, nil case "CONTAINER": - _, err := client.ContainerEnvironmentVariableAPI.DeleteContainerEnvironmentVariable( - context.Background(), - serviceId, - envVar.Id, - ).Execute() - - return err + return qovery.APIVARIABLESCOPEENUM_CONTAINER, nil + case "JOB": + return qovery.APIVARIABLESCOPEENUM_JOB, nil + case "HELM": + return qovery.APIVARIABLESCOPEENUM_HELM, nil } - - return errors.New("invalid scope") + return qovery.APIVARIABLESCOPEENUM_BUILT_IN, fmt.Errorf("the scope %s is not supported", scope) } -func DeleteSecretByKey( - client *qovery.APIClient, - projectId string, - environmentId string, - serviceId string, - serviceType ServiceType, - key string, -) error { - secrets, err := ListSecrets(client, serviceId, serviceType) - if err != nil { - return err - } - - secret := FindSecretByKey(key, secrets) - - if secret == nil { - return fmt.Errorf("secret %s not found", pterm.FgRed.Sprintf(key)) - } - - switch string(secret.Scope) { +func getParentIdByScope(scope string, projectId string, environmentId string, serviceId string) (string, qovery.APIVariableScopeEnum, error) { + switch scope { case "PROJECT": - _, err := client.ProjectSecretAPI.DeleteProjectSecret( - context.Background(), - projectId, - secret.Id, - ).Execute() - - return err + return projectId, qovery.APIVARIABLESCOPEENUM_PROJECT, nil case "ENVIRONMENT": - _, err := client.EnvironmentVariableAPI.DeleteEnvironmentEnvironmentVariable( - context.Background(), - environmentId, - secret.Id, - ).Execute() - - return err - case "APPLICATION": - _, err := client.ApplicationSecretAPI.DeleteApplicationSecret( - context.Background(), - serviceId, - secret.Id, - ).Execute() - - return err - case "JOB": - _, err := client.JobSecretAPI.DeleteJobSecret( - context.Background(), - serviceId, - secret.Id, - ).Execute() - - return err + return environmentId, qovery.APIVARIABLESCOPEENUM_ENVIRONMENT, nil + case "APPLICATION":return serviceId, qovery.APIVARIABLESCOPEENUM_APPLICATION, nil case "CONTAINER": - _, err := client.ContainerSecretAPI.DeleteContainerSecret( - context.Background(), - serviceId, - secret.Id, - ).Execute() - - return err + return serviceId, qovery.APIVARIABLESCOPEENUM_CONTAINER, nil + case "JOB": + return serviceId, qovery.APIVARIABLESCOPEENUM_JOB, nil + case "HELM": + return serviceId, qovery.APIVARIABLESCOPEENUM_HELM, nil } - return errors.New("invalid scope") + return "", qovery.APIVARIABLESCOPEENUM_BUILT_IN, fmt.Errorf("scope %s not supported", scope) } -func DeleteByKey( +func DeleteVariable( client *qovery.APIClient, - projectId string, - environmentId string, serviceId string, serviceType ServiceType, key string, ) error { - err := DeleteEnvironmentVariableByKey(client, projectId, environmentId, serviceId, serviceType, key) - if err == nil { - return nil + + envVars, err := ListEnvironmentVariables(client, serviceId, serviceType) + if err != nil { + return err } - err = DeleteSecretByKey(client, projectId, environmentId, serviceId, serviceType, key) - if err == nil { - return nil + envVar := FindEnvironmentVariableByKey(key, envVars) + if envVar == nil { + return fmt.Errorf("environment variable %s not found", pterm.FgRed.Sprintf(key)) } - return fmt.Errorf("environment variable or secret %s not found", pterm.FgRed.Sprintf(key)) + _, err = client.VariableMainCallsAPI.DeleteVariable(context.Background(), envVar.Id).Execute() + return err } func CreateEnvironmentVariableAlias( client *qovery.APIClient, - projectId string, - environmentId string, - serviceId string, - parentEnvironmentVariableId string, + aliasParentId string, + aliasScope qovery.APIVariableScopeEnum, + variableId string, alias string, - scope string, ) error { - key := *qovery.NewKey(alias) - - switch strings.ToUpper(scope) { - case "PROJECT": - _, _, err := client.ProjectEnvironmentVariableAPI.CreateProjectEnvironmentVariableAlias( - context.Background(), - projectId, - parentEnvironmentVariableId, - ).Key(key).Execute() - - return err - case "ENVIRONMENT": - _, _, err := client.EnvironmentVariableAPI.CreateEnvironmentEnvironmentVariableAlias( - context.Background(), - environmentId, - parentEnvironmentVariableId, - ).Key(key).Execute() - - return err - case "APPLICATION": - _, _, err := client.ApplicationEnvironmentVariableAPI.CreateApplicationEnvironmentVariableAlias( - context.Background(), - serviceId, - parentEnvironmentVariableId, - ).Key(key).Execute() - - return err - case "JOB": - _, _, err := client.JobEnvironmentVariableAPI.CreateJobEnvironmentVariableAlias( - context.Background(), - serviceId, - parentEnvironmentVariableId, - ).Key(key).Execute() - - return err - case "CONTAINER": - _, _, err := client.ContainerEnvironmentVariableAPI.CreateContainerEnvironmentVariableAlias( - context.Background(), - serviceId, - parentEnvironmentVariableId, - ).Key(key).Execute() - - return err + variableAliasRequest := qovery.VariableAliasRequest{ + Key: alias, + AliasScope: aliasScope, + AliasParentId: aliasParentId, } - return errors.New("invalid scope") -} - -func CreateSecretAlias( - client *qovery.APIClient, - projectId string, - environmentId string, - serviceId string, - parentSecretId string, - alias string, - scope string, -) error { - key := *qovery.NewKey(alias) - - switch strings.ToUpper(scope) { - case "PROJECT": - _, _, err := client.ProjectSecretAPI.CreateProjectSecretAlias( - context.Background(), - projectId, - parentSecretId, - ).Key(key).Execute() - - return err - case "ENVIRONMENT": - _, _, err := client.EnvironmentSecretAPI.CreateEnvironmentSecretAlias( - context.Background(), - environmentId, - parentSecretId, - ).Key(key).Execute() - - return err - case "APPLICATION": - _, _, err := client.ApplicationSecretAPI.CreateApplicationSecretAlias( - context.Background(), - serviceId, - parentSecretId, - ).Key(key).Execute() - - return err - case "JOB": - _, _, err := client.JobSecretAPI.CreateJobSecretAlias( - context.Background(), - serviceId, - parentSecretId, - ).Key(key).Execute() - - return err - case "CONTAINER": - _, _, err := client.ContainerSecretAPI.CreateContainerSecretAlias( - context.Background(), - serviceId, - parentSecretId, - ).Key(key).Execute() - - return err - } - - return errors.New("invalid scope") + _, _, err := client.VariableMainCallsAPI.CreateVariableAlias(context.Background(), variableId).VariableAliasRequest(variableAliasRequest).Execute() + return err } func CreateAlias( @@ -662,20 +321,14 @@ func CreateAlias( envVar := FindEnvironmentVariableByKey(key, envVars) - if envVar != nil { - // create alias for environment variable - return CreateEnvironmentVariableAlias(client, projectId, environmentId, serviceId, envVar.Id, alias, scope) - } - - secrets, err := ListSecrets(client, serviceId, serviceType) + parentId, parentScope, err := getParentIdByScope(scope, projectId, environmentId, serviceId) if err != nil { return err } - secret := FindSecretByKey(key, secrets) - if secret != nil { - // create alias for secret - return CreateSecretAlias(client, projectId, environmentId, serviceId, secret.Id, alias, scope) + if envVar != nil { + // create alias for environment variable + return CreateEnvironmentVariableAlias(client, parentId, parentScope, envVar.Id, alias) } return fmt.Errorf("Environment variable or secret %s not found", pterm.FgRed.Sprintf(key)) @@ -683,122 +336,19 @@ func CreateAlias( func CreateEnvironmentVariableOverride( client *qovery.APIClient, - projectId string, - environmentId string, - serviceId string, - parentEnvironmentVariableId string, - value *string, - scope string, -) error { - v := *qovery.NewValue() - if value != nil { - v.SetValue(*value) - } - - switch strings.ToUpper(scope) { - case "PROJECT": - _, _, err := client.ProjectEnvironmentVariableAPI.CreateProjectEnvironmentVariableOverride( - context.Background(), - projectId, - parentEnvironmentVariableId, - ).Value(v).Execute() - - return err - case "ENVIRONMENT": - _, _, err := client.EnvironmentVariableAPI.CreateEnvironmentEnvironmentVariableOverride( - context.Background(), - environmentId, - parentEnvironmentVariableId, - ).Value(v).Execute() - - return err - case "APPLICATION": - _, _, err := client.ApplicationEnvironmentVariableAPI.CreateApplicationEnvironmentVariableOverride( - context.Background(), - serviceId, - parentEnvironmentVariableId, - ).Value(v).Execute() - - return err - case "JOB": - _, _, err := client.JobEnvironmentVariableAPI.CreateJobEnvironmentVariableOverride( - context.Background(), - serviceId, - parentEnvironmentVariableId, - ).Value(v).Execute() - - return err - case "CONTAINER": - _, _, err := client.ContainerEnvironmentVariableAPI.CreateContainerEnvironmentVariableOverride( - context.Background(), - serviceId, - parentEnvironmentVariableId, - ).Value(v).Execute() - - return err - } - - return errors.New("invalid scope") -} - -func CreateSecretOverride( - client *qovery.APIClient, - projectId string, - environmentId string, - serviceId string, - parentSecretId string, - value *string, - scope string, + overrideParentId string, + overrideScope qovery.APIVariableScopeEnum, + variableId string, + value string, ) error { - v := *qovery.NewValue() - if value != nil { - v.SetValue(*value) - } - - switch strings.ToUpper(scope) { - case "PROJECT": - _, _, err := client.ProjectSecretAPI.CreateProjectSecretOverride( - context.Background(), - projectId, - parentSecretId, - ).Value(v).Execute() - - return err - case "ENVIRONMENT": - _, _, err := client.EnvironmentSecretAPI.CreateEnvironmentSecretOverride( - context.Background(), - environmentId, - parentSecretId, - ).Value(v).Execute() - - return err - case "APPLICATION": - _, _, err := client.ApplicationSecretAPI.CreateApplicationSecretOverride( - context.Background(), - serviceId, - parentSecretId, - ).Value(v).Execute() - - return err - case "JOB": - _, _, err := client.JobSecretAPI.CreateJobSecretOverride( - context.Background(), - serviceId, - parentSecretId, - ).Value(v).Execute() - - return err - case "CONTAINER": - _, _, err := client.ContainerSecretAPI.CreateContainerSecretOverride( - context.Background(), - serviceId, - parentSecretId, - ).Value(v).Execute() - - return err + variableOverrideRequest := qovery.VariableOverrideRequest{ + Value: value, + OverrideScope: overrideScope, + OverrideParentId: overrideParentId, } - return errors.New("invalid scope") + _, _, err := client.VariableMainCallsAPI.CreateVariableOverride(context.Background(), variableId).VariableOverrideRequest(variableOverrideRequest).Execute() + return err } func CreateOverride( @@ -808,7 +358,7 @@ func CreateOverride( serviceId string, serviceType ServiceType, key string, - value *string, + value string, scope string, ) error { envVars, err := ListEnvironmentVariables(client, serviceId, serviceType) @@ -818,18 +368,14 @@ func CreateOverride( envVar := FindEnvironmentVariableByKey(key, envVars) - if envVar != nil { - return CreateEnvironmentVariableOverride(client, projectId, environmentId, serviceId, envVar.Id, value, scope) - } - - secrets, err := ListSecrets(client, serviceId, serviceType) + parentId, parentScope, err := getParentIdByScope(scope, projectId, environmentId, serviceId) if err != nil { return err } - secret := FindSecretByKey(key, secrets) - if secret != nil { - return CreateSecretOverride(client, projectId, environmentId, serviceId, secret.Id, value, scope) + if envVar != nil { + // create override for environment variable + return CreateEnvironmentVariableOverride(client, parentId, parentScope, envVar.Id, value) } return fmt.Errorf("Environment variable or secret %s not found", pterm.FgRed.Sprintf(key))