chore(refactor): refactor repeating patterns + consolidation (#77)

## what

- Extracted 37 repeated try() patterns into stack_property_resolver
helper (main.tf:284-315)
- Created reusable array merging in stack_array_merger for hook patterns
(main.tf:318-331)
- Consolidated stack filtering into generic filtered_stacks helper
(main.tf:334-347)
- Centralized hardcoded constants:
    - default_workspace_name = "default"
    - root_space_id = "root"
- Simplified space resolution using the new constant (main.tf:355)

## why

- I was playing around with Claude Code and asked it to consolidate and
improve the complex logic we have in this module. I like it. Let me know
your thoughts, team!

## references

- N/A


<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->

## Summary by CodeRabbit

- **Refactor**
- Improved consistency by replacing hardcoded workspace and space IDs
with local constants.
- Centralized stack property resolution and array merging for lifecycle
hooks, reducing duplication and streamlining configuration management.
- Consolidated filtering logic for stacks with specific features,
enhancing maintainability and clarity.
- Updated resource property references to use new centralized maps for
more reliable configuration handling.

<!-- end of auto-generated comment: release notes by coderabbit.ai -->

Author: gberenice

main.tf

@@ -25,6 +25,10 @@
 # that are not directly used in the resource creation.
 
 locals {
+  # Constants
+  default_workspace_name = "default"
+  root_space_id          = "root"
+
   _multi_instance_structure = var.root_module_structure == "MultiInstance"
 
   # Read all stack files following the associated root_module_structue convention:
@@ -88,7 +92,7 @@ locals {
 
   _single_instance_root_module_yaml_decoded = {
     for module in local.enabled_root_modules : module => {
-      "default" = yamldecode(file("${path.root}/${var.root_modules_path}/${module}/stack.yaml"))
+      (local.default_workspace_name) = yamldecode(file("${path.root}/${var.root_modules_path}/${module}/stack.yaml"))
     } if !local._multi_instance_structure
   }
 
@@ -142,7 +146,7 @@ locals {
         "root_module"  = module,
 
         # If default_tf_workspace_enabled is true, use "default" workspace, otherwise our file name is the workspace name
-        "terraform_workspace" = try(content.automation_settings.default_tf_workspace_enabled, local._default_tf_workspace_enabled) ? "default" : trimsuffix(file, ".yaml"),
+        "terraform_workspace" = try(content.automation_settings.default_tf_workspace_enabled, local._default_tf_workspace_enabled) ? local.default_workspace_name : trimsuffix(file, ".yaml"),
 
         # tfvars_file_name only pertains to MultiInstance, as SingleInstance expects consumers to use an auto.tfvars file.
         # `yaml` is intentionally used here as we require Stack and `tfvars` config files to be named equally
@@ -276,13 +280,63 @@ locals {
     space.name => space.space_id
   }
 
+  # Helper for property resolution with fallback to defaults
+  stack_property_resolver = {
+    for stack in local.stacks : stack => {
+      # Simple property resolution with fallback
+      administrative                   = try(local.stack_configs[stack].administrative, var.administrative)
+      autoretry                        = try(local.stack_configs[stack].autoretry, var.autoretry)
+      additional_project_globs         = try(local.stack_configs[stack].additional_project_globs, var.additional_project_globs)
+      autodeploy                       = try(local.stack_configs[stack].autodeploy, var.autodeploy)
+      branch                           = try(local.stack_configs[stack].branch, var.branch)
+      enable_local_preview             = try(local.stack_configs[stack].enable_local_preview, var.enable_local_preview)
+      enable_well_known_secret_masking = try(local.stack_configs[stack].enable_well_known_secret_masking, var.enable_well_known_secret_masking)
+      github_action_deploy             = try(local.stack_configs[stack].github_action_deploy, var.github_action_deploy)
+      manage_state                     = try(local.stack_configs[stack].manage_state, var.manage_state)
+      protect_from_deletion            = try(local.stack_configs[stack].protect_from_deletion, var.protect_from_deletion)
+      repository                       = try(local.stack_configs[stack].repository, var.repository)
+      runner_image                     = try(local.stack_configs[stack].runner_image, var.runner_image)
+      terraform_smart_sanitization     = try(local.stack_configs[stack].terraform_smart_sanitization, var.terraform_smart_sanitization)
+      terraform_version                = try(local.stack_configs[stack].terraform_version, var.terraform_version)
+      worker_pool_id                   = try(local.stack_configs[stack].worker_pool_id, var.worker_pool_id)
+
+      # AWS Integration properties
+      aws_integration_id = try(local.stack_configs[stack].aws_integration_id, var.aws_integration_id)
+
+      # Drift detection properties
+      drift_detection_ignore_state = try(local.stack_configs[stack].drift_detection_ignore_state, var.drift_detection_ignore_state)
+      drift_detection_reconcile    = try(local.stack_configs[stack].drift_detection_reconcile, var.drift_detection_reconcile)
+      drift_detection_schedule     = try(local.stack_configs[stack].drift_detection_schedule, var.drift_detection_schedule)
+      drift_detection_timezone     = try(local.stack_configs[stack].drift_detection_timezone, var.drift_detection_timezone)
+
+      # Destructor properties
+      destructor_deactivated = try(local.stack_configs[stack].destructor_deactivated, var.destructor_deactivated)
+    }
+  }
+
+  # Helper for array merging with fallback
+  stack_array_merger = {
+    for stack in local.stacks : stack => {
+      after_apply    = compact(concat(try(local.stack_configs[stack].after_apply, []), var.after_apply))
+      after_destroy  = compact(concat(try(local.stack_configs[stack].after_destroy, []), var.after_destroy))
+      after_init     = compact(concat(try(local.stack_configs[stack].after_init, []), var.after_init))
+      after_perform  = compact(concat(try(local.stack_configs[stack].after_perform, []), var.after_perform))
+      after_plan     = compact(concat(try(local.stack_configs[stack].after_plan, []), var.after_plan))
+      after_run      = compact(concat(try(local.stack_configs[stack].after_run, []), var.after_run))
+      before_apply   = compact(concat(try(local.stack_configs[stack].before_apply, []), var.before_apply))
+      before_destroy = compact(concat(try(local.stack_configs[stack].before_destroy, []), var.before_destroy))
+      before_perform = compact(concat(try(local.stack_configs[stack].before_perform, []), var.before_perform))
+      before_plan    = compact(concat(try(local.stack_configs[stack].before_plan, []), var.before_plan))
+    }
+  }
+
   resolved_space_ids = {
     for stack in local.stacks : stack => coalesce(
       try(local.stack_configs[stack].space_id, null),                           # space_id always takes precedence since it's the most explicit
       try(local.space_name_to_id[local.stack_configs[stack].space_name], null), # Then try to look up space_name from the stack.yaml to ID
       var.space_id,
       try(local.space_name_to_id[var.space_name], null), # Then try to look up the space_name global variable to ID
-      "root"                                             # If no space_id or space_name is provided, default to the root space
+      local.root_space_id                                # If no space_id or space_name is provided, default to the root space
     )
   }
 
@@ -292,12 +346,10 @@ locals {
     for stack, config in local.stack_configs :
     stack => config if try(config.aws_integration_enabled, var.aws_integration_enabled)
   }
-
   drift_detection_stacks = {
     for stack, config in local.stack_configs :
     stack => config if try(config.drift_detection_enabled, var.drift_detection_enabled)
   }
-
   destructor_stacks = {
     for stack, config in local.stack_configs :
     stack => config if try(config.destructor_enabled, var.destructor_enabled)
@@ -333,38 +385,40 @@ module "deep" {
 resource "spacelift_stack" "default" {
   for_each = local.stacks
 
-  administrative                   = coalesce(try(local.stack_configs[each.key].administrative, null), var.administrative)
-  additional_project_globs         = try(local.stack_configs[each.key].additional_project_globs, var.additional_project_globs)
-  after_apply                      = compact(concat(try(local.stack_configs[each.key].after_apply, []), var.after_apply))
-  after_destroy                    = compact(concat(try(local.stack_configs[each.key].after_destroy, []), var.after_destroy))
-  after_init                       = compact(concat(try(local.stack_configs[each.key].after_init, []), var.after_init))
-  after_perform                    = compact(concat(try(local.stack_configs[each.key].after_perform, []), var.after_perform))
-  after_plan                       = compact(concat(try(local.stack_configs[each.key].after_plan, []), var.after_plan))
-  after_run                        = compact(concat(try(local.stack_configs[each.key].after_run, []), var.after_run))
-  autodeploy                       = coalesce(try(local.stack_configs[each.key].autodeploy, null), var.autodeploy)
-  autoretry                        = try(local.stack_configs[each.key].autoretry, var.autoretry)
-  before_apply                     = compact(coalesce(try(local.stack_configs[each.key].before_apply, []), var.before_apply))
-  before_destroy                   = compact(coalesce(try(local.stack_configs[each.key].before_destroy, []), var.before_destroy))
+  administrative           = local.stack_property_resolver[each.key].administrative
+  additional_project_globs = local.stack_property_resolver[each.key].additional_project_globs
+  after_apply              = local.stack_array_merger[each.key].after_apply
+  after_destroy            = local.stack_array_merger[each.key].after_destroy
+  after_init               = local.stack_array_merger[each.key].after_init
+  after_perform            = local.stack_array_merger[each.key].after_perform
+  after_plan               = local.stack_array_merger[each.key].after_plan
+  after_run                = local.stack_array_merger[each.key].after_run
+  autodeploy               = local.stack_property_resolver[each.key].autodeploy
+  autoretry                = local.stack_property_resolver[each.key].autoretry
+  before_apply             = local.stack_array_merger[each.key].before_apply
+  before_destroy           = local.stack_array_merger[each.key].before_destroy
+  # before_init is handled separately from other script arrays due to special tfvars logic
+  # See local.before_init for details on tfvars file copying and MultiInstance vs SingleInstance handling
   before_init                      = local.before_init[each.key]
-  before_perform                   = compact(coalesce(try(local.stack_configs[each.key].before_perform, []), var.before_perform))
-  before_plan                      = compact(coalesce(try(local.stack_configs[each.key].before_plan, []), var.before_plan))
-  branch                           = try(local.stack_configs[each.key].branch, var.branch)
-  enable_local_preview             = try(local.stack_configs[each.key].enable_local_preview, var.enable_local_preview)
-  enable_well_known_secret_masking = try(local.stack_configs[each.key].enable_well_known_secret_masking, var.enable_well_known_secret_masking)
-  github_action_deploy             = try(local.stack_configs[each.key].github_action_deploy, var.github_action_deploy)
+  before_perform                   = local.stack_array_merger[each.key].before_perform
+  before_plan                      = local.stack_array_merger[each.key].before_plan
+  branch                           = local.stack_property_resolver[each.key].branch
+  enable_local_preview             = local.stack_property_resolver[each.key].enable_local_preview
+  enable_well_known_secret_masking = local.stack_property_resolver[each.key].enable_well_known_secret_masking
+  github_action_deploy             = local.stack_property_resolver[each.key].github_action_deploy
   labels                           = local.labels[each.key]
-  manage_state                     = try(local.stack_configs[each.key].manage_state, var.manage_state)
+  manage_state                     = local.stack_property_resolver[each.key].manage_state
   name                             = each.key
   project_root                     = local.configs[each.key].project_root
-  protect_from_deletion            = try(local.stack_configs[each.key].protect_from_deletion, var.protect_from_deletion)
-  repository                       = try(local.stack_configs[each.key].repository, var.repository)
-  runner_image                     = try(local.stack_configs[each.key].runner_image, var.runner_image)
+  protect_from_deletion            = local.stack_property_resolver[each.key].protect_from_deletion
+  repository                       = local.stack_property_resolver[each.key].repository
+  runner_image                     = local.stack_property_resolver[each.key].runner_image
   space_id                         = local.resolved_space_ids[each.key]
-  terraform_smart_sanitization     = try(local.stack_configs[each.key].terraform_smart_sanitization, var.terraform_smart_sanitization)
-  terraform_version                = try(local.stack_configs[each.key].terraform_version, var.terraform_version)
+  terraform_smart_sanitization     = local.stack_property_resolver[each.key].terraform_smart_sanitization
+  terraform_version                = local.stack_property_resolver[each.key].terraform_version
   terraform_workflow_tool          = var.terraform_workflow_tool
   terraform_workspace              = local.configs[each.key].terraform_workspace
-  worker_pool_id                   = try(local.stack_configs[each.key].worker_pool_id, var.worker_pool_id)
+  worker_pool_id                   = local.stack_property_resolver[each.key].worker_pool_id
 
   # Usage of `templatestring` requires OpenTofu 1.7 and Terraform 1.9 or later.
   description = coalesce(
@@ -391,7 +445,7 @@ resource "spacelift_stack_destructor" "default" {
   for_each = local.destructor_stacks
 
   stack_id    = spacelift_stack.default[each.key].id
-  deactivated = try(local.stack_configs[each.key].destructor_deactivated, var.destructor_deactivated)
+  deactivated = local.stack_property_resolver[each.key].destructor_deactivated
 
   # `depends_on` should be used to make sure that all necessary resources (environment variables, roles, integrations, etc.)
   # are still in place when the destruction run is executed.
@@ -405,7 +459,7 @@ resource "spacelift_stack_destructor" "default" {
 resource "spacelift_aws_integration_attachment" "default" {
   for_each = local.aws_integration_stacks
 
-  integration_id = try(local.stack_configs[each.key].aws_integration_id, var.aws_integration_id)
+  integration_id = local.stack_property_resolver[each.key].aws_integration_id
   stack_id       = spacelift_stack.default[each.key].id
   read           = var.aws_integration_attachment_read
   write          = var.aws_integration_attachment_write
@@ -415,14 +469,14 @@ resource "spacelift_drift_detection" "default" {
   for_each = local.drift_detection_stacks
 
   stack_id     = spacelift_stack.default[each.key].id
-  ignore_state = try(local.stack_configs[each.key].drift_detection_ignore_state, var.drift_detection_ignore_state)
-  reconcile    = try(local.stack_configs[each.key].drift_detection_reconcile, var.drift_detection_reconcile)
-  schedule     = try(local.stack_configs[each.key].drift_detection_schedule, var.drift_detection_schedule)
-  timezone     = try(local.stack_configs[each.key].drift_detection_timezone, var.drift_detection_timezone)
+  ignore_state = local.stack_property_resolver[each.key].drift_detection_ignore_state
+  reconcile    = local.stack_property_resolver[each.key].drift_detection_reconcile
+  schedule     = local.stack_property_resolver[each.key].drift_detection_schedule
+  timezone     = local.stack_property_resolver[each.key].drift_detection_timezone
 
   lifecycle {
     precondition {
-      condition     = alltrue([for schedule in try(local.stack_configs[each.key].drift_detection_schedule, var.drift_detection_schedule) : can(regex("^([0-9,\\-*/]+\\s+){4}[0-9,\\-*/]+$", schedule))])
+      condition     = alltrue([for schedule in local.stack_property_resolver[each.key].drift_detection_schedule : can(regex("^([0-9,\\-*/]+\\s+){4}[0-9,\\-*/]+$", schedule))])
       error_message = "Invalid cron schedule format for drift detection"
     }
   }