belt 0.4.1 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 846db7f1373b5bd98f3e795404b1f157825f5dd94541bd46aa76e3510ba89adf
-  data.tar.gz: 251135fea6ee2d3d55e7dcdf46b98460ddc3df50fa1e4113b561f721755c935d
+  metadata.gz: e17e0755e497e26d8bd10604e6f050b0c6e0b69e3627276f8d83be984862d5da
+  data.tar.gz: b4249c4ac11715ae45a091c3eced0d0bad8ecd5d89a750edfaa8586ab6449758
 SHA512:
-  metadata.gz: 60b0ecf81e375ea1c219c84ccf7f90d568437cc81507c708ec56a40f903178e0611e5b6be03e1e71185ce66263d1ec0c12ddee8e1a4d2cfdc26f99dba4828c48
-  data.tar.gz: fb3fa14275a68c7e79892504d0fef2cbe86727225033a7d7bc3c1272b963413b5ed7259c3a5c2f1e202770d16b0234ff242571e4d2b7abed50a040090da250e1
+  metadata.gz: abe5b18f7eeeb92bba2863746e7cc71d854078462274993403c4d7b93af81ff2c82a3b5c1db2fbdf537f8a139ec15964d76aad042505ade12ad64e6069f40a5a
+  data.tar.gz: dba1d0cca64620fc48b495ee844600e7a8e38c577ad3f27ada191263038f38a081a3d640f9a66e00fd97c138e1686ae91654d6995225d357bec8a5016e903f5e

data/CHANGELOG.md

@@ -4,6 +4,18 @@
 
 ### 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/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.2'
 end

metadata

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