jets 5.0.14 → 6.0.0.beta1

data/lib/jets/cli/dotenv/list.rb

@@ -0,0 +1,32 @@
+require "shellwords"
+
+class Jets::CLI::Dotenv
+  class List < Base
+    def run
+      presenter = CliFormat::Presenter.new(@options)
+      warn "# Env from config/jets/env files and SSM parameters"
+      warn "# Values are not used locally. They are only used for the Lambda Function"
+      unless @options[:reveal]
+        warn "# To show values also, use the --reveal option"
+      end
+      presenter.empty_message = "# No env vars found"
+      unless @options[:format] == "dotenv"
+        header = ["Name"]
+        header << "Value" if @options[:reveal]
+        presenter.header = header
+      end
+      vars = Jets::Dotenv.parse
+      vars.each do |key, value|
+        v = inspect?(value) ? value.inspect : value
+        row = [key]
+        row << v if @options[:reveal]
+        presenter.rows << row
+      end
+      presenter.show
+    end
+
+    def inspect?(value)
+      value.include?("\n") || Shellwords.escape(value) != value
+    end
+  end
+end

data/lib/jets/cli/dotenv/set.rb

@@ -0,0 +1,50 @@
+class Jets::CLI::Dotenv
+  class Set < Base
+    include Jets::CLI::Env::Parse
+
+    def run
+      sure? sure_message
+      puts "Setting SSM vars for #{Jets.project.namespace}"
+
+      perform # interface method
+      Jets::CLI::Tip.show(:ssm_change)
+    end
+
+    def perform
+      ssm_manager.set(vars)
+    end
+
+    def vars
+      parse_cli_env_values(@options[option_key])
+    end
+
+    # interface method
+    def option_key
+      :values
+    end
+
+    def ssm_method
+      name = self.class.name.demodulize # Set or Unset
+      (name == "Set") ? :set : :delete
+    end
+
+    def names
+      vars.keys.map(&:to_s)
+    end
+
+    def sure_message
+      <<~EOL
+        Will #{ssm_method} the SSM vars for #{Jets.project.namespace}
+        Note: SSM changes do not update the Lambda function env vars.
+        You will need run jets deploy to update the env vars.
+
+        #{ssm_manager.preview_list(names)}
+      EOL
+    end
+
+    def ssm_manager
+      Jets::CLI::Dotenv::Ssm.new(@options)
+    end
+    memoize :ssm_manager
+  end
+end

data/lib/jets/cli/dotenv/ssm.rb

@@ -0,0 +1,60 @@
+class Jets::CLI::Dotenv
+  # The update logic is here and not a part of Jets::Dotenv::Ssm to emphasize
+  # that it's only used for jets dotenv commands.
+  # This class is responsible for updating.
+  # The other Jets::Dotenv class is only repsonsible for reading.
+  # The one part of the other class that is used is Jets::Dotenv::Convention
+  class Ssm
+    include Jets::AwsServices
+    include Jets::Util::Logging
+
+    def initialize(options = {})
+      @options = options
+      @parameter_type = options[:secure] ? "SecureString" : "String"
+    end
+
+    def set(params)
+      # Loop through the hash and update each parameter
+      params.each do |name, value|
+        name = conventional_name(name)
+        ssm.put_parameter(
+          name: name,               # The name of the parameter
+          value: value,             # The new value for the parameter
+          type: @parameter_type,     # Set type to 'SecureString' if secure, else 'String'
+          overwrite: true           # Allows overwriting an existing parameter
+        )
+        log.info "SSM Parameter set: #{name}"
+      end
+    end
+
+    # There's a delete_parameters method also that can delete 10 at a time.
+    # Use simple one-by-one deletion for clarity and to surface errors.
+    # Will allow program to continue for ParameterNotFound error.
+    # In case use wants to keep trying to delete all parameters.
+    def delete(names)
+      names.each do |name|
+        name = conventional_name(name)
+        ssm.delete_parameter(name: name)
+        log.info "SSM Parameter deleted: #{name}"
+      rescue Aws::SSM::Errors::ParameterNotFound => e
+        log.warn "WARN: Failed to delete parameter #{name}: #{e.message}"
+      end
+    end
+
+    def preview_list(names)
+      names = names.is_a?(Hash) ? names.keys.map(&:to_s) : names
+      names.map do |name|
+        "  #{conventional_name(name)}"
+      end.join("\n")
+    end
+
+    def conventional_name(name)
+      # add conventional prefix
+      # "/#{Jets.project.name}/#{Jets.env}/#{value}"
+      unless name.include?("/")
+        name = Jets::Dotenv::Convention.new.ssm_name(name)
+      end
+      name
+    end
+  end
+end

data/lib/jets/cli/dotenv/unset.rb

@@ -0,0 +1,11 @@
+class Jets::CLI::Dotenv
+  class Unset < Set
+    def perform
+      ssm_manager.delete(names)
+    end
+
+    def names
+      @options[:names]
+    end
+  end
+end

data/lib/jets/cli/dotenv.rb

@@ -0,0 +1,28 @@
+class Jets::CLI
+  class Dotenv < Jets::Thor::Base
+    desc "list", "Parse and list dotenv vars"
+    format_option(default: "dotenv")
+    option :reveal, type: :boolean, default: false, desc: "Reveal values also"
+    def list
+      List.new(options).run
+    end
+
+    desc "get NAME", "Get env var from local files and SSM"
+    def get(name)
+      Get.new(options.merge(name: name)).run
+    end
+
+    desc "set VALUES", "Set SSM env vars for function"
+    yes_option
+    option :secure, type: :boolean, default: true, desc: "Whether or not to use SSM parameter type SecureString or String"
+    def set(*values)
+      Set.new(options.merge(values: values)).run
+    end
+
+    desc "unset NAMES", "Unset SSM env vars for function"
+    yes_option
+    def unset(*names)
+      Unset.new(options.merge(names: names)).run
+    end
+  end
+end

data/lib/jets/cli/env/base.rb

@@ -0,0 +1,13 @@
+class Jets::CLI::Env
+  class Base < Jets::CLI::Base
+    include Jets::CLI::Lambda::Checks
+    include Jets::Util::Truthy
+
+    def initialize(options = {})
+      super
+      check_deployed!
+      function_name = Jets::CLI::Lambda::Lookup.function(options[:function])
+      @lambda_function = Jets::CLI::Lambda::Function.new(function_name)
+    end
+  end
+end

data/lib/jets/cli/env/get.rb

@@ -0,0 +1,13 @@
+class Jets::CLI::Env
+  class Get < Base
+    def run
+      @lambda_function.environment_variables.find do |key, value|
+        if key == @options[:key]
+          puts value
+          exit # success
+        end
+      end
+      exit 1 # not found
+    end
+  end
+end

data/lib/jets/cli/env/list.rb

@@ -0,0 +1,19 @@
+class Jets::CLI::Env
+  class List < Base
+    def run
+      warn "# Env Variables for #{Jets.project.namespace}"
+      unless @options[:reveal]
+        warn "# To show values also, use the --reveal option"
+      end
+      vars = @lambda_function.environment_variables
+
+      presenter = CliFormat::Presenter.new(@options)
+      vars.each do |key, value|
+        row = [key]
+        row << value if @options[:reveal]
+        presenter.rows << row
+      end
+      presenter.show
+    end
+  end
+end

data/lib/jets/cli/env/parse.rb

@@ -0,0 +1,11 @@
+class Jets::CLI::Env
+  module Parse
+    def parse_cli_env_values(pairs)
+      # Use each_with_object to iterate over the pairs and insert them into a hash
+      pairs.each_with_object({}) do |pair, hash|
+        key, value = pair.split("=")
+        hash[key] = value
+      end
+    end
+  end
+end

data/lib/jets/cli/env/set.rb

@@ -0,0 +1,25 @@
+class Jets::CLI::Env
+  class Set < Base
+    include Parse
+
+    def run
+      are_you_sure?
+      puts "Setting env vars for #{@lambda_function.name}"
+
+      @lambda_function.environment_variables = environment_variables
+      Jets::CLI::Tip.show(:env_change)
+    end
+
+    def environment_variables
+      parse_cli_env_values(@options[:values])
+    end
+
+    def are_you_sure?
+      name = self.class.to_s.demodulize.underscore.humanize.downcase
+      sure? <<~EOL
+        Will #{name} env vars for #{@lambda_function.name}
+        The Lambda Function will immediately use the new env vars.
+      EOL
+    end
+  end
+end

data/lib/jets/cli/env/unset.rb

@@ -0,0 +1,17 @@
+class Jets::CLI::Env
+  class Unset < Set
+    def run
+      are_you_sure?
+      puts "Unsetting env vars for #{@lambda_function.name}"
+
+      @lambda_function.environment_variables = environment_variables
+      Jets::CLI::Tip.show(:env_change)
+    end
+
+    def environment_variables
+      @options[:names].each_with_object({}) do |name, hash|
+        hash[name] = nil
+      end
+    end
+  end
+end

data/lib/jets/cli/env.rb

@@ -0,0 +1,29 @@
+class Jets::CLI
+  class Env < Jets::Thor::Base
+    class_option :function, aliases: :n, default: "controller", desc: "Lambda Function name"
+
+    desc "list", "List and show env vars"
+    format_option(default: "dotenv")
+    option :reveal, type: :boolean, default: false, desc: "Reveal values also"
+    def list
+      List.new(options).run
+    end
+
+    desc "get NAME", "Get env vars for function"
+    def get(name)
+      Get.new(options.merge(key: name)).run
+    end
+
+    desc "set VALUES", "Set env vars for function"
+    yes_option
+    def set(*values)
+      Set.new(options.merge(values: values)).run
+    end
+
+    desc "unset NAMES", "Unset env vars for function"
+    yes_option
+    def unset(*names)
+      Unset.new(options.merge(names: names)).run
+    end
+  end
+end

data/lib/jets/cli/exec/command.rb

@@ -0,0 +1,61 @@
+class Jets::CLI::Exec
+  class Command < Jets::CLI::Call
+    # override behavior
+    def run
+      result = invoke
+      if result["errorMessage"]
+        # Note:
+        # errorType is Function<Errno::ENOENT> and not useful
+        # stackTrace is also not useful. IE: [{}, {}, {}, {}, {}, {}, {}]
+        # Actual stackTrace only shows up in the logs
+        log.error "ERROR: #{result["errorMessage"]}".color(:red)
+        useless_stacktrace = result["stackTrace"]&.all? { |line| line == {} }
+        if useless_stacktrace
+          # Logs can come from:
+          #
+          #   1. Lambda invoke host log: shows cold-start and Jets.boot errors
+          #   2. Lambda runtime container log: shows errors inside handler
+          #
+          # The result seems to hide the cold-start/Jets.boot errors.
+          # Guessing AWS does this for security reasons and hides it with {}.
+          #
+          # Since result["stackTrace"] since only shows errors within the handler.
+          # Errors that outside the handler at cold-start/Jets.boot time are not in
+          # result["stackTrace"]. They show up in the logs though.
+          # So we show the logs that are available from the header.
+          log_last_4kb(<<~EOL)
+            Showing last 4KB of logs from x-amz-log-result header for errors.
+
+            You can check for more logs with.
+
+                jets logs -n #{friendly_function_name}
+
+            Last 4KB of logs:
+          EOL
+        elsif result["stackTrace"]
+          log.error "Stack Trace:"
+          result["stackTrace"].each do |line|
+            log.error line
+          end
+        else # fallback to errorMessage
+          # No stack trace available.
+          # Example: result: {"errorMessage"=>"2024-04-18T19:42:51.819Z cdbcd9f2-6d25-4672-8a83-676643698fa0 Task timed out after 3.05 seconds"}
+          log.error "errorMessage: #{result["errorMessage"]}"
+        end
+      else
+        $stdout.print result["stdout"]
+        $stderr.print result["stderr"] # same as $stderr.puts
+      end
+      result
+    end
+
+    def friendly_function_name
+      function_name.sub("#{Jets.project.namespace}-", "")
+    end
+
+    # interface method
+    def payload
+      {command: @options[:command]}.to_json
+    end
+  end
+end

data/lib/jets/cli/exec/repl/history.rb

@@ -0,0 +1,42 @@
+class Jets::CLI::Exec::Repl
+  class History
+    MAX_SIZE = 10_000
+
+    attr_reader :list
+    def initialize(options = {})
+      @options = options
+      @file = "#{ENV["HOME"]}/.jets/history"
+      @list = load
+    end
+
+    def add(cmd)
+      @list << cmd
+      @list.shift if @list.size > MAX_SIZE
+    end
+
+    def display(num = nil)
+      num ||= 20
+      num = (num == "all") ? @list.length : num.to_i
+      num = [@list.length, num].min
+      start_index = [@list.length - num, 0].max
+      @list[start_index..].each_with_index { |cmd, index| puts "#{start_index + index + 1}: #{cmd}" }
+    end
+
+    def load
+      history = if File.exist?(@file)
+        File.readlines(@file).map(&:chomp)
+      else
+        []
+      end
+      history.each { |cmd| Readline::HISTORY << cmd }
+      history
+    end
+
+    def save
+      FileUtils.mkdir_p(File.dirname(@file))
+      File.open(@file, "w") do |file|
+        @list.each { |cmd| file.puts cmd }
+      end
+    end
+  end
+end

data/lib/jets/cli/exec/repl.rb

@@ -0,0 +1,122 @@
+require "fileutils"
+require "open3"
+require "readline"
+
+class Jets::CLI::Exec
+  class Repl
+    extend Memoist
+    include Jets::Util::Logging
+
+    attr_reader :history
+    def initialize(options = {})
+      @options = options
+      @history = History.new(@options) # load for history to work upon start
+      trap_signals
+    end
+
+    def start
+      welcome
+
+      loop do
+        input = Readline.readline("$ ", true)
+
+        if input.nil? || input.downcase == "exit"
+          puts "Exiting..."
+          history.save
+          break
+        elsif input.strip.empty?
+          next
+        elsif input.strip.start_with? "history"
+          num = input.split(" ")[1]
+          history.display(num)
+          next
+        elsif input.strip.start_with? "!"
+          execute_from_history(input)
+          next
+        elsif input.strip == "status"
+          display_last_status
+          next
+        elsif %w[_ result].include?(input.strip)
+          display_last_result
+          next
+        elsif %w[help ?].include?(input.strip)
+          display_help
+          next
+        end
+
+        if history.list.empty? || input != history.list.last
+          history.add(input)
+        end
+        execute_command(input)
+      end
+    end
+
+    private
+
+    def welcome
+      function_name = Command.new(@options).function_name
+      puts <<~EOL
+        Jets REPL (#{Jets::VERSION}). Commands will be executed on Lambda.
+        Lambda function: #{function_name}
+        Type 'help' for help, 'exit' to exit.
+      EOL
+    end
+
+    def execute_command(input)
+      result = Command.new(@options.merge(command: input)).run
+      @last_status = result["errorMessage"] ? 1 : result["status"]
+      @last_result = result
+    end
+
+    def execute_from_history(input)
+      index = input[1..-1].to_i - 1
+      if index >= 0 && index < history.list.length
+        input = history.list[index]
+        puts "> #{input}"
+        execute_command(input)
+      else
+        puts "Invalid history number"
+      end
+    end
+
+    def display_last_status
+      case @last_status
+      when nil
+        puts "No command has been executed on Lambda yet."
+      when 0
+        puts "Last command had a status of success (0)."
+      else
+        puts "Last command had a status other than success (#{@last_status})."
+      end
+    end
+
+    def display_last_result
+      if @last_result
+        puts "Last result:"
+        puts JSON.pretty_generate(@last_result)
+      else
+        puts "No command has been executed on Lambda yet."
+      end
+    end
+
+    def display_help
+      puts <<~HELP
+        Available commands:
+          - history [n or 'all']: Display the last n commands or the all command history. (Default: 20)
+          - status: Display the status of the last command executed on Lambda.
+          - result or _: Show previous command result.
+          - help: Display this help message.
+          - !<number>: Execute the command from the history by number.
+          - exit: Exit the REPL. You can also use Control-D.
+      HELP
+    end
+
+    def trap_signals
+      Signal.trap("INT") do
+        puts "\nExiting..."
+        history.save
+        exit
+      end
+    end
+  end
+end

data/lib/jets/cli/exec.rb

@@ -0,0 +1,14 @@
+class Jets::CLI
+  class Exec < Base
+    def run
+      if @options[:command].empty?
+        Repl.new(options).start
+      else
+        Command.new(options).run
+      end
+    rescue Jets::CLI::Call::Error => e
+      puts "ERROR: #{e.message}".color(:red)
+      abort "Unable to find the function.  Please check the function name and try again."
+    end
+  end
+end

data/lib/jets/cli/functions.rb

@@ -0,0 +1,39 @@
+class Jets::CLI
+  class Functions < Base
+    def run
+      functions = all
+      puts functions.sort
+    end
+
+    def all
+      functions = []
+      nested_stack_resources.each do |resource|
+        stack_name = resource.physical_resource_id
+        # Custom resource stacks may not have output with function name.
+        # So use describe_stack_resources to get the function names.
+        resources = cfn.describe_stack_resources(stack_name: stack_name).stack_resources
+        resources.each do |r|
+          if r.resource_type == "AWS::Lambda::Function"
+            functions << r.physical_resource_id
+          end
+        end
+      end
+      unless @options[:full]
+        functions = functions.map { |f| f.sub("#{Jets.project.namespace}-", "") }
+      end
+      functions
+    end
+
+    def nested_stack_resources
+      stack_name = Jets::Names.parent_stack_name
+      resp = cfn.describe_stack_resources(stack_name: stack_name)
+      resp.stack_resources.select { |r| r.resource_type == "AWS::CloudFormation::Stack" }
+    rescue Aws::CloudFormation::Errors::ValidationError => e
+      if e.message.include?("does not exist")
+        abort "The stack #{stack_name} does not exist.  Have you deployed yet?".color(:red)
+      else
+        raise
+      end
+    end
+  end
+end

data/lib/jets/cli/generate/event.rb

@@ -0,0 +1,29 @@
+class Jets::CLI::Generate
+  class Event < Jets::CLI::Group::Base
+    argument :name, required: true, desc: "Event name. Example: cool"
+
+    def self.cli_options
+      [
+        [:force, aliases: :f, type: :boolean, desc: "Bypass overwrite are you sure prompt for existing files"],
+        [:method, aliases: :m, desc: "Method name", default: "handle"],
+        [:trigger, aliases: :t, desc: "Event trigger", default: "scheduled"]
+      ]
+    end
+    cli_options.each { |args| class_option(*args) }
+
+    source_root "#{__dir__}/templates/event_types"
+
+    public
+
+    def application_event
+      template "application_event.rb", "app/events/application_event.rb", skip: true
+    end
+
+    def event
+      trigger = options[:trigger]
+      trigger = "scheduled" if trigger == "schedule" # allow both to work
+      template_path = "#{trigger}.rb.tt"
+      template template_path, "app/events/#{underscore_name}_event.rb"
+    end
+  end
+end

data/lib/jets/cli/generate/templates/application_event.rb.tt

@@ -0,0 +1,6 @@
+<% module_namespacing do -%>
+class ApplicationEvent < Jets::Event::Base
+  # Adjust default timeout for all Event classes
+  class_timeout 15.minutes
+end
+<% end -%>

data/lib/jets/cli/generate/templates/event_types/application_event.rb

@@ -0,0 +1,4 @@
+class ApplicationEvent < Jets::Event::Base
+  # Adjust default timeout for all Event classes
+  class_timeout 15.minutes
+end

data/lib/jets/cli/generate/templates/event_types/dynamodb.rb.tt

@@ -0,0 +1,6 @@
+class <%= class_name %>Event < ApplicationEvent
+  dynamodb_event "test-table" # existing namespaced table: IE: demo-dev-test-table
+  def <%= options[:method] %>
+    puts "event #{JSON.dump(event)}"
+  end
+end

data/lib/jets/cli/generate/templates/event_types/iot.rb.tt

@@ -0,0 +1,6 @@
+class <%= class_name %>Event < ApplicationEvent
+  iot_event "SELECT * FROM 'my/topic'"
+  def <%= options[:method] %>
+    puts "event #{JSON.dump(event)}"
+  end
+end

data/lib/jets/{generators/job → cli/generate}/templates/event_types/kinesis.rb.tt

@@ -1,9 +1,7 @@
-<% module_namespacing do -%>
-class <%= class_name %>Job < ApplicationJob
+class <%= class_name %>Event < ApplicationEvent
   kinesis_event "my-stream" # existing stream
-  def <%= options[:name] %>
+  def <%= options[:method] %>
     puts "event #{JSON.dump(event)}"
     puts "kinesis_data #{JSON.dump(kinesis_data)}"
   end
 end
-<% end -%>