belt 0.4.0 → 0.4.2

data/lib/belt/cli/environment_command.rb

@@ -95,11 +95,11 @@ module Belt
         if @parent_environment
           puts "\nThis is a nested environment under '#{@parent_environment}'."
           puts "It will use the parent's wildcard certificate and hosted zone."
-          if @domain
-            puts "Domain will be: api.#{@env_name}.#{@parent_environment}.#{@domain}"
-          else
-            puts "Domain will be: #{@env_name}.#{@parent_environment}.<your-domain>"
-          end
+          # Nested envs use an `api-<env>` prefix (not `api.<env>`) so the API
+          # host stays a single level under the parent's *.<parent>.<domain>
+          # wildcard cert. See lib/templates/module/dns.tf.erb (api_domain).
+          puts "Frontend will be: https://#{@env_name}.#{@parent_environment}.#{@domain}"
+          puts "API will be: https://api-#{@env_name}.#{@parent_environment}.#{@domain}"
           puts "\nDeploy with:"
           puts "  belt deploy #{@env_name}"
           puts "\nNo DNS delegation needed — the parent environment handles DNS."

data/lib/belt/cli/frontend_deploy_command.rb

@@ -75,6 +75,12 @@ module Belt
 
       private
 
+      # Load infrastructure/<env>/belt.rb and apply its aws_profile + env vars
+      # to the current process. Without this, `terraform output` can't reach the
+      # S3 state backend (403), fetch_tf_output returns nil, and the deploy aborts
+      # with a misleading "Could not determine S3 bucket" error. The full
+      # `belt deploy` path applies this before invoking the frontend deploy;
+      # standalone `belt deploy frontend` must do it too.
       def load_and_apply_env_config!
         env_config = EnvironmentConfig.load(@env, infra_dir: @infra_dir)
         env_config.apply!

data/lib/belt/cli/frontend_env_command.rb

@@ -2,8 +2,10 @@
 
 require_relative 'app_detection'
 require_relative 'env_resolver'
+require_relative 'environment_config'
 require_relative 'frontend_env_map'
 require_relative 'frontend_registry'
+require_relative 'terraform_command'
 
 module Belt
   module CLI
@@ -111,18 +113,19 @@ module Belt
       def initialize(env, frontend: nil)
         @env = env
         @app_name = detect_app_name
-        @env_dir = "infrastructure/#{@env}"
+        @infra_dir = TerraformCommand.find_infrastructure_dir || 'infrastructure'
+        @env_dir = File.join(@infra_dir, @env)
         @frontend = frontend || FrontendRegistry.new.resolve!
       end
 
       def run
+        load_and_apply_env_config!
+
         unless Dir.exist?(@frontend.path)
           abort "Error: No #{@frontend.path}/ 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
+        abort "Error: #{@env_dir} not found. Run `belt generate environment #{@env}` first." unless Dir.exist?(@env_dir)
 
         map = FrontendEnvMap.new(@env, env_dir: @env_dir, frontend_path: @frontend.path)
 
@@ -142,6 +145,12 @@ module Belt
           puts "✅ Updated #{result[:path]} (#{updated.join(', ')})"
         end
       end
+
+      private
+
+      def load_and_apply_env_config!
+        EnvironmentConfig.load(@env, infra_dir: @infra_dir).apply!
+      end
     end
   end
 end

data/lib/belt/cli/logs_command.rb

@@ -2,6 +2,8 @@
 
 require 'json'
 require 'open3'
+require_relative 'environment_config'
+require_relative 'terraform_command'
 
 module Belt
   module CLI
@@ -76,6 +78,8 @@ module Belt
         @env ||= detect_environment
         abort 'Error: Cannot determine environment. Pass -e ENV or set BELT_ENV.' unless @env
 
+        apply_env_config!
+
         @app_name = detect_app_name
         abort 'Error: Cannot determine app name.' unless @app_name
 
@@ -88,6 +92,13 @@ module Belt
 
       private
 
+      def apply_env_config!
+        infra_dir = TerraformCommand.find_infrastructure_dir || find_infra_dir
+        env_config = EnvironmentConfig.load(@env, infra_dir: infra_dir)
+        env_config.apply!
+        puts "  🔑 Using AWS profile: #{env_config.aws_profile}" if env_config.aws_profile?
+      end
+
       def parse_args(args)
         i = 0
         while i < args.length

data/lib/belt/cli/server_command.rb

@@ -3,6 +3,7 @@
 require 'base64'
 require 'json'
 require_relative 'app_detection'
+require_relative 'environment_config'
 require_relative 'frontend_env_map'
 require_relative 'frontend_registry'
 require_relative 'terraform_command'
@@ -125,6 +126,9 @@ module Belt
         env_name = @deploy_env || ENV.fetch('BELT_ENV', nil) || TerraformCommand.list_environments.first
         return {} unless env_name
 
+        infra_dir = TerraformCommand.find_infrastructure_dir
+        EnvironmentConfig.load(env_name, infra_dir: infra_dir).apply!
+
         FrontendEnvMap.new(env_name, frontend_path: @frontend.path).process_env
       rescue StandardError
         # Fall back to legacy api_url detection if map resolution fails
@@ -274,6 +278,7 @@ module Belt
           next unless Dir.exist?(env_dir)
           next unless File.exist?(File.join(env_dir, '.terraform'))
 
+          EnvironmentConfig.load(env, infra_dir: infra_dir).apply!
           url = read_api_url_from_outputs(env_dir)
           if url
             @deploy_env = env

data/lib/belt/cli/setup_command.rb

@@ -40,7 +40,7 @@ module Belt
 
           Subcommands:
             state       Set up S3 bucket for Terraform state
-            tables      Generate DynamoDB table definitions from contracts.rb
+            tables      Generate DynamoDB table definitions from lambda/models/*.rb
             frontend    Generate S3 + CloudFront infrastructure for frontend hosting
 
           Options for state:

data/lib/belt/cli/tables_command.rb

@@ -15,7 +15,12 @@ module Belt
         # dynamodb.tf lives in infrastructure/modules/app and uses var.environment.
         EnvResolver.resolve(args)
 
-        new.run
+        # `--force`/`-y` overwrites dynamodb.tf even when the regen would drop a
+        # hand-added table or GSI. Without it, an interactive run prompts before
+        # clobbering and a quiet (generator) run refuses.
+        force = args.intersect?(%w[--force -f --yes -y])
+
+        new(force: force).run
       end
 
       # Automatically sync dynamodb.tf in the app module.
@@ -26,8 +31,9 @@ module Belt
         new(quiet: true).run
       end
 
-      def initialize(quiet: false)
+      def initialize(quiet: false, force: false)
         @quiet = quiet
+        @force = force
       end
 
       def run
@@ -166,6 +172,16 @@ module Belt
         # Skip if content is unchanged
         return if existing_content == new_content
 
+        # Regenerating dynamodb.tf is a full overwrite. Anything hand-added to the
+        # file that the generator can't re-derive from the models — a GSI added
+        # straight into the .tf, or a table for a model that no longer exists — would
+        # silently vanish. Detect that and refuse (quiet) or prompt (interactive)
+        # unless --force was passed.
+        if existing_content
+          dropped = detect_dropped_infrastructure(existing_content, new_content)
+          return if dropped.any? && !safe_to_overwrite?(dest, dropped)
+        end
+
         File.write(dest, new_content)
 
         if @quiet
@@ -179,10 +195,104 @@ module Belt
         end
       end
 
+      # Compare the existing dynamodb.tf against the freshly rendered content and
+      # return a list of human-readable descriptions of infrastructure that exists
+      # today but wouldn't be regenerated — i.e. would be dropped by the overwrite.
+      #
+      # We only surface *removals*, since additions and edits are the whole point of
+      # re-running the generator. A removal, on the other hand, is usually a mistake:
+      # a GSI someone added by hand that the model doesn't declare.
+      def detect_dropped_infrastructure(existing_content, new_content)
+        dropped = []
+
+        old_tables = table_labels(existing_content)
+        new_tables = table_labels(new_content)
+        dropped.concat((old_tables - new_tables).map { |label| "table \"#{label}\"" })
+
+        # Only compare GSIs on tables that survive — a dropped table already
+        # accounts for its indexes, no need to list them twice.
+        (old_tables & new_tables).each do |label|
+          old_gsis = gsi_names(existing_content, label)
+          new_gsis = gsi_names(new_content, label)
+          dropped.concat((old_gsis - new_gsis).map { |gsi| "GSI \"#{gsi}\" on table \"#{label}\"" })
+        end
+
+        dropped
+      end
+
+      # Resource labels for every aws_dynamodb_table block in the content.
+      def table_labels(content)
+        content.scan(/resource\s+"aws_dynamodb_table"\s+"([^"]+)"/).flatten
+      end
+
+      # GSI names declared inside the given table's resource block.
+      def gsi_names(content, label)
+        block = table_block(content, label)
+        return [] unless block
+
+        block.scan(/global_secondary_index\s*\{[^}]*?name\s*=\s*"([^"]+)"/m).flatten
+      end
+
+      # Extract the body of a single aws_dynamodb_table resource block by brace
+      # matching, so we can scope GSI lookups to one table.
+      def table_block(content, label)
+        marker = /resource\s+"aws_dynamodb_table"\s+"#{Regexp.escape(label)}"\s*\{/
+        match = content.match(marker)
+        return nil unless match
+
+        start = match.end(0)
+        depth = 1
+        idx = start
+        while idx < content.length && depth.positive?
+          case content[idx]
+          when '{' then depth += 1
+          when '}' then depth -= 1
+          end
+          idx += 1
+        end
+        content[start...(idx - 1)]
+      end
+
+      # Decide whether it's safe to overwrite dynamodb.tf when the regen would drop
+      # hand-added infrastructure. Returns true to proceed, false to abort the write.
+      def safe_to_overwrite?(dest, dropped)
+        return true if @force
+
+        warn_dropped(dest, dropped)
+
+        # A generator auto-sync must never silently destroy custom infra. Refuse and
+        # tell the user to resolve it deliberately.
+        if @quiet
+          puts '  ⚠ skipped dynamodb.tf — would drop hand-added infrastructure ' \
+               '(run `belt setup tables` to review)'
+          return false
+        end
+
+        print "\nOverwrite anyway and drop the above? [y/N] "
+        response = $stdin.gets&.strip&.downcase
+        return true if %w[y yes].include?(response)
+
+        puts '✗ Aborted. dynamodb.tf left unchanged.'
+        puts '  Move the custom definition into a model, or re-run with --force to overwrite.'
+        false
+      end
+
+      def warn_dropped(dest, dropped)
+        puts "\n⚠ Regenerating #{dest} would DROP infrastructure not derived from your models:"
+        dropped.each { |d| puts "    • #{d}" }
+        puts "\n  This usually means a table or GSI was added to dynamodb.tf by hand."
+        puts '  Belt only tracks tables and indexes it can read from lambda/models/*.rb,'
+        puts '  so a hand-added definition is invisible to the generator and gets overwritten.'
+      end
+
       def render_dynamodb(models)
         blocks = models.map { |m| render_table(m) }
-        "# Auto-generated by Belt from model definitions\n" \
-          "# Do not edit manually — re-run `belt setup tables`\n\n#{blocks.join("\n\n")}\n"
+        "# Auto-generated by Belt from model definitions in lambda/models/*.rb\n" \
+          "#\n" \
+          "# Do NOT edit manually. `belt setup tables` overwrites this whole file from\n" \
+          "# your models. Any table or GSI added here by hand (that a model doesn't\n" \
+          "# declare) will be DROPPED on the next regeneration. Define indexes on the\n" \
+          "# model via indexes(), belongs_to, or cognito_authenticatable instead.\n\n#{blocks.join("\n\n")}\n"
       end
 
       def render_table(model)

data/lib/belt/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: belt
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.2
 platform: ruby
 authors:
 - Stowzilla