belt 0.2.12 → 0.2.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 10e92ad2ab3fe79f48f07cca6495ce8b9ccdad09755c7a6517e651deadcc118d
-  data.tar.gz: 6cd8a8ee7ad1023fb949183122c3aca465c216cf91d175e8f9395e8f413ad880
+  metadata.gz: 43bc6e6cb774005faa3bab6b5133403255636327e3dd017ad4acad8fd9a2c884
+  data.tar.gz: fe11f89e1efa821750dea2953c70bbc21fe24bea394d418c2b870a2804adf331
 SHA512:
-  metadata.gz: cb7d5dacc2b90e0ae7c4dd9853d76ea42ef8d6e324d30edd91c5fbe6d934affafd2c3bee6fb752960d9c8462a59663244ae448797ab7e57de7ad05c50afa627f
-  data.tar.gz: fd7f4ff9af68c36b34c02c2f4af2c42649f0e9494ac192eaaefeae3111e0da81ced4091b88510b82ac183fefaadfd0677e4d34f270e16a7dcf389b54259e8c52
+  metadata.gz: d5c4900624a6435b178455b5aa7e6f34c08d7c2e75e2d1ec3c1b69e717a5964a390ba59a4ff8ccad1be797d29273bddc4354c235f83070d00bb7517d60bcb38e
+  data.tar.gz: a47bc3063743a278e4241faf65c510ede23ec922c167469f2654627f3079bb558893194f717979002354e07153e41cee257785e8b0f7dea187fc391fb351e5f3

data/CHANGELOG.md

@@ -31,7 +31,17 @@ Previously, contracts were only accessible as a side-effect of `belt routes -f j
 - Module template updated: `source` points to `config/routes.rb`
 - All scaffold/generator help text and templates reference new filenames
 
-## Unreleased
+## 0.2.13
+
+### Template cleanup
+
+- **Model template**: single-line `attr_accessor` instead of one per attribute; removed redundant `to_h` (ActiveItem::Base already provides it)
+- **Controller template**: uses implicit response pattern (instance variable assigns) instead of explicit `success_response` calls; `response_status :created` for create actions, `head :no_content` for destroy
+- **Gemfile template**: removed `activeitem` and `lambda_loadout` (already belt gem dependencies)
+- **gitignore template**: excludes `lambda/lib/routes/` (generated artifact from `belt routes`)
+- **Removed `require 'activeitem'`** from api.rb, environment.rb, and application_record.rb templates (belt requires it transitively)
+- **Removed `ActiveItem.configure` boilerplate** from api.rb and environment.rb templates (activeitem 0.0.13+ defaults `table_prefix` and `environment` from ENV vars)
+- Bumped activeitem dependency to `>= 0.0.13`
 
 ## 0.2.11
 

data/lib/belt/cli/frontend_command.rb

@@ -59,6 +59,7 @@ module Belt
 
         install_dependencies(dest_dir)
         setup_frontend_infra_for_existing_environments
+        generate_views_for_existing_resources
 
         return if @quiet || !@announce
 
@@ -104,6 +105,28 @@ module Belt
         puts "  create  #{frontend_tf}" unless @quiet
       end
 
+      def generate_views_for_existing_resources
+        routes_file = find_routes_file_path
+        return unless routes_file && File.exist?(routes_file)
+
+        resources = extract_resources_from_routes(routes_file)
+        return if resources.empty?
+
+        puts "\n  Detected existing resources: #{resources.join(', ')}" unless @quiet
+        puts '  Generating views...' unless @quiet
+
+        require_relative 'views_command'
+        resources.each do |resource_name|
+          fields = ViewsCommand.read_schema_fields(resource_name)
+          ViewsCommand.new(resource_name, fields, force: true).generate
+        end
+      end
+
+      def extract_resources_from_routes(routes_file)
+        content = File.read(routes_file)
+        content.scan(/resources\s+:(\w+)/).flatten.uniq
+      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/generate_command.rb

@@ -478,14 +478,16 @@ module Belt
         puts "  update  #{schema_file}"
       end
 
-      # Map generator field types to OpenAPI schema DSL types
+      # Map generator field types to schema DSL types.
+      # Preserves :text, :date, :datetime so views can render appropriate form inputs.
       def schema_type_for(field_type)
         case field_type.to_s
-        when 'text' then 'string'
+        when 'text' then 'text'
         when 'integer' then 'integer'
         when 'float' then 'number'
         when 'boolean' then 'boolean'
-        when 'date', 'datetime' then 'string'
+        when 'date' then 'date'
+        when 'datetime' then 'datetime'
         else 'string'
         end
       end
@@ -505,7 +507,7 @@ module Belt
         return unless Dir.exist?('frontend/src')
         return if @skip_views
 
-        Belt::CLI::ViewsCommand.new(@name, @fields).generate
+        Belt::CLI::ViewsCommand.new(@name, @fields, force: @force).generate
       end
     end
   end

data/lib/belt/cli/logs_command.rb

@@ -0,0 +1,634 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'open3'
+
+module Belt
+  module CLI
+    class LogsCommand
+      include AppDetection
+
+      COLORS = {
+        red: "\e[0;31m",
+        green: "\e[0;32m",
+        yellow: "\e[0;33m",
+        blue: "\e[0;34m",
+        magenta: "\e[0;35m",
+        cyan: "\e[0;36m",
+        gray: "\e[0;90m",
+        bold: "\e[1m",
+        dim: "\e[2m",
+        reset: "\e[0m"
+      }.freeze
+
+      def self.run(args)
+        if args.include?('--help') || args.include?('-h')
+          puts usage
+          exit 0
+        end
+
+        new(args).run
+      end
+
+      def self.usage
+        <<~USAGE
+          Usage: belt logs [lambda] [options]
+
+          View Lambda function logs. Without arguments, tails all Lambdas for the current environment.
+
+          Arguments:
+            lambda              Lambda function short name (e.g., api, worker). Optional — shows all if omitted.
+
+          Options:
+            -e, --env ENV       Environment (default: BELT_ENV or first detected)
+            -f, --follow        Follow logs in real-time
+            -s, --since PERIOD  Time range (default: 5m). Examples: 5m, 30m, 1h, 2h
+            -l, --level LEVEL   Minimum log level: DEBUG, INFO, WARN, ERROR (default: INFO)
+            --error             Show only the most recent error and exit
+            --raw               Show raw JSON logs without formatting
+            --no-color          Disable colorized output
+            -h, --help          Show this help
+
+          Examples:
+            belt logs                    # Last 5m of all lambdas (current env)
+            belt logs api                # Last 5m of api lambda
+            belt logs api -f             # Follow api lambda logs
+            belt logs -e prod            # Last 5m of all lambdas in prod
+            belt logs api -s 30m         # Last 30 minutes
+            belt logs --error            # Show most recent error across all lambdas
+            belt logs api --error        # Show most recent error for api lambda
+        USAGE
+      end
+
+      def initialize(args)
+        @lambda_name = nil
+        @env = nil
+        @follow = false
+        @since = '5m'
+        @level = 'INFO'
+        @error_mode = false
+        @raw = false
+        @color = $stdout.tty?
+        parse_args(args)
+      end
+
+      def run
+        @env ||= detect_environment
+        abort 'Error: Cannot determine environment. Pass -e ENV or set BELT_ENV.' unless @env
+
+        @app_name = detect_app_name
+        abort 'Error: Cannot determine app name.' unless @app_name
+
+        if @lambda_name
+          tail_single(@lambda_name)
+        else
+          tail_all
+        end
+      end
+
+      private
+
+      def parse_args(args)
+        i = 0
+        while i < args.length
+          case args[i]
+          when '-e', '--env'
+            @env = args[i + 1]
+            i += 2
+          when '-f', '--follow'
+            @follow = true
+            i += 1
+          when '-s', '--since'
+            @since = args[i + 1]
+            i += 2
+          when '-l', '--level'
+            @level = args[i + 1]&.upcase
+            i += 2
+          when '--error'
+            @error_mode = true
+            i += 1
+          when '--raw'
+            @raw = true
+            i += 1
+          when '--no-color'
+            @color = false
+            i += 1
+          else
+            @lambda_name = args[i] unless args[i].start_with?('-')
+            i += 1
+          end
+        end
+      end
+
+      def detect_environment
+        ENV.fetch('BELT_ENV', nil) || detect_environments.first
+      end
+
+      def tail_single(lambda_name)
+        log_group = log_group_for(lambda_name)
+
+        unless log_group_exists?(log_group)
+          abort "#{c(:red)}✗ No log group found: #{log_group}#{c(:reset)}\n  " \
+                'The Lambda may not have been deployed yet.'
+        end
+
+        if @error_mode
+          find_recent_error(log_group, lambda_name)
+        elsif @follow
+          follow_logs(log_group, lambda_name)
+        else
+          fetch_historical(log_group, lambda_name)
+        end
+      end
+
+      def tail_all
+        lambdas = discover_lambda_names
+        if lambdas.empty?
+          abort "#{c(:red)}✗ No Lambda functions found for #{@app_name}-#{@env}#{c(:reset)}\n  " \
+                "Deploy with `belt deploy #{@env}` first, or specify a lambda name: `belt logs api`"
+        end
+
+        if @error_mode
+          find_errors_across(lambdas)
+        elsif @follow
+          follow_all(lambdas)
+        else
+          fetch_all_historical(lambdas)
+        end
+      end
+
+      def discover_lambda_names
+        names = lambda_names_from_terraform
+        return names if names.any?
+
+        lambda_names_from_log_groups
+      end
+
+      def lambda_names_from_terraform
+        infra_dir = find_infra_dir
+        env_dir = infra_dir ? File.join(infra_dir, @env) : nil
+        return [] unless env_dir && Dir.exist?(File.join(env_dir, '.terraform'))
+
+        Dir.chdir(env_dir) do
+          output, status = Open3.capture2('terraform', 'output', '-json')
+          return [] unless status.success?
+
+          data = begin
+            JSON.parse(output)
+          rescue JSON::ParserError
+            {}
+          end
+
+          if data['lambda_functions']
+            funcs = data['lambda_functions']['value']
+            if funcs.is_a?(Hash)
+              return funcs.keys
+            elsif funcs.is_a?(Array)
+              return funcs.map { |f| f.is_a?(String) ? f.split('-').last : nil }.compact
+            end
+          end
+
+          data.keys.grep(/_function_name$/).map { |k| data[k]['value']&.split('-')&.last }.compact
+        end
+      rescue StandardError
+        []
+      end
+
+      def lambda_names_from_log_groups
+        prefix = "/aws/lambda/#{@app_name}-#{@env}-"
+        output, status = Open3.capture2(
+          'aws', 'logs', 'describe-log-groups',
+          '--log-group-name-prefix', prefix,
+          '--query', 'logGroups[].logGroupName',
+          '--output', 'json'
+        )
+        return [] unless status.success?
+
+        groups = begin
+          JSON.parse(output)
+        rescue JSON::ParserError
+          []
+        end
+        groups.map { |g| g.sub(prefix, '') }
+      end
+
+      def log_group_for(lambda_name)
+        "/aws/lambda/#{@app_name}-#{@env}-#{lambda_name}"
+      end
+
+      def log_group_exists?(log_group)
+        _, status = Open3.capture2(
+          'aws', 'logs', 'describe-log-groups',
+          '--log-group-name-prefix', log_group,
+          '--query', "logGroups[?logGroupName=='#{log_group}'].logGroupName",
+          '--output', 'text'
+        )
+        status.success?
+      end
+
+      def follow_logs(log_group, lambda_name)
+        print_header(lambda_name)
+        puts "#{c(:yellow)}Following logs (Ctrl+C to stop)...#{c(:reset)}\n\n"
+
+        cmd = ['aws', 'logs', 'tail', log_group, '--follow', '--format', 'short']
+        IO.popen(cmd, err: %i[child out]) do |io|
+          io.each_line { |line| process_tail_line(line) }
+        end
+      rescue Interrupt
+        puts "\n#{c(:dim)}Stopped.#{c(:reset)}"
+      end
+
+      def follow_all(lambdas)
+        puts "#{c(:cyan)}═══════════════════════════════════════════════════════════════#{c(:reset)}"
+        puts "#{c(:bold)}Lambda Logs: #{c(:magenta)}#{@app_name}-#{@env}#{c(:reset)} (#{lambdas.join(', ')})"
+        puts "#{c(:cyan)}═══════════════════════════════════════════════════════════════#{c(:reset)}"
+        puts "#{c(:yellow)}Following logs (Ctrl+C to stop)...#{c(:reset)}\n\n"
+
+        threads = lambdas.map do |name|
+          log_group = log_group_for(name)
+          Thread.new do
+            cmd = ['aws', 'logs', 'tail', log_group, '--follow', '--format', 'short']
+            IO.popen(cmd, err: %i[child out]) do |io|
+              io.each_line { |line| process_tail_line(line, prefix: name) }
+            end
+          rescue StandardError
+            nil
+          end
+        end
+
+        threads.each(&:join)
+      rescue Interrupt
+        puts "\n#{c(:dim)}Stopped.#{c(:reset)}"
+      end
+
+      def fetch_historical(log_group, lambda_name)
+        print_header(lambda_name)
+        puts "#{c(:dim)}Fetching last #{@since} of logs...#{c(:reset)}\n\n"
+
+        events = fetch_log_events(log_group)
+        if events.empty?
+          puts "#{c(:yellow)}No logs found in the last #{@since}#{c(:reset)}"
+          return
+        end
+
+        puts "#{c(:dim)}Found #{events.length} log events#{c(:reset)}\n\n"
+        events.each { |event| process_event(event) }
+
+        puts "\n#{c(:cyan)}═══════════════════════════════════════════════════════════════#{c(:reset)}"
+        puts "#{c(:dim)}Tip: Use -f to follow logs in real-time#{c(:reset)}"
+      end
+
+      def fetch_all_historical(lambdas)
+        puts "#{c(:cyan)}═══════════════════════════════════════════════════════════════#{c(:reset)}"
+        puts "#{c(:bold)}Lambda Logs: #{c(:magenta)}#{@app_name}-#{@env}#{c(:reset)} (#{lambdas.join(', ')})"
+        puts "#{c(:cyan)}═══════════════════════════════════════════════════════════════#{c(:reset)}"
+        puts "#{c(:dim)}Fetching last #{@since} of logs...#{c(:reset)}\n\n"
+
+        all_events = []
+        lambdas.each do |name|
+          log_group = log_group_for(name)
+          events = fetch_log_events(log_group)
+          events.each { |e| e['_lambda'] = name }
+          all_events.concat(events)
+        end
+
+        all_events.sort_by! { |e| e['timestamp'] || 0 }
+
+        if all_events.empty?
+          puts "#{c(:yellow)}No logs found in the last #{@since}#{c(:reset)}"
+          return
+        end
+
+        puts "#{c(:dim)}Found #{all_events.length} log events#{c(:reset)}\n\n"
+        all_events.each { |event| process_event(event, prefix: event['_lambda']) }
+
+        puts "\n#{c(:cyan)}═══════════════════════════════════════════════════════════════#{c(:reset)}"
+        puts "#{c(:dim)}Tip: Use -f to follow logs in real-time#{c(:reset)}"
+      end
+
+      def find_recent_error(log_group, lambda_name)
+        events = fetch_log_events(log_group, since: '30m', limit: 500)
+        error = find_error_in_events(events)
+
+        if error
+          puts "#{c(:bold)}Most recent error in #{c(:magenta)}#{lambda_name}#{c(:reset)}:\n\n"
+          format_error_event(error)
+        else
+          puts "#{c(:green)}✓ No errors found in the last 30 minutes for #{lambda_name}#{c(:reset)}"
+        end
+      end
+
+      def find_errors_across(lambdas)
+        latest_error = nil
+        latest_lambda = nil
+
+        lambdas.each do |name|
+          log_group = log_group_for(name)
+          events = fetch_log_events(log_group, since: '30m', limit: 500)
+          error = find_error_in_events(events)
+          next unless error
+
+          if latest_error.nil? || (error['timestamp'] || 0) > (latest_error['timestamp'] || 0)
+            latest_error = error
+            latest_lambda = name
+          end
+        end
+
+        if latest_error
+          puts "#{c(:bold)}Most recent error in #{c(:magenta)}#{latest_lambda}#{c(:reset)}:\n\n"
+          format_error_event(latest_error)
+        else
+          puts "#{c(:green)}✓ No errors found in the last 30 minutes#{c(:reset)}"
+        end
+      end
+
+      def find_error_in_events(events)
+        events.reverse_each do |event|
+          msg = event['message'] || ''
+          json = parse_json(msg)
+          next unless json
+
+          return event if json['errorMessage'] && json['errorType'] && json['stackTrace']
+          return event if json['level'] == 'ERROR'
+          return event if json['status_code'].to_i >= 500
+        end
+        nil
+      end
+
+      def format_error_event(event)
+        msg = event['message'] || ''
+        json = parse_json(msg)
+        return puts(msg) unless json
+
+        timestamp = format_timestamp(event['timestamp'])
+
+        if json['errorMessage'] && json['errorType']
+          format_init_error(json, timestamp)
+        else
+          format_structured_log(json, timestamp)
+        end
+      end
+
+      def format_init_error(json, timestamp)
+        puts "#{c(:gray)}#{timestamp}#{c(:reset)} #{c(:red)}#{c(:bold)}INIT ERROR#{c(:reset)}"
+        puts "  #{c(:dim)}Type:#{c(:reset)}    #{c(:red)}#{json['errorType']}#{c(:reset)}"
+        puts "  #{c(:dim)}Message:#{c(:reset)} #{json['errorMessage']}"
+        return unless json['stackTrace'].is_a?(Array)
+
+        puts "  #{c(:dim)}Stack:#{c(:reset)}"
+        json['stackTrace'].first(15).each do |line|
+          if line.match?(%r{(controllers|models|lib|helpers)/})
+            puts "    #{c(:yellow)}→#{c(:reset)} #{line}"
+          elsif line.include?('/var/task/')
+            puts "    #{c(:cyan)}→#{c(:reset)} #{line}"
+          else
+            puts "    #{c(:gray)}  #{line}#{c(:reset)}"
+          end
+        end
+      end
+
+      def fetch_log_events(log_group, since: @since, limit: 1000)
+        duration_ms = parse_since(since)
+        start_time = (Time.now.to_i * 1000) - duration_ms
+
+        output, status = Open3.capture2(
+          'aws', 'logs', 'filter-log-events',
+          '--log-group-name', log_group,
+          '--start-time', start_time.to_s,
+          '--limit', limit.to_s,
+          '--output', 'json'
+        )
+        return [] unless status.success?
+
+        data = begin
+          JSON.parse(output)
+        rescue JSON::ParserError
+          {}
+        end
+        data['events'] || []
+      end
+
+      def process_tail_line(line, prefix: nil)
+        return if line.match?(/\b(START|END|REPORT|INIT_START|INIT_REPORT)\s/)
+        return if line.include?('[LambdaLoadout') || line.include?('"_aws":')
+
+        if line.include?('Critical exception from handler')
+          prefix_str = prefix ? "#{c(:blue)}[#{prefix}]#{c(:reset)} " : ''
+          puts "#{prefix_str}#{c(:red)}#{c(:bold)}CRITICAL EXCEPTION#{c(:reset)}"
+          return
+        end
+
+        json_part = line.sub(/\A[\dT:.+\-Z ]+\s*/, '').strip
+        json = parse_json(json_part)
+
+        if json
+          if json['errorMessage'] && json['errorType'] && json['stackTrace']
+            format_aws_error(json, prefix: prefix)
+          elsif @raw
+            puts json_part
+          else
+            timestamp = extract_time_from_line(line)
+            format_structured_log(json, timestamp, prefix: prefix)
+          end
+        elsif line.strip.length.positive?
+          prefix_str = prefix ? "#{c(:blue)}[#{prefix}]#{c(:reset)} " : ''
+          puts "#{prefix_str}#{c(:gray)}#{line.strip}#{c(:reset)}"
+        end
+      end
+
+      def process_event(event, prefix: nil)
+        msg = event['message'] || ''
+
+        return if msg.match?(/\A(START|END|REPORT|INIT_START|INIT_REPORT)\s/)
+        return if msg.include?('[LambdaLoadout') || msg.include?('"_aws":')
+
+        if msg.include?('Critical exception from handler')
+          prefix_str = prefix ? "#{c(:blue)}[#{prefix}]#{c(:reset)} " : ''
+          puts "#{prefix_str}#{c(:red)}#{c(:bold)}CRITICAL EXCEPTION#{c(:reset)}"
+          return
+        end
+
+        json = parse_json(msg)
+        timestamp = format_timestamp(event['timestamp'])
+
+        if json
+          if json['errorMessage'] && json['errorType'] && json['stackTrace']
+            format_aws_error(json, prefix: prefix)
+          elsif @raw
+            puts JSON.pretty_generate(json)
+          else
+            format_structured_log(json, timestamp, prefix: prefix)
+          end
+        elsif msg.strip.length.positive?
+          prefix_str = prefix ? "#{c(:blue)}[#{prefix}]#{c(:reset)} " : ''
+          puts "#{prefix_str}#{c(:gray)}#{msg.strip}#{c(:reset)}"
+        end
+      end
+
+      def format_structured_log(json, timestamp, prefix: nil)
+        level = json['level']
+        message = json['message'] || ''
+
+        return unless should_show_level?(level)
+
+        prefix_str = prefix ? "#{c(:blue)}[#{prefix}]#{c(:reset)} " : ''
+
+        case level
+        when 'ERROR'
+          format_error_log(json, message, timestamp, prefix_str)
+        when 'WARN'
+          format_warn_log(json, message, timestamp, prefix_str)
+        else
+          format_info_log(json, message, timestamp, prefix_str)
+        end
+      end
+
+      def format_error_log(json, message, timestamp, prefix_str)
+        puts "#{prefix_str}#{c(:gray)}#{timestamp}#{c(:reset)} " \
+             "#{c(:red)}ERROR#{c(:reset)} #{c(:bold)}#{message}#{c(:reset)}"
+        puts "  #{c(:dim)}Action:#{c(:reset)} #{json['action']}" if json['action']
+        if json['error_class']
+          puts "  #{c(:dim)}Error:#{c(:reset)}  " \
+               "#{c(:red)}#{json['error_class']}#{c(:reset)}: #{json['error_message']}"
+        end
+        puts "  #{c(:dim)}Path:#{c(:reset)}   #{json['path']}" if json['path']
+        format_backtrace(json['backtrace'])
+      end
+
+      def format_warn_log(json, message, timestamp, prefix_str)
+        puts "#{prefix_str}#{c(:gray)}#{timestamp}#{c(:reset)} #{c(:yellow)}WARN#{c(:reset)} #{message}"
+        if json['error_class']
+          puts "  #{c(:dim)}Error:#{c(:reset)} " \
+               "#{c(:red)}#{json['error_class']}#{c(:reset)}: #{json['error_message']}"
+        end
+        puts "  #{c(:dim)}Path:#{c(:reset)} #{json['path']}" if json['path']
+        format_backtrace(json['backtrace'])
+      end
+
+      def format_info_log(json, message, timestamp, prefix_str)
+        case message
+        when 'Lambda invoked'
+          path = strip_namespace(json['path'])
+          puts "#{prefix_str}#{c(:gray)}#{timestamp}#{c(:reset)} " \
+               "#{c(:cyan)}Started#{c(:reset)} #{c(:bold)}#{json['http_method']}#{c(:reset)} #{path}"
+        when 'Request completed'
+          path = strip_namespace(json['path'])
+          sc = json['status_code'].to_i
+          sc_color = status_color(sc)
+          puts "#{prefix_str}#{c(:gray)}#{timestamp}#{c(:reset)} " \
+               "#{c(:cyan)}Completed#{c(:reset)} #{c(sc_color)}#{sc}#{c(:reset)} #{path}"
+        else
+          level = json['level']
+          level_col = level_color_for(level)
+          puts "#{prefix_str}#{c(:gray)}#{timestamp}#{c(:reset)} #{level_col}#{level}#{c(:reset)} #{message}" if level
+        end
+      end
+
+      def format_aws_error(json, prefix: nil)
+        prefix_str = prefix ? "#{c(:blue)}[#{prefix}]#{c(:reset)} " : ''
+        puts "#{prefix_str}  #{c(:dim)}Error Type:#{c(:reset)}    #{c(:red)}#{json['errorType']}#{c(:reset)}"
+        puts "#{prefix_str}  #{c(:dim)}Error Message:#{c(:reset)} #{json['errorMessage']}"
+        return unless json['stackTrace'].is_a?(Array)
+
+        puts "#{prefix_str}  #{c(:dim)}Stack Trace:#{c(:reset)}"
+        json['stackTrace'].first(20).each do |line|
+          if line.match?(%r{(controllers|models|lib|helpers)/})
+            puts "#{prefix_str}    #{c(:yellow)}→#{c(:reset)} #{line}"
+          elsif line.include?('/var/task/')
+            puts "#{prefix_str}    #{c(:cyan)}→#{c(:reset)} #{line}"
+          else
+            puts "#{prefix_str}    #{c(:gray)}  #{line}#{c(:reset)}"
+          end
+        end
+      end
+
+      def format_backtrace(backtrace)
+        return unless backtrace.is_a?(Array) && backtrace.any?
+
+        puts "  #{c(:dim)}Backtrace:#{c(:reset)}"
+        backtrace.first(15).each do |line|
+          if line.match?(%r{(controllers|models|lib|helpers)/})
+            puts "    #{c(:yellow)}→#{c(:reset)} #{line}"
+          else
+            puts "    #{c(:gray)}  #{line}#{c(:reset)}"
+          end
+        end
+      end
+
+      def should_show_level?(level)
+        return true unless level
+
+        levels = { 'DEBUG' => 1, 'INFO' => 2, 'WARN' => 3, 'ERROR' => 4 }
+        (levels[level] || 0) >= (levels[@level] || 2)
+      end
+
+      def level_color_for(level)
+        case level
+        when 'INFO' then c(:green)
+        when 'WARN' then c(:yellow)
+        when 'ERROR' then c(:red)
+        else c(:gray)
+        end
+      end
+
+      def status_color(code)
+        if code >= 500
+          :red
+        elsif code >= 400
+          :yellow
+        else
+          :green
+        end
+      end
+
+      def strip_namespace(path)
+        return path unless path
+
+        path.sub(%r{\A/[^/]+}, '')
+      end
+
+      def print_header(lambda_name)
+        full_name = "#{@app_name}-#{@env}-#{lambda_name}"
+        puts "#{c(:cyan)}═══════════════════════════════════════════════════════════════#{c(:reset)}"
+        puts "#{c(:bold)}Lambda Logs: #{c(:magenta)}#{full_name}#{c(:reset)}"
+        puts "#{c(:cyan)}═══════════════════════════════════════════════════════════════#{c(:reset)}"
+      end
+
+      def format_timestamp(epoch_ms)
+        return '' unless epoch_ms
+
+        Time.at(epoch_ms / 1000.0).strftime('%H:%M:%S')
+      end
+
+      def extract_time_from_line(line)
+        match = line.match(/\A(\d{4}-\d{2}-\d{2}T[\d:]+)/)
+        match ? match[1].split('T').last : ''
+      end
+
+      def parse_since(value)
+        num = value.to_i
+        case value
+        when /h\z/ then num * 60 * 60 * 1000
+        when /m\z/ then num * 60 * 1000
+        when /s\z/ then num * 1000
+        else num * 60 * 1000
+        end
+      end
+
+      def parse_json(str)
+        JSON.parse(str)
+      rescue StandardError
+        nil
+      end
+
+      def find_infra_dir
+        candidates = %w[infrastructure infra]
+        candidates.map { |d| File.join(Dir.pwd, d) }.find { |d| Dir.exist?(d) }
+      end
+
+      def c(name)
+        @color ? COLORS[name].to_s : ''
+      end
+    end
+  end
+end

data/lib/belt/cli/views_command.rb

@@ -10,10 +10,14 @@ module Belt
       TEMPLATE_DIR = File.expand_path('../../templates/views', __dir__)
 
       def self.run(args)
+        force = args.delete('--force') || args.delete('-f')
+
         name = args.shift
         if name.nil? || name.empty?
-          puts 'Usage: belt generate views <resource> [field:type ...]'
+          puts 'Usage: belt generate views <resource> [field:type ...] [options]'
           puts "\nGenerates React pages for all REST actions (index, show, new, edit)."
+          puts "\nOptions:"
+          puts '  --force, -f    Overwrite existing files without prompting'
           puts "\nExamples:"
           puts '  belt generate views post title:string content:text status:string'
           puts '  belt generate views comment body:text author:string'
@@ -28,7 +32,7 @@ module Belt
         # If no fields provided, try to read from contracts.rb
         fields = read_schema_fields(name) if fields.empty?
 
-        new(name, fields).generate
+        new(name, fields, force: force).generate
       end
 
       def self.read_schema_fields(name)
@@ -45,20 +49,37 @@ module Belt
 
         # 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
-            }
+          block_content = ::Regexp.last_match(1)
+          timestamp_fields = %w[created_at updated_at]
+
+          # Support both formats:
+          #   field :name, type: :string   (legacy)
+          #   string :name                 (current schema DSL)
+          dsl_types = %w[string text integer number boolean float date datetime]
+          dsl_pattern = /(?:#{dsl_types.join('|')}) :(\w+)/
+          fields = block_content.scan(/field :(\w+), type: :(\w+)/)
+          fields += block_content.scan(dsl_pattern).map do |match|
+            field_name = match[0]
+            # Extract type from the DSL method name on that line
+            type_match = block_content.match(/(\w+) :#{Regexp.escape(field_name)}/)
+            [field_name, type_match ? type_match[1] : 'string']
+          end
+
+          fields.filter_map do |n, t|
+            next if timestamp_fields.include?(n)
+
+            { name: n, type: t }
           end
         else
           []
         end
       end
 
-      def initialize(name, fields)
+      def initialize(name, fields, force: false)
         @name = name.downcase.gsub(/[^a-z0-9_]/, '_')
         @fields = fields
+        @force = force
+        @overwrite_all = false
         @singular_name = Belt::Inflector.singularize(@name)
         @resource_name = Belt::Inflector.pluralize(@singular_name)
         @class_name = Belt::Inflector.classify(@singular_name)
@@ -97,8 +118,61 @@ module Belt
       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)
+        existed = File.exist?(dest_path)
+
+        if existed && !@force && !@overwrite_all
+          action = prompt_overwrite(dest_path)
+          case action
+          when :yes
+            # fall through to write
+          when :all
+            @overwrite_all = true
+            # fall through to write
+          when :no
+            puts "  skip    #{dest_path}"
+            return
+          when :quit
+            puts "\nAborted."
+            exit 1
+          end
+        end
+
         File.write(dest_path, content)
-        puts "  create  #{dest_path}"
+        puts "  #{existed ? 'overwrite' : 'create'}  #{dest_path}"
+      end
+
+      def prompt_overwrite(path)
+        return :yes if @overwrite_all
+
+        print "  conflict  #{path}\n"
+        print "  Overwrite #{path}? (enter \"h\" for help) [Ynaqh] "
+        $stdout.flush
+
+        loop do
+          answer = $stdin.gets&.strip&.downcase
+          case answer
+          when '', 'y', 'yes'
+            return :yes
+          when 'n', 'no'
+            return :no
+          when 'a', 'all'
+            @overwrite_all = true
+            return :all
+          when 'q', 'quit'
+            return :quit
+          when 'h', 'help'
+            puts '  Y - yes, overwrite this file'
+            puts '  n - no, skip this file'
+            puts '  a - all, overwrite this and all remaining files'
+            puts '  q - quit, abort the generator'
+            puts '  h - help, show this help'
+            print "  Overwrite #{path}? (enter \"h\" for help) [Ynaqh] "
+            $stdout.flush
+          else
+            print '  Please enter Y, n, a, q, or h: '
+            $stdout.flush
+          end
+        end
       end
 
       def inject_routes
@@ -109,6 +183,12 @@ module Belt
         pages_dir = @resource_name
         plural_class = @plural_class_name || Belt::Inflector.camelize(@resource_name)
 
+        # Skip route injection if routes for this resource already exist
+        if content.include?("path=\"/#{@resource_name}\"")
+          puts "  skip    #{app_jsx} (routes already exist)"
+          return
+        end
+
         import_lines = [
           "import #{plural_class}Index from './pages/#{pages_dir}/#{plural_class}Index'",
           "import #{@class_name}Show from './pages/#{pages_dir}/#{@class_name}Show'",

data/lib/belt/cli.rb

@@ -22,6 +22,7 @@ require_relative 'cli/contracts_command'
 require_relative 'cli/lambda_config_command'
 require_relative 'cli/tasks_command'
 require_relative 'cli/console_command'
+require_relative 'cli/logs_command'
 require_relative 'cli/doctor_command'
 require_relative 'cli/plugin_command'
 
@@ -35,6 +36,7 @@ module Belt
       'contracts' => Belt::CLI::ContractsCommand,
       'lambda-config' => Belt::CLI::LambdaConfigCommand,
       %w[console c] => Belt::CLI::ConsoleCommand,
+      'logs' => Belt::CLI::LogsCommand,
       %w[tasks --tasks -T] => Belt::CLI::TasksCommand,
       'setup' => Belt::CLI::SetupCommand,
       'doctor' => Belt::CLI::DoctorCommand,
@@ -116,6 +118,7 @@ module Belt
 
           console                                     Start an interactive console (IRB)
           c                                           Alias for console
+          logs [lambda] [-f] [-s 5m] [-e env]         View Lambda function logs
           tasks [-g PATTERN] [-a]                     List available rake tasks
           -T [-g PATTERN] [-a]                        Alias for tasks
           setup state                                 Create/select S3 state bucket

data/lib/belt/route_dsl.rb

@@ -520,7 +520,7 @@ module Belt
 
   # SchemaBuilder captures request and response model definitions from contracts.rb
   class SchemaBuilder
-    SUPPORTED_TYPES = %i[string number integer boolean array object map list].freeze
+    SUPPORTED_TYPES = %i[string text number integer boolean date datetime array object map list].freeze
 
     attr_reader :request_models, :response_models
 
@@ -557,7 +557,7 @@ module Belt
   end
 
   class RequestModelBuilder
-    SUPPORTED_TYPES = %i[string number integer boolean array object map list].freeze
+    SUPPORTED_TYPES = %i[string text number integer boolean date datetime array object map list].freeze
 
     attr_reader :name, :fields
 
@@ -590,6 +590,7 @@ module Belt
 
     def map_type(dsl_type)
       case dsl_type
+      when :text, :date, :datetime then 'string'
       when :map then 'object'
       when :list then 'array'
       else dsl_type.to_s
@@ -598,7 +599,7 @@ module Belt
   end
 
   class ResponseModelBuilder
-    SUPPORTED_TYPES = %i[string number integer boolean array object map list].freeze
+    SUPPORTED_TYPES = %i[string text number integer boolean date datetime array object map list].freeze
 
     attr_reader :name, :contexts, :fields
 
@@ -636,6 +637,7 @@ module Belt
 
     def map_type(dsl_type)
       case dsl_type
+      when :text, :date, :datetime then 'string'
       when :map then 'object'
       when :list then 'array'
       else dsl_type.to_s
@@ -644,7 +646,7 @@ module Belt
   end
 
   class ContextBuilder
-    SUPPORTED_TYPES = %i[string number integer boolean array object map list].freeze
+    SUPPORTED_TYPES = %i[string text number integer boolean date datetime array object map list].freeze
 
     attr_reader :name, :fields
 
@@ -673,6 +675,7 @@ module Belt
 
     def map_type(dsl_type)
       case dsl_type
+      when :text, :date, :datetime then 'string'
       when :map then 'object'
       when :list then 'array'
       else dsl_type.to_s

data/lib/belt/version.rb

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

data/lib/belt.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'activeitem'
 require_relative 'belt/version'
 require_relative 'belt/root'
 require_relative 'belt/configuration'

data/lib/templates/generate/controller.rb.erb

@@ -6,53 +6,48 @@ module <%= @module_name %>Controllers
   class <%= @class_name %>sController < ApplicationController
     # GET /<%= @resource_name %>
     def index
-      <%= @resource_name %> = <%= @class_name %>.all
-      success_response(<%= @resource_name %>: <%= @resource_name %>.map(&:to_h))
+      @<%= @resource_name %> = <%= @class_name %>.all
     end
 
     # POST /<%= @resource_name %>
     def create
-      <%= @singular_name %> = <%= @class_name %>.new(<%= @fields.map { |f| "#{f[:name]}: params[:#{f[:name]}]" }.join(', ') %>)
+      @<%= @singular_name %> = <%= @class_name %>.new(<%= @fields.map { |f| "#{f[:name]}: params[:#{f[:name]}]" }.join(', ') %>)
 
-      if <%= @singular_name %>.save
-        success_response(<%= @singular_name %>: <%= @singular_name %>.to_h)
+      if @<%= @singular_name %>.save
+        response_status :created
       else
-        error_response(<%= @singular_name %>.errors.full_messages.join(', '), 422)
+        error_response(@<%= @singular_name %>.errors.full_messages.join(', '), :unprocessable_entity)
       end
     end
 
     # GET /<%= @resource_name %>/:<%= @singular_name %>_id
     def show
-      <%= @singular_name %> = <%= @class_name %>.find(params[:<%= @singular_name %>_id])
-      return error_response('<%= @class_name %> not found', 404) unless <%= @singular_name %>
-
-      success_response(<%= @singular_name %>: <%= @singular_name %>.to_h)
+      @<%= @singular_name %> = <%= @class_name %>.find(params[:<%= @singular_name %>_id])
+      return error_response('<%= @class_name %> not found', :not_found) unless @<%= @singular_name %>
     end
 
     # PUT /<%= @resource_name %>/:<%= @singular_name %>_id
     def update
-      <%= @singular_name %> = <%= @class_name %>.find(params[:<%= @singular_name %>_id])
-      return error_response('<%= @class_name %> not found', 404) unless <%= @singular_name %>
+      @<%= @singular_name %> = <%= @class_name %>.find(params[:<%= @singular_name %>_id])
+      return error_response('<%= @class_name %> not found', :not_found) unless @<%= @singular_name %>
 
       attrs = {}
 <% @fields.each do |field| -%>
       attrs[:<%= field[:name] %>] = params[:<%= field[:name] %>] if params.key?(:<%= field[:name] %>)
 <% end -%>
 
-      if <%= @singular_name %>.update(attrs)
-        success_response(<%= @singular_name %>: <%= @singular_name %>.to_h)
-      else
-        error_response(<%= @singular_name %>.errors.full_messages.join(', '), 422)
+      unless @<%= @singular_name %>.update(attrs)
+        error_response(@<%= @singular_name %>.errors.full_messages.join(', '), :unprocessable_entity)
       end
     end
 
     # DELETE /<%= @resource_name %>/:<%= @singular_name %>_id
     def destroy
       <%= @singular_name %> = <%= @class_name %>.find(params[:<%= @singular_name %>_id])
-      return error_response('<%= @class_name %> not found', 404) unless <%= @singular_name %>
+      return error_response('<%= @class_name %> not found', :not_found) unless <%= @singular_name %>
 
       <%= @singular_name %>.destroy
-      success_response(message: '<%= @class_name %> deleted')
+      head :no_content
     end
   end
 end

data/lib/templates/generate/model.rb.erb

@@ -1,18 +1,5 @@
 # frozen_string_literal: true
 
 class <%= @class_name %> < ApplicationRecord
-<% @fields.each do |field| -%>
-  attr_accessor :<%= field[:name] %>
-<% end -%>
-
-  def to_h
-    {
-      id: id,
-<% @fields.each do |field| -%>
-      <%= field[:name] %>: <%= field[:name] %>,
-<% end -%>
-      created_at: created_at,
-      updated_at: updated_at
-    }
-  end
+  attr_accessor <%= @fields.map { |f| ":#{f[:name]}" }.join(', ') %>
 end

data/lib/templates/new_app/Gemfile.erb

@@ -2,6 +2,4 @@
 
 source 'https://rubygems.org'
 
-gem 'activeitem'
 gem 'belt'
-gem 'lambda_loadout'

data/lib/templates/new_app/gitignore.erb

@@ -12,3 +12,6 @@
 # Lambda build artifacts
 /lambda/vendor/
 /lambda/.bundle/
+
+# Generated route manifests (belt routes --namespace)
+/lambda/lib/routes/

data/lib/templates/new_app/lambda/api.rb.erb

@@ -1,15 +1,9 @@
 # frozen_string_literal: true
 
 require 'belt'
-require 'activeitem'
 
 include Belt::LambdaHandler
 
-ActiveItem.configure do |config|
-  config.table_prefix = ENV['APP_NAME']
-  config.environment = ENV['ENVIRONMENT']
-end
-
 require_relative 'lib/routes/api_routes'
 <% @resources&.each do |r| -%>
 require_relative 'controllers/<%= @app_name %>/<%= r %>_controller'

data/lib/templates/new_app/lambda/config/environment.rb.erb

@@ -3,16 +3,10 @@
 # Boot the application. Used by `belt console` and Lambda at runtime.
 
 require 'belt'
-require 'activeitem'
 
 ENV['APP_NAME'] ||= '<%= @app_name %>'
 ENV['AWS_REGION'] ||= 'us-east-1'
 
-ActiveItem.configure do |config|
-  config.table_prefix = ENV['APP_NAME']
-  config.environment = ENV['ENVIRONMENT']
-end
-
 # Load lib and models
 Dir[File.join(__dir__, '..', 'lib', '**', '*.rb')].sort.each { |f| require f }
 

data/lib/templates/new_app/lambda/models/application_record.rb.erb

@@ -1,6 +1,4 @@
 # frozen_string_literal: true
 
-require 'activeitem'
-
 class ApplicationRecord < ActiveItem::Base
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: belt
 version: !ruby/object:Gem::Version
-  version: 0.2.12
+  version: 0.2.13
 platform: ruby
 authors:
 - Stowzilla
@@ -16,6 +16,9 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.13
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -23,6 +26,9 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.13
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
@@ -89,6 +95,7 @@ files:
 - lib/belt/cli/generate_command.rb
 - lib/belt/cli/generator_registry.rb
 - lib/belt/cli/lambda_config_command.rb
+- lib/belt/cli/logs_command.rb
 - lib/belt/cli/new_command.rb
 - lib/belt/cli/path_gem_materializer.rb
 - lib/belt/cli/plugin_command.rb