belt 0.2.20 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 983c166381b409ee19c2a23c1439be35180892299af76570097d206dea1ba1a4
-  data.tar.gz: f7888dca2b10805bed099da525b968b90e511c1b8381990ba85ab80dc23a9263
+  metadata.gz: cacb19365ad96e079f7a796dc74390f70089bff236581a65b30fabb6e5719008
+  data.tar.gz: c723291b6e114a285b146fead8f5626fe812d798c2230f90999bde34af67806a
 SHA512:
-  metadata.gz: 253f76decf02f960c12011b95570b04213c33800eecfaf70415071f8a2792cae2480a71251cc0ec1b565b837b1c9229f6522c6452124f63560334c6cb6b838d4
-  data.tar.gz: 5393e1c8cdef68b50dee5bca41a299d02560ecc9e65718e8ed45e2cb09b5ffabaf74eefc11b47e59f35fd7b78b602b866db7028eae82246e0da76b14910eca53
+  metadata.gz: 8ac85878df33cec2aa990e527530e54368972e6cca18f18f1e080f4154c50b5d539536fdcb55dfa6b2de675c2f271ed60cb578c3e4acedd4c2bc8c39f48cefd3
+  data.tar.gz: fe809339def0c18771870b7bc7bd7740c83aab12dfcef9eb7f4a3b07420bf139dce02fe0c8845bf84e994eb9743e2aa635f0fb0d6e2f0ff369f12b15cabdcc6b

data/CHANGELOG.md

@@ -1,5 +1,52 @@
 # Changelog
 
+## 0.3.0
+
+Version bump only — no code changes from 0.2.21.
+
+**Why 0.3.0 instead of another patch?** The route DSL changes in 0.2.21 (`gateway`/`function`/`namespace`/`scope`) were a minor-version level change (new features, new keywords). RubyGems doesn't allow republishing the same version, so we're bumping to 0.3.0 to correct the semver trajectory.
+
+If you're on 0.2.21, you already have the DSL changes. This release is purely for version hygiene.
+
+## 0.2.21
+
+### Route DSL: `gateway`, `function`, `namespace`, and `scope` keywords
+
+The route DSL now uses terminology that matches AWS infrastructure:
+
+- **`gateway`** — Creates an API Gateway with a default Lambda function of the same name (replaces top-level `namespace`)
+- **`function`** — Targets enclosed routes to a different Lambda function
+- **`namespace`** — Rails-like path + module prefix (e.g., `/admin/users` with `admin/users` controller). Does NOT change Lambda target.
+- **`scope`** — Flexible grouping with `path:`, `module:`, `auth:`, `tables:` options. Does NOT change Lambda target.
+
+```ruby
+Belt.application.routes.draw do
+  gateway :api, auth: :cognito do
+    resources :posts                    # → lambda: "api", path: /posts
+
+    function :onboarding do
+      resources :steps                  # → lambda: "onboarding", path: /steps
+    end
+
+    namespace :admin do
+      resources :users                  # → lambda: "api", path: /admin/users, controller: "admin/users"
+    end
+
+    scope path: 'v2', module: 'v2' do
+      resources :widgets                # → lambda: "api", path: /v2/widgets, controller: "v2/widgets"
+    end
+  end
+end
+```
+
+**ActionRouter** now accepts `gateway:` keyword (preferred):
+
+```ruby
+ROUTER = Belt::ActionRouter.new(routes: Routes::API, gateway: 'api')
+```
+
+**100% backward compatible:** `namespace :api do` at top level still works (aliased to `gateway`), and `ActionRouter.new(namespace: 'api')` still works.
+
 ## 0.2.18
 
 ### New generator: `belt generate auth`

data/README.md

@@ -105,7 +105,7 @@ require "belt"
 
 include Belt::LambdaHandler
 
-ROUTER = Belt::ActionRouter.new(routes: Routes::API, namespace: "api")
+ROUTER = Belt::ActionRouter.new(routes: Routes::API, gateway: "api")
 
 def execute(path:, body:, event:)
   ROUTER.route(event: event, body: body)
@@ -140,7 +140,7 @@ Define routes in `infrastructure/routes.tf.rb`:
 
 ```ruby
 Belt.application.routes.draw do
-  namespace :api do
+  gateway :api do
     resources :posts, only: [:index, :show, :create]
   end
 end
@@ -170,6 +170,45 @@ The provider will:
 - Generate IAM policies for DynamoDB table access
 - Set up CloudWatch log groups
 
+### Route DSL Keywords
+
+The routes DSL has four keywords that map to infrastructure and code organization:
+
+| Keyword | Purpose | Affects Lambda? |
+|---------|---------|-----------------|
+| `gateway` | Creates an API Gateway + default Lambda | Yes — sets the default Lambda for all routes inside |
+| `function` | Routes to a different Lambda | Yes — overrides the gateway's default |
+| `namespace` | Adds path prefix + controller module | No — Rails-like code organization only |
+| `scope` | Flexible path/module/auth grouping | No — grouping and shared options only |
+
+**Example combining all four:**
+
+```ruby
+Belt.application.routes.draw do
+  gateway :api, auth: :cognito do
+    resources :posts                    # → lambda: api, path: /posts, controller: posts
+
+    namespace :admin do
+      resources :users                  # → lambda: api, path: /admin/users, controller: admin/users
+    end
+
+    function :worker do
+      resources :jobs                   # → lambda: worker, path: /jobs, controller: jobs
+
+      namespace :internal do
+        resources :tasks                # → lambda: worker, path: /internal/tasks, controller: internal/tasks
+      end
+    end
+
+    scope path: 'v2', module: 'legacy' do
+      resources :widgets                # → lambda: api, path: /v2/widgets, controller: legacy/widgets
+    end
+  end
+end
+```
+
+**Key point:** `namespace` and `scope` are purely organizational — they affect URL paths and controller module resolution but never change which Lambda handles the request. Use `function` when you need routes to go to a different Lambda.
+
 ## BeltController Features
 
 ### Callbacks
@@ -423,7 +462,7 @@ The command expects `infrastructure/routes.tf.rb` in the current working directo
 
 ```ruby
 Belt.application.routes.draw do
-  namespace :api do
+  gateway :api do
     resources :posts, only: [:index, :show, :create, :destroy]
     resource :profile, only: [:show, :update]
     get "health", action: :health

data/lib/belt/action_router.rb

@@ -7,22 +7,26 @@ module Belt
   # Routes incoming requests to controllers based on a route manifest.
   #
   # Usage:
-  #   ROUTER = Belt::ActionRouter.new(routes: MY_ROUTES, namespace: "api")
+  #   ROUTER = Belt::ActionRouter.new(routes: MY_ROUTES, gateway: "api")
   #   response = ROUTER.route(event: event, body: body)
   #
   class ActionRouter
     class RouteNotFound < StandardError; end
 
-    def initialize(routes:, namespace:)
-      @namespace = namespace.to_s
-      @namespace_module_name = "#{@namespace.split('_').map(&:capitalize).join}Controllers"
+    def initialize(routes:, gateway: nil, namespace: nil)
+      # Accept `gateway:` (preferred) or legacy `namespace:` keyword
+      gw = gateway || namespace
+      raise ArgumentError, 'Belt::ActionRouter requires a gateway: (or legacy namespace:) argument' unless gw
+
+      @gateway = gw.to_s
+      @gateway_module_name = "#{@gateway.split('_').map(&:capitalize).join}Controllers"
       @routes = build_route_table(routes)
     end
 
     def route(event:, body:)
       method = event['httpMethod']
       full_path = event['path']
-      match_path = strip_namespace_prefix(full_path)
+      match_path = strip_gateway_prefix(full_path)
 
       route_info = find_route(method, match_path)
 
@@ -56,10 +60,10 @@ module Belt
 
     private
 
-    def strip_namespace_prefix(path)
+    def strip_gateway_prefix(path)
       return '/' if path.nil?
 
-      prefix = "/#{@namespace}"
+      prefix = "/#{@gateway}"
       if path.start_with?(prefix)
         stripped = path.sub(prefix, '')
         stripped.empty? ? '/' : stripped
@@ -127,15 +131,15 @@ module Belt
       return false if name.start_with?('/') || name.end_with?('/')
       return false if name.include?('\\')
 
-      # Allow only lowercase letters, digits, underscores, and a single forward slash for nesting
+      # Allow only lowercase letters, digits, underscores, and forward slashes for nesting
       name.match?(%r{\A[a-z][a-z0-9_]*(/[a-z][a-z0-9_]*)?\z})
     end
 
     def resolve_controller(controller_name)
-      # Try namespace module first (app's own controllers)
+      # Try gateway module first (app's own controllers)
       begin
-        namespace_module = Object.const_get(@namespace_module_name)
-        return resolve_from_module(namespace_module, controller_name)
+        gateway_module = Object.const_get(@gateway_module_name)
+        return resolve_from_module(gateway_module, controller_name)
       rescue NameError
         # Fall through to controller_paths lookup
       end
@@ -144,13 +148,13 @@ module Belt
       resolve_from_paths(controller_name)
     end
 
-    def resolve_from_module(namespace_module, controller_name)
+    def resolve_from_module(gateway_module, controller_name)
       if controller_name.include?('/')
         parts = controller_name.split('/')
-        parent = namespace_module.const_get(parts[0].split('_').map(&:capitalize).join)
+        parent = gateway_module.const_get(parts[0].split('_').map(&:capitalize).join)
         parent.const_get("#{parts[1].split('_').map(&:capitalize).join}Controller")
       else
-        namespace_module.const_get("#{controller_name.split('_').map(&:capitalize).join}Controller")
+        gateway_module.const_get("#{controller_name.split('_').map(&:capitalize).join}Controller")
       end
     end
 
@@ -176,9 +180,9 @@ module Belt
         class_name = "#{controller_name.split(%r{[_/]}).map(&:capitalize).join}Controller"
         return Object.const_get(class_name) if Object.const_defined?(class_name)
 
-        # Try under namespace module (e.g., BrablogControllers::PostsController)
-        if Object.const_defined?(@namespace_module_name)
-          ns = Object.const_get(@namespace_module_name)
+        # Try under gateway module (e.g., ApiControllers::PostsController)
+        if Object.const_defined?(@gateway_module_name)
+          ns = Object.const_get(@gateway_module_name)
           return ns.const_get(class_name) if ns.const_defined?(class_name)
         end
       end

data/lib/belt/cli/app_detection.rb

@@ -3,12 +3,14 @@
 module Belt
   module CLI
     module AppDetection
-      # Detects the primary namespace from the route definitions.
+      # Detects the primary gateway from the route definitions.
       # Used by generators to determine controller directory and route file naming.
       def detect_namespace
         routes_file = find_routes_file_path
         if routes_file && File.exist?(routes_file)
-          match = File.read(routes_file).match(/namespace :(\w+)/)
+          content = File.read(routes_file)
+          # Prefer `gateway :name` but fall back to legacy `namespace :name` at top-level
+          match = content.match(/^\s*gateway :(\w+)/) || content.match(/^\s*namespace :(\w+)/)
           return match[1] if match
         end
         File.basename(Dir.pwd)

data/lib/belt/cli/deploy_command.rb

@@ -145,11 +145,10 @@ module Belt
 
       def run
         validate!
+        load_and_apply_env_config!
         run_preflight_checks!
         env_dir = File.join(@infra_dir, @env)
 
-        load_and_apply_env_config!
-
         puts "belt → deploying #{@env} (in #{env_dir}/)\n\n"
 
         ensure_lockfile_consistent!

data/lib/belt/cli/generate_command.rb

@@ -450,18 +450,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

data/lib/belt/cli/tables_command.rb

@@ -243,7 +243,9 @@ module Belt
       end
 
       def table_name(model_name)
-        "${var.app_name}-${var.environment}-#{Belt::Inflector.pluralize(model_name)}"
+        # Dasherize to match ActiveItem's table_name_for convention:
+        # class_name.underscore.dasherize.pluralize
+        "${var.app_name}-${var.environment}-#{Belt::Inflector.pluralize(model_name).tr('_', '-')}"
       end
     end
   end

data/lib/belt/route_dsl.rb

@@ -52,49 +52,46 @@ module Belt
 
   class NestedResourceBuilder
     def initialize(gateway, prefix, collection_prefix, inherited_tables: [], inherited_auth: nil, # rubocop:disable Metrics/ParameterLists
-                   inherited_controller: nil)
+                   inherited_controller: nil, inherited_lambda: nil)
       @gateway = gateway
       @prefix = prefix
       @collection_prefix = collection_prefix
       @inherited_tables = inherited_tables
       @inherited_auth = inherited_auth
       @inherited_controller = inherited_controller
+      @inherited_lambda = inherited_lambda
     end
 
-    def resources(name, options = {})
+    def resources(name, options = {}, &block)
       resource_name = name.to_s
       singular = @gateway.send(:singularize, resource_name)
       param_name = options[:param] || "#{singular}_id"
-      # Auto-add this resource's table before merging inherited tables
       options = options.merge(tables: [resource_name.to_sym]) unless options.key?(:tables)
       options = merge_inherited_options(options)
       resource_options = options.merge(route_type: :resources)
       actions = @gateway.send(:determine_actions, options)
 
-      @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?(:show)
-        @gateway.send(:add_route, :get, "#{@prefix}/#{resource_name}/{#{param_name}}",
-                      resource_options)
-      end
-      if actions.include?(:update)
-        @gateway.send(:add_route, :put, "#{@prefix}/#{resource_name}/{#{param_name}}",
-                      resource_options)
-      end
-      return unless actions.include?(:destroy)
+      add_nested_resource_routes(resource_name, param_name, resource_options, actions)
+      return unless block
 
-      @gateway.send(:add_route, :delete, "#{@prefix}/#{resource_name}/{#{param_name}}",
-                    resource_options)
+      nested_member_prefix = "#{@prefix}/#{resource_name}/{#{param_name}}"
+      nested_collection_prefix = "#{@prefix}/#{resource_name}"
+      nested_builder = NestedResourceBuilder.new(@gateway, nested_member_prefix, nested_collection_prefix,
+                                                 inherited_tables: Array(options[:tables] || []),
+                                                 inherited_auth: options[:auth] || @inherited_auth,
+                                                 inherited_controller: @inherited_controller,
+                                                 inherited_lambda: @inherited_lambda)
+      nested_builder.instance_eval(&block)
     end
 
     def member(&)
       MemberCollectionBuilder.new(@gateway, @prefix, @inherited_tables, @inherited_auth,
-                                  @inherited_controller).instance_eval(&)
+                                  @inherited_controller, @inherited_lambda).instance_eval(&)
     end
 
     def collection(&)
       MemberCollectionBuilder.new(@gateway, @collection_prefix, @inherited_tables,
-                                  @inherited_auth, @inherited_controller).instance_eval(&)
+                                  @inherited_auth, @inherited_controller, @inherited_lambda).instance_eval(&)
     end
 
     %i[get post put delete patch].each do |method|
@@ -108,6 +105,20 @@ 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?(:show)
+        @gateway.send(:add_route, :get, "#{@prefix}/#{resource_name}/{#{param_name}}", resource_options)
+      end
+      if actions.include?(:update)
+        @gateway.send(:add_route, :put, "#{@prefix}/#{resource_name}/{#{param_name}}", resource_options)
+      end
+      return unless actions.include?(:destroy)
+
+      @gateway.send(:add_route, :delete, "#{@prefix}/#{resource_name}/{#{param_name}}", resource_options)
+    end
+
     def merge_inherited_options(options)
       result = options.dup
       if @inherited_tables.any?
@@ -116,17 +127,20 @@ module Belt
       end
       result[:auth] ||= @inherited_auth if @inherited_auth
       result[:controller] ||= @inherited_controller if @inherited_controller
+      result[:lambda] ||= @inherited_lambda if @inherited_lambda
       result
     end
   end
 
   class MemberCollectionBuilder
-    def initialize(gateway, prefix, inherited_tables, inherited_auth, inherited_controller = nil)
+    def initialize(gateway, prefix, inherited_tables, inherited_auth, # rubocop:disable Metrics/ParameterLists
+                   inherited_controller = nil, inherited_lambda = nil)
       @gateway = gateway
       @prefix = prefix
       @inherited_tables = inherited_tables
       @inherited_auth = inherited_auth
       @inherited_controller = inherited_controller
+      @inherited_lambda = inherited_lambda
     end
 
     %i[get post put delete patch].each do |method|
@@ -147,6 +161,7 @@ module Belt
       end
       result[:auth] ||= @inherited_auth if @inherited_auth
       result[:controller] ||= @inherited_controller if @inherited_controller
+      result[:lambda] ||= @inherited_lambda if @inherited_lambda
       result
     end
   end
@@ -198,9 +213,11 @@ module Belt
       resource_tables = Array(options[:tables] || [])
       inherited_tables = (@default_tables + resource_tables).uniq
       inherited_auth = options[:auth] || @default_auth
+      inherited_lambda = options[:lambda]
       nested_builder = NestedResourceBuilder.new(self, member_prefix, collection_prefix,
                                                  inherited_tables: inherited_tables,
-                                                 inherited_auth: inherited_auth)
+                                                 inherited_auth: inherited_auth,
+                                                 inherited_lambda: inherited_lambda)
       nested_builder.instance_eval(&)
     end
 
@@ -283,11 +300,15 @@ module Belt
         @dsl
       end
 
-      def namespace(name, options = {}, &)
-        gateway = Belt::ApiGateway.new(name, options)
-        RouteBuilder.new(gateway).instance_eval(&) if block_given?
-        @dsl.api_gateways << gateway
+      # Primary DSL keyword: defines an API Gateway with a default Lambda function.
+      def gateway(name, options = {}, &)
+        gw = Belt::ApiGateway.new(name, options)
+        RouteBuilder.new(gw).instance_eval(&) if block_given?
+        @dsl.api_gateways << gw
       end
+
+      # Legacy alias — existing routes files using `namespace` still work.
+      alias namespace gateway
     end
 
     def routes
@@ -303,11 +324,40 @@ module Belt
         @gateway = gateway
         @scope_prefix = ''
         @scope_module = nil
+        @lambda_target = nil
         @scope_auth = nil
         @scope_tables = []
         @scope_controller = nil
       end
 
+      # Rails-like `namespace` — adds both a path prefix AND a module prefix.
+      # Equivalent to: scope path: "admin", module: "admin"
+      #
+      # Example:
+      #   namespace :admin do
+      #     resources :users   # → /admin/users, controller: "admin/users"
+      #   end
+      def namespace(name, options = {}, &)
+        segment = name.to_s
+        merged = { path: segment, module: segment }.merge(options)
+        scope(merged, &)
+      end
+
+      # Rails-like `scope` — groups routes with shared options (path prefix, module,
+      # auth, tables, controller).
+      #
+      # Examples:
+      #   scope path: "admin" do
+      #     resources :users   # → /admin/users
+      #   end
+      #
+      #   scope module: "v2" do
+      #     resources :users   # → /users, controller: "v2/users"
+      #   end
+      #
+      #   scope path: "v1", module: "v1", auth: :cognito do
+      #     resources :posts   # → /v1/posts, controller: "v1/posts", auth: cognito
+      #   end
       def scope(options = {}, &)
         previous_prefix = @scope_prefix
         previous_module = @scope_module
@@ -315,12 +365,16 @@ module Belt
         previous_tables = @scope_tables
         previous_controller = @scope_controller
 
-        # Nest path segments (Rails-style): scope path: "a" { scope path: "b" } → "a/b"
+        # Nest path segments: scope path: "a" { scope path: "b" } → "a/b"
         if options.key?(:path)
           segment = options[:path].to_s.gsub(%r{^/|/$}, '')
           @scope_prefix = @scope_prefix.to_s.empty? ? segment : "#{@scope_prefix}/#{segment}"
         end
-        @scope_module = options[:module] || @scope_module
+        # Nest module segments: namespace :admin { namespace :v2 } → "admin/v2"
+        if options.key?(:module)
+          mod_segment = options[:module].to_s
+          @scope_module = @scope_module.to_s.empty? ? mod_segment : "#{@scope_module}/#{mod_segment}"
+        end
         @scope_auth = options[:auth] || @scope_auth
         @scope_tables = (@scope_tables + Array(options[:tables] || [])).uniq
         @scope_controller = options[:controller] || @scope_controller
@@ -334,85 +388,76 @@ module Belt
         @scope_controller = previous_controller
       end
 
+      # Target a different Lambda function for enclosed routes.
+      # Routes within this block will have their :lambda field set to `name`.
+      # Does NOT affect path prefixes or controller module resolution.
+      #
+      # Example:
+      #   gateway :api, auth: :cognito do
+      #     resources :posts                # → lambda: "api"
+      #
+      #     function :onboarding do
+      #       resources :stuff              # → lambda: "onboarding"
+      #     end
+      #
+      #     function :custom do
+      #       get '/blah'                   # → lambda: "custom"
+      #     end
+      #   end
+      def function(name, options = {}, &)
+        previous_lambda = @lambda_target
+        @lambda_target = name.to_s
+        # function blocks can also carry auth/tables
+        previous_auth = @scope_auth
+        previous_tables = @scope_tables
+        @scope_auth = options[:auth] if options[:auth]
+        @scope_tables = (@scope_tables + Array(options[:tables] || [])).uniq
+
+        instance_eval(&) if block_given?
+
+        @lambda_target = previous_lambda
+        @scope_auth = previous_auth
+        @scope_tables = previous_tables
+      end
+
       %i[get post put delete patch].each do |method|
         define_method(method) do |path, options = {}|
           full_path = build_path(path)
-          route_options = options.dup
-          route_options[:lambda] ||= @scope_module if @scope_module
-          route_options[:auth] ||= @scope_auth if @scope_auth
-          route_options[:controller] ||= @scope_controller if @scope_controller
-          if @scope_tables.any? || route_options[:tables]
-            route_options[:tables] =
-              (@scope_tables + Array(route_options[:tables] || [])).uniq
-          end
+          route_options = apply_scope_to_route(options)
           @gateway.send(method, full_path, route_options)
         end
       end
 
-      def resources(name, options = {}, &block)
+      def resources(name, options = {}, &)
         options = apply_scope_options(options)
 
-        if @scope_prefix.empty?
-          @gateway.resources(name, options, &block)
-        else
-          # When inside a scope, generate routes with the prefix applied.
-          # Also set the controller explicitly so inference resolves correctly
-          # (e.g., scope "admin" + resources :users → controller "admin/users").
+        if @scope_prefix.empty? && @scope_module.nil?
+          @gateway.resources(name, options, &)
+        elsif @scope_prefix.empty?
           resource_name = name.to_s
-          singular = Belt::Inflector.singularize(resource_name)
-          param_name = options[:param] || "#{singular}_id"
-          controller = "#{@scope_prefix}/#{resource_name}"
-          resource_options = options.merge(route_type: :resources, controller: controller)
-          actions = determine_scoped_actions(options)
-
-          add_scoped_resource_routes(resource_name, param_name, resource_options, actions)
-
-          if block
-            collection_prefix = build_path("/#{resource_name}")
-            member_prefix = build_path("/#{resource_name}/{#{param_name}}")
-            resource_tables = Array(options[:tables] || [])
-            inherited_tables = (@gateway.default_tables + resource_tables).uniq
-            inherited_auth = options[:auth] || @gateway.default_auth
-            nested_builder = NestedResourceBuilder.new(@gateway, member_prefix, collection_prefix,
-                                                       inherited_tables: inherited_tables,
-                                                       inherited_auth: inherited_auth,
-                                                       inherited_controller: controller)
-            nested_builder.instance_eval(&block)
-          end
+          controller = determine_scoped_controller(resource_name)
+          options = options.merge(controller: controller) unless options[:controller]
+          @gateway.resources(name, options, &)
+        else
+          build_scoped_resources(name, options, &)
         end
       end
 
       def resource(name, options = {})
         options = apply_scope_options(options)
 
-        if @scope_prefix.empty?
+        if @scope_prefix.empty? && @scope_module.nil?
           @gateway.resource(name, options)
-        else
+        elsif @scope_prefix.empty?
           resource_name = name.to_s
-          controller = "#{@scope_prefix}/#{resource_name}"
-          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)
-          if actions.include?(:update)
-            @gateway.send(:add_route, :put, build_path("/#{resource_name}"),
-                          resource_options)
-          end
-          if actions.include?(:destroy)
-            @gateway.send(:add_route, :delete, build_path("/#{resource_name}"),
-                          resource_options)
-          end
-          if actions.include?(:create)
-            @gateway.send(:add_route, :post, build_path("/#{resource_name}"),
-                          resource_options)
-          end
+          controller = determine_scoped_controller(resource_name)
+          options = options.merge(controller: controller) unless options[:controller]
+          @gateway.resource(name, options)
+        else
+          build_scoped_resource(name, options)
         end
       end
 
-      def lambda(name, &)
-        name
-      end
-
       def mount(mountable, options = {})
         prefix = options[:at]&.to_s&.gsub(%r{^/|/$}, '') || ''
         extra_tables = Array(options[:tables] || [])
@@ -457,6 +502,16 @@ module Belt
         @scope_prefix.empty? ? path : "/#{@scope_prefix}#{path}"
       end
 
+      def determine_scoped_controller(resource_name)
+        if @scope_module && !@scope_module.empty?
+          "#{@scope_module}/#{resource_name}"
+        elsif !@scope_prefix.empty?
+          "#{@scope_prefix}/#{resource_name}"
+        else
+          resource_name
+        end
+      end
+
       def determine_scoped_actions(options, default: %i[index create show update destroy])
         if options[:only]
           Array(options[:only])
@@ -481,10 +536,65 @@ module Belt
         @gateway.send(:add_route, :delete, build_path("/#{resource_name}/{#{param_name}}"), resource_options)
       end
 
+      def build_scoped_resources(name, options, &block)
+        resource_name = name.to_s
+        singular = Belt::Inflector.singularize(resource_name)
+        param_name = options[:param] || "#{singular}_id"
+        controller = options[:controller] || determine_scoped_controller(resource_name)
+        resource_options = options.merge(route_type: :resources, controller: controller)
+        actions = determine_scoped_actions(options)
+
+        add_scoped_resource_routes(resource_name, param_name, resource_options, actions)
+        build_nested_resource_block(resource_name, param_name, options, controller, &block) if block
+      end
+
+      def build_nested_resource_block(resource_name, param_name, options, controller, &)
+        collection_prefix = build_path("/#{resource_name}")
+        member_prefix = build_path("/#{resource_name}/{#{param_name}}")
+        resource_tables = Array(options[:tables] || [])
+        inherited_tables = (@gateway.default_tables + resource_tables).uniq
+        inherited_auth = options[:auth] || @gateway.default_auth
+        nested_builder = NestedResourceBuilder.new(@gateway, member_prefix, collection_prefix,
+                                                   inherited_tables: inherited_tables,
+                                                   inherited_auth: inherited_auth,
+                                                   inherited_controller: controller,
+                                                   inherited_lambda: @lambda_target)
+        nested_builder.instance_eval(&)
+      end
+
+      def build_scoped_resource(name, options)
+        resource_name = name.to_s
+        controller = options[:controller] || determine_scoped_controller(resource_name)
+        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?(:destroy)
+          @gateway.send(:add_route, :delete, build_path("/#{resource_name}"),
+                        resource_options)
+        end
+        @gateway.send(:add_route, :post, build_path("/#{resource_name}"), resource_options) if actions.include?(:create)
+      end
+
+      def apply_scope_to_route(options)
+        route_options = options.dup
+        # Lambda target: only explicit function block affects it
+        route_options[:lambda] ||= @lambda_target if @lambda_target
+        route_options[:auth] ||= @scope_auth if @scope_auth
+        route_options[:controller] ||= @scope_controller if @scope_controller
+        if @scope_tables.any? || route_options[:tables]
+          route_options[:tables] =
+            (@scope_tables + Array(route_options[:tables] || [])).uniq
+        end
+        route_options
+      end
+
       def apply_scope_options(options)
         result = options.dup
         result[:auth] ||= @scope_auth if @scope_auth
-        result[:lambda] ||= @scope_module if @scope_module
+        # Lambda target: only explicit function block affects it
+        result[:lambda] ||= @lambda_target if @lambda_target
         result[:controller] ||= @scope_controller if @scope_controller
         result[:tables] = (@scope_tables + Array(result[:tables] || [])).uniq if @scope_tables.any? || result[:tables]
         result

data/lib/belt/version.rb

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

data/lib/templates/generate/auth/cognito.tf.erb

@@ -51,9 +51,7 @@ resource "aws_cognito_user_pool_client" "<%= pool[:name] %>" {
 
   explicit_auth_flows = [
     "ALLOW_USER_SRP_AUTH",
-<% if @signup -%>
     "ALLOW_USER_PASSWORD_AUTH",
-<% end -%>
     "ALLOW_REFRESH_TOKEN_AUTH"
   ]
 

data/lib/templates/generate/auth/frontend/auth.js

@@ -55,7 +55,11 @@ export async function completeNewPassword(username, newPassword, session) {
     ChallengeName: 'NEW_PASSWORD_REQUIRED',
     ClientId: CLIENT_ID,
     Session: session,
-    ChallengeResponses: { USERNAME: username, NEW_PASSWORD: newPassword }
+    ChallengeResponses: {
+      USERNAME: username,
+      NEW_PASSWORD: newPassword,
+      'userAttributes.email': username
+    }
   }))
   setTokens(response.AuthenticationResult)
   return { success: true }

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

@@ -56,13 +56,13 @@ belt output <env>                                      # terraform output
 1. `config/routes.rb` defines routes using a DSL:
    ```ruby
    Belt.application.routes.draw do
-     namespace :<%= @app_name %> do
+     gateway :<%= @app_name %> do
        resources :things, tables: [:things]
      end
    end
    ```
 
-2. Conveyor Belt creates an API Gateway where the namespace becomes a base path mapping. URLs look like:
+2. Conveyor Belt creates an API Gateway where the gateway name becomes a base path mapping. URLs look like:
    ```
    https://api.<env>.example.com/<%= @app_name %>/things
    ```

data/lib/templates/new_app/config/routes.rb.erb

@@ -1,5 +1,7 @@
 Belt.application.routes.draw do
-  namespace :api do
+  # Creates an API Gateway named "api" with a default Lambda function of the same name.
+  # Use `function :other_name do ... end` inside to route specific paths to additional Lambdas.
+  gateway :api do
     # Public stack-check / welcome (HTML for browsers, JSON for the SPA shell)
     get "/", action: :show, controller: :welcome, auth: :none
     # resources :posts

data/lib/templates/new_app/lambda/api.rb.erb

@@ -9,7 +9,7 @@ require_relative 'lib/routes/api_routes'
 require_relative 'controllers/<%= @app_name %>/<%= r %>_controller'
 <% end -%>
 
-ROUTER = Belt::ActionRouter.new(routes: Routes::API, namespace: 'api')
+ROUTER = Belt::ActionRouter.new(routes: Routes::API, gateway: 'api')
 
 def execute(path:, body:, event:)
   ROUTER.route(event: event, body: body)

metadata

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