jets 5.0.14 → 6.0.0.beta1

data/lib/jets/lambda/dsl.rb

@@ -11,411 +11,411 @@ module Jets::Lambda::Dsl
     self.class.lambda_functions
   end
 
-  included do
-    class << self
-      extend Memoist
-      include Warnings
-
-      def class_properties(options=nil)
-        if options
-          @class_properties ||= {}
-          @class_properties.deep_merge!(options)
-        else
-          @class_properties || {}
+  module ClassMethods
+    extend Memoist
+
+    def class_properties(options = nil)
+      if options
+        @class_properties ||= {}
+        @class_properties.deep_merge!(options)
+      else
+        @class_properties || {}
+      end
+    end
+    alias_method :class_props, :class_properties
+
+    def properties(options = {})
+      @properties ||= {}
+      @properties.deep_merge!(options)
+    end
+    alias_method :props, :properties
+
+    def class_environment(hash)
+      environment = standardize_env(hash)
+      class_properties(Environment: environment)
+    end
+    alias_method :class_env, :class_environment
+
+    def environment(hash)
+      environment = standardize_env(hash)
+      properties(Environment: environment)
+    end
+    alias_method :env, :environment
+
+    # Allows user to pass in hash with or without the :variables key.
+    def standardize_env(hash)
+      return hash if hash.key?(:Variables)
+
+      environment = {}
+      environment[:Variables] ||= {}
+      environment[:Variables].merge!(hash)
+      environment
+    end
+
+    # Convenience method that set properties. List based on https://amzn.to/2oSph1P
+    # Not all properites are included because some properties are not meant to be set
+    # directly. For example, function_name is a calculated setting by Jets.
+    PROPERTIES = %W[
+      dead_letter_config
+      description
+      ephemeral_storage
+      handler
+      kms_key_arn
+      logging_config
+      memory_size
+      reserved_concurrent_executions
+      role
+      runtime
+      tags
+      timeout
+      tracing_config
+      vpc_config
+    ]
+    PROPERTIES.each do |property|
+      # Example:
+      #   def timeout(value)
+      #     properties(timeout: value)
+      #   end
+      #
+      #   def class_timeout(value)
+      #     class_properties(timeout: value)
+      #   end
+      class_eval <<~CODE, __FILE__, __LINE__ + 1
+        def #{property}(value)
+          properties(#{property}: value)
         end
-      end
-      alias_method :class_props, :class_properties
-
-      def properties(options={})
-        @properties ||= {}
-        @properties.deep_merge!(options)
-      end
-      alias_method :props, :properties
-
-      def class_environment(hash)
-        environment = standardize_env(hash)
-        class_properties(Environment: environment)
-      end
-      alias_method :class_env, :class_environment
 
-      def environment(hash)
-        environment = standardize_env(hash)
-        properties(Environment: environment)
-      end
-      alias_method :env, :environment
-
-      # Allows user to pass in hash with or without the :variables key.
-      def standardize_env(hash)
-        return hash if hash.key?(:Variables)
-
-        environment = {}
-        environment[:Variables] ||= {}
-        environment[:Variables].merge!(hash)
-        environment
-      end
-
-      # Convenience method that set properties. List based on https://amzn.to/2oSph1P
-      # Not all properites are included because some properties are not meant to be set
-      # directly. For example, function_name is a calculated setting by Jets.
-      PROPERTIES = %W[
-        dead_letter_config
-        description
-        ephemeral_storage
-        handler
-        kms_key_arn
-        memory_size
-        reserved_concurrent_executions
-        role
-        runtime
-        timeout
-        tracing_config
-        vpc_config
-        tags
-      ]
-      PROPERTIES.each do |property|
+        def class_#{property}(value)
+          class_properties(#{property}: value)
+        end
+      CODE
+    end
+
+    # Expose the PROPERTIES list so we can access it
+    def properties_list
+      PROPERTIES
+    end
+
+    # More convenience aliases
+    alias_method :memory, :memory_size
+    alias_method :class_memory, :class_memory_size
+    alias_method :desc, :description
+    alias_method :class_desc, :class_description
+    alias_method :reserved_concurrency, :reserved_concurrent_executions
+    alias_method :class_reserved_concurrency, :class_reserved_concurrent_executions
+
+    attr_writer :provisioned_concurrency
+
+    # definitions: one or more definitions
+    def iam_policy(*definitions)
+      if definitions.empty?
+        @iam_policy
+      else
+        @iam_policy ||= []
+        @iam_policy += definitions.flatten
+      end
+    end
+
+    # definitions: one or more definitions
+    def class_iam_policy(*definitions)
+      if definitions.empty?
+        @class_iam_policy
+      else
+        @class_iam_policy ||= []
+        @class_iam_policy += definitions.flatten
+      end
+    end
+
+    # definitions: one or more definitions
+    def managed_iam_policy(*definitions)
+      if definitions.empty?
+        @managed_iam_policy
+      else
+        @managed_iam_policy ||= []
+        @managed_iam_policy += definitions.flatten
+      end
+    end
+
+    # definitions: one or more definitions
+    def class_managed_iam_policy(*definitions)
+      if definitions.empty?
+        @class_managed_iam_policy
+      else
+        @class_managed_iam_policy ||= []
+        @class_managed_iam_policy += definitions.flatten
+      end
+    end
+
+    def build_class_iam?
+      !!(class_iam_policy || class_managed_iam_policy)
+    end
+
+    #############################
+    # Main method that registers resources associated with the Lambda function.
+    # All resources methods lead here.
+    def associated_resources(*definitions)
+      if definitions == [nil] # when associated_resources called with no arguments
+        @associated_resources || []
+      else
+        @associated_resources ||= []
+        associated_resource = Jets::Cfn::Resource::Associated.new(definitions)
+        associated_resource.multiple_resources = @multiple_resources
+        @associated_resources << associated_resource
+        @associated_resources.flatten!
+      end
+    end
+    alias_method :associated_resource, :associated_resources
+    # Allow user to use `resource` instead of `associated_resource` for a more natural feel
+    # User-friendly short resource method. Users will use this.
+    alias_method :resource, :associated_resources
+
+    # Using this odd way of setting these properties so we can keep the
+    # resource(*definitions) signature simple. Using keyword arguments at the end
+    # interfere with being able to pass in any keys for the properties hash at the end.
+    #
+    # TODO: If there's a cleaner way of doing this, let me know.
+    def with_fresh_properties(fresh_properties: true, multiple_resources: true)
+      @associated_properties = nil if fresh_properties # dont use any current associated_properties
+      @multiple_resources = multiple_resources
+
+      yield
+
+      @multiple_resources = false
+      @associated_properties = nil if fresh_properties # reset for next definition, since we're defining eagerly
+    end
+
+    # Properties belonging to the associated resource
+    def associated_properties(options = {})
+      @associated_properties ||= {}
+      @associated_properties.deep_merge!(options)
+    end
+    alias_method :associated_props, :associated_properties
+
+    # meta definition
+    def self.define_associated_properties(associated_properties)
+      associated_properties.each do |property|
         # Example:
-        #   def timeout(value)
-        #     properties(timeout: value)
-        #   end
-        #
-        #   def class_timeout(value)
-        #     class_properties(timeout: value)
+        #   def config_rule_name(value)
+        #     associated_properties(config_rule_name: value)
         #   end
-        class_eval <<~CODE
+        class_eval <<~CODE, __FILE__, __LINE__ + 1
           def #{property}(value)
-            properties(#{property}: value)
-          end
-
-          def class_#{property}(value)
-            class_properties(#{property}: value)
+            associated_properties(#{property}: value)
           end
         CODE
       end
-      # More convenience aliases
-      alias_method :memory, :memory_size
-      alias_method :class_memory, :class_memory_size
-      alias_method :desc, :description
-      alias_method :class_desc, :class_description
-
-      # definitions: one or more definitions
-      def iam_policy(*definitions)
-        if definitions.empty?
-          @iam_policy
-        else
-          iam_policy_unused_warning(managed=false)
-          @iam_policy ||= []
-          @iam_policy += definitions.flatten
-        end
-      end
-
-      # definitions: one or more definitions
-      def class_iam_policy(*definitions)
-        if definitions.empty?
-          @class_iam_policy
-        else
-          class_iam_policy_unused_warning(managed=false)
-          @class_iam_policy ||= []
-          @class_iam_policy += definitions.flatten
-        end
-      end
-
-      # definitions: one or more definitions
-      def managed_iam_policy(*definitions)
-        if definitions.empty?
-          @managed_iam_policy
-        else
-          iam_policy_unused_warning(managed=true)
-          @managed_iam_policy ||= []
-          @managed_iam_policy += definitions.flatten
-        end
-      end
-
-      # definitions: one or more definitions
-      def class_managed_iam_policy(*definitions)
-        if definitions.empty?
-          @class_managed_iam_policy
-        else
-          class_iam_policy_unused_warning(managed=true)
-          @class_managed_iam_policy ||= []
-          @class_managed_iam_policy += definitions.flatten
-        end
-      end
-
-      def build_class_iam?
-        !!(class_iam_policy || class_managed_iam_policy)
-      end
-
-      #############################
-      # Main method that registers resources associated with the Lambda function.
-      # All resources methods lead here.
-      def associated_resources(*definitions)
-        if definitions == [nil] # when associated_resources called with no arguments
-          @associated_resources || []
-        else
-          @associated_resources ||= []
-          associated_resource = Jets::Cfn::Resource::Associated.new(definitions)
-          associated_resource.multiple_resources = @multiple_resources
-          @associated_resources << associated_resource
-          @associated_resources.flatten!
-        end
-      end
-      # User-friendly short resource method. Users will use this.
-      alias_method :resource, :associated_resources
-
-      # Using this odd way of setting these properties so we can keep the
-      # resource(*definitions) signature simple. Using keyword arguments at the end
-      # interfere with being able to pass in any keys for the properties hash at the end.
+    end
+
+    def add_logical_id_counter?
+      return false unless @associated_resources
+      # Only takes one associated resource with multiple set to true to return false of this check
+      return false if @associated_resources.detect { |associated| associated.multiple_resources }
+      # Otherwise check if there is more than 1 @associated_resources
+      @associated_resources.size > 1
+    end
+
+    # Loop back through the resources and add a counter to the end of the id
+    # to handle multiple events.
+    # Then replace @associated_resources entirely
+    def add_logical_id_counter
+      numbered_resources = []
+      n = 1
+      @associated_resources.map do |associated|
+        logical_id = associated.logical_id
+        attributes = associated.attributes
+
+        logical_id = logical_id.to_s.sub(/\d+$/, "")
+        new_definition = {"#{logical_id}#{n}" => attributes}
+        numbered_resources << Jets::Cfn::Resource::Associated.new(new_definition)
+        n += 1
+      end
+      @associated_resources = numbered_resources
+    end
+
+    # Examples:
+    #
+    #   depends_on :custom
+    #   depends_on :custom, :alert
+    #   depends_on :custom, class_prefix: true
+    #   depends_on :custom, :alert, class_prefix: true
+    #
+    # interface method
+    def depends_on(*stacks)
+    end
+
+    def ref(name)
+      "!Ref #{name.to_s.camelize}"
+    end
+
+    def sub(value)
+      "!Sub #{value.to_s.camelize}"
+    end
+
+    # meth is a Symbol
+    def method_added(meth)
+      return if %w[initialize method_missing].include?(meth.to_s)
+      return unless public_method_defined?(meth)
+
+      register_definition(meth)
+    end
+
+    def register_definition(meth, lang = :ruby)
+      # Note: for anonymous classes like for app/functions self.name is ""
+      # We adjust the class name when we build the functions later in
+      # FunctionContstructor#adjust_definitions.
+
+      # At this point we can use the current associated_properties and defined the
+      # associated resource with the Lambda function.
+      unless associated_properties.empty?
+        associated_resources(default_associated_resource_definition(meth))
+      end
+
+      # Unsure why but we have to use @associated_resources vs associated_resources
+      # associated_resources is always nil
+      if add_logical_id_counter?
+        add_logical_id_counter
+      end
+
+      all_definitions[meth] = Jets::Lambda::Definition.new(name, meth,
+        properties: @properties, # lambda function properties
+        provisioned_concurrency: @provisioned_concurrency,
+        iam_policy: @iam_policy,
+        managed_iam_policy: @managed_iam_policy,
+        associated_resources: @associated_resources,
+        lang: lang,
+        replacements: replacements(meth))
+
+      # Done storing options, clear out for the next added method.
+      clear_properties
+      # Important to clear @properties at the end of registering outside of
+      # register_definition because register_definition is overridden in Jets::Event::Dsl
       #
-      # TODO: If there's a cleaner way of doing this, let me know.
-      def with_fresh_properties(fresh_properties: true, multiple_resources: true)
-        @associated_properties = nil if fresh_properties # dont use any current associated_properties
-        @multiple_resources = multiple_resources
-
-        yield
-
-        @multiple_resources = false
-        @associated_properties = nil if fresh_properties # reset for next definition, since we're defining eagerly
-      end
-
-      # Properties belonging to the associated resource
-      def associated_properties(options={})
-        @associated_properties ||= {}
-        @associated_properties.deep_merge!(options)
-      end
-      alias_method :associated_props, :associated_properties
-
-      # meta definition
-      def self.define_associated_properties(associated_properties)
-        associated_properties.each do |property|
-          # Example:
-          #   def config_rule_name(value)
-          #     associated_properties(config_rule_name: value)
-          #   end
-          class_eval <<~CODE
-            def #{property}(value)
-              associated_properties(#{property}: value)
-            end
-          CODE
-        end
-      end
-
-      def add_logical_id_counter?
-        return false unless @associated_resources
-        # Only takes one associated resource with multiple set to true to return false of this check
-        return false if @associated_resources.detect { |associated| associated.multiple_resources }
-        # Otherwise check if there is more than 1 @associated_resources
-        @associated_resources.size > 1
-      end
-
-      # Loop back through the resources and add a counter to the end of the id
-      # to handle multiple events.
-      # Then replace @associated_resources entirely
-      def add_logical_id_counter
-        numbered_resources = []
-        n = 1
-        @associated_resources.map do |associated|
-          logical_id = associated.logical_id
-          attributes = associated.attributes
-
-          logical_id = logical_id.to_s.sub(/\d+$/,'')
-          new_definition = { "#{logical_id}#{n}" => attributes }
-          numbered_resources << Jets::Cfn::Resource::Associated.new(new_definition)
-          n += 1
-        end
-        @associated_resources = numbered_resources
-      end
-
-      # Examples:
+      #   Jets::Event::Base < Jets::Lambda::Functions
       #
-      #   depends_on :custom
-      #   depends_on :custom, :alert
-      #   depends_on :custom, class_prefix: true
-      #   depends_on :custom, :alert, class_prefix: true
-      #
-      def depends_on(*stacks)
-        if stacks == []
-          @depends_on
+      # Both Jets::Event::Base and Jets::Lambda::Functions have Dsl modules included.
+      # So the Jets::Event::Dsl overrides some of the Jets::Lambda::Dsl behavior.
+
+      true
+    end
+
+    # Meant to be overridden to add more custom replacements based on the app class type
+    def replacements(meth)
+      {}
+    end
+
+    def clear_properties
+      @properties = nil
+      @provisioned_concurrency = nil
+      @iam_policy = nil
+      @managed_iam_policy = nil
+      @associated_resources = nil
+      @associated_properties = nil
+    end
+
+    # Returns the all definitions for this class with their method names as keys.
+    #
+    # ==== Returns
+    # OrderedHash:: An ordered hash with definitions names as keys and definition
+    #               objects as values.
+    #
+    def all_definitions
+      @all_definitions ||= ActiveSupport::OrderedHash.new
+    end
+    # Do not call all definitions outside this class, instead use: definitions or lambda functions
+    private :all_definitions
+
+    # Goes up the class inheritance chain to build the definitions.
+    #
+    # Example heirarchy:
+    #
+    #   Jets::Lambda::Functions > Jets::Controller::Base > ApplicationController ...
+    #     > PostsController > ChildPostsController
+    #
+    # Do not include definitions from the direct subclasses of Jets::Lambda::Functions
+    # because those classes are abstract.  Dont want those methods to be included.
+    def find_all_definitions(options = {})
+      public = options[:public].nil? ? true : options[:public]
+      klass = self
+      direct_subclasses = Jets::Lambda::Functions.subclasses
+      lookup = []
+
+      # Go up class inheritance and builds lookup structure in memory
+      until direct_subclasses.include?(klass)
+        lookup << klass.send(:all_definitions) # one place we want to call private all_definitions method
+        klass = klass.superclass
+      end
+      merged_definitions = ActiveSupport::OrderedHash.new
+      # Go back down the class inheritance chain in reverse order and merge the definitions
+      lookup.reverse_each do |definitions_hash|
+        # definitions_hash is a result of all_definitions. Example: PostsController.all_definitions
+        merged_definitions.merge!(definitions_hash)
+      end
+
+      # The cfn builders required the right final child class to build the lambda functions correctly.
+      merged_definitions.each do |meth, definition|
+        # Override the class name for the cfn builders
+        definition = definition.clone # do not stomp over current definitions since things are usually looked by reference
+        definition.instance_variable_set(:@class_name, name)
+        merged_definitions[meth] = definition
+      end
+
+      # Methods can be made private with the :private keyword after the method has been defined.
+      # To account for this, loop back thorugh all the methods and check if the method is indeed public.
+      definitions = ActiveSupport::OrderedHash.new
+      merged_definitions.each do |meth, definition|
+        if public
+          definitions[meth] = definition if definition.public_meth?
         else
-          @depends_on ||= []
-          options = stacks.last.is_a?(Hash) ? stacks.pop : {}
-          stacks.each do |stack|
-            @depends_on << Jets::Stack::Depends::Item.new(stack, options)
-          end
+          definitions[meth] = definition unless definition.public_meth?
         end
       end
-
-      def ref(name)
-        "!Ref #{name.to_s.camelize}"
-      end
-
-      def sub(value)
-        "!Sub #{value.to_s.camelize}"
-      end
-
-      # meth is a Symbol
-      def method_added(meth)
-        return if %w[initialize method_missing].include?(meth.to_s)
-        return unless public_method_defined?(meth)
-
-        register_definition(meth)
-      end
-
-      def register_definition(meth, lang=:ruby)
-        # Note: for anonymous classes like for app/functions self.name is ""
-        # We adjust the class name when we build the functions later in
-        # FunctionContstructor#adjust_definitions.
-
-        # At this point we can use the current associated_properties and defined the
-        # associated resource with the Lambda function.
-        unless associated_properties.empty?
-          associated_resources(default_associated_resource_definition(meth))
-        end
-
-        # Unsure why but we have to use @associated_resources vs associated_resources
-        # associated_resources is always nil
-        if add_logical_id_counter?
-          add_logical_id_counter
-        end
-
-        all_definitions[meth] = Jets::Lambda::Definition.new(self.name, meth,
-          properties: @properties, # lambda function properties
-          iam_policy: @iam_policy,
-          managed_iam_policy: @managed_iam_policy,
-          associated_resources: @associated_resources,
-          lang: lang,
-          replacements: replacements(meth))
-
-        # Done storing options, clear out for the next added method.
-        clear_properties
-        # Important to clear @properties at the end of registering outside of
-        # register_definition because register_definition is overridden in Jets::Job::Dsl
-        #
-        #   Jets::Job::Base < Jets::Lambda::Functions
-        #
-        # Both Jets::Job::Base and Jets::Lambda::Functions have Dsl modules included.
-        # So the Jets::Job::Dsl overrides some of the Jets::Lambda::Dsl behavior.
-
-        true
-      end
-
-      # Meant to be overridden to add more custom replacements based on the app class type
-      def replacements(meth)
-        {}
-      end
-
-      def clear_properties
-        @properties = nil
-        @iam_policy = nil
-        @managed_iam_policy = nil
-        @associated_resources = nil
-        @associated_properties = nil
-      end
-
-      # Returns the all definitions for this class with their method names as keys.
-      #
-      # ==== Returns
-      # OrderedHash:: An ordered hash with definitions names as keys and definition
-      #               objects as values.
-      #
-      def all_definitions
-        @all_definitions ||= ActiveSupport::OrderedHash.new
-      end
-      # Do not call all definitions outside this class, instead use: definitions or lambda functions
-      private :all_definitions
-
-      # Goes up the class inheritance chain to build the definitions.
-      #
-      # Example heirarchy:
-      #
-      #   Jets::Lambda::Functions > Jets::Controller::Base > ApplicationController ...
-      #     > PostsController > ChildPostsController
-      #
-      # Do not include definitions from the direct subclasses of Jets::Lambda::Functions
-      # because those classes are abstract.  Dont want those methods to be included.
-      def find_all_definitions(options={})
-        public = options[:public].nil? ? true : options[:public]
-        klass = self
-        direct_subclasses = Jets::Lambda::Functions.subclasses
-        lookup = []
-
-        # Go up class inheritance and builds lookup structure in memory
-        until direct_subclasses.include?(klass)
-          lookup << klass.send(:all_definitions) # one place we want to call private all_definitions method
-          klass = klass.superclass
-        end
-        merged_definitions = ActiveSupport::OrderedHash.new
-        # Go back down the class inheritance chain in reverse order and merge the definitions
-        lookup.reverse.each do |definitions_hash|
-          # definitions_hash is a result of all_definitions. Example: PostsController.all_definitions
-          merged_definitions.merge!(definitions_hash)
-        end
-
-        # The cfn builders required the right final child class to build the lambda functions correctly.
-        merged_definitions.each do |meth, definition|
-          # Override the class name for the cfn builders
-          definition = definition.clone # do not stomp over current definitions since things are usually looked by reference
-          definition.instance_variable_set(:@class_name, self.name)
-          merged_definitions[meth] = definition
-        end
-
-        # Methods can be made private with the :private keyword after the method has been defined.
-        # To account for this, loop back thorugh all the methods and check if the method is indeed public.
-        definitions = ActiveSupport::OrderedHash.new
-        merged_definitions.each do |meth, definition|
-          if public
-            definitions[meth] = definition if definition.public_meth?
-          else
-            definitions[meth] = definition unless definition.public_meth?
-          end
-        end
-        definitions
-      end
-      memoize :find_all_definitions
-
-      def all_public_definitions
-        find_all_definitions(public: true)
-      end
-
-      def all_private_definitions
-        find_all_definitions(public: false)
-      end
-
-      # Returns the definitions for this class in Array form.
-      #
-      # ==== Returns
-      # Array of definition objects
-      #
-      def definitions
-        all_public_definitions.values
-      end
-
-      # The public methods defined in the project app class ulimately become
-      # lambda functions.
-      #
-      # Example return value:
-      #   [:index, :new, :create, :show]
-      def lambda_functions
-        all_public_definitions.keys
-      end
-
-      # Used in Jets::Cfn::Builder::Interface#build
-      # Overridden in rule/dsl.rb
-      def build?
-        !definitions.empty?
-      end
-
-      # Polymorphic support
-      def defpoly(lang, meth)
-        register_definition(meth, lang)
-      end
-
-      def python(meth)
-        defpoly(:python, meth)
-      end
-
-      def node(meth)
-        defpoly(:node, meth)
-      end
-    end # end of class << self
-  end # end of included
+      definitions
+    end
+    memoize :find_all_definitions
+
+    def all_public_definitions
+      find_all_definitions(public: true)
+    end
+
+    def all_private_definitions
+      find_all_definitions(public: false)
+    end
+
+    # Returns the definitions for this class in Array form.
+    #
+    # ==== Returns
+    # Array of definition objects
+    #
+    def definitions
+      all_public_definitions.values
+    end
+
+    # The public methods defined in the project app class ulimately become
+    # lambda functions.
+    #
+    # Example return value:
+    #   [:index, :new, :create, :show]
+    def lambda_functions
+      all_public_definitions.keys
+    end
+
+    # Used in Jets::Cfn::Builder::Interface#build
+    # Overridden in rule/dsl.rb
+    def build?
+      !definitions.empty?
+    end
+
+    # Polymorphic support
+    def defpoly(lang, meth)
+      register_definition(meth, lang)
+    end
+
+    def python(meth)
+      defpoly(:python, meth)
+    end
+
+    def node(meth)
+      defpoly(:node, meth)
+    end
+  end
 end