jets 5.0.14 → 6.0.0.beta1

data/lib/jets/cfn/deployment.rb

@@ -1,85 +0,0 @@
-module Jets::Cfn
-  class Deployment
-    extend Memoist
-    include Jets::AwsServices
-    include Jets::Command::AwsHelpers
-    include Jets::Command::ApiHelpers
-
-    def initialize(options={})
-      @options = options
-      @stack_name = options[:stack_name] # stack name or stack id (deleted)
-      @rollback_version = options[:rollback_version]
-    end
-
-    def create
-      Jets.boot # needed since Jets is lazy loaded
-      return if disabled?
-      @stack = find_stack(@stack_name)
-      record_deployment if @stack
-    end
-
-    def delete
-      Jets.boot # needed since Jets is lazy loaded
-      return if disabled?
-      @stack = find_stack(@stack_name)
-      delete_deployment if @stack
-    end
-
-    def delete_deployment
-      resp = Jets::Api::Stack.retrieve("current")
-      return if resp["error"] == "not_found"
-      return unless resp["id"]
-      resp = Jets::Api::Stack.delete(resp["id"])
-      puts resp["message"] # IE: Stack demo-dev deleted
-      resp
-    rescue Jets::Api::RequestError => e
-      puts "WARNING: Unable to delete release and stack. #{e.class}: #{e.message}"
-    end
-
-    def record_deployment
-      params = stack_params.merge(git_info.params)
-      params["message"] = create_message
-      resp = Jets::Api::Release.create(params)
-      # Instead of check_for_error_message!(resp) we want to customize it a bit
-      if resp && resp["error"]
-        $stderr.puts "WARN: There was an error creating the release."
-        $stderr.puts "WARN: #{resp["error"]}"
-        exit 1
-      end
-      puts "Release version: #{resp["version"]}" if resp["version"]
-      resp
-    rescue Jets::Api::RequestError => e
-      puts "WARNING: Unable to create release. #{e.class}: #{e.message}"
-    end
-
-    def stack_params
-      {
-        stack_arn: @stack.stack_id,
-        stack_status: @stack.stack_status,
-        message: create_message,
-        deploy_user: deploy_user,
-      }
-    end
-
-    def deploy_user
-      ENV['JETS_DEPLOY_USER'] || git_info.user.first_name || ENV['USER']
-    end
-
-    def git_info
-      Jets::Git::Info.new(@options)
-    end
-    memoize :git_info
-
-    def create_message
-      if @options[:message]
-        @options[:message][0..255]
-      else
-        @rollback_version ? "Rollback to #{@rollback_version}" : "Deploy"
-      end
-    end
-
-    def disabled?
-      Jets.config.pro.disable || !Jets::Api.token
-    end
-  end
-end

data/lib/jets/cfn/download.rb

@@ -1,39 +0,0 @@
-module Jets::Cfn
-  class Download
-    include Jets::AwsServices
-
-    def download_templates(version)
-      bucket = s3_resource.bucket(bucket_name)
-      unless bucket.exists?
-        puts "ERROR: The bucket #{bucket_name} does not exist.".color(:red)
-        exit 1
-      end
-
-      # Cleanup templates folder
-      FileUtils.rm_rf(Jets::Names.templates_folder)
-      FileUtils.mkdir_p(Jets::Names.templates_folder)
-
-      key_path = "jets/cfn-templates/versions/#{version}"
-      objects = bucket.objects(prefix: key_path)
-      if objects.count > 0
-        objects.each do |object|
-          file_name = "#{Jets::Names.templates_folder}/#{object.key.split('/').last}"
-          object.get(response_target: file_name)
-          puts "Downloaded #{file_name} from s3://#{bucket_name}/#{object.key}" if ENV['JETS_DEBUG']
-        end
-      else
-        puts "ERROR: Cannot rollback to this version because the CloudFormation templates are not available.".color(:red)
-        puts <<~EOL
-          This can happen the app was deployed before Jets Pro features were enabled,
-          or if the stack was delete and redeployed. Deleted stacks history are not
-          rollbackable because their original s3 bucket is deleted.
-        EOL
-        exit 1
-      end
-    end
-
-    def bucket_name
-      Jets.s3_bucket
-    end
-  end
-end

data/lib/jets/cfn/params/api/base.rb

@@ -1,39 +0,0 @@
-# Params are an attempt to centralize the logic for building parameters.
-# Params are built at two different times:
-# 1. Cfn::Builders::Api::Methods.build_pages
-#      => Api::Pages::Methods => api-methods-1.yml nested stack
-#    Only uses keys.
-# 2. Cfn::Builders::Parent
-#      => Resource::Nested::Api::Methods => parent.yml logical id ApiMethods1
-#    Uses both keys and values.
-module Jets::Cfn::Params::Api
-  class Base
-    extend Memoist
-
-    def initialize(options={})
-      @options = options
-      @template = load_template # current paged template_path
-      @params = ActiveSupport::HashWithIndifferentAccess.new
-    end
-
-    def params
-      build # interface method
-      @params
-    end
-    memoize :params
-
-    # Nice to be able to use template or template_path so the common Template.load_file
-    # is centralized.
-    def load_template
-      if @options[:template]
-        # At Cfn::Builders::Api::Methods build time, template is in memory
-        @options[:template]
-      else
-        # At Resource::Nested::Api::Methods build time, template is on disk
-        Jets::Cfn::Template.load_file(@options[:template_path])
-      end
-    end
-
-    def build; end # noop by default
-  end
-end

data/lib/jets/cfn/params/api/cors.rb

@@ -1,10 +0,0 @@
-module Jets::Cfn::Params::Api
-  class Cors < Base
-    # interface method
-    def build
-      resources = Resources.new(@options).params
-      methods = Methods.new(@options).params
-      @params = resources.merge(methods)
-    end
-  end
-end

data/lib/jets/cfn/params/api/methods.rb

@@ -1,69 +0,0 @@
-module Jets::Cfn::Params::Api
-  class Methods < Base
-    # interface method
-    def build
-      @params.merge!(RestApi: "!GetAtt ApiGateway.Outputs.RestApi") # common
-      @template[:Resources].each do |logical_id, resource|
-        create_params_from_resource(resource)
-      end
-    end
-
-    def create_params_from_resource(resource)
-      case resource[:Type]
-      when "AWS::ApiGateway::Method"
-        # function name
-        create_function_name_param(resource)
-        # authorizer id
-        create_authorizer_param(resource)
-        # resource id
-        resource_id = resource[:Properties][:ResourceId].sub("!Ref ", "")
-        @params.merge!(resource_id => api_method_stack_value(resource_id))
-      when "AWS::Lambda::Permission"
-        # function name
-        function_name = resource[:Properties][:FunctionName].sub("!Ref ", "")
-        @params.merge!(function_name => controller_stack_value(function_name))
-      end
-    end
-
-    def create_authorizer_param(resource)
-      authorizer_id_ref = resource[:Properties][:AuthorizerId]
-      return unless authorizer_id_ref
-      authorizer_id = authorizer_id_ref.sub("!Ref ", "")
-      @params.merge!(authorizer_id => api_authorizer_stack_value(authorizer_id))
-    end
-
-    # IE: !GetAtt MainAuthorizer.Outputs.MainAuthorizerProtectAuthorizer
-    def api_authorizer_stack_value(authorizer_id)
-      stack = authorizer_id.sub(/(.*?)Authorizer.*Authorizer$/, '\1') # IE: Main
-      stack += "Authorizer" # IE: MainAuthorizer
-      "!GetAtt #{stack}.Outputs.#{authorizer_id}"
-    end
-
-    def create_function_name_param(resource)
-      # Type can be: AWS_PROXY or MOCK (cors)
-      return unless resource[:Properties][:Integration][:Type] == "AWS_PROXY"
-      uri = resource[:Properties][:Integration][:Uri]
-      md = uri.match(%r|functions/\${(.*)}/invocations|)
-      function_name = md[1]
-      @params.merge!(function_name => controller_stack_value(function_name))
-    end
-
-    # function_name: UpControllerIndexLambdaFunction
-    def controller_stack_value(function_name)
-      controller = function_name.sub(/Controller.*/, "Controller")
-      # IE: !GetAtt UpController.Outputs.UpControllerIndexLambdaFunction
-      "!GetAtt #{controller}.Outputs.#{function_name}"
-    end
-
-    def api_method_stack_value(resource_id)
-      # IE: !GetAtt ApiResources1.Outputs.UpApiResource
-      api_stack = if resource_id == "RootResourceId"
-            "ApiGateway"
-          else
-            Jets::Cfn::Params::Api::Resources.stack_logical_id(resource_id)
-          end
-      "!GetAtt #{api_stack}.Outputs.#{resource_id}"
-    end
-  end
-end
-

data/lib/jets/cfn/params/api/resources.rb

@@ -1,28 +0,0 @@
-module Jets::Cfn::Params::Api
-  class Resources < Base
-    # interface method
-    def build
-      # For the nested ApiResources template defined in the parent template, we need
-      # grab the parameters from the other paged ApiResources templates if not in
-      # the current template.
-      @template[:Parameters].keys.each do |key|
-        key = key.to_sym
-        case key.to_s
-        when "RestApi"
-          @params.merge!(key => "!GetAtt ApiGateway.Outputs.RestApi")
-        when "RootResourceId"
-          @params.merge!(key => "!GetAtt ApiGateway.Outputs.RootResourceId")
-        else
-          @params.merge!(key => "!GetAtt #{self.class.stack_logical_id(key)}.Outputs.#{key}")
-        end
-      end
-    end
-
-    class << self
-      # IE: path: #{Jets.build_root}/templates/api-resources-1.yml"
-      def stack_logical_id(parameter)
-        Jets::Cfn::Template.lookup_logical_id("api-resources", parameter)
-      end
-    end
-  end
-end

data/lib/jets/cfn/params/common.rb

@@ -1,14 +0,0 @@
-module Jets::Cfn::Params
-  module Common
-    def parameters
-      parameters = {
-        IamRole: "!GetAtt IamRole.Arn",
-        S3Bucket: "!Ref S3Bucket",
-      }
-      parameters[:GemLayer] = "!Ref GemLayer" if Jets.gem_layer?
-      parameters
-    end
-
-    extend self
-  end
-end

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

@@ -1,82 +0,0 @@
-module Jets::Cfn::Resource::ApiGateway
-  class Authorizer < Jets::Cfn::Base
-    def initialize(props={})
-      @props = props # associated_properties from dsl.rb
-    end
-
-    def definition
-      {
-        authorizer_logical_id => {
-          Type: "AWS::ApiGateway::Authorizer",
-          Properties: props,
-        }
-      }
-    end
-
-    def props
-      default = {
-        # AuthorizerCredentials: '',
-        # AuthorizerResultTtlInSeconds: '',
-        # AuthType: '',
-        # IdentitySource: '', # required
-        # IdentityValidationExpression: '',
-        # Name: '',
-        # ProviderARNs: [],
-        RestApiId: '!Ref RestApi', # Required: Yes
-        Type: '', # Required: Yes
-      }
-
-      unless @props[:Type].to_s.upcase == 'COGNITO_USER_POOLS'
-        @props[:AuthorizerUri] = { # Required: Conditional
-          "Fn::Join" => ['', [
-            'arn:aws:apigateway:',
-            "!Ref 'AWS::Region'",
-            ':lambda:path/2015-03-31/functions/',
-            {"Fn::GetAtt" => ["{namespace}LambdaFunction", "Arn"]},
-            '/invocations'
-          ]]
-        }
-      end
-      @props[:AuthorizerResultTtlInSeconds] = @props.delete(:ttl) if @props[:ttl] # shorthand
-
-      normalize_type!(@props)
-      normalize_identity_source!(@props)
-      default.merge(@props)
-    end
-
-    def authorizer_logical_id
-      "{namespace}Authorizer" # IE: protect_authorizer
-    end
-
-    def outputs
-      # IE: ProtectAuthorizer: !Ref ProtectAuthorizer
-      {
-        logical_id => "!Ref #{logical_id}",
-      }
-    end
-
-  private
-    # Also sets a default if it's not provided
-    def normalize_type!(props)
-      type = props[:Type] || :request
-      @props[:Type] = type.to_s.upcase
-    end
-
-    # Also sets a default if it's not provided
-    def normalize_identity_source!(props)
-      identity_source = props[:IdentitySource] || Jets.config.api.authorizers.default_token_source
-      # request authorizer type can have multiple identity sources.
-      # token authorizer type has only one identity source.
-      # We handle both cases.
-      identity_sources = identity_source.split(',') # to handle multipe
-      identity_sources.map! do |source|
-        if source.include?(".") # if '.' is detected assume full identify source provided
-          source
-        else
-          "method.request.header.#{source}" # convention
-        end
-      end
-      @props[:IdentitySource] = identity_sources.join(',')
-    end
-  end
-end

data/lib/jets/cfn/resource/api_gateway/base_path/function.rb

@@ -1,57 +0,0 @@
-module Jets::Cfn::Resource::ApiGateway::BasePath
-  class Function < Jets::Cfn::Base
-    include Jets::Cfn::Resource::Lambda::Function::Environment
-
-    def definition
-      {
-        BasePathFunction: {
-          Type: "AWS::Lambda::Function",
-          Properties: {
-            FunctionName: function_name,
-            Description: "Jets#base_path",
-            Code: {
-              S3Bucket: "!Ref S3Bucket",
-              S3Key: code_s3_key,
-            },
-            Role: "!GetAtt BasePathRole.Arn",
-            Handler: handler,
-            Runtime: get_runtime,
-            Timeout: 60,
-            MemorySize: 1536,
-            Environment: env_properties[:Environment],
-            Layers: layers,
-          }
-        }
-      }
-    end
-
-    def get_runtime
-      props = camelize(Jets.application.config.function.to_h)
-      props[:Runtime] || Jets.ruby_runtime
-    end
-
-    def layers
-      return Jets.config.lambda.layers if Jets.config.pro.disable
-      ["!Ref GemLayer"] + Jets.config.lambda.layers
-    end
-
-    # JETS_RESET is respected here because CloudFormation Custom Resources
-    # do not allow updates to the ServiceToken property.
-    # Changing the base-path Lambda Function name results in a CloudFormation error:
-    #
-    #     Modifying service token is not allowed
-    #
-    def function_name
-      "#{Jets.project_namespace}-jets-base-path"
-    end
-
-    def handler
-      "handlers/functions/jets/base_path.lambda_handler"
-    end
-
-    def code_s3_key
-      checksum = Jets::Builders::Md5.checksums["stage/code"]
-      "jets/code/code-#{checksum}.zip" # s3_key
-    end
-  end
-end

data/lib/jets/cfn/resource/api_gateway/base_path/mapping.rb

@@ -1,45 +0,0 @@
-# CloudFormation Docs AWS::ApiGateway::DomainName: https://amzn.to/2BsrSqo
-#
-# Example:
-#
-#   Type: AWS::ApiGateway::BasePathMapping
-#   Properties:
-#     BasePath: String
-#     DomainName: String
-#     RestApiId: String
-#     Stage: String
-#
-# Currently unable to add base path mapping in-place with CloudFormation.
-# The workaround for this is to do it post deployment with raw API calls outside
-# of CloudFormation.  Leaving this around for now in case there's a workaround
-# to get this into CloudFormation instead of raw API calls. Some notes:
-#   * Also tried to change the domain name of to something like demo-dev-[random].mydomain.com
-#   That does not work because the domain name has to match the route53 record exactly.
-#
-module Jets::Cfn::Resource::ApiGateway::BasePath
-  class Mapping < Jets::Cfn::Base
-    def definition
-      function_logical_id = "BasePathFunction" # lambda function that supports custom resource
-      {
-        BasePathMapping: {
-          Type: "Custom::BasePathMapping",
-          Properties: {
-            ServiceToken: "!GetAtt #{function_logical_id}.Arn",
-            # A change to any of these properties updates the CloudFormation Custom Resource
-            # IE: It runs the Lambda function that implements the custom resource
-            BasePath: Jets.config.domain.base_path, # '' empty path represents root
-            DomainName: "!Ref DomainName",
-            RestApiId: "!Ref RestApi",
-            Stage: Jets::Cfn::Resource::ApiGateway::Deployment.stage_name,
-          },
-        }
-      }
-    end
-
-    def outputs
-      {
-        BasePathMapping: "!Ref BasePathMapping",
-      }
-    end
-  end
-end

data/lib/jets/cfn/resource/api_gateway/base_path/role.rb

@@ -1,70 +0,0 @@
-module Jets::Cfn::Resource::ApiGateway::BasePath
-  class Role < Jets::Cfn::Base
-    extend Memoist
-    include Jets::AwsServices
-
-    def definition
-      {
-        BasePathRole: {
-          Type: "AWS::IAM::Role",
-          Properties: {
-            # RoleName: role_name,
-            Path: "/",
-            AssumeRolePolicyDocument: {
-              Version: "2012-10-17",
-              Statement: [{
-                Effect: "Allow",
-                Principal: {Service: ["lambda.amazonaws.com"]},
-                Action: ["sts:AssumeRole"]}
-              ]
-            },
-            Policies: [
-              PolicyName: "base-path-mapping-policy", # cannot be empty
-              PolicyDocument: policy_document,
-            ]
-          },
-        }
-      }
-    end
-
-    def policy_document
-      project_namespace = Jets.project_namespace
-      default_policy_statements = Jets.application.config.default_iam_policy # Array of Hashes
-      apigateway = [{
-        Action: [ "apigateway:*" ],
-        Effect: "Allow",
-        Resource: "arn:aws:apigateway:#{Jets.aws.region}::/restapis/*", # scoped to all restapis because this changes
-      },{
-        Action: [ "apigateway:*" ],
-        Effect: "Allow",
-        Resource: "arn:aws:apigateway:#{Jets.aws.region}::/domainnames/*", # scoped to all restapis because this changes
-      }]
-      cloudformation = [{
-        Action: ["cloudformation:DescribeStacks"],
-        Effect: "Allow",
-        Resource: "arn:aws:cloudformation:#{Jets.aws.region}:#{Jets.aws.account}:stack/#{project_namespace}*",
-      }]
-
-      # Combine the statements
-      {
-        Version: '2012-10-17',
-        Statement: default_policy_statements + apigateway + cloudformation
-      }
-    end
-
-    # Duplicated in rest_api/change_detection.rb, base_path/role.rb, rest_api/routes.rb
-    def rest_api_id
-      stack_name = Jets::Names.parent_stack_name
-      return "RestApi" unless stack_exists?(stack_name)
-
-      stack = cfn.describe_stacks(stack_name: stack_name).stacks.first
-
-      api_gateway_stack_arn = lookup(stack[:outputs], "ApiGateway")
-
-      # resources = cfn.describe_stack_resources(stack_name: api_gateway_stack_arn).stack_resources
-      stack = cfn.describe_stacks(stack_name: api_gateway_stack_arn).stacks.first
-      rest_api_id = lookup(stack[:outputs], "RestApi")
-    end
-    memoize :rest_api_id
-  end
-end

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

@@ -1,73 +0,0 @@
-module Jets::Cfn::Resource::ApiGateway
-  class Deployment < Jets::Cfn::Base
-    def definition
-      {
-        deployment_logical_id => {
-          Type: "AWS::ApiGateway::Deployment",
-          Properties: {
-            Description: "Version #{timestamp} deployed by jets",
-            RestApiId: "!Ref #{RestApi.logical_id}",
-            StageName: stage_name,
-          }
-        }
-      }
-    end
-
-    def parameters
-      {
-        RestApi: "RestApi",
-      }
-    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::Names.templates_folder}/*_controller*"
-      controller_logical_ids = []
-      Dir.glob(expression).each do |path|
-        next unless File.file?(path)
-
-        controller_name = path.sub("#{Jets::Names.templates_folder}/", '').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.short_env, Jets.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/cfn/resource/api_gateway/domain_name.rb

@@ -1,65 +0,0 @@
-# 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::Cfn::Resource::ApiGateway
-  class DomainName < Jets::Cfn::Base
-    def definition
-      properties = {
-        DomainName: domain_name,
-        EndpointConfiguration: {
-          Types: endpoint_types
-        }
-      }
-      # Can really only be REGIONAL or EDGE
-      if endpoint_types.include?("REGIONAL")
-        properties[:RegionalCertificateArn] = cert_arn
-      end
-      if endpoint_types.include?("EDGE")
-        properties[:CertificateArn] = cert_arn
-      end
-
-      {
-        DomainName: {
-          Type: "AWS::ApiGateway::DomainName",
-          Properties: properties
-        }
-      }
-    end
-
-    def outputs
-      {
-        DomainName: "!Ref DomainName",
-      }
-    end
-
-    def domain_name
-      name = Jets.config.domain.name
-      if Jets.config.domain.apex
-        name ||= Jets.config.domain.hosted_zone_name
-      else
-        subdomain = Jets.project_namespace
-        managed_domain_name = "#{subdomain}.#{Jets.config.domain.hosted_zone_name}"
-        name ||= managed_domain_name
-      end
-
-      # 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