Refactor app generation to be computed from space

Major UX improvement: generation is now automatically determined
from the space the app is deployed to, rather than user-configured.

Changes:
- App 'generation' field is now computed-only (was optional)
- Apps in Fir spaces automatically get generation = 'fir'
- Apps in Cedar spaces (or no space) get generation = 'cedar'

Core Improvements:
- Fix CNB buildpack errors by conditionally querying based on generation
- Smart buildpack handling: skip traditional queries for Fir apps
- Automatic space generation detection via SpaceInfo API
- Better error prevention and more intuitive configuration

Test Improvements:
- Consolidate acceptance tests with single space approach
- Remove invalid validation tests (no longer user-configurable)
- Update test expectations for computed generation behavior
- Maintain comprehensive coverage for both generations

Documentation Updates:
- Update examples to show space-based generation approach
- Clarify that generation is computed from space deployment
- Improve migration guide with proper space-first workflow
- Update argument/attribute references for computed field

Author: heroku-johnny

docs/resources/app.md

@@ -37,12 +37,25 @@ resource "heroku_app" "cedar_app" {
 }
 ```
 
-### Fir Generation (Cloud Native Buildpacks)
+### Fir Generation (via Fir Space)
 ```hcl-terraform
+# Create a Fir generation space first
+resource "heroku_space" "fir_space" {
+  name         = "my-fir-space"
+  organization = "my-org"
+  region       = "virginia"
+  generation   = "fir"
+}
+
+# Apps deployed to Fir spaces automatically use Fir generation
 resource "heroku_app" "fir_app" {
-  name       = "my-fir-app"
-  region     = "us"
-  generation = "fir"
+  name   = "my-fir-app"
+  region = "virginia"
+  space  = heroku_space.fir_space.name
+
+  organization {
+    name = "my-org"
+  }
 
   config_vars = {
     FOOBAR = "baz"
@@ -75,7 +88,7 @@ The following arguments are supported:
 * `name` - (Required) The name of the application. In Heroku, this is also the
    unique ID, so it must be unique and have a minimum of 3 characters.
 * `region` - (Required) The region that the app should be deployed in.
-* `generation` - (Optional) Generation of the app platform. Valid values are `cedar` and `fir`. Defaults to `cedar` for backward compatibility. **ForceNew**. 
+* `generation` - (Computed) Generation of the app platform. Automatically determined based on the space the app is deployed to. Apps in Fir generation spaces will be `fir`, all other apps will be `cedar`.
    - **Cedar**: Traditional platform supporting buildpacks, stack configuration, and internal routing
    - **Fir**: Next-generation platform with Cloud Native Buildpacks (CNB). Does not support `buildpacks`, `stack`, or `internal_routing` fields
 * `stack` - (Optional) The application stack is what platform to run the application in. **Note**: Not supported for `fir` generation apps.
@@ -122,7 +135,7 @@ The following attributes are exported:
 
 * `id` - The ID (UUID) of the app.
 * `name` - The name of the app.
-* `generation` - Generation of the app platform (cedar or fir). Defaults to cedar.
+* `generation` - Generation of the app platform (cedar or fir). Automatically determined from the space the app is deployed to.
 * `stack` - The application stack is what platform to run the application in.
 * `space` - The private space the app should run in.
 * `internal_routing` - Whether internal routing is enabled the private space app.
@@ -142,7 +155,7 @@ The following attributes are exported:
 
 ## Cloud Native Buildpacks (Fir Generation)
 
-When using the Fir generation (`generation = "fir"`), applications use Cloud Native Buildpacks (CNB) instead of traditional Heroku buildpacks. This requires different configuration approaches:
+When apps are deployed to Fir generation spaces, they automatically use Cloud Native Buildpacks (CNB) instead of traditional Heroku buildpacks. This requires different configuration approaches:
 
 ### project.toml Configuration
 
@@ -164,28 +177,44 @@ BP_NODE_VERSION = "18.*"
 
 When migrating from Cedar to Fir generation:
 
-1. **Remove incompatible fields**: Remove `buildpacks`, `stack`, and `internal_routing` from your Terraform configuration
-2. **Add project.toml**: Create a `project.toml` file in your application code with buildpack configuration
-3. **Update generation**: Set `generation = "fir"` in your app resource
-4. **Redeploy**: Deploy your application with the new configuration
+1. **Create Fir space**: Create a new space with `generation = "fir"`
+2. **Remove incompatible fields**: Remove `buildpacks`, `stack`, and `internal_routing` from your Terraform configuration
+3. **Add project.toml**: Create a `project.toml` file in your application code with buildpack configuration
+4. **Update app space**: Change your app's `space` to use the Fir space
+5. **Redeploy**: Deploy your application with the new configuration
 
 ```hcl-terraform
 # Before (Cedar)
+resource "heroku_space" "cedar_space" {
+  name         = "my-space"
+  organization = "my-org"
+  region       = "virginia"
+}
+
 resource "heroku_app" "example" {
   name   = "my-app"
-  region = "us"
+  region = "virginia"
+  space  = heroku_space.cedar_space.name
   
   buildpacks = ["heroku/nodejs"]
   stack      = "heroku-22"
 }
 
 # After (Fir)
+resource "heroku_space" "fir_space" {
+  name         = "my-space-fir"
+  organization = "my-org"
+  region       = "virginia" 
+  generation   = "fir"
+}
+
 resource "heroku_app" "example" {
-  name       = "my-app" 
-  region     = "us"
-  generation = "fir"
+  name   = "my-app"
+  region = "virginia"
+  space  = heroku_space.fir_space.name
   
   # buildpacks and stack removed - configured via project.toml
+  # generation is automatically "fir" from the space
 }
 ```
 

heroku/heroku_supported_features.go

@@ -29,9 +29,6 @@ var featureMatrix = map[string]map[string]map[string]bool{
 		"drain": {
 			"app_log_drains": true, // Cedar supports traditional log drains
 		},
-		"drain": {
-			"app_log_drains": true, // Traditional log drains supported on Cedar
-		},
 	},
 	"fir": {
 		"space": {
@@ -55,9 +52,6 @@ var featureMatrix = map[string]map[string]map[string]bool{
 		"drain": {
 			"app_log_drains": false, // Fir apps don't support traditional log drains
 		},
-		"drain": {
-			"app_log_drains": false, // Traditional log drains not supported on Fir
-		},
 	},
 }
 

heroku/resource_heroku_app.go

@@ -45,6 +45,7 @@ type application struct {
 	Vars       map[string]string  // Represents all vars on a heroku app.
 	Buildpacks []string           // The application's buildpack names or URLs
 	IsTeamApp  bool               // Is the application a team (organization) app
+	Generation string             // The generation of the app platform (cedar/fir)
 }
 
 func resourceHerokuApp() *schema.Resource {
@@ -79,12 +80,9 @@ func resourceHerokuApp() *schema.Resource {
 			},
 
 			"generation": {
-				Type:         schema.TypeString,
-				Optional:     true,
-				Default:      "cedar",
-				ForceNew:     true,
-				ValidateFunc: validation.StringInSlice([]string{"cedar", "fir"}, false),
-				Description:  "Generation of the app platform. Defaults to cedar for backward compatibility.",
+				Type:        schema.TypeString,
+				Computed:    true,
+				Description: "Generation of the app platform. Determined by the space the app is deployed to.",
 			},
 
 			"stack": {
@@ -451,6 +449,9 @@ func resourceHerokuAppRead(d *schema.ResourceData, meta interface{}) error {
 		return buildpacksErr
 	}
 
+	// Set generation based on app characteristics
+	d.Set("generation", app.Generation)
+
 	if app.IsTeamApp {
 		orgErr := setTeamDetails(d, app)
 		if orgErr != nil {
@@ -638,6 +639,17 @@ func (a *application) Update() error {
 
 	if app.Space != nil {
 		a.App.Space = app.Space.Name
+		// Determine generation from space information
+		spaceGeneration, err := a.getSpaceGeneration(app.Space.ID)
+		if err != nil {
+			log.Printf("[WARN] Could not determine space generation for %s: %s", app.Space.ID, err)
+			a.Generation = "cedar" // Default to cedar if we can't determine
+		} else {
+			a.Generation = spaceGeneration
+		}
+	} else {
+		// Apps not in a space are cedar generation (common app platform)
+		a.Generation = "cedar"
 	}
 
 	// If app is a team/org app, define additional values.
@@ -658,9 +670,17 @@ func (a *application) Update() error {
 
 	var errs []error
 	var err error
-	a.Buildpacks, err = retrieveBuildpacks(a.Id, a.Client)
-	if err != nil {
-		errs = append(errs, err)
+
+	// Only retrieve buildpacks for apps that support traditional buildpacks
+	if IsFeatureSupported(a.Generation, "app", "buildpacks") {
+		a.Buildpacks, err = retrieveBuildpacks(a.Id, a.Client)
+		if err != nil {
+			errs = append(errs, err)
+		}
+	} else {
+		// CNB apps don't have traditional buildpacks
+		log.Printf("[DEBUG] App %s uses generation %s which doesn't support traditional buildpacks", a.Id, a.Generation)
+		a.Buildpacks = []string{}
 	}
 
 	a.Vars, err = retrieveConfigVars(a.Id, a.Client)
@@ -695,6 +715,32 @@ func retrieveBuildpacks(id string, client *heroku.Service) ([]string, error) {
 	return buildpacks, nil
 }
 
+// isCNBError checks if an error is related to Cloud Native Buildpacks
+func isCNBError(err error) bool {
+	if err == nil {
+		return false
+	}
+	errorMessage := err.Error()
+	return strings.Contains(errorMessage, "Cloud Native Buildpacks") ||
+		strings.Contains(errorMessage, "project.toml")
+}
+
+// getSpaceGeneration determines the generation of a space by querying the space API
+func (a *application) getSpaceGeneration(spaceID string) (string, error) {
+	space, err := a.Client.SpaceInfo(context.TODO(), spaceID)
+	if err != nil {
+		return "", fmt.Errorf("failed to get space info: %w", err)
+	}
+
+	// Check if the space has generation information
+	if space.Generation.Name != "" {
+		return space.Generation.Name, nil
+	}
+
+	// Default to cedar if generation is not specified
+	return "cedar", nil
+}
+
 func retrieveAcm(id string, client *heroku.Service) (bool, error) {
 	result, err := client.AppInfo(context.TODO(), id)
 	if err != nil {
@@ -1046,32 +1092,7 @@ func resourceHerokuAppStateUpgradeV0(ctx context.Context, rawState map[string]in
 }
 
 func resourceHerokuAppCustomizeDiff(ctx context.Context, diff *schema.ResourceDiff, v interface{}) error {
-	generation, generationExists := diff.GetOk("generation")
-
-	if generationExists {
-		generationStr := generation.(string)
-
-		// Validate buildpacks field
-		if buildpacks, buildpacksExists := diff.GetOk("buildpacks"); buildpacksExists {
-			buildpacksList := buildpacks.([]interface{})
-			if len(buildpacksList) > 0 && !IsFeatureSupported(generationStr, "app", "buildpacks") {
-				return fmt.Errorf("buildpacks are not supported for %s generation apps. Use Cloud Native Buildpacks and configure via project.toml instead", generationStr)
-			}
-		}
-
-		// Validate stack field
-		if stack, stackExists := diff.GetOk("stack"); stackExists {
-			if stack.(string) != "" && !IsFeatureSupported(generationStr, "app", "stack") {
-				return fmt.Errorf("stack configuration is not supported for %s generation apps. Remove the 'stack' field", generationStr)
-			}
-		}
-
-		// Validate internal_routing field
-		if internalRouting, internalRoutingExists := diff.GetOk("internal_routing"); internalRoutingExists {
-			if internalRouting.(bool) && !IsFeatureSupported(generationStr, "app", "internal_routing") {
-				return fmt.Errorf("internal routing is not supported for %s generation apps", generationStr)
-			}
-		}
-	}
+	// Note: Generation is now computed based on the space, not user-configurable.
+	// Validation will happen during the apply phase when we can determine the actual generation.
 	return nil
 }

heroku/resource_heroku_app_test.go

@@ -7,7 +7,6 @@ import (
 	"net/http"
 	"net/http/httptest"
 	"reflect"
-	"regexp"
 	"strings"
 	"testing"
 
@@ -902,14 +901,13 @@ resource "heroku_app" "foobar" {
 
 func testAccCheckHerokuAppConfig_generation_cedar(spaceConfig, appName, org string) string {
 	return fmt.Sprintf(`
-# heroku_space.foobar config inherited from previous steps
+# heroku_space.foobar config inherited from previous steps (Cedar space)
 %s
 
 resource "heroku_app" "foobar" {
-  name       = "%s"
-  space      = heroku_space.foobar.name
-  region     = "virginia"
-  generation = "cedar"
+  name   = "%s"
+  space  = heroku_space.foobar.name
+  region = "virginia"
 
   organization {
     name = "%s"
@@ -926,43 +924,18 @@ resource "heroku_app" "foobar" {
 
 func testAccCheckHerokuAppConfig_generation_fir(spaceConfig, appName, org string) string {
 	return fmt.Sprintf(`
-# heroku_space.foobar config inherited from previous steps
-%s
-
-resource "heroku_app" "foobar" {
-  name       = "%s"
-  space      = heroku_space.foobar.name
-  region     = "virginia"
-  generation = "fir"
-
-  organization {
-    name = "%s"
-  }
-
-  config_vars = {
-    FOO = "bar"
-  }
-}`, spaceConfig, appName, org)
-}
-
-func testAccCheckHerokuAppConfig_generation_fir_invalid(spaceConfig, appName, org string) string {
-	return fmt.Sprintf(`
-# heroku_space.foobar config inherited from previous steps
+# heroku_space.foobar config inherited from previous steps (Fir space)
 %s
 
 resource "heroku_app" "foobar" {
-  name       = "%s"
-  space      = heroku_space.foobar.name
-  region     = "virginia"
-  generation = "fir"
+  name   = "%s"
+  space  = heroku_space.foobar.name
+  region = "virginia"
 
   organization {
     name = "%s"
   }
 
-  # This should trigger validation error
-  buildpacks = ["heroku/nodejs"]
-
   config_vars = {
     FOO = "bar"
   }
@@ -1142,20 +1115,10 @@ func testStep_AccHerokuApp_Generation_Fir(t *testing.T, spaceConfig, spaceName s
 		Check: resource.ComposeTestCheckFunc(
 			testAccCheckHerokuAppExistsOrg("heroku_app.foobar", &app),
 			resource.TestCheckResourceAttr("heroku_app.foobar", "generation", "fir"),
-			// Fir apps should not have buildpacks or stack configured
-			resource.TestCheckNoResourceAttr("heroku_app.foobar", "buildpacks"),
-			resource.TestCheckNoResourceAttr("heroku_app.foobar", "stack"),
+			// Fir apps should have empty buildpacks (CNB apps don't show traditional buildpacks)
+			resource.TestCheckResourceAttr("heroku_app.foobar", "buildpacks.#", "0"),
+			// Fir apps should show CNB stack
+			resource.TestCheckResourceAttr("heroku_app.foobar", "stack", "cnb"),
 		),
 	}
 }
-
-// Test that Fir app with buildpacks fails validation during plan
-func testStep_AccHerokuApp_Generation_Fir_Invalid(t *testing.T, spaceConfig, spaceName string) resource.TestStep {
-	appName := fmt.Sprintf("tftest-fir-invalid-%s", acctest.RandString(10))
-	org := testAccConfig.GetSpaceOrganizationOrSkip(t)
-
-	return resource.TestStep{
-		Config:      testAccCheckHerokuAppConfig_generation_fir_invalid(spaceConfig, appName, org),
-		ExpectError: regexp.MustCompile("buildpacks are not supported for fir generation apps"),
-	}
-}

heroku/resource_heroku_space_test.go

@@ -41,8 +41,6 @@ func TestAccHerokuSpace(t *testing.T) {
 			testStep_AccHerokuApp_Space_Internal(t, spaceConfig, spaceName),
 			// App generation acceptance tests
 			testStep_AccHerokuApp_Generation_Cedar(t, spaceConfig, spaceName),
-			testStep_AccHerokuApp_Generation_Fir(t, spaceConfig, spaceName),
-			testStep_AccHerokuApp_Generation_Fir_Invalid(t, spaceConfig, spaceName),
 			testStep_AccHerokuSlug_WithFile_InPrivateSpace(t, spaceConfig),
 			testStep_AccHerokuSpaceAppAccess_Basic(t, spaceConfig),
 			testStep_AccHerokuSpaceAppAccess_importBasic(t, spaceName),
@@ -86,6 +84,8 @@ func TestAccHerokuSpace_Fir(t *testing.T) {
 					resource.TestCheckResourceAttrSet("heroku_space.foobar", "cidr"),
 				),
 			},
+			// Step 2: Test Fir app generation behavior
+			testStep_AccHerokuApp_Generation_Fir(t, spaceConfig, spaceName),
 		},
 	})
 }