no code provisioning in registry modules

registry_module.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"fmt"
 	"log"
+	"net/http"
 	"net/url"
 	"strings"
 )
@@ -40,6 +41,9 @@ type RegistryModules interface {
 	// Delete a specific registry module version
 	DeleteVersion(ctx context.Context, moduleID RegistryModuleID, version string) error
 
+	// Update properties of a registry module
+	Update(ctx context.Context, moduleID RegistryModuleID, options RegistryModuleUpdateOptions) (*RegistryModule, error)
+
 	// Upload Terraform configuration files for the provided registry module version. It
 	// requires a path to the configuration files on disk, which will be packaged by
 	// hashicorp/go-slug before being uploaded.
@@ -104,6 +108,7 @@ type RegistryModule struct {
 	Provider        string                          `jsonapi:"attr,provider"`
 	RegistryName    RegistryName                    `jsonapi:"attr,registry-name"`
 	Namespace       string                          `jsonapi:"attr,namespace"`
+	NoCode          bool                            `jsonapi:"attr,no-code"`
 	Permissions     *RegistryModulePermissions      `jsonapi:"attr,permissions"`
 	Status          RegistryModuleStatus            `jsonapi:"attr,status"`
 	VCSRepo         *VCSRepo                        `jsonapi:"attr,vcs-repo"`
@@ -164,6 +169,9 @@ type RegistryModuleCreateOptions struct {
 	RegistryName RegistryName `jsonapi:"attr,registry-name,omitempty"`
 	// Optional: The namespace of this module. Required for public modules only.
 	Namespace string `jsonapi:"attr,namespace,omitempty"`
+	// Optional: If set to true the module is enabled for no-code provisioning.
+	// **Note: This field is still in BETA and subject to change.**
+	NoCode bool `jsonapi:"attr,no-code,omitempty"`
 }
 
 // RegistryModuleCreateVersionOptions is used when creating a registry module version
@@ -189,6 +197,19 @@ type RegistryModuleCreateWithVCSConnectionOptions struct {
 	VCSRepo *RegistryModuleVCSRepoOptions `jsonapi:"attr,vcs-repo"`
 }
 
+// RegistryModuleCreateVersionOptions is used when updating a registry module
+type RegistryModuleUpdateOptions struct {
+	// Type is a public field utilized by JSON:API to
+	// set the resource type via the field tag.
+	// It is not a user-defined value and does not need to be set.
+	// https://jsonapi.org/format/#crud-updating
+	Type string `jsonapi:"primary,registry-modules"`
+
+	// Optional: Flag to enable no-code provisioning for the whole module.
+	// **Note: This field is still in BETA and subject to change.**
+	NoCode *bool `jsonapi:"attr,no-code,omitempty"`
+}
+
 type RegistryModuleVCSRepoOptions struct {
 	Identifier        *string `json:"identifier"`         // Required
 	OAuthTokenID      *string `json:"oauth-token-id"`     // Required
@@ -265,6 +286,41 @@ func (r *registryModules) Create(ctx context.Context, organization string, optio
 	return rm, nil
 }
 
+func (r *registryModules) Update(ctx context.Context, moduleID RegistryModuleID, options RegistryModuleUpdateOptions) (*RegistryModule, error) {
+	if err := moduleID.valid(); err != nil {
+		return nil, err
+	}
+
+	if moduleID.RegistryName == "" {
+		log.Println("[WARN] Support for using the RegistryModuleID without RegistryName is deprecated as of release 1.5.0 and may be removed in a future version. The preferred method is to include the RegistryName in RegistryModuleID.")
+		moduleID.RegistryName = PrivateRegistry
+	}
+
+	if moduleID.RegistryName == PrivateRegistry && strings.TrimSpace(moduleID.Namespace) == "" {
+		log.Println("[WARN] Support for using the RegistryModuleID without Namespace is deprecated as of release 1.5.0 and may be removed in a future version. The preferred method is to include the Namespace in RegistryModuleID.")
+		moduleID.Namespace = moduleID.Organization
+	}
+
+	org := url.QueryEscape(moduleID.Organization)
+	registryName := url.QueryEscape(string(moduleID.RegistryName))
+	namespace := url.QueryEscape(moduleID.Namespace)
+	name := url.QueryEscape(moduleID.Name)
+	provider := url.QueryEscape(moduleID.Provider)
+	url := fmt.Sprintf("organizations/%s/registry-modules/%s/%s/%s/%s", org, registryName, namespace, name, provider)
+
+	req, err := r.client.NewRequest(http.MethodPatch, url, &options)
+	if err != nil {
+		return nil, err
+	}
+
+	rm := &RegistryModule{}
+	if err := req.Do(ctx, rm); err != nil {
+		return nil, err
+	}
+
+	return rm, nil
+}
+
 // CreateVersion creates a new registry module version
 func (r *registryModules) CreateVersion(ctx context.Context, moduleID RegistryModuleID, options RegistryModuleCreateVersionOptions) (*RegistryModuleVersion, error) {
 	if err := moduleID.valid(); err != nil {

registry_module_integration_test.go

@@ -106,6 +106,7 @@ func TestRegistryModulesCreate(t *testing.T) {
 			assert.Equal(t, *options.Provider, rm.Provider)
 			assert.Equal(t, PrivateRegistry, rm.RegistryName)
 			assert.Equal(t, orgTest.Name, rm.Namespace)
+			assert.False(t, rm.NoCode, "no-code module attribute should be false by default")
 
 			assertRegistryModuleAttributes(t, rm)
 		})
@@ -123,6 +124,7 @@ func TestRegistryModulesCreate(t *testing.T) {
 			assert.Equal(t, *options.Provider, rm.Provider)
 			assert.Equal(t, options.RegistryName, rm.RegistryName)
 			assert.Equal(t, orgTest.Name, rm.Namespace)
+			assert.False(t, rm.NoCode, "no-code module attribute should be false by default")
 
 			assertRegistryModuleAttributes(t, rm)
 		})
@@ -141,6 +143,27 @@ func TestRegistryModulesCreate(t *testing.T) {
 			assert.Equal(t, *options.Provider, rm.Provider)
 			assert.Equal(t, options.RegistryName, rm.RegistryName)
 			assert.Equal(t, options.Namespace, rm.Namespace)
+			assert.False(t, rm.NoCode, "no-code module attribute should be false by default")
+
+			assertRegistryModuleAttributes(t, rm)
+		})
+
+		t.Run("with no-code attribute", func(t *testing.T) {
+			skipIfBeta(t)
+			options := RegistryModuleCreateOptions{
+				Name:         String("iam"),
+				Provider:     String("aws"),
+				NoCode:       true,
+				RegistryName: PrivateRegistry,
+			}
+			rm, err := client.RegistryModules.Create(ctx, orgTest.Name, options)
+			require.NoError(t, err)
+			assert.NotEmpty(t, rm.ID)
+			assert.Equal(t, *options.Name, rm.Name)
+			assert.Equal(t, *options.Provider, rm.Provider)
+			assert.Equal(t, options.RegistryName, rm.RegistryName)
+			assert.Equal(t, orgTest.Name, rm.Namespace)
+			assert.Equal(t, options.NoCode, rm.NoCode)
 
 			assertRegistryModuleAttributes(t, rm)
 		})
@@ -231,6 +254,56 @@ func TestRegistryModulesCreate(t *testing.T) {
 	})
 }
 
+func TestRegistryModuleUpdate(t *testing.T) {
+	skipIfBeta(t)
+	client := testClient(t)
+	ctx := context.Background()
+
+	orgTest, orgTestCleanup := createOrganization(t, client)
+	defer orgTestCleanup()
+
+	options := RegistryModuleCreateOptions{
+		Name:         String("vault"),
+		Provider:     String("aws"),
+		RegistryName: PublicRegistry,
+		Namespace:    "hashicorp",
+	}
+	rm, err := client.RegistryModules.Create(ctx, orgTest.Name, options)
+	require.NoError(t, err)
+	assert.NotEmpty(t, rm.ID)
+
+	t.Run("enable no-code", func(t *testing.T) {
+		options := RegistryModuleUpdateOptions{
+			NoCode: Bool(true),
+		}
+		rm, err := client.RegistryModules.Update(ctx, RegistryModuleID{
+			Organization: orgTest.Name,
+			Name:         "vault",
+			Provider:     "aws",
+			Namespace:    "hashicorp",
+			RegistryName: PublicRegistry,
+		}, options)
+		require.NoError(t, err)
+		assert.True(t, rm.NoCode)
+	})
+
+	t.Run("disable no-code", func(t *testing.T) {
+		options := RegistryModuleUpdateOptions{
+			NoCode: Bool(false),
+		}
+		rm, err := client.RegistryModules.Update(ctx, RegistryModuleID{
+			Organization: orgTest.Name,
+			Name:         "vault",
+			Provider:     "aws",
+			Namespace:    "hashicorp",
+			RegistryName: PublicRegistry,
+		}, options)
+		require.NoError(t, err)
+		assert.False(t, rm.NoCode)
+	})
+
+}
+
 func TestRegistryModulesCreateVersion(t *testing.T) {
 	skipIfNotCINode(t)