belt 0.3.4 → 0.3.6

data/lib/belt/cli/frontend_registry.rb

@@ -0,0 +1,373 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'yaml'
+
+module Belt
+  module CLI
+    # A named frontend application (SPA) in a Belt project.
+    #
+    # Belt apps historically used a single `frontend/` directory. Apps like
+    # Stowzilla have several (customer `app/`, ops `ops-app/`, …). This object
+    # is the per-frontend view of path, build output, and terraform outputs.
+    class Frontend
+      attr_reader :name, :dist, :bucket_output, :distribution_output,
+                  :url_output, :cloudfront_domain_output
+      attr_accessor :default, :path
+
+      # rubocop:disable Metrics/ParameterLists -- keyword options from YAML config
+      def initialize(name:, path:, dist: nil, bucket_output: nil, distribution_output: nil,
+                     url_output: nil, cloudfront_domain_output: nil, default: false)
+        @name = name.to_s
+        @path = path.to_s.sub(%r{/\z}, '')
+        @dist = dist
+        @default = default
+        @bucket_output = bucket_output || default_output('bucket_name')
+        @distribution_output_explicit = present_output?(distribution_output)
+        @distribution_output = @distribution_output_explicit ? distribution_output : default_output('distribution_id')
+        @url_output = url_output || default_output('url')
+        @cloudfront_domain_output = cloudfront_domain_output
+      end
+      # rubocop:enable Metrics/ParameterLists
+
+      def default?
+        @default
+      end
+
+      def distribution_output_explicit?
+        @distribution_output_explicit
+      end
+
+      def slug
+        self.class.slug(name)
+      end
+
+      def self.slug(name)
+        name.to_s.downcase.gsub(/[^a-z0-9]+/, '_').gsub(/\A_|_\z/, '')
+      end
+
+      # Terraform resource name: `frontend` for the default, `{slug}_frontend` otherwise.
+      def tf_name
+        slug == 'frontend' ? 'frontend' : "#{slug}_frontend"
+      end
+
+      def output_prefix
+        tf_name
+      end
+
+      def src_dir
+        File.join(path, 'src')
+      end
+
+      def package_json
+        File.join(path, 'package.json')
+      end
+
+      def app_jsx
+        File.join(src_dir, 'App.jsx')
+      end
+
+      def exists?
+        Dir.exist?(path) && File.file?(package_json)
+      end
+
+      # Build output directory. Explicit `dist:` wins; otherwise prefer `dist/`
+      # then `build/` (CRA / some Vite configs) then default `dist`.
+      def dist_dir
+        return File.join(path, @dist) if @dist && !@dist.to_s.empty?
+
+        %w[dist build].each do |dir|
+          candidate = File.join(path, dir)
+          return candidate if Dir.exist?(candidate)
+        end
+
+        File.join(path, 'dist')
+      end
+
+      def label
+        name == 'frontend' ? 'frontend' : "frontend '#{name}'"
+      end
+
+      def yaml_lines
+        lines = ["  #{name}:", "    path: #{path}"]
+        lines << "    dist: #{dist}" if dist && !dist.to_s.empty?
+        lines << '    default: true' if default?
+        lines << "    bucket_output: #{bucket_output}" if bucket_output != inferred_output('bucket_name')
+        if distribution_output != inferred_output('distribution_id')
+          lines << "    distribution_output: #{distribution_output}"
+        end
+        lines << "    url_output: #{url_output}" if url_output != inferred_output('url')
+        lines << "    cloudfront_domain_output: #{cloudfront_domain_output}" if cloudfront_domain_output
+        lines
+      end
+
+      def inferred_output(suffix)
+        slug == 'frontend' ? "frontend_#{suffix}" : "#{slug}_frontend_#{suffix}"
+      end
+      alias default_output inferred_output
+
+      def present_output?(value)
+        !(value.nil? || value.to_s.empty?)
+      end
+      private :inferred_output, :default_output, :present_output?
+    end
+
+    # Discovers and resolves frontends for CLI commands.
+    #
+    # Config (first match wins):
+    #   config/frontends.yml
+    #   config/frontends.yaml
+    #   .belt/frontends.yml
+    #   .belt/frontends.yaml
+    #
+    # If no config exists and `frontend/` is present, that directory is the
+    # single implicit frontend (backwards compatible).
+    #
+    # Example:
+    #
+    #   frontends:
+    #     customer:
+    #       path: app
+    #       dist: build
+    #       default: true
+    #       bucket_output: web_app_bucket_name
+    #       url_output: web_app_url
+    #       cloudfront_domain_output: web_app_cloudfront_domain
+    #     ops:
+    #       path: ops-app
+    #       dist: build
+    #       bucket_output: ops_app_bucket_name
+    #       url_output: ops_app_url
+    class FrontendRegistry
+      CONFIG_CANDIDATES = [
+        File.join('config', 'frontends.yml'),
+        File.join('config', 'frontends.yaml'),
+        File.join('.belt', 'frontends.yml'),
+        File.join('.belt', 'frontends.yaml')
+      ].freeze
+
+      WRITE_PATH = File.join('config', 'frontends.yml')
+
+      def self.find_config_path
+        CONFIG_CANDIDATES.find { |path| File.file?(path) }
+      end
+
+      # Pull `--flag VALUE` or `--flag=VALUE` out of args, mutating the array.
+      def self.extract_flag!(args, flag)
+        i = 0
+        while i < args.length
+          arg = args[i]
+          if arg == flag
+            args.delete_at(i)
+            return args.delete_at(i)
+          elsif arg.start_with?("#{flag}=")
+            args.delete_at(i)
+            return arg.split('=', 2).last
+          else
+            i += 1
+          end
+        end
+        nil
+      end
+
+      def self.load
+        new
+      end
+
+      # Add (or update) a frontend and persist config/frontends.yml.
+      def self.register!(name:, path:, default: nil)
+        registry = new
+        registry.add(name: name, path: path, default: default)
+        registry.write!
+      end
+
+      def initialize
+        @config_path = self.class.find_config_path
+        @frontends = load_frontends
+      end
+
+      def all
+        @frontends
+      end
+
+      def empty?
+        @frontends.empty?
+      end
+
+      def existing
+        @frontends.select(&:exists?)
+      end
+
+      def named(name)
+        return nil if name.nil? || name.to_s.empty?
+
+        key = name.to_s
+        slug = Frontend.slug(key)
+        @frontends.find { |fe| fe.name == key || fe.slug == slug }
+      end
+
+      # Default frontend: explicit `default: true`, otherwise the only one.
+      def default
+        @frontends.find(&:default?) || (@frontends.length == 1 ? @frontends.first : nil)
+      end
+
+      # Resolve a frontend for generate/server/auth. Aborts when ambiguous.
+      def resolve!(name = nil)
+        if name && !name.to_s.empty?
+          fe = named(name)
+          abort unknown_message(name) unless fe
+          return fe
+        end
+
+        fe = default
+        return fe if fe
+
+        abort empty_message if @frontends.empty?
+
+        abort multiple_message
+      end
+
+      def add(name:, path:, default: nil)
+        name = name.to_s
+        path = path.to_s.sub(%r{/\z}, '')
+        existing = named(name)
+
+        becomes_default = if !default.nil?
+                            default
+                          elsif existing
+                            existing.default?
+                          else
+                            @frontends.empty?
+                          end
+
+        @frontends.each { |fe| fe.default = false } if becomes_default
+
+        if existing
+          existing.default = becomes_default
+          existing.path = path
+        else
+          @frontends << Frontend.new(name: name, path: path, default: becomes_default)
+        end
+
+        named(name)
+      end
+
+      def write!
+        dest = @config_path || WRITE_PATH
+        FileUtils.mkdir_p(File.dirname(dest))
+        File.write(dest, dump_yaml)
+        @config_path = dest
+        dest
+      end
+
+      def unknown_message(name)
+        "Error: Unknown frontend '#{name}'. #{known_suffix}"
+      end
+
+      def multiple_message
+        "Error: Multiple frontends found (#{names.join(', ')}). " \
+          'Specify one with --frontend <name>.'
+      end
+
+      def empty_message
+        'Error: No frontend found. Run `belt generate frontend react` first, ' \
+          'or add config/frontends.yml.'
+      end
+
+      def names
+        @frontends.map(&:name)
+      end
+
+      private
+
+      def load_frontends
+        if @config_path
+          parsed = parse_config(@config_path)
+          return implicit_frontends if parsed.empty?
+
+          parsed
+        else
+          implicit_frontends
+        end
+      end
+
+      def implicit_frontends
+        return [] unless Dir.exist?('frontend')
+
+        [Frontend.new(name: 'frontend', path: 'frontend', default: true)]
+      end
+
+      def parse_config(path)
+        raw = YAML.safe_load_file(path, aliases: false)
+        return [] if raw.nil? || raw == false
+
+        abort "Error: #{path} must be a YAML mapping of frontend names." unless raw.is_a?(Hash)
+
+        entries = raw['frontends'].is_a?(Hash) ? raw['frontends'] : raw
+        unless entries.is_a?(Hash)
+          abort "Error: #{path} must map frontend names to settings " \
+                '(e.g. frontends: { customer: { path: app } }).'
+        end
+
+        entries.filter_map do |name, settings|
+          next if name.to_s == 'frontends' && settings.is_a?(Hash) && raw.key?('frontends')
+
+          attrs = normalize_settings(name, settings)
+          next unless attrs
+
+          Frontend.new(**attrs)
+        end
+      rescue Psych::SyntaxError => e
+        abort "Error: invalid YAML in #{path}: #{e.message}"
+      end
+
+      def normalize_settings(name, settings)
+        case settings
+        when Hash
+          {
+            name: name.to_s,
+            path: (settings['path'] || settings[:path] || name).to_s,
+            dist: settings['dist'] || settings[:dist],
+            default: truthy?(settings['default'] || settings[:default]),
+            bucket_output: settings['bucket_output'] || settings[:bucket_output],
+            distribution_output: settings['distribution_output'] || settings[:distribution_output],
+            url_output: settings['url_output'] || settings[:url_output],
+            cloudfront_domain_output: settings['cloudfront_domain_output'] ||
+              settings[:cloudfront_domain_output]
+          }
+        when String
+          { name: name.to_s, path: settings }
+        when nil
+          { name: name.to_s, path: name.to_s }
+        else
+          abort "Error: frontend '#{name}' in #{@config_path} must be a mapping " \
+                '(path:, dist:, …) or a directory path string.'
+        end
+      end
+
+      def truthy?(value)
+        value == true || value.to_s.downcase == 'true'
+      end
+
+      def dump_yaml
+        lines = [
+          '# Belt frontend registry',
+          '# Used by `belt deploy frontend`, generators, and `belt server`.',
+          '# See `belt explain frontend`.',
+          '',
+          'frontends:'
+        ]
+        @frontends.each { |fe| lines.concat(fe.yaml_lines) }
+        "#{lines.join("\n")}\n"
+      end
+
+      def known_suffix
+        if @frontends.empty?
+          'No frontends are configured.'
+        else
+          "Known frontends: #{names.join(', ')}"
+        end
+      end
+    end
+  end
+end

data/lib/belt/cli/frontend_setup_command.rb

@@ -4,6 +4,7 @@ require 'fileutils'
 require 'erb'
 require_relative 'app_detection'
 require_relative 'env_resolver'
+require_relative 'frontend_registry'
 
 module Belt
   module CLI
@@ -16,19 +17,61 @@ module Belt
       def self.run(args)
         # Environment arg is no longer needed since frontend.tf goes in the module,
         # but we still accept it for backwards compat (just ignore it).
+        name = FrontendRegistry.extract_flag!(args, '--name')
+        name ||= FrontendRegistry.extract_flag!(args, '--frontend')
         _env = EnvResolver.resolve(args)
-        new.run
+        frontend = name ? FrontendRegistry.new.resolve!(name) : nil
+        new(nil, frontend: frontend).run
       end
 
-      def initialize(_env = nil, quiet: false)
+      def self.append_env_outputs_for(frontend, outputs_file)
+        return unless File.exist?(outputs_file)
+        return if frontend.tf_name == 'frontend'
+
+        content = File.read(outputs_file)
+        prefix = frontend.output_prefix
+        return if content.include?("output \"#{prefix}_bucket_name\"")
+
+        File.write(outputs_file, content + extra_env_outputs(frontend))
+      end
+
+      def self.extra_env_outputs(frontend)
+        prefix = frontend.output_prefix
+        label = frontend.name
+        <<~HCL
+
+          output "#{prefix}_bucket_name" {
+            description = "S3 bucket for #{label} frontend assets"
+            value       = try(module.app.#{prefix}_bucket_name, "")
+          }
+
+          output "#{prefix}_distribution_id" {
+            description = "CloudFront distribution ID for #{label} frontend"
+            value       = try(module.app.#{prefix}_distribution_id, "")
+          }
+
+          output "#{prefix}_url" {
+            description = "#{label} frontend URL"
+            value       = try(module.app.#{prefix}_url, "")
+          }
+        HCL
+      end
+
+      def initialize(_env = nil, quiet: false, frontend: nil)
         @app_name = detect_app_name
         @quiet = quiet
+        @frontend = frontend || Frontend.new(name: 'frontend', path: 'frontend', default: true)
+        @tf_name = @frontend.tf_name
+        @output_prefix = @frontend.output_prefix
+        @include_dns = @frontend.slug == 'frontend'
+        @bucket_slug = @frontend.slug == 'frontend' ? 'frontend' : "#{@frontend.slug.tr('_', '-')}-frontend"
       end
 
       def run
         validate!
         generate_frontend_tf
         ensure_cloudfront_cors
+        append_env_outputs
         return if @quiet
 
         puts "\n✓ Frontend infrastructure generated in #{MODULE_DIR}!"
@@ -46,13 +89,24 @@ module Belt
       end
 
       def generate_frontend_tf
-        dest = File.join(MODULE_DIR, 'frontend.tf')
+        dest = File.join(MODULE_DIR, "#{@tf_name}.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 append_env_outputs
+        Dir.glob('infrastructure/*/outputs.tf').reject { |f| f.include?('modules') }.each do |file|
+          before = File.read(file)
+          self.class.append_env_outputs_for(@frontend, file)
+          next if File.read(file) == before
+
+          env_name = File.basename(File.dirname(file))
+          puts "  update  #{file} (#{@frontend.name} frontend outputs for #{env_name})" unless @quiet
+        end
+      end
+
       # Wire CloudFront origin into conveyor_belt frontend_urls so SPA→API CORS works.
       # Handles common scaffold shapes so users never need the tutorial's manual CORS fix.
       def ensure_cloudfront_cors
@@ -60,13 +114,25 @@ module Belt
         return unless File.exist?(main_tf)
 
         content = File.read(main_tf)
-        return if content.include?('aws_cloudfront_distribution.frontend.domain_name')
+        ref = "aws_cloudfront_distribution.#{@tf_name}.domain_name"
+        return if content.include?(ref)
+
+        cf_line = %(["https://${#{ref}}"])
+
+        # Already a concat of CloudFront origins — insert this distribution.
+        if content.match?(/frontend_urls\s*=\s*concat\(/) &&
+           content.include?('aws_cloudfront_distribution.')
+          content = content.sub(/(frontend_urls\s*=\s*concat\(\n)/, "\\1    #{cf_line},\n")
+          File.write(main_tf, content)
+          puts "  update  #{main_tf} (CloudFront CORS: #{@tf_name})" unless @quiet
+          return
+        end
 
         replacement = lambda do |indent|
           <<~TF.chomp
             #{indent}# CloudFront first so SPA→API CORS works out of the box.
             #{indent}frontend_urls = concat(
-            #{indent}  ["https://${aws_cloudfront_distribution.frontend.domain_name}"],
+            #{indent}  #{cf_line},
             #{indent}  var.frontend_urls
             #{indent})
           TF

data/lib/belt/cli/generate_command.rb

@@ -6,6 +6,7 @@ require_relative 'app_detection'
 require_relative 'auth_command'
 require_relative 'environment_command'
 require_relative 'frontend_command'
+require_relative 'frontend_registry'
 require_relative 'tables_command'
 require_relative 'views_command'
 require_relative 'generator_registry'
@@ -28,12 +29,14 @@ module Belt
           usage: 'belt generate scaffold <name> [field:type ...] [options]',
           options: [
             ['--skip-views', 'Skip generating frontend view pages'],
+            ['--frontend NAME', 'Target frontend when several exist'],
             ['--force, -f', 'Overwrite existing resource files (skip collision check)']
           ],
           examples: [
             ['belt g scaffold post title body:text'],
             ['belt g scaffold comment post:references body:text'],
             ['belt g scaffold task --skip-views'],
+            ['belt g scaffold bag --frontend ops'],
             ['belt g scaffold post title body:text --force']
           ],
           notes: <<~NOTES
@@ -44,7 +47,7 @@ module Belt
               config/contracts.rb                                API response contract added
               lambda/lib/routes/<app>_routes.rb                  Route manifest updated
               infrastructure/modules/app/dynamodb.tf             DynamoDB table generated
-              frontend/src/pages/<names>/                        React pages (if frontend exists)
+              <frontend>/src/pages/<names>/                      React pages (if a frontend exists)
 
             Nested Resources:
               Use `<parent>:references` to create a nested resource. This will:
@@ -142,8 +145,10 @@ module Belt
 
         force = args.delete('--force') || args.delete('-f')
         skip_views = args.delete('--skip-views')
+        frontend_name = FrontendRegistry.extract_flag!(args, '--frontend')
         fields = args.map { |arg| parse_field(arg) }
-        new(generator, name, fields, skip_views: skip_views, force: force).generate
+        new(generator, name, fields, skip_views: skip_views, force: force,
+                                     frontend_name: frontend_name).generate
       end
 
       def self.parse_field(arg)
@@ -200,7 +205,7 @@ module Belt
             controller    Generate a controller
             auth          Generate Cognito user pool infrastructure
             environment   Create a new deployment environment
-            frontend      Scaffold a frontend app (react, vue, svelte)
+            frontend      Scaffold a frontend app (react, vue, svelte; --name / --path for extras)
             views         Generate React pages for a resource
 
           Aliases:
@@ -228,7 +233,9 @@ module Belt
             belt g controller comments
             belt g environment staging
             belt g frontend react
+            belt g frontend react --name ops --path ops-app
             belt g views post title body:text
+            belt g views bag --frontend ops
 
           Run 'belt generate <generator> --help' for detailed help on a specific generator.
         HELP
@@ -271,12 +278,14 @@ module Belt
         puts "\n#{info[:notes]}" if info[:notes]
       end
 
-      def initialize(generator, name, fields, skip_views: false, force: false)
+      # rubocop:disable Metrics/ParameterLists -- keyword options for generator flags
+      def initialize(generator, name, fields, skip_views: false, force: false, frontend_name: nil)
         @generator = generator
         @name = name.downcase.gsub(/[^a-z0-9_]/, '_')
         @fields = fields
         @skip_views = skip_views
         @force = force
+        @frontend_name = frontend_name
         @app_name = detect_namespace
         @module_name = @app_name.split(/[-_]/).map(&:capitalize).join
         @singular_name = Belt::Inflector.singularize(@name)
@@ -284,6 +293,7 @@ module Belt
         @class_name = Belt::Inflector.classify(@singular_name)
         @references, @regular_fields = @fields.partition { |f| f[:type] == 'references' }
       end
+      # rubocop:enable Metrics/ParameterLists
 
       def generate
         case @generator
@@ -629,10 +639,15 @@ module Belt
       end
 
       def generate_views_if_frontend
-        return unless Dir.exist?('frontend/src')
         return if @skip_views
 
-        Belt::CLI::ViewsCommand.new(@name, @fields, force: @force, quiet: true).generate
+        registry = FrontendRegistry.new
+        return if registry.empty?
+
+        frontend = registry.resolve!(@frontend_name)
+        return unless Dir.exist?(frontend.src_dir)
+
+        Belt::CLI::ViewsCommand.new(@name, @fields, force: @force, quiet: true, frontend: frontend).generate
       end
     end
   end