jets 0.2.0 → 0.5.0

data/lib/jets/commands/url.rb

@@ -0,0 +1,45 @@
+module Jets::Commands
+  class Url
+    include Jets::AwsServices
+
+    def initialize(options)
+      @options = options
+    end
+
+    def display
+      stack_name = Jets::Naming.parent_stack_name
+      stack = cfn.describe_stacks(stack_name: stack_name).stacks.first
+
+      unless stack
+        puts "Stack for '#{Jets.config.project_name} project for environment #{Jets.env}.  Couldn't find '#{stack_name}' stack."
+        exit
+      end
+
+      api_gateway_stack_arn = lookup(stack[:outputs], "ApiGateway")
+      if api_gateway_stack_arn
+        STDOUT.puts get_url(api_gateway_stack_arn)
+      else
+        puts "API Gateway not found. This jets app does have an API Gateway associated with it.  Please double check your config/routes.rb if you were expecting to see a url for the app."
+      end
+    end
+
+    def get_url(api_gateway_stack_arn)
+      stack = cfn.describe_stacks(stack_name: api_gateway_stack_arn).stacks.first
+      rest_api = lookup(stack[:outputs], "RestApi")
+      region_id = lookup(stack[:outputs], "Region")
+      # Abusing ApiGatewayDeploymentMapper
+      #   set path=nil,s3_bucket=nil
+      #   not using any methods that rely on the initialization parameters
+      map = Jets::Cfn::TemplateMappers::ApiGatewayDeploymentMapper.new(path=nil,s3_bucket=nil)
+      # https://docs.aws.amazon.com/apigateway/latest/developerguide/how-to-call-api.html
+      # https://my-api-id.execute-api.region-id.amazonaws.com/stage-name/{resourcePath}
+      "https://#{rest_api}.execute-api.#{region_id}.amazonaws.com/#{map.stage_name}"
+    end
+
+    # Lookup output value
+    def lookup(outputs, key)
+      o = outputs.find { |o| o.output_key == key }
+      o.output_value
+    end
+  end
+end

data/lib/jets/commands/webpacker_template.rb

@@ -0,0 +1,19 @@
+require 'thor'
+
+# These commands are ran after rake webpacker:install to enhance the generated
+# javascript assets to support Jets.
+# Done this way so it works for both jets new and jets webpacker:install
+class Jets::Commands::WebpackerTemplate < Thor::Group
+  include Thor::Actions
+
+  class_option :force, desc: "Bypass confirmation and overwrite existing files."
+  class_option :bootstrap, type: :boolean, default: true, desc: "Install bootstrap"
+  def self.source_root
+    File.expand_path("templates/webpacker", File.dirname(__FILE__))
+  end
+
+  def reapply_templates
+    puts "options #{options.inspect}"
+    directory "app/javascript", "app/javascript", force: options[:force]#, bootstrap: options[:bootstrap]
+  end
+end

data/lib/jets/controller.rb

@@ -0,0 +1,9 @@
+class Jets::Controller
+  autoload :Base, "jets/controller/base"
+  autoload :Layout, "jets/controller/layout"
+  autoload :Callbacks, "jets/controller/callbacks"
+  autoload :Request, "jets/controller/request"
+  autoload :Rendering, "jets/controller/rendering"
+  autoload :Redirection, "jets/controller/redirection"
+  autoload :Params, "jets/controller/params"
+end

data/lib/jets/controller/base.rb

@@ -0,0 +1,50 @@
+require "active_support/core_ext/hash"
+require "active_support/core_ext/object"
+require "json"
+require "rack/utils" # Rack::Utils.parse_nested_query
+
+# Controller public methods get turned into Lambda functions.
+class Jets::Controller
+  class Base < Jets::Lambda::Functions
+    include Layout
+    include Callbacks
+    include Rendering
+    include Params
+
+    def self.process(event, context={}, meth)
+      t1 = Time.now
+      Jets.logger.info "Processing by #{self}##{meth}"
+
+      controller = new(event, context, meth)
+
+      Jets.logger.info "  Event: #{event.inspect}"
+      Jets.logger.info "  Parameters: #{controller.params(true).to_h.inspect}"
+
+      controller.run_before_actions
+      controller.send(meth)
+      resp = controller.ensure_render
+      controller.run_after_actions
+
+      time = Time.now - t1
+      Jets.logger.info "Completed Status Code #{resp["statusCode"]} in #{time}s"
+
+      resp
+    end
+
+    delegate :headers, to: :request
+    attr_reader :request
+    def initialize(event, context={}, meth)
+      super
+      @request = Request.new(event)
+    end
+
+    class_attribute :internal_controller
+    def self.internal(value=nil)
+      if !value.nil?
+        self.internal_controller = value
+      else
+        self.internal_controller
+      end
+    end
+  end
+end

data/lib/jets/controller/callbacks.rb

@@ -0,0 +1,43 @@
+# Simpified version of callbacks
+# Does not support if
+class Jets::Controller
+  module Callbacks
+    extend ActiveSupport::Concern
+    included do
+      class_attribute :before_actions
+      self.before_actions = []
+      class_attribute :after_actions
+      self.after_actions = []
+
+      def self.before_action(meth, options={})
+        self.before_actions += [[meth, options]]
+      end
+
+      def self.after_action(meth, options={})
+        self.after_actions += [[meth, options]]
+      end
+    end # included
+
+    # Instance Methods
+    # define run_before_actions and run_after_actions
+    [:before, :after].each do |type|
+      define_method "run_#{type}_actions" do
+        called_method = @meth.to_sym
+        callbacks = self.class.send("#{type}_actions")
+        callbacks.each do |array|
+          callback, options = array
+
+          except = options[:except]
+          next if except && except.include?(called_method)
+
+          only = options[:only]
+          if only
+            send(callback) if only.include?(called_method)
+          else
+            send(callback)
+          end
+        end
+      end
+    end
+  end # ClassOptions
+end

data/lib/jets/controller/layout.rb

@@ -0,0 +1,17 @@
+class Jets::Controller
+  module Layout
+    extend ActiveSupport::Concern
+    included do
+      class_attribute :layout_name
+
+      def self.layout(name=nil)
+        if !name.nil?
+          name = name.to_s if name.is_a?(Symbol)
+          self.layout_name = name
+        else
+          self.layout_name
+        end
+      end
+    end # included
+  end # Layout
+end

data/lib/jets/controller/params.rb

@@ -0,0 +1,53 @@
+require "action_controller/metal/strong_parameters"
+
+class Jets::Controller
+  module Params
+    # Merge all the parameters together for convenience.  Users still have
+    # access via events.
+    #
+    # Precedence:
+    #   1. path parameters have highest precdence
+    #   2. query string parameters
+    #   3. body parameters
+    def params(raw=false)
+      query_string_params = event["queryStringParameters"] || {}
+      path_params = event["pathParameters"] || {}
+      params = body_params
+                .deep_merge(query_string_params)
+                .deep_merge(path_params)
+      if raw
+        params
+      else
+        ActionController::Parameters.new(params)
+      end
+    end
+
+  private
+    def body_params
+      body = event["body"]
+      return {} if body.nil?
+
+      # Try json parsing
+      parsed_json = parse_json(body)
+      return parsed_json if parsed_json
+
+
+      # For content-type application/x-www-form-urlencoded CGI.parse the body
+      headers = event["headers"] || {}
+      headers = headers.transform_keys { |key| key.downcase }
+      # API Gateway seems to use either: content-type or Content-Type
+      content_type = headers["content-type"]
+      if content_type.to_s.include?("application/x-www-form-urlencoded")
+        return Rack::Utils.parse_nested_query(body)
+      end
+
+      {} # fallback to empty Hash
+    end
+
+    def parse_json(text)
+      JSON.parse(text)
+    rescue JSON::ParserError
+      nil
+    end
+  end
+end

data/lib/jets/controller/redirection.rb

@@ -0,0 +1,55 @@
+class Jets::Controller
+  module Redirection
+    # redirect_to "/posts", :status => 301
+    # redirect_to :action=>'atom', :status => 302
+    def redirect_to(url, options={})
+      unless url.is_a?(String)
+        raise "redirect_to url parameter must be a String. Please pass in a string"
+      end
+
+      uri = URI.parse(url)
+      # if no location.host, we been provided a relative host
+      if !uri.host && actual_host
+        url = "/#{url}" unless url.starts_with?('/')
+        url = add_stage_name(url)
+        redirect_url = actual_host + url
+      else
+        redirect_url = url
+      end
+
+      redirect_url = ensure_protocol(redirect_url)
+
+      aws_proxy = Renderers::AwsProxyRenderer.new(self,
+        status: options[:status] || 302,
+        headers: { "Location" => redirect_url },
+        body: "",
+        isBase64Encoded: false,
+      )
+      resp = aws_proxy.render
+      # redirect is a type of rendering
+      @rendered = true
+      @rendered_data = resp
+    end
+
+    def ensure_protocol(url)
+      return url if url.starts_with?('http')
+
+      # annoying but the request payload is different with localhost/rack vs
+      # api gateway
+      # check out:
+      #   spec/fixtures/dumps/api_gateway/posts/create.json
+      #   spec/fixtures/dumps/rack/posts/create.json
+      protocol = if actual_host.include?("amazonaws.com") # API Gateway
+          headers["x-forwarded-proto"]
+        elsif headers["origin"] # Rack / localhost
+          URI.parse(headers["origin"]).scheme
+        else
+          "http" # fallback. Capybara / Selenium tests
+        end
+
+      raise "Invalid protocol #{protocol}" unless protocol.starts_with?('http')
+
+      "#{protocol}://#{url}"
+    end
+  end
+end

data/lib/jets/controller/renderers.rb

@@ -0,0 +1,5 @@
+module Jets::Controller::Renderers
+  autoload :AwsProxyRenderer, "jets/controller/renderers/aws_proxy_renderer"
+  autoload :BaseRenderer, "jets/controller/renderers/base_renderer"
+  autoload :TemplateRenderer, "jets/controller/renderers/template_renderer"
+end

data/lib/jets/controller/renderers/aws_proxy_renderer.rb

@@ -0,0 +1,69 @@
+require "rack/utils"
+
+# Special renderer.  All the other renderers lead here
+module Jets::Controller::Renderers
+  class AwsProxyRenderer < BaseRenderer
+    # Transform the structure to AWS_PROXY compatiable structure
+    # http://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-lambda-proxy-integrations.html#api-gateway-simple-proxy-for-lambda-output-format
+    # Example response:
+    #
+    #   {
+    #     "statusCode" => status,
+    #     "headers" => headers,
+    #     "body" => body,
+    #     "isBase64Encoded" => base64,
+    #   }
+    def render
+      # we do some normalization here
+      status = map_status_code(@options[:status]) || 200
+      status = status.to_s # API Gateway requires a string but rack is okay with either
+      body = @options[:body]
+      base64 = normalized_base64_option(@options)
+
+      headers = @options[:headers] || {}
+      headers = cors_headers.merge(headers)
+      headers["Content-Type"] ||= @options[:content_type] || "text/html; charset=utf-8"
+
+      # Compatiable Lambda Proxy response Hash.
+      # Additional extra keys results in compatiability. Explictly assign keys.
+      {
+        "statusCode" => status,
+        "headers" => headers,
+        "body" => body,
+        "isBase64Encoded" => base64,
+      }
+    end
+
+    # maps:
+    #   :continue => 100
+    #   :success => 200
+    #   etc
+    def map_status_code(code)
+      if code.is_a?(Symbol)
+        Rack::Utils::SYMBOL_TO_STATUS_CODE[code]
+      else
+        code
+      end
+    end
+
+    def normalized_base64_option(options)
+      base64 = @options[:base64] if options.key?(:base64)
+      base64 = @options[:isBase64Encoded] if options.key?(:isBase64Encoded)
+      base64
+    end
+
+    def cors_headers
+      case Jets.config.cors
+      when true
+        {
+          "Access-Control-Allow-Origin" => "*", # Required for CORS support to work
+          "Access-Control-Allow-Credentials" => "true" # Required for cookies, authorization headers with HTTPS
+        }
+      when Hash
+        Jets.config.cors # contains Hash with Access-Control-Allow-* values
+      else
+        {}
+      end
+    end
+  end
+end

data/lib/jets/controller/renderers/base_renderer.rb

@@ -0,0 +1,16 @@
+# Interface:
+#   subclasses must implement render
+module Jets::Controller::Renderers
+  class BaseRenderer
+    delegate :request, :event, :headers, to: :controller
+    attr_reader :controller
+    def initialize(controller, options={})
+      @controller = controller
+      @options = options
+    end
+
+    def render_aws_proxy(options)
+      AwsProxyRenderer.new(@controller, options).render
+    end
+  end
+end

data/lib/jets/controller/renderers/template_renderer.rb

@@ -0,0 +1,107 @@
+module Jets::Controller::Renderers
+  class TemplateRenderer < BaseRenderer
+    def controller_instance_variables
+      instance_vars = @controller.instance_variables.inject({}) do |vars, v|
+        k = v.to_s.sub(/^@/,'') # @var => var
+        vars[k] = @controller.instance_variable_get(v)
+        vars
+      end
+      instance_vars[:event] = event
+      instance_vars
+    end
+
+    def render
+      setup_action_controller # setup only when necessary
+
+      # Rails rendering does heavy lifting
+      renderer = ActionController::Base.renderer.new(renderer_options)
+      body = renderer.render(render_options)
+      @options[:body] = body # important to set as it was originally nil
+
+      render_aws_proxy(@options)
+    end
+
+    # Example: posts/index
+    def default_template_name
+      "#{template_namespace}/#{@controller.meth}"
+    end
+
+    # PostsController => "posts" is the namespace
+    def template_namespace
+      @controller.class.to_s.sub('Controller','').underscore.pluralize
+    end
+
+    # default options:
+    #   https://github.com/rails/rails/blob/master/actionpack/lib/action_controller/renderer.rb#L41-L47
+    def renderer_options
+      origin = headers["origin"]
+      if origin
+        uri = URI.parse(origin)
+        https = uri.scheme == "https"
+      end
+      options = {
+        http_host: headers["host"],
+        https: https,
+        # script_name: "",
+        # input: ""
+      }
+      @options[:method] = event["httpMethod"].downcase if event["httpMethod"]
+      options
+    end
+
+    def render_options
+      # nomralize the template option
+      template = @options[:template]
+      if template and !template.include?('/')
+        template = "#{template_namespace}/#{template}"
+      end
+      template ||= default_template_name
+      # ready to override @options[:template]
+      @options[:template] = template if @options[:template]
+
+      render_options = {
+        template: template, # weird: template needs to be set no matter because it
+          # sets the name which is used in lookup_context.rb:209:in `normalize_name'
+        layout: @options[:layout],
+        assigns: controller_instance_variables,
+      }
+      types = %w[json inline plain file xml body action].map(&:to_sym)
+      types.each do |type|
+        render_options[type] = @options[type] if @options[type]
+      end
+
+      render_options
+    end
+
+    def setup_action_controller
+      require "action_controller"
+      require "jets/rails_overrides"
+
+      # laod helpers
+      helper_class = self.class.name.to_s.sub("Controller", "Helper")
+      helper_path = "#{Jets.root}app/helpers/#{helper_class.underscore}.rb"
+      ActiveSupport.on_load :action_view do
+        include ApplicationHelper
+        include helper_class.constantize if File.exist?(helper_path)
+      end
+
+      ActionController::Base.append_view_path("#{Jets.root}app/views")
+
+      setup_webpacker if Jets.webpacker?
+    end
+
+    def setup_webpacker
+      require 'webpacker'
+      require 'webpacker/helper'
+
+      ActiveSupport.on_load :action_controller do
+        ActionController::Base.helper Webpacker::Helper
+      end
+
+      ActiveSupport.on_load :action_view do
+        include Webpacker::Helper
+      end
+    end
+
+  end
+end