jets-fs 1.6.10

data/lib/jets/resource/replacer.rb

@@ -0,0 +1,77 @@
+class Jets::Resource
+  class Replacer
+    extend Memoist
+
+    def initialize(replacements={})
+      @replacements = replacements
+    end
+
+    # Replace placeholder hash values with replacements.  This does a deep replacement
+    # to the hash values.  The replacement "key" is the string value within the value.
+    #
+    # Example:
+    #
+    #   attributes = {whatever: "foo REPLACE_KEY bar" }
+    #   replace_placeholders(attributes, REPLACE_KEY: "blah:arn")
+    #   => {whatever: "foo blah:arn bar" }
+    #
+    # Also, we always replace the special {namespace} value in the hash values. Example:
+    #
+    #   attributes = {whatever: "{namespace}LambdaFunction" }
+    #   replace_placeholders(attributes, {})
+    #   => {whatever: "foo PostsControllerIndexLambdaFunction bar" }
+    #
+    def replace_placeholders(attributes)
+      update_values(attributes)
+    end
+
+    def update_values(original)
+      case original
+      when Array
+        original.map { |v| update_values(v) }
+      when Hash
+        initializer = original.map do |k, v|
+          [k, update_values(v)]
+        end
+        Hash[initializer]
+      else
+        replace_value(original)
+      end
+    end
+
+    def replace_value(value)
+      # Dont perform replacement on Integers
+      return value if value.is_a?(Integer)
+      # return value unless value.is_a?(String) or value.is_a?(Symbol)
+
+      value = value.to_s # normalize to String
+      @replacements.each do |k,v|
+        # IE: Replaces {namespace} => SecurityJobCheck
+        value = value.gsub("{#{k}}", v)
+      end
+      value
+    end
+
+    class << self
+      # Examples:
+      #   "AWS::Events::Rule" => "events.amazonaws.com",
+      #   "AWS::Config::ConfigRule" => "config.amazonaws.com",
+      #   "AWS::ApiGateway::Method" => "apigateway.amazonaws.com"
+      def principal_map(type)
+        service = type.split('::')[1].downcase
+        "#{service}.amazonaws.com"
+      end
+
+      # From AWS docs: https://amzn.to/2N0QXQL
+      # source_arn is "not supported by all event sources"
+      #
+      # When it is not available the resource definition should add it.
+      def source_arn_map(type)
+        map = {
+          "AWS::ApiGateway::Method" => "!Sub arn:aws:execute-api:${AWS::Region}:${AWS::AccountId}:${RestApi}/*/*",
+        }
+        map[type]
+      end
+    end
+  end
+end

data/lib/jets/resource/route53.rb

@@ -0,0 +1,3 @@
+module Jets::Resource::Route53
+  autoload :RecordSet, 'jets/resource/route53/record_set'
+end

data/lib/jets/resource/route53/record_set.rb

@@ -0,0 +1,70 @@
+# CloudFormation Docs AWS::Route53::RecordSet: https://amzn.to/2BtP9s5
+#
+# Example:
+#
+#   DnsRecord:
+#     Type: AWS::Route53::RecordSet
+#     Properties:
+#       HostedZoneName: !Ref 'HostedZoneResource'
+#       Comment: DNS name for my instance.
+#       Name: !Join ['', [!Ref 'Ec2Instance', ., !Ref 'AWS::Region', ., !Ref 'HostedZone', .]]
+#       Type: A
+#       TTL: '900'
+#       ResourceRecords:
+#       - !GetAtt Ec2Instance.PublicIp
+module Jets::Resource::Route53
+  class RecordSet < Jets::Resource::Base
+    def definition
+      {
+        dns_record: {
+          type: "AWS::Route53::RecordSet",
+          properties: {
+            hosted_zone_name: hosted_zone_name,
+            comment: "DNS record managed by Jets",
+            name: name,
+            type: "CNAME",
+            ttl: "60",
+            resource_records: [
+              cname,
+            ],
+          }
+        }
+      }
+    end
+
+    def cname
+      if endpoint_types.include?("REGIONAL")
+        "!GetAtt DomainName.RegionalDomainName"
+      else
+        "!GetAtt DomainName.DistributionDomainName"
+      end
+    end
+
+    def domain_name
+      Jets::Resource::ApiGateway::DomainName.new
+    end
+    memoize :domain_name
+
+    def endpoint_types
+      domain_name.endpoint_types
+    end
+
+    # IE: demo-dev.mydomain.com
+    def name
+      # Weird looking but correct: domain_name is object and domain_name is also method
+      domain_name.domain_name
+    end
+
+    # IE: mydomain.com
+    def hosted_zone_name
+      name = Jets.config.domain.hosted_zone_name
+      name.ends_with?('.') ? name : "#{name}." # add trailing period if missing
+    end
+
+    def outputs
+      {
+        "DnsRecord" => "!Ref DnsRecord",
+      }
+    end
+  end
+end

data/lib/jets/resource/s3.rb

@@ -0,0 +1,17 @@
+class Jets::Resource
+  class S3 < Jets::Resource::Base
+    def definition
+      {
+        s3_bucket: {
+          type: "AWS::S3::Bucket"
+        }
+      }
+    end
+
+    def outputs
+      {
+        "S3Bucket" => "!Ref S3Bucket",
+      }
+    end
+  end
+end

data/lib/jets/resource/sns.rb

@@ -0,0 +1,3 @@
+module Jets::Resource::Sns
+  autoload :Topic, 'jets/resource/sns/topic'
+end

data/lib/jets/resource/sqs.rb

@@ -0,0 +1,3 @@
+module Jets::Resource::Sqs
+  autoload :Queue, 'jets/resource/sqs/queue'
+end

data/lib/jets/resource/standardizer.rb

@@ -0,0 +1,42 @@
+class Jets::Resource
+  class Standardizer
+    attr_reader :definition
+    def initialize(*definition)
+      @definition = definition.flatten
+    end
+
+    def template
+      camelize(standarize(@definition))
+    end
+
+    def camelize(attributes)
+      Jets::Camelizer.transform(attributes)
+    end
+
+    def standarize(definition)
+      first, second, third, _ = definition
+      if definition.size == 1 && first.is_a?(Hash) # long form
+        first # pass through
+      elsif definition.size == 2 && second.is_a?(Hash) # medium form
+        logical_id, attributes = first, second
+        attributes.delete(:properties) if attributes[:properties].nil? || attributes[:properties].empty?
+        { logical_id => attributes }
+      elsif definition.size == 2 && second.is_a?(String) # short form
+        logical_id, type = first, second
+        { logical_id => {
+            type: type
+        }}
+      elsif definition.size == 3 && (second.is_a?(String) || second.is_a?(NilClass))# short form
+        logical_id, type, properties = first, second, third
+        template = { logical_id => {
+                       type: type
+                    }}
+        attributes = template.values.first
+        attributes[:properties] = properties unless properties.empty?
+        template
+      else # Dont understand this form
+        raise "Invalid form provided. definition #{definition.inspect}"
+      end
+    end
+  end
+end

data/lib/jets/route.rb

@@ -0,0 +1,166 @@
+# route = Jets::Route.new(
+#   path: "posts",
+#   method: :get,
+#   to: "posts#index",
+# )
+class Jets::Route
+  CAPTURE_REGEX = "([^/]*)" # as string
+
+  def initialize(options)
+    @options = options
+  end
+
+  # IE: standard: posts/:id/edit
+  #     api_gateway: posts/{id}/edit
+  def path(format=:jets)
+    case format
+    when :api_gateway
+      api_gateway_format(@options[:path])
+    when :raw
+      @options[:path]
+    else # jets format
+      ensure_jets_format(@options[:path])
+    end
+  end
+
+  def method
+    @options[:method].to_s.upcase
+  end
+
+  # IE: posts#index
+  def to
+    @options[:to]
+  end
+
+  def internal?
+    !!@options[:internal]
+  end
+
+  def homepage?
+    path == ''
+  end
+
+  # IE: PostsController
+  def controller_name
+    to.sub(/#.*/,'').camelize + "Controller"
+  end
+
+  # IE: index
+  def action_name
+    to.sub(/.*#/,'')
+  end
+
+  # Checks to see if the corresponding controller exists. Useful to validate routes
+  # before deploying to CloudFormation and then rolling back.
+  def valid?
+    controller_class = begin
+      controller_name.constantize
+    rescue NameError
+      return false
+    end
+    controller_class.lambda_functions.include?(action_name.to_sym)
+  end
+
+  # Extracts the path parameters from the actual path
+  # Only supports extracting 1 parameter. So:
+  #
+  #   actual_path: posts/tung/edit
+  #   route.path: posts/:id/edit
+  #
+  # Returns:
+  #    { id: "tung" }
+  def extract_parameters(actual_path)
+    if path.include?(':')
+      extract_parameters_capture(actual_path)
+    elsif path.include?('*')
+      extract_parameters_proxy(actual_path)
+    else
+      # Lambda AWS_PROXY sets null to the input request when there are no path parmeters
+      nil
+    end
+  end
+
+  def extract_parameters_proxy(actual_path)
+    # changes path to a string used for a regexp
+    # others/*proxy => others\/(.*)
+    # nested/others/*proxy => nested/others\/(.*)
+    if path.include?('/')
+      leading_path = path.split('/')[0..-2].join('/') # drop last segment
+      # leading_path: nested/others
+      # capture everything after the leading_path as the value
+      regexp = Regexp.new("#{leading_path}/(.*)")
+      value = actual_path.match(regexp)[1]
+    else
+      value = actual_path
+    end
+
+    # the last segment without the '*' is the key
+    proxy_segment = path.split('/').last # last segment is the proxy segment
+    # proxy_segment: *proxy
+    key = proxy_segment.sub('*','')
+
+    { key => value }
+  end
+
+  def extract_parameters_capture(actual_path)
+    # changes path to a string used for a regexp
+    # posts/:id/edit => posts\/(.*)\/edit
+    labels = []
+    regexp_string = path.split('/').map do |s|
+                      if s.start_with?(':')
+                        labels << s.delete_prefix(':')
+                        CAPTURE_REGEX
+                      else
+                        s
+                      end
+                    end.join('\/')
+    # make sure beginning and end of the string matches
+    regexp_string = "^#{regexp_string}$"
+    regexp = Regexp.new(regexp_string)
+
+    values = regexp.match(actual_path).captures
+    labels.map do |next_label|
+      [next_label, values.delete_at(0)]
+    end.to_h
+  end
+
+  def authorization_type
+    @options[:authorization_type]
+  end
+
+private
+  def ensure_jets_format(path)
+    path.split('/').map do |s|
+      if s =~ /^\{/ and s =~ /\+\}$/
+        s.sub(/^\{/, '*').sub(/\+\}$/,'') # {proxy+} => *proxy
+      elsif s =~ /^\{/ and s =~ /\}$/
+        s.sub('{',':').sub(/\}$/,'') # {id} => :id
+      else
+        s
+      end
+    end.join('/')
+  end
+
+  def api_gateway_format(path)
+    path.split('/')
+      .map {|s| transform_capture(s) }
+      .map {|s| transform_proxy(s) }
+      .join('/')
+  end
+
+  def transform_capture(text)
+    if text.starts_with?(':')
+      text = text.sub(':','')
+      text = "{#{text}}"
+    end
+    text
+  end
+
+  def transform_proxy(text)
+    if text.starts_with?('*')
+      text = text.sub('*','')
+      text = "{#{text}+}"
+    end
+    text
+  end
+end

data/lib/jets/router.rb

@@ -0,0 +1,175 @@
+require 'text-table'
+
+module Jets
+  class Router
+    autoload :Scope, 'jets/router/scope'
+
+    attr_reader :routes
+    def initialize
+      @routes = []
+    end
+
+    def draw(&block)
+      instance_eval(&block)
+      check_collision!
+    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
+    end
+
+    # Methods supported by API Gateway
+    %w[any delete get head options patch post put].each do |method_name|
+      define_method method_name do |path, options|
+        create_route(options.merge(path: path, method: __method__))
+      end
+    end
+
+    def create_route(options)
+      # Currently only using scope to add namespace
+      # TODO: Can use it to add additional things like authorization_type
+      # Would be good to add authorization_type at the controller level also
+      options[:path] = add_namespace(options[:path])
+      @routes << Route.new(options)
+    end
+
+    def add_namespace(path)
+      return path unless @scope
+      ns = @scope.full_namespace
+      return path unless ns
+      "#{ns}/#{path}"
+    end
+
+    def namespace(ns, &block)
+      scope(namespace: ns, &block)
+    end
+
+    def scope(options={})
+      root_level = @scope.nil?
+      @scope = root_level ? Scope.new(options) : @scope.new(options)
+      yield
+    ensure
+      @scope = @scope.parent if @scope
+    end
+
+    # resources macro expands to all the routes
+    def resources(name)
+      get "#{name}", to: "#{name}#index"
+      get "#{name}/new", to: "#{name}#new" unless api_mode?
+      get "#{name}/:id", to: "#{name}#show"
+      post "#{name}", to: "#{name}#create"
+      get "#{name}/:id/edit", to: "#{name}#edit" unless api_mode?
+      put "#{name}/:id", to: "#{name}#update"
+      post "#{name}/:id", to: "#{name}#update" # for binary uploads
+      patch "#{name}/:id", to: "#{name}#update"
+      delete "#{name}/:id", to: "#{name}#delete"
+    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
+    end
+
+    # root "posts#index"
+    def root(to, options={})
+      default = {path: '', to: to, method: :get, root: true}
+      options = default.merge(options)
+      @routes << Route.new(options)
+    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
+    end
+
+    # Useful for RouterMatcher
+    #
+    # Precedence:
+    # 1. Routes with no captures get highest precedence: posts/new
+    # 2. Then consider the routes with captures: post/:id
+    # 3. Last consider the routes with wildcards: *catchall
+    #
+    # Within these 2 groups we consider the routes with the longest path first
+    # since posts/:id and posts/:id/edit can both match.
+    def ordered_routes
+      length = Proc.new { |r| r.path.length * -1 }
+      capture_routes = routes.select { |r| r.path.include?(':') }.sort_by(&length)
+      wildcard_routes = routes.select { |r| r.path.include?('*') }.sort_by(&length)
+      simple_routes = (routes - capture_routes - wildcard_routes).sort_by(&length)
+      simple_routes + capture_routes + wildcard_routes
+    end
+
+    def self.has_controller?(name)
+      routes.detect { |r| r.controller_name == name }
+    end
+
+    # Class methods
+    def self.draw
+      drawn_router
+    end
+
+    @@drawn_router = nil
+    def self.drawn_router
+      return @@drawn_router if @@drawn_router
+
+      router = Jets.application.routes
+      @@drawn_router = router
+    end
+
+    def self.routes
+      drawn_router.routes
+    end
+
+    # Returns all paths including subpaths.
+    # Example:
+    # Input: ["posts/:id/edit"]
+    # Output: ["posts", "posts/:id", "posts/:id/edit"]
+    def self.all_paths
+      drawn_router.all_paths
+    end
+
+    def self.routes_help
+      return "Your routes table is empty." if routes.empty?
+
+      table = Text::Table.new
+      table.head = %w[Verb Path Controller#action]
+      routes.each do |route|
+        table.rows << [route.method, route.path, route.to]
+      end
+      table
+    end
+
+    def self.all_routes_valid
+      invalid_routes.empty?
+    end
+
+    def self.invalid_routes
+      routes.select { |r| !r.valid? }
+    end
+  end
+end