hanami-model 0.6.1 → 0.7.0

data/lib/hanami/model/types.rb

@@ -0,0 +1,99 @@
+require 'rom/types'
+
+module Hanami
+  module Model
+    # Types definitions
+    #
+    # @since 0.7.0
+    module Types
+      include ROM::Types
+
+      # @since 0.7.0
+      # @api private
+      def self.included(mod)
+        mod.extend(ClassMethods)
+      end
+
+      # Class level interface
+      #
+      # @since 0.7.0
+      module ClassMethods
+        # Define an array of given type
+        #
+        # @since 0.7.0
+        def Collection(type) # rubocop:disable Style/MethodName
+          type = Schema::CoercibleType.new(type) unless type.is_a?(Dry::Types::Definition)
+          Types::Array.member(type)
+        end
+      end
+
+      # Types for schema definitions
+      #
+      # @since 0.7.0
+      module Schema
+        # Coercer for objects within custom schema definition
+        #
+        # @since 0.7.0
+        # @api private
+        class CoercibleType < Dry::Types::Definition
+          # Coerce given value into the wrapped object type
+          #
+          # @param value [Object] the value
+          #
+          # @return [Object] the coerced value of `object` type
+          #
+          # @raise [TypeError] if value can't be coerced
+          #
+          # @since 0.7.0
+          # @api private
+          def call(value)
+            if valid?(value)
+              coerce(value)
+            else
+              raise TypeError.new("#{value.inspect} must be coercible into #{object}")
+            end
+          end
+
+          # Check if value can be coerced
+          #
+          # It is true if value is an instance of `object` type or if value
+          # respond to `#to_hash`.
+          #
+          # @param value [Object] the value
+          #
+          # @return [TrueClass,FalseClass] the result of the check
+          #
+          # @since 0.7.0
+          # @api private
+          def valid?(value)
+            value.is_a?(object) ||
+              value.respond_to?(:to_hash)
+          end
+
+          # Coerce given value into an instance of `object` type
+          #
+          # @param value [Object] the value
+          #
+          # @return [Object] the coerced value of `object` type
+          def coerce(value)
+            case value
+            when object
+              value
+            else
+              object.new(value.to_hash)
+            end
+          end
+
+          # @since 0.7.0
+          # @api private
+          def object
+            result = primitive
+            return result unless result.respond_to?(:primitive)
+
+            result.primitive
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hanami/model/version.rb

@@ -3,6 +3,6 @@ module Hanami
     # Defines the version
     #
     # @since 0.1.0
-    VERSION = '0.6.1'.freeze
+    VERSION = '0.7.0'.freeze
   end
 end

data/lib/hanami/repository.rb

@@ -1,5 +1,10 @@
+require 'rom-repository'
+require 'hanami/model/entity_name'
+require 'hanami/model/relation_name'
+require 'hanami/model/associations/dsl'
+require 'hanami/model/association'
+require 'hanami/utils/class'
 require 'hanami/utils/class_attribute'
-require 'hanami/model/adapters/null_adapter'
 
 module Hanami
   # Mediates between the entities and the persistence layer, by offering an API
@@ -18,25 +23,11 @@ module Hanami
   #   end
   #
   #   # valid
-  #   class ArticleRepository
-  #     include Hanami::Repository
+  #   class ArticleRepository < Hanami::Repository
   #   end
   #
   #   # not valid for Article
-  #   class PostRepository
-  #     include Hanami::Repository
-  #   end
-  #
-  # Repository for an entity can be configured by setting # the `#repository`
-  # on the mapper.
-  #
-  # @example
-  #   # PostRepository is repository for Article
-  #   mapper = Hanami::Model::Mapper.new do
-  #     collection :articles do
-  #       entity Article
-  #       repository PostRepository
-  #     end
+  #   class PostRepository < Hanami::Repository
   #   end
   #
   # A repository is storage independent.
@@ -54,10 +45,9 @@ module Hanami
   #
   #   * Isolates the persistence logic at a low level
   #
-  # Hanami::Model is shipped with two adapters:
+  # Hanami::Model is shipped with one adapter:
   #
   #   * SqlAdapter
-  #   * MemoryAdapter
   #
   #
   #
@@ -82,7 +72,7 @@ module Hanami
   #   #  * If we change the storage, we are forced to change the code of the
   #   #    caller(s).
   #
-  #   ArticleRepository.where(author_id: 23).order(:published_at).limit(8)
+  #   ArticleRepository.new.where(author_id: 23).order(:published_at).limit(8)
   #
   #
   #
@@ -100,16 +90,14 @@ module Hanami
   #   #
   #   #  * If we change the storage, the callers aren't affected.
   #
-  #   ArticleRepository.most_recent_by_author(author)
+  #   ArticleRepository.new.most_recent_by_author(author)
   #
-  #   class ArticleRepository
-  #     include Hanami::Repository
-  #
-  #     def self.most_recent_by_author(author, limit = 8)
-  #       query do
+  #   class ArticleRepository < Hanami::Repository
+  #     def most_recent_by_author(author, limit = 8)
+  #       articles.
   #         where(author_id: author.id).
-  #           order(:published_at)
-  #       end.limit(limit)
+  #           order(:published_at).
+  #           limit(limit)
   #     end
   #   end
   #
@@ -118,755 +106,331 @@ module Hanami
   # @see Hanami::Entity
   # @see http://martinfowler.com/eaaCatalog/repository.html
   # @see http://en.wikipedia.org/wiki/Dependency_inversion_principle
-  module Repository
-    # Inject the public API into the hosting class.
+  class Repository < ROM::Repository::Root
+    # Mapper name.
     #
-    # @since 0.1.0
+    # With ROM mapping there is a link between the entity class and a generic
+    # reference for it. Example: <tt>BookRepository</tt> references <tt>Book</tt>
+    # as <tt>:entity</tt>.
     #
-    # @example
-    #   require 'hanami/model'
+    # @since 0.7.0
+    # @api private
     #
-    #   class UserRepository
-    #     include Hanami::Repository
-    #   end
-    def self.included(base)
-      base.class_eval do
-        extend ClassMethods
-        include Hanami::Utils::ClassAttribute
+    # @see Hanami::Repository.inherited
+    # @see Hanami::Repository.define_mapping
+    MAPPER_NAME = :entity
 
-        class_attribute :collection
-        self.adapter = Hanami::Model::Adapters::NullAdapter.new
-      end
-    end
+    # Plugins for database commands
+    #
+    # @since 0.7.0
+    # @api private
+    #
+    # @see Hanami::Model::Plugins
+    COMMAND_PLUGINS = [:schema, :mapping, :timestamps].freeze
 
-    module ClassMethods
-      # Assigns an adapter.
-      #
-      # Hanami::Model is shipped with two adapters:
-      #
-      #   * SqlAdapter
-      #   * MemoryAdapter
-      #
-      # @param adapter [Object] an object that implements
-      #   `Hanami::Model::Adapters::Abstract` interface
-      #
-      # @since 0.1.0
-      #
-      # @see Hanami::Model::Adapters::SqlAdapter
-      # @see Hanami::Model::Adapters::MemoryAdapter
-      #
-      # @example Memory adapter
-      #   require 'hanami/model'
-      #   require 'hanami/model/adapters/memory_adapter'
-      #
-      #   mapper = Hanami::Model::Mapper.new do
-      #     # ...
-      #   end
-      #
-      #   adapter = Hanami::Model::Adapters::MemoryAdapter.new(mapper)
-      #
-      #   class UserRepository
-      #     include Hanami::Repository
-      #   end
-      #
-      #   UserRepository.adapter = adapter
-      #
-      #
-      #
-      # @example SQL adapter with a Sqlite database
-      #   require 'sqlite3'
-      #   require 'hanami/model'
-      #   require 'hanami/model/adapters/sql_adapter'
-      #
-      #   mapper = Hanami::Model::Mapper.new do
-      #     # ...
-      #   end
-      #
-      #   adapter = Hanami::Model::Adapters::SqlAdapter.new(mapper, 'sqlite://path/to/database.db')
-      #
-      #   class UserRepository
-      #     include Hanami::Repository
-      #   end
-      #
-      #   UserRepository.adapter = adapter
-      #
-      #
-      #
-      # @example SQL adapter with a Postgres database
-      #   require 'pg'
-      #   require 'hanami/model'
-      #   require 'hanami/model/adapters/sql_adapter'
-      #
-      #   mapper = Hanami::Model::Mapper.new do
-      #     # ...
-      #   end
-      #
-      #   adapter = Hanami::Model::Adapters::SqlAdapter.new(mapper, 'postgres://host:port/database')
-      #
-      #   class UserRepository
-      #     include Hanami::Repository
-      #   end
-      #
-      #   UserRepository.adapter = adapter
-      def adapter=(adapter)
-        @adapter = adapter
-      end
+    # Configuration
+    #
+    # @since 0.7.0
+    # @api private
+    def self.configuration
+      Hanami::Model.configuration
+    end
 
-      # @since 0.5.0
-      # @api private
-      def adapter
-        @adapter
-      end
+    # Container
+    #
+    # @since 0.7.0
+    # @api private
+    def self.container
+      Hanami::Model.container
+    end
 
-      # Creates or updates a record in the database for the given entity.
-      #
-      # @param entity [#id, #id=] the entity to persist
-      #
-      # @return [Object] a copy of the entity with `id` assigned
-      #
-      # @since 0.1.0
-      #
-      # @see Hanami::Repository#create
-      # @see Hanami::Repository#update
-      #
-      # @example With a non persisted entity
-      #   require 'hanami/model'
-      #
-      #   class ArticleRepository
-      #     include Hanami::Repository
-      #   end
-      #
-      #   article = Article.new(title: 'Introducing Hanami::Model')
-      #   article.id # => nil
-      #
-      #   persisted_article = ArticleRepository.persist(article) # creates a record
-      #   article.id # => nil
-      #   persisted_article.id # => 23
-      #
-      # @example With a persisted entity
-      #   require 'hanami/model'
-      #
-      #   class ArticleRepository
-      #     include Hanami::Repository
-      #   end
-      #
-      #   article = ArticleRepository.find(23)
-      #   article.id # => 23
-      #
-      #   article.title = 'Launching Hanami::Model'
-      #   ArticleRepository.persist(article) # updates the record
-      #
-      #   article = ArticleRepository.find(23)
-      #   article.title # => "Launching Hanami::Model"
-      def persist(entity)
-        _touch(entity)
-        @adapter.persist(collection, entity)
-      end
+    # Define a database relation, which describes how data is fetched from the
+    # database.
+    #
+    # It auto-infers the underlying database table.
+    #
+    # @since 0.7.0
+    # @api private
+    def self.define_relation # rubocop:disable Metrics/MethodLength
+      a = @associations
 
-      # Creates a record in the database for the given entity.
-      # It returns a copy of the entity with `id` assigned.
-      #
-      # If already persisted (`id` present) it does nothing.
-      #
-      # @param entity [#id,#id=] the entity to create
-      #
-      # @return [Object] a copy of the entity with `id` assigned
-      #
-      # @since 0.1.0
-      #
-      # @see Hanami::Repository#persist
-      #
-      # @example
-      #   require 'hanami/model'
-      #
-      #   class ArticleRepository
-      #     include Hanami::Repository
-      #   end
-      #
-      #   article = Article.new(title: 'Introducing Hanami::Model')
-      #   article.id # => nil
-      #
-      #   created_article = ArticleRepository.create(article) # creates a record
-      #   article.id # => nil
-      #   created_article.id # => 23
-      #
-      #   created_article = ArticleRepository.create(article)
-      #   created_article.id # => 24
-      #
-      #   created_article = ArticleRepository.create(existing_article) # => no-op
-      #   created_article # => nil
-      #
-      def create(entity)
-        unless _persisted?(entity)
-          _touch(entity)
-          @adapter.create(collection, entity)
+      configuration.relation(relation) do
+        schema(infer: true) do
+          associations(&a) unless a.nil?
         end
-      end
 
-      # Updates a record in the database corresponding to the given entity.
-      #
-      # If not already persisted (`id` present) it raises an exception.
-      #
-      # @param entity [#id] the entity to update
-      #
-      # @return [Object] the entity
-      #
-      # @raise [Hanami::Model::NonPersistedEntityError] if the given entity
-      #   wasn't already persisted.
-      #
-      # @since 0.1.0
-      #
-      # @see Hanami::Repository#persist
-      # @see Hanami::Model::NonPersistedEntityError
-      #
-      # @example With a persisted entity
-      #   require 'hanami/model'
-      #
-      #   class ArticleRepository
-      #     include Hanami::Repository
-      #   end
-      #
-      #   article = ArticleRepository.find(23)
-      #   article.id # => 23
-      #   article.title = 'Launching Hanami::Model'
-      #
-      #   ArticleRepository.update(article) # updates the record
-      #
-      #
-      #
-      # @example With a non persisted entity
-      #   require 'hanami/model'
-      #
-      #   class ArticleRepository
-      #     include Hanami::Repository
-      #   end
-      #
-      #   article = Article.new(title: 'Introducing Hanami::Model')
-      #   article.id # => nil
-      #
-      #   ArticleRepository.update(article) # raises Hanami::Model::NonPersistedEntityError
-      def update(entity)
-        if _persisted?(entity)
-          _touch(entity)
-          @adapter.update(collection, entity)
-        else
-          raise Hanami::Model::NonPersistedEntityError
+        # rubocop:disable Lint/NestedMethodDefinition
+        def by_primary_key(id)
+          where(primary_key => id)
         end
+        # rubocop:enable Lint/NestedMethodDefinition
       end
 
-      # Deletes a record in the database corresponding to the given entity.
-      #
-      # If not already persisted (`id` present) it raises an exception.
-      #
-      # @param entity [#id] the entity to delete
-      #
-      # @return [Object] the entity
-      #
-      # @raise [Hanami::Model::NonPersistedEntityError] if the given entity
-      #   wasn't already persisted.
-      #
-      # @since 0.1.0
-      #
-      # @see Hanami::Model::NonPersistedEntityError
-      #
-      # @example With a persisted entity
-      #   require 'hanami/model'
-      #
-      #   class ArticleRepository
-      #     include Hanami::Repository
-      #   end
-      #
-      #   article = ArticleRepository.find(23)
-      #   article.id # => 23
-      #
-      #   ArticleRepository.delete(article) # deletes the record
-      #
-      #
-      #
-      # @example With a non persisted entity
-      #   require 'hanami/model'
-      #
-      #   class ArticleRepository
-      #     include Hanami::Repository
-      #   end
-      #
-      #   article = Article.new(title: 'Introducing Hanami::Model')
-      #   article.id # => nil
-      #
-      #   ArticleRepository.delete(article) # raises Hanami::Model::NonPersistedEntityError
-      def delete(entity)
-        if _persisted?(entity)
-          @adapter.delete(collection, entity)
-        else
-          raise Hanami::Model::NonPersistedEntityError
-        end
+      relations(relation)
+      root(relation)
+    end
 
-        entity
-      end
+    # Defines the ampping between a database table and an entity.
+    #
+    # It's also responsible to associate table columns to entity attributes.
+    #
+    # @since 0.7.0
+    # @api private
+    #
+    # rubocop:disable Metrics/MethodLength
+    # rubocop:disable Metrics/AbcSize
+    def self.define_mapping
+      self.entity = Utils::Class.load!(entity_name)
+      e = entity
+      m = @mapping
 
-      # Returns all the persisted entities.
-      #
-      # @return [Array<Object>] the result of the query
-      #
-      # @since 0.1.0
-      #
-      # @example
-      #   require 'hanami/model'
-      #
-      #   class ArticleRepository
-      #     include Hanami::Repository
-      #   end
-      #
-      #   ArticleRepository.all # => [ #<Article:0x007f9b19a60098> ]
-      def all
-        @adapter.all(collection)
+      blk = lambda do |_|
+        model       e
+        register_as MAPPER_NAME
+        instance_exec(&m) unless m.nil?
       end
 
-      # Finds an entity by its identity.
-      #
-      # If used with a SQL database, it corresponds to the primary key.
-      #
-      # @param id [Object] the identity of the entity
-      #
-      # @return [Object,NilClass] the result of the query, if present
-      #
-      # @since 0.1.0
-      #
-      # @example
-      #   require 'hanami/model'
-      #
-      #   class ArticleRepository
-      #     include Hanami::Repository
-      #   end
-      #
-      #   ArticleRepository.find(23)   # => #<Article:0x007f9b19a60098>
-      #   ArticleRepository.find(9999) # => nil
-      def find(id)
-        @adapter.find(collection, id)
-      end
+      root = self.root
+      configuration.mappers { define(root, &blk) }
+      configuration.define_mappings(root, &blk)
+      configuration.register_entity(relation, entity_name.underscore, e)
+    end
+    # rubocop:enable Metrics/AbcSize
+    # rubocop:enable Metrics/MethodLength
 
-      # Returns the first entity in the database.
-      #
-      # @return [Object,nil] the result of the query
-      #
-      # @since 0.1.0
-      #
-      # @see Hanami::Repository#last
-      #
-      # @example With at least one persisted entity
-      #   require 'hanami/model'
-      #
-      #   class ArticleRepository
-      #     include Hanami::Repository
-      #   end
-      #
-      #   ArticleRepository.first # => #<Article:0x007f8c71d98a28>
-      #
-      # @example With an empty collection
-      #   require 'hanami/model'
-      #
-      #   class ArticleRepository
-      #     include Hanami::Repository
-      #   end
-      #
-      #   ArticleRepository.first # => nil
-      def first
-        @adapter.first(collection)
-      end
+    # It defines associations, by adding relations to the repository
+    #
+    # @since 0.7.0
+    # @api private
+    #
+    # @see Hanami::Model::Associations::Dsl
+    def self.define_associations
+      Model::Associations::Dsl.new(self, &@associations) unless @associations.nil?
+    end
 
-      # Returns the last entity in the database.
-      #
-      # @return [Object,nil] the result of the query
-      #
-      # @since 0.1.0
-      #
-      # @see Hanami::Repository#last
-      #
-      # @example With at least one persisted entity
-      #   require 'hanami/model'
-      #
-      #   class ArticleRepository
-      #     include Hanami::Repository
-      #   end
-      #
-      #   ArticleRepository.last # => #<Article:0x007f8c71d98a28>
-      #
-      # @example With an empty collection
-      #   require 'hanami/model'
-      #
-      #   class ArticleRepository
-      #     include Hanami::Repository
-      #   end
-      #
-      #   ArticleRepository.last # => nil
-      def last
-        @adapter.last(collection)
-      end
+    # Declare associations for the repository
+    #
+    # NOTE: This is an experimental feature
+    #
+    # @since 0.7.0
+    # @api private
+    #
+    # @example
+    #   class BookRepository < Hanami::Repository
+    #     associations do
+    #       has_many :books
+    #     end
+    #   end
+    def self.associations(&blk)
+      @associations = blk
+    end
 
-      # Deletes all the records from the current collection.
-      #
-      # If used with a SQL database it executes a `DELETE FROM <table>`.
-      #
-      # @since 0.1.0
-      #
-      # @example
-      #   require 'hanami/model'
-      #
-      #   class ArticleRepository
-      #     include Hanami::Repository
-      #   end
-      #
-      #   ArticleRepository.clear # deletes all the records
-      def clear
-        @adapter.clear(collection)
-      end
+    # Declare mapping between database columns and entity's attributes
+    #
+    # NOTE: This should be used **only** when there is a name mismatch (eg. in legacy databases).
+    #
+    # @since 0.7.0
+    #
+    # @example
+    #   class BookRepository < Hanami::Repository
+    #     self.relation = :t_operator
+    #
+    #     mapping do
+    #       attribute :id,   from: :operator_id
+    #       attribute :name, from: :s_name
+    #     end
+    #   end
+    def self.mapping(&blk)
+      @mapping = blk
+    end
 
-      # Wraps the given block in a transaction.
-      #
-      # For performance reasons the block isn't in the signature of the method,
-      # but it's yielded at the lower level.
-      #
-      # Please note that it's only supported by some databases.
-      # For this reason, the accepted options may be different from adapter to
-      # adapter.
-      #
-      # For advanced scenarios, please check the documentation of each adapter.
-      #
-      # @param options [Hash] options for transaction
-      #
-      # @see Hanami::Model::Adapters::SqlAdapter#transaction
-      # @see Hanami::Model::Adapters::MemoryAdapter#transaction
-      #
-      # @since 0.2.3
-      #
-      # @example Basic usage with SQL adapter
-      #   require 'hanami/model'
-      #
-      #   class Article
-      #     include Hanami::Entity
-      #     attributes :title, :body
-      #   end
-      #
-      #   class ArticleRepository
-      #     include Hanami::Repository
-      #   end
-      #
-      #   article = Article.new(title: 'Introducing transactions',
-      #     body: 'lorem ipsum')
-      #
-      #   ArticleRepository.transaction do
-      #     ArticleRepository.dangerous_operation!(article) # => RuntimeError
-      #     # !!! ROLLBACK !!!
-      #   end
-      def transaction(options = {})
-        @adapter.transaction(options) do
-          yield
-        end
-      end
+    # Define relations, mapping and associations
+    #
+    # @since 0.7.0
+    # @api private
+    def self.load!
+      define_relation
+      define_mapping
+      define_associations
+    end
 
-      private
+    # @since 0.7.0
+    # @api private
+    def self.inherited(klass) # rubocop:disable Metrics/MethodLength
+      klass.class_eval do
+        include Utils::ClassAttribute
 
-      # Executes the given raw statement on the adapter.
-      #
-      # Please note that it's only supported by some databases,
-      # a `NotImplementedError` will be raised when the adapter does not
-      # responds to the `execute` method.
-      #
-      # For advanced scenarios, please check the documentation of each adapter.
-      #
-      # @param raw [String] the raw statement to execute on the connection
-      #
-      # @return [NilClass]
-      #
-      # @raise [NotImplementedError] if current Hanami::Model adapter doesn't
-      #   implement `execute`.
-      #
-      # @raise [Hanami::Model::InvalidCommandError] if the raw statement is invalid
-      #
-      # @see Hanami::Model::Adapters::Abstract#execute
-      # @see Hanami::Model::Adapters::SqlAdapter#execute
-      #
-      # @since 0.3.1
-      #
-      # @example Basic usage with SQL adapter
-      #   require 'hanami/model'
-      #
-      #   class Article
-      #     include Hanami::Entity
-      #     attributes :title, :body
-      #   end
-      #
-      #   class ArticleRepository
-      #     include Hanami::Repository
-      #
-      #     def self.reset_comments_count
-      #       execute "UPDATE articles SET comments_count = 0"
-      #     end
-      #   end
-      #
-      #   ArticleRepository.reset_comments_count
-      def execute(raw)
-        @adapter.execute(raw)
+        class_attribute :entity
+
+        class_attribute :entity_name
+        self.entity_name = Model::EntityName.new(name)
+
+        class_attribute :relation
+        self.relation = Model::RelationName.new(name)
+
+        commands :create, update: :by_primary_key, delete: :by_primary_key, mapper: MAPPER_NAME, use: COMMAND_PLUGINS
+        prepend Commands
       end
 
-      # Fetch raw result sets for the the given statement.
-      #
-      # PLEASE NOTE: The returned result set contains an array of hashes.
-      #              The columns are returned as they are from the database,
-      #              the mapper is bypassed here.
-      #
-      # @param raw [String] the raw statement used to fetch records
-      # @param blk [Proc] an optional block that is yielded for each record
-      #
-      # @return [Enumerable<Hash>,Array<Hash>] the collection of raw records
-      #
-      # @raise [NotImplementedError] if current Hanami::Model adapter doesn't
-      #   implement `fetch`.
-      #
-      # @raise [Hanami::Model::InvalidQueryError] if the raw statement is invalid
-      #
-      # @since 0.5.0
-      #
-      # @example Basic Usage
-      #   require 'hanami/model'
-      #
-      #   mapping do
-      #     collection :articles do
-      #       attribute :id,    Integer, as: :s_id
-      #       attribute :title, String,  as: :s_title
-      #     end
-      #   end
-      #
-      #   class Article
-      #     include Hanami::Entity
-      #     attributes :title, :body
-      #   end
-      #
-      #   class ArticleRepository
-      #     include Hanami::Repository
-      #
-      #     def self.all_raw
-      #       fetch("SELECT * FROM articles")
-      #     end
-      #   end
-      #
-      #   ArticleRepository.all_raw
-      #     # => [{:_id=>1, :user_id=>nil, :s_title=>"Art 1", :comments_count=>nil, :umapped_column=>nil}]
-      #
-      # @example Map A Value From Result Set
-      #   require 'hanami/model'
-      #
-      #   mapping do
-      #     collection :articles do
-      #       attribute :id,    Integer, as: :s_id
-      #       attribute :title, String,  as: :s_title
-      #     end
-      #   end
-      #
-      #   class Article
-      #     include Hanami::Entity
-      #     attributes :title, :body
-      #   end
-      #
-      #   class ArticleRepository
-      #     include Hanami::Repository
-      #
-      #     def self.titles
-      #       fetch("SELECT s_title FROM articles").map do |article|
-      #         article[:s_title]
-      #       end
-      #     end
-      #   end
-      #
-      #   ArticleRepository.titles # => ["Announcing Hanami v0.5.0"]
-      #
-      # @example Passing A Block
-      #   require 'hanami/model'
-      #
-      #   mapping do
-      #     collection :articles do
-      #       attribute :id,    Integer, as: :s_id
-      #       attribute :title, String,  as: :s_title
-      #     end
-      #   end
+      Hanami::Model.repositories << klass
+    end
+
+    # Extend commands from ROM::Repository with error management
+    #
+    # @since 0.7.0
+    module Commands
+      # Create a new record
       #
-      #   class Article
-      #     include Hanami::Entity
-      #     attributes :title, :body
-      #   end
+      # @return [Hanami::Entity] an new created entity
       #
-      #   class ArticleRepository
-      #     include Hanami::Repository
+      # @raise [Hanami::Model::Error] an error in case the command fails
       #
-      #     def self.titles
-      #       result = []
+      # @since 0.7.0
       #
-      #       fetch("SELECT s_title FROM articles") do |article|
-      #         result << article[:s_title]
-      #       end
+      # @example Create From Hash
+      #   user = UserRepository.new.create(name: 'Luca')
       #
-      #       result
-      #     end
-      #   end
+      # @example Create From Entity
+      #   entity = User.new(name: 'Luca')
+      #   user   = UserRepository.new.create(entity)
       #
-      #   ArticleRepository.titles # => ["Announcing Hanami v0.5.0"]
-      def fetch(raw, &blk)
-        @adapter.fetch(raw, &blk)
+      #   user.id   # => 23
+      #   entity.id # => nil - It doesn't mutate original entity
+      def create(*args)
+        super
+      rescue => e
+        raise Hanami::Model::Error.for(e)
       end
 
-      # Fabricates a query and yields the given block to access the low level
-      # APIs exposed by the query itself.
-      #
-      # This is a Ruby private method, because we wanted to prevent outside
-      # objects to query directly the database. However, this is a public API
-      # method, and this is the only way to filter entities.
-      #
-      # The returned query SHOULD be lazy: the entities should be fetched by
-      # the database only when needed.
-      #
-      # The returned query SHOULD refer to the entire collection by default.
-      #
-      # Queries can be reused and combined together. See the example below.
-      # IMPORTANT: This feature works only with the Sql adapter.
-      #
-      # A repository is storage independent.
-      # All the queries are delegated to the current adapter, which is
-      # responsible to implement a querying API.
-      #
-      # Hanami::Model is shipped with two adapters:
-      #
-      #   * SqlAdapter, which yields a Hanami::Model::Adapters::Sql::Query
-      #   * MemoryAdapter, which yields a Hanami::Model::Adapters::Memory::Query
-      #
-      # @param blk [Proc] a block of code that is executed in the context of a
-      #   query
-      #
-      # @return a query, the type depends on the current adapter
+      # Update a record
       #
-      # @api public
-      # @since 0.1.0
+      # @return [Hanami::Entity] an updated entity
       #
-      # @see Hanami::Model::Adapters::Sql::Query
-      # @see Hanami::Model::Adapters::Memory::Query
+      # @raise [Hanami::Model::Error] an error in case the command fails
       #
-      # @example
-      #   require 'hanami/model'
-      #
-      #   class ArticleRepository
-      #     include Hanami::Repository
-      #
-      #     def self.most_recent_by_author(author, limit = 8)
-      #       query do
-      #         where(author_id: author.id).
-      #           desc(:published_at).
-      #           limit(limit)
-      #       end
-      #     end
+      # @since 0.7.0
       #
-      #     def self.most_recent_published_by_author(author, limit = 8)
-      #       # combine .most_recent_published_by_author and .published queries
-      #       most_recent_by_author(author, limit).published
-      #     end
+      # @example Update From Data
+      #   repository = UserRepository.new
+      #   user       = repository.create(name: 'Luca')
       #
-      #     def self.published
-      #       query do
-      #         where(published: true)
-      #       end
-      #     end
+      #   user       = repository.update(user.id, age: 34)
       #
-      #     def self.rank
-      #       # reuse .published, which returns a query that respond to #desc
-      #       published.desc(:comments_count)
-      #     end
+      # @example Update From Entity
+      #   repository = UserRepository.new
+      #   user       = repository.create(name: 'Luca')
       #
-      #     def self.best_article_ever
-      #       # reuse .published, which returns a query that respond to #limit
-      #       rank.limit(1)
-      #     end
+      #   entity     = User.new(age: 34)
+      #   user       = repository.update(user.id, entity)
       #
-      #     def self.comments_average
-      #       query.average(:comments_count)
-      #     end
-      #   end
-      def query(&blk)
-        @adapter.query(collection, self, &blk)
+      #   user.age  # => 34
+      #   entity.id # => nil - It doesn't mutate original entity
+      def update(*args)
+        super
+      rescue => e
+        raise Hanami::Model::Error.for(e)
       end
 
-      # Negates the filtering conditions of a given query with the logical
-      # opposite operator.
-      #
-      # This is only supported by the SqlAdapter.
-      #
-      # @param query [Object] a query
+      # Delete a record
       #
-      # @return a negated query, the type depends on the current adapter
+      # @return [Hanami::Entity] a deleted entity
       #
-      # @api public
-      # @since 0.1.0
+      # @raise [Hanami::Model::Error] an error in case the command fails
       #
-      # @see Hanami::Model::Adapters::Sql::Query#negate!
+      # @since 0.7.0
       #
       # @example
-      #   require 'hanami/model'
-      #
-      #   class ProjectRepository
-      #     include Hanami::Repository
-      #
-      #     def self.cool
-      #       query do
-      #         where(language: 'ruby')
-      #       end
-      #     end
-      #
-      #     def self.not_cool
-      #       exclude cool
-      #     end
-      #   end
-      def exclude(query)
-        query.negate!
-        query
+      #   repository = UserRepository.new
+      #   user       = repository.create(name: 'Luca')
+      #
+      #   user       = repository.delete(user.id)
+      def delete(*args)
+        super
+      rescue => e
+        raise Hanami::Model::Error.for(e)
       end
+    end
 
-      # This is a method to check entity persited or not
-      #
-      # @param entity
-      # @return a boolean value
-      # @since 0.3.1
-      def _persisted?(entity)
-        !!entity.id
-      end
+    # Initialize a new instance
+    #
+    # @return [Hanami::Repository] the new instance
+    #
+    # @since 0.7.0
+    def initialize
+      super(self.class.container)
+    end
 
-      # Update timestamps
-      #
-      # @param entity [Object, Hanami::Entity] the entity
-      #
-      # @api private
-      # @since 0.3.1
-      def _touch(entity)
-        now = Time.now.utc
+    # Find by primary key
+    #
+    # @return [Hanami::Entity,NilClass] the entity, if found
+    #
+    # @since 0.7.0
+    #
+    # @example
+    #   repository = UserRepository.new
+    #   user       = repository.create(name: 'Luca')
+    #
+    #   user       = repository.find(user.id)
+    def find(id)
+      root.by_primary_key(id).as(:entity).one
+    end
 
-        if _has_timestamp?(entity, :created_at)
-          entity.created_at ||= now
-        end
+    # Return all the records for the relation
+    #
+    # @return [Array<Hanami::Entity>] all the entities
+    #
+    # @since 0.7.0
+    #
+    # @example
+    #   UserRepository.new.all
+    def all
+      root.as(:entity).to_a
+    end
 
-        if _has_timestamp?(entity, :updated_at)
-          entity.updated_at = now
-        end
-      end
+    # Returns the first record for the relation
+    #
+    # @return [Hanami::Entity,NilClass] first entity, if any
+    #
+    # @since 0.7.0
+    #
+    # @example
+    #   UserRepository.new.first
+    def first
+      root.as(:entity).first
+    end
 
-      # Check if the given entity has the given timestamp
-      #
-      # @param entity [Object, Hanami::Entity] the entity
-      # @param timestamp [Symbol] the timestamp name
-      #
-      # @return [TrueClass,FalseClass]
-      #
-      # @api private
-      # @since 0.3.1
-      def _has_timestamp?(entity, timestamp)
-        entity.respond_to?(timestamp) &&
-          entity.respond_to?("#{ timestamp }=")
-      end
+    # Returns the last record for the relation
+    #
+    # @return [Hanami::Entity,NilClass] last entity, if any
+    #
+    # @since 0.7.0
+    #
+    # @example
+    #   UserRepository.new.last
+    def last
+      root.order(Model::Sql.desc(root.primary_key)).as(:entity).first
+    end
+
+    # Deletes all the records from the relation
+    #
+    # @since 0.7.0
+    #
+    # @example
+    #   UserRepository.new.clear
+    def clear
+      root.delete
+    end
+
+    private
+
+    # Returns an association
+    #
+    # NOTE: This is an experimental feature
+    #
+    # @since 0.7.0
+    # @api private
+    def assoc(target, subject = nil)
+      Hanami::Model::Association.build(self, target, subject)
     end
   end
 end