Class: Belt::CLI::GenerateCommand

Inherits:

Object

• Object
• Belt::CLI::GenerateCommand

Includes:

AppDetection

Defined in:

lib/belt/cli/generate_command.rb

Constant Summary

TEMPLATE_DIR =

File.expand_path('../../templates/generate', __dir__)

GENERATORS =

%w[scaffold resource model controller environment frontend views index auth dns].freeze

FIELD_TYPES =

%w[string text integer float boolean date datetime references].freeze

GENERATOR_HELP =

{
  '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'],
      ['--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
      Creates:
        lambda/models/<name>.rb                            Model with validations and fields
        lambda/controllers/<app>/<names>_controller.rb    RESTful controller (index, show, create, update, destroy)
        config/routes.rb                                   Route entry added
        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 a frontend exists)

      Nested Resources:
        Use `<parent>:references` to create a nested resource. This will:
        - Add `belongs_to :<parent>` in the child model
        - Add `has_many :<children>` in the parent model (if it exists)
        - Generate a GSI on `<parent>_id` for efficient queries
        - Nest routes under the parent (e.g., /posts/{post_id}/comments)
        - Scope the controller index action to the parent

        Example: `belt g scaffold comment post:references body:text`

      Alias: `belt g resource` works the same way.
    NOTES
  },
  'model' => {
    description: 'Generate an ActiveItem model with validations and DynamoDB field definitions.',
    usage: 'belt generate model <name> [field:type ...] [options]',
    options: [
      ['--force, -f', 'Overwrite existing model files (skip collision check)']
    ],
    examples: [
      ['belt g model user email name'],
      ['belt g model event title starts_at:datetime']
    ],
    notes: <<~NOTES
      Creates:
        lambda/models/<name>.rb                            Model class inheriting from ApplicationRecord
        config/contracts.rb                                API response contract added
        infrastructure/modules/app/dynamodb.tf             DynamoDB table generated
    NOTES
  },
  'controller' => {
    description: 'Generate a controller with standard REST actions.',
    usage: 'belt generate controller <name>',
    options: [],
    examples: [
      ['belt g controller posts'],
      ['belt g controller admin/users']
    ],
    notes: <<~NOTES
      Creates:
        lambda/controllers/<app>/<name>_controller.rb    Controller class
    NOTES
  },
  'dns' => {
    description: 'Generate infrastructure for managing root domain DNS with multi-environment delegation.',
    usage: 'belt generate dns',
    options: [],
    examples: [
      ['belt g dns']
    ],
    notes: <<~NOTES
      Creates:
        infrastructure/dns/                              Root DNS zone infrastructure
        infrastructure/dns/belt.rb                       AWS profile configuration

      This enables multiple environments (dev, staging, prod) to each have their own
      hosted zone while sharing a single domain. The root zone delegates subdomains
      to per-environment zones.

      Workflow:
        1. Deploy environments first: belt deploy dev, belt deploy staging
        2. Add NS records: belt dns add dev, belt dns add staging
        3. Deploy: belt dns deploy
        4. Update your registrar's NS records to the root_name_servers output

      For multi-account setups where DNS lives in a shared account:
        Edit infrastructure/dns/belt.rb to set the AWS profile.
    NOTES
  }
}.freeze

RESERVED_NAMES =

%w[
  help new edit create update destroy index show delete remove
  application base controller model resource generate
  belt setup environment frontend views routes
].freeze

Class Method Summary

• .all_generator_names ⇒ Object
• .parse_field(arg) ⇒ Object
• .print_generate_help ⇒ Object
• .print_generator_help(generator) ⇒ Object
• .run(args) ⇒ Object
• .validate_resource_name!(name, generator) ⇒ Object

Instance Method Summary

• #generate ⇒ Object
• #initialize(generator, name, fields, skip_views: false, force: false, frontend_name: nil) ⇒ GenerateCommand constructor

  -- keyword options for generator flags.

Methods included from AppDetection

#detect_app_name, #detect_environments, #detect_namespace, #find_contracts_file_path, #find_routes_file_path, #find_schema_file_path, #s3_safe_name

Constructor Details

#initialize(generator, name, fields, skip_views: false, force: false, frontend_name: nil) ⇒ GenerateCommand

-- keyword options for generator flags

# File 'lib/belt/cli/generate_command.rb', line 312

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)
  @resource_name = Belt::Inflector.pluralize(@singular_name)
  @class_name = Belt::Inflector.classify(@singular_name)
  @references, @regular_fields = @fields.partition { |f| f[:type] == 'references' }
end

Class Method Details

.all_generator_names ⇒ Object

# File 'lib/belt/cli/generate_command.rb', line 200

def self.all_generator_names
  ((GENERATORS - ['resource']) + GeneratorRegistry.generator_names).uniq
end

.parse_field(arg) ⇒ Object

# File 'lib/belt/cli/generate_command.rb', line 183

def self.parse_field(arg)
  name, type = arg.split(':', 2)
  type ||= 'string'

  if %w[references belongs_to].include?(type)
    { name: name, type: 'references', referenced_model: name }
  else
    { name: name, type: type }
  end
end

.print_generate_help ⇒ Object

# File 'lib/belt/cli/generate_command.rb', line 224

def self.print_generate_help
  gem_generators = GeneratorRegistry.discovered_generators

  puts <<~HELP
    Usage: belt generate <generator> <name> [field:type ...] [options]
           belt g <generator> <name> [field:type ...] [options]

    Generators:
      scaffold      Generate model, controller, routes, schema, and views (full REST resource)
      model         Generate an ActiveItem model
      controller    Generate a controller
      auth          Generate Cognito user pool infrastructure
      environment   Create a new deployment environment
      dns           Generate root DNS zone with multi-environment delegation
      frontend      Scaffold a frontend app (react, vue, svelte; --name / --path for extras)
      views         Generate React pages for a resource

    Aliases:
      resource      Same as scaffold

  HELP

  if gem_generators.any?
    puts '  Gem Generators:'
    gem_generators.each do |name, klass|
      desc = klass.respond_to?(:description) ? klass.description : "Generate #{name} (from gem)"
      puts format('    %<name>-14s %<desc>s', name: name, desc: desc)
    end
    puts
  end

  puts <<~HELP
    Field Types:
      #{FIELD_TYPES.join(', ')}
      (defaults to string if omitted)

    Examples:
      belt g scaffold post title body:text status
      belt g model user email name
      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
end

.print_generator_help(generator) ⇒ Object

# File 'lib/belt/cli/generate_command.rb', line 274

def self.print_generator_help(generator)
  info = GENERATOR_HELP[generator]

  unless info
    puts "Usage: belt generate #{generator} <name>"
    puts "\nRun 'belt generate #{generator} --help' is not yet documented."
    puts "Try 'belt generate --help' for the full list of generators."
    return
  end

  puts info[:description]
  puts
  puts "Usage: #{info[:usage]}"

  if info[:options].any?
    puts "\nOptions:"
    info[:options].each do |flag, desc|
      puts format('  %<flag>-20s %<desc>s', flag: flag, desc: desc)
    end
  end

  puts "\nField Types:"
  puts "  #{FIELD_TYPES.join(', ')}"
  puts '  (defaults to string if omitted)'

  puts "\nExamples:"
  info[:examples].each do |cmd, desc|
    if desc
      puts "  #{cmd}  — #{desc}"
    else
      puts "  #{cmd}"
    end
  end

  puts "\n#{info[:notes]}" if info[:notes]
end

.run(args) ⇒ Object

# File 'lib/belt/cli/generate_command.rb', line 124

def self.run(args)
  generator = args.shift

  # Top-level help: belt generate --help or belt generate (no args)
  if generator.nil? || generator =~ /\A-/
    print_generate_help
    exit 0
  end

  unless GENERATORS.include?(generator) || GeneratorRegistry.generator_names.include?(generator)
    puts "Unknown generator: '#{generator}'"
    puts "Available generators: #{all_generator_names.join(', ')}"
    puts "\nRun 'belt generate --help' for usage information."
    exit 1
  end

  # Delegate to gem-provided generator if not a built-in
  unless GENERATORS.include?(generator)
    klass = GeneratorRegistry.find(generator)
    return klass.run(args)
  end

  # 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
  end

  return Belt::CLI::EnvironmentCommand.run(args) if generator == 'environment'

  return Belt::CLI::DnsCommand.new.generate if generator == 'dns'

  return Belt::CLI::FrontendCommand.run(args) if generator == 'frontend'

  return Belt::CLI::ViewsCommand.run(args) if generator == 'views'

  return Belt::CLI::IndexCommand.run(['add'] + args) if generator == 'index'

  return Belt::CLI::AuthCommand.run(args) if generator == 'auth'

  name = args.shift
  if name.nil? || name.empty?
    print_generator_help(generator)
    exit 0
  end

  validate_resource_name!(name, generator)

  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,
                               frontend_name: frontend_name).generate
end

.validate_resource_name!(name, generator) ⇒ Object

# File 'lib/belt/cli/generate_command.rb', line 204

def self.validate_resource_name!(name, generator)
  errors = []

  errors << 'must start with a letter' unless name.match?(/\A[a-zA-Z]/)
  errors << 'must be at least 2 characters' if name.length < 2
  errors << 'must only contain letters, numbers, and underscores' unless name.match?(/\A[a-zA-Z][a-zA-Z0-9_]*\z/)
  errors << 'must not start or end with an underscore' if name.match?(/\A_|_\z/)
  errors << 'must not contain consecutive underscores' if name.include?('__')
  errors << 'is a reserved name' if RESERVED_NAMES.include?(Belt::Inflector.singularize(name.downcase))
  errors << 'is a reserved name' if RESERVED_NAMES.include?(name.downcase)

  return if errors.empty?

  puts "\n✗ Invalid #{generator} name '#{name}':"
  errors.uniq.each { |e| puts "  - #{e}" }
  puts "\nName must start with a letter, be at least 2 characters, " \
       'and contain only letters, numbers, and single underscores.'
  exit 1
end

Instance Method Details

#generate ⇒ Object

# File 'lib/belt/cli/generate_command.rb', line 327

def generate
  case @generator
  when 'scaffold'
    check_resource_collision! unless @force
    generate_resource
  when 'model'
    check_model_collision! unless @force
    generate_model_standalone
  when 'controller'
    generate_controller
    inject_routes
  end
end