belt 0.1.6 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b09432f7426352033b67c6cc696bc90cddcae4b1facae08ce7b6fc08763b7eef
-  data.tar.gz: bb4617d6514bef6636b5b2efcfd32eaee6ebbc66b09a7e7f83581340c0fe5714
+  metadata.gz: ebbefe3f44abda51ac10b219cda18678ca834d06d8eab39e31beb3e48e99b25a
+  data.tar.gz: 3233b91c7297982ef7f5037331ef003c3637ebc6dccf4321b4a5f758ed57f1d9
 SHA512:
-  metadata.gz: 2c67896f36d6b09e394e19a73a92a6c8e31e9ec43071bf92c905f7d78ba260766d5b46aa2ee9d6c4d665c3313679557df527b866089bad240693fcdd1ce89e91
-  data.tar.gz: 8cf8956ea9a6227237be1dccc0cfe15b96ac9e75c3ddae543873cb067fcc5b8648fa23a1a258ccd3470afb9097ba54a7bc2dedfadcc701294b6ff8d9449ac755
+  metadata.gz: af38bf5330f69577f37ab34a0bd7510b5d84aa14969efd8975ac6875ea85450aaa741beeb71bf3f51f627af11c0c5445806081156706cdfd4901fba4301e33ed
+  data.tar.gz: 2eade1680ebfe76e78ab38e38d273565cf34eb1f1789427d358706ac2c4c128a5f86448a5eb2a146161be8c912bf53f9229fceb0904719c9df5ef3444dc3481e

data/lib/belt/cli/app_detection.rb

@@ -28,6 +28,12 @@ module Belt
         File.basename(Dir.pwd)
       end
 
+      # Detects existing environments by scanning infrastructure/ directories.
+      # Each subdirectory with a main.tf is considered an environment.
+      def detect_environments
+        Dir.glob('infrastructure/*/main.tf').map { |f| File.basename(File.dirname(f)) }.sort
+      end
+
       # S3 bucket names follow DNS rules — underscores are not allowed.
       # App names often use underscores (Ruby namespaces); convert for S3.
       def s3_safe_name(name)

data/lib/belt/cli/deploy_command.rb

@@ -127,6 +127,9 @@ module Belt
 
         puts "\n✅ Deployed #{@env} successfully!"
         print_outputs(env_dir)
+
+        deploy_frontend_if_exists
+
         puts "\n   Run `belt server` to view your app locally (auto-connects to the deployed API)."
       end
 
@@ -479,6 +482,18 @@ module Belt
         File.delete('tfplan') if File.exist?('tfplan')
       end
 
+      def deploy_frontend_if_exists
+        frontend_dir = File.join(@project_root, 'frontend')
+        return unless Dir.exist?(frontend_dir) && File.exist?(File.join(frontend_dir, 'package.json'))
+
+        puts "\n━━━ frontend deploy ━━━"
+        require_relative 'frontend_deploy_command'
+        Belt::CLI::FrontendDeployCommand.new(@env).run
+      rescue StandardError => e
+        puts "\n  ⚠ Frontend deploy failed: #{e.message}"
+        puts "    Run `belt deploy frontend #{@env}` manually to retry."
+      end
+
       def print_outputs(env_dir)
         Dir.chdir(env_dir) do
           output = `terraform output 2>/dev/null`.strip

data/lib/belt/cli/destroy_command.rb

@@ -0,0 +1,320 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require_relative 'app_detection'
+require_relative 'tables_command'
+require_relative '../inflector'
+
+module Belt
+  module CLI
+    class DestroyCommand
+      GENERATORS = %w[scaffold resource model controller environment frontend views].freeze
+
+      include AppDetection
+
+      def self.run(args)
+        generator = args.shift
+
+        if generator.nil? || generator =~ /\A-/
+          print_help
+          exit 0
+        end
+
+        unless GENERATORS.include?(generator)
+          puts "Unknown generator: '#{generator}'"
+          puts "Available: #{GENERATORS.uniq.join(', ')}"
+          puts "\nRun 'belt destroy --help' for usage information."
+          exit 1
+        end
+
+        # Normalize: resource is an alias for scaffold
+        generator = 'scaffold' if generator == 'resource'
+
+        case generator
+        when 'environment'
+          name = args.shift
+          if name.nil? || name.empty?
+            puts 'Usage: belt destroy environment <name>'
+            exit 1
+          end
+          new(generator, name, []).destroy
+        when 'frontend'
+          new(generator, nil, []).destroy
+        when 'views'
+          name = args.shift
+          if name.nil? || name.empty?
+            puts 'Usage: belt destroy views <name>'
+            exit 1
+          end
+          new(generator, name, args.map { |a| parse_field(a) }).destroy
+        else
+          name = args.shift
+          if name.nil? || name.empty?
+            puts "Usage: belt destroy #{generator} <name>"
+            exit 1
+          end
+          new(generator, name, args.map { |a| parse_field(a) }).destroy
+        end
+      end
+
+      def self.parse_field(arg)
+        name, type = arg.split(':', 2)
+        { name: name, type: type || 'string' }
+      end
+
+      def self.print_help
+        puts <<~HELP
+          Usage: belt destroy <generator> <name> [field:type ...]
+                 belt d <generator> <name> [field:type ...]
+
+          Removes files and references created by `belt generate`.
+
+          Generators:
+            scaffold      Remove model, controller, routes, schema, and views
+            resource      Alias for scaffold
+            model         Remove an ActiveItem model
+            controller    Remove a controller
+            environment   Remove a deployment environment directory
+            frontend      Remove the frontend/ directory
+            views         Remove React pages for a resource
+
+          Examples:
+            belt d scaffold post title:string body:text status:string
+            belt d model user
+            belt d controller comments
+            belt d environment staging
+            belt d frontend
+            belt d views post
+
+          ⚠ This is destructive. Files will be permanently deleted.
+        HELP
+      end
+
+      def initialize(generator, name, fields)
+        @generator = generator
+        @name = name&.downcase&.gsub(/[^a-z0-9_]/, '_')
+        @fields = fields
+        @app_name = detect_namespace
+        @singular_name = @name ? Belt::Inflector.singularize(@name) : nil
+        @resource_name = @singular_name ? Belt::Inflector.pluralize(@singular_name) : nil
+        @class_name = @singular_name ? Belt::Inflector.classify(@singular_name) : nil
+        @removed = []
+        @updated = []
+      end
+
+      def destroy
+        case @generator
+        when 'scaffold'  then destroy_scaffold
+        when 'model'     then destroy_model
+        when 'controller' then destroy_controller
+        when 'environment' then destroy_environment
+        when 'frontend'  then destroy_frontend
+        when 'views'     then destroy_views
+        end
+
+        print_summary
+      end
+
+      private
+
+      def destroy_scaffold
+        destroy_model
+        destroy_controller
+        remove_routes
+        remove_schema
+        sync_tables
+        destroy_views
+        puts "\n✓ Scaffold '#{@singular_name}' destroyed!"
+      end
+
+      def destroy_model
+        path = "lambda/models/#{@singular_name}.rb"
+        remove_file(path)
+      end
+
+      def destroy_controller
+        path = "lambda/controllers/#{@app_name}/#{@resource_name}_controller.rb"
+        remove_file(path)
+      end
+
+      def destroy_environment
+        dir = "infrastructure/#{@name}"
+        if Dir.exist?(dir)
+          FileUtils.rm_rf(dir)
+          @removed << dir
+          puts "  remove  #{dir}/"
+          puts "\n✓ Environment '#{@name}' destroyed!"
+        else
+          puts "✗ Environment '#{@name}' not found at #{dir}/"
+          exit 1
+        end
+      end
+
+      def destroy_frontend
+        dir = 'frontend'
+        if Dir.exist?(dir)
+          FileUtils.rm_rf(dir)
+          @removed << dir
+          puts "  remove  #{dir}/"
+
+          # Remove frontend.tf and revert frontend_urls in main.tf for each environment
+          Dir.glob('infrastructure/*/frontend.tf').each do |frontend_tf|
+            FileUtils.rm_f(frontend_tf)
+            puts "  remove  #{frontend_tf}"
+
+            env_dir = File.dirname(frontend_tf)
+            main_tf = File.join(env_dir, 'main.tf')
+            revert_main_tf_frontend_urls(main_tf)
+          end
+
+          puts "\n✓ Frontend removed!"
+        else
+          puts '✗ No frontend/ directory found.'
+          exit 1
+        end
+      end
+
+      def revert_main_tf_frontend_urls(main_tf)
+        return unless File.exist?(main_tf)
+
+        content = File.read(main_tf)
+        return unless content.include?('aws_cloudfront_distribution.frontend.domain_name')
+
+        # Replace the multi-line concat block back to a simple conditional
+        replaced = content.sub(
+          /^\s*frontend_urls\s*=\s*concat\(\n(?:.*\n)*?\s*\)\s*\n/,
+          "  frontend_urls     = var.environment == \"prod\" ? [] : [\"http://localhost:3000\"]\n"
+        )
+
+        if replaced != content
+          File.write(main_tf, replaced)
+          puts "  update  #{main_tf} (reverted frontend_urls)"
+        end
+      end
+
+      def destroy_views
+        return unless @resource_name
+
+        pages_dir = "frontend/src/pages/#{@resource_name}"
+
+        if Dir.exist?(pages_dir)
+          FileUtils.rm_rf(pages_dir)
+          @removed << pages_dir
+          puts "  remove  #{pages_dir}/"
+        end
+
+        remove_view_routes
+      end
+
+      def remove_file(path)
+        if File.exist?(path)
+          File.delete(path)
+          @removed << path
+          puts "  remove  #{path}"
+
+          # Clean up empty parent directories
+          dir = File.dirname(path)
+          while dir != '.' && Dir.exist?(dir) && Dir.empty?(dir)
+            Dir.rmdir(dir)
+            puts "  remove  #{dir}/"
+            dir = File.dirname(dir)
+          end
+        else
+          puts "  skip    #{path} (not found)"
+        end
+      end
+
+      def remove_routes
+        routes_file = 'infrastructure/routes.tf.rb'
+        return unless File.exist?(routes_file)
+
+        content = File.read(routes_file)
+        original = content.dup
+
+        # Remove "resources :posts" or "resources :posts, tables: [...]" line
+        content.gsub!(/^\s*resources :#{@resource_name}.*\n/, '')
+
+        if content != original
+          File.write(routes_file, content)
+          @updated << routes_file
+          puts "  update  #{routes_file}"
+        end
+
+        # Update route manifest
+        remove_route_manifest_entries
+      end
+
+      def remove_route_manifest_entries
+        manifest_file = "lambda/lib/routes/#{@app_name}_routes.rb"
+        return unless File.exist?(manifest_file)
+
+        content = File.read(manifest_file)
+        original = content.dup
+
+        # Remove route entries for this controller
+        content.gsub!(/^\s*\{ verb: .+?controller: '#{@resource_name}'.+?\},?\n/, '')
+
+        # Clean up trailing commas and empty arrays
+        content.gsub!(/,(\s*\n\s*\]\.freeze)/, '\1')
+
+        if content != original
+          File.write(manifest_file, content)
+          @updated << manifest_file
+          puts "  update  #{manifest_file}"
+        end
+      end
+
+      def remove_schema
+        schema_file = 'infrastructure/schema.tf.rb'
+        return unless File.exist?(schema_file)
+
+        content = File.read(schema_file)
+        original = content.dup
+
+        # Remove the model block for this resource
+        content.gsub!(/\n?\s*model :#{@singular_name} do\n.*?\n\s*end\n?/m, "\n")
+
+        # Clean up excessive blank lines
+        content.gsub!(/\n{3,}/, "\n\n")
+
+        if content != original
+          File.write(schema_file, content)
+          @updated << schema_file
+          puts "  update  #{schema_file}"
+        end
+      end
+
+      def sync_tables
+        Belt::CLI::TablesCommand.sync_all_environments
+      end
+
+      def remove_view_routes
+        app_jsx = 'frontend/src/App.jsx'
+        return unless File.exist?(app_jsx)
+
+        content = File.read(app_jsx)
+        original = content.dup
+
+        # Remove import lines for this resource's pages
+        content.gsub!(/^import #{@class_name}\w* from '.\/pages\/#{@resource_name}\/.*'\n/, '')
+
+        # Remove Route elements for this resource
+        content.gsub!(/^\s*<Route path="\/#{@resource_name}.*?\/>\n/, '')
+
+        if content != original
+          File.write(app_jsx, content)
+          @updated << app_jsx
+          puts "  update  #{app_jsx}"
+        end
+      end
+
+      def print_summary
+        return if @removed.empty? && @updated.empty?
+
+        puts "\nSummary:"
+        puts "  Removed: #{@removed.length} file(s)/dir(s)" unless @removed.empty?
+        puts "  Updated: #{@updated.length} file(s)" unless @updated.empty?
+      end
+    end
+  end
+end

data/lib/belt/cli/environment_command.rb

@@ -51,6 +51,8 @@ module Belt
 
         puts "\n✓ Environment '#{@env_name}' created!"
 
+        setup_frontend_if_exists
+
         unless @quiet
           puts "\nNext steps:"
           puts "  cd #{dest_dir}"
@@ -62,6 +64,15 @@ module Belt
 
       private
 
+      def setup_frontend_if_exists
+        return unless Dir.exist?('frontend') && !Dir.empty?('frontend')
+
+        puts "\n  Frontend detected — generating frontend infrastructure..."
+        require_relative 'frontend_setup_command'
+        FrontendSetupCommand.new(@env_name, quiet: true).run
+        puts "  create  infrastructure/#{@env_name}/frontend.tf"
+      end
+
       def templates
         {
           'main.tf.erb' => 'main.tf',

data/lib/belt/cli/frontend_command.rb

@@ -53,14 +53,46 @@ module Belt
         copy_template(framework_dir, dest_dir)
 
         puts "\n✓ Frontend (#{@framework}) created in frontend/"
+
+        install_dependencies(dest_dir)
+        setup_frontend_infra_for_existing_environments
+
         puts "\nNext steps:"
-        puts '  cd frontend && npm install && npm run dev'
-        puts '  belt setup frontend <env>    # Generate CloudFront + S3 infrastructure'
-        puts '  belt deploy frontend <env>   # Build and deploy to AWS'
+        puts '  belt server                   # Start local dev server'
+        puts '  belt deploy                   # Deploy everything to AWS'
       end
 
       private
 
+      def install_dependencies(dest_dir)
+        puts "\n  Installing npm dependencies..."
+        success = system('npm', 'install', '--prefix', dest_dir, '--loglevel', 'error')
+        if success
+          puts "  ✓ Dependencies installed"
+        else
+          puts "  ⚠ npm install failed — run `cd #{dest_dir} && npm install` manually"
+        end
+      end
+
+      def setup_frontend_infra_for_existing_environments
+        environments = detect_environments
+        return if environments.empty?
+
+        puts "\n  Setting up frontend infrastructure for existing environments..."
+        require_relative 'frontend_setup_command'
+
+        environments.each do |env_name|
+          frontend_tf = "infrastructure/#{env_name}/frontend.tf"
+          if File.exist?(frontend_tf)
+            puts "  skip    #{frontend_tf} (already exists)"
+            next
+          end
+
+          FrontendSetupCommand.new(env_name, quiet: true).run
+          puts "  create  #{frontend_tf}"
+        end
+      end
+
       def copy_template(src_dir, dest_dir)
         Dir.glob("#{src_dir}/**/*", File::FNM_DOTMATCH).each do |src|
           next if File.directory?(src)

data/lib/belt/cli/frontend_setup_command.rb

@@ -29,15 +29,19 @@ module Belt
         new(env).run
       end
 
-      def initialize(env)
+      def initialize(env, quiet: false)
         @env = env
         @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."
@@ -57,7 +61,36 @@ module Belt
         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}"
+        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