Wrap errors appropriately and move CreateNewIngredientVersionRevision to inventory model

Author: samueld-activator

cmd/state-mcp/internal/registry/tools.go

@@ -262,23 +262,23 @@ func CreateIngredientRevisionTool() Tool {
 		Handler: func(ctx context.Context, p *primer.Values, mcpRequest mcp.CallToolRequest) (*mcp.CallToolResult, error) {
 			namespace, err := mcpRequest.RequireString("namespace")
 			if err != nil {
-				return mcp.NewToolResultError(fmt.Sprintf("an ingredient namespace is required: %s", errs.JoinMessage(err))), nil
+				return mcp.NewToolResultError(fmt.Sprintf("an ingredient namespace str is required: %s", errs.JoinMessage(err))), nil
 			}
 			name, err := mcpRequest.RequireString("name")
 			if err != nil {
-				return mcp.NewToolResultError(fmt.Sprintf("an ingredient name is required: %s", errs.JoinMessage(err))), nil
+				return mcp.NewToolResultError(fmt.Sprintf("an ingredient name str is required: %s", errs.JoinMessage(err))), nil
 			}
 			version, err := mcpRequest.RequireString("version")
 			if err != nil {
-				return mcp.NewToolResultError(fmt.Sprintf("an ingredient version is required: %s", errs.JoinMessage(err))), nil
+				return mcp.NewToolResultError(fmt.Sprintf("an ingredient version str is required: %s", errs.JoinMessage(err))), nil
 			}
 			dependencies, err := mcpRequest.RequireString("dependencies")
 			if err != nil {
-				return mcp.NewToolResultError(fmt.Sprintf("the ingredient dependencies are required: %s", errs.JoinMessage(err))), nil
+				return mcp.NewToolResultError(fmt.Sprintf("the ingredient dependencies str is required: %s", errs.JoinMessage(err))), nil
 			}
 			comment, err := mcpRequest.RequireString("comment")
 			if err != nil {
-				return mcp.NewToolResultError(fmt.Sprintf("a comment for the ingredient is required: %s", errs.JoinMessage(err))), nil
+				return mcp.NewToolResultError(fmt.Sprintf("a comment str for the ingredient is required: %s", errs.JoinMessage(err))), nil
 			}
 
 			params := createrevision.NewParams(namespace, name, version, dependencies, comment)

internal/runners/mcp/createrevision/createrevision.go

@@ -2,16 +2,13 @@ package createrevision
 
 import (
 	"encoding/json"
-	"fmt"
 
+	"github.com/ActiveState/cli/internal/errs"
 	"github.com/ActiveState/cli/internal/output"
 	"github.com/ActiveState/cli/internal/primer"
-	"github.com/ActiveState/cli/pkg/platform/api/inventory"
-	"github.com/ActiveState/cli/pkg/platform/api/inventory/inventory_client/inventory_operations"
 	"github.com/ActiveState/cli/pkg/platform/api/inventory/inventory_models"
 	"github.com/ActiveState/cli/pkg/platform/authentication"
 	"github.com/ActiveState/cli/pkg/platform/model"
-	"github.com/go-openapi/strfmt"
 )
 
 type CreateRevisionRunner struct {
@@ -49,107 +46,23 @@ func (runner *CreateRevisionRunner) Run(params *Params) error {
 	var dependencies []inventory_models.Dependency
 	err := json.Unmarshal([]byte(params.dependencies), &dependencies)
 	if err != nil {
-		return fmt.Errorf("error unmarshaling dependencies, dependency JSON is in wrong format: %w", err)
+		return errs.Wrap(err, "error unmarshaling dependencies, dependency JSON is in wrong format")
 	}
 
 	// Retrieve ingredient version to access ingredient and version IDs
 	ingredient, err := model.GetIngredientByNameAndVersion(params.namespace, params.name, params.version, nil, runner.auth)
 	if err != nil {
-		return fmt.Errorf("error fetching ingredient: %w", err)
+		return errs.Wrap(err, "error fetching ingredient")
 	}
 
-	// Retrieve its latest revision to copy all data - but comment and dependencies - from
-	getParams := inventory_operations.NewGetIngredientVersionRevisionsParams()
-	getParams.SetIngredientID(*ingredient.IngredientID)
-	getParams.SetIngredientVersionID(*ingredient.IngredientVersionID)
-
-	client := inventory.Get(runner.auth)
-	revisions, err := client.GetIngredientVersionRevisions(getParams, runner.auth.ClientAuth())
-	if err != nil {
-		return fmt.Errorf("error getting version revisions: %w", err)
-	}
-	revision := revisions.Payload.IngredientVersionRevisions[len(revisions.Payload.IngredientVersionRevisions)-1]
-
-	// Prepare new ingredient version revision params to create a new revision
-	// This leaves all the attributes untouched, but dependencies and comments
-	newParams := inventory_operations.NewAddIngredientVersionRevisionParams()
-	newParams.SetIngredientID(*ingredient.IngredientID)
-	newParams.SetIngredientVersionID(*ingredient.IngredientVersionID)
-
-	// Extract build script IDs
-	var buildScriptIDs []strfmt.UUID
-	for _, script := range revision.BuildScripts {
-		buildScriptIDs = append(buildScriptIDs, *script.BuildScriptID)
-	}
-
-	// Replicate patches
-	var patches []*inventory_models.IngredientVersionRevisionCreatePatch
-	for _, patch := range revision.Patches {
-		patches = append(patches, &inventory_models.IngredientVersionRevisionCreatePatch{
-			PatchID:        patch.PatchID,
-			SequenceNumber: patch.SequenceNumber,
-		})
-	}
-
-	// Retrieve and prepare default and override option sets
-	optsetParams := inventory_operations.NewGetIngredientVersionIngredientOptionSetsParams()
-	optsetParams.SetIngredientID(*ingredient.IngredientID)
-	optsetParams.SetIngredientVersionID(*ingredient.IngredientVersionID)
-
-	response, err := client.GetIngredientVersionIngredientOptionSets(optsetParams, runner.auth.ClientAuth())
-	if err != nil {
-		return fmt.Errorf("error getting optsets: %w", err)
-	}
-
-	var default_optsets []strfmt.UUID
-	var override_optsets []strfmt.UUID
-	for _, optset := range response.Payload.IngredientOptionSetsWithUsageType {
-		switch *optset.UsageType {
-		case "default":
-			default_optsets = append(default_optsets, *optset.IngredientOptionSetID)
-		case "override":
-			override_optsets = append(override_optsets, *optset.IngredientOptionSetID)
-		}
-	}
-
-	// Create and set the new revision object from model, setting the reason as manual change
-	manual_change := inventory_models.IngredientVersionRevisionCoreReasonManualChange
-	new_revision := inventory_models.IngredientVersionRevisionCreate{
-		IngredientVersionRevisionCore: inventory_models.IngredientVersionRevisionCore{
-			Comment:                      &params.comment,
-			ProvidedFeatures:             revision.ProvidedFeatures,
-			Reason:                       &manual_change,
-			ActivestateLicenseExpression: revision.ActivestateLicenseExpression,
-			AuthorPlatformUserID:         revision.AuthorPlatformUserID,
-			CamelExtras:                  revision.CamelExtras,
-			Dependencies:                 dependencies,
-			IsIndemnified:                revision.IsIndemnified,
-			IsStableRelease:              revision.IsStableRelease,
-			IsStableRevision:             revision.IsStableRevision,
-			LicenseManifestURI:           revision.LicenseManifestURI,
-			PlatformSourceURI:            revision.PlatformSourceURI,
-			ScannerLicenseExpression:     revision.ScannerLicenseExpression,
-			SourceChecksum:               revision.SourceChecksum,
-			Status:                       revision.Status,
-		},
-		IngredientVersionRevisionCreateAllOf0: inventory_models.IngredientVersionRevisionCreateAllOf0{
-			BuildScripts:                 buildScriptIDs,
-			DefaultIngredientOptionSets:  default_optsets,
-			IngredientOptionSetOverrides: override_optsets,
-			Patches:                      patches,
-		},
-	}
-	newParams.SetIngredientVersionRevision(&new_revision)
-
-	// Create the new revision and output its marshalled string
-	newRevision, err := client.AddIngredientVersionRevision(newParams, runner.auth.ClientAuth())
+	newRevision, err := model.CreateNewIngredientVersionRevision(ingredient, params.comment, dependencies, runner.auth)
 	if err != nil {
-		return fmt.Errorf("error creating revision: %w", err)
+		return errs.Wrap(err, "error creating ingredient version revision")
 	}
 
 	marshalledRevision, err := json.Marshal(newRevision)
 	if err != nil {
-		return fmt.Errorf("error marshalling revision response: %w", err)
+		return errs.Wrap(err, "error marshalling revision response")
 	}
 	runner.output.Print(string(marshalledRevision))
 

pkg/platform/model/inventory.go

@@ -679,3 +679,97 @@ func FilterCurrentPlatform(hostPlatform string, platforms []strfmt.UUID, preferr
 
 	return platformIDs[0], nil
 }
+
+// CreateNewIngredientVersionRevision creates a new revision for the provided ingredient.
+// The new revision only updates the comment and dependencies of the ingredient version, all further fields are kept as-is.
+func CreateNewIngredientVersionRevision(ingredient *inventory_models.FullIngredientVersion, comment string, dependencies []inventory_models.Dependency, auth *authentication.Auth) (*inventory_operations.AddIngredientVersionRevisionOK, error) {
+	// Retrieve its latest revision to copy all data - but comment and dependencies - from
+	getParams := inventory_operations.NewGetIngredientVersionRevisionsParams()
+	getParams.SetIngredientID(*ingredient.IngredientID)
+	getParams.SetIngredientVersionID(*ingredient.IngredientVersionID)
+
+	client := inventory.Get(auth)
+	revisions, err := client.GetIngredientVersionRevisions(getParams, auth.ClientAuth())
+	if err != nil {
+		return nil, errs.Wrap(err, "error getting version revisions")
+	}
+	revision := revisions.Payload.IngredientVersionRevisions[len(revisions.Payload.IngredientVersionRevisions)-1]
+
+	// Prepare new ingredient version revision params to create a new revision
+	// This leaves all the attributes untouched, but dependencies and comments
+	newParams := inventory_operations.NewAddIngredientVersionRevisionParams()
+	newParams.SetIngredientID(*ingredient.IngredientID)
+	newParams.SetIngredientVersionID(*ingredient.IngredientVersionID)
+
+	// Extract build script IDs
+	var buildScriptIDs []strfmt.UUID
+	for _, script := range revision.BuildScripts {
+		buildScriptIDs = append(buildScriptIDs, *script.BuildScriptID)
+	}
+
+	// Replicate patches
+	var patches []*inventory_models.IngredientVersionRevisionCreatePatch
+	for _, patch := range revision.Patches {
+		patches = append(patches, &inventory_models.IngredientVersionRevisionCreatePatch{
+			PatchID:        patch.PatchID,
+			SequenceNumber: patch.SequenceNumber,
+		})
+	}
+
+	// Retrieve and prepare default and override option sets
+	optsetParams := inventory_operations.NewGetIngredientVersionIngredientOptionSetsParams()
+	optsetParams.SetIngredientID(*ingredient.IngredientID)
+	optsetParams.SetIngredientVersionID(*ingredient.IngredientVersionID)
+
+	response, err := client.GetIngredientVersionIngredientOptionSets(optsetParams, auth.ClientAuth())
+	if err != nil {
+		return nil, errs.Wrap(err, "error getting optsets")
+	}
+
+	var default_optsets []strfmt.UUID
+	var override_optsets []strfmt.UUID
+	for _, optset := range response.Payload.IngredientOptionSetsWithUsageType {
+		switch *optset.UsageType {
+		case "default":
+			default_optsets = append(default_optsets, *optset.IngredientOptionSetID)
+		case "override":
+			override_optsets = append(override_optsets, *optset.IngredientOptionSetID)
+		}
+	}
+
+	// Create and set the new revision object from model, setting the reason as manual change
+	manual_change := inventory_models.IngredientVersionRevisionCoreReasonManualChange
+	new_revision := inventory_models.IngredientVersionRevisionCreate{
+		IngredientVersionRevisionCore: inventory_models.IngredientVersionRevisionCore{
+			Comment:                      &comment,
+			ProvidedFeatures:             revision.ProvidedFeatures,
+			Reason:                       &manual_change,
+			ActivestateLicenseExpression: revision.ActivestateLicenseExpression,
+			AuthorPlatformUserID:         revision.AuthorPlatformUserID,
+			CamelExtras:                  revision.CamelExtras,
+			Dependencies:                 dependencies,
+			IsIndemnified:                revision.IsIndemnified,
+			IsStableRelease:              revision.IsStableRelease,
+			IsStableRevision:             revision.IsStableRevision,
+			LicenseManifestURI:           revision.LicenseManifestURI,
+			PlatformSourceURI:            revision.PlatformSourceURI,
+			ScannerLicenseExpression:     revision.ScannerLicenseExpression,
+			SourceChecksum:               revision.SourceChecksum,
+			Status:                       revision.Status,
+		},
+		IngredientVersionRevisionCreateAllOf0: inventory_models.IngredientVersionRevisionCreateAllOf0{
+			BuildScripts:                 buildScriptIDs,
+			DefaultIngredientOptionSets:  default_optsets,
+			IngredientOptionSetOverrides: override_optsets,
+			Patches:                      patches,
+		},
+	}
+	newParams.SetIngredientVersionRevision(&new_revision)
+
+	// Create the new revision and output its marshalled string
+	newRevision, err := client.AddIngredientVersionRevision(newParams, auth.ClientAuth())
+	if err != nil {
+		return nil, errs.Wrap(err, "error creating revision")
+	}
+	return newRevision, nil
+}