belt 0.4.1 → 0.4.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 846db7f1373b5bd98f3e795404b1f157825f5dd94541bd46aa76e3510ba89adf
-  data.tar.gz: 251135fea6ee2d3d55e7dcdf46b98460ddc3df50fa1e4113b561f721755c935d
+  metadata.gz: f2a6059e3ba3ce67327476626815d9a1b61b441836877277c44d04978dfa2727
+  data.tar.gz: d714bba5f18070ed1504e33f473a9fd2497019da7fe7c5609b9d97e4676d70ee
 SHA512:
-  metadata.gz: 60b0ecf81e375ea1c219c84ccf7f90d568437cc81507c708ec56a40f903178e0611e5b6be03e1e71185ce66263d1ec0c12ddee8e1a4d2cfdc26f99dba4828c48
-  data.tar.gz: fb3fa14275a68c7e79892504d0fef2cbe86727225033a7d7bc3c1272b963413b5ed7259c3a5c2f1e202770d16b0234ff242571e4d2b7abed50a040090da250e1
+  metadata.gz: d6feaddb7cb071ee7cb75427544d2d32b65ddf9354c3fa08461a67247485fdd6adddf986d93d0ee3fa778ab491136ca14395e5b6dc67fc918eb19b748b8a4214
+  data.tar.gz: 56b99bafbc94e4abcb7fa64cb3ca7b1744591c17c84afea3fe1cab07bb1cbeffe6c76f7af5b6c6f19a51bebffecba10091a70125de012f885709e417cf817bd2

data/CHANGELOG.md

@@ -1,9 +1,37 @@
 # Changelog
 
+## 0.4.3
+
+### Bug Fix
+
+- **`belt deploy` preflight no longer false-fails on `belongs_to ..., index: false`.**
+  The deploy preflight added in 0.4.2 demanded a `{Assoc}Index` GSI for *every*
+  `belongs_to`, ignoring `index: false` and `index: 'CustomName'` — the exact
+  opt-outs the table generator honours. The two halves of the gem disagreed: a
+  model that opts out (its reverse lookup is covered by another GSI, or it doesn't
+  need one) got a passing `belt setup tables` and a failing `belt deploy`, with no
+  way out but `--force`-ing the generator or pinning back to 0.4.1. The preflight's
+  index extraction now mirrors the generator exactly: it skips `index: false` and
+  honours an explicit `index: 'Name'`. `foreign_key:`-remapped associations
+  (`belongs_to :user, foreign_key: 'cognito_sub', index: false`) no longer demand a
+  phantom `UserIndex` either.
+
 ## Unreleased
 
 ### Bug Fix
 
+- **`belt setup tables` no longer silently clobbers hand-added tables/GSIs.**
+  Regenerating `dynamodb.tf` is a full overwrite from `lambda/models/*.rb`, so a
+  table or `global_secondary_index` added straight into the `.tf` file — one the
+  models don't declare — used to vanish on the next run. Dropping a live GSI is
+  not harmless: queries against it start failing. The generator now diffs the
+  existing file and, when the regen would remove infrastructure it can't
+  re-derive, it warns and lists exactly what would disappear. An interactive run
+  prompts before overwriting; a generator auto-sync refuses and leaves the file
+  untouched. Pass `--force` (`-f`/`--yes`/`-y`) to overwrite anyway. The
+  `dynamodb.tf` header comment now spells out this behavior too. (Fixes the
+  misleading "harmless diff" framing in the 0.4.0 notes below.)
+
 - **Apply environment AWS profile in `belt deploy frontend`, `belt frontend env`, `belt logs`, and `belt server`**:
   Standalone frontend deployment (`belt deploy frontend <env>`), frontend env generation (`belt frontend env <env>`),
   log viewing (`belt logs`), and the local dev server (`belt server`) now load `infrastructure/<env>/belt.rb`

data/lib/belt/cli/doctor_command.rb

@@ -262,19 +262,33 @@ module Belt
         end
       end
 
+      # Which GSIs a model's belongs_to declarations require. This MUST agree with the
+      # generator (TablesCommand#extract_belongs_to_indexes) or the two halves of the gem
+      # disagree: the generator refuses to create an index the preflight then demands,
+      # and `belt setup tables` → `belt deploy` loops forever.
+      #
+      # `index: false` opts out — the reverse lookup is covered some other way (the
+      # model's own indexes() entry under a different key, or no reverse lookup at all).
+      # The generator skips those, so the preflight must too.
+      #
+      # An explicit `index: 'Name'` overrides the convention name; we honour it so the
+      # check matches the GSI the model actually declared.
       def extract_expected_indexes(content)
         indexes = []
-        content.lines.reject { |line| line.strip.start_with?('#') }.join
-               .scan(/belongs_to\s+:(\w+)/) do |match|
-          association_name = match[0]
-          indexes << {
-            name: "#{Belt::Inflector.classify(association_name)}Index",
-            association: association_name
-          }
+        uncommented(content).scan(/belongs_to\s+:(\w+)([^\n]*)/) do |association_name, options|
+          next if options.match?(/index:\s*false/)
+
+          explicit = options.match(/index:\s*['"]([^'"]+)['"]/)
+          name = explicit ? explicit[1] : "#{Belt::Inflector.classify(association_name)}Index"
+          indexes << { name: name, association: association_name }
         end
         indexes
       end
 
+      def uncommented(content)
+        content.lines.reject { |line| line.strip.start_with?('#') }.join
+      end
+
       def check_cognito_auth
         return unless Belt.root?
 

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.1'
+  VERSION = '0.4.3'
 end

metadata

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