jets_bb_fork 0.0.4

data/lib/jets/resource/api_gateway/cors.rb

@@ -0,0 +1,61 @@
+module Jets::Resource::ApiGateway
+  # Might be weird inheriting from Method because Method has Method#cors also
+  # but Cors is essentially a Method class.
+  class Cors < Method
+    def definition
+      {
+        cors_logical_id => {
+          type: "AWS::ApiGateway::Method",
+
+          properties: {
+            resource_id: "!Ref #{resource_id}",
+            rest_api_id: "!Ref #{RestApi.logical_id}",
+            authorization_type: cors_authorization_type,
+            http_method: "OPTIONS",
+            method_responses: [{
+              status_code: '200',
+              response_parameters: response_parameters(true),
+              response_models: {},
+            }],
+            request_parameters: {},
+            integration: {
+              type: "MOCK",
+              request_templates: {
+                "application/json": "{statusCode:200}",
+              },
+              integration_responses: [{
+                status_code: '200',
+                response_parameters: response_parameters,
+                response_templates: {
+                  "application/json": '',
+                },
+              }] # closes integration_responses
+            } # closes integration
+          } # closes properties
+        } # closes logical id
+      } # closes definition
+    end
+
+    def response_parameters(method_response=false)
+      cors_headers.map do |k,v|
+        k = "method.response.header.#{k}"
+        v = method_response ? true : "'#{v}'" # surround value with single quotes
+        [k,v]
+      end.to_h
+    end
+
+    # Always the pre-flight headers in this case
+    def cors_headers
+      rack = Jets::Controller::Middleware::Cors.new(Jets.application)
+      rack.cors_headers(true)
+    end
+
+    def cors_authorization_type
+      Jets.config.api.cors_authorization_type || @route.authorization_type || "NONE"
+    end
+
+    def cors_logical_id
+      "#{resource_logical_id}_cors_api_method"
+    end
+  end
+end

data/lib/jets/resource/api_gateway/deployment.rb

@@ -0,0 +1,78 @@
+module Jets::Resource::ApiGateway
+  class Deployment < Jets::Resource::Base
+    def definition
+      {
+        deployment_logical_id => {
+          type: "AWS::ApiGateway::Deployment",
+          properties: {
+            description: "Version #{timestamp} deployed by jets",
+            rest_api_id: "!Ref #{RestApi.logical_id}",
+            stage_name: stage_name,
+          }
+        }
+      }
+    end
+
+    def parameters
+      p = {
+        "IamRole" => "IamRole",
+        "RestApi" => "RestApi",
+        "S3Bucket" => "S3Bucket",
+      }
+      p[:DomainName] = "DomainName" if Jets.custom_domain?
+      p
+    end
+
+    def outputs(internal=false)
+      rest_api = internal ? RestApi.internal_logical_id : "RestApi"
+      {
+        "RestApiUrl" => "!Sub 'https://${#{rest_api}}.execute-api.${AWS::Region}.amazonaws.com/#{stage_name}/'",
+      }
+    end
+
+    def depends_on
+      expression = "#{Jets::Naming.template_path_prefix}-*_controller*"
+      controller_logical_ids = []
+      Dir.glob(expression).each do |path|
+        next unless File.file?(path)
+
+        regexp = Regexp.new(".*#{Jets.config.project_namespace}-")
+        controller_name = path.sub(regexp, '').sub('.yml', '')
+        # map the path to a camelized logical_id. Example:
+        #   /tmp/jets/demo/templates/demo-dev-2-posts_controller.yml to
+        #   PostsController
+        controller_logical_id = controller_name.underscore.camelize
+
+        controller_logical_ids << controller_logical_id
+      end
+      controller_logical_ids
+    end
+
+    # stage_name: dev, dev-1, dev-2, etc
+    def stage_name
+      self.class.stage_name
+    end
+
+    def self.stage_name
+      # Stage name only allows a-zA-Z0-9_
+      [Jets.config.short_env, Jets.config.env_extra].compact.join('_').gsub('-','_')
+    end
+
+    def timestamp
+      self.class.timestamp
+    end
+
+    @@timestamp = nil
+    def self.timestamp
+      @@timestamp ||= Time.now.strftime("%Y%m%d%H%M%S")
+    end
+
+    def deployment_logical_id
+      self.class.logical_id.underscore
+    end
+
+    def self.logical_id
+      "ApiDeployment#{timestamp}"
+    end
+  end
+end

data/lib/jets/resource/api_gateway/domain_name.rb

@@ -0,0 +1,59 @@
+# CloudFormation Docs AWS::ApiGateway::DomainName: https://amzn.to/2Bsnmbq
+#
+# Example:
+#
+#   MyDomainName:
+#     Type: 'AWS::ApiGateway::DomainName'
+#     Properties:
+#       DomainName: api.mydomain.com
+#       CertificateArn: arn:aws:acm:us-east-1:111122223333:certificate/fb1b9770-a305-495d-aefb-27e5e101ff3
+#
+module Jets::Resource::ApiGateway
+  class DomainName < Jets::Resource::Base
+    def definition
+      properties = {
+        domain_name: domain_name,
+        endpoint_configuration: {
+          types: endpoint_types
+        }
+      }
+      # Can really only be REGIONAL or EDGE
+      if endpoint_types.include?("REGIONAL")
+        properties[:regional_certificate_arn] = cert_arn
+      end
+      if endpoint_types.include?("EDGE")
+        properties[:certificate_arn] = cert_arn
+      end
+
+      {
+        domain_name: {
+          type: "AWS::ApiGateway::DomainName",
+          properties: properties
+        }
+      }
+    end
+
+    def outputs
+      {
+        "DomainName" => "!Ref DomainName",
+      }
+    end
+
+    def domain_name
+      subdomain = Jets.project_namespace
+      managed_domain_name = "#{subdomain}.#{Jets.config.domain.hosted_zone_name}"
+      name = Jets.config.domain.name || managed_domain_name
+      # Strip trailing period if there is one set accidentally or else get this error
+      #   Trailing period should be omitted from domain name (Service: AmazonApiGateway; Status Code: 400; Error Code: BadRequestException
+      name.sub(/\.$/,'')
+    end
+
+    def endpoint_types
+      [Jets.config.domain.endpoint_type].flatten
+    end
+
+    def cert_arn
+      Jets.config.domain.cert_arn
+    end
+  end
+end

data/lib/jets/resource/api_gateway/method.rb

@@ -0,0 +1,98 @@
+# Converts a Jets::Route to a CloudFormation Jets::Resource::ApiGateway::Method resource
+module Jets::Resource::ApiGateway
+  class Method < Jets::Resource::Base
+    # also delegate permission for a method
+    delegate :permission,
+             to: :resource
+
+    # route - Jets::Route
+    def initialize(route)
+      @route = route
+    end
+
+    def definition
+      {
+        method_logical_id => {
+          type: "AWS::ApiGateway::Method",
+          properties: {
+            resource_id: "!Ref #{resource_id}",
+            rest_api_id: "!Ref #{RestApi.logical_id}",
+            http_method: @route.method,
+            request_parameters: {},
+            authorization_type: authorization_type,
+            integration: {
+              integration_http_method: "POST",
+              type: "AWS_PROXY",
+              uri: "!Sub arn:aws:apigateway:${AWS::Region}:lambda:path/2015-03-31/functions/${{namespace}LambdaFunction.Arn}/invocations"
+            },
+            method_responses: []
+          }
+        }
+      }
+    end
+
+    def method_logical_id
+      # https://stackoverflow.com/questions/6104240/how-do-i-strip-non-alphanumeric-characters-from-a-string-and-keep-spaces
+      # Add path to the logical id to allow 2 different paths to be connected to the same controller action.
+      # Example:
+      #
+      #   root "jets/public#show"
+      #   any "*catchall", to: "jets/public#show"
+      #
+      # Without the path in the logical id, the logical id would be ShowApiMethod for both routes and only the
+      # last one would be created in the CloudFormation template.
+      path = @route.path.gsub('*','')
+              .gsub(/[^0-9a-z]/i, ' ')
+              .gsub(/\s+/, '_')
+      path = nil if path == ''
+      http_verb = @route.method.downcase
+      [path, "{namespace}_#{http_verb}_api_method"].compact.join('_')
+    end
+
+    def replacements
+      # mimic task to grab replacements, we want the namespace to be the lambda function's namespace
+      resources = [definition]
+      task = Jets::Lambda::Task.new(@route.controller_name, @route.action_name,
+               resources: resources)
+      task.replacements
+    end
+
+    def cors
+      Cors.new(@route)
+    end
+    memoize :cors
+
+  private
+
+    def authorization_type
+      type = @route.authorization_type ||
+             controller_auth_type ||
+             Jets.config.api.authorization_type
+      type.to_s.upcase
+    end
+
+    def controller_auth_type
+      controller_name = @route.to.split('#').first
+      controller = "#{controller_name}_controller".camelize.constantize
+      # Already handles inheritance via class_attribute
+      controller.authorization_type
+    end
+
+    def resource_id
+      @route.path == '' ?
+       "RootResourceId" :
+       Jets::Resource.truncate_id("#{resource_logical_id.camelize}ApiResource")
+    end
+
+    # Example: Posts
+    def resource_logical_id
+      camelized_path.underscore
+    end
+
+    def camelized_path
+      path = @route.path
+      path = "homepage" if path == ''
+      path.gsub('/','_').gsub(':','').gsub('*','').camelize
+    end
+  end
+end

data/lib/jets/resource/api_gateway/resource.rb

@@ -0,0 +1,101 @@
+module Jets::Resource::ApiGateway
+  class Resource < Jets::Resource::Base
+    def initialize(path, internal: false, indexed_paths: nil)
+      @path = path # Examples: "posts/:id/edit" or "posts"
+      @internal = internal
+      @indexed_paths = indexed_paths unless indexed_paths.nil? 
+    end
+
+    def definition
+      {
+        resource_logical_id => {
+          type: "AWS::ApiGateway::Resource",
+          properties: {
+            parent_id: parent_id,
+            path_part: path_part,
+            rest_api_id: "!Ref #{RestApi.logical_id(@internal)}",
+          }
+        }
+      }
+    end  
+
+    def outputs
+      {
+        logical_id => {
+          Value: "!Ref #{logical_id}", 
+          # RDB no longer exporting
+          # Export: {
+          #   Name: "#{logical_id}-#{Jets::Resource::ApiGateway::Deployment.stage_name}"
+          # }
+        }
+      }
+    end
+
+    def resource_logical_id
+      if @path == ''
+        "RootResourceId"
+      else
+        Jets::Resource.truncate_id "#{path_logical_id(@path)}ApiResource"
+      end
+    end
+
+    # For parameter description
+    def desc
+      path.empty? ? 'Homepage route: /' : "Route for: /#{path}"
+    end
+
+    def parent_id
+      if @path.include?('/') # posts/:id or posts/:id/edit
+        parent_path = @path.split('/')[0..-2].join('/')
+        parent_logical_id = path_logical_id(parent_path)
+
+        resource_to_reference = Jets::Resource.truncate_id("#{parent_logical_id}ApiResource")
+        if @indexed_paths
+          # If the parent resource is not found in the same template as self, we need to save the parent
+          # off se we can pass it in as a Parameter from the parent template
+          path_page = @indexed_paths.fetch(@path)
+          parent_path_page = @indexed_paths.fetch(parent_path)
+          required_resources_from_parameters.push({
+            :logical_id => resource_to_reference,
+            :location => "ApiGateway#{parent_path_page}.Outputs.#{resource_to_reference}" 
+          }) if path_page != parent_path_page 
+        end
+        "!Ref #{resource_to_reference}"
+      else
+        '!Ref RootResourceId'
+      end
+    end
+
+    def required_resources_from_parameters
+      @required_resources_from_parameters ||= []
+    end
+
+    def path_part
+      last_part = path.split('/').last
+      last_part.split('/').map {|s| transform_capture(s) }.join('/') if last_part
+    end
+
+    # Modify the path to conform to API Gateway capture expressions
+    def path
+      @path.split('/').map {|s| transform_capture(s) }.join('/')
+    end
+
+    def transform_capture(text)
+      if text.starts_with?(':')
+        text = text.sub(':','')
+        text = "{#{text}}" # :foo => {foo}
+      end
+      if text.starts_with?('*')
+        text = text.sub('*','')
+        text = "{#{text}+}" # *foo => {foo+}
+      end
+      text
+    end
+
+  private
+    # Similar path_logical_id method in resource/route.rb
+    def path_logical_id(path)
+      path.gsub('/','_').gsub(':','').gsub('*','').gsub('-','_').camelize
+    end
+  end
+end

data/lib/jets/resource/api_gateway/rest_api.rb

@@ -0,0 +1,56 @@
+module Jets::Resource::ApiGateway
+  class RestApi < Jets::Resource::Base
+    def definition
+      properties = {
+        name: Jets::Naming.gateway_api_name,
+        endpoint_configuration: { types: endpoint_types }
+      }
+      properties[:binary_media_types] = binary_media_types if binary_media_types
+
+      {
+        internal_logical_id => {
+          type: "AWS::ApiGateway::RestApi",
+          properties: properties
+        }
+      }
+    end
+
+    def internal_logical_id
+      self.class.logical_id(true)
+    end
+
+    def self.logical_id(internal=false)
+      internal ? internal_logical_id : "RestApi"
+    end
+
+    @@internal_logical_id = nil
+    def self.internal_logical_id
+      @@internal_logical_id ||= LogicalId.new.get
+    end
+
+    def outputs
+      {
+        "RestApi" => "!Ref #{internal_logical_id}",
+        "Region" => "!Ref AWS::Region",
+        "RootResourceId" => "!GetAtt #{internal_logical_id}.RootResourceId",
+      }
+    end
+
+    def endpoint_types
+      [Jets.config.api.endpoint_type].flatten
+    end
+
+    # TODO: Looks like there's a bug with CloudFormation. On an API Gateway update
+    # we need to pass in the escaped version: multipart~1form-data
+    # On a brand new API Gateway creation, we need to pass in the unescaped form:
+    # multipart/form-data
+    # We are handling this with a full API Gateway replacement instead because it
+    # can be generalized more easily.
+    def binary_media_types
+      types = Jets.config.api.binary_media_types
+      return nil if types.nil? || types.empty?
+
+      [types].flatten
+    end
+  end
+end