belt 0.1.8 → 0.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ebbefe3f44abda51ac10b219cda18678ca834d06d8eab39e31beb3e48e99b25a
-  data.tar.gz: 3233b91c7297982ef7f5037331ef003c3637ebc6dccf4321b4a5f758ed57f1d9
+  metadata.gz: c48b3087bb87bb86b2111cc243cf57d889e8f3d94fb25f1b023e5ba3dabf4973
+  data.tar.gz: 53b43e092412aaab0a0fae0e531d7d7ffb07c7a69e19c3e7e7480cf19753184f
 SHA512:
-  metadata.gz: af38bf5330f69577f37ab34a0bd7510b5d84aa14969efd8975ac6875ea85450aaa741beeb71bf3f51f627af11c0c5445806081156706cdfd4901fba4301e33ed
-  data.tar.gz: 2eade1680ebfe76e78ab38e38d273565cf34eb1f1789427d358706ac2c4c128a5f86448a5eb2a146161be8c912bf53f9229fceb0904719c9df5ef3444dc3481e
+  metadata.gz: 2443a472879d551084bd9f6a72b468e6dab20105ae84b3d906cbc33d42c8af6cc32229468300b00f9788a19c324b747f6cd0872d7d652c8d17e96a20cd2c95a6
+  data.tar.gz: a6dd1cc9483792736335058a41b983df0380d8d48ee180b47e3a619a92d7d0a47fcd33af811cff20d7c451d1a783a8ccc49c3934dae60155c7aa6d039b8b7f27

data/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 ## Unreleased
 
+## 0.1.10
+
+### Frontend env map
+
+- Declarative map (`frontend/env.yml` or `.belt/frontend_env.yml`) maps process env names → terraform output names (framework-agnostic: `VITE_*`, `REACT_APP_*`, `NEXT_PUBLIC_*`, etc.)
+- `belt deploy frontend <env>` injects mapped vars into `npm run build` process env
+- `belt frontend env <env>` smart-merges mapped keys into `frontend/.env` (preserves unmapped keys/comments; missing TF outputs warn and do not clobber)
+- No map → previous default: only `VITE_API_URL` ← `api_url`
+- `belt server` uses the same map for local process env
+
 ## 0.1.4
 
 ### Bug fixes

data/lib/belt/cli/deploy_command.rb

@@ -503,8 +503,48 @@ module Belt
           output.each_line do |line|
             puts "  #{line}"
           end
+
+          # Show DNS guidance if name_servers are present and this looks like a first deploy
+          print_dns_guidance if output.include?('name_servers')
         end
       end
+
+      def print_dns_guidance
+        # Check if there's a marker file indicating DNS guidance was already shown
+        marker = File.join(@infra_dir, @env, '.dns_configured')
+        return if File.exist?(marker)
+
+        domain = detect_domain_from_tfvars
+        return unless domain
+
+        puts ''
+        puts '  ┌─────────────────────────────────────────────────────────────┐'
+        puts '  │ DNS SETUP REQUIRED                                          │'
+        puts '  ├─────────────────────────────────────────────────────────────┤'
+        puts '  │ Point your domain to the name_servers shown above.          │'
+        puts '  │                                                             │'
+        puts '  │ • External registrar (GoDaddy, Namecheap, etc.):            │'
+        puts '  │   Update nameservers in your registrar\'s DNS settings.      │'
+        puts '  │                                                             │'
+        puts '  │ • Domain in AWS Route53 Registered Domains:                 │'
+        puts '  │   Route53 → Registered Domains → Name servers → Edit.       │'
+        puts '  │                                                             │'
+        puts "  │ Verify: dig +short NS #{domain.ljust(38)}│"
+        puts '  │                                                             │'
+        puts '  │ This message won\'t appear on subsequent deploys.            │'
+        puts '  └─────────────────────────────────────────────────────────────┘'
+
+        # Create the marker so we don't nag on every deploy
+        File.write(marker, "DNS guidance shown at #{Time.now}\n")
+      end
+
+      def detect_domain_from_tfvars
+        tfvars_file = File.join(@infra_dir, @env, 'terraform.tfvars')
+        return nil unless File.exist?(tfvars_file)
+
+        match = File.read(tfvars_file).match(/^\s*domain\s*=\s*"([^"]+)"/)
+        match[1] if match
+      end
     end
   end
 end

data/lib/belt/cli/destroy_command.rb

@@ -121,8 +121,6 @@ module Belt
         destroy_model
         destroy_controller
         remove_routes
-        remove_schema
-        sync_tables
         destroy_views
         puts "\n✓ Scaffold '#{@singular_name}' destroyed!"
       end
@@ -130,6 +128,8 @@ module Belt
       def destroy_model
         path = "lambda/models/#{@singular_name}.rb"
         remove_file(path)
+        remove_schema
+        sync_tables
       end
 
       def destroy_controller
@@ -157,14 +157,12 @@ module Belt
           @removed << dir
           puts "  remove  #{dir}/"
 
-          # Remove frontend.tf and revert frontend_urls in main.tf for each environment
-          Dir.glob('infrastructure/*/frontend.tf').each do |frontend_tf|
-            FileUtils.rm_f(frontend_tf)
-            puts "  remove  #{frontend_tf}"
-
-            env_dir = File.dirname(frontend_tf)
-            main_tf = File.join(env_dir, 'main.tf')
-            revert_main_tf_frontend_urls(main_tf)
+          # Remove frontend.tf from the module
+          module_frontend = 'infrastructure/modules/app/frontend.tf'
+          if File.exist?(module_frontend)
+            FileUtils.rm_f(module_frontend)
+            @removed << module_frontend
+            puts "  remove  #{module_frontend}"
           end
 
           puts "\n✓ Frontend removed!"
@@ -174,24 +172,6 @@ module Belt
         end
       end
 
-      def revert_main_tf_frontend_urls(main_tf)
-        return unless File.exist?(main_tf)
-
-        content = File.read(main_tf)
-        return unless content.include?('aws_cloudfront_distribution.frontend.domain_name')
-
-        # Replace the multi-line concat block back to a simple conditional
-        replaced = content.sub(
-          /^\s*frontend_urls\s*=\s*concat\(\n(?:.*\n)*?\s*\)\s*\n/,
-          "  frontend_urls     = var.environment == \"prod\" ? [] : [\"http://localhost:3000\"]\n"
-        )
-
-        if replaced != content
-          File.write(main_tf, replaced)
-          puts "  update  #{main_tf} (reverted frontend_urls)"
-        end
-      end
-
       def destroy_views
         return unless @resource_name
 

data/lib/belt/cli/environment_command.rb

@@ -26,9 +26,10 @@ module Belt
         new(env_name).generate
       end
 
-      def initialize(env_name, quiet: false)
+      def initialize(env_name, quiet: false, domain: nil)
         @env_name = env_name.downcase.gsub(/[^a-z0-9_-]/, '')
         @app_name = detect_app_name
+        @domain = domain
         @quiet = quiet
       end
 
@@ -51,28 +52,19 @@ module Belt
 
         puts "\n✓ Environment '#{@env_name}' created!"
 
-        setup_frontend_if_exists
-
         unless @quiet
           puts "\nNext steps:"
           puts "  cd #{dest_dir}"
           puts '  terraform init'
           puts '  terraform plan'
           puts '  terraform apply'
+          puts "\nTo configure a custom domain, set `domain` in #{dest_dir}/terraform.tfvars:"
+          puts "  domain = \"myapp.com\""
         end
       end
 
       private
 
-      def setup_frontend_if_exists
-        return unless Dir.exist?('frontend') && !Dir.empty?('frontend')
-
-        puts "\n  Frontend detected — generating frontend infrastructure..."
-        require_relative 'frontend_setup_command'
-        FrontendSetupCommand.new(@env_name, quiet: true).run
-        puts "  create  infrastructure/#{@env_name}/frontend.tf"
-      end
-
       def templates
         {
           'main.tf.erb' => 'main.tf',

data/lib/belt/cli/frontend_command.rb

@@ -75,22 +75,20 @@ module Belt
       end
 
       def setup_frontend_infra_for_existing_environments
-        environments = detect_environments
-        return if environments.empty?
+        module_dir = 'infrastructure/modules/app'
+        frontend_tf = File.join(module_dir, 'frontend.tf')
 
-        puts "\n  Setting up frontend infrastructure for existing environments..."
-        require_relative 'frontend_setup_command'
+        if File.exist?(frontend_tf)
+          puts "  skip    #{frontend_tf} (already exists)"
+          return
+        end
 
-        environments.each do |env_name|
-          frontend_tf = "infrastructure/#{env_name}/frontend.tf"
-          if File.exist?(frontend_tf)
-            puts "  skip    #{frontend_tf} (already exists)"
-            next
-          end
+        return unless Dir.exist?(module_dir)
 
-          FrontendSetupCommand.new(env_name, quiet: true).run
-          puts "  create  #{frontend_tf}"
-        end
+        puts "\n  Setting up frontend infrastructure..."
+        require_relative 'frontend_setup_command'
+        FrontendSetupCommand.new(nil, quiet: true).run
+        puts "  create  #{frontend_tf}"
       end
 
       def copy_template(src_dir, dest_dir)

data/lib/belt/cli/frontend_deploy_command.rb

@@ -4,6 +4,7 @@ require 'shellwords'
 require 'open3'
 require_relative 'app_detection'
 require_relative 'env_resolver'
+require_relative 'frontend_env_map'
 
 module Belt
   module CLI
@@ -60,11 +61,18 @@ module Belt
         run!(*install_cmd, chdir: 'frontend')
 
         puts '🏗️  Building frontend...'
-        api_url = fetch_api_url
-        env = api_url ? { 'VITE_API_URL' => api_url } : {}
+        env = frontend_build_env
+        if env.any?
+          puts "   Injecting env: #{env.keys.sort.join(', ')}"
+        end
         run!(env, 'npm', 'run', 'build', chdir: 'frontend')
       end
 
+      # Resolve build env from frontend/env.yml map (or default VITE_API_URL ← api_url).
+      def frontend_build_env
+        FrontendEnvMap.new(@env, env_dir: @env_dir).process_env
+      end
+
       def sync_to_s3
         bucket = fetch_bucket_name
         abort "Error: Could not determine S3 bucket. Run `belt apply #{@env}` first." unless bucket
@@ -94,24 +102,24 @@ module Belt
         puts '✅ CloudFront cache invalidated'
       end
 
-      def fetch_api_url
-        output, status = Open3.capture2('terraform', 'output', '-raw', 'api_url', chdir: @env_dir)
-        status.success? && !output.strip.empty? ? output.strip : nil
-      end
-
       def fetch_bucket_name
-        output, status = Open3.capture2('terraform', 'output', '-raw', 'frontend_bucket_name', chdir: @env_dir)
-        status.success? && !output.strip.empty? ? output.strip : nil
+        fetch_tf_output('frontend_bucket_name')
       end
 
       def fetch_distribution_id
-        output, status = Open3.capture2('terraform', 'output', '-raw', 'frontend_distribution_id', chdir: @env_dir)
-        status.success? && !output.strip.empty? ? output.strip : nil
+        fetch_tf_output('frontend_distribution_id')
       end
 
       def fetch_frontend_url
-        output, status = Open3.capture2('terraform', 'output', '-raw', 'frontend_url', chdir: @env_dir)
-        status.success? && !output.strip.empty? ? output.strip : nil
+        fetch_tf_output('frontend_url')
+      end
+
+      def fetch_tf_output(name)
+        output, status = Open3.capture2('terraform', 'output', '-raw', name, chdir: @env_dir)
+        return nil unless status.success?
+
+        value = output.strip
+        value.empty? || value == 'null' ? nil : value
       end
 
       def run!(*args, **)

data/lib/belt/cli/frontend_env_command.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require_relative 'app_detection'
+require_relative 'env_resolver'
+require_relative 'frontend_env_map'
+
+module Belt
+  module CLI
+    # belt frontend env <environment>
+    #
+    # Smart-merges terraform outputs into frontend/.env using the declarative map
+    # (frontend/env.yml or .belt/frontend_env.yml). Only mapped keys are written;
+    # custom local keys are preserved.
+    class FrontendEnvCommand
+      include AppDetection
+
+      def self.run(args)
+        subcommand = args.shift
+
+        case subcommand
+        when 'env'
+          run_env(args)
+        when nil, '-h', '--help', 'help'
+          puts usage
+          exit(subcommand.nil? ? 1 : 0)
+        else
+          puts "Unknown frontend subcommand: #{subcommand}\n\n#{usage}"
+          exit 1
+        end
+      end
+
+      def self.run_env(args)
+        env = EnvResolver.resolve(args)
+
+        if env.nil?
+          puts 'Usage: belt frontend env <environment>'
+          puts "\nWrites frontend/.env from terraform outputs using the env map."
+          puts 'You can also set BELT_ENV to skip the environment argument.'
+          puts "\nMap file (optional): frontend/env.yml or .belt/frontend_env.yml"
+          puts 'Default without map: VITE_API_URL ← api_url'
+          puts "\nExamples:"
+          puts '  belt frontend env dev'
+          puts '  BELT_ENV=dev belt frontend env'
+          exit 1
+        end
+
+        new(env).run
+      end
+
+      def self.usage
+        <<~USAGE
+          Frontend helpers.
+
+          Usage:
+            belt frontend env <environment>   Write frontend/.env from terraform outputs
+            belt frontend --help
+
+          Env map (optional):
+            frontend/env.yml
+            .belt/frontend_env.yml
+
+          Example map:
+            VITE_API_URL: api_url
+            VITE_COGNITO_USER_POOL_ID: cognito_user_pool_id
+            VITE_COGNITO_CLIENT_ID: cognito_user_pool_client_id
+            VITE_AWS_REGION: cognito_region
+
+          Without a map, belt injects only VITE_API_URL from api_url.
+
+          Smart merge: only keys listed in the map are updated. Other .env keys
+          (local secrets, feature flags) are left alone. Missing terraform outputs
+          warn and do not overwrite existing values.
+        USAGE
+      end
+
+      def initialize(env)
+        @env = env
+        @app_name = detect_app_name
+        @env_dir = "infrastructure/#{@env}"
+      end
+
+      def run
+        unless Dir.exist?('frontend')
+          abort 'Error: No frontend/ directory found. Run `belt generate frontend react` first.'
+        end
+
+        unless Dir.exist?(@env_dir)
+          abort "Error: infrastructure/#{@env} not found. Run `belt generate environment #{@env}` first."
+        end
+
+        map = FrontendEnvMap.new(@env, env_dir: @env_dir)
+
+        if map.using_default_map?
+          puts '📋 No frontend/env.yml found — using default map (VITE_API_URL ← api_url)'
+        else
+          puts "📋 Loading env map from #{map.map_path}"
+        end
+
+        result = map.write_dotenv!
+        updated = result[:updated]
+
+        if updated.empty?
+          puts "⚠️  No values written to #{result[:path]} (terraform outputs missing?)"
+        else
+          puts "✅ Updated #{result[:path]} (#{updated.join(', ')})"
+        end
+      end
+    end
+  end
+end

data/lib/belt/cli/frontend_env_map.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'open3'
+require 'yaml'
+
+module Belt
+  module CLI
+    # Resolves frontend env vars from a declarative map (env name → terraform output).
+    #
+    # Map file (optional), first match wins:
+    #   frontend/env.yml
+    #   .belt/frontend_env.yml
+    #
+    # Example:
+    #   VITE_API_URL: api_url
+    #   VITE_COGNITO_USER_POOL_ID: cognito_user_pool_id
+    #   REACT_APP_API_URL: api_url
+    #
+    # No map → default { "VITE_API_URL" => "api_url" } (backwards compatible).
+    class FrontendEnvMap
+      MAP_CANDIDATES = [
+        File.join('frontend', 'env.yml'),
+        File.join('.belt', 'frontend_env.yml')
+      ].freeze
+
+      DEFAULT_MAP = { 'VITE_API_URL' => 'api_url' }.freeze
+
+      DOTENV_PATH = File.join('frontend', '.env')
+
+      attr_reader :env_name, :env_dir, :map_path, :map
+
+      def initialize(env_name, env_dir: nil, map_path: nil)
+        @env_name = env_name
+        @env_dir = env_dir || File.join('infrastructure', env_name)
+        @map_path = map_path || self.class.find_map_path
+        @map = load_map
+        @tf_cache = {}
+      end
+
+      def self.find_map_path
+        MAP_CANDIDATES.find { |path| File.file?(path) }
+      end
+
+      # Hash of env_var => value suitable for process env (npm run build / vite).
+      # Skips keys whose terraform output is missing.
+      def process_env
+        resolved = {}
+        each_resolved do |env_key, value, _tf_output|
+          resolved[env_key] = value if value
+        end
+        resolved
+      end
+
+      # Smart-merge mapped keys into frontend/.env.
+      # - Only overwrites keys present in the map
+      # - Preserves unknown keys, comments, and blank lines
+      # - Missing TF output → warn, do not clobber an existing value
+      def write_dotenv!(path: DOTENV_PATH)
+        FileUtils.mkdir_p(File.dirname(path))
+
+        existing_lines = File.file?(path) ? File.readlines(path, chomp: true) : []
+        updates = {}
+        missing = []
+
+        each_resolved do |env_key, value, tf_output|
+          if value
+            updates[env_key] = value
+          else
+            missing << [env_key, tf_output]
+          end
+        end
+
+        missing.each do |env_key, tf_output|
+          puts "⚠️  terraform output '#{tf_output}' missing — leaving #{env_key} unchanged in #{path}"
+        end
+
+        written = {}
+        new_lines = existing_lines.map do |line|
+          key = dotenv_key(line)
+          if key && updates.key?(key)
+            written[key] = true
+            format_dotenv_line(key, updates[key])
+          else
+            line
+          end
+        end
+
+        updates.each do |key, value|
+          next if written[key]
+
+          new_lines << format_dotenv_line(key, value)
+          written[key] = true
+        end
+
+        content = "#{new_lines.join("\n")}\n"
+        File.write(path, content)
+
+        {
+          path: path,
+          updated: written.keys.sort,
+          missing: missing.map(&:first)
+        }
+      end
+
+      def using_default_map?
+        @map_path.nil?
+      end
+
+      private
+
+      def load_map
+        return DEFAULT_MAP.dup if @map_path.nil?
+
+        raw = YAML.safe_load(File.read(@map_path), aliases: false)
+        unless raw.is_a?(Hash) && raw.any?
+          abort "Error: frontend env map #{@map_path} must be a non-empty YAML mapping " \
+                '(e.g. VITE_API_URL: api_url).'
+        end
+
+        raw.each_with_object({}) do |(key, value), hash|
+          k = key.to_s.strip
+          v = value.to_s.strip
+          next if k.empty? || v.empty?
+
+          hash[k] = v
+        end.tap do |parsed|
+          abort "Error: frontend env map #{@map_path} has no valid entries." if parsed.empty?
+        end
+      rescue Psych::SyntaxError => e
+        abort "Error: invalid YAML in #{@map_path}: #{e.message}"
+      end
+
+      def each_resolved
+        map.each do |env_key, tf_output|
+          yield env_key, fetch_tf_output(tf_output), tf_output
+        end
+      end
+
+      def fetch_tf_output(name)
+        return @tf_cache[name] if @tf_cache.key?(name)
+
+        @tf_cache[name] = read_tf_output(name)
+      end
+
+      def read_tf_output(name)
+        return nil unless Dir.exist?(@env_dir)
+
+        output, status = Open3.capture2(
+          'terraform', 'output', '-raw', name,
+          chdir: @env_dir,
+          err: File::NULL
+        )
+        return nil unless status.success?
+
+        value = output.strip
+        return nil if value.empty? || value == 'null'
+
+        value
+      rescue Errno::ENOENT
+        nil
+      end
+
+      # Match KEY=value lines; ignore comments and export prefixes.
+      def dotenv_key(line)
+        return nil if line.strip.empty? || line.lstrip.start_with?('#')
+
+        stripped = line.strip
+        stripped = stripped.sub(/\Aexport\s+/, '')
+        return nil unless stripped =~ /\A([A-Za-z_][A-Za-z0-9_]*)=/
+
+        Regexp.last_match(1)
+      end
+
+      def format_dotenv_line(key, value)
+        "#{key}=#{escape_dotenv_value(value)}"
+      end
+
+      def escape_dotenv_value(value)
+        str = value.to_s
+        return str if str.empty?
+        return str unless str.match?(/[\s\#"'\\$`]/)
+
+        %("#{str.gsub('\\', '\\\\').gsub('"', '\\"')}")
+      end
+    end
+  end
+end