belt 0.3.4 → 0.3.6

data/lib/belt/docs/frontend.md

@@ -0,0 +1,103 @@
+# Frontends
+
+Belt can host one or more JavaScript SPAs (React, Vue, or Svelte) next to the
+Lambda API. A typical app has a single `frontend/` directory. Some apps — Stowzilla
+is the example that drove this — have several independent SPAs (customer, ops,
+partners) that share the same models and API.
+
+## Single frontend (default)
+
+```bash
+belt new blog --frontend react
+# or, in an existing app:
+belt generate frontend react
+```
+
+That creates `frontend/`, S3 + CloudFront infrastructure, and wires CORS so the
+SPA can call the API. No config file is required.
+
+```bash
+belt server                       # local Vite dev server
+belt frontend env dev01           # write frontend/.env from terraform outputs
+belt deploy frontend dev01        # npm ci → build → S3 sync → CloudFront invalidation
+```
+
+## Multiple frontends
+
+Declare them in `config/frontends.yml` (or `.belt/frontends.yml`):
+
+```yaml
+frontends:
+  customer:
+    path: app
+    dist: build
+    default: true
+    bucket_output: web_app_bucket_name
+    url_output: web_app_url
+    cloudfront_domain_output: web_app_cloudfront_domain
+  ops:
+    path: ops-app
+    dist: build
+    bucket_output: ops_app_bucket_name
+    url_output: ops_app_url
+    cloudfront_domain_output: ops_app_cloudfront_domain
+```
+
+`path` is the directory. `dist` is the build output (`dist` by default; belt
+also auto-detects `build/` after `npm run build`). Terraform output names default
+to `frontend_*` for the `frontend` app and `{name}_frontend_*` for others — override
+them when existing infrastructure uses different names.
+
+If terraform exports a CloudFront **domain** instead of a distribution ID, set
+`cloudfront_domain_output` and skip `distribution_output`. Belt looks the ID up
+via AWS and will not probe `{name}_frontend_distribution_id`.
+
+```bash
+belt frontend list
+belt generate frontend react --name ops --path ops-app
+belt generate views bag --frontend ops
+belt generate scaffold order --frontend customer
+belt server --frontend ops
+belt frontend env dev01 --frontend customer
+belt deploy frontend dev01                  # all configured frontends
+belt deploy frontend dev01 --frontend ops   # just ops
+```
+
+If several frontends exist and you omit `--frontend`, generators and `belt server`
+use the one marked `default: true`. If none is default, they ask you to pick.
+
+`belt deploy frontend <env>` with no `--frontend` deploys every frontend that
+has a `package.json`. Full `belt deploy <env>` does the same after terraform apply.
+
+## Env maps
+
+Each frontend can have its own `env.yml` mapping process env names to terraform
+outputs:
+
+```yaml
+# app/env.yml
+VITE_API_URL: api_url
+VITE_COGNITO_USER_POOL_ID: cognito_user_pool_id
+VITE_COGNITO_CLIENT_ID: cognito_user_pool_client_id
+```
+
+The default `frontend/` directory also accepts `.belt/frontend_env.yml` as a
+fallback. See the existing env-map behavior: only mapped keys are written into
+`.env`; missing terraform outputs warn and do not clobber local values.
+
+## Infrastructure
+
+`belt setup frontend` (and `belt generate frontend`) writes S3 + CloudFront into
+`infrastructure/modules/app/frontend.tf`. Additional named frontends get
+`{name}_frontend.tf` with unique resource names and outputs
+(`ops_frontend_bucket_name`, …). Extra frontends get a CloudFront URL only —
+custom DNS stays on the default frontend unless you add records yourself.
+
+CORS: each CloudFront domain is added to `frontend_urls` on the conveyor-belt
+resource so SPA → API calls work.
+
+## See Also
+
+- `belt explain deployment` — how frontend deploy fits into `belt deploy`
+- `belt explain generators` — `belt generate frontend` / views
+- `belt explain structure` — where frontend directories live

data/lib/belt/docs/generators.md

@@ -51,8 +51,12 @@ Adds a frontend framework to the project:
 belt generate frontend react
 belt generate frontend vue
 belt generate frontend svelte
+belt generate frontend react --name ops --path ops-app
 ```
 
+`--name` and `--path` scaffold an additional SPA and register it in
+`config/frontends.yml`. See `belt explain frontend`.
+
 ### Views
 
 Generates React pages for a resource's REST actions:
@@ -60,8 +64,12 @@ Generates React pages for a resource's REST actions:
 ```bash
 belt generate views post title:string body:text status:string
 belt g views comment body:text author:string
+belt g views bag --frontend ops
 ```
 
+When the app has multiple frontends, pass `--frontend <name>` (or mark one
+`default: true` in `config/frontends.yml`).
+
 ### Auth
 
 Sets up Cognito authentication:
@@ -94,6 +102,7 @@ belt destroy model comment
 belt destroy controller admin/users
 belt destroy environment staging
 belt destroy frontend
+belt destroy frontend --frontend ops
 belt destroy views post
 ```
 

data/lib/belt/docs/structure.md

@@ -43,6 +43,7 @@ my-app/
 │   └── prod/
 │       └── ...
 ├── frontend/                      # Optional frontend (React/Vue/Svelte)
+├── config/frontends.yml           # Optional: multiple named frontends
 ├── Gemfile                        # Project-level dependencies (CLI, dev tools)
 ├── Rakefile                       # Rake tasks
 ├── AGENTS.md                      # AI agent guide
@@ -85,6 +86,8 @@ Terraform resources.
   `lambda/Gemfile` is what gets packaged into the Lambda.
 - **Config over code**: Lambda configuration (timeout, memory, env vars) goes in
   YAML files, not hardcoded in Terraform.
+- **Frontends**: Default directory is `frontend/`. Multiple SPAs (customer + ops,
+  etc.) are declared in `config/frontends.yml`. See `belt explain frontend`.
 
 ## See Also
 

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.4'
+  VERSION = '0.3.6'
 end

data/lib/templates/frontend/react/env.yml.example

@@ -1,6 +1,6 @@
 # Declarative frontend env map for belt.
 # Left: env var your build tool reads. Right: terraform output name.
-# Copy to frontend/env.yml (or .belt/frontend_env.yml) and adjust.
+# Copy to <frontend>/env.yml (or .belt/frontend_env.yml for the default frontend/) and adjust.
 #
 # belt deploy frontend <env>  → injects these into npm run build
 # belt frontend env <env>     → smart-merges into frontend/.env for local dev

data/lib/templates/module/frontend.tf.erb

@@ -1,15 +1,17 @@
-# Frontend hosting — S3 + CloudFront
+# Frontend hosting — S3 + CloudFront<% if @include_dns %>
 # Custom domain attached when var.domain is set
-
-resource "random_string" "frontend_suffix" {
+<% else %>
+# Additional frontend '<%= @frontend.name %>' — CloudFront default domain (no Route53)
+<% end %>
+resource "random_string" "<%= @tf_name %>_suffix" {
   length  = 8
   special = false
   upper   = false
 }
 
 # S3 bucket for frontend static assets
-resource "aws_s3_bucket" "frontend" {
-  bucket        = "${var.app_name}-frontend-${var.environment}-${random_string.frontend_suffix.result}"
+resource "aws_s3_bucket" "<%= @tf_name %>" {
+  bucket        = "${var.app_name}-<%= @bucket_slug %>-${var.environment}-${random_string.<%= @tf_name %>_suffix.result}"
   force_destroy = true
 
   lifecycle {
@@ -17,8 +19,8 @@ resource "aws_s3_bucket" "frontend" {
   }
 }
 
-resource "aws_s3_bucket_public_access_block" "frontend" {
-  bucket = aws_s3_bucket.frontend.id
+resource "aws_s3_bucket_public_access_block" "<%= @tf_name %>" {
+  bucket = aws_s3_bucket.<%= @tf_name %>.id
 
   block_public_acls       = true
   block_public_policy     = true
@@ -26,8 +28,8 @@ resource "aws_s3_bucket_public_access_block" "frontend" {
   restrict_public_buckets = true
 }
 
-resource "aws_s3_bucket_server_side_encryption_configuration" "frontend" {
-  bucket = aws_s3_bucket.frontend.id
+resource "aws_s3_bucket_server_side_encryption_configuration" "<%= @tf_name %>" {
+  bucket = aws_s3_bucket.<%= @tf_name %>.id
 
   rule {
     apply_server_side_encryption_by_default {
@@ -38,36 +40,36 @@ resource "aws_s3_bucket_server_side_encryption_configuration" "frontend" {
 }
 
 # CloudFront OAC
-resource "aws_cloudfront_origin_access_control" "frontend" {
-  name                              = "${var.app_name}-${var.environment}-frontend-oac"
-  description                       = "OAC for frontend bucket"
+resource "aws_cloudfront_origin_access_control" "<%= @tf_name %>" {
+  name                              = "${var.app_name}-${var.environment}-<%= @bucket_slug %>-oac"
+  description                       = "OAC for <%= @bucket_slug %> bucket"
   origin_access_control_origin_type = "s3"
   signing_behavior                  = "always"
   signing_protocol                  = "sigv4"
 }
 
 # CloudFront distribution
-resource "aws_cloudfront_distribution" "frontend" {
+resource "aws_cloudfront_distribution" "<%= @tf_name %>" {
   origin {
-    domain_name              = aws_s3_bucket.frontend.bucket_regional_domain_name
-    origin_id                = "S3-${aws_s3_bucket.frontend.id}"
-    origin_access_control_id = aws_cloudfront_origin_access_control.frontend.id
+    domain_name              = aws_s3_bucket.<%= @tf_name %>.bucket_regional_domain_name
+    origin_id                = "S3-${aws_s3_bucket.<%= @tf_name %>.id}"
+    origin_access_control_id = aws_cloudfront_origin_access_control.<%= @tf_name %>.id
   }
 
   enabled             = true
   is_ipv6_enabled     = true
   default_root_object = "index.html"
-
+<% if @include_dns %>
   # Custom domain aliases (if DNS configured)
   aliases = local.dns_enabled ? compact([
     local.app_domain,
     var.environment == "prod" ? "www.${var.domain}" : ""
   ]) : []
-
+<% end %>
   default_cache_behavior {
     allowed_methods        = ["GET", "HEAD", "OPTIONS"]
     cached_methods         = ["GET", "HEAD"]
-    target_origin_id       = "S3-${aws_s3_bucket.frontend.id}"
+    target_origin_id       = "S3-${aws_s3_bucket.<%= @tf_name %>.id}"
     compress               = true
     viewer_protocol_policy = "redirect-to-https"
 
@@ -99,22 +101,22 @@ resource "aws_cloudfront_distribution" "frontend" {
   }
 
   viewer_certificate {
-    cloudfront_default_certificate = !local.dns_enabled
-    acm_certificate_arn            = local.dns_enabled ? aws_acm_certificate_validation.app[0].certificate_arn : null
-    ssl_support_method             = local.dns_enabled ? "sni-only" : null
-    minimum_protocol_version       = local.dns_enabled ? "TLSv1.2_2021" : null
+    cloudfront_default_certificate = <%= @include_dns ? '!local.dns_enabled' : 'true' %>
+    acm_certificate_arn            = <%= @include_dns ? 'local.dns_enabled ? aws_acm_certificate_validation.app[0].certificate_arn : null' : 'null' %>
+    ssl_support_method             = <%= @include_dns ? 'local.dns_enabled ? "sni-only" : null' : 'null' %>
+    minimum_protocol_version       = <%= @include_dns ? 'local.dns_enabled ? "TLSv1.2_2021" : null' : 'null' %>
   }
 
   tags = {
-    Name        = "${var.app_name}-${var.environment}-frontend"
+    Name        = "${var.app_name}-${var.environment}-<%= @bucket_slug %>"
     Environment = var.environment
     ManagedBy   = "Terraform"
   }
 }
 
 # S3 bucket policy — CloudFront OAC access only
-resource "aws_s3_bucket_policy" "frontend" {
-  bucket = aws_s3_bucket.frontend.id
+resource "aws_s3_bucket_policy" "<%= @tf_name %>" {
+  bucket = aws_s3_bucket.<%= @tf_name %>.id
 
   policy = jsonencode({
     Version = "2012-10-17"
@@ -126,55 +128,59 @@ resource "aws_s3_bucket_policy" "frontend" {
           Service = "cloudfront.amazonaws.com"
         }
         Action   = "s3:GetObject"
-        Resource = "${aws_s3_bucket.frontend.arn}/*"
+        Resource = "${aws_s3_bucket.<%= @tf_name %>.arn}/*"
         Condition = {
           StringEquals = {
-            "AWS:SourceArn" = aws_cloudfront_distribution.frontend.arn
+            "AWS:SourceArn" = aws_cloudfront_distribution.<%= @tf_name %>.arn
           }
         }
       }
     ]
   })
 
-  depends_on = [aws_s3_bucket_public_access_block.frontend]
+  depends_on = [aws_s3_bucket_public_access_block.<%= @tf_name %>]
 }
-
+<% if @include_dns %>
 # Route53 record for frontend (app domain → CloudFront)
-resource "aws_route53_record" "frontend" {
+resource "aws_route53_record" "<%= @tf_name %>" {
   count   = local.dns_enabled ? 1 : 0
   zone_id = aws_route53_zone.app[0].zone_id
   name    = local.app_domain
   type    = "A"
 
   alias {
-    name                   = aws_cloudfront_distribution.frontend.domain_name
-    zone_id                = aws_cloudfront_distribution.frontend.hosted_zone_id
+    name                   = aws_cloudfront_distribution.<%= @tf_name %>.domain_name
+    zone_id                = aws_cloudfront_distribution.<%= @tf_name %>.hosted_zone_id
     evaluate_target_health = false
   }
 }
 
 # www record for prod only
-resource "aws_route53_record" "frontend_www" {
+resource "aws_route53_record" "<%= @tf_name %>_www" {
   count   = local.dns_enabled && var.environment == "prod" ? 1 : 0
   zone_id = aws_route53_zone.app[0].zone_id
   name    = "www.${var.domain}"
   type    = "A"
 
   alias {
-    name                   = aws_cloudfront_distribution.frontend.domain_name
-    zone_id                = aws_cloudfront_distribution.frontend.hosted_zone_id
+    name                   = aws_cloudfront_distribution.<%= @tf_name %>.domain_name
+    zone_id                = aws_cloudfront_distribution.<%= @tf_name %>.hosted_zone_id
     evaluate_target_health = false
   }
 }
-
-output "frontend_bucket_name" {
-  value = aws_s3_bucket.frontend.id
+<% end %>
+output "<%= @output_prefix %>_bucket_name" {
+  value = aws_s3_bucket.<%= @tf_name %>.id
 }
 
-output "frontend_distribution_id" {
-  value = aws_cloudfront_distribution.frontend.id
+output "<%= @output_prefix %>_distribution_id" {
+  value = aws_cloudfront_distribution.<%= @tf_name %>.id
 }
 
-output "frontend_url" {
-  value = local.dns_enabled ? "https://${local.app_domain}" : "https://${aws_cloudfront_distribution.frontend.domain_name}"
+output "<%= @output_prefix %>_url" {
+<% if @include_dns -%>
+  value = local.dns_enabled ? "https://${local.app_domain}" : "https://${aws_cloudfront_distribution.<%= @tf_name %>.domain_name}"
+<% else -%>
+  value = "https://${aws_cloudfront_distribution.<%= @tf_name %>.domain_name}"
+<% 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.4
+  version: 0.3.6
 platform: ruby
 authors:
 - Stowzilla
@@ -121,6 +121,7 @@ files:
 - lib/belt/cli/frontend_deploy_command.rb
 - lib/belt/cli/frontend_env_command.rb
 - lib/belt/cli/frontend_env_map.rb
+- lib/belt/cli/frontend_registry.rb
 - lib/belt/cli/frontend_setup_command.rb
 - lib/belt/cli/generate_command.rb
 - lib/belt/cli/generator_registry.rb
@@ -131,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
@@ -139,12 +141,14 @@ files:
 - lib/belt/cli/tasks_command.rb
 - lib/belt/cli/terraform_command.rb
 - lib/belt/cli/views_command.rb
+- lib/belt/cli/zip_artifact_builder.rb
 - lib/belt/configuration.rb
 - lib/belt/controllers/welcome_controller.rb
 - lib/belt/docs/backups.md
 - lib/belt/docs/console.md
 - lib/belt/docs/controllers.md
 - lib/belt/docs/deployment.md
+- lib/belt/docs/frontend.md
 - lib/belt/docs/generators.md
 - lib/belt/docs/lambda_handler.md
 - lib/belt/docs/models.md