belt 0.3.5 → 0.3.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 803700aa6a859842c684ea0dc77b455a050698f1585663346e2c0aa1c057687a
-  data.tar.gz: b442f719e65920b93f1ba09eb841ba6498490645630576e8700d448073f21731
+  metadata.gz: 0be7ca644efba0ca7b1e95b076bbae96873ced55d3251e5de235208169bbcce9
+  data.tar.gz: d5f0b277442b1b139fb48c306b4f2c0ca13ce30d6b35637a67749b549f6a7182
 SHA512:
-  metadata.gz: 6ebc34ade7cbbd8867330adbbe5c0ae2732719265d7afe1c080a4d9320c7d80e1dce316186f2de560bcda3df76ad8bdc4af31a2d7c3bd77d95c0dbd0c2fe41b5
-  data.tar.gz: 43abfb9e472722ca8728558edd91f2a41a8f77f5857d992528c915a35c36951f9b30548918d11f2a6291947714abd9f823049d22e3e3907ad850b16ae5c3331c
+  metadata.gz: cac4e33287828876e5f248dcf3536f2e4709b2637481453e9d5015711b8a1de4bfc854edfc429060c7929a17f3ec46b17dc15127474ce9bd0312f064c23d77ee
+  data.tar.gz: eca9b584458ff63559fe3e4fad915be300628ec0659ae4e3d7d7cac66bba8d8d2e2eb9dd9010174f3d6bce6d7e688356e1325070f7aec0150e518348ab8be50d

data/CHANGELOG.md

@@ -1,6 +1,40 @@
 # Changelog
 
-## Unreleased
+## 0.3.7
+
+### Bug Fix
+
+- **App name detection in worktrees**: `detect_app_name` now checks
+  `infrastructure/*/variables.tf` for `variable "app_name" { default = "..." }`
+  before falling back to the directory name. Fixes incorrect Lambda function
+  lookups (e.g. `belt logs`) when running from a git worktree whose directory
+  name doesn't match the actual app name.
+
+## 0.3.6
+
+### Enhancement
+
+- **Per-action request_model**: `request_model` on `resources` now accepts a Hash
+  to specify different validation schemas per action:
+  ```ruby
+  resources :items, request_model: { create: :create_item, update: :update_item }
+  ```
+  Symbol style (uniform for all body verbs) still works unchanged.
+
+- **Convention-based request_model inference**: When no explicit `request_model` is
+  set on a resource route, `belt routes` auto-discovers matching contracts from
+  `contracts.rb` using a naming cascade:
+  1. `:<verb>_<gateway>_<singular_resource>` (e.g. `:create_customer_item`)
+  2. `:<verb>_<singular_resource>` (e.g. `:create_item`)
+
+  Only applies to body-accepting verbs (POST/PUT/PATCH). Explicit `request_model:`
+  always takes priority. No matching contract = no validation (same as before).
+
+- **Convention-based response_model inference**: When no explicit `response_model` is
+  set on a resource route, `belt routes` auto-discovers a matching response model
+  from `contracts.rb` using the singular resource name.
+  e.g. `resources :items` → looks for `model :item` → auto-wires `response_model: :item`.
+  Applies to all verbs. Explicit `response_model:` always takes priority.
 
 ## 0.3.5
 

data/lib/belt/cli/app_detection.rb

@@ -17,7 +17,7 @@ module Belt
       end
 
       # Detects the application name.
-      # Prefers terraform.tfvars app_name, then falls back to directory name.
+      # Priority: terraform.tfvars app_name > variables.tf default > directory name.
       def detect_app_name
         # Check any environment tfvars for the app_name
         Dir.glob('infrastructure/*/terraform.tfvars').each do |f|
@@ -26,6 +26,10 @@ module Belt
           return match[1] if match
         end
 
+        # Check variables.tf for a default app_name value
+        name = detect_app_name_from_variables_tf
+        return name if name
+
         # Fall back to directory name
         File.basename(Dir.pwd)
       end
@@ -67,6 +71,27 @@ module Belt
       def find_schema_file_path
         find_contracts_file_path
       end
+
+      private
+
+      # Parses `variable "app_name" { default = "..." }` from any environment's variables.tf.
+      # This handles the common pattern where app_name is a Terraform variable with a default
+      # rather than being set directly in terraform.tfvars.
+      def detect_app_name_from_variables_tf
+        Dir.glob('infrastructure/*/variables.tf').each do |f|
+          content = File.read(f)
+          # Match the app_name variable block and extract its default value
+          next unless content.match?(/variable\s+"app_name"/)
+
+          # Extract default from within the variable block
+          block_match = content.match(/variable\s+"app_name"\s*\{([^}]*)\}/m)
+          next unless block_match
+
+          default_match = block_match[1].match(/default\s*=\s*"([^"]+)"/)
+          return default_match[1] if default_match
+        end
+        nil
+      end
     end
   end
 end

data/lib/belt/cli/deploy_command.rb

@@ -321,6 +321,19 @@ module Belt
           return match[1] if match
         end
 
+        # Try variables.tf for a default app_name value
+        vars_file = File.join(@infra_dir, @env, 'variables.tf')
+        if File.exist?(vars_file)
+          content = File.read(vars_file)
+          if content.match?(/variable\s+"app_name"/)
+            block_match = content.match(/variable\s+"app_name"\s*\{([^}]*)\}/m)
+            if block_match
+              default_match = block_match[1].match(/default\s*=\s*"([^"]+)"/)
+              return default_match[1] if default_match
+            end
+          end
+        end
+
         # Fall back to directory name
         File.basename(@project_root)
       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.rb

@@ -7,12 +7,14 @@ require_relative '../route_dsl'
 require_relative '../table_inference'
 require_relative 'routes_command/schema_loader'
 require_relative 'routes_command/route_inference'
+require_relative 'routes_command/request_model_inference'
 
 module Belt
   module CLI
     class RoutesCommand
       include SchemaLoader
       include RouteInference
+      include RequestModelInference
 
       def self.run(args)
         new(args).run
@@ -33,6 +35,11 @@ module Belt
         dsl = load_routes(routes_file)
         @table_inference = TableInference.new(@options[:tables_file])
         routes = collect_routes(dsl)
+
+        # Convention-based request_model inference from contracts
+        contracts_file = resolve_contracts_file(routes_file)
+        infer_request_models!(routes, contracts_file) if contracts_file
+
         routes = apply_grep(routes) if @options[:grep]
 
         warn 'Warning: --output-dir has no effect without --namespace' if @options[:output_dir] && !@options[:namespace]

data/lib/belt/route_dsl.rb

@@ -106,17 +106,37 @@ module Belt
     private
 
     def add_nested_resource_routes(resource_name, param_name, resource_options, actions)
-      @gateway.send(:add_route, :get, "#{@prefix}/#{resource_name}", resource_options) if actions.include?(:index)
-      @gateway.send(:add_route, :post, "#{@prefix}/#{resource_name}", resource_options) if actions.include?(:create)
+      if actions.include?(:index)
+        @gateway.send(:add_route, :get, "#{@prefix}/#{resource_name}",
+                      resolve_request_model_for(resource_options, :index))
+      end
+      if actions.include?(:create)
+        @gateway.send(:add_route, :post, "#{@prefix}/#{resource_name}",
+                      resolve_request_model_for(resource_options, :create))
+      end
       if actions.include?(:show)
-        @gateway.send(:add_route, :get, "#{@prefix}/#{resource_name}/{#{param_name}}", resource_options)
+        @gateway.send(:add_route, :get, "#{@prefix}/#{resource_name}/{#{param_name}}",
+                      resolve_request_model_for(resource_options, :show))
       end
       if actions.include?(:update)
-        @gateway.send(:add_route, :put, "#{@prefix}/#{resource_name}/{#{param_name}}", resource_options)
+        @gateway.send(:add_route, :put, "#{@prefix}/#{resource_name}/{#{param_name}}",
+                      resolve_request_model_for(resource_options, :update))
       end
       return unless actions.include?(:destroy)
 
-      @gateway.send(:add_route, :delete, "#{@prefix}/#{resource_name}/{#{param_name}}", resource_options)
+      @gateway.send(:add_route, :delete, "#{@prefix}/#{resource_name}/{#{param_name}}",
+                    resolve_request_model_for(resource_options, :destroy))
+    end
+
+    def resolve_request_model_for(options, action)
+      rm = options[:request_model]
+      case rm
+      when Hash
+        resolved = rm[action] || rm[action.to_s]
+        options.merge(request_model: resolved)
+      else
+        options
+      end
     end
 
     def merge_inherited_options(options)
@@ -200,11 +220,7 @@ module Belt
       resource_options = options.merge(route_type: :resources)
       actions = determine_actions(options)
 
-      add_route(:get, "/#{resource_name}", resource_options) if actions.include?(:index)
-      add_route(:post, "/#{resource_name}", resource_options) if actions.include?(:create)
-      add_route(:get, "/#{resource_name}/{#{param_name}}", resource_options) if actions.include?(:show)
-      add_route(:put, "/#{resource_name}/{#{param_name}}", resource_options) if actions.include?(:update)
-      add_route(:delete, "/#{resource_name}/{#{param_name}}", resource_options) if actions.include?(:destroy)
+      add_resource_routes(resource_name, param_name, resource_options, actions)
 
       return unless block_given?
 
@@ -226,10 +242,22 @@ module Belt
       actions = determine_actions(options, default: %i[show update destroy])
       resource_options = options.merge(route_type: :resource)
 
-      add_route(:get, "/#{resource_name}", resource_options) if actions.include?(:show)
-      add_route(:put, "/#{resource_name}", resource_options) if actions.include?(:update)
-      add_route(:delete, "/#{resource_name}", resource_options) if actions.include?(:destroy)
-      add_route(:post, "/#{resource_name}", resource_options) if actions.include?(:create)
+      if actions.include?(:show)
+        add_route(:get, "/#{resource_name}",
+                  resolve_request_model_for(resource_options, :show))
+      end
+      if actions.include?(:update)
+        add_route(:put, "/#{resource_name}",
+                  resolve_request_model_for(resource_options, :update))
+      end
+      if actions.include?(:destroy)
+        add_route(:delete, "/#{resource_name}",
+                  resolve_request_model_for(resource_options, :destroy))
+      end
+      return unless actions.include?(:create)
+
+      add_route(:post, "/#{resource_name}",
+                resolve_request_model_for(resource_options, :create))
     end
 
     private
@@ -271,6 +299,39 @@ module Belt
       options.merge(tables: [resource_name.to_sym])
     end
 
+    def add_resource_routes(resource_name, param_name, resource_options, actions)
+      if actions.include?(:index)
+        add_route(:get, "/#{resource_name}",
+                  resolve_request_model_for(resource_options, :index))
+      end
+      if actions.include?(:create)
+        add_route(:post, "/#{resource_name}",
+                  resolve_request_model_for(resource_options, :create))
+      end
+      if actions.include?(:show)
+        add_route(:get, "/#{resource_name}/{#{param_name}}",
+                  resolve_request_model_for(resource_options, :show))
+      end
+      if actions.include?(:update)
+        add_route(:put, "/#{resource_name}/{#{param_name}}",
+                  resolve_request_model_for(resource_options, :update))
+      end
+      return unless actions.include?(:destroy)
+
+      add_route(:delete, "/#{resource_name}/{#{param_name}}", resolve_request_model_for(resource_options, :destroy))
+    end
+
+    def resolve_request_model_for(options, action)
+      rm = options[:request_model]
+      case rm
+      when Hash
+        resolved = rm[action] || rm[action.to_s]
+        options.merge(request_model: resolved)
+      else
+        options
+      end
+    end
+
     def determine_actions(options, default: %i[index create show update destroy])
       if options[:only]
         Array(options[:only])
@@ -540,17 +601,37 @@ module Belt
       end
 
       def add_scoped_resource_routes(resource_name, param_name, resource_options, actions)
-        @gateway.send(:add_route, :get, build_path("/#{resource_name}"), resource_options) if actions.include?(:index)
-        @gateway.send(:add_route, :post, build_path("/#{resource_name}"), resource_options) if actions.include?(:create)
+        if actions.include?(:index)
+          @gateway.send(:add_route, :get, build_path("/#{resource_name}"),
+                        resolve_request_model_for(resource_options, :index))
+        end
+        if actions.include?(:create)
+          @gateway.send(:add_route, :post, build_path("/#{resource_name}"),
+                        resolve_request_model_for(resource_options, :create))
+        end
         if actions.include?(:show)
-          @gateway.send(:add_route, :get, build_path("/#{resource_name}/{#{param_name}}"), resource_options)
+          @gateway.send(:add_route, :get, build_path("/#{resource_name}/{#{param_name}}"),
+                        resolve_request_model_for(resource_options, :show))
         end
         if actions.include?(:update)
-          @gateway.send(:add_route, :put, build_path("/#{resource_name}/{#{param_name}}"), resource_options)
+          @gateway.send(:add_route, :put, build_path("/#{resource_name}/{#{param_name}}"),
+                        resolve_request_model_for(resource_options, :update))
         end
         return unless actions.include?(:destroy)
 
-        @gateway.send(:add_route, :delete, build_path("/#{resource_name}/{#{param_name}}"), resource_options)
+        @gateway.send(:add_route, :delete, build_path("/#{resource_name}/{#{param_name}}"),
+                      resolve_request_model_for(resource_options, :destroy))
+      end
+
+      def resolve_request_model_for(options, action)
+        rm = options[:request_model]
+        case rm
+        when Hash
+          resolved = rm[action] || rm[action.to_s]
+          options.merge(request_model: resolved)
+        else
+          options
+        end
       end
 
       def build_scoped_resources(name, options, &block)
@@ -585,13 +666,22 @@ module Belt
         resource_options = options.merge(route_type: :resource, controller: controller)
         actions = determine_scoped_actions(options, default: %i[show update destroy create])
 
-        @gateway.send(:add_route, :get, build_path("/#{resource_name}"), resource_options) if actions.include?(:show)
-        @gateway.send(:add_route, :put, build_path("/#{resource_name}"), resource_options) if actions.include?(:update)
+        if actions.include?(:show)
+          @gateway.send(:add_route, :get, build_path("/#{resource_name}"),
+                        resolve_request_model_for(resource_options, :show))
+        end
+        if actions.include?(:update)
+          @gateway.send(:add_route, :put, build_path("/#{resource_name}"),
+                        resolve_request_model_for(resource_options, :update))
+        end
         if actions.include?(:destroy)
           @gateway.send(:add_route, :delete, build_path("/#{resource_name}"),
-                        resource_options)
+                        resolve_request_model_for(resource_options, :destroy))
         end
-        @gateway.send(:add_route, :post, build_path("/#{resource_name}"), resource_options) if actions.include?(:create)
+        return unless actions.include?(:create)
+
+        @gateway.send(:add_route, :post, build_path("/#{resource_name}"),
+                      resolve_request_model_for(resource_options, :create))
       end
 
       def apply_scope_to_route(options)

data/lib/belt/version.rb

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

data/lib/templates/new_app/AGENTS.md.erb

@@ -161,6 +161,35 @@ belt doctor                                            # Check dependencies
 
 4. `resources :things` generates: `GET /things`, `POST /things`, `GET /things/:id`, `PUT /things/:id`, `DELETE /things/:id`. **PUT, not PATCH.**
 
+### Request Model Wiring (Validation)
+
+Belt auto-wires request validation from `config/contracts.rb` using conventions:
+
+- `POST /items` → looks for `:create_item` (or `:create_<gateway>_item`)
+- `PUT /items/:id` → looks for `:update_item` (or `:update_<gateway>_item`)
+
+**No `request_model:` declaration needed** if your contract names follow this pattern. Belt infers it.
+
+### Response Model Wiring (Documentation)
+
+Belt auto-wires response models the same way:
+
+- `resources :items` → looks for `model :item` in contracts → auto-wires `response_model: :item`
+
+**No `response_model:` declaration needed** if your model name matches the singular resource name.
+
+### Overrides
+
+For per-action overrides when conventions don't fit:
+```ruby
+resources :items, request_model: { create: :create_item, update: :update_item }
+```
+
+For non-CRUD custom actions, use explicit wiring:
+```ruby
+post '/schedule', request_model: :schedule_pickup
+```
+
 ## How Models Work
 
 Models use ActiveItem (DynamoDB ORM):

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: belt
 version: !ruby/object:Gem::Version
-  version: 0.3.5
+  version: 0.3.7
 platform: ruby
 authors:
 - Stowzilla
@@ -132,6 +132,7 @@ files:
 - lib/belt/cli/path_gem_materializer.rb
 - lib/belt/cli/plugin_command.rb
 - lib/belt/cli/routes_command.rb
+- lib/belt/cli/routes_command/request_model_inference.rb
 - lib/belt/cli/routes_command/route_inference.rb
 - lib/belt/cli/routes_command/schema_loader.rb
 - lib/belt/cli/server_command.rb