jets-fs 1.6.10

data/lib/jets/controller/request.rb

@@ -0,0 +1,29 @@
+require 'rack/request'
+
+class Jets::Controller
+  class Request < ::Rack::Request
+    def initialize(event, context)
+      @event, @context = event, context
+      super(env)
+    end
+
+    def env
+      @env ||= Jets::Controller::Rack::Env.new(@event, @context).convert # convert to Rack env
+    end
+
+    # When request hits the middleware Controller::Rack::Middleware::Main endpoint
+    # We set the it with the updated env since it could had been mutated down the
+    # middleware stack.
+    def set_env!(env)
+      @env = env
+    end
+
+    # API Gateway is inconsistent about how it cases it keys.
+    # Sometimes it is "x-requested-with" vs "X-Requested-With"
+    # Normalize it with downcase.
+    def headers
+      headers = @event["headers"] || {}
+      headers.transform_keys { |key| key.downcase }
+    end
+  end
+end

data/lib/jets/controller/response.rb

@@ -0,0 +1,61 @@
+require 'rack/response'
+
+class Jets::Controller
+  # The response object. See Rack::Response and Rack::Response::Helpers for
+  # more info:
+  # http://rubydoc.info/github/rack/rack/master/Rack/Response
+  # http://rubydoc.info/github/rack/rack/master/Rack/Response/Helpers
+  class Response < ::Rack::Response
+    DROP_BODY_RESPONSES = [204, 304]
+    def initialize(*)
+      super
+      # headers['Content-Type'] ||= 'text/html'
+    end
+
+    # TODO: unsure if we should even have these methods.  We dont really use them.
+    def body=(value)
+      value = value.body while Rack::Response === value
+      @body = String === value ? [value.to_str] : value
+    end
+
+    def each
+      block_given? ? super : enum_for(:each)
+    end
+
+    def finish
+      result = body
+
+      if drop_content_info?
+        headers.delete "Content-Length"
+        headers.delete "Content-Type"
+      end
+
+      if drop_body?
+        close
+        result = []
+      end
+
+      if calculate_content_length?
+        # if some other code has already set Content-Length, don't muck with it
+        # currently, this would be the static file-handler
+        headers["Content-Length"] = body.inject(0) { |l, p| l + p.bytesize }.to_s
+      end
+
+      [status.to_i, headers, result]
+    end
+
+    private
+
+    def calculate_content_length?
+      headers["Content-Type"] and not headers["Content-Length"] and Array === body
+    end
+
+    def drop_content_info?
+      status.to_i / 100 == 1 or drop_body?
+    end
+
+    def drop_body?
+      DROP_BODY_RESPONSES.include?(status.to_i)
+    end
+  end
+end

data/lib/jets/core.rb

@@ -0,0 +1,211 @@
+module Jets::Core
+  extend Memoist
+
+  def application
+    Jets::Application.instance
+  end
+
+  def config
+    application.config
+  end
+
+  def aws
+    application.aws
+  end
+
+  # Load all application base classes and project classes
+  def boot(options={})
+    Jets::Booter.boot!(options)
+  end
+
+  def root
+    # Do not memoize this method. Turbo mode can change it
+    root = ENV['JETS_ROOT'].to_s
+    root = Dir.pwd if root == ''
+    Pathname.new(root)
+  end
+
+  def env
+    env = ENV['JETS_ENV'] || 'development'
+    ENV['RAILS_ENV'] = ENV['RACK_ENV'] = env
+    ActiveSupport::StringInquirer.new(env)
+  end
+  memoize :env
+
+  def build_root
+    "/tmp/jets/#{config.project_name}".freeze
+  end
+  memoize :build_root
+
+  def logger
+    Jets.application.config.logger
+  end
+  memoize :logger
+
+  def webpacker?
+    Gem.loaded_specs.keys.include?("webpacker")
+  end
+  memoize :webpacker?
+
+  def load_tasks
+    Jets::Commands::RakeTasks.load!
+  end
+
+  def version
+    Jets::VERSION
+  end
+
+  def eager_load!
+    eager_load_jets
+    eager_load_app
+  end
+
+  # Eager load jet's lib and classes
+  def eager_load_jets
+    lib_jets = File.expand_path(".", File.dirname(__FILE__))
+    Dir.glob("#{lib_jets}/**/*.rb").select do |path|
+      next if !File.file?(path)
+      next if skip_eager_load_paths?(path)
+
+      path = path.sub("#{lib_jets}/","jets/")
+      class_name = path
+                    .sub(/\.rb$/,'') # remove .rb
+                    .sub(/^\.\//,'') # remove ./
+                    .sub(/app\/\w+\//,'') # remove app/controllers or app/jobs etc
+                    .camelize
+      # special class mappings
+      class_name = class_mappings(class_name)
+      class_name.constantize # use constantize instead of require so dont have to worry about order.
+    end
+  end
+
+  # Skip these paths because eager loading doesnt work for them.
+  def skip_eager_load_paths?(path)
+    path =~ %r{/cli} ||
+    path =~ %r{/core_ext} ||
+    path =~ %r{/default/application} ||
+    path =~ %r{/functions} ||
+    path =~ %r{/internal/app} ||
+    path =~ %r{/jets/stack} ||
+    path =~ %r{/overrides} ||
+    path =~ %r{/rackup_wrappers} ||
+    path =~ %r{/reconfigure_rails} ||
+    path =~ %r{/templates/} ||
+    path =~ %r{/turbo/project/} ||
+    path =~ %r{/version} ||
+    path =~ %r{/webpacker} ||
+    path =~ %r{/jets/spec}
+  end
+
+  def class_mappings(class_name)
+    map = {
+      "Jets::Io" => "Jets::IO",
+    }
+    map[class_name] || class_name
+  end
+
+  # Eager load user's application
+  def eager_load_app
+    Dir.glob("#{Jets.root}/app/**/*.rb").select do |path|
+      next if !File.file?(path) or path =~ %r{/javascript/} or path =~ %r{/views/}
+      next if path.include?('app/functions') || path.include?('app/shared/functions') || path.include?('app/internal/functions')
+
+      class_name = path
+                    .sub(/\.rb$/,'') # remove .rb
+                    .sub(%{^\./},'') # remove ./
+                    .sub("#{Jets.root}/",'')
+                    .sub(%r{app/shared/\w+/},'') # remove shared/resources or shared/extensions
+                    .sub(%r{app/\w+/},'') # remove app/controllers or app/jobs etc
+      class_name = class_name.classify
+      class_name.constantize # use constantize instead of require so dont have to worry about order.
+    end
+  end
+
+  # NOTE: In development this will always be 1 because the app gets reloaded.
+  # On AWS Lambda, this will be ever increasing until the container gets replaced.
+  @@call_count = 0
+  def increase_call_count
+    @@call_count += 1
+  end
+
+  def call_count
+    @@call_count
+  end
+
+  @@prewarm_count = 0
+  def increase_prewarm_count
+    @@prewarm_count += 1
+  end
+
+  def prewarm_count
+    @@prewarm_count
+  end
+
+  def project_namespace
+    [config.project_name, config.short_env, config.env_extra].compact.join('-').gsub('_','-')
+  end
+
+  def rack?
+    path = "#{Jets.root}/rack"
+    File.exist?(path) || File.symlink?(path)
+  end
+
+  def poly_only?
+    return true if ENV['JETS_POLY_ONLY'] # bypass to allow rapid development of handlers
+    Jets::Commands::Build.poly_only?
+  end
+
+  def report_exception(exception)
+    puts "DEPRECATED: report_exception. Use on_exception instead.".color(:yellow)
+    on_exception(exception)
+  end
+
+  def on_exception(exception)
+    Jets::Turbine.subclasses.each do |subclass|
+      reporters = subclass.on_exceptions || []
+      reporters.each do |label, block|
+        block.call(exception)
+      end
+    end
+  end
+
+  def custom_domain?
+    Jets.config.domain.hosted_zone_name
+  end
+
+  def process(event, context, handler)
+    if event['_prewarm']
+      Jets.increase_prewarm_count
+      Jets.logger.info("Prewarm request")
+      {prewarmed_at: Time.now.to_s}
+    else
+      Jets::Processors::MainProcessor.new(event, context, handler).run
+    end
+  end
+
+  def once
+    boot
+    override_lambda_ruby_runtime
+    tmp_load!
+    start_rack_server
+  end
+
+  def tmp_load!
+    Jets::TmpLoader.load!
+  end
+
+  # Megamode support
+  def start_rack_server(options={})
+    rack = Jets::RackServer.new(options)
+    rack.start
+    rack.wait_for_socket
+  end
+
+  def default_gems_source
+    "https://gems2.lambdagems.com"
+  end
+
+  def override_lambda_ruby_runtime
+    require "jets/overrides/lambda"
+  end
+end

data/lib/jets/core_ext/kernel.rb

@@ -0,0 +1,56 @@
+# Works with io.rb
+# IO.flush # flush output and write to disk for node shim
+module Kernel
+  JETS_OUTPUT = "/tmp/jets-output.log"
+  @@io_buffer = []
+
+  # List from https://ruby-doc.org/core-2.5.1/Kernel.html
+  # Note, will lose pp format in the @io_buffer but looks like a lot of work to keep the pp format.
+  # Must override stdout which can be messy quick: https://www.ruby-forum.com/topic/43725
+  OVERRIDE_METHODS = %w[
+    p
+    pp
+    print
+    printf
+    putc
+    puts
+  ]
+  # NOTE adding sprintf produces #<%s: %s:%s/%s> with puma? So not including sprintf
+  OVERRIDE_METHODS.each do |meth|
+    # Example of generated code:
+    #
+    #   alias_method :original_puts, :puts
+    #   def puts(*args, &block)
+    #     @@io_buffer << args.first # message
+    #     original_puts(*args, &block)
+    #   end
+    #
+    class_eval <<~CODE
+      alias_method :original_#{meth}, :#{meth}
+      def #{meth}(*args, &block)
+        @@io_buffer << args.first # message
+        original_#{meth}(*args, &block)
+      end
+    CODE
+  end
+
+  def io_buffer
+    @@io_buffer
+  end
+
+  # Note: Writing binary data to the log will crash the process with an error like this:
+  #   jets/lib/jets/core_ext/kernel.rb:20:in `write': "\x89" from ASCII-8BIT to UTF-8 (Encoding::UndefinedConversionError)
+  # Rescue and discard it to keep the process alive.
+  def io_flush
+    chunk = @@io_buffer.join("\n")
+    chunk += "\n" unless chunk == ''
+    begin
+      # since we always append to the file, the node shim is responsible for truncating the file
+      IO.write(JETS_OUTPUT, chunk, mode: 'a') if chunk
+    # Writing to log with binary content will crash the process so rescuing it and writing an info message.
+    rescue Encoding::UndefinedConversionError
+      IO.write(JETS_OUTPUT, "[BINARY DATA]\n", mode: 'a')
+    end
+    @@io_buffer = []
+  end
+end

data/lib/jets/db.rb

@@ -0,0 +1,15 @@
+module Jets::Db ; end
+
+# Thanks: https://makandracards.com/makandra/42521-detecting-if-a-ruby-gem-is-loaded
+if File.exist?("#{Jets.root}/config/database.yml")
+  require "active_record"
+  specs = Gem.loaded_specs
+  require "mysql2" if specs.key?('mysql2')
+  require "pg" if specs.key?('pg')
+end
+
+if File.exist?("#{Jets.root}/config/dynamodb.yml")
+  specs = Gem.loaded_specs
+  specs.key?('dynomite')
+  require "dynomite" if specs.key?('dynomite')
+end

data/lib/jets/dotenv.rb

@@ -0,0 +1,39 @@
+require 'dotenv'
+
+class Jets::Dotenv
+  def self.load!(remote=false)
+    new(remote).load!
+  end
+
+  def initialize(remote=false)
+    @remote = remote
+    @remote = ENV['JETS_ENV_REMOTE'] if ENV['JETS_ENV_REMOTE']
+  end
+
+  def load!
+    ::Dotenv.load(*dotenv_files)
+  end
+
+  # dotenv files with the following precedence:
+  #
+  # - .env.development.remote (highest)
+  # - .env.development.local
+  # - .env.development
+  # - .env.local - This file is loaded for all environments _except_ `test`.
+  # - .env` - The original (lowest)
+  #
+  def dotenv_files
+    files = [
+      root.join(".env"),
+      (root.join(".env.local") unless Jets.env.test?),
+      root.join(".env.#{Jets.env}"),
+      root.join(".env.#{Jets.env}.local"),
+    ]
+    files << root.join(".env.#{Jets.env}.remote") if @remote
+    files.reverse.compact # reverse so the precedence is right
+  end
+
+  def root
+    Jets.root || Pathname.new(ENV["JETS_ROOT"] || Dir.pwd)
+  end
+end

data/lib/jets/erb.rb

@@ -0,0 +1,51 @@
+require 'erb'
+
+# Renders Erb and provide better backtrace where there's an error
+#
+# Usage:
+#
+#   result = Jets::Erb.result(path, key1: "val1", key2: "val2")
+#
+class Jets::Erb
+  class << self
+    def result(path, variables={})
+      set_template_variables(variables)
+      template = IO.read(path)
+      begin
+        ERB.new(template, nil, "-").result(binding)
+      rescue Exception => e
+        puts e
+        puts e.backtrace if ENV['JETS_DEBUG']
+
+        # how to know where ERB stopped? - https://www.ruby-forum.com/topic/182051
+        # syntax errors have the (erb):xxx info in e.message
+        # undefined variables have (erb):xxx info in e.backtrac
+        error_info = e.message.split("\n").grep(/\(erb\)/)[0]
+        error_info ||= e.backtrace.grep(/\(erb\)/)[0]
+        raise unless error_info # unable to find the (erb):xxx: error line
+        line = error_info.split(':')[1].to_i
+        puts "Error evaluating ERB template on line #{line.to_s.color(:red)} of: #{path.sub(/^\.\//, '').color(:green)}"
+
+        template_lines = template.split("\n")
+        context = 5 # lines of context
+        top, bottom = [line-context-1, 0].max, line+context-1
+        spacing = template_lines.size.to_s.size
+        template_lines[top..bottom].each_with_index do |line_content, index|
+          line_number = top+index+1
+          if line_number == line
+            printf("%#{spacing}d %s\n".color(:red), line_number, line_content)
+          else
+            printf("%#{spacing}d %s\n", line_number, line_content)
+          end
+        end
+        exit 1 unless ENV['TEST']
+      end
+    end
+
+    def set_template_variables(variables)
+      variables.each do |key, value|
+        instance_variable_set(:"@#{key}", value)
+      end
+    end
+  end
+end