jets-fs 1.6.10

data/lib/jets/builders/shim_vars.rb

@@ -0,0 +1,5 @@
+module Jets::Builders::ShimVars
+  autoload :App, "jets/builders/shim_vars/app"
+  autoload :Base, "jets/builders/shim_vars/base"
+  autoload :Shared, "jets/builders/shim_vars/shared"
+end

data/lib/jets/builders/shim_vars/app.rb

@@ -0,0 +1,78 @@
+# Jets::Builders::ShimVars::Shared.new(path)
+#
+#   @vars.functions.each do |function_name|
+#     @vars.handler_for(function_name)
+#   end
+#
+# Implements:
+#
+#   functions: IE [:index, :show]
+#   handler_for(function_name): IE handlers/controllers/posts_controller.index
+#   dest_path: IE: handlers/controllers/posts_controller.js
+#
+module Jets::Builders::ShimVars
+  class App < Base
+    # Allow user to specify relative or full path. The right path gets used
+    # internally. Example paths:
+    #   app/controllers/posts_controller.rb
+    #   app/jobs/hard_job.rb
+    #   /tmp/jets/build/app_root/app/jobs/hard_job.rb
+    #   /tmp/jets/build/app_root/app/functions/hello.rb
+    def initialize(path)
+      @full_path = full(path)
+      @relative_path = relative(path)
+    end
+
+    def full(path)
+      path = "#{Jets.root}/#{path}" unless path.starts_with?("/")
+      path
+    end
+
+    def relative(path)
+      full_path = full(path)
+      full_path.sub("#{Jets.root}/", "")
+               .sub(/.*internal\/app/, "app")
+
+    end
+
+    # process_type is key, it will either "controller" or "job".
+    # It is used to deduce klass, etc.
+    # We get the process_type from the path.
+    # Example paths:
+    #   app/controllers/posts_controller.rb
+    #   app/jobs/hard_job.rb
+    def process_type
+      @relative_path.split('/')[1].singularize # controller or job
+    end
+
+    # Returns the public methods of the child_class.
+    # Example: [:create, :update]
+    def functions
+      klass.lambda_functions
+    end
+
+    # Examples: PostsController, HardJob, Hello, HelloFunction
+    def klass
+      @klass ||= Jets::Klass.from_path(@relative_path)
+    end
+
+    def lang(meth)
+      klass.tasks.find
+    end
+
+    # This gets called in the node shim js template
+    # IE handlers/controllers/posts_controller.index
+    def handler_for(meth)
+      # possibly not include _function
+      underscored_name = @relative_path.sub(%r{app/(\w+)/},'').sub('.rb','')
+      "handlers/#{process_type.pluralize}/#{underscored_name}.#{meth}"
+    end
+
+    # Example return: "handlers/controllers/posts.js"
+    # TODO: rename this to dest_path or something better now since using native ruby
+    def dest_path
+      @relative_path
+        .sub("app", "handlers")
+    end
+  end
+end

data/lib/jets/builders/shim_vars/base.rb

@@ -0,0 +1,25 @@
+module Jets::Builders::ShimVars
+  class Base
+    include Jets::AwsServices
+    extend Memoist
+
+    def s3_bucket
+      Jets.aws.s3_bucket
+    end
+
+    def rack_zip
+      checksum_zip(:rack)
+    end
+
+    def bundled_zip
+      checksum_zip(:bundled)
+    end
+
+  private
+    def checksum_zip(name)
+      checksum = Jets::Builders::Md5.checksums["stage/#{name}"]
+      return unless checksum
+      "#{name}-#{checksum}.zip"
+    end
+  end
+end

data/lib/jets/builders/shim_vars/shared.rb

@@ -0,0 +1,37 @@
+# Jets::Builders::ShimVars::Shared.new(fun)
+#
+#   @deducer.functions.each do |function_name|
+#     @deducer.handler_for(function_name)
+#   end
+#
+# Implements:
+#
+#   functions: IE [:index, :show]
+#   handler_for(function_name): IE handlers/controllers/posts_controller.index
+#   dest_path: IE: handlers/controllers/posts_controller.js
+#
+module Jets::Builders::ShimVars
+  class Shared < Base
+    # fun is a Jets::Stack::Function
+    def initialize(fun)
+      @fun = fun
+    end
+
+    # Always only one element for shared functions
+    # functions: IE [:handle]
+    def functions
+      [@fun.meth] # function_names
+    end
+
+    # Dont need function_name arg but keeping the same interface as parent class
+    # IE handlers/shared/functions/bob.handle
+    def handler_for(function_name)
+      @fun.handler_dest
+    end
+
+    # IE handlers/shared/functions/bob.js
+    def dest_path
+      @fun.handler_dest
+    end
+  end
+end

data/lib/jets/builders/templates/handler.rb

@@ -0,0 +1,12 @@
+require "bundler/setup"
+require "jets"
+Jets.once  # runs once in lambda execution context
+
+<% @vars.functions.each do |function_name|
+  handler = @vars.handler_for(function_name)
+  meth = handler.split('.').last
+-%>
+def <%= meth -%>(event:, context:)
+  Jets.process(event, context, "<%= handler -%>")
+end
+<% end %>

data/lib/jets/builders/tidy.rb

@@ -0,0 +1,107 @@
+class Jets::Builders
+  class Tidy
+    include Util
+
+    def initialize(project_root, noop: false)
+      @project_root = project_root
+      @noop = noop
+    end
+
+    def cleanup!
+      removals.each do |removal|
+        removal = removal.sub(%r{^/},'') # remove leading slash
+        path = "#{@project_root}/#{removal}"
+        rm_rf(path)
+      end
+
+      clean_vendor_gems
+      clean_webpack_assets
+    end
+
+    # Clean out unnecessary src and compiled packs because Jets serves them out of s3.
+    # This keeps the code size down to help keep it in size limit so we can use the
+    # live Lambda console editor.
+    def clean_webpack_assets
+      FileUtils.rm_rf("#{@project_root}/app/javascript/src")
+
+      return unless File.exist?("#{@project_root}/public/packs") # this class works for rack subfolder too
+      FileUtils.mv("#{@project_root}/public/packs/manifest.json", "#{stage_area}/manifest.json")
+      FileUtils.rm_rf("#{@project_root}/public/packs")
+      FileUtils.mkdir_p("#{@project_root}/public/packs")
+      FileUtils.mv("#{stage_area}/manifest.json", "#{@project_root}/public/packs/manifest.json")
+    end
+
+    def removals
+      removals = always_removals
+      removals += get_removals("#{@project_root}/.gitignore")
+      removals += get_removals("#{@project_root}/.dockerignore")
+      removals = removals.reject do |p|
+        jetskeep.find do |keep|
+          p.include?(keep)
+        end
+      end
+      removals.uniq
+    end
+
+    def get_removals(file)
+      path = file
+      return [] unless File.exist?(path)
+
+      removal = File.read(path).split("\n")
+      removal.map {|i| i.strip}.reject {|i| i =~ /^#/ || i.empty?}
+      # IE: ["/handlers", "/bundled*", "/vendor/jets]
+    end
+
+    # We clean out ignored files pretty aggressively. So provide
+    # a way for users to keep files from being cleaned out.
+    def jetskeep
+      always = %w[.bundle packs]
+      path = "#{@project_root}/.jetskeep"
+      return always unless File.exist?(path)
+
+      keep = IO.readlines(path)
+      keep = keep.map {|i| i.strip}.reject { |i| i =~ /^#/ || i.empty? }
+      (always + keep).uniq
+    end
+
+    # folders to remove in the vendor/gems folder regardless of the level of the folder
+    def clean_vendor_gems
+      # Thanks: https://stackoverflow.com/questions/11385795/ruby-list-directory-with-dir-including-dotfiles-but-not-and
+      Dir.glob("#{@project_root}/vendor/gems/**/*", File::FNM_DOTMATCH).each do |path|
+        next unless File.directory?(path)
+        dir = File.basename(path)
+        next unless always_removals.include?(dir)
+
+        rm_rf(path)
+      end
+
+      remove_gem_cache
+    end
+
+    # Reason do not remove the cache folder generally is because some gems have
+    # actual cache folders that they used.
+    def remove_gem_cache
+      ruby_minor_version = Jets::RUBY_VERSION.split('.')[0..1].join('.') + '.0'
+      cache_path = "#{@project_root}/vendor/gems/ruby/#{ruby_minor_version}/cache"
+      FileUtils.rm_rf(cache_path)
+    end
+
+    def rm_rf(path)
+      exists = File.exist?("#{path}/.gitkeep") || File.exist?("#{path}/.keep")
+      return if exists
+
+      # say "  rm -rf #{path}".color(:yellow) # uncomment to debug
+      system("rm -rf #{path}") unless @noop
+    end
+
+    # These directories will be removed regardless of dir level
+    def always_removals
+      %w[.git spec tmp]
+    end
+
+    def say(message)
+      message = "NOOP #{message}" if @noop
+      puts message
+    end
+  end
+end

data/lib/jets/builders/util.rb

@@ -0,0 +1,31 @@
+class Jets::Builders
+  module Util
+  private
+    def sh(command)
+      puts "=> #{command}".color(:green)
+      success = system(command)
+      unless success
+        puts "#{command} failed to run.".color(:red)
+        puts caller[0]
+        exit 1
+      end
+      success
+    end
+
+    def headline(message)
+      puts "=> #{message}".color(:cyan)
+    end
+
+    def build_area
+      Jets.build_root
+    end
+
+    def stage_area
+      "#{build_area}/stage"
+    end
+
+    def cache_area
+      "#{build_area}/cache" # cleaner to use full path for this setting
+    end
+  end
+end

data/lib/jets/camelizer.rb

@@ -0,0 +1,67 @@
+# Custom Camelizer with CloudFormation specific handling.
+# Based on: https://stackoverflow.com/questions/8706930/converting-nested-hash-keys-from-camelcase-to-snake-case-in-ruby
+module Jets
+  class Camelizer
+    class << self
+      def transform(value, parent_keys=[])
+        case value
+        when Array
+          value.map { |v| transform(v) }
+        when Hash
+          initializer = value.map do |k, v|
+            new_key = camelize_key(k, parent_keys)
+            [new_key, transform(v, parent_keys+[new_key])]
+          end
+          Hash[initializer]
+        else
+          value # do not transform values
+         end
+      end
+
+      def camelize_key(k, parent_keys=[])
+        k = k.to_s
+
+        if passthrough?(k, parent_keys)
+          k # pass through untouch
+        elsif parent_keys.last == "EventPattern" # top-level
+          k.dasherize
+        elsif parent_keys.include?("EventPattern")
+          # Any keys at 2nd level under EventPattern will be pascalized
+          pascalize(k)
+        else
+          camelize(k)
+        end
+      end
+
+      def passthrough?(k, parent_keys)
+        parent_keys.include?("Variables") || # do not transform keys anything under Variables
+        parent_keys.include?("ResponseParameters") || # do not transform keys anything under Variables
+        k.include?('-') || k.include?('/')
+      end
+
+      def camelize(value)
+        return value if value.is_a?(Integer)
+
+        value = value.to_s.camelize
+        special_map[value] || value
+      end
+
+      def pascalize(value)
+        new_value = value.camelize
+        first_char = new_value[0..0].downcase
+        new_value[0] = first_char
+        new_value
+      end
+
+      # Some keys have special mappings
+      def special_map
+        {
+          "TemplateUrl" => "TemplateURL",
+          "Ttl" => "TTL",
+          "MaxReceiveCount" => "maxReceiveCount",
+          "DeadLetterTargetArn" => "deadLetterTargetArn",
+        }
+      end
+    end
+  end
+end

data/lib/jets/cfn.rb

@@ -0,0 +1,6 @@
+class Jets::Cfn
+  autoload :Builders, "jets/cfn/builders"
+  autoload :Ship, "jets/cfn/ship"
+  autoload :Status, "jets/cfn/status"
+  autoload :Upload, "jets/cfn/upload"
+end

data/lib/jets/cfn/builders.rb

@@ -0,0 +1,20 @@
+require 'yaml'
+
+class Jets::Cfn
+  class Builders
+    autoload :Interface, "jets/cfn/builders/interface"
+    autoload :ParentBuilder, "jets/cfn/builders/parent_builder"
+
+    # These build the app/controllers, app/jobs, and app/functions
+    autoload :BaseChildBuilder, "jets/cfn/builders/base_child_builder"
+    autoload :ControllerBuilder, "jets/cfn/builders/controller_builder"
+    autoload :FunctionBuilder, "jets/cfn/builders/function_builder"
+    autoload :JobBuilder, "jets/cfn/builders/job_builder"
+    autoload :RuleBuilder, "jets/cfn/builders/rule_builder"
+
+    autoload :ApiGatewayBuilder, "jets/cfn/builders/api_gateway_builder"
+    autoload :ApiDeploymentBuilder, "jets/cfn/builders/api_deployment_builder"
+
+    autoload :SharedBuilder, "jets/cfn/builders/shared_builder"
+  end
+end

data/lib/jets/cfn/builders/api_deployment_builder.rb

@@ -0,0 +1,58 @@
+class Jets::Cfn::Builders
+  class ApiDeploymentBuilder
+    include Interface
+    include Jets::AwsServices
+
+    def initialize(options={})
+      @options = options
+      @template = ActiveSupport::HashWithIndifferentAccess.new(Resources: {})
+    end
+
+    # compose is an interface method
+    def compose
+      return unless @options[:templates] || @options[:stack_type] != :minimal
+
+      deployment = Jets::Resource::ApiGateway::Deployment.new
+      add_resource(deployment)
+      add_parameters(deployment.parameters)
+      add_outputs(deployment.outputs)
+
+      add_base_path_mapping
+    end
+
+    # Because Jets generates a new timestamped logical id for the API Deployment
+    # resource it also creates a new root base path mapping and fails.  Additionally,
+    # the base path mapping depends on the API Deploy for the stage name.
+    #
+    # We resolve this by using a custom resource that does an in-place update.
+    #
+    # Note, also tried to change the domain name of to something like demo-dev-[random].mydomain.com
+    # but that does not work because the domain name has to match the route53 record exactly.
+    #
+    def add_base_path_mapping
+      return unless Jets.custom_domain?
+
+      function = Jets::Resource::ApiGateway::BasePath::Function.new
+      add_resource(function)
+      add_outputs(function.outputs)
+
+      mapping = Jets::Resource::ApiGateway::BasePath::Mapping.new
+      add_resource(mapping)
+      add_outputs(mapping.outputs)
+
+      iam_role = Jets::Resource::ApiGateway::BasePath::Role.new
+      add_resource(iam_role)
+      add_outputs(iam_role.outputs)
+    end
+
+    # template_path is an interface method
+    def template_path
+      Jets::Naming.api_deployment_template_path
+    end
+
+    # do not bother writing a template if routes are empty
+    def write
+      super unless Jets::Router.routes.empty?
+    end
+  end
+end