appfuel 0.2.0

data/lib/appfuel/msg_request.rb

@@ -0,0 +1,207 @@
+module Appfuel
+  # This represents the message delivered by RabbitMQ. We encapsulate it
+  # so that if you want to fire an action from the command line you can
+  # use a CliRequest and not worry about rabbit details
+  #
+  class MsgRequest
+    attr_reader :config, :service_route, :reply_to, :correlation_id,
+      :delivery_info, :properties, :feature, :action, :inputs, :current_user
+
+    #
+    # metadata properties
+    #   headers:        message headers, important for service_route
+    #   reply_to:       name of rpc response queue
+    #   correlation_id: id used in rpc to match response
+    #
+    # @param msg            String  serialized message from rabbitmq
+    # @param delivery_info  Hash    info used to acknowledge messages
+    # @param metadata       Object  properties of the messages
+    #
+    # @return MsgRequest
+    def initialize(msg, delivery_info, metadata)
+      @auditable         =  true
+      self.inputs        = msg
+      self.delivery_info = delivery_info
+      self.properties    = metadata
+    end
+
+    # Rpc requires a reply queue to respond to and a correlation_id to
+    # identify that response in the queue. When these two things exist
+    # then the request is consided to be an rpc
+    #
+    # @return [Boolean]
+    def rpc?
+      !reply_to.nil? && !correlation_id.nil?
+    end
+
+    # Flag used to determine if the request should be sent to the audit log.
+    # The default value is true and a header is used to opt out of this.
+    #
+    # @return [Boolean]
+    def auditable?
+      @auditable
+    end
+
+    # The current user is required for all audit logs and this flag is used
+    # to determine if it exists. When an audit is not required the current
+    # user is optional
+    #
+    # @return [Boolean]
+    def current_user?
+      !@current_user.nil?
+    end
+
+    private
+
+    # Ensures when a current_user_id is given it is valid. This is optional
+    # and the msg will not enforce its presence when auditable is true, that
+    # will be handled by objects implementing auditing.
+    #
+    # @param value [Integer, nil] the current user id
+    # @return [Integer, nil]
+    def current_user=(value)
+      return @current_user = nil if value.nil?
+
+      begin
+        @current_user = Integer(value)
+      rescue
+        raise 'current_user_id must be an Integer'
+      end
+    end
+
+    # All message inputs are sent encoded as json. We parse then json then
+    # symbolize the keys which allows any validation, action or command to
+    # expect a consistent hash
+    #
+    # @param data [String]
+    # @return [Hash]
+    def inputs=(data)
+      data = data.to_s
+      return @inputs = {} if data.empty?
+
+
+      begin
+        data = JSON.parse(data)
+        fail "message inputs must be a hash" unless data.is_a?(Hash)
+        @inputs = data.deep_symbolize_keys
+      rescue => e
+        msg = "message request could not parse the inputs: #{e.message}"
+        error = RuntimeError.new(msg)
+        error.set_backtrace(e.backtrace)
+        raise error
+      end
+    end
+
+    # Hash like structure that hold information about the delivery of the message
+    #   :consumer_tag   Each consumer (subscription) has an identifier called a
+    #                   consumer tag. It can be used to unsubscribe from
+    #                   messages. Consumer tags are just strings.
+    #
+    #   :delivery_tag   If set to 1, the delivery tag is treated as
+    #                   "up to and including", so that multiple messages can be
+    #                   acknowledged with a single method. If set to zero, the
+    #                   delivery tag refers to a single message. If the multiple
+    #                   field is 1, and the delivery tag is zero, this indicates
+    #                   acknowledgement of all outstanding messages.
+    #
+    #   :redelivered    true if this delivery is a redelivery ( the message was
+    #                   requeued at least once )
+    #
+    #   :routing_key    routing key used by exchange to route to queue
+    #
+    #   :exchange       name of exchange
+    #
+    #   :consumer       the consumer that subsribed
+    #
+    #   :channel        the channel the message was sent on
+    #
+    # @param data [Bunny::Delivery::Info]
+    # @return [Bunny::Delivery::Info]
+    def delivery_info=(data)
+      @deliver_info = data
+    end
+
+    # Hash like structure that holds attributes of the message as defined by
+    # the amqp protocol
+    #
+    #   :content_type       (Optional) content type of the message, as set by
+    #                       the publisher
+    #
+    #   :content_encoding   (Optional) content encoding of the message, as set
+    #                       by the publisher
+    #
+    #   :headers            message headers
+    #
+    #   :delivery_mode      [Integer] Delivery mode (persistent or transient)
+    #
+    #   :priority           [Integer] Message priority, as set by the publisher
+    #
+    #   :correlation_id     [String] What message this message is a reply to
+    #                       (or corresponds to), as set by the publisher
+    #
+    #   :reply_to           [String] (Optional) How to reply to the publisher
+    #                       (usually a reply queue name)
+    #
+    #   :expiration         [String] Message expiration, as set by the publisher
+    #
+    #   :message_id         [String] Message ID, as set by the publisher
+    #
+    #   :timestamp          [Time] Message timestamp, as set by the publisher
+    #
+    #   :user_id            [String] Publishing user, as set by the publisher
+    #                       not an application user
+    #
+    #   :app_id             [String] Publishing application, as set by the
+    #                       publisher
+    #
+    #   :cluster_id         [String] Cluster ID, as set by the publisher
+    #
+    # @param data [Bunny::MessageProperties]
+    # @return Bunny::MessageProperties
+    def properties=(data)
+      @reply_to        = data.reply_to
+      @correlation_id  = data.correlation_id
+
+      if data.headers['auditable'] == false
+        @auditable = false
+      end
+
+      self.service_route = data.headers['service_route']
+      self.current_user  = data.headers['current_user']
+      @properties = data
+    end
+
+    # The service route is a forward slash separated string consisting of two
+    # parts. The first part is the feature that holds the action and the
+    # second is the action itself.
+    #
+    # @example 'offers/create'
+    #   feature is Offers
+    #   action is Create
+    #
+    # This is used by the dispatcher to locate the action to be called
+    #
+    # @param route [String]
+    # @param [String]
+    def service_route=(route)
+      fail "service route missing from message headers" if route.nil?
+      fail "service route must be a String" unless route.is_a?(String)
+
+      feature, action= route.split('/', 2)
+
+      # NOTE: feature.strip! returns nil we are really after the empty?
+      if feature.nil? || (feature.strip! || feature.empty?)
+        fail "feature is missing route must be like <feature>/<action>"
+      end
+
+      if action.nil? || (action.strip! || action.empty?)
+        fail "action is missing route must be like <feature>/<action>"
+      end
+
+      @service_route = route
+      @feature = feature.camelize
+      @action  = action.camelize
+      route
+    end
+  end
+end

data/lib/appfuel/predicates.rb

@@ -0,0 +1,10 @@
+module Appfuel
+  module Predicates
+    include Dry::Logic::Predicates
+
+    predicate(:criteria?) do |value|
+      value.instance_of?(Appfuel::Domain::Criteria)
+    end
+
+  end
+end

data/lib/appfuel/presenter.rb

@@ -0,0 +1,18 @@
+require_relative 'presenter/base'
+module Appfuel
+  module Presenter
+    def self.present(name, opts = {}, &block)
+      key  = Appfuel.expand_container_key(name, 'presenters')
+      root = opts[:root] || Appfuel.default_app_name
+      app_container = Appfuel.app_container(root)
+
+      presenter = create_presenter(opts[:base_class] || Base, &block)
+      app_container.register(key, presenter)
+    end
+
+    def self.create_presenter(klass, &block)
+      presenter = klass.new
+      ->(data, criteria) { presenter.instance_exec(data, criteria, &block) }
+    end
+  end
+end

data/lib/appfuel/presenter/base.rb

@@ -0,0 +1,7 @@
+module Appfuel
+  module Presenter
+    class Base
+
+    end
+  end
+end

data/lib/appfuel/repository.rb

@@ -0,0 +1,73 @@
+require_relative 'repository/base'
+require_relative 'repository/mapping_entry'
+require_relative 'repository/mapping_dsl'
+require_relative 'repository/mapper'
+require_relative 'repository/mapping_registry'
+require_relative 'repository/initializer'
+
+module Appfuel
+  module Repository
+    # Mapping uses the map_dsl_class to define and map mapping entries
+    # into the mapping registry
+    #
+    # @example Simple mapping
+    #   mapping 'foo.bar', db: foo_table_one do
+    #     map 'id'
+    #     map 'project_user_id', 'user.id'
+    #   end
+    #
+    #   Note: When no :key value is given to options then the entity base
+    #         name is used. The following would be equivalent:
+    #
+    #   mapping 'offers.offer', db: foo_table_two do
+    #     ...
+    #   end
+    #
+    # @param entity_name [String] domain name of the entity we are mapping
+    # @param db_class [String] name of the database class used in mapping
+    # @return [DbEntityMapper]
+    def self.mapping(domain_name, options = {}, &block)
+      dsl = MappingDsl.new(domain_name, options)
+      dsl.instance_eval(&block)
+
+      dsl.entries.each do |entry|
+        root      = entry.container_name || Appfuel.default_app_name
+        container = Appfuel.app_container(root)
+        mappings  = container['repository_mappings']
+
+        domain_name = entry.domain_name
+        mappings[domain_name] = {} unless mappings.key?(domain_name)
+
+        entries = mappings[domain_name]
+        entries[entry.domain_attr] = entry
+      end
+    end
+
+    def self.entity_builder(domain_name, type, opts = {}, &block)
+      fail "entity builder must be used with a block" unless block_given?
+
+      root = opts[:root] || Appfuel.default_app_name
+      repo = create_repo(type, domain_name)
+      repo.class.load_path_from_container_namespace("#{root}.#{domain_name}")
+
+      app_container = Appfuel.app_container(root)
+      category      = "domain_builders.#{type}"
+      builder_key   = repo.qualify_container_key(domain_name, category)
+      app_container.register(builder_key, create_builder(repo, &block))
+    end
+
+    def self.create_repo(type, domain_name)
+      repo_class = "Appfuel::#{type.to_s.classify}::Repository"
+      unless Kernel.const_defined?(repo_class)
+        fail "Could not find #{repo_class} for entity builder #{domain_name}"
+      end
+      Kernel.const_get(repo_class).new
+    end
+
+    def self.create_builder(repo, &block)
+      ->(storage, criteria) {
+        repo.instance_exec(storage, criteria, &block)
+      }
+    end
+  end
+end

data/lib/appfuel/repository/base.rb

@@ -0,0 +1,72 @@
+module Appfuel
+  module Repository
+    class Base
+      include Appfuel::Application::AppContainer
+
+      class << self
+        attr_writer :mapper
+        def inherited(klass)
+          register_container_class(klass)
+        end
+
+        def mapper
+          @mapper ||= create_mapper
+        end
+
+        def create_mapper(maps = nil)
+          Mapper.new(maps)
+        end
+      end
+
+      def mapper
+        self.class.mapper
+      end
+
+      def to_storage(entity, exclude = [])
+        mapper.to_storage(entity, exclude)
+      end
+
+      def to_entity(domain_name, storage)
+        key  = qualify_container_key(domain_name, "domains")
+        hash = mapper.to_entity_hash(domain_name, storage)
+        app_container[key].new(hash)
+      end
+
+      def build(type:, name:, storage:, **inputs)
+        builder = find_entity_builder(type: type, domain_name: name)
+        builder.call(storage, inputs)
+      end
+
+      # features.membership.presenters.hash.user
+      # global.presenters.user
+      #
+      # key => db_model
+      # key => db_model
+      def find_entity_builder(domain_name:, type:)
+        key = qualify_container_key(domain_name, "domain_builders.#{type}")
+
+        container = app_container
+        unless container.key?(key)
+          return ->(data, inputs = {}) {
+            build_default_entity(domain_name: domain_name, storage: data)
+          }
+        end
+
+        container[key]
+      end
+
+      def build_default_entity(domain_name:, storage:)
+        storage = [storage] unless storage.is_a?(Array)
+
+        storage_attrs = {}
+        storage.each do |model|
+          storage_attrs.merge!(mapper.model_attributes(model))
+        end
+
+        hash = mapper.to_entity_hash(domain_name, storage_attrs)
+        key  = qualify_container_key(domain_name, "domains")
+        app_container[key].new(hash)
+      end
+    end
+  end
+end

data/lib/appfuel/repository/initializer.rb

@@ -0,0 +1,19 @@
+module Appfuel
+  module Repository
+    class Initializer
+      def call(container)
+        config    = container[:config]
+        root_path = container[:root_path]
+        path      = config[:repo_mapping_path]
+        unless path
+          path = "#{root_path}/storage/mappings"
+        end
+
+        unless ::File.exist?(path)
+          fail "Failed to load repo maps, file #{path} does not exist"
+        end
+        require path
+      end
+    end
+  end
+end

data/lib/appfuel/repository/mapper.rb

@@ -0,0 +1,203 @@
+module Appfuel
+  module Repository
+    # The mapping registry holds all entity to db mappings. Mappings are
+    # contained within a DbEntityMapEntry object and are arranged by
+    # entity name. Each entity will hold a hash where the keys are the
+    # attribute names and the value is the entry
+    class Mapper
+      attr_reader :container_root_name
+
+      def initialize(app_name, map = nil)
+        @container_root_name = app_name
+        if !map.nil? && !map.is_a?(Hash)
+          fail "repository mappings must be a hash"
+        end
+        @map = map
+      end
+
+      # The map represents domain mappings to one or more storage systems.
+      # Currently one map represents all storage. So if you have a file, and
+      # database storage for a given domain the storage attributes are the same
+      # for each interface. This will load the repository mappings from the
+      # application container if no map as been manually set.
+      #
+      # @example a map has the following structure
+      #   {
+      #     domain_name: {
+      #       domain_attr1: <MappingEntry>,
+      #       domain_attr1: <MappingEntry>
+      #     }
+      #     ...
+      #   }
+      # @return [Hash]
+      def map
+        @map ||= mappings_from_container
+      end
+
+      # Determine if an entity has been added
+      #
+      # @param entity [String]
+      # @return [Boolean]
+      def entity?(entity_name)
+        map.key?(entity_name)
+      end
+
+      # Determine if an attribute is mapped for a given entity
+      #
+      # @param entity [String] name of the entity
+      # @param attr [String] name of the attribute
+      # @return [Boolean]
+      def entity_attr?(entity_name, entity_attr)
+        return false unless entity?(entity_name)
+
+        map[entity_name].key?(entity_attr)
+      end
+
+      # Returns a mapping entry for a given entity
+      #
+      # @raise [RuntimeError] when entity not found
+      # @raise [RuntimeError] when attr not found
+      #
+      # @param entity_name [String] qualified entity name "<feature>.<entity>"
+      # @param entity_attr [String] name of the attribute
+      # @return [Boolean]
+      def find(entity_name, entity_attr)
+        validate_domain(entity_name)
+
+        unless map[entity_name].key?(entity_attr)
+          fail "Entity (#{entity_name}) attr (#{entity_attr}) is not registered"
+        end
+        map[entity_name][entity_attr]
+      end
+
+      # Iterates over all entries for a given entity
+      #
+      # @yield [attr, entry] expose the entity attr name and entry
+      #
+      # @param entity_name [String] qualified entity name "<feature>.<entity>"
+      # @return [void]
+      def each_entity_attr(entity_name)
+        validate_domain(entity_name)
+        map[entity_name].each do |_attr, entry|
+          yield entry
+        end
+      end
+
+      # Determine if an column is mapped for a given entity
+      #
+      # @param entity_name [String] qualified entity name "<feature>.<entity>"
+      # @param storage_attr [String] name the persistence attr
+      # @return [Boolean]
+      def storage_attr_mapped?(entity_name, storage_attr)
+        each_entity_attr(entity_name) do |entry|
+          return true if storage_attr == entry.storage_attr
+        end
+
+        false
+      end
+
+      # Returns a column name for an entity's attribute
+      #
+      # @raise [RuntimeError] when entity not found
+      # @raise [RuntimeError] when attr not found
+      #
+      # @param entity_name [String] qualified entity name "<feature>.<entity>"
+      # @param entity_attr [String] name of the attribute
+      # @return [String]
+      def storage_attr(entity_name, entity_attr)
+        find(entity_name, entity_attr).storage_attr
+      end
+
+      # Returns the storage class based on type
+      # mapping foo.bar, db: auth.foo_bar,
+      #
+      # @raise [RuntimeError] when entity not found
+      # @raise [RuntimeError] when attr not found
+      # @raise [Dry::Contriner::Error] when db_class is not registered
+      #
+      # @param entity [String] name of the entity
+      # @param attr [String] name of the attribute
+      # @return [Object]
+      def storage_class(domain_name, domain_attr, type)
+        entry = find(domain_name, attr)
+
+        unless entry.storage?(type)
+          fail "No (#{type}) storage has been mapped"
+        end
+
+        container_name = entry.container_name
+        unless container_root_name == container_name
+          fail "You can not access a mapping outside of this container " +
+            "(#{container_root_name}, #{container_name})"
+        end
+        app_container = Appfuel.app_container(entry.container)
+        key = entry.storage(type)
+        app_container[key]
+      end
+
+      def to_entity_hash(domain_name,  data, opts = {})
+        entity_attrs = {}
+        each_entity_attr(domain_name) do |entry|
+          attr_name   = entry.storage_attr
+          domain_attr = entry.domain_attr
+          next unless data.key?(attr_name)
+
+          update_entity_hash(domain_attr, data[attr_name], entity_attrs)
+        end
+
+        entity_attrs
+      end
+
+      def update_entity_hash(domain_attr, value, hash)
+        if domain_attr.include?('.')
+          hash.deep_merge!(create_entity_hash(domain_attr, value))
+        else
+          hash[domain_attr] = value
+        end
+      end
+
+      def entity_value(domain, map_entry)
+        value = resolve_entity_value(domain, map_entry.domain_attr)
+        if map_entry.computed_attr?
+          value = map_entry.compute_attr(domain, value)
+        end
+
+        value = nil if undefined?(value)
+
+        value
+      end
+
+      def create_entity_hash(domain_attr, value)
+        domain_attr.split('.').reverse.inject(value) do |result, nested_attr|
+          {nested_attr => result}
+        end
+      end
+
+      def undefined?(value)
+        value == Types::Undefined
+      end
+
+      def resolve_entity_value(domain, entity_attr)
+        chain  = entity_attr.split('.')
+        target = domain
+        chain.each do |attr_method|
+          return nil unless target.respond_to?(attr_method)
+          target = target.public_send(attr_method)
+        end
+        target
+      end
+
+      private
+      def validate_domain(entity_name)
+        unless entity?(entity_name)
+          fail "Entity (#{entity_name}) is not registered"
+        end
+      end
+
+      def mappings_from_container
+        container = Appfuel.app_container(container_root_name)
+        container[:repository_mappings]
+      end
+    end
+  end
+end