belt 0.1.7 → 0.1.9

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
@@ -109,11 +119,10 @@ module Belt
         %W[
           #{@app_name}/lambda/controllers/api
           #{@app_name}/lambda/models
-          #{@app_name}/lambda/models/concerns
           #{@app_name}/lambda/lib/routes
           #{@app_name}/lambda/config
           #{@app_name}/lambda/spec
-          #{@app_name}/infrastructure
+          #{@app_name}/infrastructure/modules/app
         ]
       end
 
@@ -124,7 +133,6 @@ module Belt
           'lambda/api.rb.erb' => "#{@app_name}/lambda/api.rb",
           'lambda/config/environment.rb.erb' => "#{@app_name}/lambda/config/environment.rb",
           'lambda/models/application_record.rb.erb' => "#{@app_name}/lambda/models/application_record.rb",
-          'lambda/models/concerns/timestampable.rb.erb' => "#{@app_name}/lambda/models/concerns/timestampable.rb",
           '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",
@@ -136,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
@@ -150,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
@@ -182,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
@@ -194,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?
@@ -253,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/routes_command.rb

@@ -292,15 +292,7 @@ module Belt
       end
 
       def singularize(word)
-        if word.end_with?('ies')
-          "#{word[0..-4]}y"
-        elsif word.end_with?('ses') || word.end_with?('xes') || word.end_with?('zes')
-          word[0..-3]
-        elsif word.end_with?('s') && !word.end_with?('ss')
-          word[0..-2]
-        else
-          word
-        end
+        Belt::Inflector.singularize(word)
       end
     end
   end

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

@@ -2,11 +2,14 @@
 
 require_relative 'app_detection'
 require_relative 'env_resolver'
+require_relative 'terraform_command'
+require_relative '../inflector'
 
 module Belt
   module CLI
     class TablesCommand
       SCHEMA_FILE = 'infrastructure/schema.tf.rb'
+      MODULE_DIR = 'infrastructure/modules/app'
 
       include AppDetection
 
@@ -14,31 +17,40 @@ 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
 
-      def initialize(env)
+      # 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)
+
+        # 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
         validate!
         models = parse_schema
         if models.empty?
-          puts "No models found in #{SCHEMA_FILE}"
-          exit 0
+          puts "No models found in #{SCHEMA_FILE}" unless @quiet
+          return
         end
 
         generate_dynamodb_tf(models)
@@ -47,44 +59,65 @@ module Belt
       private
 
       def validate!
-        abort "Error: #{SCHEMA_FILE} not found. Run `belt generate resource` first." unless File.exist?(SCHEMA_FILE)
-        return if Dir.exist?(@env_dir)
+        unless File.exist?(SCHEMA_FILE)
+          abort "Error: #{SCHEMA_FILE} not found. Run `belt generate resource` first." unless @quiet
+          return
+        end
+        return if Dir.exist?(MODULE_DIR)
 
-        abort "Error: Environment '#{@env}' not found at #{@env_dir}/.\n" \
-              "Create it with: belt generate environment #{@env}"
+        unless @quiet
+          abort "Error: Module directory not found at #{MODULE_DIR}/.\n" \
+                "Run `belt new` to create a project with the correct structure."
+        end
       end
 
       def parse_schema
+        return [] unless File.exist?(SCHEMA_FILE)
+
         parser = SchemaParser.new
         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(/\nend\s*\z/, '')
+        inner = schema_content.sub(/\A(?:Belt\.application)\.schema\.draw do\n?/, '').sub(/\n?end\s*\z/, '')
+        inner.strip!
+
+        return [] if inner.empty? || inner.match?(/\A\s*\z/m)
+
         parser.instance_eval(inner, SCHEMA_FILE)
         parser.models
       end
 
       def generate_dynamodb_tf(models)
-        dest = File.join(@env_dir, 'dynamodb.tf')
-        content = render_dynamodb(models)
-        File.write(dest, content)
-        puts "  create  #{dest}"
-        puts "\n✓ Generated DynamoDB tables for #{models.size} model(s):"
-        models.each { |m| puts "    • #{table_name(m[:name])}" }
-        puts "\nRun `belt apply #{@env}` to create them."
+        dest = File.join(MODULE_DIR, 'dynamodb.tf')
+        existing_content = File.exist?(dest) ? File.read(dest) : nil
+        new_content = render_dynamodb(models)
+
+        # Skip if content is unchanged
+        return if existing_content == new_content
+
+        File.write(dest, new_content)
+
+        if @quiet
+          verb = existing_content ? 'update' : 'create'
+          puts "  #{verb}  #{dest}"
+        else
+          puts "  create  #{dest}"
+          puts "\n✓ Generated DynamoDB tables for #{models.size} model(s):"
+          models.each { |m| puts "    • #{Belt::Inflector.pluralize(m[:name])}" }
+          puts "\nRun `belt deploy` to create them."
+        end
       end
 
       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)
         name = table_name(model[:name])
         <<~HCL
-          resource "aws_dynamodb_table" "#{model[:name]}s" {
+          resource "aws_dynamodb_table" "#{Belt::Inflector.pluralize(model[:name])}" {
             name         = "#{name}"
             billing_mode = "PAY_PER_REQUEST"
             hash_key     = "id"
@@ -104,7 +137,7 @@ module Belt
       end
 
       def table_name(model_name)
-        "#{@app_name}-#{@env}-#{model_name}s"
+        "#{@app_name}-${var.environment}-#{Belt::Inflector.pluralize(model_name)}"
       end
 
       # Minimal DSL parser for schema.tf.rb

data/lib/belt/cli/views_command.rb

@@ -2,6 +2,7 @@
 
 require 'fileutils'
 require 'erb'
+require_relative '../inflector'
 
 module Belt
   module CLI
@@ -35,7 +36,7 @@ module Belt
         return [] unless File.exist?(schema_file)
 
         content = File.read(schema_file)
-        singular = name.end_with?('s') ? name.chomp('s') : name
+        singular = Belt::Inflector.singularize(name)
 
         # Extract fields from model block
         if content =~ /model :#{singular} do\n(.*?)\n\s*end/m
@@ -53,9 +54,9 @@ module Belt
       def initialize(name, fields)
         @name = name.downcase.gsub(/[^a-z0-9_]/, '_')
         @fields = fields
-        @resource_name = @name.end_with?('s') ? @name : "#{@name}s"
-        @singular_name = @name.end_with?('s') ? @name.chomp('s') : @name
-        @class_name = @singular_name.split('_').map(&:capitalize).join
+        @singular_name = Belt::Inflector.singularize(@name)
+        @resource_name = Belt::Inflector.pluralize(@singular_name)
+        @class_name = Belt::Inflector.classify(@singular_name)
       end
 
       def generate
@@ -65,9 +66,10 @@ module Belt
         end
 
         pages_dir = "frontend/src/pages/#{@resource_name}"
+        @plural_class_name = Belt::Inflector.camelize(@resource_name)
         FileUtils.mkdir_p(pages_dir)
 
-        write_template('Index.jsx.erb', "#{pages_dir}/#{@class_name}sIndex.jsx")
+        write_template('Index.jsx.erb', "#{pages_dir}/#{@plural_class_name}Index.jsx")
         write_template('Show.jsx.erb', "#{pages_dir}/#{@class_name}Show.jsx")
         write_template('New.jsx.erb', "#{pages_dir}/#{@class_name}New.jsx")
         write_template('Edit.jsx.erb', "#{pages_dir}/#{@class_name}Edit.jsx")
@@ -77,7 +79,7 @@ module Belt
 
         puts "\n✓ Views for '#{@singular_name}' generated!"
         puts "\nFiles created:"
-        puts "  #{pages_dir}/#{@class_name}sIndex.jsx"
+        puts "  #{pages_dir}/#{@plural_class_name}Index.jsx"
         puts "  #{pages_dir}/#{@class_name}Show.jsx"
         puts "  #{pages_dir}/#{@class_name}New.jsx"
         puts "  #{pages_dir}/#{@class_name}Edit.jsx"
@@ -100,16 +102,17 @@ module Belt
 
         content = File.read(app_jsx)
         pages_dir = @resource_name
+        plural_class = @plural_class_name || Belt::Inflector.camelize(@resource_name)
 
         import_lines = [
-          "import #{@class_name}sIndex from './pages/#{pages_dir}/#{@class_name}sIndex'",
+          "import #{plural_class}Index from './pages/#{pages_dir}/#{plural_class}Index'",
           "import #{@class_name}Show from './pages/#{pages_dir}/#{@class_name}Show'",
           "import #{@class_name}New from './pages/#{pages_dir}/#{@class_name}New'",
           "import #{@class_name}Edit from './pages/#{pages_dir}/#{@class_name}Edit'"
         ]
 
         route_lines = [
-          "        <Route path=\"/#{@resource_name}\" element={<#{@class_name}sIndex />} />",
+          "        <Route path=\"/#{@resource_name}\" element={<#{plural_class}Index />} />",
           "        <Route path=\"/#{@resource_name}/new\" element={<#{@class_name}New />} />",
           "        <Route path=\"/#{@resource_name}/:id\" element={<#{@class_name}Show />} />",
           "        <Route path=\"/#{@resource_name}/:id/edit\" element={<#{@class_name}Edit />} />"

data/lib/belt/inflector.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/string/inflections'
+require 'active_support/inflector'
+
+# Add common inflection rules that ActiveSupport doesn't include by default
+ActiveSupport::Inflector.inflections(:en) do |inflect|
+  inflect.irregular 'hero', 'heroes'
+  inflect.irregular 'potato', 'potatoes'
+  inflect.irregular 'volcano', 'volcanoes'
+  inflect.irregular 'echo', 'echoes'
+  inflect.irregular 'embargo', 'embargoes'
+  inflect.irregular 'veto', 'vetoes'
+end
+
+module Belt
+  # Provides proper English inflection rules (pluralize, singularize, classify, etc.)
+  # via ActiveSupport::Inflector. Used throughout Belt for resource name derivation.
+  #
+  # ActiveSupport is already a transitive dependency (via activeitem → activemodel → activesupport)
+  # so this adds zero new weight.
+  module Inflector
+    module_function
+
+    # "hero" → "heroes", "post" → "posts", "person" → "people"
+    def pluralize(word)
+      word.to_s.pluralize
+    end
+
+    # "heroes" → "hero", "posts" → "post", "people" → "person"
+    def singularize(word)
+      word.to_s.singularize
+    end
+
+    # "blog_post" → "BlogPost", "hero" → "Hero"
+    def classify(word)
+      singularize(word).split('_').map(&:capitalize).join
+    end
+
+    # "blog_posts" → "BlogPosts", "heroes" → "Heroes" (no singularization)
+    def camelize(word)
+      word.to_s.split('_').map(&:capitalize).join
+    end
+
+    # "BlogPost" → "blog_post"
+    def underscore(word)
+      word.to_s
+          .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+          .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+          .downcase
+    end
+
+    # "heroes_controller" → "heroes", "PostsController" → "posts"
+    def resource_name(word)
+      pluralize(word.to_s.sub(/_?controller$/i, '').downcase)
+    end
+  end
+end

data/lib/belt/lambda_handler.rb

@@ -41,6 +41,17 @@ module Belt
         subdir = File.join(controllers_dir, child)
         Belt.controller_paths << subdir if File.directory?(subdir)
       end
+
+      # Auto-load all models (application_record first, then the rest)
+      models_dir = File.join(File.dirname(caller_file), 'models')
+      if File.directory?(models_dir)
+        all_models = Dir[File.join(models_dir, '**', '*.rb')].sort
+        app_record = all_models.find { |f| File.basename(f) == 'application_record.rb' }
+        rest = all_models - [app_record].compact
+
+        require app_record if app_record
+        rest.each { |f| require f }
+      end
     end
 
     # API Gateway Lambda handler.

data/lib/belt/route_dsl.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative 'inflector'
+
 module Belt
   # DSL for defining API Gateway routes.
   # Ported from terraform-provider-conveyor-belt/scripts/lib/route_dsl.rb
@@ -256,17 +258,7 @@ module Belt
     end
 
     def singularize(word)
-      if word.end_with?('ies')
-        "#{word[0..-4]}y"
-      elsif word.end_with?('xes') || word.end_with?('zes') || word.end_with?('ses')
-        word[0..-3]
-      elsif word.end_with?('ches') || word.end_with?('shes')
-        word[0..-3]
-      elsif word.end_with?('s') && !word.end_with?('ss')
-        word[0..-2]
-      else
-        word
-      end
+      Belt::Inflector.singularize(word)
     end
   end
 

data/lib/belt/table_inference.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative 'inflector'
+
 module Belt
   # Infers DynamoDB table names from route paths by matching against
   # tables defined in a Terraform file containing aws_dynamodb_table resources.
@@ -45,27 +47,11 @@ module Belt
     end
 
     def pluralize(word)
-      if word.end_with?('y')
-        "#{word[0..-2]}ies"
-      elsif word.end_with?('s', 'x', 'z', 'ch', 'sh')
-        "#{word}es"
-      else
-        "#{word}s"
-      end
+      Belt::Inflector.pluralize(word)
     end
 
     def singularize(word)
-      if word.end_with?('ies')
-        "#{word[0..-4]}y"
-      elsif word.end_with?('xes', 'zes', 'ses')
-        word[0..-3]
-      elsif word.end_with?('ches', 'shes')
-        word[0..-3]
-      elsif word.end_with?('s') && !word.end_with?('ss')
-        word[0..-2]
-      else
-        word
-      end
+      Belt::Inflector.singularize(word)
     end
   end
 end

data/lib/belt/version.rb

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

data/lib/templates/environment/backend.tf.erb

@@ -1,7 +1,7 @@
 terraform {
   backend "s3" {
-    bucket  = "<%= s3_safe_name(@app_name) %>-terraform-state"
-    key     = "<%= @env_name %>/terraform.tfstate"
+    bucket  = "belt-terraform-state"
+    key     = "<%= s3_safe_name(@app_name) %>/<%= @env_name %>/terraform.tfstate"
     region  = "us-east-1"
     encrypt = true
   }