belt 0.2.17 → 0.3.15

data/lib/belt/route_dsl.rb

@@ -52,48 +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"
+      options = options.merge(tables: [resource_name.to_sym]) unless options.key?(:tables)
       options = merge_inherited_options(options)
-      options = @gateway.send(:auto_infer_tables, resource_name, 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|
@@ -107,6 +105,40 @@ module Belt
 
     private
 
+    def add_nested_resource_routes(resource_name, param_name, resource_options, actions)
+      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}}",
+                      resolve_request_model_for(resource_options, :show))
+      end
+      if actions.include?(:update)
+        @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}}",
+                    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)
       result = options.dup
       if @inherited_tables.any?
@@ -115,17 +147,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|
@@ -146,6 +181,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
@@ -156,7 +192,7 @@ module Belt
     def initialize(name, options = {})
       @name = name.to_s
       @routes = []
-      @default_auth = options[:auth] || :cognito
+      @default_auth = options[:auth] || :none
       @default_lambda = options[:lambda] || name
       @default_cors = options.fetch(:cors, true)
       @default_tables = Array(options[:tables] || [])
@@ -184,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?
 
@@ -197,9 +229,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
 
@@ -208,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
@@ -253,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])
@@ -282,11 +361,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
@@ -302,11 +385,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
@@ -314,12 +426,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
@@ -333,85 +449,93 @@ 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)
+      # Rails-like `root` — defines a GET / route.
+      #
+      # Examples:
+      #   root to: "welcome#show"
+      #   root action: :show, controller: :welcome
+      #   root "pages#home"
+      def root(options_or_target = nil, **options)
+        if options_or_target.is_a?(String)
+          options[:to] = options_or_target
+        elsif options_or_target.is_a?(Hash)
+          options = options_or_target.merge(options)
+        end
+        options[:auth] ||= :none
+        route_options = apply_scope_to_route(options)
+        @gateway.send(:get, '/', route_options)
+      end
+
+      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] || [])
@@ -456,6 +580,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])
@@ -467,23 +601,107 @@ 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)
+        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])
+
+        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}"),
+                        resolve_request_model_for(resource_options, :destroy))
+        end
+        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)
+        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.17'
+  VERSION = '0.3.15'
 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
@@ -9,5 +9,5 @@
 
 VITE_API_URL: api_url
 # VITE_COGNITO_USER_POOL_ID: cognito_user_pool_id
-# VITE_COGNITO_CLIENT_ID: cognito_user_pool_client_id
+# VITE_COGNITO_CLIENT_ID: cognito_client_id
 # VITE_AWS_REGION: cognito_region