appfuel 0.2.0

data/lib/appfuel/handler/command.rb

@@ -0,0 +1,18 @@
+module Appfuel
+  module Handler
+    class Command < Base
+      class << self
+        def resolve_dependencies(results = Dry::Container.new)
+=begin
+          super
+          resolve_container(results)
+          resolve_domains(results)
+          resolve_db_models(results)
+          resolve_repos(results)
+          results
+=end
+        end
+      end
+    end
+  end
+end

data/lib/appfuel/handler/inject_dsl.rb

@@ -0,0 +1,88 @@
+module Appfuel
+  module Handler
+    # Allow handlers to inject domains, commands, repositories or anything
+    # that was initialized in the app container. Injections are done in two
+    # steps, first, when the class is loaded in memory the declarations are
+    # converted into fully qualified container keys and second, when the
+    # handler is run they plucked from the app container into a container
+    # dedicated to that one execution.
+    module InjectDsl
+      TYPES = [:domain, :cmd, :repo, :container]
+
+      # Holds a dictionary where the key is the container key and the value
+      # is an an optional alias for the name of the injection to be saved
+      # as. Injections a separated into two categories because domains are
+      # part of the type system (Dry::Types) and therefore kept in its own
+      # container "Types", meaning are fetched differently.
+      #
+      # @return [Hash]
+      def injections
+        @injections ||= {}
+      end
+
+      # Dsl to declare a dependency injection. You can inject one of four
+      # types, which are:
+      #   domain:     these are domains or value object
+      #   cmd:        commands to be run
+      #   repo:       repositories to query the persistence layer
+      #   container:  any initialized container item
+      #
+      # since names an collide you can rename your injection with the
+      # :as option.
+      #
+      # @example of using an alias to rename a domain injection
+      #   inject :domain, 'member.user', as: :current_user
+      #
+      # @example of normal domain injection. In this case the name of the
+      #          domain with me the base name "user" not "member.user"
+      #
+      #   inject :domain, 'member.user'
+      #
+      #
+      # @param type [Symbol] type of injection
+      # @param key [String, Symbol] container key
+      # @param opts [Hash]
+      # @option as [String, Symbol] alternate name for injection
+      # @return nil
+      def inject(type, key, opts = {})
+        unless inject_type?(type)
+          fail "inject type must be #{TYPES.join(",")} #{type} given"
+        end
+
+        cat = case type
+              when :repo   then 'repositories'
+              when :cmd    then 'commands'
+              when :domain then 'domains'
+              else
+                "container"
+              end
+
+        namespaced_key = qualify_container_key(key, cat)
+        injections[namespaced_key] = opts[:as]
+        nil
+      end
+
+      def resolve_dependencies(container = Dry::Container.new)
+        app_container = Appfuel.app_container
+        injections.each do |key, alias_name|
+          unless app_container.key?(key)
+            fail "Could not inject (#{key}): not registered in app container"
+          end
+
+          basename = key.split('.').last
+          item = app_container[key]
+          container_key = alias_name || basename
+          container.register(container_key, item)
+        end
+      end
+
+      private
+
+      # @param type [Symbol]
+      # @return [Bool]
+      def inject_type?(type)
+        TYPES.include?(type)
+      end
+    end
+  end
+end

data/lib/appfuel/handler/validator_dsl.rb

@@ -0,0 +1,256 @@
+module Appfuel
+  module Handler
+    #
+    #
+    # 1) single block validator. A basic validator that is only used by
+    #    that particular interactor
+    #
+    #
+    #     validator('foo', fail_fast: true) do
+    #
+    #     end
+    #
+    # 2) single validator from the features validators located in the app
+    #    container under the key "features.<feature-name>.validators.<validator-name>"
+    #
+    #    validator 'foo'
+    #
+    # 3) single validator from the global validators located in the app
+    #   container under the key "global.validators.<validator-name>"
+    #
+    #   validator 'global.foo'
+    #
+    # 4) muliple validators, all are located in the feature namespace
+    #   validators 'foo', 'bar', 'baz'
+    #
+    # 5) multiple validators, some in features other in global
+    #   validators 'foo', 'global.bar', 'baz'
+    #
+    # 6) a pipe is a closure that lives before a given validator in order
+    #    to manipulate the inputs to fit the next validator. it does not validate
+    #
+    #   validator_pipe do |inputs, data|
+    #
+    #   end
+    #
+    # 7) using a pipe when using muliple validators
+    #
+    #   validators 'foo', 'pipe.bar', 'base'
+    #
+    # 8) using global pipe in multiple validator declaration
+    #   validators 'foo', 'global-pipe.bar', 'base'
+    #
+    # 9) validator_schema is used to use Dry::Validations with out our block
+    #    processing
+    #
+    #    validation_schema 'foo', Dry::Validation.Schama do
+    #
+    #    end
+    #
+    #    validation_schema Dry::Validation.Schema do
+    #
+    #    end
+    #
+    #    validation_schema 'foo', fail_fast: true, Dry::Validation.Schema do
+    #
+    #    end
+    #
+    # validator
+    #   name: to identify it in errors and as a key to register it with container
+    #   fail_fast: when true runner will bail on first error
+    #   pipe?: false
+    #   code: validator schema to run
+    #   call: run the validator schema
+    #
+    # validator-pipe
+    #   name: to identify the pipe in errors and register it with container
+    #   code: lambda to run
+    #   call: run the lamda
+    module ValidatorDsl
+
+      def validators(*args)
+        @validators ||= []
+        return @validators if args.empty?
+
+        args.each do |arg|
+          @validators << load_validator(arg)
+        end
+      end
+
+      # When no name for a validator is given then the default name will
+      # be the name of the concrete handler class
+      #
+      # @return [String]
+      def default_validator_name
+        self.to_s.split('::').last.underscore
+      end
+
+      # Converts a given block to a validator or load the validator from
+      # either global or feature validators
+      #
+      # @param key [String] name of the validator
+      # @param opts [Hash] options for creating a validator
+      # @option fail_fast [Bool] allows that validator to fail immediately
+      # @return [Nil]
+      def validator(key = nil, opts = {}, &block)
+        key  = default_validator_name if key.nil?
+        validators << build_validator(key, opts, &block)
+        nil
+      end
+
+      # load a validator with the given key from the app container.
+      #
+      # @note the key is encode and will be decoded first
+      #       @see ValidatorDsl#convert_to_container_key for details
+      #
+      # @param key [String]
+      # @param opts [Hash]
+      # @return Appfuel::Validation::Validator
+      def load_validator(key, opts = {})
+        fail "validator must have a key" if key.nil?
+
+        container_key = convert_to_container_key(key)
+        container = Appfuel.app_container
+        unless container.key?(container_key)
+          fail "Could not locate validator with (#{container_key})"
+        end
+
+        container[container_key]
+      end
+
+      # return [Bool]
+      def validators?
+        !validators.empty?
+      end
+
+      # Used when resolving inputs to determine if we should apply any
+      # validation
+      #
+      # return [Bool]
+      def skip_validation?
+        @skip_validation == true
+      end
+
+      # Dsl method to allow a handler to tell the system not to validate
+      # anything and use the raw inputs
+      #
+      # return [Bool]
+      def skip_validation!
+        @skip_validation = true
+      end
+
+      # Validate all inputs using the list of validators that were assigned
+      # using the dsl methods.
+      #
+      # @param inputs [Hash]
+      # @return Appfuel::Response
+      def resolve_inputs(inputs = {})
+        return ok(inputs) if skip_validation?
+        return ok({}) unless validators?
+
+        response = nil
+        has_failed = false
+        validators.each do |validator|
+          if validator.pipe?
+            result = handle_validator_pipe(validator, inputs)
+            inputs = result unless result == false
+            next
+          end
+
+          result = validator.call(inputs)
+          if result.success? && !has_failed
+            response = handle_successful_inputs(result, response)
+            next
+          end
+
+          return error(result.errors(full: true)) if validator.fail_fast?
+          has_failed = true
+          response = handle_error_inputs(result, response)
+        end
+
+        fail "multi validators can not be only Procs" if response.nil?
+
+        response
+      end
+
+      private
+
+      # Decodes the given key into a dependency injection namespace that is
+      # used to find a validator or pipe in the app container. It decodes
+      # to a global or feature namespaces.
+      #
+      # @param key [String]
+      # #return [String]
+      def convert_to_container_key(key)
+        parts = key.to_s.split('.')
+        last  = parts.last
+        first = parts.first
+        case first
+          when 'global'
+            "global.validators.#{last}"
+          when 'global-pipe'
+            "global.validator-pipes.#{last}"
+          when 'pipe'
+            "#{container_feature_key}.validator-pipes.#{last}"
+          else
+            "#{container_feature_key}.validators.#{first}"
+        end
+      end
+
+      # Create a validator for the handler or load it from the container
+      # depending on if a block is given
+      #
+      # @param key [String] key used to identify the item
+      # @param opts [Hash]
+      # @return [
+      #   Appfuel::Validation::Validator,
+      #   Appfuel::Validation::ValidatorPipe
+      #   ]
+      def build_validator(key, opts = {}, &block)
+        return load_validator(key, opts)  unless block_given?
+
+        Appfuel::Validation.build_validator(key, opts, &block)
+      end
+
+      # Creates a response the first time otherwise it merges the results
+      # from the last validator into the response
+      #
+      # @param results [Hash] successful valid inputs
+      # @param response [Appfuel::Response]
+      def handle_successful_inputs(result, response)
+        if response.nil?
+          ok(result.output)
+        else
+          ok(response.ok.merge(result.output))
+        end
+      end
+
+      # Creates a response the first time otherwise it merges the error
+      # results from the last validator into the response
+      #
+      # @param results [Hash] successful valid inputs
+      # @param response [Appfuel::Response]
+      def handle_error_inputs(result, response)
+        if response.nil?
+          error(result.errors(full: true))
+        else
+          error(result.errors(full: true).merge(response.error_messages))
+        end
+      end
+
+      # Delegates call to the validator pipe
+      #
+      # @param pipe [Appfuel::Validation::ValidatorPipe]
+      # @param inputs [Hash]
+      # @return [Hash]
+      def handle_validator_pipe(pipe, inputs)
+        result = pipe.call(inputs, Dry::Container.new)
+        return false unless result
+        unless result.is_a?(Hash)
+          fail "multi validator proc must return a Hash"
+        end
+        result
+      end
+    end
+  end
+end

data/lib/appfuel/initialize.rb

@@ -0,0 +1,70 @@
+require_relative 'initialize/initializer'
+
+module Appfuel
+  module Initialize
+    class << self
+
+      # Dsl used to add an initializer into to the application container. This
+      # will add an initializer into the default app unless another name is
+      # given.
+      #
+      # @param name [String] name of the initializer
+      # @param envs [String, Symbol, Array] A env,list of envs this can run in
+      # @param app_name [String] name of app for this initializer
+      def define(namespace_key, name, envs = [], app_name = nil, &block)
+        initializers = Appfuel.resolve("#{namespace_key}.initializers", app_name)
+        initializers << Initializer.new(name, envs, &block)
+      end
+
+      # Populate configuration definition that is in the container and
+      # add its results to the container. It also adds the environment from
+      # the config to the container for easier access.
+      #
+      # @raises RuntimeError when :env is not in the config
+      #
+      #
+      # @param container [Dry::Container]
+      # @param params [Hash]
+      # @option overrides [Hash] used to override config values
+      # @option env [ENV] used to collect environment variables
+      # @return [Dry::Container] that was passed in
+      def handle_configuration(container, params = {})
+        overrides    = params[:overrides]  || {}
+        env          = params[:env]        || ENV
+        definition   = container['config_definition']
+
+        config = definition.populate(env: env, overrides: overrides)
+        env = config.fetch(:env) { fail "key (:env) is missing from config" }
+
+        container.register(:config, config)
+        container.register(:env, env)
+
+        container
+      end
+
+      def handle_repository_mapping(container, params = {})
+        initializer = container[:repository_initializer]
+        initializer.call(container)
+      end
+
+      # This will initialize the app by handling configuration and running
+      # all the initilizers, which will result in an app container that has
+      # registered the config, env, and anything else the initializers
+      # decide to add.
+      #
+      # @param params [Hash]
+      # @option app_name [String] name of the app to initialize, (optional)
+      # @return [Dry::Container]
+      def run(params = {})
+        app_name  = params.fetch(:app_name) { Appfuel.default_app_name }
+        container = Appfuel.app_container(app_name)
+        handle_configuration(container, params)
+        handle_repository_mapping(container, params)
+
+        Appfuel.run_initializers('global', container, params[:exclude] || [])
+
+        container
+      end
+    end
+  end
+end

data/lib/appfuel/initialize/initializer.rb

@@ -0,0 +1,68 @@
+module Appfuel
+  module Initialize
+    # The client application will declare a series of initializer blocks.
+    # Each of these blocks are represented as this class. This allows us
+    # to save the block to be later executed along with info about which
+    # environments this can run on
+    class Initializer
+      attr_reader :name, :envs, :code
+
+      # Ensure each environment is stored as a lowercased string, convert
+      # the name to a string as save the block to be executed later
+      #
+      # @raises ArgumentError, when env is not an Array
+      # @raises ArgumentError, when block is not given
+      #
+      # @param name [String, Symbol] name to identify this initializer
+      # @param env [String, Symbol, Array] env or list of envs to execute on
+      # @param blk [Proc] the code to be excuted
+      # @return [Initializer]
+      def initialize(name, env = [], &block)
+        @name = name.to_s
+        @envs = []
+
+        env = [env] if env.is_a?(String) || env.is_a?(Symbol)
+        env = []    if env.nil?
+
+        unless env.is_a?(Array)
+          fail ArgumentError, "environments must be a string, symbol or array"
+        end
+        env.each {|item| add_env(item) }
+
+        fail ArgumentError, "initializer requires a block" unless block_given?
+        @code = block
+      end
+
+      # Determines which env this is allowed to execute on. No enironment means
+      # it it is allow to execute on all
+      #
+      # @param env [String, Symbol]
+      # @return [Bool]
+      def env_allowed?(env)
+        return true if envs.empty?
+
+        envs.include?(env.to_s.downcase)
+      end
+
+      # @raises RuntimeError, when env already exists
+      #
+      # @param name [String, Symbol] name of the environment
+      # @return [Array]
+      def add_env(name)
+        name = name.to_s.downcase
+        fail "env already exists" if envs.include?(name)
+        envs << name.to_s.downcase
+      end
+
+      # Delegate to executing the stored code
+      #
+      # @param config [Hash]
+      # @param app_container [Dry::Container]
+      # @return nil
+      def call(config, container)
+        code.call(config, container)
+        nil
+      end
+    end
+  end
+end