belt 0.2.8 → 0.2.10

data/lib/belt/helpers/response.rb

@@ -2,6 +2,7 @@
 
 require_relative 'error_logging'
 require_relative 'cors_origin'
+require_relative '../http_status'
 
 module Belt
   module Helpers
@@ -9,8 +10,9 @@ module Belt
       def cors_headers(event = nil)
         event = @event if event.nil? && instance_variable_defined?(:@event)
         origin = CorsOrigin.resolve_origin(CorsOrigin.origin_from_event(event))
+        allow_headers = 'Content-Type,Accept,X-Amz-Date,Authorization,X-Api-Key,X-Amz-Security-Token'
         headers = {
-          'Access-Control-Allow-Headers' => 'Content-Type,X-Amz-Date,Authorization,X-Api-Key,X-Amz-Security-Token',
+          'Access-Control-Allow-Headers' => allow_headers,
           'Access-Control-Allow-Methods' => 'GET,POST,PUT,DELETE,PATCH,OPTIONS',
           'Access-Control-Max-Age' => '300',
           'Content-Type' => 'application/json'
@@ -19,16 +21,18 @@ module Belt
         headers
       end
 
+      # JSON success. Status accepts Integer or Symbol (:created, :ok, …).
       def success_response(body, status_code = 200)
-        { statusCode: status_code, headers: cors_headers, body: JSON.generate(body) }
+        { statusCode: resolve_status(status_code), headers: cors_headers, body: JSON.generate(body) }
       end
 
+      # JSON error. Status accepts Integer or Symbol (:unprocessable_entity, :not_found, …).
       def error_response(message, status_code = 400, error_details = nil)
         body = { error: message }
         if error_details
           body[:details] = error_details.is_a?(Hash) ? error_details : { message: error_details.to_s }
         end
-        { statusCode: status_code, headers: cors_headers, body: JSON.generate(body) }
+        { statusCode: resolve_status(status_code), headers: cors_headers, body: JSON.generate(body) }
       end
 
       def html_response(html, status_code = 200)
@@ -36,7 +40,30 @@ module Belt
         origin = CorsOrigin.resolve_origin(CorsOrigin.origin_from_event(event))
         headers = { 'Content-Type' => 'text/html; charset=utf-8' }
         headers['Access-Control-Allow-Origin'] = origin if origin
-        { statusCode: status_code, headers: headers, body: html }
+        { statusCode: resolve_status(status_code), headers: headers, body: html }
+      end
+
+      # Empty-body response (Rails-style). Useful for destroy / create-without-body.
+      #
+      #   head :created      # 201, empty body
+      #   head :no_content   # 204
+      #   head 201
+      #
+      def head(status = :no_content)
+        { statusCode: resolve_status(status), headers: cors_headers, body: '' }
+      end
+
+      # Set the status used by implicit assigns / HTML render (when you don't
+      # call success_response / render yourself).
+      #
+      #   def create
+      #     @post = Post.create!(...)
+      #     response_status :created
+      #   end
+      #   # → 201 + { post: {...} }
+      #
+      def response_status(status)
+        @__response_status = resolve_status(status)
       end
 
       def handle_error_and_respond(error, message, context = {}, status_code = 500)
@@ -56,6 +83,10 @@ module Belt
 
       private
 
+      def resolve_status(status)
+        Belt::HttpStatus.resolve(status)
+      end
+
       def verbose_errors_enabled?
         env = ENV['ENVIRONMENT']&.downcase || ''
         env.start_with?('dev') || env == 'local' || env == 'test'

data/lib/belt/http_status.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Belt
+  # Rails/Rack-style symbolic HTTP status codes.
+  # Mirrors the common subset of Rack::Utils::SYMBOL_TO_STATUS_CODE so apps
+  # can write `head :created` / `success_response(body, :created)` without
+  # taking a rack dependency.
+  module HttpStatus
+    SYMBOL_TO_STATUS_CODE = {
+      continue: 100,
+      switching_protocols: 101,
+      processing: 102,
+      ok: 200,
+      created: 201,
+      accepted: 202,
+      non_authoritative_information: 203,
+      no_content: 204,
+      reset_content: 205,
+      partial_content: 206,
+      multi_status: 207,
+      already_reported: 208,
+      im_used: 226,
+      multiple_choices: 300,
+      moved_permanently: 301,
+      found: 302,
+      see_other: 303,
+      not_modified: 304,
+      use_proxy: 305,
+      temporary_redirect: 307,
+      permanent_redirect: 308,
+      bad_request: 400,
+      unauthorized: 401,
+      payment_required: 402,
+      forbidden: 403,
+      not_found: 404,
+      method_not_allowed: 405,
+      not_acceptable: 406,
+      proxy_authentication_required: 407,
+      request_timeout: 408,
+      conflict: 409,
+      gone: 410,
+      length_required: 411,
+      precondition_failed: 412,
+      payload_too_large: 413,
+      uri_too_long: 414,
+      unsupported_media_type: 415,
+      range_not_satisfiable: 416,
+      expectation_failed: 417,
+      unprocessable_entity: 422,
+      locked: 423,
+      failed_dependency: 424,
+      upgrade_required: 426,
+      precondition_required: 428,
+      too_many_requests: 429,
+      request_header_fields_too_large: 431,
+      unavailable_for_legal_reasons: 451,
+      internal_server_error: 500,
+      not_implemented: 501,
+      bad_gateway: 502,
+      service_unavailable: 503,
+      gateway_timeout: 504,
+      http_version_not_supported: 505,
+      variant_also_negotiates: 506,
+      insufficient_storage: 507,
+      loop_detected: 508,
+      not_extended: 510,
+      network_authentication_required: 511
+    }.freeze
+
+    module_function
+
+    # Resolve a status to an integer code.
+    # Accepts Integer (200), String ("201"), or Symbol (:created).
+    def resolve(status)
+      case status
+      when Integer
+        status
+      when String
+        Integer(status)
+      when Symbol
+        SYMBOL_TO_STATUS_CODE.fetch(status) do
+          raise ArgumentError, "Unknown HTTP status symbol: #{status.inspect}"
+        end
+      else
+        raise ArgumentError, "status must be Integer, String, or Symbol (got #{status.class})"
+      end
+    end
+  end
+end

data/lib/belt/rendering.rb

@@ -54,6 +54,7 @@ module Belt
     #   render layout: false           — skip layout (default: no layout)
     #
     def render(options = {})
+      # Status may be Integer or Symbol (:created, :ok, …)
       status = options.fetch(:status, 200)
 
       html = if options.key?(:inline)

data/lib/belt/version.rb

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

data/lib/belt/views/welcome/show.html.erb

@@ -12,39 +12,39 @@
     <div class="overlay">
       <h1><%= h(@title) %></h1>
       <p class="subtitle"><%= h(@subtitle) %></p>
-    </div>
-  </div>
-  <div class="container">
-    <div class="stack-check">
-      <div class="check-item check-pass">
-        <span class="icon">✓</span>
-        <span>API Gateway</span>
-      </div>
-      <div class="arrow">→</div>
-      <div class="check-item check-pass">
-        <span class="icon">✓</span>
-        <span>Lambda</span>
+
+      <div class="stack-check">
+        <div class="check-item check-pass">
+          <span class="icon">✓</span>
+          <span>API Gateway</span>
+        </div>
+        <div class="arrow">→</div>
+        <div class="check-item check-pass">
+          <span class="icon">✓</span>
+          <span>Lambda</span>
+        </div>
+        <div class="arrow">→</div>
+        <%- if @dynamodb_connected -%>
+        <div class="check-item check-pass">
+          <span class="icon">✓</span>
+          <span>DynamoDB</span>
+        </div>
+        <%- else -%>
+        <div class="check-item check-neutral">
+          <span class="icon">○</span>
+          <span>DynamoDB</span>
+        </div>
+        <%- end -%>
       </div>
-      <div class="arrow">→</div>
-      <%- if @dynamodb_connected -%>
-      <div class="check-item check-pass">
-        <span class="icon">✓</span>
-        <span>DynamoDB</span>
+
+      <div class="next-steps">
+        <h2>Next Steps</h2>
+        <ol>
+          <li>Scaffold a resource: <code><%= h(@scaffold_hint_cmd) %></code></li>
+          <li>Deploy: <code>belt deploy</code></li>
+          <li>This page will be replaced once you define your own root route.</li>
+        </ol>
       </div>
-      <%- else -%>
-      <div class="check-item check-warn">
-        <span class="icon">⚠</span>
-        <span>DynamoDB</span>
-      </div>
-      <%- end -%>
-    </div>
-    <div class="next-steps">
-      <h2>Next Steps</h2>
-      <ol>
-        <li>Generate a resource: <code>belt g resource post title:string body:text</code></li>
-        <li>Deploy: <code>belt deploy</code></li>
-        <li>This page will be replaced once you define your own root route.</li>
-      </ol>
     </div>
   </div>
 </body>

data/lib/belt.rb

@@ -2,6 +2,8 @@
 
 require_relative 'belt/version'
 require_relative 'belt/root'
+require_relative 'belt/configuration'
+require_relative 'belt/http_status'
 require_relative 'belt/parameters'
 require_relative 'belt/observability'
 require_relative 'belt/lambda_handler'
@@ -18,6 +20,20 @@ module Belt
   class << self
     attr_reader :controller_paths
 
+    # Runtime configuration (lambda/config/environment.rb). Separate from the
+    # CLI sandboxed DSL in infrastructure/<env>/belt.rb.
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield configuration
+    end
+
+    def reset_configuration!
+      @configuration = Configuration.new
+    end
+
     # Auto-discover lambda/controllers dirs in all loaded gems
     def gem_controller_paths
       @gem_controller_paths ||= discover_gem_paths('lambda/controllers')

data/lib/belt_controller/base.rb

@@ -7,11 +7,13 @@ require_relative '../belt/helpers/response'
 require_relative '../belt/helpers/error_logging'
 require_relative '../belt/helpers/cors_origin'
 require_relative '../belt/rendering'
+require_relative 'implicit_response'
 
 module BeltController
   class Base
     include Belt::Helpers::Response
     include Belt::Rendering
+    include ImplicitResponse
 
     attr_reader :event, :body
 
@@ -48,6 +50,25 @@ module BeltController
         skipped_before_actions << { method: method_name, only: only&.map(&:to_sym), except: except&.map(&:to_sym) }
       end
 
+      # Implicit response format when the action does not call success_response /
+      # error_response / html_response / render / head.
+      # Inherits up the controller chain; falls back to Belt.configuration.default_format.
+      def default_format
+        return @default_format if defined?(@default_format)
+        return superclass.default_format if superclass.respond_to?(:default_format)
+
+        Belt.configuration.default_format
+      end
+
+      def default_format=(value)
+        format = value.to_sym
+        unless Belt::Configuration::VALID_FORMATS.include?(format)
+          raise ArgumentError, "default_format must be :json or :html (got #{value.inspect})"
+        end
+
+        @default_format = format
+      end
+
       def all_before_actions
         if superclass.respond_to?(:all_before_actions)
           superclass.all_before_actions + before_actions
@@ -115,9 +136,11 @@ module BeltController
       end
 
       run_before_actions(action_sym)
+      # Snapshot ivars so we only auto-serialize assigns set by the action (Rails-style)
+      @__assigns_before = instance_variables
       result = send(action_sym)
       run_after_actions(action_sym)
-      result
+      finalize_response(result)
     rescue StandardError => e
       handle_exception(e)
     end

data/lib/belt_controller/implicit_response.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module BeltController
+  # Rails-like implicit JSON/HTML responses from action assigns / return values.
+  # Included by BeltController::Base so the base class stays under Metrics/ClassLength.
+  module ImplicitResponse
+    # Never auto-serialize these into the JSON body (framework internals).
+    FRAMEWORK_IVARS = %i[
+      @event @raw_body @params @current_action @current_user_id @user_groups
+      @logger @__assigns_before @__response_status
+    ].freeze
+
+    private
+
+    # Turn the action return value (or instance-variable assigns) into an API Gateway response.
+    #
+    # Rails-like behavior for API-first controllers (default_format :json):
+    #   def index
+    #     @posts = Post.all   # → success_response({ posts: [...] })
+    #   end
+    #
+    # HTML controllers (default_format :html):
+    #   def show
+    #     @post = Post.find(...)  # → render template views/<ctrl>/show.html.erb
+    #   end
+    #
+    # Explicit responses still win:
+    #   success_response(...), error_response(...), html_response(...), render, head
+    #
+    # Non-200 with implicit body:
+    #   def create
+    #     @post = Post.create!(...)
+    #     response_status :created
+    #   end
+    def finalize_response(result)
+      return result if lambda_response?(result)
+
+      status = @__response_status || 200
+
+      return render(status: status) if self.class.default_format == :html
+
+      # Prefer assigns when present. Ruby assignment returns the RHS, so
+      # `@posts = Post.all` would otherwise look like an explicit return value.
+      # (Rails ignores the action return value entirely; we keep a thin fallback
+      # for explicit non-assign returns.)
+      assigns = collect_assigns
+      return success_response(assigns, status) if assigns.any?
+
+      return success_response({}, status) if result.nil?
+
+      success_response(serialize_for_response(result), status)
+    end
+
+    def lambda_response?(result)
+      result.is_a?(Hash) && (result.key?(:statusCode) || result.key?('statusCode'))
+    end
+
+    # Instance variables set during the action (excluding framework internals).
+    # Keys are the ivar names without @ — so @posts becomes { posts: ... }.
+    def collect_assigns
+      before = @__assigns_before || []
+      (instance_variables - before - FRAMEWORK_IVARS).each_with_object({}) do |ivar, hash|
+        key = ivar.to_s.delete_prefix('@')
+        next if key.start_with?('_')
+
+        hash[key.to_sym] = serialize_for_response(instance_variable_get(ivar))
+      end
+    end
+
+    # Deep-serialize models/relations into JSON-friendly hashes/arrays.
+    # ActiveItem::Relation (and any Enumerable of models) maps via to_h on each record.
+    def serialize_for_response(value)
+      case value
+      when nil, String, Numeric, TrueClass, FalseClass
+        value
+      when Symbol
+        value.to_s
+      when Hash
+        value.each_with_object({}) do |(k, v), h|
+          h[k.is_a?(Symbol) ? k : k.to_s] = serialize_for_response(v)
+        end
+      when Array
+        value.map { |v| serialize_for_response(v) }
+      else
+        serialize_object(value)
+      end
+    end
+
+    def serialize_object(value)
+      # Relations are Enumerable — map each record (don't call Enumerable#to_h)
+      if defined?(ActiveItem::Relation) && value.is_a?(ActiveItem::Relation)
+        value.map { |record| serialize_for_response(record) }
+      elsif value.respond_to?(:to_h) && !value.is_a?(Enumerable)
+        serialize_for_response(value.to_h)
+      elsif value.is_a?(Enumerable)
+        value.map { |item| serialize_for_response(item) }
+      elsif value.respond_to?(:to_h)
+        serialize_for_response(value.to_h)
+      else
+        value
+      end
+    end
+  end
+end

data/lib/templates/environment/backend.tf.erb

@@ -1,5 +1,6 @@
 terraform {
   backend "s3" {
+    # Resolved to belt-terraform-state-<account-id> by `belt setup state` / `belt new`
     bucket  = "belt-terraform-state"
     key     = "<%= s3_safe_name(@app_name) %>/<%= @env_name %>/terraform.tfstate"
     region  = "us-east-1"

data/lib/templates/frontend/react/src/index.css

@@ -1,10 +1,10 @@
 :root {
-  font-family: system-ui, -apple-system, sans-serif;
+  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
   line-height: 1.5;
-  color: #213547;
-  background-color: #ffffff;
+  color: #2d3748;
+  background-color: #f8f9fa;
 }
 
 * { box-sizing: border-box; margin: 0; padding: 0; }
 
-body { min-height: 100vh; }
+body { min-height: 100vh; background: #f8f9fa; }

data/lib/templates/frontend/react/src/lib/apiClient.js.erb

@@ -3,15 +3,32 @@ const API_URL = import.meta.env.VITE_API_URL || 'http://localhost:3000'
 export async function apiClient(path, options = {}) {
   const { method = 'GET', body, headers = {} } = options
 
+  // Only set Content-Type when sending a body. application/json on a GET forces a
+  // CORS preflight; Accept alone is safelisted and stays a simple request.
   const config = {
     method,
-    headers: { 'Content-Type': 'application/json', ...headers }
+    headers: {
+      Accept: 'application/json',
+      ...(body !== undefined && body !== null ? { 'Content-Type': 'application/json' } : {}),
+      ...headers
+    }
   }
 
-  if (body) config.body = JSON.stringify(body)
+  if (body !== undefined && body !== null) config.body = JSON.stringify(body)
 
   const response = await fetch(`${API_URL}${path}`, config)
-  const data = await response.json()
+
+  let data
+  const text = await response.text()
+  try {
+    data = text ? JSON.parse(text) : {}
+  } catch {
+    throw new Error(
+      response.ok
+        ? 'API returned non-JSON (is VITE_API_URL pointing at the API Gateway?)'
+        : `Request failed: ${response.status}`
+    )
+  }
 
   if (!response.ok) throw new Error(data.error || `Request failed: ${response.status}`)