Stacks: Add create-from-blueprint command

Author: Seraf

cmd/cycloid/middleware/middleware.go

@@ -35,6 +35,7 @@ type Middleware interface {
 	UpdateStack(org, ref, teamCanonical string, visibility *string) (*models.ServiceCatalog, error)
 	ListStacks(org string) ([]*models.ServiceCatalog, error)
 	ListBlueprints(org string) ([]*models.ServiceCatalog, error)
+	CreateStackFromBlueprint(org, blueprintRef, name, canonical, serviceCatalogSourceCanonical, useCase string) (*models.ServiceCatalog, error)
 	GetStackConfig(org, ref string) (models.ServiceCatalogConfigs, error)
 
 	// organization_credentials

cmd/cycloid/middleware/stacks.go

@@ -11,6 +11,7 @@ import (
 
 	"github.com/cycloidio/cycloid-cli/client/client/service_catalogs"
 	"github.com/cycloidio/cycloid-cli/client/models"
+	"github.com/cycloidio/cycloid-cli/internal/ptr"
 )
 
 func (m *middleware) GetStack(org, ref string) (*models.ServiceCatalog, error) {
@@ -108,6 +109,39 @@ func (m *middleware) ListBlueprints(org string) ([]*models.ServiceCatalog, error
 	return validBlueprints, nil
 }
 
+func (m *middleware) CreateStackFromBlueprint(org, blueprintRef, name, canonical, serviceCatalogSourceCanonical, useCase string) (*models.ServiceCatalog, error) {
+	params := service_catalogs.NewCreateServiceCatalogFromTemplateParams()
+	params.SetOrganizationCanonical(org)
+	params.SetServiceCatalogRef(blueprintRef)
+
+	body := &models.NewServiceCatalogFromTemplate{
+		Name:                          ptr.Ptr(name),
+		Canonical:                     ptr.Ptr(canonical),
+		ServiceCatalogSourceCanonical: ptr.Ptr(serviceCatalogSourceCanonical),
+		UseCase:                       ptr.Ptr(useCase),
+	}
+
+	err := body.Validate(strfmt.Default)
+	if err != nil {
+		return nil, errors.Wrap(err, "validation failed for createServiceCatalogFromTemplate input")
+	}
+
+	params.WithBody(body)
+
+	resp, err := m.api.ServiceCatalogs.CreateServiceCatalogFromTemplate(params, m.api.Credentials(&org))
+	if err != nil {
+		return nil, NewApiError(err)
+	}
+
+	payload := resp.GetPayload()
+	err = payload.Validate(strfmt.Default)
+	if err != nil {
+		return payload.Data, fmt.Errorf("invalid response from the API: %v", err)
+	}
+
+	return payload.Data, nil
+}
+
 
 
 func (m *middleware) UpdateStack(

cmd/cycloid/stacks/cmd.go

@@ -19,6 +19,7 @@ func NewCommands() *cobra.Command {
 		NewGetCommand(),
 		NewUpdateCommand(),
 		NewConfigGetCommand(),
+		NewCreateFromBlueprintCommand(),
 		NewFormsCommands(),
 		NewConfigCommands(),
 	)

cmd/cycloid/stacks/create_from_blueprint.go

@@ -0,0 +1,114 @@
+package stacks
+
+import (
+	"github.com/pkg/errors"
+	"github.com/spf13/cobra"
+
+	"github.com/cycloidio/cycloid-cli/cmd/cycloid/common"
+	"github.com/cycloidio/cycloid-cli/cmd/cycloid/middleware"
+	"github.com/cycloidio/cycloid-cli/internal/cyargs"
+	"github.com/cycloidio/cycloid-cli/printer"
+	"github.com/cycloidio/cycloid-cli/printer/factory"
+)
+
+// CreateFromBlueprintOutput represents the formatted output for create-from-blueprint command
+type CreateFromBlueprintOutput struct {
+	Canonical   string `json:"canonical"`
+	Name        string `json:"name"`
+	Ref         string `json:"ref"`
+	Description string `json:"description"`
+}
+
+func NewCreateFromBlueprintCommand() *cobra.Command {
+	var cmd = &cobra.Command{
+		Use:     "create-from-blueprint",
+		Short:   "create a new stack from a blueprint",
+		Example: `cy --org my-org stack create-from-blueprint --blueprint-ref repo:blueprint-canonical --name "My Stack" --canonical my-stack --service-catalog-source-canonical my-catalog --use-case production`,
+		RunE:    createFromBlueprint,
+	}
+
+	cmd.Flags().String("blueprint-ref", "", "Blueprint reference to use as template (required)")
+	cmd.MarkFlagRequired("blueprint-ref")
+
+	cmd.Flags().String("name", "", "Name of the new stack (required)")
+	cmd.MarkFlagRequired("name")
+
+	cmd.Flags().String("canonical", "", "Canonical name (slug) of the new stack (required)")
+	cmd.MarkFlagRequired("canonical")
+
+	cmd.Flags().String("service-catalog-source-canonical", "", "Service catalog source canonical (required)")
+	cmd.MarkFlagRequired("service-catalog-source-canonical")
+
+	cmd.Flags().String("use-case", "", "Use case canonical to apply from the blueprint (required)")
+	cmd.MarkFlagRequired("use-case")
+
+	return cmd
+}
+
+func createFromBlueprint(cmd *cobra.Command, args []string) error {
+	api := common.NewAPI()
+	m := middleware.NewMiddleware(api)
+
+	org, err := cyargs.GetOrg(cmd)
+	if err != nil {
+		return err
+	}
+
+	output, err := cyargs.GetOutput(cmd)
+	if err != nil {
+		return err
+	}
+
+	// Get required flags
+	blueprintRef, err := cmd.Flags().GetString("blueprint-ref")
+	if err != nil {
+		return err
+	}
+
+	name, err := cmd.Flags().GetString("name")
+	if err != nil {
+		return err
+	}
+
+	canonical, err := cmd.Flags().GetString("canonical")
+	if err != nil {
+		return err
+	}
+
+	serviceCatalogSourceCanonical, err := cmd.Flags().GetString("service-catalog-source-canonical")
+	if err != nil {
+		return err
+	}
+
+	useCase, err := cmd.Flags().GetString("use-case")
+	if err != nil {
+		return err
+	}
+
+	// fetch the printer from the factory
+	p, err := factory.GetPrinter(output)
+	if err != nil {
+		return errors.Wrap(err, "unable to get printer")
+	}
+
+	// Create the stack from blueprint
+	stack, err := m.CreateStackFromBlueprint(org, blueprintRef, name, canonical, serviceCatalogSourceCanonical, useCase)
+	if err != nil {
+		return printer.SmartPrint(p, nil, err, "failed to create stack from blueprint", printer.Options{}, cmd.OutOrStdout())
+	}
+
+	// For JSON output, return all fields; for table output, return only specific fields
+	if output == "json" {
+		return printer.SmartPrint(p, stack, nil, "", printer.Options{}, cmd.OutOrStdout())
+	}
+
+	// For table output, format to show only the requested fields
+	formattedOutput := &CreateFromBlueprintOutput{
+		Canonical:   getStringValue(stack.Canonical),
+		Name:        getStringValue(stack.Name),
+		Ref:         getStringValue(stack.Ref),
+		Description: stack.Description,
+	}
+
+	return printer.SmartPrint(p, formattedOutput, nil, "", printer.Options{}, cmd.OutOrStdout())
+}