[PRDGRO-2070] Services Create Non-Interactive Command (#311)

* create types for runtime, envvars, region, secretfile and servicetype to help with validation of service create params

* Add a service type to validate and normalize cli input

* Create a registry helper to get registry creds by name or id

* Helper to get a service by it's name or id

* Secret file helper to read file from disk

* Use the service type to build a service create request

* Populate a service from the api so we can 'clone' an existing service

* Add support for string arrays, we need them for envvars

* Wire it all up in a command

* Alias service to services

* RegistryCredential can also be set for the docker runtime

* Rename to ParseOption to hopfully be a little clearer to future readers

* Better seperation of concerns in clone.go extract values from the api serivce then apply them to empty input fields

GitOrigin-RevId: 6e2cd0501061f0e8840c0041b1110e23bbbda642

Author: mosslilley

cmd/service.go

@@ -26,8 +26,9 @@ import (
 )
 
 var servicesCmd = &cobra.Command{
-	Use:   "services",
-	Short: "Manage services and datastores",
+	Use:     "services",
+	Aliases: []string{"service"},
+	Short:   "Manage services and datastores",
 	Long: `Manage services and datastores for the active workspace.
 In interactive mode you can view logs, restart, deploy, SSH, and open PSQL sessions.`,
 	GroupID: GroupCore.ID,

cmd/servicecreate.go

@@ -0,0 +1,143 @@
+package cmd
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/spf13/cobra"
+
+	"github.com/render-oss/cli/pkg/client"
+	"github.com/render-oss/cli/pkg/command"
+	"github.com/render-oss/cli/pkg/config"
+	"github.com/render-oss/cli/pkg/dependencies"
+	"github.com/render-oss/cli/pkg/service"
+	"github.com/render-oss/cli/pkg/text"
+	"github.com/render-oss/cli/pkg/types"
+	servicetypes "github.com/render-oss/cli/pkg/types/service"
+)
+
+var ServiceCreateCmd = &cobra.Command{
+	Use:   "create",
+	Args:  cobra.NoArgs,
+	Short: "Create a new service",
+	Long: `Create a new service on Render.
+
+This command currently runs in non-interactive mode only.
+Provide all config with flags.
+
+Examples:
+  render services create --name my-api --type web_service --repo https://github.com/org/repo --output json
+  render services create --from srv-abc123 --name my-api-clone --output json
+`,
+}
+
+func init() {
+	servicesCmd.AddCommand(ServiceCreateCmd)
+
+	ServiceCreateCmd.RunE = func(cmd *cobra.Command, args []string) error {
+		var cliInput servicetypes.Service
+		if err := command.ParseCommand(cmd, args, &cliInput); err != nil {
+			return fmt.Errorf("failed to parse command: %w", err)
+		}
+
+		// Interactive mode is not implemented yet; force non-interactive behavior for now.
+		command.DefaultFormatNonInteractive(cmd)
+
+		ctx := cmd.Context()
+
+		nonInteractive, err := command.NonInteractive(cmd, func() (*client.Service, error) {
+			return createServiceNonInteractive(ctx, cliInput)
+		}, func(svc *client.Service) string {
+			return text.FormatStringF("Created service %s (%s)", svc.Name, svc.Id)
+		})
+		if err != nil {
+			return err
+		}
+		if nonInteractive {
+			return nil
+		}
+
+		// TODO: Implement interactive TUI mode in a later phase
+		// This will use views.NewServiceCreateView for guided configuration
+		return fmt.Errorf("interactive mode not yet implemented")
+	}
+
+	ServiceCreateCmd.Flags().String("name", "", "Service name")
+	serviceTypeFlag := command.NewEnumInput(servicetypes.ServiceTypeValues(), false)
+	ServiceCreateCmd.Flags().Var(serviceTypeFlag, "type", "Service type")
+	ServiceCreateCmd.Flags().String("from", "", "Clone configuration from existing service (ID or name). Other flags override cloned values.")
+	ServiceCreateCmd.Flags().String("repo", "", "Git repository URL")
+	ServiceCreateCmd.Flags().String("branch", "", "Git branch")
+	ServiceCreateCmd.Flags().String("image", "", "Docker image URL")
+	regionFlag := command.NewEnumInput(types.RegionValues(), false)
+	ServiceCreateCmd.Flags().Var(regionFlag, "region", "Deployment region")
+	ServiceCreateCmd.Flags().String("plan", "", "Service plan")
+	runtimeFlag := command.NewEnumInput(servicetypes.ServiceRuntimeValues(), false)
+	ServiceCreateCmd.Flags().Var(runtimeFlag, "runtime", "Runtime environment")
+	ServiceCreateCmd.Flags().String("root-directory", "", "Root directory")
+	ServiceCreateCmd.Flags().String("build-command", "", "Build command")
+	ServiceCreateCmd.Flags().String("start-command", "", "Start command")
+	ServiceCreateCmd.Flags().String("health-check-path", "", "Health check path")
+	ServiceCreateCmd.Flags().String("publish-directory", "", "Publish directory")
+	ServiceCreateCmd.Flags().String("cron-command", "", "Cron command")
+	ServiceCreateCmd.Flags().String("cron-schedule", "", "Cron schedule")
+	ServiceCreateCmd.Flags().String("environment-id", "", "Environment ID")
+	ServiceCreateCmd.Flags().StringArray("env-var", nil, "Environment variable in KEY=VALUE format (can be specified multiple times)")
+	ServiceCreateCmd.Flags().StringArray("secret-file", nil, "Secret file in NAME:LOCAL_PATH format (can be specified multiple times)")
+	ServiceCreateCmd.Flags().String("registry-credential", "", "Registry credential")
+	ServiceCreateCmd.Flags().Bool("auto-deploy", true, "Enable auto-deploy")
+	ServiceCreateCmd.Flags().String("pre-deploy-command", "", "Pre-deploy command")
+}
+
+func createServiceNonInteractive(ctx context.Context, cliInput servicetypes.Service) (*client.Service, error) {
+	deps := dependencies.GetFromContext(ctx)
+	serviceRepo := deps.ServiceRepo()
+	registryService := deps.RegistryService()
+
+	ownerID, err := config.WorkspaceID()
+	if err != nil {
+		return nil, err
+	}
+
+	cliInput = servicetypes.NormalizeServiceCreateCLIInput(cliInput)
+
+	if cliInput.From != nil {
+		if err := getConfigFromService(ctx, serviceRepo, &cliInput); err != nil {
+			return nil, fmt.Errorf("failed to clone configuration from source service %q: %w", *cliInput.From, err)
+		}
+	}
+
+	cliInput, err = servicetypes.NormalizeAndValidateCreateInput(cliInput, false)
+	if err != nil {
+		return nil, err
+	}
+
+	if cliInput.RegistryCredential != nil && cliInput.SupportsRegistryCredentials() {
+		registryCredentialID, err := registryService.FindOneRegistryCredentialByIDFromNameOrID(ctx, ownerID, *cliInput.RegistryCredential)
+		if err != nil {
+			return nil, err
+		}
+		cliInput.RegistryCredential = &registryCredentialID
+	}
+
+	body, err := service.BuildCreateRequest(cliInput, ownerID)
+	if err != nil {
+		return nil, err
+	}
+	return serviceRepo.CreateService(ctx, body)
+}
+
+func getConfigFromService(ctx context.Context, repo *service.Repo, input *servicetypes.Service) error {
+	serviceID, err := repo.ResolveServiceIDFromNameOrID(ctx, *input.From)
+	if err != nil {
+		return fmt.Errorf("failed to resolve source service %s: %w", *input.From, err)
+	}
+	input.From = &serviceID
+
+	sourceService, err := repo.GetService(ctx, serviceID)
+	if err != nil {
+		return fmt.Errorf("failed to load source service %s: %w", serviceID, err)
+	}
+	service.ServiceFromAPI(input, sourceService)
+	return nil
+}

cmd/servicecreate_test.go

@@ -0,0 +1,40 @@
+package cmd
+
+import (
+	"testing"
+
+	"github.com/spf13/cobra"
+	"github.com/stretchr/testify/require"
+)
+
+func TestServiceCreateCmdRejectsPositionalArgs(t *testing.T) {
+	require.Error(t, ServiceCreateCmd.Args(ServiceCreateCmd, []string{"unexpected"}))
+	require.NoError(t, ServiceCreateCmd.Args(ServiceCreateCmd, []string{}))
+}
+
+func TestServiceAliasResolvesToCreateCommand(t *testing.T) {
+	plural, _, err := rootCmd.Find([]string{"services", "create"})
+	require.NoError(t, err)
+	require.Same(t, ServiceCreateCmd, plural)
+
+	alias, _, err := rootCmd.Find([]string{"service", "create"})
+	require.NoError(t, err)
+	require.Same(t, ServiceCreateCmd, alias)
+}
+
+func TestServiceCreateNoArgsValidationPreventsExecution(t *testing.T) {
+	called := false
+	cmd := &cobra.Command{
+		Use:  "create",
+		Args: ServiceCreateCmd.Args,
+		RunE: func(_ *cobra.Command, _ []string) error {
+			called = true
+			return nil
+		},
+	}
+	cmd.SetArgs([]string{"unexpected"})
+
+	err := cmd.Execute()
+	require.Error(t, err)
+	require.False(t, called)
+}

pkg/command/inputs.go

@@ -83,6 +83,16 @@ func getStringSliceValue(flags *pflag.FlagSet, tag string) ([]string, error) {
 			val := cobraEnum.SelectedValues()
 			return val, nil
 		}
+
+		// StringArray flags support multiple invocations: --flag a --flag b
+		// Unlike StringSlice which expects comma-separated: --flag=a,b
+		if flag.Value.Type() == "stringArray" {
+			val, err := flags.GetStringArray(tag)
+			if err != nil {
+				return nil, err
+			}
+			return val, nil
+		}
 	}
 
 	val, err := flags.GetStringSlice(tag)

pkg/command/inputs_test.go

@@ -110,6 +110,21 @@ func TestParseCommand(t *testing.T) {
 		require.Equal(t, []string{"bar", "baz"}, v.Foo)
 	})
 
+	t.Run("parse string array", func(t *testing.T) {
+		type testStruct struct {
+			Foo []string `cli:"foo"`
+		}
+		var v testStruct
+		cmd := &cobra.Command{}
+		cmd.Flags().StringArray("foo", []string{}, "")
+		require.NoError(t, cmd.ParseFlags([]string{"--foo", "bar", "--foo", "baz"}))
+
+		err := command.ParseCommand(cmd, []string{}, &v)
+		require.NoError(t, err)
+
+		require.Equal(t, []string{"bar", "baz"}, v.Foo)
+	})
+
 	t.Run("arg parsing", func(t *testing.T) {
 		t.Run("simple arg", func(t *testing.T) {
 			type testStruct struct {

pkg/dependencies/dependencies.go

@@ -13,6 +13,7 @@ import (
 	"github.com/render-oss/cli/pkg/owner"
 	"github.com/render-oss/cli/pkg/postgres"
 	"github.com/render-oss/cli/pkg/project"
+	"github.com/render-oss/cli/pkg/registry"
 	"github.com/render-oss/cli/pkg/resource"
 	"github.com/render-oss/cli/pkg/service"
 	"github.com/render-oss/cli/pkg/tasks"
@@ -45,6 +46,8 @@ type cachedDependencies struct {
 	projectRepo         cache[*project.Repo]
 	environmentRepo     cache[*environment.Repo]
 	serviceRepo         cache[*service.Repo]
+	registryRepo        cache[*registry.Repo]
+	registryService     cache[*registry.Service]
 	postgresRepo        cache[*postgres.Repo]
 	keyValueRepo        cache[*keyvalue.Repo]
 	userRepo            cache[*user.Repo]
@@ -125,6 +128,12 @@ func (d *Dependencies) ServiceRepo() *service.Repo {
 	})
 }
 
+func (d *Dependencies) RegistryRepo() *registry.Repo {
+	return d.cache.registryRepo.Get(func() *registry.Repo {
+		return registry.NewRepo(d.client)
+	})
+}
+
 func (d *Dependencies) PostgresRepo() *postgres.Repo {
 	return d.cache.postgresRepo.Get(func() *postgres.Repo {
 		return postgres.NewRepo(d.client)
@@ -173,6 +182,12 @@ func (d *Dependencies) KeyValueService() *keyvalue.Service {
 	})
 }
 
+func (d *Dependencies) RegistryService() *registry.Service {
+	return d.cache.registryService.Get(func() *registry.Service {
+		return registry.NewService(d.RegistryRepo())
+	})
+}
+
 func (d *Dependencies) ResourceService() *resource.Service {
 	return d.cache.resourceService.Get(func() *resource.Service {
 		return resource.NewResourceService(

pkg/registry/repo.go

@@ -0,0 +1,52 @@
+package registry
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+
+	"github.com/render-oss/cli/pkg/client"
+)
+
+type Repo struct {
+	client *client.ClientWithResponses
+}
+
+func NewRepo(c *client.ClientWithResponses) *Repo {
+	return &Repo{
+		client: c,
+	}
+}
+
+func (s *Repo) ListRegistryCredentials(ctx context.Context, params *client.ListRegistryCredentialsParams) (*[]client.RegistryCredential, error) {
+	resp, err := s.client.ListRegistryCredentialsWithResponse(ctx, params)
+	if err != nil {
+		return nil, err
+	}
+
+	if err := client.ErrorFromResponse(resp); err != nil {
+		return nil, err
+	}
+
+	return resp.JSON200, nil
+}
+
+func (s *Repo) GetRegistryCredential(ctx context.Context, id string) (*client.RegistryCredential, error) {
+	resp, err := s.client.RetrieveRegistryCredentialWithResponse(ctx, id)
+	if err != nil {
+		return nil, err
+	}
+	if resp.StatusCode() == http.StatusNotFound {
+		return nil, nil
+	}
+
+	if err := client.ErrorFromResponse(resp); err != nil {
+		return nil, err
+	}
+
+	if resp.JSON200 == nil {
+		return nil, fmt.Errorf("registry credential lookup failed for %q: empty response", id)
+	}
+
+	return resp.JSON200, nil
+}