belt 0.3.18 → 0.3.20

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 065a7879623cef17ebf1f3244d147aa90186ce337612a6e77f2b43f394a42f3f
-  data.tar.gz: 1df4985ccf796f9fbe28b19d07ffe592f80d5bdc2350077d4b990fc140f7eaaf
+  metadata.gz: 82023cea9ac6649d621b0830d5eb6f0be9185b479f4887abec7146780155953a
+  data.tar.gz: 3fbbe4cc88b68874f751d89f51c7f1e381171fa486c3cbdfa4a18331911584f2
 SHA512:
-  metadata.gz: 220746d8b316b233aae167526dae8cb0db4bf65bf598c537ddcf18f5c0cec61680cfbbb63bc98018a31398c07f2e32db233a403f4ede1ab71d3c2fc00efa1f4a
-  data.tar.gz: 0ae05a242fecad194a4ad39a4642595a437735ce11845bd27a8cb1b6e2f102f38799a36f453f3fd1171ec4f1fb0ad3d113a28801015b7037d4d0162e203f508d
+  metadata.gz: 23ffe36bb364bff9e846eafc096bd0fd41a581442cbceade34bae462851ea461a2ac39ba99e73a3e875eb3d9b900a76527deac0413a1907f57f2647e4e8e13ad
+  data.tar.gz: fbb2663798c280a8aa0d369a2d7f25fdbc849c17ea293f541fca69bcd90e8c7ca441c5dfd4b1c0636c046a1ebc95ea8207abacf801a3a7b014efc3c6b676917c

data/lib/belt/cli/dns_command.rb

@@ -0,0 +1,306 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'erb'
+require 'json'
+require_relative 'app_detection'
+require_relative 'environment_config'
+
+module Belt
+  module CLI
+    class DnsCommand
+      TEMPLATE_DIR = File.expand_path('../../templates/dns', __dir__)
+      DNS_DIR = 'infrastructure/dns'
+
+      include AppDetection
+
+      def self.run(args)
+        subcommand = args.shift
+
+        case subcommand
+        when 'deploy', nil
+          new.deploy(args)
+        when 'generate', 'init'
+          new.generate
+        when 'add'
+          new.add_environment(args)
+        when '--help', '-h', 'help'
+          puts help
+        else
+          puts "Unknown dns subcommand: #{subcommand}\n\n#{help}"
+          exit 1
+        end
+      end
+
+      def self.help
+        <<~HELP
+          Usage: belt dns <subcommand>
+
+          Subcommands:
+            deploy              Deploy the dns infrastructure (init → plan → apply)
+            generate            Create the infrastructure/dns directory (same as belt generate dns)
+            add <env>           Add an environment's NS records to dns/terraform.tfvars
+            help                Show this help
+
+          Examples:
+            belt dns deploy                 # Deploy the root zone
+            belt dns generate               # Scaffold infrastructure/dns
+            belt dns add staging            # Add staging's NS records to tfvars
+
+          The dns directory manages your root domain and delegates subdomains to
+          per-environment hosted zones. Each environment (dev, staging, prod) gets
+          its own Route 53 zone, and this root zone delegates to each of them.
+
+          Workflow:
+            1. belt deploy dev              # Deploy environments first
+            2. belt dns generate            # Create infrastructure/dns
+            3. belt dns add dev             # Add dev's NS records
+            4. belt dns deploy              # Deploy root zone
+            5. Update registrar NS records to output values
+        HELP
+      end
+
+      def initialize(quiet: false)
+        @app_name = detect_app_name
+        @quiet = quiet
+        @state_bucket = resolve_state_bucket
+      end
+
+      # --- Generate ---
+      def generate
+        if Dir.exist?(DNS_DIR)
+          puts "dns infrastructure already exists at #{DNS_DIR}/"
+          puts "\nTo configure it:"
+          puts "  1. Edit #{DNS_DIR}/terraform.tfvars with your domain and environment NS records"
+          puts '  2. Run: belt dns deploy'
+          exit 1
+        end
+
+        puts 'Creating dns infrastructure...' unless @quiet
+        FileUtils.mkdir_p(DNS_DIR)
+
+        templates.each do |template_name, dest_file|
+          dest_path = File.join(DNS_DIR, dest_file)
+          write_template(template_name, dest_path)
+          puts "  create  #{dest_path}" unless @quiet
+        end
+
+        return if @quiet
+
+        puts "\n✓ dns infrastructure created!"
+        puts "\nThis manages your root domain and delegates subdomains to per-environment zones."
+        puts "\nNext steps:"
+        puts '  1. Deploy your environments first (if not already deployed):'
+        puts '       belt deploy dev'
+        puts '       belt deploy staging'
+        puts ''
+        puts '  2. Add each environment\'s NS records:'
+        puts '       belt dns add dev'
+        puts '       belt dns add staging'
+        puts ''
+        puts '  3. Deploy the dns infrastructure:'
+        puts '       belt dns deploy'
+        puts ''
+        puts '  4. Update your registrar\'s NS records to the root_name_servers output'
+      end
+
+      # --- Deploy ---
+      def deploy(args)
+        unless Dir.exist?(DNS_DIR)
+          puts 'No infrastructure/dns directory found.'
+          puts "\nCreate it first:"
+          puts '  belt dns generate'
+          exit 1
+        end
+
+        auto = args.include?('--auto') || args.include?('-y')
+        env_config = load_dns_config
+
+        Dir.chdir(DNS_DIR) do
+          run_terraform('init', env_config)
+          run_terraform('plan', env_config, '-out=tfplan')
+
+          if auto
+            run_terraform('apply', env_config, 'tfplan')
+          else
+            print "\nApply this plan? [y/N] "
+            answer = $stdin.gets&.strip&.downcase
+            if %w[y yes].include?(answer)
+              run_terraform('apply', env_config, 'tfplan')
+            else
+              puts 'Aborted.'
+              exit 1
+            end
+          end
+        end
+      end
+
+      # --- Add Environment ---
+      def add_environment(args)
+        env_name = args.shift
+
+        if env_name.nil? || env_name.start_with?('-')
+          puts 'Usage: belt dns add <env>'
+          puts "\nExample: belt dns add staging"
+          exit 1
+        end
+
+        env_dir = "infrastructure/#{env_name}"
+        unless Dir.exist?(env_dir)
+          puts "Environment #{env_name} not found at #{env_dir}/"
+          exit 1
+        end
+
+        # Get NS records from environment
+        ns_records = fetch_ns_records(env_name)
+        if ns_records.nil? || ns_records.empty?
+          puts "Could not fetch NS records for #{env_name}."
+          puts "\nMake sure the environment is deployed:"
+          puts "  belt deploy #{env_name}"
+          exit 1
+        end
+
+        # Update terraform.tfvars
+        tfvars_path = "#{DNS_DIR}/terraform.tfvars"
+        unless File.exist?(tfvars_path)
+          puts "#{tfvars_path} not found. Run 'belt dns generate' first."
+          exit 1
+        end
+
+        update_tfvars(tfvars_path, env_name, ns_records)
+        puts "✓ Added #{env_name} NS records to #{tfvars_path}"
+        puts "\nRun 'belt dns deploy' to apply the changes."
+      end
+
+      private
+
+      def templates
+        {
+          'main.tf.erb' => 'main.tf',
+          'backend.tf.erb' => 'backend.tf',
+          'variables.tf.erb' => 'variables.tf',
+          'terraform.tfvars.erb' => 'terraform.tfvars',
+          'outputs.tf.erb' => 'outputs.tf',
+          'belt.rb.erb' => 'belt.rb'
+        }
+      end
+
+      def write_template(template_name, dest_path)
+        template_path = File.join(TEMPLATE_DIR, template_name)
+        content = ERB.new(File.read(template_path), trim_mode: '-').result(binding)
+        File.write(dest_path, content)
+      end
+
+      def load_dns_config
+        belt_rb = File.join(DNS_DIR, 'belt.rb')
+        return {} unless File.exist?(belt_rb)
+
+        EnvironmentConfig.load(belt_rb)
+      end
+
+      def run_terraform(action, env_config, *extra_args)
+        cmd = ['terraform', action] + extra_args
+        env = {}
+
+        if env_config[:aws_profile]
+          env['AWS_PROFILE'] = env_config[:aws_profile]
+          puts "Using AWS profile: #{env_config[:aws_profile]}" if action == 'init'
+        end
+
+        system(env, *cmd) || begin
+          puts "\n✗ terraform #{action} failed"
+          exit 1
+        end
+      end
+
+      def fetch_ns_records(env_name)
+        env_dir = "infrastructure/#{env_name}"
+        env_config = EnvironmentConfig.load(env_name)
+
+        env = {}
+        env['AWS_PROFILE'] = env_config.aws_profile if env_config.aws_profile?
+
+        Dir.chdir(env_dir) do
+          # Try terraform output first
+          output, status = Open3.capture2e(env, 'terraform', 'output', '-json', 'name_servers')
+          if status.success?
+            begin
+              return JSON.parse(output)
+            rescue JSON::ParserError
+              # Fall through to state inspection
+            end
+          end
+
+          # Fallback: inspect state for the zone
+          output, status = Open3.capture2e(env, 'terraform', 'state', 'show', '-json',
+                                           'module.app.aws_route53_zone.app[0]')
+          return nil unless status.success?
+
+          begin
+            state = JSON.parse(output)
+            state.dig('values', 'name_servers')
+          rescue JSON::ParserError
+            nil
+          end
+        end
+      end
+
+      def update_tfvars(path, env_name, ns_records)
+        content = File.read(path)
+
+        # Format the NS records for HCL
+        ns_list = ns_records.map { |ns| "    \"#{ns}\"" }.join(",\n")
+        new_entry = "  #{env_name} = [\n#{ns_list}\n  ]"
+
+        # Check if environment_zones already has entries
+        if content =~ /environment_zones\s*=\s*\{([^}]*)\}/m
+          existing = ::Regexp.last_match(1).strip
+
+          if existing.empty?
+            # Empty block - replace with our entry
+            content.sub!(/environment_zones\s*=\s*\{\s*\}/, "environment_zones = {\n#{new_entry}\n}")
+          elsif existing.include?("#{env_name} =")
+            # Environment already exists - update it
+            content.sub!(/#{env_name}\s*=\s*\[[^\]]*\]/m, "#{env_name} = [\n#{ns_list}\n  ]")
+          else
+            # Add to existing entries
+            content.sub!(/environment_zones\s*=\s*\{/m, "environment_zones = {\n#{new_entry}")
+          end
+        end
+
+        File.write(path, content)
+      end
+
+      # Resolve the state bucket name to use in backend.tf.
+      # Priority: existing sibling backend.tf → AWS account ID → bare placeholder.
+      def resolve_state_bucket
+        bucket_from_sibling || bucket_from_aws || 'belt-terraform-state'
+      end
+
+      def bucket_from_sibling
+        Dir.glob('infrastructure/*/backend.tf').each do |f|
+          match = File.read(f).match(/bucket\s*=\s*"([^"]+)"/)
+          next unless match
+          # Skip the bare placeholder — it means state wasn't set up yet
+          return match[1] unless match[1] == 'belt-terraform-state'
+        end
+        nil
+      end
+
+      def bucket_from_aws
+        require 'open3'
+        output, status = Open3.capture2e('aws', 'sts', 'get-caller-identity')
+        return nil unless status.success?
+
+        data = begin
+          JSON.parse(output)
+        rescue StandardError
+          nil
+        end
+        return nil unless data&.dig('Account')
+
+        "belt-terraform-state-#{data['Account']}"
+      end
+    end
+  end
+end

data/lib/belt/cli/environment_command.rb

@@ -64,6 +64,9 @@ module Belt
         puts '  domain      = "..."   # your domain (e.g., "myapp.com")'
         puts "\nThen deploy:"
         puts "  belt deploy #{@env_name}"
+        puts "\nIf using multiple environments with a custom domain, run:"
+        puts '  belt dns generate'
+        puts 'to manage root domain delegation to per-environment zones.'
       end
 
       private

data/lib/belt/cli/generate_command.rb

@@ -4,6 +4,7 @@ require 'fileutils'
 require 'erb'
 require_relative 'app_detection'
 require_relative 'auth_command'
+require_relative 'dns_command'
 require_relative 'environment_command'
 require_relative 'frontend_command'
 require_relative 'frontend_registry'
@@ -17,7 +18,7 @@ module Belt
     class GenerateCommand
       TEMPLATE_DIR = File.expand_path('../../templates/generate', __dir__)
 
-      GENERATORS = %w[scaffold resource model controller environment frontend views index auth].freeze
+      GENERATORS = %w[scaffold resource model controller environment frontend views index auth dns].freeze
 
       include AppDetection
 
@@ -91,6 +92,32 @@ module Belt
             Creates:
               lambda/controllers/<app>/<name>_controller.rb    Controller class
           NOTES
+        },
+        'dns' => {
+          description: 'Generate infrastructure for managing root domain DNS with multi-environment delegation.',
+          usage: 'belt generate dns',
+          options: [],
+          examples: [
+            ['belt g dns']
+          ],
+          notes: <<~NOTES
+            Creates:
+              infrastructure/dns/                              Root DNS zone infrastructure
+              infrastructure/dns/belt.rb                       AWS profile configuration
+
+            This enables multiple environments (dev, staging, prod) to each have their own
+            hosted zone while sharing a single domain. The root zone delegates subdomains
+            to per-environment zones.
+
+            Workflow:
+              1. Deploy environments first: belt deploy dev, belt deploy staging
+              2. Add NS records: belt dns add dev, belt dns add staging
+              3. Deploy: belt dns deploy
+              4. Update your registrar's NS records to the root_name_servers output
+
+            For multi-account setups where DNS lives in a shared account:
+              Edit infrastructure/dns/belt.rb to set the AWS profile.
+          NOTES
         }
       }.freeze
 
@@ -127,6 +154,8 @@ module Belt
 
         return Belt::CLI::EnvironmentCommand.run(args) if generator == 'environment'
 
+        return Belt::CLI::DnsCommand.new.generate if generator == 'dns'
+
         return Belt::CLI::FrontendCommand.run(args) if generator == 'frontend'
 
         return Belt::CLI::ViewsCommand.run(args) if generator == 'views'
@@ -205,6 +234,7 @@ module Belt
             controller    Generate a controller
             auth          Generate Cognito user pool infrastructure
             environment   Create a new deployment environment
+            dns           Generate root DNS zone with multi-environment delegation
             frontend      Scaffold a frontend app (react, vue, svelte; --name / --path for extras)
             views         Generate React pages for a resource
 

data/lib/belt/cli.rb

@@ -2,6 +2,7 @@
 
 require_relative 'version'
 require_relative 'root'
+require_relative 'cli/dns_command'
 require_relative 'cli/env_resolver'
 require_relative 'cli/new_command'
 require_relative 'cli/generate_command'
@@ -45,6 +46,7 @@ module Belt
       'plugin' => Belt::CLI::PluginCommand,
       'explain' => Belt::CLI::ExplainCommand,
       'deploy' => Belt::CLI::DeployCommand,
+      'dns' => Belt::CLI::DnsCommand,
       'frontend' => Belt::CLI::FrontendEnvCommand,
       %w[server s] => Belt::CLI::ServerCommand,
       %w[version --version -v] => ->(_args) { puts "Belt #{Belt::VERSION}" }
@@ -103,6 +105,7 @@ module Belt
           generate frontend <react|vue|svelte>        Scaffold a frontend app [--name --path]
           generate views <resource> [fields...]       Generate React pages [--frontend NAME]
           generate environment <name>                 Create a new environment
+          generate dns                                Generate root DNS zone infrastructure
           destroy <scaffold|model|controller> <name>  Remove generated components
           destroy frontend [--frontend NAME]          Remove a frontend directory
           destroy views <resource>                    Remove React pages for a resource
@@ -111,6 +114,8 @@ module Belt
           s                                           Alias for server
           deploy [environment]                        Deploy to AWS (init → plan → apply)
           deploy frontend <env> [--frontend NAME]     Build and deploy frontend(s) to AWS
+          dns deploy                                  Deploy root DNS zone (init → plan → apply)
+          dns add <env>                               Add environment NS records to dns/terraform.tfvars
           frontend env <env> [--frontend NAME]        Write <frontend>/.env from terraform outputs
           frontend list                               List configured frontends
           routes [-g PATTERN] [-f json]               Show route definitions

data/lib/belt/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Belt
-  VERSION = '0.3.18'
+  VERSION = '0.3.20'
 end

data/lib/templates/dns/backend.tf.erb

@@ -0,0 +1,8 @@
+terraform {
+  backend "s3" {
+    bucket  = "<%= @state_bucket %>"
+    key     = "<%= @app_name %>/dns/terraform.tfstate"
+    region  = "us-east-1"
+    encrypt = true
+  }
+}

data/lib/templates/dns/belt.rb.erb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+Belt.configure do |config|
+  # Set the AWS profile to use for DNS infrastructure.
+  # This can be a shared account for cross-environment DNS management,
+  # or the same profile as your environments for single-account setups.
+  #
+  # Example (shared DNS account):
+  #   config.aws_profile = "sharedzilla"
+  #
+  # Example (same as environments):
+  #   config.aws_profile = "myapp-dev"
+  #
+  # config.aws_profile = ""
+end

data/lib/templates/dns/main.tf.erb

@@ -0,0 +1,45 @@
+# DNS Root Zone Configuration
+# This module manages the root domain and delegates subdomains to per-environment
+# hosted zones. This enables multiple environments (dev, staging, prod, etc.) to
+# each have their own DNS zone while sharing a single domain.
+#
+# SETUP:
+# 1. Deploy each environment first: belt deploy dev, belt deploy staging, etc.
+# 2. Get each environment's NS records: cd infrastructure/<env> && terraform output name_servers
+# 3. Add them to terraform.tfvars below
+# 4. Apply this module: cd infrastructure/dns-root && terraform apply
+# 5. Update your registrar's NS records to the root_name_servers output
+
+terraform {
+  required_version = ">= 1.0"
+
+  required_providers {
+    aws = {
+      source  = "hashicorp/aws"
+      version = ">= 5.0"
+    }
+  }
+}
+
+provider "aws" {
+  region = var.aws_region
+}
+
+# --- Root Hosted Zone ---
+resource "aws_route53_zone" "root" {
+  name = var.domain
+}
+
+# --- Subdomain NS Delegation ---
+# For each environment, create NS records that delegate to that environment's
+# hosted zone. This allows dev.domain.com, staging.domain.com, etc. to resolve
+# independently.
+resource "aws_route53_record" "env_delegation" {
+  for_each = var.environment_zones
+
+  zone_id = aws_route53_zone.root.zone_id
+  name    = "${each.key}.${var.domain}"
+  type    = "NS"
+  ttl     = 300
+  records = each.value
+}

data/lib/templates/dns/outputs.tf.erb

@@ -0,0 +1,14 @@
+output "root_zone_id" {
+  description = "Route53 Hosted Zone ID for the root domain"
+  value       = aws_route53_zone.root.zone_id
+}
+
+output "root_name_servers" {
+  description = "NS records to configure at your registrar (name.com, GoDaddy, etc.)"
+  value       = aws_route53_zone.root.name_servers
+}
+
+output "delegated_environments" {
+  description = "Environments with NS delegation configured"
+  value       = keys(var.environment_zones)
+}

data/lib/templates/dns/terraform.tfvars.erb

@@ -0,0 +1,22 @@
+domain = ""  # Your root domain (e.g., "myapp.com")
+
+# NS records from each environment's hosted zone.
+# After deploying an environment, get its NS records:
+#   cd infrastructure/<env> && terraform output name_servers
+#
+# Then add them here:
+# environment_zones = {
+#   dev = [
+#     "ns-xxx.awsdns-xx.org",
+#     "ns-xxx.awsdns-xx.co.uk",
+#     "ns-xxx.awsdns-xx.com",
+#     "ns-xxx.awsdns-xx.net"
+#   ]
+#   staging = [
+#     "ns-yyy.awsdns-yy.org",
+#     "ns-yyy.awsdns-yy.co.uk",
+#     "ns-yyy.awsdns-yy.com",
+#     "ns-yyy.awsdns-yy.net"
+#   ]
+# }
+environment_zones = {}

data/lib/templates/dns/variables.tf.erb

@@ -0,0 +1,27 @@
+variable "domain" {
+  description = "Root domain (e.g., myapp.com)"
+  type        = string
+}
+
+variable "aws_region" {
+  description = "AWS region"
+  type        = string
+  default     = "us-east-1"
+}
+
+variable "environment_zones" {
+  description = <<-EOT
+    Map of environment names to their hosted zone NS records.
+    Get these values from each environment's Terraform output:
+      cd infrastructure/<env> && terraform output name_servers
+    
+    Example:
+      environment_zones = {
+        dev     = ["ns-1098.awsdns-09.org", "ns-2035.awsdns-62.co.uk", ...]
+        staging = ["ns-1318.awsdns-36.org", "ns-1762.awsdns-28.co.uk", ...]
+        prod    = ["ns-111.awsdns-11.org", "ns-222.awsdns-22.co.uk", ...]
+      }
+  EOT
+  type        = map(list(string))
+  default     = {}
+}

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: belt
 version: !ruby/object:Gem::Version
-  version: 0.3.18
+  version: 0.3.20
 platform: ruby
 authors:
 - Stowzilla
@@ -112,6 +112,7 @@ files:
 - lib/belt/cli/contracts_command.rb
 - lib/belt/cli/deploy_command.rb
 - lib/belt/cli/destroy_command.rb
+- lib/belt/cli/dns_command.rb
 - lib/belt/cli/doctor_command.rb
 - lib/belt/cli/env_resolver.rb
 - lib/belt/cli/environment_command.rb
@@ -172,6 +173,12 @@ files:
 - lib/belt/views/welcome/show.html.erb
 - lib/belt_controller/base.rb
 - lib/belt_controller/implicit_response.rb
+- lib/templates/dns/backend.tf.erb
+- lib/templates/dns/belt.rb.erb
+- lib/templates/dns/main.tf.erb
+- lib/templates/dns/outputs.tf.erb
+- lib/templates/dns/terraform.tfvars.erb
+- lib/templates/dns/variables.tf.erb
 - lib/templates/environment/backend.tf.erb
 - lib/templates/environment/main.tf.erb
 - lib/templates/environment/outputs.tf.erb