appfuel 0.4.5 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d3a177c11d50f541f3190be60b12e703604d1154
-  data.tar.gz: aec5544881946e4293a347721cb3275bffa27109
+  metadata.gz: 2ebc666db81c563d31cb86e1d1783187e090c9a0
+  data.tar.gz: 50554a3c3ddbef08ea7c453f9ab20850c8569dcd
 SHA512:
-  metadata.gz: e229df4c4375776527a8091f8b7e493d741cd103fd2c2b2d8406e0d78db954f3b2e767428adc7d4b0f5041dcdf2541bef4922169b8ad6e01f001bfe50d533d3c
-  data.tar.gz: ea420d94728c15cf578bcd8f20535c21354662550c6ad761fa0b3e4920447e212b05dfdf4ca5f9ea01ecc094b45fad523d215e471f3e72553bde4db38813b94f
+  metadata.gz: e5b5a659ce0a686e2b495d1c6f6326a991b787f62619640c9bbecd06dd9e194f4508b247cff7190b2839606e864b1083f432c429e6c1952b95050d0d8fa07f40
+  data.tar.gz: 8493feb719823602a34412e8b8ac18f995b523e24dada3dcd61dd9bcf6603dff6ab6b30b48a783657ce20eea1778a892516906e6334972028e8ac74f8efbf132

data/CHANGELOG.md

@@ -5,6 +5,18 @@ All notable changes to this project will be documented in this file. (Pending ap
 
 
 # Releases
+## [[0.5.0]] (https://github.com/rsb/appfuel/releases/tag/0.5.0) 2017-06-29
+### Added
+- adding new repository type of aws dynamodb
+- adding initializers for aws dynamodb
+
+### Fixed
+- bootstrapping the app is not idempotent and does not throw any errors when
+  done twice
+
+### Changed
+- storage mapping as simplified to a one-to-one between domain and storage model
+
 ## [[0.4.5]] (https://github.com/rsb/appfuel/releases/tag/0.4.5) 2017-06-29
 ### Fixed
 - fixed active record migrator, was not updating config properly

data/lib/appfuel/application/app_container.rb

@@ -203,7 +203,9 @@ module Appfuel
         # @param key [String] partial key to be built into fully qualified key
         # @param type_ns [String] namespace for key
         # @return [String] fully qualified namespaced key
-        def qualify_container_key(key, type_ns)
+        def qualify_container_key(key, type_ns, opts = {})
+          return key if opts[:no_context] == true
+
           parts     = key.to_s.split('.')
           namespace = "#{container_feature_key}."
           if parts[0].downcase == 'global'

data/lib/appfuel/application/root.rb

@@ -110,12 +110,13 @@ module Appfuel
           Repository::Initializer.new
         }
 
+        mappings = Repository::MappingCollection.new
         root_name = root.to_s.underscore
         container.register(:root, root)
         container.register(:root_name, root_name)
         container.register(:root_path, root_path)
         container.register(:auto_register_classes, [])
-        container.register(:repository_mappings, {})
+        container.register(:repository_mappings, mappings)
         container.register(:repository_cache, {})
         container.register(:repository_initializer, repo_initializer)
         container.register(:features_path, "#{root_name}/features")

data/lib/appfuel/handler/inject_dsl.rb

@@ -57,7 +57,12 @@ module Appfuel
                 "container"
               end
 
-        namespaced_key = qualify_container_key(key, cat)
+        no_context = false
+        if opts.key?(:no_context)
+          no_context = !!opts.delete(:no_context)
+        end
+
+        namespaced_key = qualify_container_key(key, cat, no_context: no_context)
         injections[namespaced_key] = opts[:as]
         nil
       end

data/lib/appfuel/initialize.rb

@@ -81,11 +81,16 @@ module Appfuel
       def run(params = {})
         app_name  = params.fetch(:app_name) { Appfuel.default_app_name }
         container = Appfuel.app_container(app_name)
+        if container.key?(:initialized) && container[:initialized] == true
+          return container
+        end
+
         handle_configuration(container, params)
         handle_repository_mapping(container, params)
 
         Appfuel.run_initializers('global', container, params[:exclude] || [])
 
+        container.register(:initialized, true)
         container
       end
     end

data/lib/appfuel/initializers/all.rb

@@ -1,3 +1,4 @@
 require_relative 'logging'
 require_relative 'db'
 require_relative 'web_api'
+require_relative 'aws_dynamodb'

data/lib/appfuel/initializers/aws_dynamodb.rb

@@ -0,0 +1,17 @@
+Appfuel::Initialize.define('global.aws_dynamodb') do |config, container|
+  require 'aws-sdk'
+  require 'appfuel/storage/aws_dynamodb'
+
+  env = config[:env]
+  if ['local', 'development'].include?(env.to_s)
+    Aws.config.update({
+      region: config[:aws][:dynamodb][:region],
+      endpoint: config[:aws][:dynamodb][:endpoint]
+    })
+  end
+  key = Appfuel::AwsDynamodb::CLIENT_CONTAINER_KEY
+
+  client = Aws::DynamoDB::Client.new
+
+  container.register(key, client)
+end

data/lib/appfuel/initializers/db.rb

@@ -4,6 +4,8 @@ Appfuel::Initialize.define('global.db') do |config, container|
 
   require 'pg'
   require 'active_record'
+  require 'appfuel/storage/db'
+
   config[:db][:main] = config[:db][:main].with_indifferent_access
 
   ActiveSupport.on_load(:active_record) do

data/lib/appfuel/initializers/web_api.rb

@@ -1,4 +1,5 @@
 Appfuel::Initialize.define('global.web_api') do |config, container|
   require 'rest-client'
+  require 'appfuel/storage/web_api'
   container.register('web_api.http_adapter', RestClient)
 end

data/lib/appfuel/storage/aws_dynamodb/no_sql_model.rb

@@ -0,0 +1,44 @@
+module Appfuel
+  module AwsDynamodb
+    CLIENT_CONTAINER_KEY = 'aws.dynamodb.client'
+    class NoSqlModel
+      include Appfuel::Application::AppContainer
+
+      class << self
+        def container_class_type
+          'aws.dynamo_db'
+        end
+
+        def config_key(value = nil)
+          return @config_key if value.nil?
+          @config_key = value.to_sym
+        end
+
+        def load_config
+          config = app_container[:config]
+          unless config.key?(config_key)
+            fail "[aws_dynamodb] config key (#{config_key}) not found - #{self}"
+          end
+          config[config_key]
+        end
+
+        def load_client
+          app_container[CLIENT_CONTAINER_KEY]
+        end
+
+        def inherited(klass)
+          stage_class_for_registration(klass)
+        end
+      end
+
+      attr_reader :config, :client
+
+      def initialize
+        @client = self.class.load_client
+        @config = self.class.load_config
+        @table_prefix = @config.fetch(:table_prefix) { '' }
+      end
+
+    end
+  end
+end

data/lib/appfuel/storage/aws_dynamodb/repository.rb

@@ -0,0 +1,11 @@
+module Appfuel
+  module AwsDynamodb
+    class Repository < Appfuel::Repository::Base
+      class << self
+        def container_class_type
+          "#{super}.aws.dynamo_db"
+        end
+      end
+    end
+  end
+end

data/lib/appfuel/storage/aws_dynamodb.rb

@@ -0,0 +1,2 @@
+require_relative 'aws_dynamodb/repository'
+require_relative 'aws_dynamodb/no_sql_model'

data/lib/appfuel/storage/db/mapper.rb

@@ -16,10 +16,12 @@ module Appfuel
       # @param expr [SpCore::Domain::Expr]
       # @return [table_name, column] [Array]
       def db_table_column(expr, entry = nil)
-        entry ||= find(expr.domain_name, expr.domain_attr)
-        db  = storage_class_from_entry(entry, :db)
+        storage_map = storage_map(:db, expr.domain_name)
 
-        [db.table_name, entry.storage_attr]
+        db     = fetch_storage_class(storage_map.storage_key)
+        column = storage_map.storage_attr(expr.domain_attr)
+
+        [db.table_name, column]
       end
 
       # Converts an entity expression into a valid active record expresion

data/lib/appfuel/storage/repository/base.rb

@@ -195,9 +195,9 @@ module Appfuel
         mapper.to_storage(entity, exclude)
       end
 
-      def to_entity(domain_name, storage)
+      def to_entity(domain_name, type, storage)
         key  = qualify_container_key(domain_name, "domains")
-        hash = mapper.to_entity_hash(domain_name, storage)
+        hash = mapper.to_entity_hash(domain_name, type, storage)
         app_container[key].new(hash)
       end
 

data/lib/appfuel/storage/repository/mapper.rb

@@ -9,8 +9,8 @@ module Appfuel
 
       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"
+        if !map.nil? && !map.instance_of?(MappingCollection)
+          fail "repository mappings must be a MappingCollection"
         end
         @map = map
       end
@@ -39,7 +39,7 @@ module Appfuel
       # @param entity [String]
       # @return [Boolean]
       def entity?(entity_name)
-        map.key?(entity_name)
+        map.entity?(entity_name)
       end
 
       # Determine if an attribute is mapped for a given entity
@@ -47,65 +47,32 @@ module Appfuel
       # @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)
+      def entity_attr?(entity_name, entity_attr, type)
+        map.entity_attr?(type, entity_name, entity_attr)
       end
 
-      # Returns a mapping entry for a given entity
+      # 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 [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]
+      # @return [String]
+      def storage_attr(entity_name, entity_attr, type)
+        map.storage_attr(type, 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
+      def storage_key(type, entity_name)
+        map.storage_key(type, entity_name)
       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
+      def entity_container_name(type, entity_name)
+        map.container_name(type, entity_name)
       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
+      def storage_map(type, domain_name)
+        map.storage_map(type, domain_name)
       end
 
       # Returns the storage class based on type
@@ -118,36 +85,30 @@ module Appfuel
       # @param entity [String] name of the entity
       # @param attr [String] name of the attribute
       # @return [Object]
-      def storage_class(entity_name, entity_attr, type)
-        entry = find(entity_name, entity_attr)
-        storage_class_from_entry(entry, type)
-      end
-
-      def storage_class_from_entry(entry, type)
-        unless entry.storage?(type)
-          fail "No (#{type}) storage has been mapped"
-        end
-
-        container_name = entry.container_name
-        unless container_root_name == container_name
+      def storage_class(type, entity_name)
+        key = storage_key(type, entity_name)
+        domain_container = entity_container_name(type, entity_name)
+        unless container_root_name == domain_container
           fail "You can not access a mapping outside of this container " +
-            "(mapper: #{container_root_name}, entry: #{container_name})"
+            "(mapper: #{container_root_name}, entry: #{domain_container})"
         end
-        app_container = Appfuel.app_container(entry.container_name)
-        key = entry.storage(type)
+
+        fetch_storage_class(key)
+      end
+
+      def fetch_storage_class(key)
+        app_container = Appfuel.app_container(container_root_name)
         app_container[key]
       end
 
-      def to_entity_hash(domain_name,  storage)
+      def to_entity_hash(domain_name, type, storage)
         entity_attrs = {}
         storage_data = storage_hash(storage)
-        each_entity_attr(domain_name) do |entry|
-          attr_name   = entry.storage_attr
-          domain_attr = entry.domain_attr
-          next unless storage_data.key?(attr_name)
-          update_entity_hash(domain_attr, storage_data[attr_name], entity_attrs)
+        map.each_attr(type, domain_name) do |domain_attr, storage_attr, skip|
+          next unless storage_data.key?(storage_attr)
+          value = storage_data[storage_attr]
+          update_entity_hash(domain_attr, value, entity_attrs)
         end
-
         entity_attrs
       end
 
@@ -156,6 +117,7 @@ module Appfuel
         fail "storage must implement to_h" unless storage.respond_to?(:to_h)
         storage.to_h
       end
+
       # Convert the domain into a hash of storage attributes that represent.
       # Each storage class has its own hash of mapped attributes. A domain
       # can have more than one storage class.
@@ -172,22 +134,30 @@ module Appfuel
           fail "Domain entity must implement :domain_name"
         end
 
-        excluded = opts[:exclude] || []
-        data     = {}
-        each_entity_attr(domain.domain_name) do |entry|
-          unless entry.storage?(type)
-            "storage type (#{type}) is not support for (#{domain.domain_name})"
-          end
-          storage_attr  = entry.storage_attr
-          storage_class = entry.storage(type)
-          next if excluded.include?(storage_attr) || entry.skip?
-
-          data[storage_class] = {} unless data.key?(storage_class)
-          data[storage_class][storage_attr] = entity_value(domain, entry)
+        excluded     = opts[:exclude] || []
+        data         = {}
+        domain_name  = domain.domain_name
+        map.each_attr(domain_name, type) do |domain_attr, storage_attr, skip|
+          next if excluded.include?(storage_attr) || skip == true
+
+          data[storage_attr] = entity_value(domain, entry)
         end
+
         data
       end
 
+      # user.role.id => user_role_id 99
+      #
+      # {
+      #   user: {
+      #     role: {
+      #       id: 99
+      #       }
+      #     }
+      #   }
+      #
+      #  id
+      #
       def update_entity_hash(domain_attr, value, hash)
         if domain_attr.include?('.')
           hash.deep_merge!(create_entity_hash(domain_attr, value))
@@ -207,6 +177,10 @@ module Appfuel
         value
       end
 
+      # user.role.id
+      #
+      # [id, role, user]
+      #
       def create_entity_hash(domain_attr, value)
         domain_attr.split('.').reverse.inject(value) do |result, nested_attr|
           {nested_attr => result}

data/lib/appfuel/storage/repository/mapping_collection.rb

@@ -0,0 +1,60 @@
+module Appfuel
+  module Repository
+    class MappingCollection
+      attr_reader :collection
+
+      def initialize(collection = {})
+        @collection = collection
+        fail "collection must be a hash" unless collection.is_a?(Hash)
+      end
+
+      # map {
+      #  domain_name => {
+      #   type => map
+      #  }
+      # }
+      def load(storage_map)
+        domain_name  = storage_map.domain_name
+        storage_type = storage_map.storage_type
+        collection[domain_name] = {} unless  collection.key?(domain_name)
+        collection[domain_name][storage_type] = storage_map
+      end
+
+      def entity?(domain_name)
+        collection.key?(domain_name)
+      end
+
+      def storage_attr(type, domain_name, domain_attr)
+        map = storage_map(type, domain_name)
+        map.storage_attr(domain_attr)
+      end
+
+      def storage_key(type, domain_name)
+        map = storage_map(type, domain_name)
+        map.storage_key
+      end
+
+      def container_name(type, domain_name)
+        map = storage_map(type, domain_name)
+        map.container_name
+      end
+
+      def each_attr(type, domain_name, &block)
+        map = storage_map(type, domain_name)
+        map.each(&block)
+      end
+
+      def storage_map(type, domain_name)
+        unless entity?(domain_name)
+          fail "#{domain_name} is not registered in map"
+        end
+
+        unless collection[domain_name].key?(type)
+          fail "#{domain_name} storage #{type} is not registered in map"
+        end
+
+        collection[domain_name][type]
+      end
+    end
+  end
+end

data/lib/appfuel/storage/repository/mapping_dsl.rb

@@ -6,208 +6,87 @@ module Appfuel
     # and don't want any incorrect method_missing calls to be confused when
     # collecting mapped values vs when defining them.
     class MappingDsl
-      attr_reader :domain_name, :storage, :entries, :entry_class,
-                  :container_name
+      attr_reader :domain_name, :entries, :map_class, :container_name,
+                  :storage_key, :storage_type
 
-      STORAGE_TYPES = [:db, :file, :memory, :web_api]
-
-      # 1) mapping 'feature.domain', db: true, do
-      #    ...
-      #    end
-      #
-      # 2) mapping 'feature.domain', db: 'foo.bar', do
-      #    ...
-      #    end
+      # 1) mapping 'feature.domain', to: :db, model: 'foo.db.bar', contextual_key: false do
       #
-      # 3) mapping 'feature.domain', db: 'global.bar' do
-      #    ...
       #    end
       #
-      # 4) mapping 'feature.domain', db: 'foo.bar.baz', key_translation: false)
-      # 4) mapping 'feature.domain', storage: [:db, :file] do
-      #    ...
+      #    mapping 'feature.domain' web_api: 'web_api.http.model' do
+      #     map 'id'
+      #     map 'foo', 'bar'
+      #     map 'biz', 'baz'
       #    end
       #
-      # a file model requires the domain_name it represents.
-      #
-      #   case1 - build a model with default settings
-      #   file: storage.file.model
-      #           path: <root_path>/storage/file/{key}.yaml
-      #           adapter: storage.file.model
-      #
-      #   case2 - build a model with given settings
-      #           note: if path is absolute nothing is done
-      #                 if path is relative we will prepend root_path
-      #                 if no yaml extension the key is translated to a path
-      #
-      #           path: foo/bar/baz.yml -> <root_path>/foo/bar/baz.yml
-      #           path: /foo/bar/baz.yml -> /foo/bar/baz.yml
-      #           path  auth.user -> <root_path>/storage/features/auth/file/user.yml
-      #           path gobal.user -> <root_path/storage/global/auth/file/user.yml
-      #
-      #   case3 - build a model with adapter and path
-      #     path: sames as above
-      #     adapter translates key to location of adapter in storage
-      #
-      #     container
-      #         default key -> storage.file.model is default
-      #         auth.user -> features.auth.storage.file.user
-      #
-      # file 'storage.file.model'
-      #
-      # storage db: 'foo.user_user'
-      # storage :file
-      # storage :memory
-      #
-      # storage db: 'foo.user_ath',
-      #         file: 'storage.file.model',
-      #         memory: 'storage.memory.model'
-      #
-      def initialize(domain_name, options = {})
-        fail "options must be a hash" unless options.is_a?(Hash)
-
+      def initialize(domain_name, to:, model:, **opts)
+        opts          ||= {}
         @entries        = []
         @domain_name    = domain_name.to_s
-        @entry_class    = options[:entry_class] || MappingEntry
-        @container_name = options[:container] || Appfuel.default_app_name
-        @storage        = initialize_storage(options)
-
-        fail "entity name can not be empty" if @domain_name.empty?
-      end
-
-      def db(key)
-        @storage[:db] = translate_storage_key(key)
-      end
-
-      # 5) mapping 'feature.domain' db: true do
-      #    end
-      #
-      # 6) mapping 'feature.domain', db: true do
-      #      storage :db, 'foo.bar'
-      #      storage :file
-      #    end
-      #  storage(type = nil, options = {})
-      #
-      def storage(type = nil, *args)
-        return @storage if type.nil?
-        unless type.respond_to?(:to_sym)
-          fail "Storage type must implement :to_sym"
-        end
-        type = type.to_sym
-
-        if all_storage_symbols?(*args)
-          args.unshift(type)
-          @storage = initialize_storage(storage: args)
-          return self
-        end
+        @map_class      = opts[:map_class] || StorageMap
+        @container_name = opts[:container] || Appfuel.default_app_name
 
-        args = [true] if args.empty?
-
-        key  = args.shift
-        opts = args.shift
-        data = {type => key}
-        if opts.is_a?(Hash)
-          data.merge!(opts)
+        @contextual_key = true
+        if opts.key?(:contextual_key) && opts[:contextual_key] == false
+          @contextual_key = false
         end
+        @storage_type = to
+        @storage_key  = translate_storage_key(to, model)
 
-        @storage.merge!(initialize_storage(data))
-        self
+        fail "entity name can not be empty" if @domain_name.empty?
       end
 
-      def all_storage_symbols?(*args)
-        result = args - STORAGE_TYPES
-        result.empty?
+      def create_storage_map
+        map_class.new(
+          domain_name:  domain_name,
+          container:    container_name,
+          storage_type: storage_type,
+          storage_key:  storage_key,
+          entries:      entries
+        )
       end
 
       def map(name, domain_attr = nil, opts = {})
+        if domain_attr.is_a?(Hash)
+          opts = domain_attr
+          domain_attr = nil
+        end
+
         domain_attr = name if domain_attr.nil?
 
         data = opts.merge({
-          domain_name: domain_name,
           domain_attr: domain_attr,
-          storage: storage,
           storage_attr: name,
-          container: container_name,
         })
 
-        @entries << entry_class.new(data)
-      end
-
-      private
-
-      def initialize_storage(data)
-        storage = {}
-        if data.key?(:db)
-          value = data[:db]
-          storage[:db] = initialize_general_storage(:db, value, data)
-        elsif data.key?(:file)
-          value = data[:file]
-          storage[:file] = initialize_file_storage(value)
-        elsif data.key?(:web_api)
-          value = data[:web_api]
-          storage[:web_api] = initialize_general_storage(:web_api, value, data)
-        elsif data.key?(:storage) && data[:storage].is_a?(Array)
-          data[:storage].each do |type|
-            storage[type] = if type.to_s.downcase == 'file'
-                              initialize_file_storage(true)
-                            else
-                              initialize_general_storage(type, true)
-                            end
-          end
-        end
-        storage
-      end
-
-      def initialize_general_storage(key, value, opts = {})
-        case
-        when value == true
-          translate_storage_key(key, domain_name)
-        when opts.is_a?(Hash) && opts[:key_translation] == false
-          value
-        else
-          translate_storage_key(key, value)
-        end
-      end
-
-      def initialize_file_storage(value)
-        key = translate_storage_key(:file, domain_name)
-        case value
-        when true
-          {
-            model: 'file.model',
-            path: "#{storage_path}/#{key.tr('.', '/')}.yml"
-          }
-        end
+        entries << data
       end
 
-      def storage_path
-        app_container = Appfuel.app_container(container_name)
-        path = app_container[:root_path]
-        if app_container.key?(:storage_path)
-          path = app_container[:storage_path]
-        end
-        path
+      def contextual_key?
+        @contextual_key
       end
 
-      #
       # global.user
       # global.storage.db.user
       # membership.user
       # features.membership.{type}.user
       def translate_storage_key(type, partial_key)
-        fail "#{type} can not be empty" if partial_key.empty?
+        return partial_key unless contextual_key?
+        fail "#{type} model key can not be empty" if partial_key.empty?
 
+        # take the feature or domain root unless its global
+        domain_top, _domain_base = domain_name.split('.')
         top, *parts = partial_key.split('.')
-        top = "features.#{top}" unless top == 'global'
-        "#{top}.#{type}.#{parts.join('.')}"
-      end
 
-      def assign_storage(type, partial_key)
-        @storage[type] = translate_storage_key(partial_key)
-      end
+        if top == 'global'
+          root = top
+          base = parts.join('.')
+        else
+          root = "features.#{domain_top}"
+          base = top
+        end
 
-      def assign_default_storage(type)
-        @storage[type] = "#{type.to_s.underscore}.model"
+        "#{root}.#{type}.#{base}"
       end
     end
   end

data/lib/appfuel/storage/repository/mapping_entry.rb

@@ -1,7 +1,7 @@
 module Appfuel
   module Repository
     class MappingEntry
-      attr_reader :domain_name, :domain_attr, :computed_attr, :storage_attr,
+      attr_reader :domain_name, :domain_attr, :storage_attr,
                   :container_name, :container_key
 
       def initialize(data)

data/lib/appfuel/storage/repository/storage_map.rb

@@ -0,0 +1,62 @@
+module Appfuel
+  module Repository
+    class StorageMap
+      attr_reader :domain_name, :container_name, :entries,
+                  :storage_type, :storage_key
+
+      def initialize(data)
+        fail "Mapping data must be a hash" unless data.is_a?(Hash)
+
+        @container_name = data[:container]
+        @domain_name    = data.fetch(:domain_name)  { domain_name_failure }.to_s
+        @storage_type   = data.fetch(:storage_type) { storage_type_failure }
+        @storage_key    = data.fetch(:storage_key)  { storage_key_failure }
+        @entries        = data.fetch(:entries)      { entries_failure }
+      end
+
+      def storage_attr(domain_attr)
+        entries.each do |data|
+           return data[:storage_attr] if data[:domain_attr] == domain_attr
+        end
+
+        fail "[storage_map #{domain_name}] #{domain_attr} not registered"
+      end
+
+      def domain_attr(storage_attr)
+        entries.each do |data|
+           return data[:domain_attr] if data[:storage_attr] == storage_attr
+        end
+
+        fail "[storage_map #{domain_name}] #{storage_attr} not registered"
+      end
+
+      def each
+        entries.each do |data|
+          yield data[:domain_attr], data[:storage_attr], data[:skip]
+        end
+      end
+
+      private
+
+      def domain_name_failure
+        fail "Fully qualified domain name is required"
+      end
+
+      def storage_type_failure
+        domain_failure("storage_type is required for storage map")
+      end
+
+      def storage_key_failure
+        domain_failure(":storage_key is required for storage map")
+      end
+
+      def entries_failure
+        domain_failure(":mapping_entries are required for storage map")
+      end
+
+      def domain_failure(msg)
+        fail "[#{domain_name}] #{msg}"
+      end
+    end
+  end
+end

data/lib/appfuel/storage/repository.rb

@@ -2,8 +2,12 @@ require 'parslet'
 require 'parslet/convenience'
 
 require_relative 'repository/base'
+
 require_relative 'repository/mapping_entry'
+require_relative 'repository/storage_map'
 require_relative 'repository/mapping_dsl'
+require_relative 'repository/mapping_collection'
+
 require_relative 'repository/mapper'
 require_relative 'repository/initializer'
 require_relative 'repository/runner'
@@ -38,21 +42,14 @@ module Appfuel
     # @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)
+    def self.mapping(domain_name, to:, model:, **opts, &block)
+      dsl = MappingDsl.new(domain_name, to: to, model: model, **opts)
       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
+      container   = Appfuel.app_container(dsl.container_name)
+      mappings    = container['repository_mappings']
+      storage_map = dsl.create_storage_map
+      mappings.load(storage_map)
     end
 
     def self.entity_builder(domain_name, type, opts = {}, &block)

data/lib/appfuel/storage/web_api/repository.rb

@@ -22,116 +22,12 @@ module Appfuel
 =end
       end
 
-      def storage_class(domain_name, domain_attr)
-        mapper.storage_class(domain_name, domain_attr, :web_api)
+      def storage_class(domain_name)
+        mapper.storage_class(:web_api, domain_name)
       end
 
-      # when key has no . assume the feature of the repository
-      #
-      #
-      def api_class(key)
-        unless key.include?('.')
-          key = "features.#{self.class.container_feature_name}.web_api.#{key}"
-        end
-        app_container[key]
-      end
-
-      # Handles the treatment of the relation when the recordset is empty
-      # based on the criteria.
-      #
-      # @param criteria [SpCore::Criteria]
-      # @return [SpCore::Error, SpCore::Domain::EntityNotFound, nil]
-      def handle_empty_relation(criteria, relation)
-        return nil unless relation.blank?
-
-        if criteria.error_on_empty_dataset?
-          return error(criteria.domain => ["#{criteria.domain} not found"])
-        end
-
-        if criteria.single?
-          return create_entity_not_found(criteria)
-        end
-      end
-
-      # Null object used when you can not find a given entity
-      #
-      # @param criteria [SpCore::Criteria]
-      # @return SpCore::Domain::EntityNotFound
-      def create_entity_not_found(criteria)
-        Appfuel::Domain::EntityNotFound.new(entity_name: criteria.domain_name)
-      end
-
-      # Apply where, order and limit clauses to the relation based on the
-      # criteria.
-      #
-      # @param criteria [SpCore::Criteria]
-      # @param relation [mixed]
-      # @return relation
-      def apply_query_conditions(criteria, relation, _settings)
-
-      end
-
-      # Determines which query conditions to apply to the relation
-      #
-      # @param criteria [SpCore::Criteria]
-      # @param relation
-      # @return relation
-      def handle_query_conditions(criteria, relation, settings)
-        if settings.all?
-          return order(criteria, relation.all)
-        end
-
-        apply_query_conditions(criteria, relation, settings)
-      end
-
-      def handle_empty_relation(criteria, relation, settings)
-        unless relation.respond_to?(:blank?)
-          fail "The database relation invalid, does not implement :blank?"
-        end
-
-        return nil unless relation.blank?
-
-        if criteria.error_on_empty_dataset?
-          return domain_not_found_error(criteria)
-        end
-
-        if criteria.single?
-          return domain_not_found(criteria)
-        end
-      end
-
-      # 1) lookup query id in cache
-      #   if found build collection from cached query ids
-      #
-      # 2) query id not found in cache
-      #   a) assign query id from criteria
-      #   b) find the domain builder for that criteria
-      #   c) loop through each item in the database relation
-      #   d) build an domain from each record in the relation
-      #   e) create cache id from the domain
-      #   f) record cache id into a list that represents query
-      #   g) assign domain into the cache with its cache id
-      #       id is in the cache the its updated *represents a miss
-      #   h) assign the query list into the cache with its query id
-      #
-      def build_domains(criteria, relation, settings)
-        result  = handle_empty_relation(criteria, relation, settings)
-        return result if result
-
-
-        if settings.single?
-          method   = settings.first? ? :first : :last
-          db_model = relation.send(method)
-          builder  = domain_builder(criteria.domain_name)
-          domain   = builder.call(db_model, criteria)
-          ap domain
-        end
-
-      end
-
-      def domain_builder(domain_name)
-        key = qualify_container_key(domain_name, 'domain_builders.db')
-        app_container[key]
+      def to_entity(domain_name, storage)
+        super(domain_name, :web_api, storage)
       end
 
       private

data/lib/appfuel/storage.rb

@@ -1,5 +1,4 @@
 require_relative 'storage/repository'
 require_relative 'storage/file'
 require_relative 'storage/memory'
-require_relative 'storage/db'
-require_relative 'storage/web_api'
+

data/lib/appfuel/version.rb

@@ -1,3 +1,3 @@
 module Appfuel
-  VERSION = "0.4.5"
+  VERSION = "0.5.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: appfuel
 version: !ruby/object:Gem::Version
-  version: 0.4.5
+  version: 0.5.0
 platform: ruby
 authors:
 - Robert Scott-Buccleuch
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-06-29 00:00:00.000000000 Z
+date: 2017-07-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -316,6 +316,7 @@ files:
 - lib/appfuel/initialize.rb
 - lib/appfuel/initialize/initializer.rb
 - lib/appfuel/initializers/all.rb
+- lib/appfuel/initializers/aws_dynamodb.rb
 - lib/appfuel/initializers/db.rb
 - lib/appfuel/initializers/logging.rb
 - lib/appfuel/initializers/web_api.rb
@@ -330,6 +331,9 @@ files:
 - lib/appfuel/root_module.rb
 - lib/appfuel/run_error.rb
 - lib/appfuel/storage.rb
+- lib/appfuel/storage/aws_dynamodb.rb
+- lib/appfuel/storage/aws_dynamodb/no_sql_model.rb
+- lib/appfuel/storage/aws_dynamodb/repository.rb
 - lib/appfuel/storage/db.rb
 - lib/appfuel/storage/db/active_record_model.rb
 - lib/appfuel/storage/db/mapper.rb
@@ -352,6 +356,7 @@ files:
 - lib/appfuel/storage/repository/expr_transform.rb
 - lib/appfuel/storage/repository/initializer.rb
 - lib/appfuel/storage/repository/mapper.rb
+- lib/appfuel/storage/repository/mapping_collection.rb
 - lib/appfuel/storage/repository/mapping_dsl.rb
 - lib/appfuel/storage/repository/mapping_entry.rb
 - lib/appfuel/storage/repository/order_expr.rb
@@ -359,6 +364,7 @@ files:
 - lib/appfuel/storage/repository/search_parser.rb
 - lib/appfuel/storage/repository/search_transform.rb
 - lib/appfuel/storage/repository/settings.rb
+- lib/appfuel/storage/repository/storage_map.rb
 - lib/appfuel/storage/web_api.rb
 - lib/appfuel/storage/web_api/http_model.rb
 - lib/appfuel/storage/web_api/repository.rb