jets 3.1.0 → 5.0.10

data/lib/jets/router.rb

@@ -1,180 +1,94 @@
-require 'text-table'
-
 module Jets
-  class Router
-    include Dsl
+  module Router
+    class Error < RuntimeError ; end
 
-    attr_reader :routes
-    def initialize
-      @routes = []
-      @scope = Scope.new
-    end
+    NAMED_ROUTES_METHODS = %w[index new create show edit update destroy].freeze
 
-    def draw(&block)
-      instance_eval(&block)
-      check_collision!
+    def has_controller?(name)
+      routes.detect { |r| r.controller_name == name }
     end
 
-    # Validate routes that deployable
-    def check_collision!
-      paths = self.routes.map(&:path)
-      collision = Jets::Resource::ApiGateway::RestApi::Routes::Collision.new
-      collide = collision.collision?(paths)
-      raise collision.exception if collide
+    def draw
+      drawn_route_set
     end
 
-    def create_route(options)
-      # TODO: Can use it to add additional things like authorization_type
-      # Would be good to add authorization_type at the controller level also
-      infer_to_option!(options)
-      handle_on!(options)
-      MethodCreator.new(options, @scope).define_url_helper!
-      @routes << Route.new(options, @scope)
-    end
-
-    # Can possibly infer to option from the path. Example:
-    #
-    #     get 'posts/index'
-    #     get 'posts', to: 'posts#index'
-    #
-    #     get 'posts/show'
-    #     get 'posts', to: 'posts#show'
-    #
-    def infer_to_option!(options)
-      return if options[:to]
-
-      path = options[:path].to_s
-      return unless path.include?('/')
-
-      items = path.split('/')
-      if items.size == 2
-        options[:to] = items.join('#')
-      end
-    end
+    @@drawn_route_set = nil
+    def drawn_route_set
+      return @@drawn_route_set if @@drawn_route_set
 
-    def handle_on!(options)
-      if options[:on] && !%w[resources resource].include?(@scope.from.to_s)
-        raise Error.new("ERROR: The `on:` option can only be used within a resource or resources block")
-      end
-      options[:on] ||= @on_option if @on_option
+      route_set = Jets.application.routes
+      @@drawn_route_set = route_set
     end
 
-    def api_mode?
-      if Jets.config.key?(:api_mode) || Jets.config.key?(:api_generator)
-        puts <<~EOL.color(:yellow)
-          DEPRECATED: Jets.config.api_generator
-          Instead, please update your config/application.rb to use:
-            Jets.config.mode = 'api'
-          You can also run:
-            jets upgrade
-        EOL
-      end
-      api_mode = Jets.config.mode == 'api' || Jets.config.api_mode || Jets.config.api_generator
-      api_mode
+    def clear!
+      @@drawn_route_set = nil
     end
 
-    # Useful for creating API Gateway Resources
-    def all_paths
-      results = []
-      paths = routes.map(&:path)
-      paths.each do |p|
-        sub_paths = []
-        parts = p.split('/')
-        until parts.empty?
-          parts.pop
-          sub_path = parts.join('/')
-          sub_paths << sub_path unless sub_path == ''
-        end
-        results += sub_paths
-      end
-      @all_paths = (results + paths).sort.uniq
+    def routes
+      drawn_route_set.routes
     end
 
-    # Useful for RouterMatcher
+    # So we can save state in s3 post deploy. Example of structure.
     #
-    # Precedence:
-    # Routes with wildcards are considered after routes without wildcards
+    #   [
+    #     {"scope"=>{"options"=>{"as"=>"posts", "path"=>"posts", "param"=>nil, "from"=>"resources"}, "parent"=>{"options"=>{}, "parent"=>nil, "level"=>1}, "level"=>2}, "options"=>{"to"=>"posts#index", "path"=>"posts", "method"=>"get"}, "path"=>"posts", "to"=>"posts#index", "as"=>"posts"},
+    #     {"scope"=>{"options"=>{"as"=>"posts", "path"=>"posts", "param"=>nil, "from"=>"resources"}, "parent"=>{"options"=>{}, "parent"=>nil, "level"=>1}, "level"=>2}, "options"=>{"to"=>"posts#new", "path"=>"posts/new", "method"=>"get"}, "path"=>"posts/new", "to"=>"posts#new", "as"=>"new_post"},
+    #     ...
+    #   ]
     #
-    # Routes with fewer captures are ordered first since both
-    # /posts/:post_id/comments/new and /posts/:post_id/comments/:id are equally
-    # long
-    #
-    # Routes with the same amount of captures and wildcards are orderd so that
-    # the longest path is considered first since posts/:id and posts/:id/edit
-    # can both match.
-    def ordered_routes
-      length = Proc.new { |r| [r.path.count("*"), r.path.count(":"), r.path.length * -1] }
-      routes.sort_by(&length)
+    def to_json
+      JSON.dump(routes.map(&:to_h))
     end
 
-    class << self
-      def has_controller?(name)
-        routes.detect { |r| r.controller_name == name }
-      end
-
-      # Class methods
-      def draw
-        drawn_router
-      end
-
-      @@drawn_router = nil
-      def drawn_router
-        return @@drawn_router if @@drawn_router
-
-        router = Jets.application.routes
-        @@drawn_router = router
-      end
-
-      def clear!
-        @@drawn_router = nil
-        Jets::Router::Helpers::NamedRoutesHelper.clear!
-      end
+    # Returns all paths including subpaths.
+    # Example:
+    # Input: ["posts/:id/edit"]
+    # Output: ["posts", "posts/:id", "posts/:id/edit"]
+    def all_paths
+      drawn_route_set.all_paths
+    end
 
-      def routes
-        drawn_router.routes
-      end
+    def all_routes_valid?
+      invalid_routes.empty?
+    end
 
-      # Returns all paths including subpaths.
-      # Example:
-      # Input: ["posts/:id/edit"]
-      # Output: ["posts", "posts/:id", "posts/:id/edit"]
-      def all_paths
-        drawn_router.all_paths
-      end
+    def invalid_routes
+      routes.select { |r| !r.valid? }
+    end
 
-      def help(routes)
-        return "Your routes table is empty." if routes.empty?
+    def validate_routes!
+      return true if Jets.config.cfn.build.routes == "one_apigw_method_for_all_routes"
+      check_route_connected_functions
+    end
 
-        table = Text::Table.new
-        table.head = %w[As Verb Path Controller#action]
-        routes.each do |route|
-          table.rows << [route.as, route.method, route.path, route.to]
-        end
-        table
-      end
+    # Checks that all routes are validate and have corresponding lambda functions
+    def check_route_connected_functions
+      return true if all_routes_valid?
 
-      def all_routes_valid?
-        invalid_routes.empty?
+      puts "Please double check the routes below map to valid controllers:".color(:red)
+      invalid_routes.each do |route|
+        puts "  /#{route.path} => #{route.controller_name}##{route.action_name}"
       end
+      false
+    end
 
-      def invalid_routes
-        routes.select { |r| !r.valid? }
-      end
+    def find_route_by_event(event)
+      request = Jets::Controller::Request.new(event: event)
+      Jets::Router::Matcher.new.find_by_request(request)
+    end
 
-      def validate_routes!
-        check_route_connected_functions
+    def find_by_definition(definition)
+      routes.find do |route|
+        route.controller_name == definition.class_name &&
+        route.action_name == definition.meth.to_s
       end
+    end
 
-      # Checks that all routes are validate and have corresponding lambda functions
-      def check_route_connected_functions
-        return true if all_routes_valid?
-
-        puts "Please double check the routes below map to valid controllers:".color(:red)
-        invalid_routes.each do |route|
-          puts "  /#{route.path} => #{route.controller_name}##{route.action_name}"
-        end
-        false
-      end
+    # Filters out internal routes
+    def no_routes?
+      routes.reject(&:internal?).empty?
     end
+
+    extend self
   end
-end
+end

data/lib/jets/ruby_version_check.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+if Gem::Version.new(RUBY_VERSION) < Gem::Version.new("2.7.0") && RUBY_ENGINE == "ruby"
+  desc = defined?(RUBY_DESCRIPTION) ? RUBY_DESCRIPTION : "ruby #{RUBY_VERSION} (#{RUBY_RELEASE_DATE})"
+  abort <<-end_message
+
+    Jets 5 requires Ruby 2.7.0 or newer.
+
+    You're running
+      #{desc}
+
+    Please upgrade to Ruby 2.7.0 or newer to continue.
+
+  end_message
+end

data/lib/jets/rule/base.rb

@@ -8,6 +8,7 @@ require 'json'
 module Jets::Rule
   class Base < Jets::Lambda::Functions
     include Dsl
+    prepend Jets::ExceptionReporting::Process
 
     class << self
       def process(event, context, meth)

data/lib/jets/rule/dsl.rb

@@ -27,13 +27,13 @@ module Jets::Rule::Dsl
       def scope(value)
         scope = case value
           when String
-            {compliance_resource_types: [value]}
+            {ComplianceResourceTypes: [value]}
           when Array
-            {compliance_resource_types: value}
+            {ComplianceResourceTypes: value}
           else # default to hash
             value
           end
-        associated_properties(scope: scope)
+        associated_properties(Scope: scope)
       end
 
       # Convenience method that set properties. List based on https://amzn.to/2oSph1P
@@ -53,13 +53,13 @@ module Jets::Rule::Dsl
       end
 
       def config_rule_definition(meth)
-        resource = Jets::Resource::Config::ConfigRule.new(self, meth, associated_properties)
+        resource = Jets::Cfn::Resource::Config::ConfigRule.new(self, meth, associated_properties)
         resource.definition # returns a definition to be added by associated_resources
       end
 
       def managed_rule(name)
         name = name.to_s
-        managed_rule = Jets::Resource::Config::ManagedRule.new(self, name, associated_properties)
+        managed_rule = Jets::Cfn::Resource::Config::ManagedRule.new(self, name, associated_properties)
         resource(managed_rule.definition) # Sets @associated_resources
 
         # The key to not register the task to all_tasks to avoid creating a Lambda function.
@@ -75,7 +75,7 @@ module Jets::Rule::Dsl
         # Only using the task for base_replacements.
         resources = [definition]
         meth = name
-        task = Jets::Lambda::Task.new(self.name, meth,
+        task = Jets::Lambda::Definition.new(self.name, meth,
                  resources: resources,
                  replacements: replacements(meth))
         all_managed_rules[name] = { definition: definition, replacements: task.replacements }
@@ -102,7 +102,7 @@ module Jets::Rule::Dsl
 
       # Override Lambda::Dsl.build? to account for possible managed_rules
       def build?
-        !tasks.empty? || !managed_rules.empty?
+        !definitions.empty? || !managed_rules.empty?
       end
     end
   end

data/lib/jets/secrets.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "tempfile"
+require "active_support/message_encryptor"
+
+module Jets
+  # Greatly inspired by Ara T. Howard's magnificent sekrets gem. 😘
+  class Secrets # :nodoc:
+    class MissingKeyError < RuntimeError
+      def initialize
+        super(<<-end_of_message.squish)
+          Missing encryption key to decrypt secrets with.
+          Ask your team for your master key and put it in ENV["JETS_MASTER_KEY"]
+        end_of_message
+      end
+    end
+
+    @cipher = "aes-128-gcm"
+    @root = File # Wonky, but ensures `join` uses the current directory.
+
+    class << self
+      attr_writer :root
+
+      def parse(paths, env:)
+        paths.each_with_object(Hash.new) do |path, all_secrets|
+          require "erb"
+
+          source = ERB.new(preprocess(path)).result
+          secrets = YAML.respond_to?(:unsafe_load) ? YAML.unsafe_load(source) : YAML.load(source)
+          secrets ||= {}
+
+          all_secrets.merge!(secrets["shared"].deep_symbolize_keys) if secrets["shared"]
+          all_secrets.merge!(secrets[env].deep_symbolize_keys) if secrets[env]
+        end
+      end
+
+      def key
+        ENV["JETS_MASTER_KEY"] || read_key_file || handle_missing_key
+      end
+
+      def encrypt(data)
+        encryptor.encrypt_and_sign(data)
+      end
+
+      def decrypt(data)
+        encryptor.decrypt_and_verify(data)
+      end
+
+      def read
+        decrypt(IO.binread(path))
+      end
+
+      def write(contents)
+        IO.binwrite("#{path}.tmp", encrypt(contents))
+        FileUtils.mv("#{path}.tmp", path)
+      end
+
+      def read_for_editing(&block)
+        writing(read, &block)
+      end
+
+      private
+        def handle_missing_key
+          raise MissingKeyError
+        end
+
+        def read_key_file
+          if File.exist?(key_path)
+            IO.binread(key_path).strip
+          end
+        end
+
+        def key_path
+          @root.join("config", "secrets.yml.key")
+        end
+
+        def path
+          @root.join("config", "secrets.yml.enc").to_s
+        end
+
+        def preprocess(path)
+          if path.end_with?(".enc")
+            decrypt(IO.binread(path))
+          else
+            IO.read(path)
+          end
+        end
+
+        def writing(contents)
+          file_name = "#{File.basename(path)}.#{Process.pid}"
+
+          Tempfile.create(["", "-" + file_name]) do |tmp_file|
+            tmp_path = Pathname.new(tmp_file)
+            tmp_path.binwrite contents
+
+            yield tmp_path
+
+            updated_contents = tmp_path.binread
+
+            write(updated_contents) if updated_contents != contents
+          end
+        end
+
+        def encryptor
+          @encryptor ||= ActiveSupport::MessageEncryptor.new([ key ].pack("H*"), cipher: @cipher)
+        end
+    end
+  end
+end

data/lib/jets/spec_helpers/controllers/request.rb

@@ -10,7 +10,7 @@ module Jets::SpecHelpers::Controllers
     def event
       json = {}
       id_params = route.path.scan(%r{:([^/]+)}).flatten
-      expanded_path = escape_path(path)
+      expanded_path = route.escape_path(path)
       path_parameters = {}
 
       id_params.each do |id_param|
@@ -20,12 +20,12 @@ module Jets::SpecHelpers::Controllers
         raise "Path param :#{id_param} value cannot be blank" if path_param_value.blank?
 
         escaped_path_param_value = CGI.escape(path_param_value.to_s)
-        expanded_path.gsub!(":#{id_param}", escaped_path_param_value)
+        expanded_path = expanded_path.gsub(":#{id_param}", escaped_path_param_value)
         path_parameters.deep_merge!(id_param => escaped_path_param_value)
       end
 
-      json['resource'] = escape_path(path)
-      json['path'] = expanded_path
+      json['resource'] = strip_query_string(route.path.gsub(/:(\w+)/, '{\1}'))
+      json['path'] = strip_query_string(expanded_path)
       json['httpMethod'] = method.to_s.upcase
       json['pathParameters'] = path_parameters
       json['headers'] = (headers || {}).stringify_keys
@@ -51,10 +51,7 @@ module Jets::SpecHelpers::Controllers
         json['isBase64Encoded'] = true
       end
 
-      params.query_params.each do |key, value|
-        json['queryStringParameters'] ||= {}
-        json['queryStringParameters'][key.to_s] = value.deep_dup
-      end
+      json['queryStringParameters'] = params.query_params if params.query_params.present?
 
       json
     end
@@ -72,17 +69,32 @@ module Jets::SpecHelpers::Controllers
       path = self.path
       path = path[0..-2] if path.end_with? '/'
       path = path[1..-1] if path.start_with? '/'
+      path = strip_query_string(path)
       path
     end
 
+    def strip_query_string(path)
+      path.sub(/\?.*/, '')
+    end
+
     def route
-      Jets::Router::Finder.new(normalized_path, method).run
+      Jets::Router::Matcher.new(Jets.application.routes).find_by_env(
+        "REQUEST_METHOD" => method.to_s.upcase,
+        "PATH_INFO" => path,
+      )
     end
     memoize :route
 
+    def request
+      Jets::Controller::Request.new(event: event)
+    end
+    memoize :request
+
     def dispatch!
       klass = Object.const_get(route.controller_name)
-      controller = klass.new(event, {}, route.action_name)
+      context = Jets::Controller::Middleware::Mimic::LambdaContext.new
+      rack_env = Jets::Controller::RackAdapter::Env.new(event, context).convert
+      controller = klass.new(event, context, route.action_name, rack_env)
       response = controller.process! # response is API Gateway Hash
 
       unless response['statusCode'] && response['body']
@@ -91,11 +103,5 @@ module Jets::SpecHelpers::Controllers
 
       Response.new(response) # converts APIGW hash to prettier object
     end
-
-    private
-
-    def escape_path(path)
-      path.to_s.split('/').map { |s| s =~ /\A[:\*]/ ? s : CGI.escape(s) }.join('/')
-    end
   end
 end

data/lib/jets/spec_helpers/controllers.rb

@@ -2,13 +2,6 @@ module Jets::SpecHelpers
   module Controllers
     include Jets::Router::Helpers # must be at the top because response is overridden later
 
-    attr_reader :response
-    # Note: caching it like this instead of within the initialize results in the headers not being cached
-    # See: https://community.rubyonjets.com/t/is-jets-spechelpers-controllers-request-being-cached/244/2
-    def request
-      @request ||= Request.new(:get, '/', {}, Params.new)
-    end
-
     rest_methods = %w[get post put patch delete]
     rest_methods.each do |meth|
       define_method(meth) do |path, **params|
@@ -20,28 +13,43 @@ module Jets::SpecHelpers
       # end
     end
 
-    def http_call(method:, path:, **params)
-      request.method = method.to_sym
-      request.path = path
-      request.headers.deep_merge!(params.delete(:headers) || {})
-
-      request.params.query_params = params.delete(:query)
-
-      if request.method == :get
-        request.params.body_params = {}
-        request.params.query_params ||= params.delete(:params)
-        request.params.query_params ||= params
+    attr_reader :request, :response
+    def http_call(method:, path:, **options)
+      headers = options.delete(:headers) || {}
+      md = path.match(/\?(.*)/)
+      query_string = md ? md[1] : ''
+      query = Rack::Utils.parse_nested_query(query_string)
+
+      params = Params.new
+      if method.to_sym == :get
+        params.body_params = {}
+        params.query_params ||= options.delete(:params) || options
       else
-        request.params.body_params = params.delete(:body)
-        request.params.body_params ||= params.delete(:params)
-        request.params.body_params ||= params
+        params.body_params = options.delete(:body) || options.delete(:params) || options
       end
+      params.path_params = params.path_params
+      params.query_params = query
 
-      request.params.query_params ||= {}
+      # Note: Do not cache the request object.  Otherwise, it cannot be reused between specs.
+      # See: https://community.rubyonjets.com/t/is-jets-spechelpers-controllers-request-being-cached/244/2
+      @request = Request.new(method, path, headers, params)
 
-      request.params.path_params = params
+      @request.method = method.to_sym
+      @request.path = path
+      @request.headers.deep_merge!(headers)
 
-      @response = request.dispatch!
+      suppress_logging do
+        @response = @request.dispatch!
+      end
+    end
+
+    def suppress_logging
+      old_logger = Jets.logger
+      unless ENV['JETS_TEST_LOGGING']
+        Jets.logger = ActionView::Base.logger = Logger.new("/dev/null")
+      end
+      yield
+      Jets.logger = old_logger
     end
   end
 end

data/lib/jets/spec_helpers.rb

@@ -9,12 +9,6 @@ module Jets
   end
 end
 
-if File.exist?("#{Jets.root}/config/database.yml") && !ENV["SKIP_MIGRATION_CHECK"]
-  ActiveRecord::Tasks::DatabaseTasks.db_dir = "#{Jets.root}/db"
-  ActiveRecord::Migration.extend ActiveRecord::MigrationChecker
-  ActiveRecord::Migration.prepare_test_db
-end
-
 require "rspec"
 RSpec.configure do |c|
   c.include Jets::SpecHelpers

data/lib/jets/stack/builder.rb

@@ -1,6 +1,7 @@
 class Jets::Stack
   class Builder
     extend Memoist
+    include Jets::Util::Camelize
 
     def initialize(stack)
       @stack = stack
@@ -11,7 +12,7 @@ class Jets::Stack
       build_section(:parameters)
       build_section(:resources)
       build_section(:outputs)
-      Jets::Camelizer.transform(@template)
+      camelize(@template).deep_stringify_keys
     end
     memoize :template
 
@@ -20,7 +21,7 @@ class Jets::Stack
       return unless elements
 
       if section == :parameters
-        elements["GemLayer"] = {"Type"=>"String"} unless Jets.poly_only?
+        elements[:GemLayer] = {Type: "String"} if Jets.gem_layer?
       end
       @template[section] = elements
     end

data/lib/jets/stack/definition.rb

@@ -5,6 +5,7 @@
 class Jets::Stack
   module Definition
     extend ActiveSupport::Concern
+    include Jets::Util::Camelize
 
     # Example of usage that leads here:
     #
@@ -22,10 +23,6 @@ class Jets::Stack
       self.class.register(@subclass, *@definition)
     end
 
-    def camelize(attributes)
-      Jets::Camelizer.transform(attributes)
-    end
-
     class_methods do
       def register(subclass, *definition)
         @definitions ||= {}

data/lib/jets/stack/function.rb

@@ -9,7 +9,7 @@ class Jets::Stack
 
     def meth
       attributes = @template.values.first
-      handler = attributes['Properties']['Handler']
+      handler = attributes[:Properties][:Handler]
       handler.split('.').last
     end
 
@@ -49,13 +49,15 @@ class Jets::Stack
 
     def base_search_expression
       attributes = @template.values.first
-      handler = attributes['Properties']['Handler']
+      handler = attributes[:Properties][:Handler]
       handler.split('.')[0..-2].join('.') + '.*' # search_expression
       # Example: handlers/shared/functions/jets/s3_bucket_config.*
     end
 
     # Internal flag is mainly used to disable WARN messages
     def internal?
+      return true if internal_search_expression.include?("jets/base_path")
+      return true if internal_search_expression.include?("jets/s3_bucket_config")
       !!Dir.glob(internal_search_expression).first
     end