belt 0.1.12 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 892f04b0175a10793ba63f3cf65182b3d3e380ab75446984004283b8b8cf7377
-  data.tar.gz: 701534fd954f5d444783d3adb085d0582c4f9d1b92bf4518249e677add64c1b7
+  metadata.gz: dd7335772d9025878073df619babf32aff170b29d620420382c5f73a8eebff30
+  data.tar.gz: 8c0379aee3988b267d690d639c986bb827b4e0d403bf358b04ef86c5a64a4d60
 SHA512:
-  metadata.gz: '0682c1d964357b0109baca143e7c43fb8688a375aa84af0ba3ba2c46fbf0d56932a011b8eef6a0027dcf6b289f3eb6bc4617bcecd8717812246133b107563233'
-  data.tar.gz: 68d1e8b3a4311ca6bd3be6dbfeb48594efeb4afaf42500d27b7076e0068a8b21c8cd73a1e41a70c4ee6338e910dab96aaa8fdba09683c922027574141049a899
+  metadata.gz: 17a2e1f23c328abc880c19228234cac3fd6d4af78abbf704b2abbdc703990312115cd39ff12e492fa671d28a79cc8276a681778071fa094ab6dfdc7931360889
+  data.tar.gz: bc78f0e686cae19a4806ad21b3dbf9fc52adb768854e915dcbef155c593bf0317f771eb260478125ce10717e83e7dfa1e4230ebb9c123ad59bfcafb4578c3ed9

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 0.1.13
+
+### Generator Extension API
+
+- Gems can now register generators by placing a file at `lib/belt/generators/<name>_generator.rb`.
+- Discovered automatically via `Gem.loaded_specs` — no manual registration needed.
+- Available as `belt generate <name>` / `belt destroy <name>`.
+- Generator contract: `.run(args)` (required), `.destroy(args)` (optional), `.description` (optional).
+- Help output includes gem-provided generators under "Gem Generators" section.
+
 ## Unreleased
 
 ## 0.1.11

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

@@ -2,6 +2,7 @@
 
 require 'fileutils'
 require_relative 'app_detection'
+require_relative 'generator_registry'
 require_relative 'tables_command'
 require_relative '../inflector'
 
@@ -20,13 +21,22 @@ module Belt
           exit 0
         end
 
-        unless GENERATORS.include?(generator)
+        unless GENERATORS.include?(generator) || GeneratorRegistry.generator_names.include?(generator)
           puts "Unknown generator: '#{generator}'"
-          puts "Available: #{GENERATORS.uniq.join(', ')}"
+          puts "Available: #{(GENERATORS + GeneratorRegistry.generator_names).uniq.join(', ')}"
           puts "\nRun 'belt destroy --help' for usage information."
           exit 1
         end
 
+        # Delegate to gem-provided generator if not a built-in
+        unless GENERATORS.include?(generator)
+          klass = GeneratorRegistry.find(generator)
+          return klass.destroy(args) if klass.respond_to?(:destroy)
+
+          puts "Generator '#{generator}' does not support destroy."
+          exit 1
+        end
+
         # Normalize: resource is an alias for scaffold
         generator = 'scaffold' if generator == 'resource'
 
@@ -205,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
@@ -245,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/frontend_env_map.rb

@@ -181,7 +181,7 @@ module Belt
         return str if str.empty?
         return str unless str.match?(/[\s\#"'\\$`]/)
 
-        %("#{str.gsub('\\', '\\\\').gsub('"', '\\"')}")
+        %("#{str.gsub('\\') { '\\\\' }.gsub('"') { '\\"' }}")
       end
     end
   end

data/lib/belt/cli/generate_command.rb

@@ -7,6 +7,7 @@ require_relative 'environment_command'
 require_relative 'frontend_command'
 require_relative 'tables_command'
 require_relative 'views_command'
+require_relative 'generator_registry'
 require_relative '../inflector'
 
 module Belt
@@ -37,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)
 
@@ -84,13 +85,19 @@ module Belt
           exit 0
         end
 
-        unless GENERATORS.include?(generator)
+        unless GENERATORS.include?(generator) || GeneratorRegistry.generator_names.include?(generator)
           puts "Unknown generator: '#{generator}'"
-          puts "Available generators: #{(GENERATORS - ['resource']).join(', ')}"
+          puts "Available generators: #{all_generator_names.join(', ')}"
           puts "\nRun 'belt generate --help' for usage information."
           exit 1
         end
 
+        # Delegate to gem-provided generator if not a built-in
+        unless GENERATORS.include?(generator)
+          klass = GeneratorRegistry.find(generator)
+          return klass.run(args)
+        end
+
         # Normalize: resource is an alias for scaffold
         generator = 'scaffold' if generator == 'resource'
 
@@ -131,6 +138,10 @@ module Belt
         belt setup environment frontend views routes
       ].freeze
 
+      def self.all_generator_names
+        ((GENERATORS - ['resource']) + GeneratorRegistry.generator_names).uniq
+      end
+
       def self.validate_resource_name!(name, generator)
         errors = []
 
@@ -152,6 +163,8 @@ module Belt
       end
 
       def self.print_generate_help
+        gem_generators = GeneratorRegistry.discovered_generators
+
         puts <<~HELP
           Usage: belt generate <generator> <name> [field:type ...] [options]
                  belt g <generator> <name> [field:type ...] [options]
@@ -167,6 +180,18 @@ module Belt
           Aliases:
             resource      Same as scaffold
 
+        HELP
+
+        if gem_generators.any?
+          puts '  Gem Generators:'
+          gem_generators.each do |name, klass|
+            desc = klass.respond_to?(:description) ? klass.description : "Generate #{name} (from gem)"
+            puts format('    %<name>-14s %<desc>s', name: name, desc: desc)
+          end
+          puts
+        end
+
+        puts <<~HELP
           Field Types:
             #{FIELD_TYPES.join(', ')}
             (defaults to string if omitted)
@@ -254,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
 
@@ -277,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
 
@@ -302,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
@@ -327,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}]" : ''
@@ -419,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/generator_registry.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Belt
+  module CLI
+    # Discovers and manages generators provided by external gems.
+    #
+    # Gems register generators by placing a file at:
+    #   lib/belt/generators/<name>_generator.rb
+    #
+    # Each generator class must:
+    #   - Be named <Name>Generator (e.g., MessagingGenerator)
+    #   - Live in the Belt::Generators module
+    #   - Implement .run(args) for generation
+    #   - Implement .destroy(args) for teardown (optional)
+    #   - Implement .description for help text (optional)
+    #
+    # Example gem structure:
+    #   belt-messaging/
+    #     lib/
+    #       belt/
+    #         generators/
+    #           messaging_generator.rb
+    #
+    # The generator is then available as:
+    #   belt generate messaging
+    #   belt destroy messaging
+    #
+    module GeneratorRegistry
+      GENERATOR_PATH = 'lib/belt/generators'
+
+      class << self
+        # Returns a hash of { "name" => generator_class } for all discovered generators.
+        def discovered_generators
+          @discovered_generators ||= discover_all
+        end
+
+        # Returns just the names of discovered generators.
+        def generator_names
+          discovered_generators.keys
+        end
+
+        # Loads and returns the generator class for a given name.
+        # Returns nil if not found.
+        def find(name)
+          discovered_generators[name]
+        end
+
+        # Reset cache (useful in tests)
+        def reset!
+          @discovered_generators = nil
+        end
+
+        private
+
+        def discover_all
+          generators = {}
+
+          Gem.loaded_specs.each_value do |spec|
+            generators_dir = File.join(spec.gem_dir, GENERATOR_PATH)
+            next unless File.directory?(generators_dir)
+
+            Dir.glob(File.join(generators_dir, '*_generator.rb')).each do |file|
+              name = File.basename(file, '.rb').sub(/_generator\z/, '')
+              klass = load_generator_class(file, name)
+              generators[name] = klass if klass
+            end
+          end
+
+          generators
+        end
+
+        def load_generator_class(file, name)
+          require file
+
+          class_name = "#{classify(name)}Generator"
+          Belt::Generators.const_get(class_name)
+        rescue LoadError, NameError => e
+          warn "[Belt] Warning: Failed to load generator '#{name}' from #{file}: #{e.message}"
+          nil
+        end
+
+        def classify(name)
+          name.split('_').map(&:capitalize).join
+        end
+      end
+    end
+  end
+
+  # Namespace for generator classes provided by external gems
+  module Generators
+  end
+end

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,
@@ -56,7 +58,7 @@ module Belt
           # belt destroy --help → DestroyCommand help
           # belt destroy (no args) → terraform destroy (needs env)
           return DestroyCommand.run(args) if args.include?('--help') || args.include?('-h')
-        elsif DestroyCommand::GENERATORS.include?(args.first)
+        elsif DestroyCommand::GENERATORS.include?(args.first) || GeneratorRegistry.generator_names.include?(args.first)
           return DestroyCommand.run(args)
         end
       end
@@ -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.12'
+  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.12
+  version: 0.2.0
 platform: ruby
 authors:
 - Stowzilla
@@ -82,6 +82,8 @@ files:
 - lib/belt/cli/frontend_env_map.rb
 - 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
@@ -133,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