belt 0.0.7 → 0.1.0

data/lib/belt/cli/tables_command.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require_relative 'app_detection'
+require_relative 'env_resolver'
+
+module Belt
+  module CLI
+    class TablesCommand
+      SCHEMA_FILE = 'infrastructure/schema.tf.rb'
+
+      include AppDetection
+
+      def self.run(args)
+        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 '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'
+          exit 1
+        end
+
+        new(env).run
+      end
+
+      def initialize(env)
+        @env = env
+        @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
+        end
+
+        generate_dynamodb_tf(models)
+      end
+
+      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)
+
+        abort "Error: Environment '#{@env}' not found at #{@env_dir}/.\n" \
+              "Create it with: belt generate environment #{@env}"
+      end
+
+      def parse_schema
+        parser = SchemaParser.new
+        schema_content = File.read(SCHEMA_FILE)
+
+        # Replace DSL wrapper with direct parser call
+        # TerraDispatch.schema.draw do ... end → parser.instance_eval do ... end
+        inner = schema_content.sub(/\ATerraDispatch\.schema\.draw do\n?/, '').sub(/\nend\s*\z/, '')
+        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."
+      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"
+      end
+
+      def render_table(model)
+        name = table_name(model[:name])
+        <<~HCL
+          resource "aws_dynamodb_table" "#{model[:name]}s" {
+            name         = "#{name}"
+            billing_mode = "PAY_PER_REQUEST"
+            hash_key     = "id"
+
+            attribute {
+              name = "id"
+              type = "S"
+            }
+
+            tags = {
+              Name        = "#{name}"
+              Environment = var.environment
+              ManagedBy   = "Terraform"
+            }
+          }
+        HCL
+      end
+
+      def table_name(model_name)
+        "#{@app_name}-#{@env}-#{model_name}s"
+      end
+
+      # Minimal DSL parser for schema.tf.rb
+      class SchemaParser
+        attr_reader :models
+
+        def initialize
+          @models = []
+        end
+
+        def model(name, &block)
+          model_def = ModelParser.new
+          model_def.instance_eval(&block) if block
+          @models << { name: name.to_s, fields: model_def.fields }
+        end
+      end
+
+      class ModelParser
+        attr_reader :fields
+
+        def initialize
+          @fields = []
+        end
+
+        def field(name, **opts)
+          @fields << { name: name.to_s, type: opts[:type]&.to_s || 'string' }
+        end
+      end
+    end
+  end
+end

data/lib/belt/cli/terraform_command.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require_relative 'env_resolver'
+
+module Belt
+  module CLI
+    class TerraformCommand
+      ACTIONS = %w[init plan apply destroy output].freeze
+
+      def self.run(action, args)
+        env = EnvResolver.resolve(args)
+
+        if env.nil?
+          puts "Usage: belt #{action} <environment> [terraform flags...]"
+          puts "\nYou can also set BELT_ENV to skip the environment argument."
+          puts "\nExamples:"
+          puts "  belt #{action} wups"
+          puts "  belt #{action} dev01"
+          puts "  BELT_ENV=wups belt #{action}"
+          puts '  belt plan staging -target=module.lambda'
+          puts "\nAvailable environments:"
+          list_environments.each { |e| puts "  #{e}" }
+          exit 1
+        end
+
+        new(action, env, args).run
+      end
+
+      def self.list_environments
+        infra_dir = find_infrastructure_dir
+        return [] unless infra_dir
+
+        Dir.children(infra_dir)
+           .select { |d| File.directory?(File.join(infra_dir, d)) }
+           .reject { |d| d.start_with?('.') || d == 'modules' }
+           .sort
+      end
+
+      def self.find_infrastructure_dir
+        %w[infrastructure infra].each do |dir|
+          return dir if Dir.exist?(dir)
+        end
+        nil
+      end
+
+      def initialize(action, env, extra_args)
+        @action = action
+        @env = env
+        @extra_args = extra_args
+        @infra_dir = self.class.find_infrastructure_dir
+      end
+
+      def run
+        validate!
+        env_dir = File.join(@infra_dir, @env)
+        args = ['terraform', @action, *@extra_args]
+        puts "belt → #{args.join(' ')}  (in #{env_dir}/)"
+        Dir.chdir(env_dir) { exec(*args) }
+      end
+
+      private
+
+      def validate!
+        unless @infra_dir
+          abort "Error: No infrastructure/ directory found. Run `belt generate environment #{@env}` first."
+        end
+
+        env_dir = File.join(@infra_dir, @env)
+        return if Dir.exist?(env_dir)
+
+        abort "Error: Environment '#{@env}' not found at #{env_dir}/.\n\n" \
+              "Available environments:\n#{self.class.list_environments.map { |e| "  #{e}" }.join("\n")}\n\n" \
+              "Create it with: belt generate environment #{@env}"
+      end
+    end
+  end
+end

data/lib/belt/cli/views_command.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'erb'
+
+module Belt
+  module CLI
+    class ViewsCommand
+      TEMPLATE_DIR = File.expand_path('../../templates/views', __dir__)
+
+      def self.run(args)
+        name = args.shift
+        if name.nil? || name.empty?
+          puts 'Usage: belt generate views <resource> [field:type ...]'
+          puts "\nGenerates React pages for all REST actions (index, show, new, edit)."
+          puts "\nExamples:"
+          puts '  belt generate views post title:string content:text status:string'
+          puts '  belt generate views comment body:text author:string'
+          exit 1
+        end
+
+        fields = args.map do |arg|
+          n, t = arg.split(':', 2)
+          { name: n, type: t || 'string' }
+        end
+
+        # If no fields provided, try to read from schema.tf.rb
+        fields = read_schema_fields(name) if fields.empty?
+
+        new(name, fields).generate
+      end
+
+      def self.read_schema_fields(name)
+        schema_file = 'infrastructure/schema.tf.rb'
+        return [] unless File.exist?(schema_file)
+
+        content = File.read(schema_file)
+        singular = name.end_with?('s') ? name.chomp('s') : name
+
+        # Extract fields from model block
+        if content =~ /model :#{singular} do\n(.*?)\n\s*end/m
+          ::Regexp.last_match(1).scan(/field :(\w+), type: :(\w+)/).except('created_at', 'updated_at')
+                  .map do |n, t|
+            {
+              name: n, type: t
+            }
+          end
+        else
+          []
+        end
+      end
+
+      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
+      end
+
+      def generate
+        unless Dir.exist?('frontend/src')
+          puts '✗ No frontend/ directory found. Run `belt generate frontend react` first.'
+          exit 1
+        end
+
+        pages_dir = "frontend/src/pages/#{@resource_name}"
+        FileUtils.mkdir_p(pages_dir)
+
+        write_template('Index.jsx.erb', "#{pages_dir}/#{@class_name}sIndex.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")
+        write_template('Form.jsx.erb', "#{pages_dir}/#{@class_name}Form.jsx")
+
+        inject_routes
+
+        puts "\n✓ Views for '#{@singular_name}' generated!"
+        puts "\nFiles created:"
+        puts "  #{pages_dir}/#{@class_name}sIndex.jsx"
+        puts "  #{pages_dir}/#{@class_name}Show.jsx"
+        puts "  #{pages_dir}/#{@class_name}New.jsx"
+        puts "  #{pages_dir}/#{@class_name}Edit.jsx"
+        puts "  #{pages_dir}/#{@class_name}Form.jsx"
+        puts '  frontend/src/App.jsx (updated)'
+      end
+
+      private
+
+      def write_template(template_name, dest_path)
+        template_path = File.join(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
+
+      def inject_routes
+        app_jsx = 'frontend/src/App.jsx'
+        return unless File.exist?(app_jsx)
+
+        content = File.read(app_jsx)
+        pages_dir = @resource_name
+
+        import_lines = [
+          "import #{@class_name}sIndex from './pages/#{pages_dir}/#{@class_name}sIndex'",
+          "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}/new\" element={<#{@class_name}New />} />",
+          "        <Route path=\"/#{@resource_name}/:id\" element={<#{@class_name}Show />} />",
+          "        <Route path=\"/#{@resource_name}/:id/edit\" element={<#{@class_name}Edit />} />"
+        ]
+
+        # Add imports after last import line
+        last_import_idx = content.rindex(/^import .+$/)
+        if last_import_idx
+          end_of_line = content.index("\n", last_import_idx)
+          content.insert(end_of_line, "\n#{import_lines.join("\n")}")
+        end
+
+        # Add routes before closing </Routes> (no regex — avoids polynomial backtracking)
+        close_idx = content.index('</Routes>')
+        content.insert(close_idx, "#{route_lines.join("\n")}\n") if close_idx
+
+        File.write(app_jsx, content)
+        puts "  update  #{app_jsx}"
+      end
+    end
+  end
+end

data/lib/belt/cli.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require_relative 'version'
+require_relative 'cli/env_resolver'
+require_relative 'cli/new_command'
+require_relative 'cli/generate_command'
+require_relative 'cli/frontend_command'
+require_relative 'cli/frontend_setup_command'
+require_relative 'cli/frontend_deploy_command'
+require_relative 'cli/views_command'
+require_relative 'cli/setup_command'
+require_relative 'cli/terraform_command'
+
+module Belt
+  module CLI
+    COMMANDS = {
+      'new' => Belt::CLI::NewCommand,
+      'generate' => Belt::CLI::GenerateCommand,
+      'g' => Belt::CLI::GenerateCommand,
+      'setup' => Belt::CLI::SetupCommand,
+      'deploy' => lambda { |args|
+        subcommand = args.shift
+        if subcommand == 'frontend'
+          Belt::CLI::FrontendDeployCommand.run(args)
+        else
+          puts 'Usage: belt deploy frontend <environment>'
+          exit 1
+        end
+      },
+      '--version' => ->(_args) { puts "Belt #{Belt::VERSION}" },
+      '-v' => ->(_args) { puts "Belt #{Belt::VERSION}" }
+    }.freeze
+
+    TERRAFORM_ACTIONS = Belt::CLI::TerraformCommand::ACTIONS
+
+    def self.start(args)
+      command = args.shift
+
+      if command.nil?
+        puts usage
+        exit 1
+      end
+
+      # Terraform shorthand: belt init wups, belt plan wups, belt apply wups
+      return Belt::CLI::TerraformCommand.run(command, args) if TERRAFORM_ACTIONS.include?(command)
+
+      handler = COMMANDS[command]
+
+      if handler.nil?
+        puts "Unknown command: #{command}\n\n#{usage}"
+        exit 1
+      end
+
+      if handler.is_a?(Proc)
+        handler.call(args)
+      else
+        handler.run(args)
+      end
+    end
+
+    def self.usage
+      <<~USAGE
+        Usage: belt <command> [options]
+
+        Commands:
+          new <app_name> [--frontend react]           Create a new Belt application
+          generate <resource|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
+          setup state                                 Create/select S3 state bucket
+          setup tables <env>                          Generate DynamoDB tables from schema
+          setup frontend <env>                        Generate S3 + CloudFront infrastructure
+          deploy frontend <env>                       Build and deploy frontend to AWS
+          init <env>                                  terraform init for environment
+          plan <env>                                  terraform plan for environment
+          apply <env>                                 terraform apply for environment
+          destroy <env>                               terraform destroy for environment
+          output <env>                                terraform output for environment
+          --version                                   Show Belt version
+
+        Environment:
+          Set BELT_ENV to skip the <env> argument:
+            export BELT_ENV=wups
+            belt apply                  # uses BELT_ENV
+            belt apply dev01            # explicit arg wins
+
+        Examples:
+          belt new blog --frontend react
+          belt generate resource post title:string content:text status:string
+          belt generate frontend react
+          belt setup frontend wups
+          belt deploy frontend wups
+          belt apply wups
+      USAGE
+    end
+  end
+end

data/lib/belt/lambda_handler.rb

@@ -25,6 +25,22 @@ module Belt
 
     def self.included(base)
       base.instance_variable_set(:@belt_lambda_handler_included, true)
+
+      # Skip auto-registration in test environments to avoid stale paths
+      return if ENV['BELT_ENV'] == 'test' || ENV['RACK_ENV'] == 'test' || defined?(RSpec)
+
+      # Auto-register controllers directory relative to the including file's location
+      caller_file = caller_locations(1, 1)&.first&.path
+      return unless caller_file
+
+      controllers_dir = File.join(File.dirname(caller_file), 'controllers')
+      return unless File.directory?(controllers_dir)
+
+      Belt.controller_paths << controllers_dir
+      Dir.children(controllers_dir).each do |child|
+        subdir = File.join(controllers_dir, child)
+        Belt.controller_paths << subdir if File.directory?(subdir)
+      end
     end
 
     # API Gateway Lambda handler.

data/lib/belt/version.rb

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

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

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

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

@@ -0,0 +1,42 @@
+terraform {
+  required_providers {
+    aws = {
+      source  = "hashicorp/aws"
+      version = "~> 5.0"
+    }
+    random = {
+      source  = "hashicorp/random"
+      version = "~> 3.0"
+    }
+    dispatcher = {
+      source  = "terraform.local/stowzilla/dispatcher"
+      version = "99.0.0"
+    }
+  }
+}
+
+provider "aws" {
+  region = var.aws_region
+
+  default_tags {
+    tags = {
+      Project     = "<%= @app_name.capitalize %>"
+      Environment = var.environment
+      ManagedBy   = "Terraform"
+    }
+  }
+}
+
+provider "dispatcher" {
+  environment = var.environment
+  aws_region  = var.aws_region
+}
+
+resource "dispatcher" "main" {
+  source            = "${path.module}/../routes.tf.rb"
+  app_name          = var.app_name
+  lambda_source_dir = "${path.module}/../../lambda"
+  lambda_shared_dirs = ["controllers", "helpers", "lib", "models", "templates"]
+  frontend_urls     = ["http://localhost:3000"]
+  friendly_errors   = true
+}

data/lib/templates/environment/terraform.tfvars.erb

@@ -0,0 +1 @@
+environment = "<%= @env_name %>"

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

@@ -0,0 +1,16 @@
+variable "app_name" {
+  description = "Name of the application"
+  type        = string
+  default     = "<%= @app_name %>"
+}
+
+variable "environment" {
+  description = "Environment name"
+  type        = string
+}
+
+variable "aws_region" {
+  description = "AWS region"
+  type        = string
+  default     = "us-east-1"
+}

data/lib/templates/frontend/react/index.html.erb

@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title><%= @module_name %></title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.jsx"></script>
+  </body>
+</html>

data/lib/templates/frontend/react/package.json.erb

@@ -0,0 +1,20 @@
+{
+  "name": "<%= @app_name %>",
+  "private": true,
+  "version": "0.1.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "react-router-dom": "^6.28.0"
+  },
+  "devDependencies": {
+    "@vitejs/plugin-react": "^4.3.4",
+    "vite": "^6.0.0"
+  }
+}

data/lib/templates/frontend/react/src/App.jsx

@@ -0,0 +1,14 @@
+import { BrowserRouter, Routes, Route } from 'react-router-dom'
+import Home from './pages/Home'
+
+function App() {
+  return (
+    <BrowserRouter>
+      <Routes>
+        <Route path="/" element={<Home />} />
+      </Routes>
+    </BrowserRouter>
+  )
+}
+
+export default App

data/lib/templates/frontend/react/src/index.css

@@ -0,0 +1,10 @@
+:root {
+  font-family: system-ui, -apple-system, sans-serif;
+  line-height: 1.5;
+  color: #213547;
+  background-color: #ffffff;
+}
+
+* { box-sizing: border-box; margin: 0; padding: 0; }
+
+body { min-height: 100vh; }

data/lib/templates/frontend/react/src/lib/apiClient.js.erb

@@ -0,0 +1,19 @@
+const API_URL = import.meta.env.VITE_API_URL || 'http://localhost:3000'
+
+export async function apiClient(path, options = {}) {
+  const { method = 'GET', body, headers = {} } = options
+
+  const config = {
+    method,
+    headers: { 'Content-Type': 'application/json', ...headers }
+  }
+
+  if (body) config.body = JSON.stringify(body)
+
+  const response = await fetch(`${API_URL}${path}`, config)
+  const data = await response.json()
+
+  if (!response.ok) throw new Error(data.error || `Request failed: ${response.status}`)
+
+  return data
+}

data/lib/templates/frontend/react/src/main.jsx

@@ -0,0 +1,10 @@
+import React from 'react'
+import ReactDOM from 'react-dom/client'
+import App from './App'
+import './index.css'
+
+ReactDOM.createRoot(document.getElementById('root')).render(
+  <React.StrictMode>
+    <App />
+  </React.StrictMode>
+)

data/lib/templates/frontend/react/src/pages/Home.jsx.erb

@@ -0,0 +1,10 @@
+function Home() {
+  return (
+    <main style={{ padding: '2rem', maxWidth: '800px', margin: '0 auto' }}>
+      <h1><%= @module_name %></h1>
+      <p>Your Belt app is running. Edit <code>src/pages/Home.jsx</code> to get started.</p>
+    </main>
+  )
+}
+
+export default Home

data/lib/templates/frontend/react/vite.config.js

@@ -0,0 +1,8 @@
+import { defineConfig } from 'vite'
+import react from '@vitejs/plugin-react'
+
+export default defineConfig({
+  plugins: [react()],
+  server: { port: 3000 },
+  build: { outDir: 'dist' }
+})