jets 5.0.17 → 6.0.0.beta1

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

@@ -1,184 +0,0 @@
-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 result.nil? || @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

@@ -1,48 +0,0 @@
-# Guesser transforms the user provided function name to the actual lambda
-# function name.
-#
-# Allow for variety of different inputs to work:
-# Simple:
-#   admin/pages_controller-index => admin-pages_controller-index
-#   admin-pages_controller-index => admin-pages_controller-index
-#
-# Complex, requires detecting the right class name:
-#   admin/related_pages_controller-list_all
-#   admin-related-pages-controller-list-all
-#
-# All still result in: admin-related_pages_controller-index
-#
-# The detection process follows. Given worse case:
-#   admin-related-pages-controller-list-all
-#
-# Know that the action comes after controller, try:
-#   AdminRelatedPagesController
-#   Admin::RelatedPagesController <= found stop guessing
-#
-# admin/related_pages_controller <= underscored
-# admin/related_pages_controller-list_all <= add action back on
-# admin-related_pages_controller-list_all <= gsub / - DONE
-#
-# Now we're at a point where we can start guessing
-# function_name = detect_function_name(function_name)
-module Jets::Commands::Call
-  class Guesser
-    delegate :class_name, :method_name, :error_message, :function_name,
-      to: :delegate_guesser
-
-    # Example of provided_function_name:
-    #   admin/related_pages_controller-list_all
-    #   admin-related-pages-controller-list-all
-    def initialize(provided_function_name)
-      @provided_function_name = provided_function_name
-    end
-
-    def delegate_guesser
-      @delegate_guesser ||= if @provided_function_name =~ /[-_](controller|job|rule)/
-                              AutoloadGuesser.new(@provided_function_name)
-                            else
-                              AnonymousGuesser.new(@provided_function_name)
-                            end
-    end
-  end
-end

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

@@ -1,24 +0,0 @@
-module Jets::Commands::Clean
-  class Base
-    def initialize(options={})
-      @options = options
-    end
-
-  private
-    def say(message)
-      prefix = 'NOOP ' if @options[:noop]
-      puts "#{prefix}#{message}" unless @options[:mute]
-    end
-
-    def are_you_sure?(message)
-      return true if @options[:yes]
-
-      puts "Are you sure that you want to #{message}? (y/N)"
-      yes = $stdin.gets.strip
-      unless yes =~ /^y/
-        puts "Phew that was close!"
-        exit 0
-      end
-    end
-  end
-end

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

@@ -1,13 +0,0 @@
-require 'fileutils'
-
-module Jets::Commands::Clean
-  class Build < Base
-    def clean
-      are_you_sure?("delete /tmp/jets")
-
-      say "Removing /tmp/jets..."
-      FileUtils.rm_rf("/tmp/jets") unless @options[:noop]
-      say "Removed /tmp/jets"
-    end
-  end
-end

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

@@ -1,15 +0,0 @@
-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

@@ -1,111 +0,0 @@
-# The thing that limits this implementation is that there needs to be at least
-# one lambda function created from an internal jets function. Example:
-#
-#   /aws/lambda/demo-dev-2-jets-preheat_job-warm
-#   /aws/lambda/demo-dev-2-jets-public_controller-show
-#
-# We're doing this because Jets.extra environments can create additional matching
-# 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.
-module Jets::Commands::Clean
-  class Log < Base
-    extend Memoist
-    include Jets::AwsServices
-
-    def clean
-      are_you_sure?("delete CloudWatch logs")
-
-      say "Removing CloudWatch logs for #{prefix_guess}..."
-      log_groups.each do |g|
-        next if keep_log_group?(g.log_group_name)
-        delete_log_group(g.log_group_name) unless @options[:noop]
-        say "Removed log group: #{g.log_group_name}"
-      end
-      say "Removed CloudWatch logs for #{prefix_guess}"
-    end
-
-    def delete_log_group(log_group_name)
-      logs.delete_log_group(log_group_name: log_group_name)
-    end
-
-    def clean_deploys
-      groups = deploy_log_groups.sort_by do |g|
-        g.log_group_name
-      end
-      # Keep the last 2 recent log groups so we can see the deleted logic
-      groups = groups[0..-3]
-      groups.each do |g|
-        logs.delete_log_group(log_group_name: g.log_group_name) unless @options[:noop]
-      end
-    end
-
-    def deploy_log_groups
-      log_groups.select do |g|
-        !keep_log_group?(g.log_group_name) &&
-        g.log_group_name.include?('jets-base-path')
-      end
-    end
-
-  private
-    def prefix_guess
-      Jets::Names.parent_stack_name
-    end
-
-    def log_groups
-      groups, next_token = [], true
-      while next_token
-        next_token = nil if next_token == true # just at start the loop
-        resp = logs.describe_log_groups(
-          log_group_name_prefix: "/aws/lambda/#{prefix_guess}-",
-          next_token: next_token,
-        )
-        groups += resp.log_groups
-        next_token = resp.next_token
-      end
-      groups
-    end
-    memoize :log_groups
-
-    def log_group_names
-      log_groups.map(&:log_group_name)
-    end
-
-    def all_prefixes(log_group_names)
-      log_prefixes(log_group_names)
-    end
-    memoize :all_prefixes
-
-    # Check for the prefixes to keep. The slightly tricky thing to watch for is
-    # for the prefix matching addiitonal log groups that belong to other
-    # JETS_EXTRA=xxx created environments.
-    #
-    # We find and store the prefixes to keep so we don't over aggressively delete
-    # log groups.
-    def keep_prefixes(log_group_names)
-      names = log_group_names.reject do |name|
-        name =~ %r{/aws/lambda/#{prefix_guess}-jets}
-      end
-      log_prefixes(names)
-    end
-    memoize :keep_prefixes
-
-    # Strips -jets.* from the full log group name to leave only the prefix behind
-    def log_prefixes(names)
-      names = names.select do |name|
-        name.match(Regexp.new("#{prefix_guess}-.*jets"))
-      end
-      names.map do |name|
-        name.sub(/-jets.*/,'')
-      end.uniq.sort
-    end
-
-    # Check if it is safe to delete the log group
-    def keep_log_group?(log_group_name)
-      keep_prefixes = keep_prefixes(log_group_names)
-      !!keep_prefixes.detect do |keep_prefix|
-        log_group_name =~ Regexp.new(keep_prefix)
-      end
-    end
-  end
-end

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

@@ -1,9 +0,0 @@
-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

@@ -1,38 +0,0 @@
-# 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

@@ -1,103 +0,0 @@
-## 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`.
-

data/lib/jets/commands/credentials/credentials_command/diffing.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-module Jets::Command::CredentialsCommand::Diffing # :nodoc:
-  GITATTRIBUTES_ENTRY = <<~END
-    config/credentials/*.yml.enc diff=jets_credentials
-    config/credentials.yml.enc diff=jets_credentials
-  END
-
-  def enroll_project_in_credentials_diffing
-    if enrolled_in_credentials_diffing?
-      say "Project is already enrolled in credentials file diffing."
-    else
-      gitattributes.write(GITATTRIBUTES_ENTRY, mode: "a")
-
-      say "Enrolled project in credentials file diffing!"
-      say "Jets ensures the jets_credentials diff driver is set when running `credentials:edit`. See `credentials:help` for more."
-    end
-  end
-
-  def disenroll_project_from_credentials_diffing
-    if enrolled_in_credentials_diffing?
-      gitattributes.write(gitattributes.read.gsub(GITATTRIBUTES_ENTRY, ""))
-      gitattributes.delete if gitattributes.empty?
-
-      say "Disenrolled project from credentials file diffing!"
-    else
-      say "Project is not enrolled in credentials file diffing."
-    end
-  end
-
-  def ensure_diffing_driver_is_configured
-    configure_diffing_driver if enrolled_in_credentials_diffing? && !diffing_driver_configured?
-  end
-
-  private
-    def enrolled_in_credentials_diffing?
-      gitattributes.file? && gitattributes.read.include?(GITATTRIBUTES_ENTRY)
-    end
-
-    def diffing_driver_configured?
-      system "git config --get diff.jets_credentials.textconv", out: File::NULL
-    end
-
-    def configure_diffing_driver
-      system "git config diff.jets_credentials.textconv 'bin/jets credentials:diff'"
-    end
-
-    def gitattributes
-      Jets.root.join(".gitattributes")
-    end
-end