belt 0.2.17 → 0.3.14

data/lib/belt/cli/generate_command.rb

@@ -3,8 +3,10 @@
 require 'fileutils'
 require 'erb'
 require_relative 'app_detection'
+require_relative 'auth_command'
 require_relative 'environment_command'
 require_relative 'frontend_command'
+require_relative 'frontend_registry'
 require_relative 'tables_command'
 require_relative 'views_command'
 require_relative 'generator_registry'
@@ -14,7 +16,8 @@ module Belt
   module CLI
     class GenerateCommand
       TEMPLATE_DIR = File.expand_path('../../templates/generate', __dir__)
-      GENERATORS = %w[scaffold resource model controller environment frontend views].freeze
+
+      GENERATORS = %w[scaffold resource model controller environment frontend views index auth].freeze
 
       include AppDetection
 
@@ -26,12 +29,14 @@ module Belt
           usage: 'belt generate scaffold <name> [field:type ...] [options]',
           options: [
             ['--skip-views', 'Skip generating frontend view pages'],
+            ['--frontend NAME', 'Target frontend when several exist'],
             ['--force, -f', 'Overwrite existing resource files (skip collision check)']
           ],
           examples: [
             ['belt g scaffold post title body:text'],
             ['belt g scaffold comment post:references body:text'],
             ['belt g scaffold task --skip-views'],
+            ['belt g scaffold bag --frontend ops'],
             ['belt g scaffold post title body:text --force']
           ],
           notes: <<~NOTES
@@ -42,7 +47,7 @@ module Belt
               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)
+              <frontend>/src/pages/<names>/                      React pages (if a frontend exists)
 
             Nested Resources:
               Use `<parent>:references` to create a nested resource. This will:
@@ -126,6 +131,10 @@ module Belt
 
         return Belt::CLI::ViewsCommand.run(args) if generator == 'views'
 
+        return Belt::CLI::IndexCommand.run(['add'] + args) if generator == 'index'
+
+        return Belt::CLI::AuthCommand.run(args) if generator == 'auth'
+
         name = args.shift
         if name.nil? || name.empty?
           print_generator_help(generator)
@@ -136,8 +145,10 @@ module Belt
 
         force = args.delete('--force') || args.delete('-f')
         skip_views = args.delete('--skip-views')
+        frontend_name = FrontendRegistry.extract_flag!(args, '--frontend')
         fields = args.map { |arg| parse_field(arg) }
-        new(generator, name, fields, skip_views: skip_views, force: force).generate
+        new(generator, name, fields, skip_views: skip_views, force: force,
+                                     frontend_name: frontend_name).generate
       end
 
       def self.parse_field(arg)
@@ -192,8 +203,9 @@ module Belt
             scaffold      Generate model, controller, routes, schema, and views (full REST resource)
             model         Generate an ActiveItem model
             controller    Generate a controller
+            auth          Generate Cognito user pool infrastructure
             environment   Create a new deployment environment
-            frontend      Scaffold a frontend app (react, vue, svelte)
+            frontend      Scaffold a frontend app (react, vue, svelte; --name / --path for extras)
             views         Generate React pages for a resource
 
           Aliases:
@@ -221,7 +233,9 @@ module Belt
             belt g controller comments
             belt g environment staging
             belt g frontend react
+            belt g frontend react --name ops --path ops-app
             belt g views post title body:text
+            belt g views bag --frontend ops
 
           Run 'belt generate <generator> --help' for detailed help on a specific generator.
         HELP
@@ -264,12 +278,14 @@ module Belt
         puts "\n#{info[:notes]}" if info[:notes]
       end
 
-      def initialize(generator, name, fields, skip_views: false, force: false)
+      # rubocop:disable Metrics/ParameterLists -- keyword options for generator flags
+      def initialize(generator, name, fields, skip_views: false, force: false, frontend_name: nil)
         @generator = generator
         @name = name.downcase.gsub(/[^a-z0-9_]/, '_')
         @fields = fields
         @skip_views = skip_views
         @force = force
+        @frontend_name = frontend_name
         @app_name = detect_namespace
         @module_name = @app_name.split(/[-_]/).map(&:capitalize).join
         @singular_name = Belt::Inflector.singularize(@name)
@@ -277,6 +293,7 @@ module Belt
         @class_name = Belt::Inflector.classify(@singular_name)
         @references, @regular_fields = @fields.partition { |f| f[:type] == 'references' }
       end
+      # rubocop:enable Metrics/ParameterLists
 
       def generate
         case @generator
@@ -286,7 +303,9 @@ module Belt
         when 'model'
           check_model_collision! unless @force
           generate_model_standalone
-        when 'controller' then generate_controller
+        when 'controller'
+          generate_controller
+          inject_routes
         end
       end
 
@@ -347,18 +366,6 @@ module Belt
         inject_parent_associations
         sync_tables
         generate_views_if_frontend
-        puts "\n✓ Scaffold '#{@singular_name}' generated!"
-        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.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')
-        @references.each do |ref|
-          parent_model_path = "lambda/models/#{ref[:referenced_model]}.rb"
-          puts "  #{parent_model_path} (updated — added has_many)" if File.exist?(parent_model_path)
-        end
       end
 
       def generate_model_standalone
@@ -382,25 +389,26 @@ module Belt
 
       def inject_routes
         routes_file = find_routes_file_path
-        return unless routes_file && File.exist?(routes_file)
 
-        content = File.read(routes_file)
-        tables_arg = @fields.any? ? ", tables: [:#{@resource_name}]" : ''
+        if routes_file && File.exist?(routes_file)
+          content = File.read(routes_file)
+          tables_arg = @fields.any? ? ", tables: [:#{@resource_name}]" : ''
 
-        # If this resource has a reference to a parent that already has routes, nest it
-        parent_ref = @references.find do |ref|
-          parent_resource = Belt::Inflector.pluralize(ref[:referenced_model])
-          content.match?(/resources :#{Regexp.escape(parent_resource)}\b/)
-        end
+          # If this resource has a reference to a parent that already has routes, nest it
+          parent_ref = @references.find do |ref|
+            parent_resource = Belt::Inflector.pluralize(ref[:referenced_model])
+            content.match?(/resources :#{Regexp.escape(parent_resource)}\b/)
+          end
 
-        if parent_ref
-          inject_nested_route(content, routes_file, parent_ref, tables_arg)
+          if parent_ref
+            inject_nested_route(content, routes_file, parent_ref, tables_arg)
+          else
+            inject_top_level_route(content, routes_file, tables_arg)
+          end
         else
-          inject_top_level_route(content, routes_file, tables_arg)
+          # Legacy projects without config/routes.rb — update the manifest directly
+          inject_route_manifest
         end
-
-        # Also update route manifest
-        inject_route_manifest
       end
 
       def inject_nested_route(content, routes_file, parent_ref, tables_arg)
@@ -452,18 +460,25 @@ module Belt
         elsif content.include?('# resources :posts')
           content.sub!('# resources :posts', resource_line)
         else
-          # Find the target namespace block and insert before its closing `end`
+          # Find the target gateway (or legacy namespace) block and insert before its closing `end`
+          gateway_pattern = /^(\s*)gateway :#{Regexp.escape(@app_name)}\b[^\n]*do\s*\n(.*?)^\1end/m
           namespace_pattern = /^(\s*)namespace :#{Regexp.escape(@app_name)}\b[^\n]*do\s*\n(.*?)^\1end/m
 
-          if content.match?(namespace_pattern)
-            content.sub!(namespace_pattern) do |match|
+          target_pattern = if content.match?(gateway_pattern)
+                             gateway_pattern
+                           elsif content.match?(namespace_pattern)
+                             namespace_pattern
+                           end
+
+          if target_pattern
+            content.sub!(target_pattern) do |match|
               indent = ::Regexp.last_match(1)
               match.sub(/^(#{indent})end\z/m, "#{indent}  #{resource_line}\n#{indent}end")
             end
           else
-            single_ns_pattern = /^(\s*)namespace :\w+\b[^\n]*do\s*\n(.*?)^\1end/m
-            if content.match?(single_ns_pattern)
-              content.sub!(single_ns_pattern) do |match|
+            single_gw_pattern = /^(\s*)(?:gateway|namespace) :\w+\b[^\n]*do\s*\n(.*?)^\1end/m
+            if content.match?(single_gw_pattern)
+              content.sub!(single_gw_pattern) do |match|
                 indent = ::Regexp.last_match(1)
                 match.sub(/^(#{indent})end\z/m, "#{indent}  #{resource_line}\n#{indent}end")
               end
@@ -592,8 +607,7 @@ module Belt
           next unless File.exist?(parent_model_path)
 
           content = File.read(parent_model_path)
-          has_many_line = "  has_many :#{@resource_name}, foreign_key: '#{ref[:referenced_model]}_id', " \
-                          "index: '#{Belt::Inflector.classify(ref[:referenced_model])}Index'"
+          has_many_line = "  has_many :#{@resource_name}"
 
           next if content.include?("has_many :#{@resource_name}")
 
@@ -625,10 +639,15 @@ module Belt
       end
 
       def generate_views_if_frontend
-        return unless Dir.exist?('frontend/src')
         return if @skip_views
 
-        Belt::CLI::ViewsCommand.new(@name, @fields, force: @force).generate
+        registry = FrontendRegistry.new
+        return if registry.empty?
+
+        frontend = registry.resolve!(@frontend_name)
+        return unless Dir.exist?(frontend.src_dir)
+
+        Belt::CLI::ViewsCommand.new(@name, @fields, force: @force, quiet: true, frontend: frontend).generate
       end
     end
   end

data/lib/belt/cli/index_command.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+require_relative 'tables_command'
+require_relative '../inflector'
+
+module Belt
+  module CLI
+    class IndexCommand
+      MODULE_DIR = 'infrastructure/modules/app'
+      DYNAMODB_TF = File.join(MODULE_DIR, 'dynamodb.tf')
+
+      def self.run(args)
+        action = args.shift
+
+        case action
+        when 'add', nil
+          add(args)
+        when 'remove', 'rm'
+          remove(args)
+        when '--help', '-h'
+          puts usage
+        else
+          # Treat first arg as table name if no subcommand
+          add([action] + args)
+        end
+      end
+
+      def self.usage
+        <<~USAGE
+          Usage: belt generate index <table> <IndexName> --partition-key <key> [--sort-key <key>]
+                 belt destroy index <table> <IndexName>
+
+          Add or remove a Global Secondary Index (GSI) from dynamodb.tf.
+
+          Examples:
+            belt generate index messages ConversationIndex --partition-key conversation_id
+            belt generate index messages RecentByUserIndex --partition-key user_id --sort-key created_at
+            belt destroy index messages ConversationIndex
+
+          Note: After modifying indexes, run `belt deploy` to apply changes to AWS.
+                Adding a GSI to an existing table takes ~5-10 minutes (AWS limitation).
+        USAGE
+      end
+
+      def self.add(args)
+        table, index_name, partition_key, sort_key = parse_add_args(args)
+        new(table, index_name, partition_key: partition_key, sort_key: sort_key).add
+      end
+
+      def self.remove(args)
+        table = args.shift
+        index_name = args.shift
+
+        if table.nil? || index_name.nil?
+          abort "Usage: belt destroy index <table> <IndexName>\n\n" \
+                'Example: belt destroy index messages ConversationIndex'
+        end
+
+        new(table, index_name).remove
+      end
+
+      def self.parse_add_args(args)
+        table = args.shift
+        index_name = args.shift
+        partition_key = nil
+        sort_key = nil
+
+        i = 0
+        while i < args.length
+          case args[i]
+          when '--partition-key', '-p'
+            i += 1
+            partition_key = args[i]
+          when '--sort-key', '-s'
+            i += 1
+            sort_key = args[i]
+          end
+          i += 1
+        end
+
+        if table.nil? || index_name.nil? || partition_key.nil?
+          abort "Usage: belt generate index <table> <IndexName> --partition-key <key> [--sort-key <key>]\n\n" \
+                'Example: belt generate index messages ConversationIndex --partition-key conversation_id'
+        end
+
+        [table, index_name, partition_key, sort_key]
+      end
+
+      def initialize(table, index_name, partition_key: nil, sort_key: nil)
+        @table = table
+        @index_name = index_name
+        @partition_key = partition_key
+        @sort_key = sort_key
+      end
+
+      def add
+        validate_tf_exists!
+
+        content = File.read(DYNAMODB_TF)
+        table_resource = "aws_dynamodb_table\" \"#{@table}\""
+
+        unless content.include?(table_resource)
+          abort "Error: Table '#{@table}' not found in #{DYNAMODB_TF}.\n" \
+                'Run `belt setup tables` first to generate the table.'
+        end
+
+        if content.include?("name            = \"#{@index_name}\"")
+          puts "  skip    #{@index_name} (already exists on #{@table})"
+          return
+        end
+
+        dynamo_pk = Belt::Inflector.camelize_lower(@partition_key)
+        dynamo_sk = @sort_key ? Belt::Inflector.camelize_lower(@sort_key) : nil
+
+        # Build the GSI block
+        gsi_block = build_gsi_block(dynamo_pk, dynamo_sk)
+
+        # Build attribute blocks for new keys
+        attr_blocks = build_attribute_blocks(content, dynamo_pk, dynamo_sk)
+
+        # Insert into the table resource
+        insert_gsi(content, gsi_block, attr_blocks)
+
+        puts "  create  #{@index_name} on #{@table} (partition: #{dynamo_pk}#{", sort: #{dynamo_sk}" if dynamo_sk})"
+        puts "\n  Run `belt deploy` to apply. Adding a GSI to an existing table takes ~5-10 min."
+      end
+
+      def remove
+        validate_tf_exists!
+
+        content = File.read(DYNAMODB_TF)
+
+        unless content.include?("name            = \"#{@index_name}\"")
+          abort "Error: Index '#{@index_name}' not found in #{DYNAMODB_TF}."
+        end
+
+        # Remove the GSI block
+        content.sub!(/\n\s*global_secondary_index \{\n\s*name\s*=\s*"#{Regexp.escape(@index_name)}".*?\n\s*\}/m, '')
+
+        File.write(DYNAMODB_TF, content)
+        puts "  remove  #{@index_name} from #{@table}"
+        puts "\n  Run `belt deploy` to apply."
+      end
+
+      private
+
+      def validate_tf_exists!
+        return if File.exist?(DYNAMODB_TF)
+
+        abort "Error: #{DYNAMODB_TF} not found.\nRun `belt setup tables` first."
+      end
+
+      def build_gsi_block(dynamo_pk, dynamo_sk)
+        lines = []
+        lines << '  global_secondary_index {'
+        lines << "    name            = \"#{@index_name}\""
+        lines << "    hash_key        = \"#{dynamo_pk}\""
+        lines << "    range_key       = \"#{dynamo_sk}\"" if dynamo_sk
+        lines << '    projection_type = "ALL"'
+        lines << '  }'
+        lines.join("\n")
+      end
+
+      def build_attribute_blocks(content, dynamo_pk, dynamo_sk)
+        blocks = []
+        [dynamo_pk, dynamo_sk].compact.each do |key|
+          next if content.include?("name = \"#{key}\"")
+
+          blocks << "\n  attribute {\n    name = \"#{key}\"\n    type = \"S\"\n  }"
+        end
+        blocks.join
+      end
+
+      def insert_gsi(content, gsi_block, attr_blocks)
+        # Find the table's resource block and insert before point_in_time_recovery
+        table_pattern = /resource "aws_dynamodb_table" "#{Regexp.escape(@table)}" \{.*?point_in_time_recovery/m
+
+        content.sub!(table_pattern) do |match|
+          # Insert attributes after last existing attribute block
+          unless attr_blocks.empty?
+            match.sub!(/(  attribute \{.*?\n  \})(?!.*attribute)/m) { |attr_match| "#{attr_match}#{attr_blocks}" }
+          end
+
+          # Insert GSI before point_in_time_recovery
+          match.sub('point_in_time_recovery', "#{gsi_block}\n\n  point_in_time_recovery")
+        end
+
+        File.write(DYNAMODB_TF, content)
+      end
+    end
+  end
+end

data/lib/belt/cli/lambda_config_command.rb

@@ -34,7 +34,7 @@ module Belt
       SUPPORTED_KEYS = %w[
         timeout memory_size env_vars env_keys
         s3_buckets dynamodb_tables sns_triggers sqs_triggers
-        reserved_concurrency ephemeral_storage
+        reserved_concurrency ephemeral_storage iam_policy_arns
       ].freeze
 
       def self.run(args)
@@ -112,6 +112,7 @@ module Belt
             sqs_triggers         SQS queue triggers
             reserved_concurrency Reserved concurrency limit
             ephemeral_storage    Ephemeral storage in MB (512-10240)
+            iam_policy_arns      Additional IAM policy ARNs (supports ref())
         HELP
       end
 
@@ -145,8 +146,13 @@ module Belt
         return {} unless Dir.exist?(config_dir)
 
         configs = {}
-        Dir.glob(File.join(config_dir, '*.yml')).each do |file|
-          name = File.basename(file, '.yml')
+        files = Dir.glob(File.join(config_dir, '*.{yml,yaml}'))
+        # Sort so .yml comes before .yaml for the same basename (yml wins if both exist)
+        files.sort_by! { |f| [File.basename(f).sub(/\.ya?ml\z/, ''), f.end_with?('.yml') ? 0 : 1] }
+        files.each do |file|
+          name = File.basename(file).sub(/\.ya?ml\z/, '')
+          next if configs.key?(name) # .yml takes precedence
+
           raw = YAML.safe_load_file(file, aliases: true) || {}
           configs[name] = resolve_environment(raw, environment)
         end

data/lib/belt/cli/routes_command/request_model_inference.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module Belt
+  module CLI
+    class RoutesCommand
+      # Infers request_model and response_model from contracts using naming conventions.
+      #
+      # Request model convention cascade (first match wins):
+      #   1. :<verb>_<gateway>_<singular_resource>  (e.g. :create_customer_item)
+      #   2. :<verb>_<singular_resource>            (e.g. :create_item)
+      #
+      # Response model convention:
+      #   Singular of the resource name matches a `model` in contracts.
+      #   e.g. `resources :items` → looks for `model :item` in contracts.rb
+      #
+      # Only request_model inference applies to body-accepting verbs (POST/PUT/PATCH).
+      # Response model inference applies to all verbs on resource routes.
+      # Explicit values always win — inference only fills in blanks.
+      module RequestModelInference
+        private
+
+        # Applies convention-based request_model inference to all routes.
+        # Requires the set of known contract names from contracts.rb.
+        def infer_request_models!(routes, contracts_file)
+          contract_names = load_contract_names(contracts_file)
+          return if contract_names[:request].empty? && contract_names[:response].empty?
+
+          routes.each do |route|
+            infer_request_model_for!(route, contract_names[:request])
+            infer_response_model_for!(route, contract_names[:response])
+          end
+        end
+
+        def load_contract_names(contracts_file)
+          empty_result = { request: Set.new, response: Set.new }
+          return empty_result unless contracts_file && File.exist?(contracts_file)
+
+          # Reset application state for clean contract loading
+          Belt.instance_variable_set(:@application, nil)
+          begin
+            eval(File.read(contracts_file), binding, contracts_file) # rubocop:disable Security/Eval
+          rescue StandardError => e
+            warn "Warning: Failed to load contracts for inference: #{e.message}"
+            return empty_result
+          end
+
+          schema = Belt.application.schema.to_h
+          request_names = Set.new
+          response_names = Set.new
+          (schema[:request_models] || {}).each_key { |name| request_names << name.to_s }
+          (schema[:response_models] || {}).each_key { |name| response_names << name.to_s }
+          { request: request_names, response: response_names }
+        end
+
+        def infer_request_model_for!(route, request_contracts)
+          return if request_contracts.empty?
+          return unless route[:request_model].to_s.empty?
+          return unless body_accepting_verb?(route[:verb])
+
+          inferred = infer_request_model_for_route(route, request_contracts)
+          route[:request_model] = inferred if inferred
+        end
+
+        def infer_response_model_for!(route, response_contracts)
+          return if response_contracts.empty?
+          return unless route[:response_model].to_s.empty?
+
+          inferred = infer_response_model_for_route(route, response_contracts)
+          route[:response_model] = inferred if inferred
+        end
+
+        def infer_request_model_for_route(route, contract_names)
+          verb_prefix = infer_verb_prefix(route[:verb], route[:action])
+          return nil unless verb_prefix
+
+          resource_name = extract_singular_resource(route)
+          return nil unless resource_name
+
+          gateway = route[:gateway]
+
+          # Cascade: gateway-scoped first, then generic
+          candidates = [
+            "#{verb_prefix}_#{gateway}_#{resource_name}",
+            "#{verb_prefix}_#{resource_name}"
+          ]
+
+          candidates.find { |candidate| contract_names.include?(candidate) }
+        end
+
+        def infer_response_model_for_route(route, response_contracts)
+          resource_name = extract_singular_resource(route)
+          return nil unless resource_name
+
+          # Convention: singular resource name matches a response model
+          return resource_name if response_contracts.include?(resource_name)
+
+          nil
+        end
+
+        def infer_verb_prefix(verb, action)
+          # Map HTTP verb + action to the contract naming prefix
+          case action
+          when 'create' then 'create'
+          when 'update' then 'update'
+          else
+            # For non-standard actions on body verbs, don't infer
+            case verb
+            when 'POST' then 'create'
+            when 'PUT', 'PATCH' then 'update'
+            end
+          end
+        end
+
+        def extract_singular_resource(route)
+          # Extract the resource name from the path
+          segments = route[:path].split('/').reject(&:empty?)
+          # Find the last non-param segment that looks like a resource
+          resource_segments = segments.reject { |s| s.start_with?('{', ':') }
+          return nil if resource_segments.empty?
+
+          resource = resource_segments.last
+          Belt::Inflector.singularize(resource.gsub('-', '_'))
+        end
+
+        def body_accepting_verb?(verb)
+          %w[POST PUT PATCH].include?(verb)
+        end
+      end
+    end
+  end
+end

data/lib/belt/cli/routes_command/route_inference.rb

@@ -14,9 +14,10 @@ module Belt
           non_param = segments.reject { |s| s.start_with?(':', '{') }
           return gateway.name if non_param.empty?
 
-          # Nested resources (/posts/{id}/comments) and scoped resources (/admin/users):
-          # join non-param segments → posts/comments, admin/users
-          return non_param.map { |s| s.gsub('-', '_') }.join('/') if route.resource? && non_param.length > 1
+          # Nested resources (/posts/{id}/comments): use the last non-param segment
+          # as the controller name (matches Rails — nesting affects URL, not controller lookup).
+          # Scoped resources (/admin/users) still use the full path when controller is explicitly set.
+          return non_param.last.gsub('-', '_') if route.resource? && non_param.length > 1
 
           # For non-resource routes with a single segment (e.g., post '/signup' in :onboarding),
           # the segment is the action name, not the controller. Use the gateway name as controller.