jets 4.0.12 → 5.0.0.beta1

data/lib/jets/command.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require "active_support"
+require "active_support/core_ext/enumerable"
+require "active_support/core_ext/object/blank"
+
+require "thor"
+
+module Jets
+  module Command
+    extend ActiveSupport::Autoload
+
+    autoload :Behavior
+    autoload :Base
+
+    include Behavior
+
+    HELP_MAPPINGS = %w(-h -? --help)
+
+    class << self
+      def hidden_commands # :nodoc:
+        @hidden_commands ||= []
+      end
+
+      def environment # :nodoc:
+        ENV["JETS_ENV"].presence || ENV["RACK_ENV"].presence || "development"
+      end
+
+      # Receives a namespace, arguments, and the behavior to invoke the command.
+      def invoke(full_namespace, args = [], **config)
+        namespace = full_namespace = full_namespace.to_s
+
+        if char = namespace =~ /:(\w+)$/
+          command_name, namespace = $1, namespace.slice(0, char)
+        else
+          command_name = namespace
+        end
+
+        command_name, namespace = "help", "help" if command_name.blank? || HELP_MAPPINGS.include?(command_name)
+        command_name, namespace, args = "application", "application", ["--help"] if jets_new_with_no_path?(args)
+        command_name, namespace = "version", "version" if %w( -v --version ).include?(command_name)
+
+        original_argv = ARGV.dup
+        ARGV.replace(args)
+
+        command = find_by_namespace(namespace, command_name)
+        if command && command.all_commands[command_name]
+          command.perform(full_namespace, command_name, args, config)
+        else
+          args = ["--describe", full_namespace] if HELP_MAPPINGS.include?(args[0])
+          find_by_namespace("rake").perform(full_namespace, args, config)
+        end
+      ensure
+        ARGV.replace(original_argv)
+      end
+
+      # Jets finds namespaces similar to Thor, it only adds one rule:
+      #
+      # Command names must end with "_command.rb". This is required because Jets
+      # looks in load paths and loads the command just before it's going to be used.
+      #
+      #   find_by_namespace :webrat, :integration
+      #
+      # Will search for the following commands:
+      #
+      #   "webrat", "webrat:integration", "jets:webrat", "jets:webrat:integration"
+      #
+      def find_by_namespace(namespace, command_name = nil) # :nodoc:
+        lookups = [ namespace ]
+        lookups << "#{namespace}:#{command_name}" if command_name
+        lookups.concat lookups.map { |lookup| "jets:#{lookup}" }
+
+        lookup(lookups)
+
+        namespaces = subclasses.index_by(&:namespace)
+        namespaces[(lookups & namespaces.keys).first]
+      end
+
+      # Returns the root of the Jets engine or app running the command.
+      def root
+        if defined?(ENGINE_ROOT)
+          Pathname.new(ENGINE_ROOT)
+        elsif defined?(APP_PATH)
+          Pathname.new(File.expand_path("../..", APP_PATH))
+        end
+      end
+
+      def print_commands # :nodoc:
+        commands.each { |command| puts("  #{command}") }
+      end
+
+      private
+        COMMANDS_IN_USAGE = %w(
+          generate
+          console
+          server
+          deploy
+          logs
+          new
+        )
+        private_constant :COMMANDS_IN_USAGE
+
+        PRO_COMMANDS = %w(
+          projects
+          stacks
+          releases
+          rollback
+        )
+
+        def jets_new_with_no_path?(args)
+          args == ["new"]
+        end
+
+        def commands
+          lookup!
+          visible_commands = (subclasses - hidden_commands).flat_map(&:printing_commands)
+          (visible_commands - COMMANDS_IN_USAGE - PRO_COMMANDS).sort
+        end
+
+        def command_type # :doc:
+          @command_type ||= "command"
+        end
+
+        def lookup_paths # :doc:
+          @lookup_paths ||= %w( jets/commands commands )
+        end
+
+        def file_lookup_paths # :doc:
+          @file_lookup_paths ||= [ "{#{lookup_paths.join(',')}}", "**", "*_command.rb" ]
+        end
+    end
+  end
+end

data/lib/jets/commands/application/application_command.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Jets
+  module Command
+    class ApplicationCommand < Base # :nodoc:
+      hide_command!
+
+      self.bin = "jets" if respond_to?(:bin=) # Rails 7.1
+
+      def help
+        perform # Punt help output to the generator.
+      end
+
+      # This is:
+      #
+      #   bundle exec jets application:help => jets new --help
+      #   bundle exec jets application      => jets new --help
+      #
+      def perform(*args)
+        # require lazily so that Rails constant is only defined within generators
+        require "jets/generators/overrides/app/app_generator"
+        override_exit_on_failure?
+        argv = Rails::Generators::ARGVScrubber.new(args).prepare!
+        Jets::Generators::AppGenerator.start argv
+      end
+
+    private
+      # We override this way because Jets require generators lazily
+      def override_exit_on_failure?
+        Jets::Generators::AppGenerator.class_eval do
+          # We want to exit on failure to be kind to other libraries
+          # This is only when accessing via CLI
+          def self.exit_on_failure?
+            true
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jets/commands/build/build_command.rb

@@ -0,0 +1,33 @@
+module Jets::Command
+  class BuildCommand < Base # :nodoc:
+    include EnvironmentArgument
+
+    option :templates, type: :boolean, desc: "Build CloudFormation templates only"
+
+    desc "build", "Builds and packages project for AWS Lambda"
+    long_desc Help.text(:build)
+    def perform
+      ENV['JETS_TEMPLATES'] = '1' if options[:templates]
+
+      extract_environment_option_from_argument
+      require_application_and_environment!
+
+      puts "Building project for Lambda..."
+      # run gets called from the CLI and does not have all the stack_options yet.
+      # We compute it and change the options early here.
+      @options.merge!(stack_type: stack_type, s3_bucket: Jets.s3_bucket)
+      do_build
+    end
+
+  private
+    # Note: build is picked up as a command so naming it do_build
+    def do_build
+      Jets::Builders::CodeBuilder.new.build unless ENV['JETS_TEMPLATES']
+      Jets::Cfn::Builder.new(@options).build
+    end
+
+    def stack_type
+      first_run? ? :minimal : :full
+    end
+  end
+end

data/lib/jets/commands/call/anonymous_guesser.rb

@@ -1,4 +1,4 @@
-class Jets::Commands::Call
+module Jets::Commands::Call
   class AnonymousGuesser < BaseGuesser
     def detect_class_name
       found_path = function_paths.find do |path|

data/lib/jets/commands/call/autoload_guesser.rb

@@ -1,4 +1,4 @@
-class Jets::Commands::Call
+module Jets::Commands::Call
   class AutoloadGuesser < BaseGuesser
     def detect_class_name
       # First guess the class name assuming simple
@@ -53,7 +53,7 @@ class Jets::Commands::Call
       meth = underscored_function_name.sub(underscored_class_name, '')
       meth = meth.sub(/^[-_]/,'') # remove leading _ or -
 
-      if class_name.constantize.tasks.map(&:meth).include?(meth.to_sym)
+      if class_name.constantize.definitions.map(&:meth).include?(meth.to_sym)
         @method_name = meth
       else
         @method_name_error ="#{class_name} class found but #{meth} method not found"

data/lib/jets/commands/call/base_guesser.rb

@@ -3,7 +3,7 @@
 #   method_name
 #   error_message
 #
-class Jets::Commands::Call
+module Jets::Commands::Call
   class BaseGuesser
     include Jets::AwsServices
 
@@ -26,15 +26,15 @@ class Jets::Commands::Call
       # Strip the project namespace if the user has accidentally added it
       # Since we're going to automatically add it no matter what at the end
       # and dont want the namespace to be included twice
-      @provided_function_name = @provided_function_name.sub("#{Jets.config.project_namespace}-", "")
+      @provided_function_name = @provided_function_name.sub("#{Jets.project_namespace}-", "")
 
       code_path = class_name.underscore.gsub('/','-')
-      function_name = [Jets.config.project_namespace, code_path, method_name].join('-')
+      function_name = [Jets.project_namespace, code_path, method_name].join('-')
       generated_function_name(function_name)
     end
 
     def generated_function_name(function_name)
-      if function_name.size > Jets::MAX_FUNCTION_NAME_SIZE # name generated by CloudFormation
+      if function_name.size > Jets::Cfn::Resource::Lambda::Function::MAX_FUNCTION_NAME_SIZE # name generated by CloudFormation
         logical_id = @class_name.gsub('::','')
 
         parent_resources = stack_resources(parent_stack.stack_id)

data/lib/jets/commands/call/call_command.rb

@@ -0,0 +1,27 @@
+require "base64"
+require "json"
+
+module Jets::Command
+  class CallCommand < Base # :nodoc:
+    include Jets::AwsServices
+
+    desc "call [function] [event]", "Call a lambda function on AWS or locally"
+    long_desc Help.text(:call)
+    option :invocation_type, default: "RequestResponse", desc: "RequestResponse, Event, or DryRun"
+    option :log_type, default: "Tail", desc: "Works if invocation_type set to RequestResponse"
+    option :qualifier, desc: "Lambda function version or alias name"
+    option :show_log, type: :boolean, desc: "Shows last 4KB of log in the x-amz-log-result header"
+    option :show_logs, type: :boolean, desc: "Shows last 4KB of log in the x-amz-log-result header"
+    option :lambda_proxy, type: :boolean, default: true, desc: "Enables automatic Lambda proxy transformation of the event payload"
+    option :guess, type: :boolean, default: true, desc: "Enables guess mode. Uses inference to allows use of all dashes to specify functions. Guess mode verifies that the function exists in the code base."
+    option :local, type: :boolean, desc: "Enables local mode. Instead of invoke the AWS Lambda function, the method gets called locally with current app code. With local mode guess mode is always used."
+    option :retry_limit, type: :numeric, default: nil, desc: "Retry count of invoking function. It work with remote call"
+    option :read_timeout, type: :numeric, default: nil, desc: " The number of seconds to wait for response data. It work with remote call"
+    def perform(function_name, payload='')
+      $stdout.sync = true
+      $stderr.sync = true
+      $stdout = $stderr # jets call operation
+      Jets::Commands::Call::Caller.new(function_name, payload, options).run
+    end
+  end
+end

data/lib/jets/commands/call/caller.rb

@@ -0,0 +1,184 @@
+module Jets::Commands::Call
+  class Caller
+    include Jets::AwsServices
+
+    def initialize(provided_function_name, event, options={})
+      @options = options
+      @guess = @options[:guess].nil? ? true : @options[:guess]
+
+      @provided_function_name = provided_function_name
+      @event = event
+
+      @invocation_type = options[:invocation_type] || "RequestResponse"
+      @log_type = options[:log_type] || "Tail"
+      @qualifier = @qualifier
+    end
+
+    def function_name
+      if @provided_function_name == 'controller'
+        "#{Jets.project_namespace}-controller"
+      elsif @provided_function_name.starts_with?(Jets.project_namespace)
+        @provided_function_name # fully qualified function name
+      elsif @guess
+        ensure_guesses_found! # possibly exits here
+        guesser.function_name # guesser adds namespace already
+      else
+        [Jets.project_namespace, @provided_function_name].join('-')
+      end
+    end
+
+    def run
+      @options[:local] ? local_run : remote_run
+    end
+
+    # With local mode there is no way to bypass the guesser
+    def local_run
+      puts "Local mode enabled!"
+      ensure_guesses_found! # possibly exits here
+      klass = guesser.class_name.constantize
+      # Example:
+      #   PostsController.process(event, context, meth)
+      event = JSON.load(transformed_event) || {} # transformed_event is JSON text String
+
+      fun = Jets::Poly.new(klass, guesser.method_name)
+      result = fun.run(event) # check the logs for polymorphic function errors
+      # Note: even though data might not always be json, the JSON.dump does a
+      # good job of not bombing, so always calling it to simplify code.
+
+      text = Jets::Util.normalize_result(result)
+      STDOUT.puts text
+    end
+
+    def remote_run
+      puts "Calling lambda function #{function_name} on AWS" unless @options[:mute]
+      return if @options[:noop]
+
+      options = {
+        # client_context: client_context,
+        function_name: function_name,
+        invocation_type: @invocation_type, # "Event", # RequestResponse
+        log_type: @log_type, # pretty sweet
+        payload: transformed_event, # "fileb://file-path/input.json", <= JSON
+        qualifier: @qualifier, # "1",
+      }
+
+      begin
+        resp = lambda_client.invoke(options)
+      rescue Aws::Lambda::Errors::ResourceNotFoundException
+        puts "The function #{function_name} was not found.  Maybe check the spelling or the AWS_PROFILE?".color(:red)
+        return
+      end
+
+      if @options[:show_logs] || @options[:show_log]
+        puts "Last 4KB of log in the x-amz-log-result header:".color(:green)
+        puts Base64.decode64(resp.log_result)
+      end
+
+      add_console_link_to_clipboard
+      result = resp.payload.read # already been normalized/JSON.dump by AWS
+      unless @options[:mute_output]
+        STDOUT.puts result # only thing that goes to stdout
+      end
+    end
+
+    def guesser
+      @guesser ||= Guesser.new(@provided_function_name)
+    end
+
+    def ensure_guesses_found!
+      unless guesser.class_name and guesser.method_name
+        puts guesser.error_message
+        exit
+      end
+    end
+
+    # @event is String because it can be the file:// notation
+    # Returns text String for the lambda.invoke payload.
+    def transformed_event
+      text = @event
+      if text && text.include?("file://")
+        text = load_event_from_file(text)
+      end
+
+      check_valid_json!(text)
+
+      puts "Function name: #{function_name.color(:green)}" unless @options[:mute]
+      return text unless function_name.include?("_controller-")
+      return text if @options[:lambda_proxy] == false
+
+      event = JSON.load(text)
+      lambda_proxy = {"queryStringParameters" => event}
+      JSON.dump(lambda_proxy)
+    end
+
+    def load_event_from_file(text)
+      path = text.gsub('file://','')
+      path = "#{Jets.root}/#{path}" unless path[0..0] == '/'
+      unless File.exist?(path)
+        puts "File #{path} does not exist.  Are you sure the file exists?".color(:red)
+        exit
+      end
+      text = IO.read(path)
+    end
+
+    # Exits with friendly error message when user provides bad just
+    def check_valid_json!(text)
+      JSON.load(text)
+    rescue JSON::ParserError => e
+      puts "Invalid json provided:\n  '#{text}'"
+      puts "Exiting... Please try again and provide valid json."
+      exit 1
+    end
+
+    # So use can quickly paste this into their browser if they want to see the function
+    # via the Lambda console
+    def add_console_link_to_clipboard
+      return unless RUBY_PLATFORM =~ /darwin/
+      return unless system("type pbcopy > /dev/null")
+
+      # TODO: for add_console_link_to_clipboard get the region from the ~/.aws/config and AWS_PROFILE setting
+      region = Aws::S3::Client.new.config.region || ENV["AWS_REGION"] ||'us-east-1'
+      link = "https://console.aws.amazon.com/lambda/home?region=#{region}#/functions/#{function_name}?tab=configuration"
+      system("echo #{link} | pbcopy")
+      puts "Pro tip: The Lambda Console Link to the #{function_name} function has been added to your clipboard." unless @options[:mute]
+    end
+
+    # TODO: Hook client_context up and make sure it works. Think I've figure out how to sign client_context below.
+    # Client context must be a valid Base64-encoded JSON object
+    # Example: http://docs.aws.amazon.com/mobileanalytics/latest/ug/PutEvents.html
+    def client_context
+      context = {
+        "client" => {
+          "client_id" => "Jets",
+          "app_title" => "jets call cli",
+          "app_version_name" => Jets::VERSION,
+        },
+        "custom" => {},
+        "env" =>{
+          "platform" => RUBY_PLATFORM,
+          "platform_version" => RUBY_VERSION,
+        }
+      }
+      Base64.encode64(JSON.dump(context))
+    end
+
+    # For this class redirect puts to stderr so user can pipe output to tools like
+    # jq. Example:
+    #   jets call posts_controller-index '{"test":1}' | jq .
+    def puts(text)
+      $stderr.puts(text)
+    end
+
+    def lambda_client
+      opt = {}
+      opt = opt.merge({retry_limit: @options[:retry_limit]}) if @options[:retry_limit].present?
+      opt = opt.merge({http_read_timeout: @options[:read_timeout]}) if @options[:read_timeout].present?
+
+      if opt.empty?
+        aws_lambda
+      else
+        Aws::Lambda::Client.new(opt)
+      end
+    end
+  end
+end

data/lib/jets/commands/call/guesser.rb

@@ -25,7 +25,7 @@
 #
 # Now we're at a point where we can start guessing
 # function_name = detect_function_name(function_name)
-class Jets::Commands::Call
+module Jets::Commands::Call
   class Guesser
     delegate :class_name, :method_name, :error_message, :function_name,
       to: :delegate_guesser

data/lib/jets/commands/clean/base.rb

@@ -1,4 +1,4 @@
-class Jets::Commands::Clean
+module Jets::Commands::Clean
   class Base
     def initialize(options={})
       @options = options

data/lib/jets/commands/clean/build.rb

@@ -1,6 +1,6 @@
 require 'fileutils'
 
-class Jets::Commands::Clean
+module Jets::Commands::Clean
   class Build < Base
     def clean
       are_you_sure?("delete /tmp/jets")

data/lib/jets/commands/clean/clean_command.rb

@@ -0,0 +1,15 @@
+module Jets::Command
+  class CleanCommand < Base # :nodoc:
+    desc "log", "Cleans CloudWatch log groups assocated with app"
+    long_desc Help.text("clean/log")
+    def log
+      Jets::Commands::Clean::Log.new(options).clean
+    end
+
+    desc "build", "Cleans jets build"
+    long_desc Help.text("clean/build")
+    def build
+      Jets::Commands::Clean::Build.new(options).clean
+    end
+  end
+end

data/lib/jets/commands/clean/log.rb

@@ -8,7 +8,7 @@
 # log groups and we don't want to overly-aggressively delete them.
 #
 # The `keep_prefixes(log_group_names)` method calcuates the log groups to keep.
-class Jets::Commands::Clean
+module Jets::Commands::Clean
   class Log < Base
     extend Memoist
     include Jets::AwsServices

data/lib/jets/commands/configure/configure_command.rb

@@ -0,0 +1,9 @@
+module Jets::Command
+  class ConfigureCommand < Base # :nodoc:
+    desc "configure [TOKEN]", "configure token and updates ~/.jets/config.yml"
+    long_desc Help.text(:configure)
+    def perform(token=nil)
+      Jets::Api::Config.instance.update_token(token)
+    end
+  end
+end

data/lib/jets/commands/console/console_command.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "irb"
+require "irb/completion"
+
+module Jets::Command
+  class ConsoleCommand < Base # :nodoc:
+    include EnvironmentArgument
+
+    desc "console", "REPL console with Jets environment loaded"
+    long_desc Help.text(:console)
+    def perform
+      extract_environment_option_from_argument
+      require_application_and_environment!
+      Console.new(options).run
+    end
+  end
+
+  class Console
+    attr_reader :environment
+
+    def initialize(environment)
+      @environment = environment
+    end
+
+    def run
+      puts Jets::Booter.message
+
+      # Thanks: https://mutelight.org/bin-console
+      require "irb"
+      require "irb/completion"
+
+      ARGV.clear # https://stackoverflow.com/questions/33070092/irb-start-not-starting/33136762
+      IRB.start
+    end
+  end
+
+end

data/lib/jets/commands/credentials/USAGE

@@ -0,0 +1,103 @@
+## Storing Encrypted Credentials in Source Control
+
+The Jets `credentials` commands provide access to encrypted credentials,
+so you can safely store access tokens, database passwords, and the like
+safely inside the app without relying on a mess of ENVs.
+
+This also allows for atomic deploys: no need to coordinate key changes
+to get everything working as the keys are shipped with the code.
+
+## Setup
+
+Applications after Jets 5 automatically have a basic credentials file generated
+that just contains the secret_key_base used by MessageVerifiers/MessageEncryptors, like the ones
+signing and encrypting cookies.
+
+For applications created prior to Jets 5, we'll automatically generate a new
+credentials file in `config/credentials.yml.enc` the first time you run `bin/jets credentials:edit`.
+If you didn't have a master key saved in `config/master.key`, that'll be created too.
+
+Don't lose this master key! Put it in a password manager your team can access.
+Should you lose it no one, including you, will be able to access any encrypted
+credentials.
+
+Don't commit the key! Add `config/master.key` to your source control's
+ignore file. If you use Git, Jets handles this for you.
+
+Jets also looks for the master key in `ENV["JETS_MASTER_KEY"]`, if that's easier to manage.
+
+You could prepend that to your server's start command like this:
+
+    JETS_MASTER_KEY="very-secret-and-secure" server.start
+
+## Set up Git to Diff Credentials
+
+Jets provides `bin/jets credentials:diff --enroll` to instruct Git to call
+`bin/jets credentials:diff` when `git diff` is run on a credentials file.
+
+Running the command enrolls the project such that all credentials files use the
+"jets_credentials" diff driver in .gitattributes.
+
+Additionally since Git requires the driver itself to be set up in a config file
+that isn't tracked Jets automatically ensures it's configured when running
+`credentials:edit`.
+
+Otherwise each co-worker would have to run enable manually, including on each new
+repo clone.
+
+To disenroll from this feature, run `bin/jets credentials:diff --disenroll`.
+
+## Editing Credentials
+
+This will open a temporary file in `$EDITOR` with the decrypted contents to edit
+the encrypted credentials.
+
+When the temporary file is next saved the contents are encrypted and written to
+`config/credentials.yml.enc` while the file itself is destroyed to prevent credentials
+from leaking.
+
+## Environment Specific Credentials
+
+The `credentials` command supports passing an `--environment` option to create an
+environment specific override. That override will take precedence over the
+global `config/credentials.yml.enc` file when running in that environment. So:
+
+    bin/jets credentials:edit --environment development
+
+will create `config/credentials/development.yml.enc` with the corresponding
+encryption key in `config/credentials/development.key` if the credentials file
+doesn't exist.
+
+The encryption key can also be put in `ENV["JETS_MASTER_KEY"]`, which takes
+precedence over the file encryption key.
+
+In addition to that, the default credentials lookup paths can be overridden through
+`config.credentials.content_path` and `config.credentials.key_path`.
+
+## Editor wait
+
+For editors that fork and exit immediately, it's important to pass a wait flag,
+otherwise the credentials will be saved immediately with no chance to edit.
+
+    EDITOR="code --wait" jets credentials:edit
+
+## Accessing in App
+
+Let's say you have credentials like so:
+
+    ❯ jets credentials:show
+    secret_key_base: somesecretvalue
+    foo: bar
+
+You can access them in the app like so:
+
+    ❯ jets console
+    > Jets.application.credentials.secret_key_base
+    => "somesecretvalue"
+    > Jets.application.credentials.foo
+    => "bar"
+    > Jets.application.credentials.does_not_exist
+    => nil
+
+Remember, when you deploy this to Lambda you should set the `JETS_MASTER_KEY`. You set it with [Env Files](https://rubyonjets.com/docs/env-files/). Otherwise the `Jets.application.credentials.xx` values will return `nil`.
+