Support name and provider when display identifier unexpected

Author: jillirami

internal/provider/resource_tfe_registry_module.go

@@ -33,6 +33,9 @@ func resourceTFERegistryModule() *schema.Resource {
 		},
 
 		CustomizeDiff: func(c context.Context, d *schema.ResourceDiff, meta interface{}) error {
+			if err := validateNameAndProvider(d); err != nil {
+				return err
+			}
 			if err := validateVcsRepo(d); err != nil {
 				return err
 			}
@@ -46,12 +49,10 @@ func resourceTFERegistryModule() *schema.Resource {
 				ForceNew: true,
 			},
 			"module_provider": {
-				Type:         schema.TypeString,
-				Optional:     true,
-				Computed:     true,
-				ForceNew:     true,
-				ExactlyOneOf: []string{"vcs_repo"},
-				RequiredWith: []string{"organization", "name"},
+				Type:     schema.TypeString,
+				Optional: true,
+				Computed: true,
+				ForceNew: true,
 			},
 			"name": {
 				Type:     schema.TypeString,
@@ -193,6 +194,18 @@ func resourceTFERegistryModuleCreateWithVCS(v interface{}, meta interface{}, d *
 		log.Printf("[WARN] Error getting organization name: %s", err)
 	}
 
+	// Support for explicitly specifying Name and Provider with VCS repos.
+	// This is particularly useful for monorepos with source_directory where the repository name
+	// doesn't follow the terraform-<provider>-<name> convention (e.g., "private-modules", "monorepo").
+	// When these fields are not provided, the API will infer them from the repository identifier.
+	if name, ok := d.GetOk("name"); ok {
+		options.Name = tfe.String(name.(string))
+	}
+
+	if provider, ok := d.GetOk("module_provider"); ok {
+		options.Provider = tfe.String(provider.(string))
+	}
+
 	options.VCSRepo = &tfe.RegistryModuleVCSRepoOptions{
 		Identifier:        tfe.String(vcsRepo["identifier"].(string)),
 		GHAInstallationID: tfe.String(vcsRepo["github_app_installation_id"].(string)),
@@ -519,6 +532,69 @@ func resourceTFERegistryModuleDelete(d *schema.ResourceData, meta interface{}) e
 	return nil
 }
 
+func validateNameAndProvider(d *schema.ResourceDiff) error {
+	configMap := d.GetRawConfig().AsValueMap()
+	nameValue, hasName := configMap["name"]
+	providerValue, hasProvider := configMap["module_provider"]
+	vcsRepoValue, hasVcsRepo := configMap["vcs_repo"]
+
+	vcsRepoProvided := hasVcsRepo && !vcsRepoValue.IsNull()
+	nameProvided := hasName && !nameValue.IsNull()
+	providerProvided := hasProvider && !providerValue.IsNull()
+
+	// Either vcs_repo OR module_provider must be provided
+	if !vcsRepoProvided && !providerProvided {
+		return fmt.Errorf("one of vcs_repo or module_provider is required")
+	}
+
+	// When using vcs_repo, check if we can parse terraform-<provider>-<name> from display_identifier
+	if vcsRepoProvided {
+		// Check if the repository name follows terraform-<provider>-<name> convention
+		canInferFromRepo := false
+		if vcsRepoValue.LengthInt() > 0 {
+			vcsRepoBlock := vcsRepoValue.AsValueSlice()[0]
+			displayIdentifier := vcsRepoBlock.GetAttr("display_identifier")
+			if !displayIdentifier.IsNull() && displayIdentifier.IsKnown() {
+				repoName := displayIdentifier.AsString()
+				// Extract just the repo name from "org/repo" format
+				parts := strings.Split(repoName, "/")
+				if len(parts) > 0 {
+					lastPart := parts[len(parts)-1]
+					// Check if it follows terraform-<provider>-<name> format
+					nameParts := strings.Split(lastPart, "-")
+					if len(nameParts) == 3 {
+						canInferFromRepo = true
+					}
+				}
+			}
+		}
+
+		// If we can't infer from repo name, require both name and module_provider together
+		if !canInferFromRepo {
+			if nameProvided != providerProvided {
+				if nameProvided {
+					return fmt.Errorf("module_provider must be provided when name is specified with a non-standard repository name")
+				}
+				return fmt.Errorf("name must be provided when module_provider is specified with a non-standard repository name")
+			}
+			// If neither is provided with a non-standard repo name, that's also an error
+			if !nameProvided && !providerProvided {
+				return fmt.Errorf("name and module_provider are required when the repository name does not follow the terraform-<provider>-<name> convention")
+			}
+		}
+	} else {
+		// When not using vcs_repo, both name and module_provider are required
+		if !providerProvided {
+			return fmt.Errorf("module_provider is required when not using vcs_repo")
+		}
+		if !nameProvided {
+			return fmt.Errorf("name must be set if module_provider is used")
+		}
+	}
+
+	return nil
+}
+
 func resourceTFERegistryModuleImporter(ctx context.Context, d *schema.ResourceData, meta interface{}) ([]*schema.ResourceData, error) {
 	registryModuleInfo := strings.SplitN(d.Id(), "/", 6)
 	if len(registryModuleInfo) == 4 {