belt 0.1.9 → 0.1.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c3c75f106f7a0f2ebf672294ee30e96f96745fb3ecbd142307c08b6b006933c8
-  data.tar.gz: 470cefb769cfab7dbaf80e6f950eb62cf87fb5a6b297f3661cf147c26d494501
+  metadata.gz: 68099232d7da2991436a263de28721bfc4e15822116f11a42cd2433588293b59
+  data.tar.gz: ba091a54897cfd88b02e2ddf48750ca8a47ca3f4c298b7b4371be799e835550e
 SHA512:
-  metadata.gz: e5c5ed3dfa729483fd54e28197c9bd2f47f3581bea5f0892a4ac44c02f55253809f4fe1c12167ca55a040bdebc97e545b462f08d2f42c23dd1304a4a9dfd7768
-  data.tar.gz: be36355b315e467f411079880a4b3e14e94b56567cbf1892a95fff3f2b3c1c9a8bfe91e2e8618b405b1b06045ee1c06e999c12a6c281b9c490b8e8dc43d8f999
+  metadata.gz: 8e3d77c55c4297f2978486d9d0755ce45fda7f4a8886c372af0b211952502e5f5fde50c0d8881d4d5db39be4c3747a469825dfbd1b5d6f9be1120d441116600a
+  data.tar.gz: 7226f0ce500b1d19a7bccf60f9f087573998f3589ae7b41dceba7f35289a71e7e4ea3250269b96b18ef823acff06bbd67916f8d39c1ecb025ce97fbb8288019e

data/CHANGELOG.md

@@ -2,6 +2,26 @@
 
 ## Unreleased
 
+## 0.1.11
+
+### Route DSL
+
+- `resources` / `resource` honor `scope path:` (and nested path scopes).  
+  Example: `scope path: "admin", auth: :cognito { resources :users }` → `/admin/users…` with Cognito auth.
+- Nested `scope path:` segments stack (`a` then `b` → `a/b`) instead of replacing.
+- `scope controller:` is applied to `resources` / `resource` the same way as verb routes.
+- Controller inference for multi-segment resource paths joins segments (`/admin/users` → `admin/users`), matching nested-resource convention.
+
+## 0.1.10
+
+### Frontend env map
+
+- Declarative map (`frontend/env.yml` or `.belt/frontend_env.yml`) maps process env names → terraform output names (framework-agnostic: `VITE_*`, `REACT_APP_*`, `NEXT_PUBLIC_*`, etc.)
+- `belt deploy frontend <env>` injects mapped vars into `npm run build` process env
+- `belt frontend env <env>` smart-merges mapped keys into `frontend/.env` (preserves unmapped keys/comments; missing TF outputs warn and do not clobber)
+- No map → previous default: only `VITE_API_URL` ← `api_url`
+- `belt server` uses the same map for local process env
+
 ## 0.1.4
 
 ### Bug fixes

data/lib/belt/cli/frontend_deploy_command.rb

@@ -4,6 +4,7 @@ require 'shellwords'
 require 'open3'
 require_relative 'app_detection'
 require_relative 'env_resolver'
+require_relative 'frontend_env_map'
 
 module Belt
   module CLI
@@ -60,11 +61,18 @@ module Belt
         run!(*install_cmd, chdir: 'frontend')
 
         puts '🏗️  Building frontend...'
-        api_url = fetch_api_url
-        env = api_url ? { 'VITE_API_URL' => api_url } : {}
+        env = frontend_build_env
+        if env.any?
+          puts "   Injecting env: #{env.keys.sort.join(', ')}"
+        end
         run!(env, 'npm', 'run', 'build', chdir: 'frontend')
       end
 
+      # Resolve build env from frontend/env.yml map (or default VITE_API_URL ← api_url).
+      def frontend_build_env
+        FrontendEnvMap.new(@env, env_dir: @env_dir).process_env
+      end
+
       def sync_to_s3
         bucket = fetch_bucket_name
         abort "Error: Could not determine S3 bucket. Run `belt apply #{@env}` first." unless bucket
@@ -94,24 +102,24 @@ module Belt
         puts '✅ CloudFront cache invalidated'
       end
 
-      def fetch_api_url
-        output, status = Open3.capture2('terraform', 'output', '-raw', 'api_url', chdir: @env_dir)
-        status.success? && !output.strip.empty? ? output.strip : nil
-      end
-
       def fetch_bucket_name
-        output, status = Open3.capture2('terraform', 'output', '-raw', 'frontend_bucket_name', chdir: @env_dir)
-        status.success? && !output.strip.empty? ? output.strip : nil
+        fetch_tf_output('frontend_bucket_name')
       end
 
       def fetch_distribution_id
-        output, status = Open3.capture2('terraform', 'output', '-raw', 'frontend_distribution_id', chdir: @env_dir)
-        status.success? && !output.strip.empty? ? output.strip : nil
+        fetch_tf_output('frontend_distribution_id')
       end
 
       def fetch_frontend_url
-        output, status = Open3.capture2('terraform', 'output', '-raw', 'frontend_url', chdir: @env_dir)
-        status.success? && !output.strip.empty? ? output.strip : nil
+        fetch_tf_output('frontend_url')
+      end
+
+      def fetch_tf_output(name)
+        output, status = Open3.capture2('terraform', 'output', '-raw', name, chdir: @env_dir)
+        return nil unless status.success?
+
+        value = output.strip
+        value.empty? || value == 'null' ? nil : value
       end
 
       def run!(*args, **)

data/lib/belt/cli/frontend_env_command.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require_relative 'app_detection'
+require_relative 'env_resolver'
+require_relative 'frontend_env_map'
+
+module Belt
+  module CLI
+    # belt frontend env <environment>
+    #
+    # Smart-merges terraform outputs into frontend/.env using the declarative map
+    # (frontend/env.yml or .belt/frontend_env.yml). Only mapped keys are written;
+    # custom local keys are preserved.
+    class FrontendEnvCommand
+      include AppDetection
+
+      def self.run(args)
+        subcommand = args.shift
+
+        case subcommand
+        when 'env'
+          run_env(args)
+        when nil, '-h', '--help', 'help'
+          puts usage
+          exit(subcommand.nil? ? 1 : 0)
+        else
+          puts "Unknown frontend subcommand: #{subcommand}\n\n#{usage}"
+          exit 1
+        end
+      end
+
+      def self.run_env(args)
+        env = EnvResolver.resolve(args)
+
+        if env.nil?
+          puts 'Usage: belt frontend env <environment>'
+          puts "\nWrites frontend/.env from terraform outputs using the env map."
+          puts 'You can also set BELT_ENV to skip the environment argument.'
+          puts "\nMap file (optional): frontend/env.yml or .belt/frontend_env.yml"
+          puts 'Default without map: VITE_API_URL ← api_url'
+          puts "\nExamples:"
+          puts '  belt frontend env dev'
+          puts '  BELT_ENV=dev belt frontend env'
+          exit 1
+        end
+
+        new(env).run
+      end
+
+      def self.usage
+        <<~USAGE
+          Frontend helpers.
+
+          Usage:
+            belt frontend env <environment>   Write frontend/.env from terraform outputs
+            belt frontend --help
+
+          Env map (optional):
+            frontend/env.yml
+            .belt/frontend_env.yml
+
+          Example map:
+            VITE_API_URL: api_url
+            VITE_COGNITO_USER_POOL_ID: cognito_user_pool_id
+            VITE_COGNITO_CLIENT_ID: cognito_user_pool_client_id
+            VITE_AWS_REGION: cognito_region
+
+          Without a map, belt injects only VITE_API_URL from api_url.
+
+          Smart merge: only keys listed in the map are updated. Other .env keys
+          (local secrets, feature flags) are left alone. Missing terraform outputs
+          warn and do not overwrite existing values.
+        USAGE
+      end
+
+      def initialize(env)
+        @env = env
+        @app_name = detect_app_name
+        @env_dir = "infrastructure/#{@env}"
+      end
+
+      def run
+        unless Dir.exist?('frontend')
+          abort 'Error: No frontend/ directory found. Run `belt generate frontend react` first.'
+        end
+
+        unless Dir.exist?(@env_dir)
+          abort "Error: infrastructure/#{@env} not found. Run `belt generate environment #{@env}` first."
+        end
+
+        map = FrontendEnvMap.new(@env, env_dir: @env_dir)
+
+        if map.using_default_map?
+          puts '📋 No frontend/env.yml found — using default map (VITE_API_URL ← api_url)'
+        else
+          puts "📋 Loading env map from #{map.map_path}"
+        end
+
+        result = map.write_dotenv!
+        updated = result[:updated]
+
+        if updated.empty?
+          puts "⚠️  No values written to #{result[:path]} (terraform outputs missing?)"
+        else
+          puts "✅ Updated #{result[:path]} (#{updated.join(', ')})"
+        end
+      end
+    end
+  end
+end

data/lib/belt/cli/frontend_env_map.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'open3'
+require 'yaml'
+
+module Belt
+  module CLI
+    # Resolves frontend env vars from a declarative map (env name → terraform output).
+    #
+    # Map file (optional), first match wins:
+    #   frontend/env.yml
+    #   .belt/frontend_env.yml
+    #
+    # Example:
+    #   VITE_API_URL: api_url
+    #   VITE_COGNITO_USER_POOL_ID: cognito_user_pool_id
+    #   REACT_APP_API_URL: api_url
+    #
+    # No map → default { "VITE_API_URL" => "api_url" } (backwards compatible).
+    class FrontendEnvMap
+      MAP_CANDIDATES = [
+        File.join('frontend', 'env.yml'),
+        File.join('.belt', 'frontend_env.yml')
+      ].freeze
+
+      DEFAULT_MAP = { 'VITE_API_URL' => 'api_url' }.freeze
+
+      DOTENV_PATH = File.join('frontend', '.env')
+
+      attr_reader :env_name, :env_dir, :map_path, :map
+
+      def initialize(env_name, env_dir: nil, map_path: nil)
+        @env_name = env_name
+        @env_dir = env_dir || File.join('infrastructure', env_name)
+        @map_path = map_path || self.class.find_map_path
+        @map = load_map
+        @tf_cache = {}
+      end
+
+      def self.find_map_path
+        MAP_CANDIDATES.find { |path| File.file?(path) }
+      end
+
+      # Hash of env_var => value suitable for process env (npm run build / vite).
+      # Skips keys whose terraform output is missing.
+      def process_env
+        resolved = {}
+        each_resolved do |env_key, value, _tf_output|
+          resolved[env_key] = value if value
+        end
+        resolved
+      end
+
+      # Smart-merge mapped keys into frontend/.env.
+      # - Only overwrites keys present in the map
+      # - Preserves unknown keys, comments, and blank lines
+      # - Missing TF output → warn, do not clobber an existing value
+      def write_dotenv!(path: DOTENV_PATH)
+        FileUtils.mkdir_p(File.dirname(path))
+
+        existing_lines = File.file?(path) ? File.readlines(path, chomp: true) : []
+        updates = {}
+        missing = []
+
+        each_resolved do |env_key, value, tf_output|
+          if value
+            updates[env_key] = value
+          else
+            missing << [env_key, tf_output]
+          end
+        end
+
+        missing.each do |env_key, tf_output|
+          puts "⚠️  terraform output '#{tf_output}' missing — leaving #{env_key} unchanged in #{path}"
+        end
+
+        written = {}
+        new_lines = existing_lines.map do |line|
+          key = dotenv_key(line)
+          if key && updates.key?(key)
+            written[key] = true
+            format_dotenv_line(key, updates[key])
+          else
+            line
+          end
+        end
+
+        updates.each do |key, value|
+          next if written[key]
+
+          new_lines << format_dotenv_line(key, value)
+          written[key] = true
+        end
+
+        content = "#{new_lines.join("\n")}\n"
+        File.write(path, content)
+
+        {
+          path: path,
+          updated: written.keys.sort,
+          missing: missing.map(&:first)
+        }
+      end
+
+      def using_default_map?
+        @map_path.nil?
+      end
+
+      private
+
+      def load_map
+        return DEFAULT_MAP.dup if @map_path.nil?
+
+        raw = YAML.safe_load(File.read(@map_path), aliases: false)
+        unless raw.is_a?(Hash) && raw.any?
+          abort "Error: frontend env map #{@map_path} must be a non-empty YAML mapping " \
+                '(e.g. VITE_API_URL: api_url).'
+        end
+
+        raw.each_with_object({}) do |(key, value), hash|
+          k = key.to_s.strip
+          v = value.to_s.strip
+          next if k.empty? || v.empty?
+
+          hash[k] = v
+        end.tap do |parsed|
+          abort "Error: frontend env map #{@map_path} has no valid entries." if parsed.empty?
+        end
+      rescue Psych::SyntaxError => e
+        abort "Error: invalid YAML in #{@map_path}: #{e.message}"
+      end
+
+      def each_resolved
+        map.each do |env_key, tf_output|
+          yield env_key, fetch_tf_output(tf_output), tf_output
+        end
+      end
+
+      def fetch_tf_output(name)
+        return @tf_cache[name] if @tf_cache.key?(name)
+
+        @tf_cache[name] = read_tf_output(name)
+      end
+
+      def read_tf_output(name)
+        return nil unless Dir.exist?(@env_dir)
+
+        output, status = Open3.capture2(
+          'terraform', 'output', '-raw', name,
+          chdir: @env_dir,
+          err: File::NULL
+        )
+        return nil unless status.success?
+
+        value = output.strip
+        return nil if value.empty? || value == 'null'
+
+        value
+      rescue Errno::ENOENT
+        nil
+      end
+
+      # Match KEY=value lines; ignore comments and export prefixes.
+      def dotenv_key(line)
+        return nil if line.strip.empty? || line.lstrip.start_with?('#')
+
+        stripped = line.strip
+        stripped = stripped.sub(/\Aexport\s+/, '')
+        return nil unless stripped =~ /\A([A-Za-z_][A-Za-z0-9_]*)=/
+
+        Regexp.last_match(1)
+      end
+
+      def format_dotenv_line(key, value)
+        "#{key}=#{escape_dotenv_value(value)}"
+      end
+
+      def escape_dotenv_value(value)
+        str = value.to_s
+        return str if str.empty?
+        return str unless str.match?(/[\s\#"'\\$`]/)
+
+        %("#{str.gsub('\\', '\\\\').gsub('"', '\\"')}")
+      end
+    end
+  end
+end

data/lib/belt/cli/routes_command/route_inference.rb

@@ -14,7 +14,11 @@ module Belt
           non_param = segments.reject { |s| s.start_with?(':', '{') }
           return gateway.name if non_param.empty?
 
-          return non_param.map { |s| s.gsub('-', '_') }.join('/') if route.resource? && nested_resource?(segments)
+          # Nested resources (/posts/{id}/comments) and scoped resources (/admin/users):
+          # join non-param segments → posts/comments, admin/users
+          if route.resource? && non_param.length > 1
+            return non_param.map { |s| s.gsub('-', '_') }.join('/')
+          end
 
           # For non-resource routes with a single segment (e.g., post '/signup' in :onboarding),
           # the segment is the action name, not the controller. Use the gateway name as controller.

data/lib/belt/cli/server_command.rb

@@ -3,6 +3,7 @@
 require 'base64'
 require 'json'
 require_relative 'app_detection'
+require_relative 'frontend_env_map'
 require_relative 'terraform_command'
 
 module Belt
@@ -50,13 +51,14 @@ module Belt
 
           Behavior:
             • If frontend/ exists → runs the frontend dev server (npm run dev)
-              Automatically sets VITE_API_URL from terraform outputs if deployed.
+              Injects env from frontend/env.yml (or default VITE_API_URL) using
+              terraform outputs when available.
             • If no frontend → serves the welcome page via a local HTTP server
               After deploy, shows live API URL and deployment status.
 
           Note: The backend is serverless (AWS Lambda). Use `belt deploy` to deploy
-          your backend to AWS. Local frontend development automatically points to
-          your deployed API via VITE_API_URL.
+          your backend to AWS. Local frontend development reads the env map (or
+          frontend/.env via `belt frontend env <env>`).
 
           Examples:
             belt server                 # Start on port #{DEFAULT_PORT}
@@ -84,17 +86,22 @@ module Belt
 
       def run_frontend_dev_server
         puts "🚀 Starting frontend dev server on port #{@port}..."
-        if @api_url
-          puts "   Backend API: #{@api_url}"
+        build_env = frontend_process_env
+        api_url = build_env['VITE_API_URL'] || build_env['REACT_APP_API_URL'] ||
+                  build_env['NEXT_PUBLIC_API_URL'] || @api_url
+        if api_url
+          puts "   Backend API: #{api_url}"
         else
           puts '   Backend is serverless — deploy with `belt deploy` to set up AWS resources.'
         end
+        if build_env.any?
+          puts "   Env: #{build_env.keys.sort.join(', ')}"
+        end
         puts ''
 
         open_browser_later if @open_browser
 
-        env = { 'PORT' => @port.to_s }
-        env['VITE_API_URL'] = @api_url if @api_url
+        env = { 'PORT' => @port.to_s }.merge(build_env)
 
         # Prefer the dev script with the port flag for Vite-based setups
         Dir.chdir('frontend') do
@@ -102,6 +109,17 @@ module Belt
         end
       end
 
+      # Process env from the declarative map (or default VITE_API_URL), if an env is available.
+      def frontend_process_env
+        env_name = @deploy_env || ENV.fetch('BELT_ENV', nil) || TerraformCommand.list_environments.first
+        return {} unless env_name
+
+        FrontendEnvMap.new(env_name).process_env
+      rescue StandardError
+        # Fall back to legacy api_url detection if map resolution fails
+        @api_url ? { 'VITE_API_URL' => @api_url } : {}
+      end
+
       def run_welcome_server
         if @api_url
           puts "🚀 Serving Belt welcome page on http://localhost:#{@port}"

data/lib/belt/cli.rb

@@ -9,6 +9,7 @@ require_relative 'cli/destroy_command'
 require_relative 'cli/frontend_command'
 require_relative 'cli/frontend_setup_command'
 require_relative 'cli/frontend_deploy_command'
+require_relative 'cli/frontend_env_command'
 require_relative 'cli/views_command'
 require_relative 'cli/setup_command'
 require_relative 'cli/terraform_command'
@@ -29,10 +30,12 @@ module Belt
       %w[tasks --tasks -T] => Belt::CLI::TasksCommand,
       'setup' => Belt::CLI::SetupCommand,
       'deploy' => Belt::CLI::DeployCommand,
+      'frontend' => Belt::CLI::FrontendEnvCommand,
       %w[server s] => Belt::CLI::ServerCommand,
       %w[version --version -v] => ->(_args) { puts "Belt #{Belt::VERSION}" }
     }.freeze
 
+
     COMMANDS = COMMANDS_DEFINITION.each_with_object({}) do |(keys, handler), hash|
       Array(keys).each { |key| hash[key] = handler }
     end.freeze
@@ -99,7 +102,9 @@ module Belt
           s                                           Alias for server
           deploy [environment]                        Deploy to AWS (init → plan → apply)
           deploy frontend <env>                       Build and deploy frontend to AWS
+          frontend env <env>                          Write frontend/.env from terraform outputs
           routes [-g PATTERN] [-f json]               Show route definitions
+
           console                                     Start an interactive console (IRB)
           c                                           Alias for console
           tasks [-g PATTERN] [-a]                     List available rake tasks
@@ -133,6 +138,7 @@ module Belt
           belt deploy                   # Deploy dev to AWS
           belt deploy prod --auto       # Deploy prod without confirmation
           belt deploy frontend wups
+          belt frontend env wups        # Smart-merge TF outputs into frontend/.env
           belt setup frontend wups
           belt apply wups
           belt tasks                    # list all rake tasks

data/lib/belt/route_dsl.rb

@@ -174,20 +174,22 @@ module Belt
       resource_name = name.to_s
       singular = singularize(resource_name)
       param_name = options[:param] || "#{singular}_id"
+      base_path = resource_base_path(resource_name, options)
+      options = options.except(:path_prefix)
       options = auto_infer_tables(resource_name, options)
       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_route(:get, base_path, resource_options) if actions.include?(:index)
+      add_route(:post, base_path, resource_options) if actions.include?(:create)
+      add_route(:get, "#{base_path}/{#{param_name}}", resource_options) if actions.include?(:show)
+      add_route(:put, "#{base_path}/{#{param_name}}", resource_options) if actions.include?(:update)
+      add_route(:delete, "#{base_path}/{#{param_name}}", resource_options) if actions.include?(:destroy)
 
       return unless block_given?
 
-      collection_prefix = "/#{resource_name}"
-      member_prefix = "/#{resource_name}/{#{param_name}}"
+      collection_prefix = base_path
+      member_prefix = "#{base_path}/{#{param_name}}"
       resource_tables = Array(options[:tables] || [])
       inherited_tables = (@default_tables + resource_tables).uniq
       inherited_auth = options[:auth] || @default_auth
@@ -199,17 +201,25 @@ module Belt
 
     def resource(name, options = {})
       resource_name = name.to_s
+      base_path = resource_base_path(resource_name, options)
+      options = options.except(:path_prefix)
       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)
+      add_route(:get, base_path, resource_options) if actions.include?(:show)
+      add_route(:put, base_path, resource_options) if actions.include?(:update)
+      add_route(:delete, base_path, resource_options) if actions.include?(:destroy)
+      add_route(:post, base_path, resource_options) if actions.include?(:create)
     end
 
     private
 
+    # Builds "/users" or "/admin/users" when path_prefix is set (from scope path:).
+    def resource_base_path(resource_name, options)
+      prefix = options[:path_prefix].to_s.gsub(%r{^/|/$}, '')
+      prefix.empty? ? "/#{resource_name}" : "/#{prefix}/#{resource_name}"
+    end
+
     def add_route(method, path, options = {})
       lambda_to_use = options[:lambda] || @current_lambda_context || @default_lambda
       route_tables = Array(options[:tables] || [])
@@ -308,7 +318,11 @@ module Belt
         previous_tables = @scope_tables
         previous_controller = @scope_controller
 
-        @scope_prefix = options[:path] || @scope_prefix
+        # Nest path segments (Rails-style): 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
         @scope_auth = options[:auth] || @scope_auth
         @scope_tables = (@scope_tables + Array(options[:tables] || [])).uniq
@@ -340,11 +354,13 @@ module Belt
 
       def resources(name, options = {}, &)
         options = apply_scope_options(options)
+        options = options.merge(path_prefix: @scope_prefix) unless @scope_prefix.to_s.empty?
         @gateway.resources(name, options, &)
       end
 
       def resource(name, options = {})
         options = apply_scope_options(options)
+        options = options.merge(path_prefix: @scope_prefix) unless @scope_prefix.to_s.empty?
         @gateway.resource(name, options)
       end
 
@@ -400,6 +416,7 @@ module Belt
         result = options.dup
         result[:auth] ||= @scope_auth if @scope_auth
         result[:lambda] ||= @scope_module if @scope_module
+        result[:controller] ||= @scope_controller if @scope_controller
         result[:tables] = (@scope_tables + Array(result[:tables] || [])).uniq if @scope_tables.any? || result[:tables]
         result
       end

data/lib/belt/version.rb

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

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

@@ -0,0 +1,13 @@
+# 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.
+#
+# belt deploy frontend <env>  → injects these into npm run build
+# belt frontend env <env>     → smart-merges into frontend/.env for local dev
+#
+# Without this file, belt only sets VITE_API_URL from api_url.
+
+VITE_API_URL: api_url
+# VITE_COGNITO_USER_POOL_ID: cognito_user_pool_id
+# VITE_COGNITO_CLIENT_ID: cognito_user_pool_client_id
+# VITE_AWS_REGION: cognito_region

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: belt
 version: !ruby/object:Gem::Version
-  version: 0.1.9
+  version: 0.1.11
 platform: ruby
 authors:
 - Stowzilla
@@ -78,6 +78,8 @@ files:
 - lib/belt/cli/environment_command.rb
 - lib/belt/cli/frontend_command.rb
 - 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_setup_command.rb
 - lib/belt/cli/generate_command.rb
 - lib/belt/cli/new_command.rb
@@ -110,6 +112,7 @@ files:
 - lib/templates/environment/outputs.tf.erb
 - lib/templates/environment/terraform.tfvars.erb
 - lib/templates/environment/variables.tf.erb
+- lib/templates/frontend/react/env.yml.example
 - lib/templates/frontend/react/index.html.erb
 - lib/templates/frontend/react/package.json.erb
 - lib/templates/frontend/react/src/App.jsx