belt 0.1.6 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b09432f7426352033b67c6cc696bc90cddcae4b1facae08ce7b6fc08763b7eef
-  data.tar.gz: bb4617d6514bef6636b5b2efcfd32eaee6ebbc66b09a7e7f83581340c0fe5714
+  metadata.gz: 479b619266e398d1d3052c96eb18f05c8452306a01aa46576b82e072372820b5
+  data.tar.gz: d5697750193b1a1cbba8d39e81190035d8fd40db490efbdb24903e7647374767
 SHA512:
-  metadata.gz: 2c67896f36d6b09e394e19a73a92a6c8e31e9ec43071bf92c905f7d78ba260766d5b46aa2ee9d6c4d665c3313679557df527b866089bad240693fcdd1ce89e91
-  data.tar.gz: 8cf8956ea9a6227237be1dccc0cfe15b96ac9e75c3ddae543873cb067fcc5b8648fa23a1a258ccd3470afb9097ba54a7bc2dedfadcc701294b6ff8d9449ac755
+  metadata.gz: 73ac84ffd0e2238b929180f89972f70c55a7d43a92d0f9de23b85cc6c318982c40c9466f49fe1d2d0960a47685acc90e1352b43f7e390ffee2951c83568ba432
+  data.tar.gz: 74db2374a336ba5ac774a5a8a4f7c053136de9dc652907e4abeebd69ec6bfa6485f35d3339787e7e5b17feadb3cf23014ae356d8050e817c90a2ba1fbf817ba6

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,287 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require_relative 'app_detection'
+
+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
+        @resource_name = if @name
+                           @name.end_with?('s') ? @name : "#{@name}s"
+                         end
+        @singular_name = if @name
+                           @name.end_with?('s') ? @name.chomp('s') : @name
+                         end
+        @class_name = @singular_name&.split('_')&.map(&:capitalize)&.join
+        @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
+        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}/"
+          puts "\n✓ Frontend removed!"
+        else
+          puts '✗ No frontend/ directory found.'
+          exit 1
+        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 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,18 @@ 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
+        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 +60,7 @@ 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
     end
   end

data/lib/belt/cli/generate_command.rb

@@ -11,23 +11,23 @@ module Belt
   module CLI
     class GenerateCommand
       TEMPLATE_DIR = File.expand_path('../../templates/generate', __dir__)
-      GENERATORS = %w[resource model controller environment frontend views].freeze
+      GENERATORS = %w[scaffold resource model controller environment frontend views].freeze
 
       include AppDetection
 
       FIELD_TYPES = %w[string text integer float boolean date datetime].freeze
 
       GENERATOR_HELP = {
-        'resource' => {
-          description: 'Generate a model, controller, routes, and schema for a REST resource.',
-          usage: 'belt generate resource <name> [field:type ...] [options]',
+        'scaffold' => {
+          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']
           ],
           examples: [
-            ['belt g resource post title:string body:text', 'Post with title and body fields'],
-            ['belt g resource comment author:string body:text status:string', 'Comment with multiple fields'],
-            ['belt g resource task --skip-views', 'Task resource without frontend pages']
+            ['belt g scaffold post title:string body:text', 'Post with title and body fields'],
+            ['belt g scaffold comment author:string body:text status:string', 'Scaffold with multiple fields'],
+            ['belt g scaffold task --skip-views', 'Scaffold without frontend pages']
           ],
           notes: <<~NOTES
             Creates:
@@ -36,6 +36,9 @@ module Belt
               infrastructure/routes.tf.rb                        Route entry added
               infrastructure/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)
+
+            Alias: `belt g resource` works the same way.
           NOTES
         },
         'model' => {
@@ -77,12 +80,15 @@ module Belt
 
         unless GENERATORS.include?(generator)
           puts "Unknown generator: '#{generator}'"
-          puts "Available generators: #{GENERATORS.join(', ')}"
+          puts "Available generators: #{(GENERATORS - ['resource']).join(', ')}"
           puts "\nRun 'belt generate --help' for usage information."
           exit 1
         end
 
-        # Per-generator help: belt g resource --help
+        # Normalize: resource is an alias for scaffold
+        generator = 'scaffold' if generator == 'resource'
+
+        # Per-generator help: belt g scaffold --help
         if args.include?('--help') || args.include?('-h')
           print_generator_help(generator)
           exit 0
@@ -143,18 +149,21 @@ module Belt
                  belt g <generator> <name> [field:type ...] [options]
 
           Generators:
-            resource      Generate model, controller, routes, and schema (full REST resource)
+            scaffold      Generate model, controller, routes, schema, and views (full REST resource)
             model         Generate an ActiveItem model
             controller    Generate a controller
             environment   Create a new deployment environment
             frontend      Scaffold a frontend app (react, vue, svelte)
             views         Generate React pages for a resource
 
+          Aliases:
+            resource      Same as scaffold
+
           Field Types:
             #{FIELD_TYPES.join(', ')}
 
           Examples:
-            belt g resource post title:string body:text status:string
+            belt g scaffold post title:string body:text status:string
             belt g model user email:string name:string
             belt g controller comments
             belt g environment staging
@@ -219,7 +228,7 @@ module Belt
 
       def generate
         case @generator
-        when 'resource'  then generate_resource
+        when 'scaffold'  then generate_resource
         when 'model'     then generate_model
         when 'controller' then generate_controller
         end
@@ -233,7 +242,7 @@ module Belt
         inject_routes
         inject_schema
         generate_views_if_frontend
-        puts "\n✓ Resource '#{@singular_name}' generated!"
+        puts "\n✓ Scaffold '#{@singular_name}' generated!"
         puts "\nFiles created/updated:"
         puts "  lambda/models/#{@singular_name}.rb"
         puts "  lambda/controllers/#{@app_name}/#{@resource_name}_controller.rb"
@@ -261,14 +270,35 @@ module Belt
 
         content = File.read(routes_file)
         tables_arg = @fields.any? ? ", tables: [:#{@resource_name}]" : ''
+        resource_line = "resources :#{@resource_name}#{tables_arg}"
 
-        # Insert before the closing `end` of the namespace block
+        # Replace the commented placeholder if it exists
         if content.include?('# resources :posts')
-          content.sub!('# resources :posts', "resources :#{@resource_name}#{tables_arg}")
-        elsif content.match?(/namespace :\w+[^\n]*do\n(\s+#[^\n]*\n)*\s+end/)
-          content.sub!(/^(\s+)(end\s*\z)/m, "\\1  resources :#{@resource_name}#{tables_arg}\n\\1\\2")
+          content.sub!('# resources :posts', resource_line)
         else
-          content.sub!(/^(\s*end\s*\z)/m, "    resources :#{@resource_name}#{tables_arg}\n\\1")
+          # Find the target namespace block and insert before its closing `end`
+          # Match: `namespace :<name> do` ... `end` (the first `end` at the same indent level)
+          namespace_pattern = /^(\s*)namespace :#{Regexp.escape(@app_name)}\b[^\n]*do\s*\n(.*?)^\1end/m
+
+          if content.match?(namespace_pattern)
+            content.sub!(namespace_pattern) do |match|
+              indent = $1
+              # Insert the resource line before the namespace's closing `end`
+              match.sub(/^(#{indent})end\z/m, "#{indent}  #{resource_line}\n#{indent}end")
+            end
+          else
+            # Fallback: find any single namespace block and insert into it
+            single_ns_pattern = /^(\s*)namespace :\w+\b[^\n]*do\s*\n(.*?)^\1end/m
+            if content.match?(single_ns_pattern)
+              content.sub!(single_ns_pattern) do |match|
+                indent = $1
+                match.sub(/^(#{indent})end\z/m, "#{indent}  #{resource_line}\n#{indent}end")
+              end
+            else
+              # No namespace block found at all — insert at top level before final end
+              content.sub!(/^(\s*end\s*)\z/m, "  #{resource_line}\n\\1")
+            end
+          end
         end
 
         File.write(routes_file, content)

data/lib/belt/cli/new_command.rb

@@ -82,8 +82,8 @@ module Belt
 
         puts "Creating new Belt application: #{@app_name}"
         create_structure
-        generate_frontend if @frontend
         generate_environments
+        generate_frontend if @frontend
         init_git
         run_bundle_install
         setup_state

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

@@ -16,6 +16,10 @@ module Belt
 
           return non_param.map { |s| s.gsub('-', '_') }.join('/') if route.resource? && nested_resource?(segments)
 
+          # For non-resource routes with a single segment (e.g., post '/signup' in :onboarding),
+          # the segment is the action name, not the controller. Use the gateway name as controller.
+          return gateway.name if !route.resource? && non_param.length == 1
+
           non_param.first.gsub('-', '_')
         end
 

data/lib/belt/cli.rb

@@ -5,6 +5,7 @@ require_relative 'root'
 require_relative 'cli/env_resolver'
 require_relative 'cli/new_command'
 require_relative 'cli/generate_command'
+require_relative 'cli/destroy_command'
 require_relative 'cli/frontend_command'
 require_relative 'cli/frontend_setup_command'
 require_relative 'cli/frontend_deploy_command'
@@ -22,6 +23,7 @@ module Belt
     COMMANDS_DEFINITION = {
       'new' => Belt::CLI::NewCommand,
       %w[generate g] => Belt::CLI::GenerateCommand,
+      %w[destroy d] => Belt::CLI::DestroyCommand,
       'routes' => Belt::CLI::RoutesCommand,
       %w[console c] => Belt::CLI::ConsoleCommand,
       %w[tasks --tasks -T] => Belt::CLI::TasksCommand,
@@ -45,7 +47,21 @@ module Belt
         exit 1
       end
 
-      # Terraform shorthand: belt init wups, belt plan wups, belt apply wups
+      # `belt destroy` is ambiguous: could be terraform destroy or belt destroy <generator>.
+      # Route to DestroyCommand if the first arg is a known generator or help flag.
+      if command == 'destroy'
+        if args.empty? || args.first =~ /\A-/
+          # belt destroy --help → DestroyCommand help
+          # belt destroy (no args) → terraform destroy (needs env)
+          if args.include?('--help') || args.include?('-h')
+            return DestroyCommand.run(args)
+          end
+        elsif DestroyCommand::GENERATORS.include?(args.first)
+          return DestroyCommand.run(args)
+        end
+      end
+
+      # Terraform shorthand: belt init wups, belt plan wups, belt apply wups, belt destroy wups
       return Belt::CLI::TerraformCommand.run(command, args) if TERRAFORM_ACTIONS.include?(command)
 
       handler = COMMANDS[command]
@@ -71,10 +87,14 @@ module Belt
 
         Commands:
           new <app_name> [--frontend react]           Create a new Belt application
-          generate <resource|model|controller> <name> Generate components
+          generate <scaffold|model|controller> <name> Generate components
           generate frontend <react|vue|svelte>        Scaffold a frontend app
           generate views <resource> [fields...]       Generate React pages for REST actions
           generate environment <name>                 Create a new environment
+          destroy <scaffold|model|controller> <name>  Remove generated components
+          destroy frontend                            Remove the frontend/ directory
+          destroy views <resource>                    Remove React pages for a resource
+          destroy environment <name>                  Remove an environment directory
           server                                      Start local dev server (frontend)
           s                                           Alias for server
           deploy [environment]                        Deploy to AWS (init → plan → apply)
@@ -106,7 +126,8 @@ module Belt
 
         Examples:
           belt new blog --frontend react
-          belt generate resource post title:string content:text status:string
+          belt generate scaffold post title:string content:text status:string
+          belt destroy scaffold post
           belt generate frontend react
           belt server                   # Start local frontend server
           belt deploy                   # Deploy dev to AWS

data/lib/belt/version.rb

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

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

@@ -1,5 +1,10 @@
 output "api_url" {
   description = "API Gateway base URL"
+  value       = values(conveyor_belt.main.api_gateway_urls)[0]
+}
+
+output "api_urls" {
+  description = "Map of gateway names to API Gateway URLs"
   value       = conveyor_belt.main.api_gateway_urls
 }
 

data/lib/templates/frontend_infra/frontend.tf.erb

@@ -153,7 +153,3 @@ output "frontend_distribution_id" {
 output "frontend_url" {
   value = "https://${aws_cloudfront_distribution.frontend.domain_name}"
 }
-
-output "api_url" {
-  value = values(conveyor_belt.main.api_gateway_urls)[0]
-}

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: belt
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.7
 platform: ruby
 authors:
 - Stowzilla
@@ -59,6 +59,7 @@ files:
 - lib/belt/cli/bucket_security.rb
 - lib/belt/cli/console_command.rb
 - lib/belt/cli/deploy_command.rb
+- lib/belt/cli/destroy_command.rb
 - lib/belt/cli/env_resolver.rb
 - lib/belt/cli/environment_command.rb
 - lib/belt/cli/frontend_command.rb