belt 0.1.8 → 0.1.10

data/lib/belt/cli/frontend_setup_command.rb

@@ -8,90 +8,49 @@ require_relative 'env_resolver'
 module Belt
   module CLI
     class FrontendSetupCommand
-      TEMPLATE_DIR = File.expand_path('../../templates/frontend_infra', __dir__)
+      TEMPLATE_DIR = File.expand_path('../../templates/module', __dir__)
+      MODULE_DIR = 'infrastructure/modules/app'
 
       include AppDetection
 
       def self.run(args)
-        env = EnvResolver.resolve(args)
-
-        if env.nil?
-          puts 'Usage: belt setup frontend <environment>'
-          puts "\nGenerates S3 + CloudFront Terraform for frontend hosting."
-          puts 'You can also set BELT_ENV to skip the environment argument.'
-          puts "\nExamples:"
-          puts '  belt setup frontend wups'
-          puts '  belt setup frontend dev01'
-          puts '  BELT_ENV=wups belt setup frontend'
-          exit 1
-        end
-
-        new(env).run
+        # Environment arg is no longer needed since frontend.tf goes in the module,
+        # but we still accept it for backwards compat (just ignore it).
+        _env = EnvResolver.resolve(args)
+        new.run
       end
 
-      def initialize(env, quiet: false)
-        @env = env
+      def initialize(env = nil, quiet: false)
         @app_name = detect_app_name
-        @env_dir = "infrastructure/#{@env}"
         @quiet = quiet
       end
 
       def run
         validate!
         generate_frontend_tf
-        update_main_tf_frontend_urls
         return if @quiet
 
-        puts "\n✓ Frontend infrastructure generated for '#{@env}'!"
-        puts "\nRun `belt apply #{@env}` to create the S3 bucket and CloudFront distribution."
-        puts "Then `belt deploy frontend #{@env}` to build and deploy."
+        puts "\n✓ Frontend infrastructure generated in #{MODULE_DIR}!"
+        puts "\nRun `belt deploy` to create the S3 bucket and CloudFront distribution."
+        puts "Then `belt deploy frontend` to build and deploy."
       end
 
       private
 
       def validate!
-        return if Dir.exist?(@env_dir)
+        return if Dir.exist?(MODULE_DIR)
 
-        abort "Error: Environment '#{@env}' not found at #{@env_dir}/.\n" \
-              "Create it with: belt generate environment #{@env}"
+        abort "Error: Module directory not found at #{MODULE_DIR}/.\n" \
+              "Run `belt new` to create a project with the correct structure."
       end
 
       def generate_frontend_tf
-        dest = File.join(@env_dir, 'frontend.tf')
+        dest = File.join(MODULE_DIR, 'frontend.tf')
         template_path = File.join(TEMPLATE_DIR, 'frontend.tf.erb')
         content = ERB.new(File.read(template_path), trim_mode: '-').result(binding)
         File.write(dest, content)
         puts "  create  #{dest}" unless @quiet
       end
-
-      def update_main_tf_frontend_urls
-        main_tf = File.join(@env_dir, 'main.tf')
-        return unless File.exist?(main_tf)
-
-        content = File.read(main_tf)
-        cloudfront_url = '"https://${aws_cloudfront_distribution.frontend.domain_name}"'
-
-        # Already patched — skip
-        return if content.include?('aws_cloudfront_distribution.frontend.domain_name')
-
-        # Match any frontend_urls line (hardcoded list or conditional expression)
-        new_frontend_urls = <<~HCL.chomp
-          frontend_urls     = concat(
-            [#{cloudfront_url}],
-            var.environment == "prod" ? [] : ["http://localhost:3000"]
-          )
-        HCL
-
-        replaced = content.sub(
-          /^(\s*)frontend_urls\s*=\s*.+$/,
-          new_frontend_urls
-        )
-
-        if replaced != content
-          File.write(main_tf, replaced)
-          puts "  update  #{main_tf} (added CloudFront URL to frontend_urls)" unless @quiet
-        end
-      end
     end
   end
 end

data/lib/belt/cli/generate_command.rb

@@ -24,12 +24,14 @@ module Belt
           description: 'Generate a model, controller, routes, schema, and views for a REST resource.',
           usage: 'belt generate scaffold <name> [field:type ...] [options]',
           options: [
-            ['--skip-views', 'Skip generating frontend view pages']
+            ['--skip-views', 'Skip generating frontend view pages'],
+            ['--force, -f', 'Overwrite existing resource files (skip collision check)']
           ],
           examples: [
             ['belt g scaffold post title body:text'],
             ['belt g scaffold comment author body:text status'],
-            ['belt g scaffold task --skip-views']
+            ['belt g scaffold task --skip-views'],
+            ['belt g scaffold post title body:text --force']
           ],
           notes: <<~NOTES
             Creates:
@@ -45,8 +47,10 @@ module Belt
         },
         'model' => {
           description: 'Generate an ActiveItem model with validations and DynamoDB field definitions.',
-          usage: 'belt generate model <name> [field:type ...]',
-          options: [],
+          usage: 'belt generate model <name> [field:type ...] [options]',
+          options: [
+            ['--force, -f', 'Overwrite existing model files (skip collision check)']
+          ],
           examples: [
             ['belt g model user email name'],
             ['belt g model event title starts_at:datetime']
@@ -110,9 +114,10 @@ module Belt
 
         validate_resource_name!(name, generator)
 
+        force = args.delete('--force') || args.delete('-f')
         skip_views = args.delete('--skip-views')
         fields = args.map { |arg| parse_field(arg) }
-        new(generator, name, fields, skip_views: skip_views).generate
+        new(generator, name, fields, skip_views: skip_views, force: force).generate
       end
 
       def self.parse_field(arg)
@@ -214,11 +219,12 @@ module Belt
         puts "\n#{info[:notes]}" if info[:notes]
       end
 
-      def initialize(generator, name, fields, skip_views: false)
+      def initialize(generator, name, fields, skip_views: false, force: false)
         @generator = generator
         @name = name.downcase.gsub(/[^a-z0-9_]/, '_')
         @fields = fields
         @skip_views = skip_views
+        @force = force
         @app_name = detect_namespace
         @module_name = @app_name.split(/[-_]/).map(&:capitalize).join
         @singular_name = Belt::Inflector.singularize(@name)
@@ -228,14 +234,60 @@ module Belt
 
       def generate
         case @generator
-        when 'scaffold'  then generate_resource
-        when 'model'     then generate_model_standalone
+        when 'scaffold'
+          check_resource_collision! unless @force
+          generate_resource
+        when 'model'
+          check_model_collision! unless @force
+          generate_model_standalone
         when 'controller' then generate_controller
         end
       end
 
       private
 
+      def check_resource_collision!
+        conflicts = []
+        conflicts << "lambda/models/#{@singular_name}.rb" if File.exist?("lambda/models/#{@singular_name}.rb")
+        conflicts << "lambda/controllers/#{@app_name}/#{@resource_name}_controller.rb" if File.exist?("lambda/controllers/#{@app_name}/#{@resource_name}_controller.rb")
+
+        schema_file = 'infrastructure/schema.tf.rb'
+        if 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/)
+          conflicts << "#{routes_file} (resources :#{@resource_name})"
+        end
+
+        return if conflicts.empty?
+
+        puts "\n✗ Resource '#{@singular_name}' already exists. Conflicting files:"
+        conflicts.each { |c| puts "    • #{c}" }
+        puts "\nTo overwrite, run again with --force:"
+        puts "  belt g scaffold #{@singular_name} #{@fields.map { |f| "#{f[:name]}:#{f[:type]}" }.join(' ')} --force"
+        exit 1
+      end
+
+      def check_model_collision!
+        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/)
+          conflicts << "#{schema_file} (model :#{@singular_name})"
+        end
+
+        return if conflicts.empty?
+
+        puts "\n✗ Model '#{@singular_name}' already exists. Conflicting files:"
+        conflicts.each { |c| puts "    • #{c}" }
+        puts "\nTo overwrite, run again with --force:"
+        puts "  belt g model #{@singular_name} #{@fields.map { |f| "#{f[:name]}:#{f[:type]}" }.join(' ')} --force"
+        exit 1
+      end
+
       def generate_resource
         generate_model
         generate_controller
@@ -279,8 +331,15 @@ module Belt
         tables_arg = @fields.any? ? ", tables: [:#{@resource_name}]" : ''
         resource_line = "resources :#{@resource_name}#{tables_arg}"
 
+        # If this resource already exists in routes (force mode), replace it
+        existing_resource_pattern = /^\s*resources :#{Regexp.escape(@resource_name)}\b[^\n]*/
+        if content.match?(existing_resource_pattern)
+          content.sub!(existing_resource_pattern) do |match|
+            indent = match[/^\s*/]
+            "#{indent}#{resource_line}"
+          end
         # Replace the commented placeholder if it exists
-        if content.include?('# resources :posts')
+        elsif content.include?('# resources :posts')
           content.sub!('# resources :posts', resource_line)
         else
           # Find the target namespace block and insert before its closing `end`
@@ -368,8 +427,12 @@ module Belt
 
         schema_block = "  model :#{@singular_name} do\n#{field_lines.join("\n")}\n  end\n"
 
+        # If model already exists (force mode), replace it
+        existing_model_pattern = /^  model :#{Regexp.escape(@singular_name)} do\n.*?^  end\n/m
+        if content.match?(existing_model_pattern)
+          content.sub!(existing_model_pattern, schema_block)
         # Replace commented-out block or insert before final end
-        if content.match?(/^\s*#\s*model :/)
+        elsif content.match?(/^\s*#\s*model :/)
           content.gsub!(/^\s*#[^\n]*\n/, '')
           content.sub!(/^(end\s*\z)/m, "#{schema_block}\\1")
         else

data/lib/belt/cli/new_command.rb

@@ -17,6 +17,7 @@ module Belt
         frontend = nil
         bucket = nil
         environments = nil
+        domain = nil
 
         i = 0
         while i < args.length
@@ -43,6 +44,11 @@ module Belt
             environments = args[i]
           when /^--environments=/
             environments = arg.split('=', 2).last
+          when '--domain'
+            i += 1
+            domain = args[i]
+          when /^--domain=/
+            domain = arg.split('=', 2).last
           else
             app_name ||= arg unless arg.start_with?('-')
           end
@@ -54,6 +60,7 @@ module Belt
           puts ''
           puts 'Options:'
           puts '  --frontend react|vue|svelte    Set up frontend framework'
+          puts '  --domain DOMAIN                Custom domain (e.g., myapp.com)'
           puts '  --bucket BUCKET_NAME           S3 bucket for Terraform state'
           puts '  --state-bucket BUCKET_NAME     Alias for --bucket'
           puts '  --environments dev,prod        Comma-separated environments (default: dev,prod)'
@@ -61,14 +68,15 @@ module Belt
           exit 1
         end
 
-        new(app_name, frontend: frontend, bucket: bucket, environments: environments).generate
+        new(app_name, frontend: frontend, bucket: bucket, environments: environments, domain: domain).generate
       end
 
-      def initialize(app_name, frontend: nil, bucket: nil, environments: nil)
+      def initialize(app_name, frontend: nil, bucket: nil, environments: nil, domain: nil)
         @app_name = app_name.gsub(/[^a-z0-9_-]/i, '_').downcase
         @module_name = @app_name.split(/[-_]/).map(&:capitalize).join
         @frontend = frontend
         @bucket = bucket
+        @domain = domain
         @environments = parse_environments(environments)
         @resolved_bucket = nil
         @state_setup_succeeded = false
@@ -82,6 +90,7 @@ module Belt
 
         puts "Creating new Belt application: #{@app_name}"
         create_structure
+        generate_module
         generate_environments
         generate_frontend if @frontend
         init_git
@@ -89,6 +98,7 @@ module Belt
         setup_state
         puts "\n✓ #{@app_name} created successfully!"
         print_next_steps
+        enter_project!
       end
 
       private
@@ -112,7 +122,7 @@ module Belt
           #{@app_name}/lambda/lib/routes
           #{@app_name}/lambda/config
           #{@app_name}/lambda/spec
-          #{@app_name}/infrastructure
+          #{@app_name}/infrastructure/modules/app
         ]
       end
 
@@ -134,12 +144,32 @@ module Belt
         }
       end
 
+      def generate_module
+        module_dir = "#{@app_name}/infrastructure/modules/app"
+        module_template_dir = File.expand_path('../../templates/module', File.dirname(__FILE__))
+
+        module_templates = {
+          'main.tf.erb' => 'main.tf',
+          'variables.tf.erb' => 'variables.tf',
+          'outputs.tf.erb' => 'outputs.tf',
+          'dns.tf.erb' => 'dns.tf'
+        }
+
+        module_templates.each do |template_name, dest_file|
+          dest_path = File.join(module_dir, dest_file)
+          template_path = File.join(module_template_dir, template_name)
+          content = ERB.new(File.read(template_path), trim_mode: '-').result(binding)
+          File.write(dest_path, content)
+          puts "  create  #{dest_path}"
+        end
+      end
+
       def generate_environments
         return if @environments.empty?
 
         Dir.chdir(@app_name) do
           @environments.each do |env_name|
-            Belt::CLI::EnvironmentCommand.new(env_name, quiet: true).generate
+            Belt::CLI::EnvironmentCommand.new(env_name, quiet: true, domain: @domain).generate
           end
         end
       end
@@ -148,28 +178,11 @@ module Belt
         return if @environments.empty?
 
         Dir.chdir(@app_name) do
-          # Resolve bucket name — include account ID + region if AWS credentials are available
-          if @bucket
-            @resolved_bucket = @bucket
-          elsif aws_configured?
-            region = detect_region
-            @resolved_bucket = s3_safe_name("#{@app_name}-terraform-state-#{@aws_account_id}-#{region}")
-          else
-            @resolved_bucket = s3_safe_name("#{@app_name}-terraform-state")
-          end
-
-          # Update backend.tf files with the resolved bucket name
-          @environments.each do |env_name|
-            backend_file = "infrastructure/#{env_name}/backend.tf"
-            next unless File.exist?(backend_file)
-
-            content = File.read(backend_file)
-            updated = content.gsub(/bucket\s*=\s*"[^"]+"/, "bucket  = \"#{@resolved_bucket}\"")
-            File.write(backend_file, updated) if updated != content
-          end
+          # Shared bucket: one per AWS account, all belt apps share it
+          @resolved_bucket = @bucket || 'belt-terraform-state'
 
           # Attempt to actually create the bucket if credentials are available
-          if @aws_account_id
+          if aws_configured?
             puts "\n  Setting up Terraform state bucket..."
             begin
               Belt::CLI::SetupCommand.new(["--bucket", @resolved_bucket]).run_state_setup
@@ -180,6 +193,7 @@ module Belt
             end
           else
             puts "\n  State bucket: #{@resolved_bucket}"
+            puts "  State keys:   #{s3_safe_name(@app_name)}/<env>/terraform.tfstate"
             if @aws_error&.include?('ForbiddenException') || @aws_error&.include?('AccessDenied')
               puts "  ⚠ AWS credentials found but access denied — check your profile/role configuration."
               puts "    #{@aws_error}" if @aws_error
@@ -192,14 +206,6 @@ module Belt
         end
       end
 
-      def detect_region
-        Dir.glob('infrastructure/*/backend.tf').each do |f|
-          match = File.read(f).match(/region\s*=\s*"([^"]+)"/)
-          return match[1] if match
-        end
-        'us-east-1'
-      end
-
       def aws_configured?
         output, status = Open3.capture2e('aws', 'sts', 'get-caller-identity')
         if status.success?
@@ -251,13 +257,56 @@ module Belt
 
       def print_next_steps
         puts "\nNext steps:"
-        puts "  cd #{@app_name}"
         unless @state_setup_succeeded
           puts '  # Configure AWS credentials (aws sso login / AWS_PROFILE)'
           puts '  belt setup state              # Create the S3 state bucket'
         end
         puts '  belt deploy                   # Deploy to AWS'
         puts '  belt server                   # Start local frontend server' if @frontend
+        if @domain
+          puts "\n  Custom domain: #{@domain}"
+          puts "    prod  → #{@domain}"
+          puts "    dev   → dev.#{@domain}"
+          puts ''
+          puts '  DNS setup (after first deploy):'
+          puts '  ─────────────────────────────────────────────────────────────────'
+          puts '  1. Run: terraform output name_servers'
+          puts '     This prints the 4 NS records for your Route53 hosted zone.'
+          puts ''
+          puts '  2. Point your domain to those nameservers:'
+          puts ''
+          puts '     • Domain registered OUTSIDE AWS (GoDaddy, Namecheap, etc.):'
+          puts '       Go to your registrar → DNS/Nameserver settings → replace the'
+          puts '       default nameservers with the 4 values from step 1.'
+          puts ''
+          puts '     • Domain registered IN AWS (Route53 Registered Domains):'
+          puts '       Go to Route53 → Registered Domains → your domain → Name servers'
+          puts '       → Edit → paste the 4 values from step 1.'
+          puts ''
+          puts '  3. Wait for propagation (usually 5–30 min, can take up to 48h).'
+          puts '     Verify: dig +short NS #{@domain}'
+          puts '  ─────────────────────────────────────────────────────────────────'
+        else
+          puts "\n  To add a custom domain later, set `domain` in infrastructure/<env>/terraform.tfvars:"
+          puts '    domain = "myapp.com"'
+        end
+      end
+
+      def enter_project!
+        project_path = File.expand_path(@app_name)
+
+        # Don't exec into a subshell if:
+        # - Not running interactively (CI, scripts, piped)
+        # - User explicitly opted out
+        unless $stdin.tty? && ENV['BELT_NO_CD'].nil?
+          puts "\n  cd #{@app_name}"
+          return
+        end
+
+        Dir.chdir(project_path)
+        shell = ENV['SHELL'] || '/bin/bash'
+        puts "\n  Entering #{@app_name}/...\n\n"
+        exec(shell)
       end
 
       def s3_safe_name(name)

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/setup_command.rb

@@ -61,7 +61,7 @@ module Belt
           exit 1
         end
 
-        # Re-resolve bucket name with account ID suffix now that we have credentials
+        # Resolve final bucket name now that we have credentials
         @bucket_name = resolve_bucket_name unless @custom_bucket
 
         @bucket_name = interactive_bucket_selection if @select_mode
@@ -142,13 +142,7 @@ module Belt
         if @custom_bucket
           @custom_bucket
         else
-          base = if @env_name
-                   "#{@app_name}-terraform-state-#{@env_name}"
-                 else
-                   "#{@app_name}-terraform-state"
-                 end
-          base = "#{base}-#{@aws_account_id}-#{@region}" if @aws_account_id
-          s3_safe_name(base)
+          'belt-terraform-state'
         end
       end
 

data/lib/belt/cli/tables_command.rb

@@ -9,6 +9,7 @@ module Belt
   module CLI
     class TablesCommand
       SCHEMA_FILE = 'infrastructure/schema.tf.rb'
+      MODULE_DIR = 'infrastructure/modules/app'
 
       include AppDetection
 
@@ -16,37 +17,32 @@ module Belt
         env = EnvResolver.resolve(args)
 
         if env.nil?
-          puts 'Usage: belt setup tables <environment>'
-          puts "\nReads schema.tf.rb and generates dynamodb.tf in the environment directory."
+          puts 'Usage: belt setup tables [environment]'
+          puts "\nReads schema.tf.rb and generates dynamodb.tf in the app module."
           puts 'You can also set BELT_ENV to skip the environment argument.'
           puts "\nExamples:"
-          puts '  belt setup tables wups'
-          puts '  belt setup tables dev01'
-          puts '  BELT_ENV=wups belt setup tables'
+          puts '  belt setup tables'
+          puts '  belt setup tables dev'
+          puts '  BELT_ENV=dev belt setup tables'
           exit 1
         end
 
         new(env).run
       end
 
-      # Automatically sync dynamodb.tf for all existing environments.
+      # 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)
 
-        environments = TerraformCommand.list_environments
-        return if environments.empty?
-
-        environments.each do |env|
-          new(env, quiet: true).run
-        end
+        # With the module approach, we only need to generate once into modules/app/
+        new(nil, quiet: true).run
       end
 
       def initialize(env, quiet: false)
         @env = env
         @quiet = quiet
         @app_name = detect_app_name
-        @env_dir = "infrastructure/#{@env}"
       end
 
       def run
@@ -67,11 +63,11 @@ module Belt
           abort "Error: #{SCHEMA_FILE} not found. Run `belt generate resource` first." unless @quiet
           return
         end
-        return if Dir.exist?(@env_dir)
+        return if Dir.exist?(MODULE_DIR)
 
         unless @quiet
-          abort "Error: Environment '#{@env}' not found at #{@env_dir}/.\n" \
-                "Create it with: belt generate environment #{@env}"
+          abort "Error: Module directory not found at #{MODULE_DIR}/.\n" \
+                "Run `belt new` to create a project with the correct structure."
         end
       end
 
@@ -82,7 +78,6 @@ module Belt
         schema_content = File.read(SCHEMA_FILE)
 
         # Replace DSL wrapper with direct parser call
-        # Belt.application.schema.draw do ... end → parser.instance_eval do ... end
         inner = schema_content.sub(/\A(?:Belt\.application)\.schema\.draw do\n?/, '').sub(/\n?end\s*\z/, '')
         inner.strip!
 
@@ -93,7 +88,7 @@ module Belt
       end
 
       def generate_dynamodb_tf(models)
-        dest = File.join(@env_dir, 'dynamodb.tf')
+        dest = File.join(MODULE_DIR, 'dynamodb.tf')
         existing_content = File.exist?(dest) ? File.read(dest) : nil
         new_content = render_dynamodb(models)
 
@@ -108,7 +103,7 @@ module Belt
         else
           puts "  create  #{dest}"
           puts "\n✓ Generated DynamoDB tables for #{models.size} model(s):"
-          models.each { |m| puts "    • #{table_name(m[:name])}" }
+          models.each { |m| puts "    • #{Belt::Inflector.pluralize(m[:name])}" }
           puts "\nRun `belt deploy` to create them."
         end
       end
@@ -116,7 +111,7 @@ module Belt
       def render_dynamodb(models)
         blocks = models.map { |m| render_table(m) }
         "# Auto-generated by Belt from schema.tf.rb\n" \
-          "# Do not edit manually — re-run `belt setup tables #{@env}`\n\n#{blocks.join("\n\n")}\n"
+          "# Do not edit manually — re-run `belt setup tables`\n\n#{blocks.join("\n\n")}\n"
       end
 
       def render_table(model)
@@ -142,7 +137,7 @@ module Belt
       end
 
       def table_name(model_name)
-        "#{@app_name}-#{@env}-#{Belt::Inflector.pluralize(model_name)}"
+        "#{@app_name}-${var.environment}-#{Belt::Inflector.pluralize(model_name)}"
       end
 
       # Minimal DSL parser for schema.tf.rb