jets 3.1.0 → 5.0.10

data/lib/jets/command/help/call.md

@@ -0,0 +1,48 @@
+## Remote mode
+
+Invoke the lambda function on AWS.
+
+## Examples
+
+### Controller Examples
+
+    jets call controller '{"path": "/up", "httpMethod": "GET"}' --show-logs | jq
+
+You'll need to specify enough of the event payload so that the Jets shim handler can find the route and send it to the right controller action.
+
+    jets call controller '{"path":"/posts"}' --show-logs | jq .
+    jets call controller 'file://event.json' --show-logs | jq .
+
+## Job Examples
+
+    jets call hard_job-drive '{"test":1}'
+    jets call hard_job-drive '{"test":1}' | jq .
+    jets call hard_job-drive file://event.json | jq . # load event with a file
+
+
+The equivalent AWS Lambda CLI command:
+
+    aws lambda invoke --function-name demo-dev-hard_job-dig --payload '{"path":"/posts","test":1}' outfile.txt
+    cat outfile.txt | jq '.'
+
+Jets figures out what functions to call by evaluating the app code and finds if the class and method exists.  If you want to turn guess mode off and want to always explicitly provide the method name use the `--no-guess` option.  The function name will then have to match the lambda function without the namespace. Example:
+
+    jets call controller --no-guess
+
+If you want to call a function which runs too long time, you can set `read_timeout`.
+
+    jets call some_long_job-index --read_timeout 900
+
+And you can set `retry_limit`. If you don't want to retry you can set 0.
+
+    jets call some_long_job-index --retry_limit 0
+
+## Local mode
+
+Instead of calling AWS lambda remote, you can also have `jets call` use the code directly on your machine.  To enable this, use the `--local` flag. Example:
+
+    jets call hard_job-drive --local
+
+## Logs
+
+The `jets call` command can also print out the last 4KB of the lambda logs with the `--show-logs` option. The logging output is directed to stderr and the response output from the lambda function itself is directed to stdout so you can safely pipe the results of the call command to other tools like `jq`.

data/lib/jets/{commands → command}/help/deploy.md

@@ -5,7 +5,7 @@ This builds the project and deploys it AWS Lambda. The deployment is mainly hand
 ## Example
 
     $ jets deploy
-    Deploying to Lambda demo-dev environment...
+    Deploying stack demo-dev ...
     => Compling assets in current project directory
     => Copying current project directory to temporary build area: /tmp/jets/demo/app_root
     => Tidying project: removing ignored files to reduce package size.

data/lib/jets/command/help/gems/check.md

@@ -0,0 +1 @@
+Check if precompiled gems are available from Jets Pro.

data/lib/jets/command/help/logs.md

@@ -0,0 +1,21 @@
+Show logs from Lambda function CloudWatch log group.
+
+This defaults to the controller Lambda function in the `one_lambda_for_all_controllers` mode.  Example:
+
+    ❯ jets logs
+    Showing logs for /aws/lambda/demo-dev-controller
+
+If you want to follow the logs use the `-f` flag.
+
+    ❯ jets logs -f
+    Tailing logs for /aws/lambda/demo-dev-controller
+
+If you want to see the production logs:
+
+    ❯ JETS_ENV=production jets logs -f
+    Tailing logs for /aws/lambda/demo-prod-controller
+
+If you want to see logs for a job, specify the job and method.
+
+    ❯ jets logs -f -n hard_job-dig
+    Tailing logs for /aws/lambda/demo-dev-hard_job-dig

data/lib/jets/{commands → command}/help/new.md

@@ -1,10 +1,9 @@
 ## Examples
 
     $ jets new demo
-    Creating a new Jets project called demo.
-          create  demo/app/controllers/application_controller.rb
-          create  demo/app/helpers/application_helper.rb
-          create  demo/app/jobs/application_job.rb
+          create  app/controllers/application_controller.rb
+          create  app/helpers/application_helper.rb
+          create  app/jobs/application_job.rb
     ...
     ================================================================
     Congrats  You have successfully created a Jets project.

data/lib/jets/command/help/projects.md

@@ -0,0 +1,6 @@
+## Examples
+
+    ❯ jets projects
+    api
+    backend
+    demo

data/lib/jets/command/help/releases.md

@@ -0,0 +1,19 @@
+## Examples
+
+    $ jets releases
+    Releases for stack: demo-dev
+    +---------+-----------------+--------------+---------+
+    | Version |     Status      | Released At  | Message |
+    +---------+-----------------+--------------+---------+
+    | 3       | UPDATE_COMPLETE | 10 hours ago | Deploy  |
+    | 2       | UPDATE_COMPLETE | 18 hours ago | Deploy  |
+    | 1       | UPDATE_COMPLETE | 22 hours ago | Deploy  |
+    +---------+-----------------+--------------+---------+
+
+The shown releases are paginated. If you need to see more releases you can use the `--page` option.
+
+    $ jets releases --page 2
+
+## Other Commands
+
+  releases:info      View detailed information for a release

data/lib/jets/command/help/rollback.md

@@ -0,0 +1,5 @@
+## Examples
+
+    jets rollback 8
+
+Use the [jets releases](/reference/jets-releases/) command to view release history.

data/lib/jets/command/help/routes.md

@@ -0,0 +1,15 @@
+## Example
+
+    $ jets routes
+    +-------------------+--------+--------------------+--------------------+
+    |    As (Prefix)    |  Verb  | Path (URI Pattern) | Controller#action  |
+    +-------------------+--------+--------------------+--------------------+
+    | posts             | GET    | /posts             | posts#index        |
+    | posts             | POST   | /posts             | posts#create       |
+    | new_post          | GET    | /posts/new         | posts#new          |
+    | edit_post         | GET    | /posts/:id/edit    | posts#edit         |
+    | post              | GET    | /posts/:id         | posts#show         |
+    | post              | PUT    | /posts/:id         | posts#update       |
+    | post              | PATCH  | /posts/:id         | posts#update       |
+    | post              | DELETE | /posts/:id         | posts#destroy      |
+    +-------------------+--------+--------------------+--------------------+

data/lib/jets/command/help/runner.md

@@ -0,0 +1,40 @@
+## Examples
+
+    $ jets runner 'puts "hi"'
+    hi
+    $ jets runner 'puts Jets.env'
+    development
+
+Using a script in a file.  Let's say you have a script:
+
+script.rb:
+
+```ruby
+puts "hello world: #{Jets.env}"
+```
+
+    $ jets runner file://script.rb
+    hello world: development
+
+
+Optionally pass in an argument on the command line:
+
+    Usage: jets runner file|Ruby code [args]
+
+The argument will be assigned to the `args` variable.
+
+Example:
+
+    $ jets runner 'puts "hello world with args: #{args}"' 123
+    hello world with args: 123
+
+
+Example with script.rb:
+
+```ruby
+puts "hello world with args: #{args}"
+```
+
+    $ jets runner file://script.rb 123
+    hello world with args: 123
+

data/lib/jets/command/help/stacks.md

@@ -0,0 +1,6 @@
+## Examples
+
+    ❯ jets stacks
+    Stacks for project: demo
+    demo-dev
+    demo-prod

data/lib/jets/command/help.rb

@@ -0,0 +1,17 @@
+module Jets::Command
+  class Help
+    class << self
+      def text(namespaced_command)
+        file = namespaced_command.to_s.gsub(':','/')
+        path = File.expand_path("../help/#{file}.md", __FILE__)
+        return IO.read(path) if File.exist?(path)
+
+        # Also look up for a help folder within the current command folder
+        called_from = caller.first.split(':').first
+        unnamespaced_command = namespaced_command.to_s.split(':').last
+        path = File.expand_path("../help/#{unnamespaced_command}.md", called_from)
+        return IO.read(path) if File.exist?(path)
+      end
+    end
+  end
+end

data/lib/jets/command/helpers/editor.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "active_support/encrypted_file"
+
+module Jets
+  module Command
+    module Helpers
+      module Editor
+        private
+          def ensure_editor_available(command:)
+            if ENV["EDITOR"].to_s.empty?
+              say "No $EDITOR to open file in. Assign one like this:"
+              say ""
+              say %(EDITOR="mate --wait" #{command})
+              say ""
+              say "For editors that fork and exit immediately, it's important to pass a wait flag,"
+              say "otherwise the credentials will be saved immediately with no chance to edit."
+
+              false
+            else
+              true
+            end
+          end
+
+          def catch_editing_exceptions
+            yield
+          rescue Interrupt
+            say "Aborted changing file: nothing saved."
+          rescue ActiveSupport::EncryptedFile::MissingKeyError => error
+            say error.message
+          end
+      end
+    end
+  end
+end

data/lib/jets/command/rake_decorate.rb

@@ -0,0 +1,38 @@
+module Jets::Command
+  module RakeDecorate
+    # Decorate this method because this does not get called until runtime.
+    # It's "lazy loaded" so we can avoid the Rails const being defined in general.
+    def [](task_name, scopes=nil)
+      super # => Rake::TaskManager#[]
+    rescue RuntimeError => e
+      # We require dummy/rails since this time because all the rake tasks have been loaded
+      # and we need to load dummy/rails to get the database configurations. Normally,
+      # we do not want to require dummy/rails because it defines the Rails.
+      # However, a "command not found" error, more accurately,
+      # a "rake task not found" error, has already been encountered.
+      # Also:
+      # require "dummy/rails" to prevent another error.
+      #   from lib/active_record/railties/databases.rake
+      #
+      #   NoMethodError: undefined method `env' for Rails:Module (NoMethodError)
+      #     database_configs = ActiveRecord::DatabaseConfigurations.new(databases).configs_for(env_name: Rails.env)
+      #
+      require "jets/overrides/dummy/rails"
+
+      # Original error message from rake is something like this
+      #
+      #   Don't know how to build task 'foo:bar' (See the list of available tasks with `jets --tasks`)
+      #
+      # With an ugly backtrace.
+      # We override the error message to be more user friendly.
+      #
+      # All of that in order for
+      #   jets foo:bar
+      # to show a pretty error message.
+      $stderr.puts "ERROR: Could not find command: #{task_name.inspect}".color(:red)
+      require "jets/commands/help/help_command"
+      Jets::Command::HelpCommand.new.help
+      exit 1
+    end
+  end
+end

data/lib/jets/command.rb

@@ -0,0 +1,142 @@
+# 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)
+
+    cattr_accessor :original_cli_command
+
+    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
+        Jets::Command.original_cli_command = full_namespace
+
+        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
+          # Decorate the rake [] method in order to rescue the error and print out
+          # a user friendly message. This works to catch rake errors but
+          # unsure why cannot just rescue RuntimeError here.
+          # More details in the RakeDecorate module.
+          require "rake/application"
+          Rake::Application.send(:include, RakeDecorate)
+          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
+
+        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
+
+      private
+        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,46 @@
+# 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)
+        version_flags = %w[-v --version] & args
+        unless version_flags.empty?
+          puts "Jets #{Jets::VERSION}"
+          return
+        end
+
+        # 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)
@@ -56,7 +56,7 @@ class Jets::Commands::Call
 
     @@parent_stack = nil
     def parent_stack
-      @@parent_stack ||= cfn.describe_stacks(stack_name: Jets::Naming.parent_stack_name).stacks.first
+      @@parent_stack ||= cfn.describe_stacks(stack_name: Jets::Names.parent_stack_name).stacks.first
     end
   end
 end

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