jets 4.0.10 → 5.0.0

data/lib/jets/cfn/template_source.rb

@@ -1,61 +0,0 @@
-module Jets::Cfn
-  class TemplateSource
-    include Jets::AwsServices
-
-    attr_reader :path
-
-    def initialize(path, options)
-      @path = path
-      @options = options
-    end
-
-    def body
-      @body ||= IO.read(path)
-    end
-
-    def url
-      @url ||= upload_file_to_s3
-    end
-
-    def to_h
-      if upload_to_s3?
-        from_s3
-      else
-        from_path
-      end
-    end
-
-    private
-
-    def upload_to_s3?
-      bucket_name.present?
-    end
-
-    def from_s3
-      {
-        template_url: url
-      }
-    end
-
-    def from_path
-      {
-        template_body: body
-      }
-    end
-
-    def upload_file_to_s3
-      obj = s3_resource.bucket(bucket_name).object(s3_key)
-      obj.upload_file(path)
-
-      "https://s3.amazonaws.com/#{bucket_name}/#{s3_key}"
-    end
-
-    def bucket_name
-      @options[:s3_bucket]
-    end
-
-    def s3_key
-      @s3_key ||= "jets/cfn-templates/#{File.basename(path)}"
-    end
-  end
-end

data/lib/jets/commands/base.rb

@@ -1,145 +0,0 @@
-require "thor"
-
-# Override thor's long_desc identation behavior
-# https://github.com/erikhuda/thor/issues/398
-class Thor
-  module Shell
-    class Basic
-      def print_wrapped(message, options = {})
-        message = "\n#{message}" unless message.starts_with?("\n")
-        stdout.puts message
-      end
-    end
-  end
-end
-
-class Jets::Commands::Base < Thor
-  class << self
-    extend Memoist
-
-    # thor_args is an array of commands. Examples:
-    #   ["help"]
-    #   ["dynamodb:migrate"]
-    #
-    # Same signature as RakeCommand.perform.  Not using full_command.
-    def perform(full_command, thor_args)
-      config = {} # doesnt seem like config is used
-      dispatch(nil, thor_args, nil, config)
-    end
-
-    # Hacky way to handle error for 'jets new' when no project name is passed in to avoid
-    # this error:
-    #
-    #   required arguments 'project_name' (Thor::RequiredArgumentMissingError)
-    def dispatch(command, given_args, given_opts, config)
-      if given_args.reject{|s| s =~ /^-/} == ['new'] # user forgot to pass a project name
-        given_args = ['help', 'new']
-      end
-      super
-    end
-
-    # Track all command subclasses.
-    def subclasses
-      @subclasses ||= []
-    end
-
-    def inherited(base)
-      super
-
-      if base.name
-        self.subclasses << base
-      end
-    end
-
-    # Fully qualifed task names. Examples:
-    #   build
-    #   process:controller
-    #   dynamodb:migrate:down
-    def namespaced_commands
-      eager_load!
-      subclasses.map do |klass|
-        # This all_tasks is part of Thor not the lambda/dsl.rb
-        klass.all_tasks.keys.map do |task_name|
-          klass = klass.to_s.sub('Jets::Commands::','')
-          namespace = klass =~ /^Main/ ? nil : klass.underscore.gsub('/',':')
-          [namespace, task_name].compact.join(':')
-        end
-      end.flatten.sort
-    end
-
-    # Use Jets banner instead of Thor to account for namespaces in commands.
-    def banner(command, namespace = nil, subcommand = false)
-      namespace = namespace_from_class(self)
-      command_name = command.usage # set with desc when defining tht Thor class
-      namespaced_command = [namespace, command_name].compact.join(':')
-
-      "jets #{namespaced_command}"
-    end
-
-    def namespace_from_class(klass)
-      namespace = klass.to_s.sub('Jets::Commands::', '').underscore.gsub('/',':')
-      namespace unless namespace == "main"
-    end
-
-    def help_list(all=false)
-      # hack to show hidden comands when requested
-      Thor::HiddenCommand.class_eval do
-        def hidden?; false; end
-      end if all
-
-      list = []
-      eager_load!
-      subclasses.each do |klass|
-        commands = klass.printable_commands(true, false)
-        commands.reject! { |array| array[0].include?(':help') }
-        list += commands
-      end
-
-      list.sort_by! { |array| array[0] }
-    end
-
-    def klass_from_namespace(namespace)
-      if namespace.nil?
-        Jets::Commands::Main
-      else
-        class_name = namespace.gsub(':','/')
-        class_name = "Jets::Commands::#{class_name.camelize}"
-        class_name.constantize
-      end
-    end
-
-    # If this fails to find a match then return the original full command
-    def autocomplete(full_command)
-      return nil if full_command.nil? # jets help
-
-      eager_load!
-
-      words = full_command.split(':')
-      namespace = words[0..-2].join(':') if words.size > 1
-      command = words.last
-
-      # Thor's normalize_command_name autocompletes the command but then we need to add the namespace back
-      begin
-        thor_subclass = klass_from_namespace(namespace) # could NameError
-        command = thor_subclass.normalize_command_name(command) # could Thor::AmbiguousCommandError
-        [namespace, command].compact.join(':')
-      rescue NameError
-        full_command # return original full_command
-      rescue Thor::AmbiguousCommandError => e
-        puts "Unable to autodetect the command name. #{e.message}."
-        full_command # return original full_command
-      end
-    end
-
-    # For help menu to list all commands, we must eager load the command classes.
-    #
-    # There is special eager_load logic here because this is called super early as part of the CLI start.
-    # We cannot assume we have full access to to the project yet.
-    def eager_load!
-      return if Jets::Turbo.afterburner?
-
-      Jets::Autoloaders.cli.eager_load
-    end
-    memoize :eager_load!
-  end
-end

data/lib/jets/commands/call.rb

@@ -1,184 +0,0 @@
-require "base64"
-require "json"
-
-class Jets::Commands::Call
-  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.starts_with?(Jets.config.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.config.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::PolyFun.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_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

data/lib/jets/commands/clean.rb

@@ -1,19 +0,0 @@
-module Jets::Commands
-  class Clean < Jets::Commands::Base
-    class_option :noop, type: :boolean, desc: "noop or dry-run mode"
-    class_option :mute, type: :boolean, desc: "mute output"
-    class_option :yes, aliases: "y", type: :boolean, desc: "bypass are you sure prompt"
-
-    desc "log", "Cleans CloudWatch log groups assocated with app"
-    long_desc Help.text('clean:log')
-    def log
-      Log.new(options).clean
-    end
-
-    desc "build", "Cleans jets build"
-    long_desc Help.text('clean:build')
-    def build
-      Build.new(options).clean
-    end
-  end
-end

data/lib/jets/commands/configure.rb

@@ -1,51 +0,0 @@
-module Jets::Commands
-  class Configure
-    extend Memoist
-
-    def initialize(options)
-      @options = options
-    end
-
-    def run
-      data = load_yaml
-      data['key'] = token
-      FileUtils.mkdir_p(File.dirname(path))
-      IO.write(path, YAML.dump(data))
-      puts "Updated #{pretty(path)}"
-    end
-
-    def load_yaml
-      if File.exist?(path)
-        Jets::Util::Yamler.load_file(path)
-      else
-        {}
-      end
-    rescue Psych::SyntaxError => e
-      puts "WARN: There was an error reading #{pretty(path)}".color(:yellow)
-      puts "WARN: #{e.class} #{e.message}".color(:yellow)
-      {}
-    end
-
-    def pretty(path)
-      path.sub(ENV['HOME'], '~')
-    end
-
-    def path
-      "#{ENV['HOME']}/.jets/config.yml"
-    end
-
-    def token
-      @options[:token] || prompt
-    end
-    memoize :token
-
-    def prompt
-      puts <<~EOL
-        You are about to configure your ~/.jets/config.yml
-        You can get a token from serverlessgems.com
-      EOL
-      print "Please provide your token: "
-      $stdin.gets.strip
-    end
-  end
-end

data/lib/jets/commands/console.rb

@@ -1,18 +0,0 @@
-class Jets::Commands::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

data/lib/jets/commands/db/environment-task.rake

@@ -1,3 +0,0 @@
-task :environment do
-  Jets.boot
-end

data/lib/jets/commands/db/tasks/dummy/app.rb

@@ -1,25 +0,0 @@
-require "recursive-open-struct"
-
-module Jets::Commands::Db::Tasks::Dummy
-  class App
-    def config
-      Config.new(
-        active_record: {
-          belongs_to_required_by_default: true
-        },
-        paths: {
-          db: ["db"],
-          "db/migrate": ["db/migrate"]
-        }
-      )
-    end
-
-    def paths
-      RecursiveOpenStruct.new(
-        paths: {
-          "db/migrate": ["db/migrate"]
-        }
-      )
-    end
-  end
-end

data/lib/jets/commands/db/tasks/dummy/config.rb

@@ -1,14 +0,0 @@
-require "recursive-open-struct"
-
-module Jets::Commands::Db::Tasks::Dummy
-  class Config < RecursiveOpenStruct
-    def load_database_yaml # :nodoc:
-      require "rails/application/dummy_erb_compiler"
-
-      path = "#{Jets.root}/config/database.yml"
-      yaml = Pathname.new(path)
-      erb = DummyERB.new(yaml.read)
-      YAML.load(erb.result) || {}
-    end
-  end
-end

data/lib/jets/commands/db/tasks.rb

@@ -1,34 +0,0 @@
-class Jets::Commands::Db::Tasks
-  # Ugly but it loads ActiveRecord database tasks
-  def self.load!
-    # Lazy require rails so Rails const is only defined in jets db:* tasks
-    require "rails"
-    require "active_record"
-
-    # Jets.boot # Jets.boot here screws up jets -h, the db_config doesnt seem to match exactly
-    # but seems to be working anyway.
-    db_configs = Jets.application.config.database
-    ActiveRecord::Tasks::DatabaseTasks.database_configuration = db_configs
-    ActiveRecord::Tasks::DatabaseTasks.migrations_paths = ["db/migrate"]
-    ActiveRecord::Tasks::DatabaseTasks.seed_loader = Seeder.new("#{Jets.root}/db/seeds.rb")
-
-    # Need to mock out the usage of Rails.application in:
-    # activerecord-5.1.4/lib/active_record/tasks/database_tasks.rb
-    Rails.application = Dummy::App.new
-    load "active_record/railties/databases.rake"
-    load File.expand_path("../environment-task.rake", __FILE__)
-  end
-
-
-  # Thanks: https://stackoverflow.com/questions/19206764/how-can-i-load-activerecord-database-tasks-on-a-ruby-project-outside-rails/24840749
-  class Seeder
-    def initialize(seed_file)
-      @seed_file = seed_file
-    end
-
-    def load_seed
-      raise "Seed file '#{@seed_file}' does not exist" unless File.file?(@seed_file)
-      load @seed_file
-    end
-  end
-end

data/lib/jets/commands/db.rb

@@ -1,13 +0,0 @@
-module Jets::Commands
-  class Db < Jets::Commands::Base
-    desc "generate", "Creates a migration to change a db table"
-    long_desc Help.text('db:generate')
-    def generate(*args)
-      require "rails/generators"
-      require "rails/generators/active_record/migration/migration_generator"
-
-      generator = ActiveRecord::Generators::MigrationGenerator.new(args)
-      generator.create_migration_file
-    end
-  end
-end