belt 0.2.11 → 0.2.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 43ae84461595be08ca6caada3afd148ccfa0db94bfc2e2bd864a9b466d41f087
-  data.tar.gz: 1f33826b8c7a7b068458db8ca38aa9910079e16f04c3c5c727550f084ed85075
+  metadata.gz: 43bc6e6cb774005faa3bab6b5133403255636327e3dd017ad4acad8fd9a2c884
+  data.tar.gz: fe11f89e1efa821750dea2953c70bbc21fe24bea394d418c2b870a2804adf331
 SHA512:
-  metadata.gz: 81532edca53a084bdd6aabf5e7027fd1653ec0fc4c592b0bdb60374283c7c59512a2217405d3a19f32a975bcbcbbebdf9f9a97d952a25b1567e05af8e2cb879d
-  data.tar.gz: d5ff609d6526f8cc59964df6da091a43150eca9d1c6f625dee27b070db0c56bd90ef58ef11c42f57e27259f169c477a4c1c548f9ca0f4c4f916c8bea540763bb
+  metadata.gz: d5c4900624a6435b178455b5aa7e6f34c08d7c2e75e2d1ec3c1b69e717a5964a390ba59a4ff8ccad1be797d29273bddc4354c235f83070d00bb7517d60bcb38e
+  data.tar.gz: a47bc3063743a278e4241faf65c510ede23ec922c167469f2654627f3079bb558893194f717979002354e07153e41cee257785e8b0f7dea187fc391fb351e5f3

data/CHANGELOG.md

@@ -1,6 +1,47 @@
 # Changelog
 
-## Unreleased
+## 0.2.12
+
+### Rename: `routes.tf.rb` → `routes.rb`, `schema.tf.rb` → `contracts.rb`
+
+The `.tf.rb` extension was a vestige of when these files produced HCL output — that hasn't been the case for a while. New apps now get clean, Rails-familiar names:
+
+- `config/routes.rb` — API route definitions
+- `config/contracts.rb` — API request/response contracts
+
+**Backward compatible:** All detection helpers (`Belt.root`, `Belt.routes_file`, `Belt.contracts_file`, `find_routes_file_path`, `find_contracts_file_path`) check new names first, then fall back to `*.tf.rb` and `infrastructure/` paths. Existing apps continue working without changes.
+
+### New command: `belt contracts`
+
+Dedicated CLI command for inspecting API contracts, separate from `belt routes`:
+
+```bash
+belt contracts                    # Human-readable table of request/response models
+belt contracts -f json            # JSON output (for tooling/CI)
+belt contracts -g post            # Filter by pattern
+belt contracts --file path.rb     # Explicit file override
+```
+
+Previously, contracts were only accessible as a side-effect of `belt routes -f json --schema <file>`. Now they have their own first-class command. `belt routes -f json` continues to include models for backward compatibility.
+
+### Other changes
+
+- `Belt.schema_file` is now an alias for `Belt.contracts_file`
+- `find_schema_file_path` is now an alias for `find_contracts_file_path`
+- Module template updated: `source` points to `config/routes.rb`
+- All scaffold/generator help text and templates reference new filenames
+
+## 0.2.13
+
+### Template cleanup
+
+- **Model template**: single-line `attr_accessor` instead of one per attribute; removed redundant `to_h` (ActiveItem::Base already provides it)
+- **Controller template**: uses implicit response pattern (instance variable assigns) instead of explicit `success_response` calls; `response_status :created` for create actions, `head :no_content` for destroy
+- **Gemfile template**: removed `activeitem` and `lambda_loadout` (already belt gem dependencies)
+- **gitignore template**: excludes `lambda/lib/routes/` (generated artifact from `belt routes`)
+- **Removed `require 'activeitem'`** from api.rb, environment.rb, and application_record.rb templates (belt requires it transitively)
+- **Removed `ActiveItem.configure` boilerplate** from api.rb and environment.rb templates (activeitem 0.0.13+ defaults `table_prefix` and `environment` from ENV vars)
+- Bumped activeitem dependency to `>= 0.0.13`
 
 ## 0.2.11
 

data/lib/belt/cli/app_detection.rb

@@ -40,17 +40,31 @@ module Belt
         name.to_s.downcase.tr('_', '-')
       end
 
-      # Finds routes.tf.rb checking config/ first, then infrastructure/ (legacy).
+      # Finds routes file checking config/routes.rb first, then legacy paths.
       def find_routes_file_path
-        candidates = ['config/routes.tf.rb', 'infrastructure/routes.tf.rb']
+        candidates = [
+          'config/routes.rb',
+          'config/routes.tf.rb',
+          'infrastructure/routes.tf.rb'
+        ]
         candidates.find { |f| File.exist?(f) }
       end
 
-      # Finds schema.tf.rb checking config/ first, then infrastructure/ (legacy).
-      def find_schema_file_path
-        candidates = ['config/schema.tf.rb', 'infrastructure/schema.tf.rb']
+      # Finds contracts file checking config/contracts.rb first, then legacy paths.
+      def find_contracts_file_path
+        candidates = [
+          'config/contracts.rb',
+          'config/contracts.tf.rb',
+          'config/schema.tf.rb',
+          'infrastructure/schema.tf.rb'
+        ]
         candidates.find { |f| File.exist?(f) }
       end
+
+      # Legacy alias for backward compatibility
+      def find_schema_file_path
+        find_contracts_file_path
+      end
     end
   end
 end

data/lib/belt/cli/contracts_command.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'optparse'
+require_relative '../route_dsl'
+require_relative 'routes_command/schema_loader'
+
+module Belt
+  module CLI
+    class ContractsCommand
+      include RoutesCommand::SchemaLoader
+
+      def self.run(args)
+        new(args).run
+      end
+
+      def initialize(args)
+        @options = {}
+        parse_options(args)
+      end
+
+      def run
+        contracts_file = find_contracts_file
+        unless contracts_file
+          abort 'Error: No contracts file found. ' \
+                'Expected config/contracts.rb (or config/contracts.tf.rb, config/schema.tf.rb)'
+        end
+
+        models = load_contracts(contracts_file)
+
+        if @options[:format] == 'json'
+          output_json(models)
+        else
+          output_concise(models)
+        end
+      end
+
+      private
+
+      def parse_options(args)
+        OptionParser.new do |opts|
+          opts.banner = 'Usage: belt contracts [options]'
+
+          opts.on('-f', '--format FORMAT', 'Output format: concise (default), json') do |format|
+            @options[:format] = format
+          end
+
+          opts.on('-g', '--grep PATTERN', 'Filter contracts matching pattern') do |pattern|
+            @options[:grep] = pattern
+          end
+
+          opts.on('--file FILE', 'Path to contracts file (overrides auto-detection)') do |file|
+            @options[:contracts_file] = file
+          end
+
+          opts.on('-h', '--help', 'Show this help') do
+            puts opts
+            exit
+          end
+        end.parse!(args)
+      end
+
+      def find_contracts_file
+        if @options[:contracts_file]
+          file = @options[:contracts_file]
+          return file if File.exist?(file)
+
+          abort "Error: Specified contracts file not found: #{file}"
+        end
+
+        candidates = [
+          'config/contracts.rb',
+          'config/contracts.tf.rb',
+          'config/schema.tf.rb',
+          'infrastructure/schema.tf.rb'
+        ]
+        candidates.find { |f| File.exist?(f) }
+      end
+
+      def load_contracts(file)
+        Belt.instance_variable_set(:@application, nil)
+        begin
+          eval(File.read(file), binding, file) # rubocop:disable Security/Eval
+        rescue StandardError => e
+          abort "Error: Failed to load contracts file #{file}: #{e.message}"
+        end
+
+        schema = Belt.application.schema.to_h
+        models = build_models_from_schema(schema)
+        models = apply_grep(models) if @options[:grep]
+        models
+      end
+
+      def apply_grep(models)
+        pattern = Regexp.new(@options[:grep], Regexp::IGNORECASE)
+        models.select do |m|
+          m[:name].match?(pattern) ||
+            m[:kind].match?(pattern) ||
+            m[:description].match?(pattern)
+        end
+      end
+
+      def output_json(models)
+        puts JSON.pretty_generate(models: models)
+      end
+
+      def output_concise(models)
+        return puts('No contracts defined.') if models.empty?
+
+        requests = models.select { |m| m[:kind] == 'request' }
+        responses = models.select { |m| m[:kind] == 'response' }
+
+        if requests.any?
+          puts 'REQUEST MODELS'
+          puts '-' * 60
+          requests.each { |m| print_model(m) }
+          puts
+        end
+
+        if responses.any?
+          puts 'RESPONSE MODELS'
+          puts '-' * 60
+          responses.each { |m| print_model(m) }
+        end
+
+        puts "\n#{models.length} contract(s) total (#{requests.length} request, #{responses.length} response)"
+      end
+
+      def print_model(model)
+        required = model[:required] || []
+        props = (model[:properties] || {}).map do |name, meta|
+          type = meta['type'] || meta[:type] || 'string'
+          req_marker = required.include?(name.to_s) ? ' *' : ''
+          "#{name}:#{type}#{req_marker}"
+        end
+
+        puts "  #{model[:name]} (#{model[:kind]})"
+        puts "    #{props.join(', ')}" if props.any?
+      end
+    end
+  end
+end

data/lib/belt/cli/destroy_command.rb

@@ -258,6 +258,9 @@ module Belt
             end
           end
 
+          # Empty S3 buckets before destroy — terraform can't delete non-empty buckets
+          empty_s3_buckets_in_state
+
           # Run destroy with auto-approve (user already confirmed)
           unless system('terraform', 'destroy', '-auto-approve')
             puts "\n✗ terraform destroy failed."
@@ -269,6 +272,77 @@ module Belt
         puts '  ✓ Infrastructure destroyed.'
       end
 
+      def empty_s3_buckets_in_state
+        output = `terraform state list 2>/dev/null`
+        return unless Process.last_status.success?
+
+        bucket_resources = output.lines.map(&:strip).grep(/\Aaws_s3_bucket\./)
+        return if bucket_resources.empty?
+
+        bucket_resources.each do |resource|
+          bucket_name = resolve_bucket_name(resource)
+          next unless bucket_name
+
+          empty_s3_bucket(bucket_name)
+        end
+      end
+
+      def resolve_bucket_name(resource)
+        output = `terraform state show '#{resource}' 2>/dev/null`
+        return nil unless Process.last_status.success?
+
+        match = output.match(/^\s*bucket\s*=\s*"([^"]+)"/)
+        match&.[](1)
+      end
+
+      def empty_s3_bucket(bucket_name)
+        # Check if bucket exists
+        `aws s3api head-bucket --bucket '#{bucket_name}' 2>&1`
+        return unless Process.last_status.success?
+
+        puts "  Emptying S3 bucket: #{bucket_name}"
+
+        # Delete all object versions (handles versioned buckets)
+        `aws s3 rm 's3://#{bucket_name}' --recursive 2>/dev/null`
+
+        # Also delete versioned objects and delete markers
+        delete_all_versions(bucket_name)
+      end
+
+      def delete_all_versions(bucket_name)
+        loop do
+          output = `aws s3api list-object-versions --bucket '#{bucket_name}' --max-items 1000 2>/dev/null`
+          break unless Process.last_status.success?
+
+          begin
+            data = JSON.parse(output)
+          rescue JSON::ParserError
+            break
+          end
+
+          versions = (data['Versions'] || []) + (data['DeleteMarkers'] || [])
+          break if versions.empty?
+
+          # Build delete objects payload
+          objects = versions.map do |v|
+            { 'Key' => v['Key'], 'VersionId' => v['VersionId'] }
+          end
+
+          delete_payload = JSON.generate({ 'Objects' => objects, 'Quiet' => true })
+
+          # Use a temp file for the payload since it can be large
+          require 'tempfile'
+          Tempfile.create(['delete-objects', '.json']) do |f|
+            f.write(delete_payload)
+            f.flush
+            `aws s3api delete-objects --bucket '#{bucket_name}' --delete 'file://#{f.path}' 2>/dev/null`
+          end
+
+          # If there's no next token, we're done
+          break unless data['NextToken'] || data['IsTruncated']
+        end
+      end
+
       def destroy_frontend
         dir = 'frontend'
         if Dir.exist?(dir)

data/lib/belt/cli/frontend_command.rb

@@ -59,6 +59,7 @@ module Belt
 
         install_dependencies(dest_dir)
         setup_frontend_infra_for_existing_environments
+        generate_views_for_existing_resources
 
         return if @quiet || !@announce
 
@@ -104,6 +105,28 @@ module Belt
         puts "  create  #{frontend_tf}" unless @quiet
       end
 
+      def generate_views_for_existing_resources
+        routes_file = find_routes_file_path
+        return unless routes_file && File.exist?(routes_file)
+
+        resources = extract_resources_from_routes(routes_file)
+        return if resources.empty?
+
+        puts "\n  Detected existing resources: #{resources.join(', ')}" unless @quiet
+        puts '  Generating views...' unless @quiet
+
+        require_relative 'views_command'
+        resources.each do |resource_name|
+          fields = ViewsCommand.read_schema_fields(resource_name)
+          ViewsCommand.new(resource_name, fields, force: true).generate
+        end
+      end
+
+      def extract_resources_from_routes(routes_file)
+        content = File.read(routes_file)
+        content.scan(/resources\s+:(\w+)/).flatten.uniq
+      end
+
       def copy_template(src_dir, dest_dir)
         Dir.glob("#{src_dir}/**/*", File::FNM_DOTMATCH).each do |src|
           next if File.directory?(src)

data/lib/belt/cli/generate_command.rb

@@ -38,8 +38,8 @@ module Belt
             Creates:
               lambda/models/<name>.rb                            Model with validations and fields
               lambda/controllers/<app>/<names>_controller.rb    RESTful controller (index, show, create, update, destroy)
-              config/routes.tf.rb                                Route entry added
-              config/schema.tf.rb                                API response contract added
+              config/routes.rb                                   Route entry added
+              config/contracts.rb                                API response contract added
               lambda/lib/routes/<app>_routes.rb                  Route manifest updated
               infrastructure/modules/app/dynamodb.tf             DynamoDB table generated
               frontend/src/pages/<names>/                        React pages (if frontend exists)
@@ -60,7 +60,7 @@ module Belt
           notes: <<~NOTES
             Creates:
               lambda/models/<name>.rb                            Model class inheriting from ApplicationRecord
-              config/schema.tf.rb                                API response contract added
+              config/contracts.rb                                API response contract added
               infrastructure/modules/app/dynamodb.tf             DynamoDB table generated
           NOTES
         },
@@ -333,8 +333,8 @@ module Belt
         puts "\nFiles created/updated:"
         puts "  lambda/models/#{@singular_name}.rb"
         puts "  lambda/controllers/#{@app_name}/#{@resource_name}_controller.rb"
-        puts "  #{find_routes_file_path || 'config/routes.tf.rb'} (updated)"
-        puts "  #{find_schema_file_path || 'config/schema.tf.rb'} (updated)"
+        puts "  #{find_routes_file_path || 'config/routes.rb'} (updated)"
+        puts "  #{find_contracts_file_path || 'config/contracts.rb'} (updated)"
         puts "  lambda/lib/routes/#{@app_name}_routes.rb (updated)"
         puts "  frontend/src/pages/#{@resource_name}/ (views)" if Dir.exist?('frontend/src')
       end
@@ -478,14 +478,16 @@ module Belt
         puts "  update  #{schema_file}"
       end
 
-      # Map generator field types to OpenAPI schema DSL types
+      # Map generator field types to schema DSL types.
+      # Preserves :text, :date, :datetime so views can render appropriate form inputs.
       def schema_type_for(field_type)
         case field_type.to_s
-        when 'text' then 'string'
+        when 'text' then 'text'
         when 'integer' then 'integer'
         when 'float' then 'number'
         when 'boolean' then 'boolean'
-        when 'date', 'datetime' then 'string'
+        when 'date' then 'date'
+        when 'datetime' then 'datetime'
         else 'string'
         end
       end
@@ -505,7 +507,7 @@ module Belt
         return unless Dir.exist?('frontend/src')
         return if @skip_views
 
-        Belt::CLI::ViewsCommand.new(@name, @fields).generate
+        Belt::CLI::ViewsCommand.new(@name, @fields, force: @force).generate
       end
     end
   end