jets 3.1.0 → 5.0.0

data/lib/jets/generator.rb

@@ -1,112 +0,0 @@
-# Piggy back off of Rails Generators.
-class Jets::Generator
-  class << self
-    def invoke(generator, *args)
-      new(generator, *args).run(:invoke)
-    end
-
-    def revoke(generator, *args)
-      new(generator, *args).run(:revoke)
-    end
-
-    def help(args=ARGV)
-      # `jets generate -h` results in:
-      #
-      #     args = ["generate", "-h"]
-      #
-      args = args[1..-1] || []
-      help_flags = Thor::HELP_MAPPINGS + ["help"]
-      args.pop if help_flags.include?(args.last)
-      subcommand = args[0]
-
-      out = capture_stdout do
-        if subcommand
-          # Using invoke because it ensure the generator is configured properly
-          invoke(subcommand) # sub-level: jets generate scaffold -h
-        else
-          puts Jets::Commands::Help.text(:generate) # to trigger the regular Thor help
-          # Note: How to call the original top-level help menu from Rails. Keeping around in case its useful later:
-          # Rails::Generators.help # top-level: jets generate -h
-        end
-      end
-      out.gsub('rails','jets').gsub('Rails','Jets')
-    end
-
-    def capture_stdout
-      stdout_old = $stdout
-      io = StringIO.new
-      $stdout = io
-      yield
-      $stdout = stdout_old
-      io.string
-    end
-
-    def require_generators
-      # lazy require so Rails const is only defined when using generators
-      require "rails/generators"
-      require "rails/configuration"
-      require_active_job_generator
-    end
-
-    def require_active_job_generator
-      require "active_job"
-      require "rails/generators/job/job_generator"
-      # Override the source_root
-      Rails::Generators::JobGenerator.class_eval do
-        def self.source_root
-          File.expand_path("../generator/templates/active_job/job/templates", __FILE__)
-        end
-      end
-    end
-  end
-
-  def initialize(generator, *args)
-    @generator, @args = generator, args
-    @args << '--pretend' if noop?
-  end
-
-  # Used to delegate noop option to Rails generator pretend option.  Both work:
-  #
-  #     jets generate scaffold user title:string --noop
-  #     jets generate scaffold user title:string --pretend
-  #
-  # Grabbing directly from the ARGV because think its cleaner than passing options from
-  # Thor all the way down.
-  def noop?
-    ARGV.include?('--noop')
-  end
-
-  def run(behavior=:invoke)
-    self.class.require_generators
-
-    Jets::Commands::Db::Tasks.load!
-
-    Rails::Generators.configure!(config)
-    Rails::Generators.invoke(@generator, @args, behavior: behavior, destination_root: Jets.root)
-  end
-
-  def config
-    g = Rails::Configuration::Generators.new
-    g.orm             :active_record, migration: true, timestamps: true
-    # TODO: support g.orm :dynamodb
-    g.test_framework  nil #:test_unit, fixture: false
-    # g.test_framework :rspec # TODO: load rspec configuration to use rspec
-    g.stylesheets     false
-    g.javascripts     false
-    g.assets          false
-    if Jets.config.mode == 'api'
-      g.api_only = true
-      g.template_engine nil
-    else
-      g.template_engine :erb
-    end
-    g.resource_route  true
-    g.templates.unshift(template_paths)
-    g
-  end
-
-  def template_paths
-    templates_path = File.expand_path("../generator/templates", __FILE__)
-    [templates_path]
-  end
-end

data/lib/jets/internal/app/controllers/jets/bare_controller.rb

@@ -1,16 +0,0 @@
-# Parent class for MountController and RackController
-class Jets::BareController < Jets::Controller::Base
-  layout false
-  internal true
-  skip_forgery_protection
-
-private
-  # Override process! so it doesnt go through the complete Jets project middleware stack which could interfer with
-  # the mounted Rack app.
-  def process!
-    status, headers, body = dispatch!
-    # Use the adapter only to convert the Rack triplet to a API Gateway hash structure
-    adapter = Jets::Controller::Rack::Adapter.new(event, context, meth)
-    adapter.convert_to_api_gateway(status, headers, body)
-  end
-end

data/lib/jets/internal/app/controllers/jets/rack_controller.rb

@@ -1,12 +0,0 @@
-class Jets::RackController < Jets::BareController
-  # Megamode
-  def process
-    resp = mega_request
-    render(resp)
-  end
-
-private
-  def mega_request
-    Jets::Mega::Request.new(event, self).proxy
-  end
-end

data/lib/jets/internal/app/functions/jets/base_path.rb

@@ -1,18 +0,0 @@
-require 'bundler/setup'
-require 'cfn_response'
-require 'jets/internal/app/functions/jets/base_path_mapping'
-
-STAGE_NAME = "<%= @stage_name %>"
-
-def lambda_handler(event:, context:)
-  cfn = CfnResponse.new(event, context)
-  cfn.response do
-    mapping = BasePathMapping.new(event, STAGE_NAME)
-    case event['RequestType']
-    when "Create", "Update"
-      mapping.update
-    when "Delete"
-      mapping.delete(true) if mapping.should_delete?
-    end
-  end
-end

data/lib/jets/internal/app/functions/jets/base_path_mapping.rb

@@ -1,100 +0,0 @@
-require 'aws-sdk-apigateway'
-require 'aws-sdk-cloudformation'
-
-class BasePathMapping
-  def initialize(event, stage_name)
-    @event, @stage_name = event, stage_name
-    aws_config_update!
-  end
-
-  # Override the AWS retry settings. The aws-sdk-core has expondential backup with this formula:
-  #
-  #   2 ** c.retries * c.config.retry_base_delay
-  #
-  # So the max delay will be 2 ** 7 * 0.6 = 76.8s
-  #
-  # Useful links:
-  #
-  #   https://github.com/aws/aws-sdk-ruby/blob/master/gems/aws-sdk-core/lib/aws-sdk-core/plugins/retry_errors.rb
-  #   https://docs.aws.amazon.com/apigateway/latest/developerguide/limits.html
-  #
-  def aws_config_update!
-    Aws.config.update(
-      retry_limit: 7, # default: 3
-      retry_base_delay: 0.6, # default: 0.3
-    )
-  end
-
-  # Cannot use update_base_path_mapping to update the base_mapping because it doesnt
-  # allow us to change the rest_api_id. So we delete and create.
-  def update
-    delete(true)
-    create
-  end
-
-  # Dont delete the newly created base path mapping unless this is an operation
-  # where we're fully deleting the stack
-  def should_delete?
-    deleting_parent?
-  end
-
-  def delete(fail_silently=false)
-    apigateway.delete_base_path_mapping(
-      domain_name: domain_name, # required
-      base_path: base_path.empty? ? '(none)' : base_path,
-    )
-  # https://github.com/tongueroo/jets/issues/255
-  # Used to return: Aws::APIGateway::Errors::NotFoundException
-  # Now returns: Aws::APIGateway::Errors::InternalFailure
-  # So we'll use a more generic error
-  rescue Aws::APIGateway::Errors::ServiceError => e
-    raise(e) unless fail_silently
-  end
-
-  def create
-    apigateway.create_base_path_mapping(
-      domain_name: domain_name, # required
-      base_path: base_path,
-      rest_api_id: rest_api_id, # required
-      stage: @stage_name,
-    )
-  end
-
-  def deployment_stack
-    @deployment_stack ||= cfn.describe_stacks(stack_name: @event['StackId']).stacks.first
-  end
-
-  def rest_api_id
-    @rest_api_id ||= parameter_value('RestApi')
-  end
-
-  def domain_name
-    @domain_name ||= parameter_value('DomainName')
-  end
-
-  def base_path
-    @base_path ||= parameter_value('BasePath') || ''
-  end
-
-  def parameter_value(parameter_key)
-    param = deployment_stack[:parameters].find { |p| p.parameter_key == parameter_key }
-    param&.parameter_value # possible for this to be nil when removing the config: IE: config.domain.name = nil
-  end
-
-  def deleting_parent?
-    stack = cfn.describe_stacks(stack_name: parent_stack_name).stacks.first
-    stack.stack_status == 'DELETE_IN_PROGRESS'
-  end
-
-  def parent_stack_name
-    deployment_stack[:root_id]
-  end
-
-  def apigateway
-    @apigateway ||= Aws::APIGateway::Client.new
-  end
-
-  def cfn
-    @cfn ||= Aws::CloudFormation::Client.new
-  end
-end

data/lib/jets/internal/app/helpers/jets/mailers_helper.rb

@@ -1,9 +0,0 @@
-module Jets::MailersHelper
-  def part_query(mime_type)
-    mime_type
-  end
-
-  def locale_query(locale)
-    locale
-  end
-end

data/lib/jets/internal/app/jobs/jets/preheat_job.rb

@@ -1,70 +0,0 @@
-class Jets::PreheatJob < ApplicationJob
-  ENABLED = Jets.config.prewarm.enable
-  CONCURRENCY = Jets.config.prewarm.concurrency
-  PREWARM_RATE = Jets.config.prewarm.rate
-  torching = ENABLED && CONCURRENCY > 1
-  warming = ENABLED && CONCURRENCY == 1
-
-  class_timeout 30
-  class_memory 1024
-  class_iam_policy(
-    {
-      sid: "Statement1",
-      action: ["logs:*"],
-      effect: "Allow",
-      resource: "arn:aws:logs:#{Jets.aws.region}:#{Jets.aws.account}:log-group:#{Jets.config.project_namespace}-*",
-    },
-    {
-      sid: "Statement2",
-      action: ["lambda:InvokeFunction", "lambda:InvokeAsync"],
-      effect: "Allow",
-      resource: "arn:aws:lambda:#{Jets.aws.region}:#{Jets.aws.account}:function:#{Jets.config.project_namespace}-*",
-    }
-  )
-
-  rate(PREWARM_RATE) if torching
-  def torch
-    threads = []
-    CONCURRENCY.times do
-      threads << Thread.new do
-        # intentionally calling remote lambda for concurrency
-        # avoid passing the _prewarm=1 flag because we want the PreheatJob#warm
-        # to run it's normal workload.
-        # Do not use Jets::Preheat.warm(function_name) here as that passes the _prewarm=1.
-        function_name = "jets-preheat_job-warm"
-        event_json = JSON.dump(event)
-        options = call_options(event[:quiet])
-        Jets::Commands::Call.new(function_name, event_json, options).run unless Jets.env.test?
-      end
-    end
-    threads.each { |t| t.join }
-    "Finished prewarming your application with a concurrency of #{CONCURRENCY}."
-  end
-
-  rate(PREWARM_RATE) if warming
-  def warm
-    options = call_options(event[:quiet])
-    Jets::Preheat.warm_all(options)
-    "Finished prewarming your application."
-  end
-
-  class << self
-    # Can use this to prewarm post deploy
-    def prewarm!
-      meth = CONCURRENCY > 1 ? :torch : :warm
-      perform_now(meth, quiet: true)
-    end
-  end
-
-private
-  def call_options(quiet)
-    options = {}
-    options.merge!(mute: true, mute_output: true) if quiet
-    # All the methods in this Job class leads to Jets::Commands::Call.
-    # This is true for the Jets::Preheat.warm_all also.
-    # These jobs delegate out to Lambda function calls. We do not need/want
-    # the invocation type: RequestResponse in this case.
-    options.merge!(invocation_type: "Event")
-    options
-  end
-end

data/lib/jets/internal/app/views/jets/mailers/index.html.erb

@@ -1,8 +0,0 @@
-<% @previews.each do |preview| %>
-<h3><%= link_to(preview.preview_name.titleize, "/jets/mailers/#{preview.preview_name}") %></h3>
-<ul>
-<% preview.emails.each do |email| %>
-<li><%= link_to(email, "/jets/mailers/#{preview.preview_name}/#{email}") %></li>
-<% end %>
-</ul>
-<% end %>

data/lib/jets/internal/app/views/jets/mailers/mailer.html.erb

@@ -1,6 +0,0 @@
-<h3><%= @preview.preview_name.titleize %></h3>
-<ul>
-<% @preview.emails.each do |email| %>
-<li><%= link_to(email, "/jets/mailers/#{@preview.preview_name}/#{email}") %></li>
-<% end %>
-</ul>

data/lib/jets/internal/turbines/jets/mailer.rb

@@ -1,52 +0,0 @@
-module Jets
-  # Reference: https://github.com/rails/rails/blob/master/actionmailer/lib/action_mailer/railtie.rb
-  class Mailer < ::Jets::Turbine
-    config.action_mailer = ActiveSupport::OrderedOptions.new
-
-    initializer "action_mailer.logger" do
-      ActiveSupport.on_load(:action_mailer) { self.logger ||= Jets.logger }
-    end
-
-    initializer "action_mailer.set_configs" do |app|
-      app.config.action_mailer ||= ActiveSupport::OrderedOptions.new # TODO: temp fix. only happens sometimes?
-      options = app.config.action_mailer
-      options.default_url_options ||= {}
-      options.default_url_options[:protocol] ||= "https"
-      options.show_previews = false if options.show_previews.nil?
-      options.preview_path ||= "#{Jets.root}/app/previews" if options.show_previews
-      options.view_paths ||= "#{Jets.root}/app/views"
-
-      # TODO: Dont think Jets sets asset_host the same way
-      # make sure readers methods get compiled
-      # options.asset_host          ||= app.config.asset_host
-      # options.relative_url_root   ||= app.config.relative_url_root
-
-      ActiveSupport.on_load(:action_mailer) do
-        include AbstractController::UrlFor
-        # TODO: figure out rest of the helpers
-        # extend ::AbstractController::Railties::RoutesHelpers.with(app.routes, false)
-        # include app.routes.mounted_helpers
-
-        register_interceptors(options.delete(:interceptors))
-        register_preview_interceptors(options.delete(:preview_interceptors))
-        register_observers(options.delete(:observers))
-
-        options.each { |k, v| send("#{k}=", v) }
-      end
-    end
-
-    after_initializer "action_mailer.routes" do |app|
-      if app.config.action_mailer.show_previews
-        app.routes.draw do
-          get "jets/mailers", to: "jets/mailers#index"
-          get "jets/mailers/*path", to: "jets/mailers#preview"
-        end
-
-        ActiveSupport.on_load :action_controller do
-          internal_views = File.expand_path("internal/app/views", File.dirname(__FILE__))
-          ActionController::Base.append_view_path(internal_views)
-        end
-      end
-    end
-  end
-end

data/lib/jets/lambda/task.rb

@@ -1,111 +0,0 @@
-class Jets::Lambda::Task
-  attr_accessor :class_name, :type
-  attr_reader :meth, :properties, :iam_policy, :managed_iam_policy, :lang, :associated_resources
-  def initialize(class_name, meth, options={})
-    @class_name = class_name.to_s
-    @meth = meth
-    @options = options
-    @type = options[:type] || get_type  # controller, job, or function
-    @properties = options[:properties] || {}
-    @iam_policy = options[:iam_policy]
-    @managed_iam_policy = options[:managed_iam_policy]
-    @lang = options[:lang] || :ruby
-    @associated_resources = options[:associated_resources] || {}
-    @replacements = options[:replacements] || {} # added to baseline replacements
-  end
-
-  def name
-    @meth
-  end
-
-  def public_meth?
-    # For anonymous classes (app/functions/hello.rb) the class name will be blank.
-    # These types of classes are treated specially and has only one handler method
-    # that is registered. So we know it is public.
-    return true if @class_name.nil? || @class_name == ''
-
-    # Consider all polymorphic methods public for now
-    return true if @lang != :ruby
-
-    klass = @class_name.constantize
-    public_methods = klass.public_instance_methods
-    public_methods.include?(meth.to_sym)
-  end
-
-  def build_function_iam?
-    !!(@iam_policy || @managed_iam_policy)
-  end
-
-  @@lang_exts = {
-    ruby: '.rb',
-    python: '.py',
-    node: '.js',
-  }
-  def lang_ext
-    @@lang_exts[@lang]
-  end
-
-  # The get_type method works for controller and job classes.
-  #
-  # Usually able to get the type from the class name. Examples:
-  #
-  #   PostsController => controller
-  #   HardJob => job
-  #
-  # However, for function types, we are not able to get the type for multiple of
-  # reasons.  First, function types are allowed to be named with or without
-  # _function.  Examples:
-  #
-  #   path => class => type
-  #   app/functions/hello.rb => Hello => function
-  #   app/functions/hello_function.rb => HelloFunction => function
-  #
-  # The second reason is that functions are not regular ruby classes. Instead they
-  # are anonymous classes created with Class.new.  When classes are created with
-  # Class.new the method_added hook has "" (blank string) as the self class name.
-  # We add the class_type to the task later on as we are constructing the class
-  # as part of the Class.new logic.
-  #
-  # For controller and job standard ruby classes though it can easily be
-  # determinated as part of initialization. So we get the type for convenience then.
-  #
-  # For anonymous function classes, we just set to nil and will later fix in
-  # FunctionConstructor.
-  #
-  # Returns: "controller", "job" or nil
-  def get_type
-    unless @class_name.empty? # when anonymous class is created with Class.new
-      @class_name.underscore.split('_').last # controller, job or rule
-    end
-  end
-
-  def full_handler(handler_function)
-    "#{handler_base}.#{handler_function}"
-  end
-
-  def handler_path
-    "#{handler_base}#{lang_ext}"
-  end
-
-  def handler_base
-    base = "handlers/#{@type.pluralize}/#{@class_name.underscore}"
-    base += "/#{@lang}" if @lang != :ruby
-    base += "/#{@meth}"
-  end
-
-  def poly_src_path
-    handler_path.sub("handlers/", "app/")
-  end
-
-  def replacements
-    # Merge in the custom replacements specific to each app class: ConfigRule, Job, etc.
-    baseline_replacements.merge(@replacements)
-  end
-
-  def baseline_replacements
-    {
-      # camelized because used in not just keys but common used in values
-      namespace: @meth.to_s.camelize,
-    }
-  end
-end

data/lib/jets/logger.rb

@@ -1,21 +0,0 @@
-require 'logger'
-
-module Jets
-  class Logger < ::Logger
-    # Only need to override the add method as the other calls all lead to it.
-    def add(severity, message = nil, progname = nil)
-      # Taken from Logger#add source
-      # https://ruby-doc.org/stdlib-2.5.1/libdoc/logger/rdoc/Logger.html#method-i-add
-      if message.nil?
-        if block_given?
-          message = yield
-        else
-          message = progname
-          progname = @progname
-        end
-      end
-
-      super # original logical
-    end
-  end
-end

data/lib/jets/middleware/configurator.rb

@@ -1,84 +0,0 @@
-# Based on Rails MiddlewareStackProxy
-#
-# Configurator is a recorder for the Jets middleware stack that allows
-# you to configure middlewares in your application. It works basically as a
-# command recorder, saving each command to be applied after initialization
-# over the default middleware stack, so you can add, swap, or remove any
-# middleware in Jets.
-#
-# You can add your own middlewares by using the +config.middleware.use+ method:
-#
-#     config.middleware.use Magical::Unicorns
-#
-# This will put the <tt>Magical::Unicorns</tt> middleware on the end of the stack.
-# You can use +insert_before+ if you wish to add a middleware before another:
-#
-#     config.middleware.insert_before Rack::Head, Magical::Unicorns
-#
-# There's also +insert_after+ which will insert a middleware after another:
-#
-#     config.middleware.insert_after Rack::Head, Magical::Unicorns
-#
-# Middlewares can also be completely swapped out and replaced with others:
-#
-#     config.middleware.swap ActionDispatch::Flash, Magical::Unicorns
-#
-# And finally they can also be removed from the stack completely:
-#
-#     config.middleware.delete ActionDispatch::Flash
-#
-module Jets::Middleware
-  class Configurator
-    def initialize(operations = [], delete_operations = [])
-      @operations = operations
-      @delete_operations = delete_operations
-    end
-
-    def insert_before(*args, &block)
-      @operations << [__method__, args, block]
-    end
-
-    alias :insert :insert_before
-
-    def insert_after(*args, &block)
-      @operations << [__method__, args, block]
-    end
-
-    def swap(*args, &block)
-      @operations << [__method__, args, block]
-    end
-
-    def use(*args, &block)
-      @operations << [__method__, args, block]
-    end
-
-    def delete(*args, &block)
-      @delete_operations << [__method__, args, block]
-    end
-
-    def unshift(*args, &block)
-      @operations << [__method__, args, block]
-    end
-
-    def merge_into(other) #:nodoc:
-      (@operations + @delete_operations).each do |operation, args, block|
-        other.send(operation, *args, &block)
-      end
-
-      other
-    end
-
-    def +(other) # :nodoc:
-      Configurator.new(@operations + other.operations, @delete_operations + other.delete_operations)
-    end
-
-    protected
-      def operations
-        @operations
-      end
-
-      def delete_operations
-        @delete_operations
-      end
-  end
-end

data/lib/jets/middleware/default_stack.rb

@@ -1,53 +0,0 @@
-require "shotgun"
-
-module Jets::Middleware
-  class DefaultStack
-    attr_reader :config, :app
-    def initialize(app, config)
-      @app = app
-      @config = config
-    end
-
-    def build_stack
-      Stack.new do |middleware|
-        middleware.use Shotgun::Static
-        middleware.use Rack::Runtime
-        middleware.use Jets::Controller::Middleware::Cors if cors_enabled?
-        middleware.use Rack::MethodOverride unless ENV['JETS_RACK_METHOD_OVERRIDE'] == '0' # must come before Middleware::Local for multipart post forms to work
-        middleware.use Jets::Controller::Middleware::Reloader if Jets.config.hot_reload
-        middleware.use Jets::Controller::Middleware::Local # mimics AWS Lambda for local server only
-        middleware.use session_store, session_options
-        middleware.use Rack::Head
-        middleware.use Rack::ConditionalGet
-        middleware.use Rack::ETag
-        use_webpacker(middleware)
-      end
-    end
-
-  private
-    def cors_enabled?
-      Jets.config.cors
-    end
-
-    # Written as method to easily not include webpacker for case when either
-    # webpacker not installed at all or disabled upon `jets deploy`.
-    def use_webpacker(middleware)
-      return unless Jets.webpacker? # checks for local development if webpacker installed
-      # Different check for middleware because we need webpacker helpers for url helpers.
-      # But we dont want to actually serve via webpacker middleware when running on AWS.
-      # By this time the url helpers are serving assets out of s3.
-      return if File.exist?("#{Jets.root}/config/disable-webpacker-middleware.txt") # created as part of `jets deploy`
-      require "jets/controller/middleware/webpacker_setup"
-      middleware.use Webpacker::DevServerProxy
-    end
-
-    def session_store
-      Jets.config.session[:store] # do not use dot notation. session.store is a method on ActiveSupport::OrderedOptions.new
-    end
-
-    def session_options
-      defaults = { secret: ENV['SECRET_KEY_BASE'] }
-      defaults.merge(Jets.config.session.options)
-    end
-  end
-end