belt 0.1.13 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b3834960aad8c883c22d15acec6a320d860bd8b90acb3c7c74751c59ce49b959
-  data.tar.gz: 29f96098a7ac79c0f3eb62edd9950a9d1e95e2f56b219b3fcd024b19f3b4daac
+  metadata.gz: dd7335772d9025878073df619babf32aff170b29d620420382c5f73a8eebff30
+  data.tar.gz: 8c0379aee3988b267d690d639c986bb827b4e0d403bf358b04ef86c5a64a4d60
 SHA512:
-  metadata.gz: 597c85007b7e8838f77605ec31de2b20bac85bf29ec20de371b85f03dd4a9eb20abba6be12f5b8f701e2c36ee02377b3488efa00292060f36b8bc956ef04d8ed
-  data.tar.gz: 4c24a2f2c554244010ec246bc337194f6616ed04394ff8aeea4d5aabe91c97adeac7aaad76fbfa9a812fa35397fc46770c347ee590a5d307e2073ee2e811ff13
+  metadata.gz: 17a2e1f23c328abc880c19228234cac3fd6d4af78abbf704b2abbdc703990312115cd39ff12e492fa671d28a79cc8276a681778071fa094ab6dfdc7931360889
+  data.tar.gz: bc78f0e686cae19a4806ad21b3dbf9fc52adb768854e915dcbef155c593bf0317f771eb260478125ce10717e83e7dfa1e4230ebb9c123ad59bfcafb4578c3ed9

data/lib/belt/cli/app_detection.rb

@@ -6,8 +6,8 @@ module Belt
       # Detects the primary namespace from the route definitions.
       # Used by generators to determine controller directory and route file naming.
       def detect_namespace
-        routes_file = 'infrastructure/routes.tf.rb'
-        if File.exist?(routes_file)
+        routes_file = find_routes_file_path
+        if routes_file && File.exist?(routes_file)
           match = File.read(routes_file).match(/namespace :(\w+)/)
           return match[1] if match
         end
@@ -39,6 +39,18 @@ module Belt
       def s3_safe_name(name)
         name.to_s.downcase.tr('_', '-')
       end
+
+      # Finds routes.tf.rb checking config/ first, then infrastructure/ (legacy).
+      def find_routes_file_path
+        candidates = ['config/routes.tf.rb', 'infrastructure/routes.tf.rb']
+        candidates.find { |f| File.exist?(f) }
+      end
+
+      # Finds schema.tf.rb checking config/ first, then infrastructure/ (legacy).
+      def find_schema_file_path
+        candidates = ['config/schema.tf.rb', 'infrastructure/schema.tf.rb']
+        candidates.find { |f| File.exist?(f) }
+      end
     end
   end
 end

data/lib/belt/cli/destroy_command.rb

@@ -215,8 +215,8 @@ module Belt
       end
 
       def remove_routes
-        routes_file = 'infrastructure/routes.tf.rb'
-        return unless File.exist?(routes_file)
+        routes_file = find_routes_file_path
+        return unless routes_file && File.exist?(routes_file)
 
         content = File.read(routes_file)
         original = content.dup
@@ -255,8 +255,8 @@ module Belt
       end
 
       def remove_schema
-        schema_file = 'infrastructure/schema.tf.rb'
-        return unless File.exist?(schema_file)
+        schema_file = find_schema_file_path
+        return unless schema_file && File.exist?(schema_file)
 
         content = File.read(schema_file)
         original = content.dup

data/lib/belt/cli/generate_command.rb

@@ -38,8 +38,8 @@ module Belt
             Creates:
               lambda/models/<name>.rb                            Model with validations and fields
               lambda/controllers/<app>/<names>_controller.rb    RESTful controller (index, show, create, update, destroy)
-              infrastructure/routes.tf.rb                        Route entry added
-              infrastructure/schema.tf.rb                        DynamoDB table schema added
+              config/routes.tf.rb                                Route entry added
+              config/schema.tf.rb                                DynamoDB table schema added
               lambda/lib/routes/<app>_routes.rb                  Route manifest updated
               frontend/src/pages/<names>/                        React pages (if frontend exists)
 
@@ -279,13 +279,15 @@ module Belt
           conflicts << "lambda/controllers/#{@app_name}/#{@resource_name}_controller.rb"
         end
 
-        schema_file = 'infrastructure/schema.tf.rb'
-        if File.exist?(schema_file) && File.read(schema_file).match?(/^\s*model :#{Regexp.escape(@singular_name)}\b/)
+        schema_file = find_schema_file_path
+        if schema_file && File.exist?(schema_file) &&
+           File.read(schema_file).match?(/^\s*model :#{Regexp.escape(@singular_name)}\b/)
           conflicts << "#{schema_file} (model :#{@singular_name})"
         end
 
-        routes_file = 'infrastructure/routes.tf.rb'
-        if File.exist?(routes_file) && File.read(routes_file).match?(/resources :#{Regexp.escape(@resource_name)}\b/)
+        routes_file = find_routes_file_path
+        if routes_file && File.exist?(routes_file) &&
+           File.read(routes_file).match?(/resources :#{Regexp.escape(@resource_name)}\b/)
           conflicts << "#{routes_file} (resources :#{@resource_name})"
         end
 
@@ -302,8 +304,9 @@ module Belt
         conflicts = []
         conflicts << "lambda/models/#{@singular_name}.rb" if File.exist?("lambda/models/#{@singular_name}.rb")
 
-        schema_file = 'infrastructure/schema.tf.rb'
-        if File.exist?(schema_file) && File.read(schema_file).match?(/^\s*model :#{Regexp.escape(@singular_name)}\b/)
+        schema_file = find_schema_file_path
+        if schema_file && File.exist?(schema_file) &&
+           File.read(schema_file).match?(/^\s*model :#{Regexp.escape(@singular_name)}\b/)
           conflicts << "#{schema_file} (model :#{@singular_name})"
         end
 
@@ -327,8 +330,8 @@ module Belt
         puts "\nFiles created/updated:"
         puts "  lambda/models/#{@singular_name}.rb"
         puts "  lambda/controllers/#{@app_name}/#{@resource_name}_controller.rb"
-        puts '  infrastructure/routes.tf.rb (updated)'
-        puts '  infrastructure/schema.tf.rb (updated)'
+        puts "  #{find_routes_file_path || 'config/routes.tf.rb'} (updated)"
+        puts "  #{find_schema_file_path || 'config/schema.tf.rb'} (updated)"
         puts "  lambda/lib/routes/#{@app_name}_routes.rb (updated)"
         puts "  frontend/src/pages/#{@resource_name}/ (views)" if Dir.exist?('frontend/src')
       end
@@ -352,8 +355,8 @@ module Belt
       end
 
       def inject_routes
-        routes_file = 'infrastructure/routes.tf.rb'
-        return unless File.exist?(routes_file)
+        routes_file = find_routes_file_path
+        return unless routes_file && File.exist?(routes_file)
 
         content = File.read(routes_file)
         tables_arg = @fields.any? ? ", tables: [:#{@resource_name}]" : ''
@@ -444,8 +447,8 @@ module Belt
       end
 
       def inject_schema
-        schema_file = 'infrastructure/schema.tf.rb'
-        return unless File.exist?(schema_file)
+        schema_file = find_schema_file_path
+        return unless schema_file && File.exist?(schema_file)
 
         content = File.read(schema_file)
 

data/lib/belt/cli/lambda_config_command.rb

@@ -0,0 +1,298 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'json'
+require_relative 'app_detection'
+
+module Belt
+  module CLI
+    # Reads config/lambda/*.yml files and produces a merged lambda_config hash
+    # suitable for Conveyor Belt's `lambda_config` variable.
+    #
+    # Each YAML file follows a database.yml-like pattern:
+    #
+    #   # config/lambda/customer.yml
+    #   default: &default
+    #     timeout: 60
+    #     memory_size: 512
+    #     env_keys:
+    #       - IMAGES_BUCKET_NAME
+    #       - IMAGES_CLOUDFRONT_DOMAIN
+    #
+    #   dev:
+    #     <<: *default
+    #     memory_size: 256
+    #
+    #   prod:
+    #     <<: *default
+    #     timeout: 30
+    #     memory_size: 1024
+    #
+    class LambdaConfigCommand
+      include AppDetection
+
+      SUPPORTED_KEYS = %w[
+        timeout memory_size env_vars env_keys
+        s3_buckets dynamodb_tables sns_triggers sqs_triggers
+        reserved_concurrency ephemeral_storage
+      ].freeze
+
+      def self.run(args)
+        options = {}
+
+        i = 0
+        while i < args.length
+          case args[i]
+          when '-e', '--environment'
+            i += 1
+            options[:environment] = args[i]
+          when '-f', '--format'
+            i += 1
+            options[:format] = args[i]
+          when '--lambda'
+            i += 1
+            options[:lambda] = args[i]
+          when '-h', '--help'
+            puts help_text
+            exit 0
+          end
+          i += 1
+        end
+
+        new(options).run
+      end
+
+      def self.help_text
+        <<~HELP
+          Read lambda config from config/lambda/*.yml files.
+
+          Usage: belt lambda-config [options]
+
+          Reads YAML config files and produces a merged configuration hash for the
+          specified environment (like database.yml in Rails).
+
+          Options:
+            -e, --environment ENV    Target environment (default: dev)
+            -f, --format FORMAT      Output format: json (default), terraform
+            --lambda NAME            Only output config for a specific lambda
+            -h, --help               Show this help
+
+          Examples:
+            belt lambda-config -e prod
+            belt lambda-config -e dev --format terraform
+            belt lambda-config --lambda customer -e prod
+
+          Config files live at config/lambda/<name>.yml. Each file can define
+          environment-specific overrides using YAML anchors:
+
+            # config/lambda/customer.yml
+            default: &default
+              timeout: 60
+              memory_size: 512
+              env_keys:
+                - IMAGES_BUCKET_NAME
+                - STRIPE_KEY
+
+            dev:
+              <<: *default
+              memory_size: 256
+
+            prod:
+              <<: *default
+              memory_size: 1024
+
+          Keys:
+            timeout              Lambda timeout in seconds (default: 30)
+            memory_size          Lambda memory in MB (default: 256)
+            env_keys             List of env var names this lambda needs
+            env_vars             Static env vars (key: value pairs)
+            s3_buckets           S3 bucket access declarations
+            dynamodb_tables      DynamoDB table access declarations
+            sns_triggers         SNS topic triggers
+            sqs_triggers         SQS queue triggers
+            reserved_concurrency Reserved concurrency limit
+            ephemeral_storage    Ephemeral storage in MB (512-10240)
+        HELP
+      end
+
+      def initialize(options = {})
+        @environment = options[:environment] || ENV.fetch('BELT_ENV', 'dev')
+        @format = options[:format] || 'json'
+        @lambda_filter = options[:lambda]
+        @config_dir = 'config/lambda'
+      end
+
+      def run
+        abort "Error: #{@config_dir}/ not found. Create lambda config files there." unless Dir.exist?(@config_dir)
+
+        configs = load_all_configs
+        configs = configs.select { |name, _| name == @lambda_filter } if @lambda_filter
+
+        if configs.empty?
+          if @lambda_filter
+            abort "Error: No config found for lambda '#{@lambda_filter}' in #{@config_dir}/"
+          else
+            abort "Error: No .yml files found in #{@config_dir}/"
+          end
+        end
+
+        output(configs)
+      end
+
+      # Public API: load and merge all configs for a given environment.
+      # Used by other belt commands and potentially by the Conveyor Belt provider.
+      def self.load_configs(environment: 'dev', config_dir: 'config/lambda')
+        return {} unless Dir.exist?(config_dir)
+
+        configs = {}
+        Dir.glob(File.join(config_dir, '*.yml')).each do |file|
+          name = File.basename(file, '.yml')
+          raw = YAML.safe_load_file(file, aliases: true) || {}
+          configs[name] = resolve_environment(raw, environment)
+        end
+        configs
+      end
+
+      private
+
+      def load_all_configs
+        self.class.load_configs(environment: @environment, config_dir: @config_dir)
+      end
+
+      def self.resolve_environment(raw, environment)
+        # Merge: default < environment-specific
+        base = raw['default'] || {}
+        env_config = raw[environment] || {}
+        merged = deep_merge(base, env_config)
+
+        # Remove the YAML anchor/environment keys from output
+        merged.reject { |k, _| k == 'default' || !SUPPORTED_KEYS.include?(k) }
+      end
+      private_class_method :resolve_environment
+
+      def self.deep_merge(base, override)
+        base.merge(override) do |_key, old_val, new_val|
+          if old_val.is_a?(Hash) && new_val.is_a?(Hash)
+            deep_merge(old_val, new_val)
+          else
+            new_val
+          end
+        end
+      end
+      private_class_method :deep_merge
+
+      def output(configs)
+        case @format
+        when 'json'
+          puts JSON.pretty_generate(configs)
+        when 'terraform'
+          output_terraform(configs)
+        else
+          abort "Unknown format: #{@format}. Use 'json' or 'terraform'."
+        end
+      end
+
+      # Output a Terraform-compatible lambda_config block.
+      # This can be piped to a .tfvars file or used by the provider directly.
+      def output_terraform(configs)
+        puts 'lambda_config = {'
+        configs.each_with_index do |(name, config), idx|
+          puts "  #{name} = {"
+          puts "    timeout     = #{config['timeout']}" if config['timeout']
+          puts "    memory_size = #{config['memory_size']}" if config['memory_size']
+          puts "    reserved_concurrency = #{config['reserved_concurrency']}" if config['reserved_concurrency']
+          puts "    ephemeral_storage = #{config['ephemeral_storage']}" if config['ephemeral_storage']
+
+          output_env_vars_tf(config) if config['env_vars'] || config['env_keys']
+          output_s3_buckets_tf(config['s3_buckets']) if config['s3_buckets']
+          output_dynamodb_tables_tf(config['dynamodb_tables']) if config['dynamodb_tables']
+          output_sns_triggers_tf(config['sns_triggers']) if config['sns_triggers']
+          output_sqs_triggers_tf(config['sqs_triggers']) if config['sqs_triggers']
+
+          puts "  }#{'' unless idx < configs.size - 1}"
+          puts '' if idx < configs.size - 1
+        end
+        puts '}'
+      end
+
+      def output_env_vars_tf(config)
+        env_vars = config['env_vars'] || {}
+        env_keys = config['env_keys'] || []
+
+        # env_keys become placeholder entries that Terraform must fill
+        all_vars = env_vars.dup
+        env_keys.each { |k| all_vars[k] ||= '' }
+
+        return if all_vars.empty?
+
+        puts ''
+        puts '    env_vars = {'
+        all_vars.each do |key, value|
+          if value.empty?
+            puts "      #{key} = var.#{key.downcase}"
+          else
+            puts "      #{key} = #{value.inspect}"
+          end
+        end
+        puts '    }'
+      end
+
+      def output_s3_buckets_tf(buckets)
+        return if buckets.nil? || buckets.empty?
+
+        puts ''
+        puts '    s3_buckets = ['
+        buckets.each do |bucket|
+          puts '      {'
+          puts "        bucket_arn  = #{bucket['bucket_arn'] || 'TODO'}"
+          puts "        permissions = #{bucket['permissions'].inspect}" if bucket['permissions']
+          puts '      }'
+        end
+        puts '    ]'
+      end
+
+      def output_dynamodb_tables_tf(tables)
+        return if tables.nil? || tables.empty?
+
+        puts ''
+        puts '    dynamodb_tables = ['
+        tables.each do |table|
+          puts '      {'
+          puts "        table_arn   = #{table['table_arn'] || 'TODO'}"
+          puts "        permissions = #{table['permissions'].inspect}" if table['permissions']
+          puts "        index_names = #{table['index_names'].inspect}" if table['index_names']
+          puts '      }'
+        end
+        puts '    ]'
+      end
+
+      def output_sns_triggers_tf(triggers)
+        return if triggers.nil? || triggers.empty?
+
+        puts ''
+        puts '    sns_triggers = ['
+        triggers.each do |trigger|
+          puts '      {'
+          puts "        topic_arn    = #{trigger['topic_arn'] || 'TODO'}"
+          puts "        statement_id = #{trigger['statement_id'].inspect}" if trigger['statement_id']
+          puts '      }'
+        end
+        puts '    ]'
+      end
+
+      def output_sqs_triggers_tf(triggers)
+        return if triggers.nil? || triggers.empty?
+
+        puts ''
+        puts '    sqs_triggers = ['
+        triggers.each do |trigger|
+          puts '      {'
+          puts "        queue_arn  = #{trigger['queue_arn'] || 'TODO'}"
+          puts "        batch_size = #{trigger['batch_size']}" if trigger['batch_size']
+          puts '      }'
+        end
+        puts '    ]'
+      end
+    end
+  end
+end

data/lib/belt/cli/new_command.rb

@@ -122,6 +122,7 @@ module Belt
           #{@app_name}/lambda/lib/routes
           #{@app_name}/lambda/config
           #{@app_name}/lambda/spec
+          #{@app_name}/config/lambda
           #{@app_name}/infrastructure/modules/app
         ]
       end
@@ -136,8 +137,9 @@ module Belt
           'lambda/controllers/application_controller.rb.erb' =>
             "#{@app_name}/lambda/controllers/api/application_controller.rb",
           'lambda/lib/routes/routes.rb.erb' => "#{@app_name}/lambda/lib/routes/api_routes.rb",
-          'infrastructure/routes.tf.rb.erb' => "#{@app_name}/infrastructure/routes.tf.rb",
-          'infrastructure/schema.tf.rb.erb' => "#{@app_name}/infrastructure/schema.tf.rb",
+          'config/routes.tf.rb.erb' => "#{@app_name}/config/routes.tf.rb",
+          'config/schema.tf.rb.erb' => "#{@app_name}/config/schema.tf.rb",
+          'config/lambda/api.yml.erb' => "#{@app_name}/config/lambda/api.yml",
           'README.md.erb' => "#{@app_name}/README.md",
           'AGENTS.md.erb' => "#{@app_name}/AGENTS.md",
           'gitignore.erb' => "#{@app_name}/.gitignore"

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

@@ -28,6 +28,11 @@ module Belt
           unless schema_file
             routes_dir = File.dirname(File.expand_path(routes_file))
             schema_file = File.join(routes_dir, 'schema.tf.rb')
+            # Fall back to infrastructure/ if not found in same directory as routes
+            unless File.exist?(schema_file)
+              alt = 'infrastructure/schema.tf.rb'
+              schema_file = alt if File.exist?(alt)
+            end
           end
           schema_file
         end

data/lib/belt/cli/routes_command.rb

@@ -25,7 +25,10 @@ module Belt
 
       def run
         routes_file = find_routes_file
-        abort 'Error: No routes file found. Expected infrastructure/routes.tf.rb' unless routes_file
+        unless routes_file
+          abort 'Error: No routes file found. ' \
+                'Expected config/routes.tf.rb (or infrastructure/routes.tf.rb)'
+        end
 
         dsl = load_routes(routes_file)
         @table_inference = TableInference.new(@options[:tables_file])
@@ -84,8 +87,8 @@ module Belt
       end
 
       def find_routes_file
-        path = 'infrastructure/routes.tf.rb'
-        File.exist?(path) ? path : nil
+        candidates = ['config/routes.tf.rb', 'infrastructure/routes.tf.rb']
+        candidates.find { |f| File.exist?(f) }
       end
 
       def load_routes(file)

data/lib/belt/cli/tables_command.rb

@@ -8,7 +8,7 @@ require_relative '../inflector'
 module Belt
   module CLI
     class TablesCommand
-      SCHEMA_FILE = 'infrastructure/schema.tf.rb'
+      SCHEMA_FILE_CANDIDATES = ['config/schema.tf.rb', 'infrastructure/schema.tf.rb'].freeze
       MODULE_DIR = 'infrastructure/modules/app'
 
       include AppDetection
@@ -33,12 +33,16 @@ module Belt
       # Automatically sync dynamodb.tf in the app module.
       # Called by generators after updating schema.tf.rb.
       def self.sync_all_environments
-        return unless File.exist?(SCHEMA_FILE)
+        return unless schema_file_path
 
         # With the module approach, we only need to generate once into modules/app/
         new(nil, quiet: true).run
       end
 
+      def self.schema_file_path
+        SCHEMA_FILE_CANDIDATES.find { |f| File.exist?(f) }
+      end
+
       def initialize(env, quiet: false)
         @env = env
         @quiet = quiet
@@ -59,8 +63,12 @@ module Belt
       private
 
       def validate!
-        unless File.exist?(SCHEMA_FILE)
-          abort "Error: #{SCHEMA_FILE} not found. Run `belt generate resource` first." unless @quiet
+        schema_file = self.class.schema_file_path
+        unless schema_file
+          unless @quiet
+            abort 'Error: No schema.tf.rb found (checked config/ and infrastructure/). ' \
+                  'Run `belt generate resource` first.'
+          end
           return
         end
         return if Dir.exist?(MODULE_DIR)
@@ -72,10 +80,11 @@ module Belt
       end
 
       def parse_schema
-        return [] unless File.exist?(SCHEMA_FILE)
+        schema_file = self.class.schema_file_path
+        return [] unless schema_file && File.exist?(schema_file)
 
         parser = SchemaParser.new
-        schema_content = File.read(SCHEMA_FILE)
+        schema_content = File.read(schema_file)
 
         # Replace DSL wrapper with direct parser call
         inner = schema_content.sub(/\A(?:Belt\.application)\.schema\.draw do\n?/, '').sub(/\n?end\s*\z/, '')
@@ -83,7 +92,7 @@ module Belt
 
         return [] if inner.empty? || inner.match?(/\A\s*\z/m)
 
-        parser.instance_eval(inner, SCHEMA_FILE)
+        parser.instance_eval(inner, schema_file)
         parser.models
       end
 

data/lib/belt/cli/views_command.rb

@@ -32,8 +32,8 @@ module Belt
       end
 
       def self.read_schema_fields(name)
-        schema_file = 'infrastructure/schema.tf.rb'
-        return [] unless File.exist?(schema_file)
+        schema_file = ['config/schema.tf.rb', 'infrastructure/schema.tf.rb'].find { |f| File.exist?(f) }
+        return [] unless schema_file
 
         content = File.read(schema_file)
         singular = Belt::Inflector.singularize(name)

data/lib/belt/cli.rb

@@ -16,6 +16,7 @@ require_relative 'cli/terraform_command'
 require_relative 'cli/deploy_command'
 require_relative 'cli/server_command'
 require_relative 'cli/routes_command'
+require_relative 'cli/lambda_config_command'
 require_relative 'cli/tasks_command'
 require_relative 'cli/console_command'
 
@@ -26,6 +27,7 @@ module Belt
       %w[generate g] => Belt::CLI::GenerateCommand,
       %w[destroy d] => Belt::CLI::DestroyCommand,
       'routes' => Belt::CLI::RoutesCommand,
+      'lambda-config' => Belt::CLI::LambdaConfigCommand,
       %w[console c] => Belt::CLI::ConsoleCommand,
       %w[tasks --tasks -T] => Belt::CLI::TasksCommand,
       'setup' => Belt::CLI::SetupCommand,
@@ -101,6 +103,7 @@ module Belt
           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
+          lambda-config [-e ENV] [-f json|terraform]  Show merged lambda configuration
 
           console                                     Start an interactive console (IRB)
           c                                           Alias for console

data/lib/belt/root.rb

@@ -9,9 +9,33 @@ module Belt
     @root = path
   end
 
+  # Resolves the path to routes.tf.rb, checking config/ first then infrastructure/ (legacy).
+  def self.routes_file
+    candidates = [
+      File.join(root, 'config/routes.tf.rb'),
+      File.join(root, 'infrastructure/routes.tf.rb')
+    ]
+    candidates.find { |f| File.exist?(f) }
+  end
+
+  # Resolves the path to schema.tf.rb, checking config/ first then infrastructure/ (legacy).
+  def self.schema_file
+    candidates = [
+      File.join(root, 'config/schema.tf.rb'),
+      File.join(root, 'infrastructure/schema.tf.rb')
+    ]
+    candidates.find { |f| File.exist?(f) }
+  end
+
+  # Resolves the lambda config directory.
+  def self.lambda_config_dir
+    File.join(root, 'config/lambda')
+  end
+
   def self.detect_root
     dir = Dir.pwd
     loop do
+      return dir if File.exist?(File.join(dir, 'config/routes.tf.rb'))
       return dir if File.exist?(File.join(dir, 'infrastructure/routes.tf.rb'))
 
       parent = File.dirname(dir)

data/lib/belt/version.rb

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

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

@@ -13,7 +13,7 @@ terraform {
     }
     conveyor-belt = {
       source  = "stowzilla/conveyor-belt"
-      version = "~> 0.0.1"
+      version = "~> 0.0.2"
     }
   }
 }
@@ -21,7 +21,7 @@ terraform {
 resource "conveyor_belt" "main" {
   provider = conveyor-belt
 
-  source            = "${path.module}/../../routes.tf.rb"
+  source            = "${path.module}/../../config/routes.tf.rb"
   app_name          = var.app_name
   lambda_source_dir = "${path.module}/../../../lambda"
   lambda_shared_dirs = ["controllers", "helpers", "lib", "models", "views"]
@@ -30,13 +30,12 @@ resource "conveyor_belt" "main" {
 
   custom_domain_name = local.dns_enabled ? local.api_domain : ""
 
-  # Per-lambda configuration: env vars, timeouts, memory
-  lambda_config = {
-    api = {
-      env_vars = {
-        WELCOME_TITLE    = "Welcome to ${var.app_name}"
-        WELCOME_SUBTITLE = "API Gateway → Lambda → DynamoDB — all connected."
-      }
-    }
-  }
+  # Per-lambda configuration from config/lambda/*.yml (database.yml style)
+  lambda_config_dir = "${path.module}/../../config/lambda"
+
+  # Dynamic value references — YAML env_vars use ref(name) to pull these in
+  lambda_env_refs = var.lambda_env_refs
+
+  # Terraform overrides for values that need interpolation (${var.app_name}, module outputs, etc.)
+  lambda_config = var.lambda_config
 }

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

@@ -25,3 +25,15 @@ variable "frontend_urls" {
   type        = list(string)
   default     = []
 }
+
+variable "lambda_env_refs" {
+  description = "Map of reference names to dynamic Terraform values. YAML env_vars use ref(name) to resolve these."
+  type        = map(string)
+  default     = {}
+}
+
+variable "lambda_config" {
+  description = "Additional lambda configuration overrides (for dynamic Terraform values)"
+  type        = any
+  default     = {}
+}

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

@@ -22,9 +22,12 @@ This file explains the project structure, tooling, and conventions for AI agents
 │   │   └── concerns/                   # Shared model concerns
 │   ├── lib/routes/                     # Route manifests (auto-generated)
 │   └── Gemfile                         # Lambda-specific dependencies
-├── infrastructure/
+├── config/
 │   ├── routes.tf.rb                    # API routes (Conveyor Belt DSL)
 │   ├── schema.tf.rb                    # Model schema definitions
+│   └── lambda/                         # Per-lambda config (like database.yml)
+│       └── api.yml                     # Lambda timeout, memory, env vars
+├── infrastructure/
 │   └── <env>/                          # Per-environment Terraform configs
 ├── Gemfile                             # Project-level dependencies
 └── AGENTS.md                           # This file
@@ -50,7 +53,7 @@ belt output <env>                                      # terraform output
 
 ## How Routing Works
 
-1. `infrastructure/routes.tf.rb` defines routes using a DSL:
+1. `config/routes.tf.rb` defines routes using a DSL:
    ```ruby
    Belt.application.routes.draw do
      namespace :<%= @app_name %> do

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

@@ -5,9 +5,12 @@ A serverless application built with [Belt](https://github.com/stowzilla/belt) an
 ## Structure
 
 ```
-├── infrastructure/
+├── config/
 │   ├── routes.tf.rb        # API route definitions
-│   └── schema.tf.rb        # Model schema definitions
+│   ├── schema.tf.rb        # Model schema definitions
+│   └── lambda/             # Per-lambda config (timeout, memory, env vars)
+│       └── api.yml
+├── infrastructure/         # Terraform environments
 └── lambda/
     ├── api.rb              # Lambda entry point
     ├── controllers/<%= @app_name %>/  # Controllers

data/lib/templates/new_app/config/lambda/api.yml.erb

@@ -0,0 +1,32 @@
+# Lambda configuration for the api function.
+# Works like Rails' database.yml — define defaults and override per environment.
+#
+# Keys:
+#   timeout           Lambda timeout in seconds (default: 30)
+#   memory_size       Lambda memory in MB (default: 256)
+#   env_vars          Environment variables (static values or ref() for Terraform values)
+#   dynamodb_tables   DynamoDB table access (by name — ARNs built by convention)
+#   s3_buckets        S3 bucket access declarations
+#   sns_triggers      SNS topic triggers
+#   sqs_triggers      SQS queue triggers
+#
+# ref(name) references are resolved from lambda_env_refs in Terraform.
+# DynamoDB tables use shorthand (table: [permissions]) or expanded form.
+#
+# Usage:
+#   belt lambda-config -e prod         # View merged config for prod
+#   belt lambda-config -f terraform    # Output as Terraform-ready lambda_config
+
+default: &default
+  timeout: 30
+  memory_size: 256
+  env_vars:
+    WELCOME_TITLE: "Welcome to <%= @app_name %>"
+    WELCOME_SUBTITLE: "API Gateway → Lambda → DynamoDB — all connected."
+
+dev:
+  <<: *default
+
+prod:
+  <<: *default
+  memory_size: 512

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: belt
 version: !ruby/object:Gem::Version
-  version: 0.1.13
+  version: 0.2.0
 platform: ruby
 authors:
 - Stowzilla
@@ -83,6 +83,7 @@ files:
 - lib/belt/cli/frontend_setup_command.rb
 - lib/belt/cli/generate_command.rb
 - lib/belt/cli/generator_registry.rb
+- lib/belt/cli/lambda_config_command.rb
 - lib/belt/cli/new_command.rb
 - lib/belt/cli/routes_command.rb
 - lib/belt/cli/routes_command/route_inference.rb
@@ -134,9 +135,10 @@ files:
 - lib/templates/new_app/Gemfile.erb
 - lib/templates/new_app/README.md.erb
 - lib/templates/new_app/Rakefile.erb
+- lib/templates/new_app/config/lambda/api.yml.erb
+- lib/templates/new_app/config/routes.tf.rb.erb
+- lib/templates/new_app/config/schema.tf.rb.erb
 - lib/templates/new_app/gitignore.erb
-- lib/templates/new_app/infrastructure/routes.tf.rb.erb
-- lib/templates/new_app/infrastructure/schema.tf.rb.erb
 - lib/templates/new_app/lambda/api.rb.erb
 - lib/templates/new_app/lambda/config/environment.rb.erb
 - lib/templates/new_app/lambda/controllers/application_controller.rb.erb