Upload 150 files

model-main/.github/FUNDING.yml

@@ -0,0 +1 @@
+github: hanami

model-main/.github/workflows/ci.yml

@@ -0,0 +1,76 @@
+name: ci
+
+"on":
+  push:
+    paths:
+      - ".github/workflows/ci.yml"
+      - "lib/**"
+      - "*.gemspec"
+      - "spec/**"
+      - "Rakefile"
+      - "Gemfile"
+      - ".rubocop.yml"
+      - "script/ci"
+  pull_request:
+    branches:
+      - main
+  create:
+
+jobs:
+  tests:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby:
+          - "2.7"
+        db:
+          - sqlite3
+          - mysql
+          - postgresql
+    env:
+      DB: ${{matrix.db}}
+    steps:
+      - uses: actions/checkout@v1
+      - name: Install package dependencies
+        run: "[ -e $APT_DEPS ] || sudo apt-get install -y --no-install-recommends $APT_DEPS"
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          bundler-cache: true
+          ruby-version: ${{matrix.ruby}}
+      - name: Run all tests
+        env:
+          HANAMI_DATABASE_USERNAME: root
+          HANAMI_DATABASE_PASSWORD: root
+          HANAMI_DATABASE_HOST: 127.0.0.1
+          HANAMI_DATABASE_NAME: hanami_model
+        run: script/ci
+    services:
+      mysql:
+        image: mysql:8
+        env:
+          ALLOW_EMPTY_PASSWORD: true
+          MYSQL_AUTHENTICATION_PLUGIN: mysql_native_password
+          MYSQL_ROOT_PASSWORD: root
+          MYSQL_DATABASE: hanami_model
+        ports:
+          - 3306:3306
+        options: >-
+          --health-cmd="mysqladmin ping"
+          --health-interval=10s
+          --health-timeout=5s
+          --health-retries=3
+      postgres:
+        image: postgres:13
+        ports:
+          - 5432:5432
+        options: >-
+          --health-cmd pg_isready
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+        env:
+          POSTGRES_USER: root
+          POSTGRES_PASSWORD: root
+          POSTGRES_DB: hanami_model

model-main/.gitignore

@@ -0,0 +1,21 @@
+*.gem
+*.rbc
+.bundle
+.config
+.DS_Store
+.greenbar
+.ruby-version
+.yardoc
+.rubocop-*
+_yardoc
+coverage
+doc/
+Gemfile.lock
+InstalledFiles
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

model-main/.jrubyrc

@@ -0,0 +1 @@
+debug.fullTrace=true

model-main/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

model-main/.rubocop.yml

@@ -0,0 +1,18 @@
+# Please keep AllCops, Bundler, Style, Metrics groups and then order cops
+# alphabetically
+inherit_from:
+  - https://raw.githubusercontent.com/hanami/devtools/1.3.x/.rubocop.yml
+Naming/MethodParameterName:
+  AllowedNames:
+    - ci
+    - db
+    - id
+    - os
+Layout/LineLength:
+  Enabled: false
+Naming/RescuedExceptionsVariableName:
+  PreferredName: "exception"
+Style/RescueStandardError:
+  Enabled: false
+Style/DateTime:
+  Enabled: false

model-main/.yardopts

@@ -0,0 +1,5 @@
+--protected
+--private
+-
+LICENSE.md
+lib/**/*.rb

model-main/CHANGELOG.md

@@ -0,0 +1,316 @@
+# Hanami::Model
+A persistence layer for Hanami
+
+## v1.3.3 - 2021-05-22
+### Fixed
+- [Sean Collins] Specify dependency on BigDecimal v1.4
+- [Adam Daniels] Use environment variables for PostgreSQL CLI tools
+
+## v1.3.2 - 2019-01-31
+### Fixed
+- [Luca Guidi] Depend on `dry-logic` `~> 0.4.2`, `< 0.5`
+
+## v1.3.1 - 2019-01-18
+### Added
+- [Luca Guidi] Official support for Ruby: MRI 2.6
+- [Luca Guidi] Support `bundler` 2.0+
+
+## v1.3.0 - 2018-10-24
+
+## v1.3.0.beta1 - 2018-08-08
+### Fixed
+- [Luca Guidi] Print meaningful error message when connection URL is misconfigured (eg. `Unknown database adapter for URL: "". Please check your database configuration (hint: ENV['DATABASE_URL']).`)
+- [Ian Ker-Seymer] Reliably parse query params from connection string
+
+## v1.2.0 - 2018-04-11
+
+## v1.2.0.rc2 - 2018-04-06
+
+## v1.2.0.rc1 - 2018-03-30
+### Fixed
+- [Marcello Rocha & Luca Guidi] Ensure repository relations to access database attributes via `#[]` (eg. `projects[:name].ilike("Hanami")`)
+
+## v1.2.0.beta2 - 2018-03-23
+
+## v1.2.0.beta1 - 2018-02-28
+### Added
+- [Luca Guidi] Official support for Ruby: MRI 2.5
+- [Marcello Rocha] Introduce `Hanami::Repository#command` as a factory for custom database commands. This is useful to create custom bulk operations.
+
+## v1.1.0 - 2017-10-25
+### Fixed
+- [Luca Guidi] Ensure associations to always accept objects that are serializable into `::Hash`
+
+## v1.1.0.rc1 - 2017-10-16
+### Added
+- [Marcello Rocha] Added support for associations aliasing via `:as` option (`has_many :users, through: :comments, as: :authors`)
+- [Luca Guidi] Allow entities to be used as type in entities manual schema (`attribute :owner, Types::Entity(User)`)
+
+## v1.1.0.beta3 - 2017-10-04
+
+## v1.1.0.beta2 - 2017-10-03
+### Added
+- [Alfonso Uceda] Introduce `Hanami::Model::Migrator#rollback` to provide database migrations rollback
+- [Alfonso Uceda] Improve connection string for PostgreSQL in order to pass credentials as URI query string
+
+### Fixed
+- [Marcello Rocha] One-To-Many properly destroy the associated methods
+
+## v1.1.0.beta1 - 2017-08-11
+### Added
+- [Marcello Rocha] Many-To-One association (aka `belongs_to`)
+- [Marcello Rocha] One-To-One association (aka `has_one`)
+- [Marcello Rocha] Many-To-Many association (aka `has_many :through`)
+- [Luca Guidi] Introduced new extra behaviors for entity manual schema: `:schema` (default), `:strict`, `:weak`, and `:permissive`
+
+### Fixed
+- [Sean Collins] Enhanced error message for Postgres `db create` and `db drop` when `createdb` and `dropdb` aren't in `PATH`
+
+## v1.0.4 - 2017-10-14
+### Fixed
+- [Nikita Shilnikov] Keep the dependency on `rom-sql` at `~> 1.3`, which is compatible with `dry-types` `~> 0.11.0`
+- [Nikita Shilnikov] Ensure to write Postgres JSON (`PGJSON`) type for nested associated records
+- [Nikita Shilnikov] Ensure `Repository#select` to work with `Hanami::Model::MappedRelation`
+
+## v1.0.3 - 2017-10-11
+### Fixed
+- [Luca Guidi] Keep the dependency on `dry-types` at `~> 0.11.0`
+
+## v1.0.2 - 2017-08-04
+### Fixed
+- [Maurizio De Magnis] URI escape for Postgres password
+- [Marion Duprey] Ensure repository to generate timestamps values even when only one between `created_at` and `updated_at` is present
+- [Paweł Świątkowski] Make Postgres JSON(B) to work with Ruby arrays
+- [Luca Guidi] Don't remove migrations when running `Hanami::Model::Migrator#apply` fails to dump the database
+
+## v1.0.1 - 2017-06-23
+### Fixed
+- [Kai Kuchenbecker & Marcello Rocha & Luca Guidi] Ensure `Hanami::Entity#initialize` to not serialize (into `Hash`) other entities passed as an argument
+- [Luca Guidi] Let `Hanami::Repository.relation=` to accept strings as an argument
+- [Nikita Shilnikov] Prevent stack-overflow when `Hanami::Repository#update` is called thousand times
+
+## v1.0.0 - 2017-04-06
+
+## v1.0.0.rc1 - 2017-03-31
+
+## v1.0.0.beta3 - 2017-03-17
+### Added
+- [Luca Guidi] Introduced `Hanami::Model.disconnect` to disconnect all the active database connections
+
+## v1.0.0.beta2 - 2017-03-02
+### Added
+- [Semyon Pupkov] Allow to define Postgres connection URL as `"postgresql:///mydb?host=localhost&port=6433&user=postgres&password=testpasswd"`
+
+### Fixed
+- [Marcello Rocha] Fixed migrations MySQL detection of username and password
+- [Luca Guidi] Fixed migrations creation/drop of a MySQL database with a dash in the name
+- [Semyon Pupkov] Ensure `db console` to work when Postgres connection URL is defined with `"postgresql://"` scheme
+
+## v1.0.0.beta1 - 2017-02-14
+### Added
+- [Luca Guidi] Official support for Ruby: MRI 2.4
+- [Luca Guidi] Introduced `Repository#read` to fetch from database with raw SQL string
+- [Luca Guidi] Introduced `Repository.schema` to manually configure the schema of a database table. This is useful for legacy databases where Hanami::Model autoinferring doesn't map correctly the schema.
+- [Luca Guidi & Alfonso Uceda] Added `Hanami::Model::Configuration#gateway` to configure gateway and the raw connection
+- [Luca Guidi] Added `Hanami::Model::Configuration#logger` to configure a logger
+- [Luca Guidi] Database operations (including migrations) print informations to standard output
+
+### Fixed
+- [Thorbjørn Hermansen] Ensure repository to not override given timestamps
+- [Luca Guidi] Raise `Hanami::Model::MissingPrimaryKeyError` if `Repository#find` is ran against a database w/o a primary key
+- [Alfonso Uceda] Ensure SQLite databases to be used on JRuby when the database path is in the same directory of the Ruby script (eg. `./test.sqlite`)
+
+### Changed
+- [Luca Guidi] Automap the main relation in a repository, by removing the need of use `.as(:entity)`
+- [Luca Guidi] Raise an `Hanami::Model::UnknownDatabaseTypeError` when the application is loaded and there is an unknown column type in the database
+
+## v0.7.0 - 2016-11-15
+### Added
+- [Luca Guidi] `Hanami::Entity` defines an automatic schema for SQL databases
+– [Luca Guidi] `Hanami::Entity` attributes schema
+- [Luca Guidi] Experimental support for One-To-Many association (aka `has_many`)
+- [Luca Guidi] Native support for PostgreSQL types like UUID, Array, JSON(B) and Money
+- [Luca Guidi] Repositories instances can access all the relations (eg. `BookRepository` can access `users` relation via `#users`)
+- [Luca Guidi] Automapping for SQL databases
+- [Luca Guidi] Added `Hanami::Model::DatabaseError`
+
+### Changed
+- [Luca Guidi] Entities are immutable
+- [Luca Guidi] Removed support for Memory and File System adapters
+- [Luca Guidi] Removed support for _dirty tracking_
+- [Luca Guidi] `Hanami::Entity.attributes` method no longer accepts a list of attributes, but a block to optionally define typed attributes
+- [Luca Guidi] Removed `#fetch`, `#execute` and `#transaction` from repository
+- [Luca Guidi] Removed `mapping` block from `Hanami::Model.configure`
+- [Luca Guidi] Changed `adapter` signature in `Hanami::Model.configure` (use `adapter :sql, ENV['DATABASE_URL']`)
+- [Luca Guidi] Repositories must inherit from `Hanami::Repository` instead of including it
+- [Luca Guidi] Entities must inherit from `Hanami::Entity` instead of including it
+- [Pascal Betz] Repositories use instance level interface (eg. `BookRepository.new.find` instead of `BookRepository.find`)
+- [Luca Guidi] Repositories now accept hashes for CRUD operations
+- [Luca Guidi] `Hanami::Repository#create` now accepts: hash (or entity)
+- [Luca Guidi] `Hanami::Repository#update` now accepts two arguments: primary key (`id`) and data (or entity)
+- [Luca Guidi] `Hanami::Repository#delete` now accepts: primary key (`id`)
+- [Luca Guidi] Drop `Hanami::Model::NonPersistedEntityError`, `Hanami::Model::InvalidMappingError`, `Hanami::Model::InvalidCommandError`, `Hanami::Model::InvalidQueryError`
+- [Luca Guidi] Official support for Ruby 2.3 and JRuby 9.0.5.0
+- [Luca Guidi] Drop support for Ruby 2.0, 2.1, 2.2, and JRuby 9.0.0.0
+- [Luca Guidi] Drop support for `mysql` gem in favor of `mysql2`
+
+### Fixed
+- [Luca Guidi] Ensure booleans to be correctly dumped in database
+- [Luca Guidi] Ensure to respect default database schema values
+- [Luca Guidi] Ensure SQL UPDATE to not override non-default primary key
+- [James Hamilton] Print appropriate error message when trying to create a PostgreSQL database that is already existing
+
+## v0.6.2 - 2016-06-01
+### Changed
+- [Kjell-Magne Øierud] Ensure inherited entities to expose attributes from base class
+
+## v0.6.1 - 2016-02-05
+### Changed
+- [Hélio Costa e Silva & Pascal Betz] Mapping SQL Adapter's errors as `Hanami::Model` errors
+
+## v0.6.1 - 2016-02-05
+### Changed
+- [Hélio Costa e Silva & Pascal Betz] Mapping SQL Adapter's errors as `Hanami::Model` errors
+
+## v0.6.0 - 2016-01-22
+### Changed
+- [Luca Guidi] Renamed the project
+
+## v0.5.2 - 2016-01-19
+### Changed
+- [Sean Collins] Improved error message for `Lotus::Model::Adapters::NoAdapterError`
+
+### Fixed
+- [Kyle Chong & Trung Lê] Catch Sequel exceptions and re-raise as `Lotus::Model::Error`
+
+## v0.5.1 - 2016-01-12
+### Added
+- [Taylor Finnell] Let `Lotus::Model::Configuration#adapter` to accept arbitrary options (eg. `adapter type: :sql, uri: 'jdbc:...', after_connect: Proc.new { |connection| connection.auto_commit(true) }`)
+
+### Changed
+- [Andrey Deryabin] Improved `Entity#inspect`
+- [Karim Tarek] Introduced `Lotus::Model::Error` and let all the framework exceptions to inherit from it.
+
+### Fixed
+- [Luca Guidi] Improved error message when trying to use a repository without mapping the corresponding collections
+- [Sean Collins] Improved error message when trying to create database, but it fails (eg. missing `createdb` executable)
+- [Andrey Deryabin] Improved error message when trying to drop database, but a client is still connected (useful for PostgreSQL)
+- [Hiếu Nguyễn] Improved error message when trying to "prepare" database, but it fails
+
+## v0.5.0 - 2015-09-30
+### Added
+- [Brenno Costa] Official support for JRuby 9k+
+- [Luca Guidi] Command/Query separation via `Repository.execute` and `Repository.fetch`
+- [Luca Guidi] Custom attribute coercers for data mapper
+- [Alfonso Uceda] Added `#join` and `#left_join` and `#group` to SQL adapter
+
+### Changed
+- [Luca Guidi] `Repository.execute` no longer returns a result from the database.
+
+### Fixed
+- [Manuel Corrales] Use `dropdb` to drop PostgreSQL database.
+- [Luca Guidi & Bohdan V.] Ignore dotfiles while running migrations.
+
+## v0.4.1 - 2015-07-10
+### Fixed
+- [Nick Coyne] Fixed database creation for PostgreSQL (now it uses `createdb`).
+
+## v0.4.0 - 2015-06-23
+### Added
+- [Luca Guidi] Database migrations
+
+### Changed
+- [Matthew Bellantoni] Made `Repository.execute` not callable from the outside (private Ruby method, public API).
+
+## v0.3.2 - 2015-05-22
+### Added
+- [Dmitry Tymchuk & Luca Guidi] Fix for dirty tracking of attributes changed in place (eg. `book.tags << 'non-fiction'`)
+
+## v0.3.1 - 2015-05-15
+### Added
+- [Dmitry Tymchuk] Dirty tracking for entities (via `Lotus::Entity::DirtyTracking` module to include)
+- [My Mai] Automatic update of timestamps when an entity is persisted.
+- [Peter Berkenbosch] Introduced `Lotus::Repository#execute`, to execute raw query/commands against database (eg. `BookRepository.execute "SELECT * FROM users"` or `BookRepository.execute "UPDATE users SET admin = 'f'"`)
+- [Guilherme Franco] Memory and File System adapters now accept a block for `where`, `or`, `and` conditions (eg `where { age > 33 }`).
+
+### Fixed
+- [Luca Guidi] Ensure Array coercion to preserve original data structure
+
+## v0.3.0 - 2015-03-23
+### Added
+- [Linus Pettersson] Database console
+
+### Fixed
+- [Alfonso Uceda Pompa] Don't send unwanted null values to the database, while coercing entities
+- [Jan Lelis] Do not define top-level `Boolean`, because it is already defined by `hanami-utils`
+- [Vsevolod Romashov] Fix entity class resolving in `Coercer#from_record`
+- [Jason Harrelson] Add file and line to `instance_eval` in `Coercer` to make backtrace more usable
+
+## v0.2.4 - 2015-02-20
+### Fixed
+- [Luca Guidi] When duplicate the framework don't copy over the original `Lotus::Model` configuration
+
+## v0.2.3 - 2015-02-13
+### Added
+- [Alfonso Uceda Pompa] Added support for database transactions in repositories
+
+### Fixed
+- [Luca Guidi] Ensure file system adapter old data is read when a new process is started
+
+## v0.2.2 - 2015-01-18
+### Added
+- [Luca Guidi] Coerce entities when persisted
+
+## v0.2.1 - 2015-01-12
+### Added
+- [Luca Guidi] Compatibility between Lotus::Entity and Lotus::Validations
+
+## v0.2.0 - 2014-12-23
+### Added
+- [Luca Guidi] Introduced file system adapter
+– [Benny Klotz & Trung Lê] Introduced `Entity` inheritance of attributes
+- [Trung Lê] Introduced `Entity#update` for bulk update of attributes
+- [Luca Guidi] Improved error when try to use a repository which wasn't configured or when the framework wasn't loaded yet
+- [Trung Lê] Introduced `Entity#to_h`
+- [Trung Lê] Introduced `Lotus::Model.duplicate`
+- [Trung Lê] Made `Lotus::Mapper` lazy
+- [Trung Lê] Introduced thread safe autoloading for adapters
+- [Felipe Sere] Add support for `Symbol` coercion
+- [Celso Fernandes] Add support for `BigDecimal` coercion
+- [Trung Lê] Introduced `Lotus::Model.load!` as entry point for loading
+- [Trung Lê] Introduced `Mapper#repository` as DSL to associate a repository to a collection
+- [Trung Lê & Tao Guo] Introduced `Configuration#mapping` as DSL to configure the mapping
+- [Coen Wessels] Allow `where`, `exclude` and `or` to accept blocks
+- [Trung Lê & Tao Guo] Introduced `Configuration#adapter` as DSL to configure the adapter
+- [Trung Lê] Introduced `Lotus::Model::Configuration`
+
+### Changed
+- [Trung Lê] Changed `Entity.attributes=` to `Entity.attributes`
+- [Trung Lê] In case of missing entity, let `Repository#find` returns `nil` instead of raise an exception
+
+### Fixed
+- [Rik Tonnard] Ensure correct behavior of `#offset` in memory adapter
+- [Benny Klotz] Ensure `Entity` to set the attributes even when the given Hash uses strings as keys
+- [Ben Askins] Always return the entity from `Repository#persist`
+- [Jeremy Stephens] Made `Memory::Query#where` and `#or` behave more like the SQL counter-part
+
+## v0.1.2 - 2014-06-26
+### Fixed
+- [Stanislav Spiridonov] Ensure to require `'hanami/model/mapping/coercions'`
+- [Krzysztof Zalewski] `Entity` defines `#id` accessor by default
+
+
+## v0.1.1 - 2014-06-23
+### Added
+- [Luca Guidi] Introduced `Lotus::Model::Mapping::Coercions` in order to decouple from `Lotus::Utils::Kernel`
+- [Luca Guidi] Official support for Ruby 2.1
+
+## v0.1.0 - 2014-04-23
+### Added
+- [Luca Guidi] Allow to inject coercer into mapper
+- [Luca Guidi] Introduced database mapping
+- [Luca Guidi] Introduced `Lotus::Entity`
+- [Luca Guidi] Introduced SQL adapter
+- [Luca Guidi] Introduced memory adapter
+– [Luca Guidi] Introduced adapters for repositories
+- [Luca Guidi] Introduced `Lotus::Repository`

model-main/Gemfile

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+gemspec
+
+unless ENV["CI"]
+  gem "byebug", require: false, platforms: :mri
+  gem "yard",   require: false
+end
+
+gem "hanami-utils", "~> 1.3", require: false, git: "https://github.com/hanami/utils.git", branch: "1.3.x"
+
+gem "sqlite3", require: false, platforms: :mri, group: :sqlite
+gem "pg",      require: false, platforms: :mri, group: :postgres
+gem "mysql2",  require: false, platforms: :mri, group: :mysql
+
+gem "jdbc-sqlite3",  require: false, platforms: :jruby, group: :sqlite
+gem "jdbc-postgres", require: false, platforms: :jruby, group: :postgres
+gem "jdbc-mysql",    require: false, platforms: :jruby, group: :mysql
+
+gem "hanami-devtools", require: false, git: "https://github.com/hanami/devtools.git", branch: "1.3.x"

model-main/LICENSE.md

@@ -0,0 +1,22 @@
+Copyright © 2014-2021 Luca Guidi
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

model-main/README.md

@@ -0,0 +1,303 @@
+# Hanami::Model
+
+A persistence framework for [Hanami](http://hanamirb.org).
+
+It delivers a convenient public API to execute queries and commands against a database.
+The architecture eases keeping the business logic (entities) separated from details such as persistence or validations.
+
+It implements the following concepts:
+
+  * [Entity](#entities) - A model domain object defined by its identity.
+  * [Repository](#repositories) - An object that mediates between the entities and the persistence layer.
+
+Like all the other Hanami components, it can be used as a standalone framework or within a full Hanami application.
+
+## Version
+
+**This branch contains the code for `hanami-model` 2.x.**
+
+## Status
+
+[![Gem Version](https://badge.fury.io/rb/hanami-model.svg)](https://badge.fury.io/rb/hanami-model)
+[![CI](https://github.com/hanami/model/workflows/ci/badge.svg?branch=main)](https://github.com/hanami/model/actions?query=workflow%3Aci+branch%3Amain)
+[![Test Coverage](https://codecov.io/gh/hanami/model/branch/main/graph/badge.svg)](https://codecov.io/gh/hanami/model)
+[![Depfu](https://badges.depfu.com/badges/3a5d3f9e72895493bb6f39402ac4f129/overview.svg)](https://depfu.com/github/hanami/model?project=Bundler)
+[![Inline Docs](http://inch-ci.org/github/hanami/model.svg)](http://inch-ci.org/github/hanami/model)
+
+## Contact
+
+* Home page: http://hanamirb.org
+* Mailing List: http://hanamirb.org/mailing-list
+* API Doc: http://rdoc.info/gems/hanami-model
+* Bugs/Issues: https://github.com/hanami/model/issues
+* Support: http://stackoverflow.com/questions/tagged/hanami
+* Chat: https://chat.hanamirb.org
+
+## Rubies
+
+__Hanami::Model__ supports Ruby (MRI) 2.6+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'hanami-model'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install hanami-model
+
+## Usage
+
+This class provides a DSL to configure the connection.
+
+```ruby
+require 'hanami/model'
+require 'hanami/model/sql'
+
+class User < Hanami::Entity
+end
+
+class UserRepository < Hanami::Repository
+end
+
+Hanami::Model.configure do
+  adapter :sql, 'postgres://username:password@localhost/bookshelf'
+end.load!
+
+repository = UserRepository.new
+user       = repository.create(name: 'Luca')
+
+puts user.id # => 1
+
+found = repository.find(user.id)
+found == user # => true
+
+updated = repository.update(user.id, age: 34)
+updated.age # => 34
+
+repository.delete(user.id)
+```
+
+## Concepts
+
+### Entities
+
+A model domain object that is defined by its identity.
+See "Domain Driven Design" by Eric Evans.
+
+An entity is the core of an application, where the part of the domain logic is implemented.
+It's a small, cohesive object that expresses coherent and meaningful behaviors.
+
+It deals with one and only one responsibility that is pertinent to the
+domain of the application, without caring about details such as persistence
+or validations.
+
+This simplicity of design allows developers to focus on behaviors, or
+message passing if you will, which is the quintessence of Object Oriented Programming.
+
+```ruby
+require 'hanami/model'
+
+class Person < Hanami::Entity
+end
+```
+
+### Repositories
+
+An object that mediates between entities and the persistence layer.
+It offers a standardized API to query and execute commands on a database.
+
+A repository is **storage independent**, all the queries and commands are
+delegated to the current adapter.
+
+This architecture has several advantages:
+
+  * Applications depend on a standard API, instead of low level details
+    (Dependency Inversion principle)
+
+  * Applications depend on a stable API, that doesn't change if the
+    storage changes
+
+  * Developers can postpone storage decisions
+
+  * Confines persistence logic at a low level
+
+  * Multiple data sources can easily coexist in an application
+
+When a class inherits from `Hanami::Repository`, it will receive the following interface:
+
+  * `#create(data)`     – Create a record for the given data (or entity)
+  * `#update(id, data)` – Update the record corresponding to the given id by setting the given data (or entity)
+  * `#delete(id)`       – Delete the record corresponding to the given id
+  * `#all`              - Fetch all the entities from the relation
+  * `#find`             - Fetch an entity from the relation by primary key
+  * `#first`            - Fetch the first entity from the relation
+  * `#last`             - Fetch the last entity from the relation
+  * `#clear`            - Delete all the records from the relation
+
+**A relation is a homogenous set of records.**
+It corresponds to a table for a SQL database or to a MongoDB collection.
+
+**All the queries are private**.
+This decision forces developers to define intention revealing API, instead of leaking storage API details outside of a repository.
+
+Look at the following code:
+
+```ruby
+ArticleRepository.new.where(author_id: 23).order(:published_at).limit(8)
+```
+
+This is **bad** for a variety of reasons:
+
+  * The caller has an intimate knowledge of the internal mechanisms of the Repository.
+
+  * The caller works on several levels of abstraction.
+
+  * It doesn't express a clear intent, it's just a chain of methods.
+
+  * The caller can't be easily tested in isolation.
+
+  * If we change the storage, we are forced to change the code of the caller(s).
+
+There is a better way:
+
+```ruby
+require 'hanami/model'
+
+class ArticleRepository < Hanami::Repository
+  def most_recent_by_author(author, limit: 8)
+    articles.where(author_id: author.id).
+      order(:published_at).
+      limit(limit)
+  end
+end
+```
+
+This is a **huge improvement**, because:
+
+  * The caller doesn't know how the repository fetches the entities.
+
+  * The caller works on a single level of abstraction. It doesn't even know about records, only works with entities.
+
+  * It expresses a clear intent.
+
+  * The caller can be easily tested in isolation. It's just a matter of stubbing this method.
+
+  * If we change the storage, the callers aren't affected.
+
+### Mapping
+
+Hanami::Model can **_automap_** columns from relations and entities attributes.
+
+When using a `sql` adapter, you must require `hanami/model/sql` before `Hanami::Model.load!` is called so the relations are loaded correctly.
+
+However, there are cases where columns and attribute names do not match (mainly **legacy databases**).
+
+```ruby
+require 'hanami/model'
+
+class UserRepository < Hanami::Repository
+  self.relation = :t_user_archive
+
+  mapping do
+    attribute :id,   from: :i_user_id
+    attribute :name, from: :s_name
+    attribute :age,  from: :i_age
+  end
+end
+```
+**NOTE:** This feature should be used only when **_automapping_** fails because of the naming mismatch.
+
+### Conventions
+
+  * A repository must be named after an entity, by appending `"Repository"` to the entity class name (eg. `Article` => `ArticleRepository`).
+
+### Thread safety
+
+**Hanami::Model**'s is thread safe during the runtime, but it isn't during the loading process.
+The mapper compiles some code internally, so be sure to safely load it before your application starts.
+
+```ruby
+Mutex.new.synchronize do
+  Hanami::Model.load!
+end
+```
+
+**This is not necessary when Hanami::Model is used within a Hanami application.**
+
+## Features
+
+### Timestamps
+
+If an entity has the following accessors: `:created_at` and `:updated_at`, they will be automatically updated when the entity is persisted.
+
+```ruby
+require 'hanami/model'
+require 'hanami/model/sql'
+
+class User < Hanami::Entity
+end
+
+class UserRepository < Hanami::Repository
+end
+
+Hanami::Model.configure do
+  adapter :sql, 'postgresql://localhost/bookshelf'
+end.load!
+
+repository = UserRepository.new
+
+user = repository.create(name: 'Luca')
+
+puts user.created_at.to_s # => "2016-09-19 13:40:13 UTC"
+puts user.updated_at.to_s # => "2016-09-19 13:40:13 UTC"
+
+sleep 3
+user = repository.update(user.id, age: 34)
+puts user.created_at.to_s # => "2016-09-19 13:40:13 UTC"
+puts user.updated_at.to_s # => "2016-09-19 13:40:16 UTC"
+```
+
+## Configuration
+
+### Logging
+
+In order to log database operations, you can configure a logger:
+
+```ruby
+Hanami::Model.configure do
+  # ...
+  logger "log/development.log", level: :debug
+end
+```
+
+It accepts the following arguments:
+
+  * `stream`: a Ruby StringIO object - it can be `$stdout` or a path to file (eg. `"log/development.log"`) - Defaults to `$stdout`
+  * `:level`: logging level - it can be: `:debug`, `:info`, `:warn`, `:error`, `:fatal`, `:unknown` - Defaults to `:debug`
+  * `:formatter`: logging formatter - it can be: `:default` or `:json` - Defaults to `:default`
+
+## Versioning
+
+__Hanami::Model__ uses [Semantic Versioning 2.0.0](http://semver.org)
+
+## Contributing
+
+1. Fork it ( https://github.com/hanami/model/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## Copyright
+
+Copyright © 2014-2021 Luca Guidi – Released under MIT License
+
+This project was formerly known as Lotus (`lotus-model`).

model-main/Rakefile

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "rake"
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require "hanami/devtools/rake_tasks"
+
+namespace :spec do
+  RSpec::Core::RakeTask.new(:unit) do |task|
+    task.pattern = FileList["spec/**/*_spec.rb"]
+  end
+end
+
+task default: "spec:unit"

model-main/hanami-model.gemspec

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "hanami/model/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "hanami-model"
+  spec.version       = Hanami::Model::VERSION
+  spec.authors       = ["Luca Guidi"]
+  spec.email         = ["me@lucaguidi.com"]
+  spec.summary       = "A persistence layer for Hanami"
+  spec.description   = "A persistence framework with entities and repositories"
+  spec.homepage      = "http://hanamirb.org"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z -- lib/* CHANGELOG.md EXAMPLE.md LICENSE.md README.md hanami-model.gemspec`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+  spec.required_ruby_version = ">= 2.3.0", "< 3"
+
+  spec.add_runtime_dependency "hanami-utils",    "~> 1.3"
+  spec.add_runtime_dependency "rom",             "~> 3.3", ">= 3.3.3"
+  spec.add_runtime_dependency "rom-sql",         "~> 1.3", ">= 1.3.5"
+  spec.add_runtime_dependency "rom-repository",  "~> 1.4"
+  spec.add_runtime_dependency "dry-types",       "~> 0.11.0"
+  spec.add_runtime_dependency "dry-logic",       "~> 0.4.2", "< 0.5"
+  spec.add_runtime_dependency "concurrent-ruby", "~> 1.0"
+  spec.add_runtime_dependency "bigdecimal",      "~> 1.4"
+
+  spec.add_development_dependency "bundler", ">= 1.6", "< 3"
+  spec.add_development_dependency "rake",  "~> 12"
+  spec.add_development_dependency "rspec", "~> 3.7"
+  spec.add_development_dependency "rubocop", "0.81" # rubocop 0.81+ removed support for Ruby 2.3
+end

model-main/lib/hanami-model.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "hanami/model"

model-main/lib/hanami/entity.rb

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+require "hanami/model/types"
+
+module Hanami
+  # An object that is defined by its identity.
+  # See "Domain Driven Design" by Eric Evans.
+  #
+  # An entity is the core of an application, where the part of the domain
+  # logic is implemented. It's a small, cohesive object that expresses coherent
+  # and meaningful behaviors.
+  #
+  # It deals with one and only one responsibility that is pertinent to the
+  # domain of the application, without caring about details such as persistence
+  # or validations.
+  #
+  # This simplicity of design allows developers to focus on behaviors, or
+  # message passing if you will, which is the quintessence of Object Oriented
+  # Programming.
+  #
+  # @example With Hanami::Entity
+  #   require 'hanami/model'
+  #
+  #   class Person < Hanami::Entity
+  #   end
+  #
+  # If we expand the code above in **pure Ruby**, it would be:
+  #
+  # @example Pure Ruby
+  #   class Person
+  #     attr_accessor :id, :name, :age
+  #
+  #     def initialize(attributes = {})
+  #       @id, @name, @age = attributes.values_at(:id, :name, :age)
+  #     end
+  #   end
+  #
+  # **Hanami::Model** ships `Hanami::Entity` for developers' convenience.
+  #
+  # **Hanami::Model** depends on a narrow and well-defined interface for an
+  # Entity - `#id`, `#id=`, `#initialize(attributes={})`.If your object
+  # implements that interface then that object can be used as an Entity in the
+  # **Hanami::Model** framework.
+  #
+  # However, we suggest to implement this interface by including
+  # `Hanami::Entity`, in case that future versions of the framework will expand
+  # it.
+  #
+  # See Dependency Inversion Principle for more on interfaces.
+  #
+  # @since 0.1.0
+  #
+  # @see Hanami::Repository
+  class Entity
+    require "hanami/entity/schema"
+
+    # Syntactic shortcut to reference types in custom schema DSL
+    #
+    # @since 0.7.0
+    module Types
+      include Hanami::Model::Types
+    end
+
+    # Class level interface
+    #
+    # @since 0.7.0
+    # @api private
+    module ClassMethods
+      # Define manual entity schema
+      #
+      # With a SQL database this setup happens automatically and you SHOULD NOT
+      # use this DSL. You should use only when you want to customize the automatic
+      # setup.
+      #
+      # If you're working with an entity that isn't "backed" by a SQL table or
+      # with a schema-less database, you may want to manually setup a set of
+      # attributes via this DSL. If you don't do any setup, the entity accepts all
+      # the given attributes.
+      #
+      # @param type [Symbol] the type of schema to build
+      # @param blk [Proc] the block that defines the attributes
+      #
+      # @since 0.7.0
+      #
+      # @see Hanami::Entity
+      def attributes(type = nil, &blk)
+        self.schema = Schema.new(type, &blk)
+        @attributes = true
+      end
+
+      # Assign a schema
+      #
+      # @param value [Hanami::Entity::Schema] the schema
+      #
+      # @since 0.7.0
+      # @api private
+      def schema=(value)
+        return if defined?(@attributes)
+
+        @schema = value
+      end
+
+      # @since 0.7.0
+      # @api private
+      attr_reader :schema
+    end
+
+    # @since 0.7.0
+    # @api private
+    def self.inherited(klass)
+      klass.class_eval do
+        @schema = Schema.new
+        extend  ClassMethods
+      end
+    end
+
+    # Instantiate a new entity
+    #
+    # @param attributes [Hash,#to_h,NilClass] data to initialize the entity
+    #
+    # @return [Hanami::Entity] the new entity instance
+    #
+    # @raise [TypeError] if the given attributes are invalid
+    #
+    # @since 0.1.0
+    def initialize(attributes = nil)
+      @attributes = self.class.schema[attributes]
+      freeze
+    end
+
+    # Entity ID
+    #
+    # @return [Object,NilClass] the ID, if present
+    #
+    # @since 0.7.0
+    def id
+      attributes.fetch(:id, nil)
+    end
+
+    # Handle dynamic accessors
+    #
+    # If internal attributes set has the requested key, it returns the linked
+    # value, otherwise it raises a <tt>NoMethodError</tt>
+    #
+    # @since 0.7.0
+    def method_missing(method_name, *)
+      attribute?(method_name) or super
+      attributes.fetch(method_name, nil)
+    end
+
+    # Implement generic equality for entities
+    #
+    # Two entities are equal if they are instances of the same class and they
+    # have the same id.
+    #
+    # @param other [Object] the object of comparison
+    #
+    # @return [FalseClass,TrueClass] the result of the check
+    #
+    # @since 0.1.0
+    def ==(other)
+      self.class == other.class &&
+        id == other.id
+    end
+
+    # Implement predictable hashing for hash equality
+    #
+    # @return [Integer] the object hash
+    #
+    # @since 0.7.0
+    def hash
+      [self.class, id].hash
+    end
+
+    # Freeze the entity
+    #
+    # @since 0.7.0
+    def freeze
+      attributes.freeze
+      super
+    end
+
+    # Serialize entity to a Hash
+    #
+    # @return [Hash] the result of serialization
+    #
+    # @since 0.1.0
+    def to_h
+      Utils::Hash.deep_dup(attributes)
+    end
+
+    # @since 0.7.0
+    alias_method :to_hash, :to_h
+
+    protected
+
+    # Check if the attribute is allowed to be read
+    #
+    # @since 0.7.0
+    # @api private
+    def attribute?(name)
+      self.class.schema.attribute?(name)
+    end
+
+    private
+
+    # @since 0.1.0
+    # @api private
+    attr_reader :attributes
+
+    # @since 0.7.0
+    # @api private
+    def respond_to_missing?(name, _include_all)
+      attribute?(name)
+    end
+  end
+end

model-main/lib/hanami/entity/schema.rb

@@ -0,0 +1,269 @@
+# frozen_string_literal: true
+
+require "hanami/model/types"
+require "hanami/utils/hash"
+
+module Hanami
+  class Entity
+    # Entity schema is a definition of a set of typed attributes.
+    #
+    # @since 0.7.0
+    # @api private
+    #
+    # @example SQL Automatic Setup
+    #  require 'hanami/model'
+    #
+    #   class Account < Hanami::Entity
+    #   end
+    #
+    #   account = Account.new(name: "Acme Inc.")
+    #   account.name # => "Hanami"
+    #
+    #   account = Account.new(foo: "bar")
+    #   account.foo # => NoMethodError
+    #
+    # @example Non-SQL Manual Setup
+    #   require 'hanami/model'
+    #
+    #   class Account < Hanami::Entity
+    #     attributes do
+    #       attribute :id,         Types::Int
+    #       attribute :name,       Types::String
+    #       attribute :codes,      Types::Array(Types::Int)
+    #       attribute :users,      Types::Array(User)
+    #       attribute :email,      Types::String.constrained(format: /@/)
+    #       attribute :created_at, Types::DateTime
+    #     end
+    #   end
+    #
+    #   account = Account.new(name: "Acme Inc.")
+    #   account.name # => "Acme Inc."
+    #
+    #   account = Account.new(foo: "bar")
+    #   account.foo # => NoMethodError
+    #
+    # @example Schemaless Entity
+    #   require 'hanami/model'
+    #
+    #   class Account < Hanami::Entity
+    #   end
+    #
+    #   account = Account.new(name: "Acme Inc.")
+    #   account.name # => "Acme Inc."
+    #
+    #   account = Account.new(foo: "bar")
+    #   account.foo # => "bar"
+    class Schema
+      # Schemaless entities logic
+      #
+      # @since 0.7.0
+      # @api private
+      class Schemaless
+        # @since 0.7.0
+        # @api private
+        def initialize
+          freeze
+        end
+
+        # @param attributes [#to_hash] the attributes hash
+        #
+        # @return [Hash]
+        #
+        # @since 0.7.0
+        # @api private
+        def call(attributes)
+          if attributes.nil?
+            {}
+          else
+            Utils::Hash.deep_symbolize(attributes.to_hash.dup)
+          end
+        end
+
+        # @since 0.7.0
+        # @api private
+        def attribute?(_name)
+          true
+        end
+      end
+
+      # Schema definition
+      #
+      # @since 0.7.0
+      # @api private
+      class Definition
+        # Schema DSL
+        #
+        # @since 0.7.0
+        class Dsl
+          # @since 1.1.0
+          # @api private
+          TYPES = %i[schema strict weak permissive strict_with_defaults symbolized].freeze
+
+          # @since 1.1.0
+          # @api private
+          DEFAULT_TYPE = TYPES.first
+
+          # @since 0.7.0
+          # @api private
+          def self.build(type, &blk)
+            type ||= DEFAULT_TYPE
+            raise Hanami::Model::Error.new("Unknown schema type: `#{type.inspect}'") unless TYPES.include?(type)
+
+            attributes = new(&blk).to_h
+            [attributes, Hanami::Model::Types::Coercible::Hash.__send__(type, attributes)]
+          end
+
+          # @since 0.7.0
+          # @api private
+          def initialize(&blk)
+            @attributes = {}
+            instance_eval(&blk)
+          end
+
+          # Define an attribute
+          #
+          # @param name [Symbol] the attribute name
+          # @param type [Dry::Types::Definition] the attribute type
+          #
+          # @since 0.7.0
+          #
+          # @example
+          #   require 'hanami/model'
+          #
+          #   class Account < Hanami::Entity
+          #     attributes do
+          #       attribute :id,         Types::Int
+          #       attribute :name,       Types::String
+          #       attribute :codes,      Types::Array(Types::Int)
+          #       attribute :users,      Types::Array(User)
+          #       attribute :email,      Types::String.constrained(format: /@/)
+          #       attribute :created_at, Types::DateTime
+          #     end
+          #   end
+          #
+          #   account = Account.new(name: "Acme Inc.")
+          #   account.name # => "Acme Inc."
+          #
+          #   account = Account.new(foo: "bar")
+          #   account.foo # => NoMethodError
+          def attribute(name, type)
+            @attributes[name] = type
+          end
+
+          # @since 0.7.0
+          # @api private
+          def to_h
+            @attributes
+          end
+        end
+
+        # Instantiate a new DSL instance for an entity
+        #
+        # @param blk [Proc] the block that defines the attributes
+        #
+        # @return [Hanami::Entity::Schema::Dsl] the DSL
+        #
+        # @since 0.7.0
+        # @api private
+        def initialize(type = nil, &blk)
+          raise LocalJumpError unless block_given?
+
+          @attributes, @schema = Dsl.build(type, &blk)
+          @attributes = Hash[@attributes.map { |k, _| [k, true] }]
+          freeze
+        end
+
+        # Process attributes
+        #
+        # @param attributes [#to_hash] the attributes hash
+        #
+        # @raise [TypeError] if the process fails
+        # @raise [ArgumentError] if data is missing, or unknown keys are given
+        #
+        # @since 0.7.0
+        # @api private
+        def call(attributes)
+          schema.call(attributes)
+        rescue Dry::Types::SchemaError => exception
+          raise TypeError.new(exception.message)
+        rescue Dry::Types::MissingKeyError, Dry::Types::UnknownKeysError => exception
+          raise ArgumentError.new(exception.message)
+        end
+
+        # Check if the attribute is known
+        #
+        # @param name [Symbol] the attribute name
+        #
+        # @return [TrueClass,FalseClass] the result of the check
+        #
+        # @since 0.7.0
+        # @api private
+        def attribute?(name)
+          attributes.key?(name)
+        end
+
+        private
+
+        # @since 0.7.0
+        # @api private
+        attr_reader :schema
+
+        # @since 0.7.0
+        # @api private
+        attr_reader :attributes
+      end
+
+      # Build a new instance of Schema with the attributes defined by the given block
+      #
+      # @param blk [Proc] the optional block that defines the attributes
+      #
+      # @return [Hanami::Entity::Schema] the schema
+      #
+      # @since 0.7.0
+      # @api private
+      def initialize(type = nil, &blk)
+        @schema = if block_given?
+                    Definition.new(type, &blk)
+                  else
+                    Schemaless.new
+                  end
+      end
+
+      # Process attributes
+      #
+      # @param attributes [#to_hash] the attributes hash
+      #
+      # @raise [TypeError] if the process fails
+      #
+      # @since 0.7.0
+      # @api private
+      def call(attributes)
+        Utils::Hash.deep_symbolize(
+          schema.call(attributes)
+        )
+      end
+
+      # @since 0.7.0
+      # @api private
+      alias_method :[], :call
+
+      # Check if the attribute is known
+      #
+      # @param name [Symbol] the attribute name
+      #
+      # @return [TrueClass,FalseClass] the result of the check
+      #
+      # @since 0.7.0
+      # @api private
+      def attribute?(name)
+        schema.attribute?(name)
+      end
+
+      protected
+
+      # @since 0.7.0
+      # @api private
+      attr_reader :schema
+    end
+  end
+end

model-main/lib/hanami/model.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require "rom"
+require "concurrent"
+require "hanami/entity"
+require "hanami/repository"
+
+# Hanami
+#
+# @since 0.1.0
+module Hanami
+  # Hanami persistence
+  #
+  # @since 0.1.0
+  module Model
+    require "hanami/model/version"
+    require "hanami/model/error"
+    require "hanami/model/configuration"
+    require "hanami/model/configurator"
+    require "hanami/model/mapping"
+    require "hanami/model/plugins"
+
+    # @api private
+    # @since 0.7.0
+    @__repositories__ = Concurrent::Array.new
+
+    class << self
+      # @since 0.7.0
+      # @api private
+      attr_reader :config
+
+      # @since 0.7.0
+      # @api private
+      attr_reader :loaded
+
+      # @since 0.7.0
+      # @api private
+      alias_method :loaded?, :loaded
+    end
+
+    # Configure the framework
+    #
+    # @since 0.1.0
+    #
+    # @example
+    #   require 'hanami/model'
+    #
+    #   Hanami::Model.configure do
+    #     adapter :sql, ENV['DATABASE_URL']
+    #
+    #     migrations 'db/migrations'
+    #     schema     'db/schema.sql'
+    #   end
+    def self.configure(&block)
+      @config = Configurator.build(&block)
+      self
+    end
+
+    # Current configuration
+    #
+    # @since 0.1.0
+    def self.configuration
+      @configuration ||= Configuration.new(config)
+    end
+
+    # @since 0.7.0
+    # @api private
+    def self.repositories
+      @__repositories__
+    end
+
+    # @since 0.7.0
+    # @api private
+    def self.container
+      raise "Not loaded" unless loaded?
+
+      @container
+    end
+
+    # @since 0.1.0
+    def self.load!(&blk)
+      @container = configuration.load!(repositories, &blk)
+      @loaded    = true
+    end
+
+    # Disconnect from the database
+    #
+    # This is useful for rebooting applications in production and to ensure that
+    # the framework prunes stale connections.
+    #
+    # @since 1.0.0
+    #
+    # @example With Full Stack Hanami Project
+    #   # config/puma.rb
+    #   # ...
+    #   on_worker_boot do
+    #     Hanami.boot
+    #   end
+    #
+    # @example With Standalone Hanami::Model
+    #   # config/puma.rb
+    #   # ...
+    #   on_worker_boot do
+    #     Hanami::Model.disconnect
+    #     Hanami::Model.load!
+    #   end
+    def self.disconnect
+      configuration.connection&.disconnect
+    end
+  end
+end

model-main/lib/hanami/model/association.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "rom-sql"
+require "hanami/model/associations/belongs_to"
+require "hanami/model/associations/has_many"
+require "hanami/model/associations/has_one"
+require "hanami/model/associations/many_to_many"
+
+module Hanami
+  module Model
+    # Association factory
+    #
+    # @since 0.7.0
+    # @api private
+    class Association
+      # Instantiate an association
+      #
+      # @since 0.7.0
+      # @api private
+      def self.build(repository, target, subject)
+        lookup(repository.root.associations[target])
+          .new(repository, repository.root.name.to_sym, target, subject)
+      end
+
+      # Translate ROM SQL associations into Hanami::Model associations
+      #
+      # @since 0.7.0
+      # @api private
+      def self.lookup(association)
+        case association
+        when ROM::SQL::Association::ManyToMany
+          Associations::ManyToMany
+        when ROM::SQL::Association::OneToOne
+          Associations::HasOne
+        when ROM::SQL::Association::OneToMany
+          Associations::HasMany
+        when ROM::SQL::Association::ManyToOne
+          Associations::BelongsTo
+        else
+          raise "Unsupported association: #{association}"
+        end
+      end
+    end
+  end
+end

model-main/lib/hanami/model/associations/belongs_to.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require "hanami/model/types"
+
+module Hanami
+  module Model
+    module Associations
+      # Many-To-One association
+      #
+      # @since 1.1.0
+      # @api private
+      class BelongsTo
+        # @since 1.1.0
+        # @api private
+        def self.schema_type(entity)
+          Sql::Types::Schema::AssociationType.new(entity)
+        end
+
+        # @since 1.1.0
+        # @api private
+        attr_reader :repository
+
+        # @since 1.1.0
+        # @api private
+        attr_reader :source
+
+        # @since 1.1.0
+        # @api private
+        attr_reader :target
+
+        # @since 1.1.0
+        # @api private
+        attr_reader :subject
+
+        # @since 1.1.0
+        # @api private
+        attr_reader :scope
+
+        # @since 1.1.0
+        # @api private
+        def initialize(repository, source, target, subject, scope = nil)
+          @repository = repository
+          @source     = source
+          @target     = target
+          @subject    = subject.to_hash unless subject.nil?
+          @scope      = scope || _build_scope
+          freeze
+        end
+
+        # @since 1.1.0
+        # @api private
+        def one
+          scope.one
+        end
+
+        private
+
+        # @since 1.1.0
+        # @api private
+        def container
+          repository.container
+        end
+
+        # @since 1.1.0
+        # @api private
+        def primary_key
+          association_keys.first
+        end
+
+        # @since 1.1.0
+        # @api private
+        def relation(name)
+          repository.relations[Hanami::Utils::String.pluralize(name)]
+        end
+
+        # @since 1.1.0
+        # @api private
+        def foreign_key
+          association_keys.last
+        end
+
+        # Returns primary key and foreign key
+        #
+        # @since 1.1.0
+        # @api private
+        def association_keys
+          association
+            .__send__(:join_key_map, container.relations)
+        end
+
+        # Return the ROM::Associations for the source relation
+        #
+        # @since 1.1.9
+        # @api private
+        def association
+          relation(source).associations[target]
+        end
+
+        # @since 1.1.0
+        # @api private
+        def _build_scope
+          result = relation(association.target.to_sym)
+          result = result.where(foreign_key => subject.fetch(primary_key)) unless subject.nil?
+          result.as(Model::MappedRelation.mapper_name)
+        end
+      end
+    end
+  end
+end

model-main/lib/hanami/model/associations/dsl.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Hanami
+  module Model
+    module Associations
+      # Auto-infer relations linked to repository's associations
+      #
+      # @since 0.7.0
+      # @api private
+      #
+      class Dsl
+        # @since 0.7.0
+        # @api private
+        def initialize(repository, &blk)
+          @repository = repository
+          instance_eval(&blk)
+        end
+
+        # @since 0.7.0
+        # @api private
+        def has_many(relation, **args)
+          @repository.__send__(:relations, relation)
+          @repository.__send__(:relations, args[:through]) if args[:through]
+        end
+
+        # @since 1.1.0
+        # @api private
+        def has_one(relation, *)
+          @repository.__send__(:relations, Hanami::Utils::String.pluralize(relation).to_sym)
+        end
+
+        # @since 1.1.0
+        # @api private
+        def belongs_to(relation, *)
+          @repository.__send__(:relations, Hanami::Utils::String.pluralize(relation).to_sym)
+        end
+      end
+    end
+  end
+end

model-main/lib/hanami/model/associations/has_many.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+require "hanami/model/types"
+
+module Hanami
+  module Model
+    module Associations
+      # One-To-Many association
+      #
+      # @since 0.7.0
+      # @api private
+      class HasMany
+        # @since 0.7.0
+        # @api private
+        def self.schema_type(entity)
+          type = Sql::Types::Schema::AssociationType.new(entity)
+          Types::Strict::Array.member(type)
+        end
+
+        # @since 0.7.0
+        # @api private
+        attr_reader :repository
+
+        # @since 0.7.0
+        # @api private
+        attr_reader :source
+
+        # @since 0.7.0
+        # @api private
+        attr_reader :target
+
+        # @since 0.7.0
+        # @api private
+        attr_reader :subject
+
+        # @since 0.7.0
+        # @api private
+        attr_reader :scope
+
+        # @since 0.7.0
+        # @api private
+        def initialize(repository, source, target, subject, scope = nil)
+          @repository = repository
+          @source     = source
+          @target     = target
+          @subject    = subject.to_hash unless subject.nil?
+          @scope      = scope || _build_scope
+          freeze
+        end
+
+        # @since 0.7.0
+        # @api private
+        def create(data)
+          entity.new(command(:create, aggregate(target), mapper: nil, use: [:timestamps])
+            .call(serialize(data)))
+        rescue => exception
+          raise Hanami::Model::Error.for(exception)
+        end
+
+        # @since 0.7.0
+        # @api private
+        def add(data)
+          command(:create, relation(target), use: [:timestamps])
+            .call(associate(serialize(data)))
+        rescue => exception
+          raise Hanami::Model::Error.for(exception)
+        end
+
+        # @since 0.7.0
+        # @api private
+        def remove(id)
+          command(:update, relation(target), use: [:timestamps])
+            .by_pk(id)
+            .call(unassociate)
+        end
+
+        # @since 0.7.0
+        # @api private
+        def delete
+          scope.delete
+        end
+
+        # @since 0.7.0
+        # @api private
+        def each(&blk)
+          scope.each(&blk)
+        end
+
+        # @since 0.7.0
+        # @api private
+        def map(&blk)
+          to_a.map(&blk)
+        end
+
+        # @since 0.7.0
+        # @api private
+        def to_a
+          scope.to_a
+        end
+
+        # @since 0.7.0
+        # @api private
+        def where(condition)
+          __new__(scope.where(condition))
+        end
+
+        # @since 0.7.0
+        # @api private
+        def count
+          scope.count
+        end
+
+        private
+
+        # @since 0.7.0
+        # @api private
+        def command(target, relation, options = {})
+          repository.command(target, relation, options)
+        end
+
+        # @since 0.7.0
+        # @api private
+        def entity
+          repository.class.entity
+        end
+
+        # @since 0.7.0
+        # @api private
+        def relation(name)
+          repository.relations[name]
+        end
+
+        # @since 0.7.0
+        # @api private
+        def aggregate(name)
+          repository.aggregate(name)
+        end
+
+        # @since 0.7.0
+        # @api private
+        def association(name)
+          relation(target).associations[name]
+        end
+
+        # @since 0.7.0
+        # @api private
+        def associate(data)
+          relation(source)
+            .associations[target]
+            .associate(container.relations, data, subject)
+        end
+
+        # @since 0.7.0
+        # @api private
+        def unassociate
+          {foreign_key => nil}
+        end
+
+        # @since 0.7.0
+        # @api private
+        def container
+          repository.container
+        end
+
+        # @since 0.7.0
+        # @api private
+        def primary_key
+          association_keys.first
+        end
+
+        # @since 0.7.0
+        # @api private
+        def foreign_key
+          association_keys.last
+        end
+
+        # Returns primary key and foreign key
+        #
+        # @since 0.7.0
+        # @api private
+        def association_keys
+          target_association
+            .__send__(:join_key_map, container.relations)
+        end
+
+        # Returns the targeted association for a given source
+        #
+        # @since 0.7.0
+        # @api private
+        def target_association
+          relation(source).associations[target]
+        end
+
+        # @since 0.7.0
+        # @api private
+        def _build_scope
+          result = relation(target_association.target.to_sym)
+          result = result.where(foreign_key => subject.fetch(primary_key)) unless subject.nil?
+          result.as(Model::MappedRelation.mapper_name)
+        end
+
+        # @since 0.7.0
+        # @api private
+        def __new__(new_scope)
+          self.class.new(repository, source, target, subject, new_scope)
+        end
+
+        def serialize(data)
+          Utils::Hash.deep_serialize(data)
+        end
+      end
+    end
+  end
+end

model-main/lib/hanami/model/associations/has_one.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+require "hanami/utils/hash"
+
+module Hanami
+  module Model
+    module Associations
+      # Many-To-One association
+      #
+      # @since 1.1.0
+      # @api private
+      class HasOne
+        # @since 1.1.0
+        # @api private
+        def self.schema_type(entity)
+          Sql::Types::Schema::AssociationType.new(entity)
+        end
+        #
+        # @since 1.1.0
+        # @api private
+        attr_reader :repository
+
+        # @since 1.1.0
+        # @api private
+        attr_reader :source
+
+        # @since 1.1.0
+        # @api private
+        attr_reader :target
+
+        # @since 1.1.0
+        # @api private
+        attr_reader :subject
+
+        # @since 1.1.0
+        # @api private
+        attr_reader :scope
+
+        # @since 1.1.0
+        # @api private
+        def initialize(repository, source, target, subject, scope = nil)
+          @repository = repository
+          @source     = source
+          @target     = target
+          @subject    = subject.to_hash unless subject.nil?
+          @scope      = scope || _build_scope
+          freeze
+        end
+
+        def one
+          scope.one
+        end
+
+        def create(data)
+          entity.new(
+            command(:create, aggregate(target), mapper: nil).call(serialize(data))
+          )
+        rescue => exception
+          raise Hanami::Model::Error.for(exception)
+        end
+
+        def add(data)
+          command(:create, relation(target), mapper: nil).call(associate(serialize(data)))
+        rescue => exception
+          raise Hanami::Model::Error.for(exception)
+        end
+
+        def update(data)
+          command(:update, relation(target), mapper: nil)
+            .by_pk(
+              one.public_send(relation(target).primary_key)
+            ).call(serialize(data))
+        rescue => exception
+          raise Hanami::Model::Error.for(exception)
+        end
+
+        def delete
+          scope.delete
+        end
+        alias_method :remove, :delete
+
+        def replace(data)
+          repository.transaction do
+            delete
+            add(serialize(data))
+          end
+        end
+
+        private
+
+        # @since 1.1.0
+        # @api private
+        def entity
+          repository.class.entity
+        end
+
+        # @since 1.1.0
+        # @api private
+        def aggregate(name)
+          repository.aggregate(name)
+        end
+
+        # @since 1.1.0
+        # @api private
+        def command(target, relation, options = {})
+          repository.command(target, relation, options)
+        end
+
+        # @since 1.1.0
+        # @api private
+        def relation(name)
+          repository.relations[Hanami::Utils::String.pluralize(name)]
+        end
+
+        # @since 1.1.0
+        # @api private
+        def container
+          repository.container
+        end
+
+        # @since 1.1.0
+        # @api private
+        def primary_key
+          association_keys.first
+        end
+
+        # @since 1.1.0
+        # @api private
+        def foreign_key
+          association_keys.last
+        end
+
+        # @since 1.1.0
+        # @api private
+        def associate(data)
+          relation(source)
+            .associations[target]
+            .associate(container.relations, data, subject)
+        end
+
+        # Returns primary key and foreign key
+        #
+        # @since 1.1.0
+        # @api private
+        def association_keys
+          relation(source)
+            .associations[target]
+            .__send__(:join_key_map, container.relations)
+        end
+
+        # @since 1.1.0
+        # @api private
+        def _build_scope
+          result = relation(target)
+          result = result.where(foreign_key => subject.fetch(primary_key)) unless subject.nil?
+          result.as(Model::MappedRelation.mapper_name)
+        end
+
+        # @since 1.1.0
+        # @api private
+        def serialize(data)
+          Utils::Hash.deep_serialize(data)
+        end
+      end
+    end
+  end
+end

model-main/lib/hanami/model/associations/many_to_many.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+require "hanami/utils/hash"
+
+module Hanami
+  module Model
+    module Associations
+      # Many-To-Many association
+      #
+      # @since 0.7.0
+      # @api private
+      class ManyToMany
+        # @since 0.7.0
+        # @api private
+        def self.schema_type(entity)
+          type = Sql::Types::Schema::AssociationType.new(entity)
+          Types::Strict::Array.member(type)
+        end
+
+        # @since 1.1.0
+        # @api private
+        attr_reader :repository
+
+        # @since 1.1.0
+        # @api private
+        attr_reader :source
+
+        # @since 1.1.0
+        # @api private
+        attr_reader :target
+
+        # @since 1.1.0
+        # @api private
+        attr_reader :subject
+
+        # @since 1.1.0
+        # @api private
+        attr_reader :scope
+
+        # @since 1.1.0
+        # @api private
+        attr_reader :through
+
+        def initialize(repository, source, target, subject, scope = nil)
+          @repository = repository
+          @source     = source
+          @target     = target
+          @subject    = subject.to_hash unless subject.nil?
+          @through    = relation(source).associations[target].through.to_sym
+          @scope      = scope || _build_scope
+          freeze
+        end
+
+        def to_a
+          scope.to_a
+        end
+
+        def map(&blk)
+          to_a.map(&blk)
+        end
+
+        def each(&blk)
+          scope.each(&blk)
+        end
+
+        def count
+          scope.count
+        end
+
+        def where(condition)
+          __new__(scope.where(condition))
+        end
+
+        # Return the association table object. Would need an aditional query to return the entity
+        #
+        # @since 1.1.0
+        # @api private
+        def add(*data)
+          command(:create, relation(through), use: [:timestamps])
+            .call(associate(serialize(data)))
+        rescue => exception
+          raise Hanami::Model::Error.for(exception)
+        end
+
+        # @since 1.1.0
+        # @api private
+        def delete
+          relation(through).where(source_foreign_key => subject.fetch(source_primary_key)).delete
+        end
+
+        # @since 1.1.0
+        # @api private
+        def remove(target_id)
+          association_record = relation(through)
+            .where(target_foreign_key => target_id, source_foreign_key => subject.fetch(source_primary_key))
+            .one
+
+          return if association_record.nil?
+
+          ar_id = association_record.public_send relation(through).primary_key
+          command(:delete, relation(through)).by_pk(ar_id).call
+        end
+
+        private
+
+        # @since 1.1.0
+        # @api private
+        def container
+          repository.container
+        end
+
+        # @since 1.1.0
+        # @api private
+        def relation(name)
+          repository.relations[name]
+        end
+
+        # @since 1.1.0
+        # @api private
+        def command(target, relation, options = {})
+          repository.command(target, relation, options)
+        end
+
+        # @since 1.1.0
+        # @api private
+        def associate(data)
+          relation(target)
+            .associations[source]
+            .associate(container.relations, data, subject)
+        end
+
+        # @since 1.1.0
+        # @api private
+        def source_primary_key
+          association_keys[0].first
+        end
+
+        # @since 1.1.0
+        # @api private
+        def source_foreign_key
+          association_keys[0].last
+        end
+
+        # @since 1.1.0
+        # @api private
+        def association_keys
+          relation(source)
+            .associations[target]
+            .__send__(:join_key_map, container.relations)
+        end
+
+        # @since 1.1.0
+        # @api private
+        def target_foreign_key
+          association_keys[1].first
+        end
+
+        # @since 1.1.0
+        # @api private
+        def target_primary_key
+          association_keys[1].last
+        end
+
+        # Return the ROM::Associations for the source relation
+        #
+        # @since 1.1.0
+        # @api private
+        def association
+          relation(source).associations[target]
+        end
+
+        # @since 1.1.0
+        #
+        # @api private
+        def _build_scope
+          result = relation(association.target.to_sym).qualified
+          unless subject.nil?
+            result = result
+              .join(through, target_foreign_key => target_primary_key)
+              .where(source_foreign_key => subject.fetch(source_primary_key))
+          end
+          result.as(Model::MappedRelation.mapper_name)
+        end
+
+        # @since 1.1.0
+        # @api private
+        def __new__(new_scope)
+          self.class.new(repository, source, target, subject, new_scope)
+        end
+
+        # @since 1.1.0
+        # @api private
+        def serialize(data)
+          data.map do |d|
+            Utils::Hash.deep_serialize(d)
+          end
+        end
+      end
+    end
+  end
+end

model-main/lib/hanami/model/configuration.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+require "rom/configuration"
+
+module Hanami
+  module Model
+    # Configuration for the framework, models and adapters.
+    #
+    # Hanami::Model has its own global configuration that can be manipulated
+    # via `Hanami::Model.configure`.
+    #
+    # @since 0.2.0
+    class Configuration
+      # @since 0.7.0
+      # @api private
+      attr_reader :mappings
+
+      # @since 0.7.0
+      # @api private
+      attr_reader :entities
+
+      # @since 1.0.0
+      # @api private
+      attr_reader :logger
+
+      # @since 1.0.0
+      # @api private
+      attr_reader :migrations_logger
+
+      # @since 0.2.0
+      # @api private
+      def initialize(configurator)
+        @backend = configurator.backend
+        @url = configurator.url
+        @migrations = configurator._migrations
+        @schema = configurator._schema
+        @gateway_config = configurator._gateway
+        @logger = configurator._logger
+        @migrations_logger = configurator.migrations_logger
+        @mappings = {}
+        @entities = {}
+      end
+
+      # NOTE: This must be changed when we want to support several adapters at the time
+      #
+      # @since 0.7.0
+      # @api private
+      attr_reader :url
+
+      # NOTE: This must be changed when we want to support several adapters at the time
+      #
+      # @raise [Hanami::Model::UnknownDatabaseAdapterError] if `url` is blank,
+      #   or it uses an unknown adapter.
+      #
+      # @since 0.7.0
+      # @api private
+      def connection
+        gateway.connection
+      end
+
+      # NOTE: This must be changed when we want to support several adapters at the time
+      #
+      # @raise [Hanami::Model::UnknownDatabaseAdapterError] if `url` is blank,
+      #   or it uses an unknown adapter.
+      #
+      # @since 0.7.0
+      # @api private
+      def gateway
+        gateways[:default]
+      end
+
+      # Root directory
+      #
+      # @since 0.4.0
+      # @api private
+      def root
+        Hanami.respond_to?(:root) ? Hanami.root : Pathname.pwd
+      end
+
+      # Migrations directory
+      #
+      # @since 0.4.0
+      def migrations
+        (@migrations.nil? ? root : root.join(@migrations)).realpath
+      end
+
+      # Path for schema dump file
+      #
+      # @since 0.4.0
+      def schema
+        @schema.nil? ? root : root.join(@schema)
+      end
+
+      # @since 0.7.0
+      # @api private
+      def define_mappings(root, &blk)
+        @mappings[root] = Mapping.new(&blk)
+      end
+
+      # @since 0.7.0
+      # @api private
+      def register_entity(plural, singular, klass)
+        @entities[plural]   = klass
+        @entities[singular] = klass
+      end
+
+      # @since 0.7.0
+      # @api private
+      def define_entities_mappings(container, repositories)
+        return unless defined?(Sql::Entity::Schema)
+
+        repositories.each do |r|
+          relation = r.relation
+          entity   = r.entity
+
+          entity.schema = Sql::Entity::Schema.new(entities, container.relations[relation], mappings.fetch(relation))
+        end
+      end
+
+      # @since 1.0.0
+      # @api private
+      def configure_gateway
+        @gateway_config&.call(gateway)
+      end
+
+      # @since 1.0.0
+      # @api private
+      def logger=(value)
+        return if value.nil?
+
+        gateway.use_logger(@logger = value)
+      end
+
+      # @raise [Hanami::Model::UnknownDatabaseAdapterError] if `url` is blank,
+      #   or it uses an unknown adapter.
+      #
+      # @since 1.0.0
+      # @api private
+      def rom
+        @rom ||= ROM::Configuration.new(@backend, @url, infer_relations: false)
+      rescue => exception
+        raise UnknownDatabaseAdapterError.new(@url) if exception.message =~ /adapters/
+
+        raise exception
+      end
+
+      # @raise [Hanami::Model::UnknownDatabaseAdapterError] if `url` is blank,
+      #   or it uses an unknown adapter.
+      #
+      # @since 1.0.0
+      # @api private
+      def load!(repositories, &blk)
+        rom.setup.auto_registration(config.directory.to_s) unless config.directory.nil?
+        rom.instance_eval(&blk)                            if     block_given?
+        configure_gateway
+        repositories.each(&:load!)
+        self.logger = logger
+
+        container = ROM.container(rom)
+        define_entities_mappings(container, repositories)
+        container
+      rescue => exception
+        raise Hanami::Model::Error.for(exception)
+      end
+
+      # @since 1.0.0
+      # @api private
+      def method_missing(method_name, *args, &blk)
+        if rom.respond_to?(method_name)
+          rom.__send__(method_name, *args, &blk)
+        else
+          super
+        end
+      end
+
+      # @since 1.1.0
+      # @api private
+      def respond_to_missing?(method_name, include_all)
+        rom.respond_to?(method_name, include_all)
+      end
+    end
+  end
+end

model-main/lib/hanami/model/configurator.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Hanami
+  module Model
+    # Configuration DSL
+    #
+    # @since 0.7.0
+    # @api private
+    class Configurator
+      # @since 0.7.0
+      # @api private
+      attr_reader :backend
+
+      # @since 0.7.0
+      # @api private
+      attr_reader :url
+
+      # @since 0.7.0
+      # @api private
+      attr_reader :directory
+
+      # @since 0.7.0
+      # @api private
+      attr_reader :_migrations
+
+      # @since 0.7.0
+      # @api private
+      attr_reader :_schema
+
+      # @since 1.0.0
+      # @api private
+      attr_reader :_logger
+
+      # @since 1.0.0
+      # @api private
+      attr_reader :_gateway
+
+      # @since 0.7.0
+      # @api private
+      def self.build(&block)
+        new.tap { |config| config.instance_eval(&block) }
+      end
+
+      # @since 1.0.0
+      # @api private
+      def migrations_logger(stream = $stdout)
+        require "hanami/model/migrator/logger"
+        @migrations_logger ||= Hanami::Model::Migrator::Logger.new(stream)
+      end
+
+      private
+
+      # @since 0.7.0
+      # @api private
+      def adapter(backend, url)
+        @backend = backend
+        @url = url
+      end
+
+      # @since 0.7.0
+      # @api private
+      def path(path)
+        @directory = path
+      end
+
+      # @since 0.7.0
+      # @api private
+      def migrations(path)
+        @_migrations = path
+      end
+
+      # @since 0.7.0
+      # @api private
+      def schema(path)
+        @_schema = path
+      end
+
+      # @since 1.0.0
+      # @api private
+      def logger(stream, options = {})
+        require "hanami/logger"
+
+        opts = options.merge(stream: stream)
+        @_logger = Hanami::Logger.new("hanami.model", **opts)
+      end
+
+      # @since 1.0.0
+      # @api private
+      def gateway(&blk)
+        @_gateway = blk
+      end
+    end
+  end
+end

model-main/lib/hanami/model/entity_name.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Hanami
+  module Model
+    # Conventional name for entities.
+    #
+    # Given a repository named <tt>SourceFileRepository</tt>, the associated
+    # entity will be <tt>SourceFile</tt>.
+    #
+    # @since 0.7.0
+    # @api private
+    class EntityName
+      # @since 0.7.0
+      # @api private
+      SUFFIX = /Repository\z/.freeze
+
+      # @param name [Class,String] the class or its name
+      # @return [String] the entity name
+      #
+      # @since 0.7.0
+      # @api private
+      def initialize(name)
+        @name = name.sub(SUFFIX, "")
+      end
+
+      # @since 0.7.0
+      # @api private
+      def underscore
+        Utils::String.underscore(@name).to_sym
+      end
+
+      # @since 0.7.0
+      # @api private
+      def to_s
+        @name
+      end
+    end
+  end
+end

model-main/lib/hanami/model/error.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require "concurrent"
+
+module Hanami
+  module Model
+    # Default Error class
+    #
+    # @since 0.5.1
+    class Error < ::StandardError
+      # @api private
+      # @since 0.7.0
+      @__mapping__ = Concurrent::Map.new
+
+      # @api private
+      # @since 0.7.0
+      def self.for(exception)
+        mapping.fetch(exception.class, self).new(exception)
+      end
+
+      # @api private
+      # @since 0.7.0
+      def self.register(external, internal)
+        mapping.put_if_absent(external, internal)
+      end
+
+      # @api private
+      # @since 0.7.0
+      def self.mapping
+        @__mapping__
+      end
+    end
+
+    # Generic database error
+    #
+    # @since 0.7.0
+    class DatabaseError < Error
+    end
+
+    # Error for invalid raw command syntax
+    #
+    # @since 0.5.0
+    class InvalidCommandError < Error
+      # @since 0.5.0
+      # @api private
+      def initialize(message = "Invalid command")
+        super
+      end
+    end
+
+    # Error for Constraint Violation
+    #
+    # @since 0.7.0
+    class ConstraintViolationError < Error
+      # @since 0.7.0
+      # @api private
+      def initialize(message = "Constraint has been violated")
+        super
+      end
+    end
+
+    # Error for Unique Constraint Violation
+    #
+    # @since 0.6.1
+    class UniqueConstraintViolationError < ConstraintViolationError
+      # @since 0.6.1
+      # @api private
+      def initialize(message = "Unique constraint has been violated")
+        super
+      end
+    end
+
+    # Error for Foreign Key Constraint Violation
+    #
+    # @since 0.6.1
+    class ForeignKeyConstraintViolationError < ConstraintViolationError
+      # @since 0.6.1
+      # @api private
+      def initialize(message = "Foreign key constraint has been violated")
+        super
+      end
+    end
+
+    # Error for Not Null Constraint Violation
+    #
+    # @since 0.6.1
+    class NotNullConstraintViolationError < ConstraintViolationError
+      # @since 0.6.1
+      # @api private
+      def initialize(message = "NOT NULL constraint has been violated")
+        super
+      end
+    end
+
+    # Error for Check Constraint Violation raised by Sequel
+    #
+    # @since 0.6.1
+    class CheckConstraintViolationError < ConstraintViolationError
+      # @since 0.6.1
+      # @api private
+      def initialize(message = "Check constraint has been violated")
+        super
+      end
+    end
+
+    # Unknown database type error for repository auto-mapping
+    #
+    # @since 1.0.0
+    class UnknownDatabaseTypeError < Error
+    end
+
+    # Unknown primary key error
+    #
+    # @since 1.0.0
+    class MissingPrimaryKeyError < Error
+    end
+
+    # Unknown attribute error
+    #
+    # @since 1.2.0
+    class UnknownAttributeError < Error
+    end
+
+    # Unknown database adapter error
+    #
+    # @since 1.2.1
+    class UnknownDatabaseAdapterError < Error
+      def initialize(url)
+        super("Unknown database adapter for URL: #{url.inspect}. Please check your database configuration (hint: ENV['DATABASE_URL']).")
+      end
+    end
+  end
+end

model-main/lib/hanami/model/mapped_relation.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Hanami
+  module Model
+    # Mapped proxy for ROM relations.
+    #
+    # It eliminates the need to use #as for repository queries
+    #
+    # @since 1.0.0
+    # @api private
+    class MappedRelation < SimpleDelegator
+      # Mapper name.
+      #
+      # 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>.
+      #
+      # @since 1.0.0
+      # @api private
+      MAPPER_NAME = :entity
+
+      # @since 1.0.0
+      # @api private
+      def self.mapper_name
+        MAPPER_NAME
+      end
+
+      # @since 1.0.0
+      # @api private
+      def initialize(relation)
+        @relation = relation
+        super(relation.as(self.class.mapper_name))
+      end
+
+      # Access low level relation's attribute
+      #
+      # @param attribute [Symbol] the attribute name
+      #
+      # @return [ROM::SQL::Attribute] the attribute
+      #
+      # @raise [Hanami::Model::UnknownAttributeError] if the attribute cannot be found
+      #
+      # @since 1.2.0
+      #
+      # @example
+      #   class UserRepository < Hanami::Repository
+      #     def by_matching_name(name)
+      #       users
+      #         .where(users[:name].ilike(name))
+      #         .map_to(User)
+      #         .to_a
+      #     end
+      #   end
+      def [](attribute)
+        @relation[attribute]
+      rescue KeyError => exception
+        raise UnknownAttributeError.new(exception.message)
+      end
+    end
+  end
+end

model-main/lib/hanami/model/mapping.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "transproc/all"
+
+module Hanami
+  module Model
+    # Mapping
+    #
+    # @since 0.1.0
+    # @api private
+    class Mapping
+      extend Transproc::Registry
+
+      import Transproc::HashTransformations
+
+      # @since 0.1.0
+      # @api private
+      def initialize(&blk)
+        @attributes   = {}
+        @r_attributes = {}
+        instance_eval(&blk)
+        @processor = @attributes.empty? ? ::Hash : t(:rename_keys, @attributes)
+      end
+
+      # @api private
+      def t(name, *args)
+        self.class[name, *args]
+      end
+
+      # @api private
+      def model(entity)
+      end
+
+      # @api private
+      def register_as(name)
+      end
+
+      # @api private
+      def attribute(name, options)
+        from = options.fetch(:from, name)
+
+        @attributes[name]   = from
+        @r_attributes[from] = name
+      end
+
+      # @api private
+      def process(input)
+        @processor[input]
+      end
+
+      # @api private
+      def reverse?
+        @r_attributes.any?
+      end
+
+      # @api private
+      def translate(attribute)
+        @r_attributes.fetch(attribute)
+      end
+    end
+  end
+end

model-main/lib/hanami/model/migration.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Hanami
+  module Model
+    # Database migration
+    #
+    # @since 0.7.0
+    # @api private
+    class Migration
+      # @since 0.7.0
+      # @api private
+      attr_reader :gateway
+
+      # @since 0.7.0
+      # @api private
+      attr_reader :migration
+
+      # @since 0.7.0
+      # @api private
+      def initialize(gateway, &block)
+        @gateway = gateway
+        @migration = gateway.migration(&block)
+        freeze
+      end
+
+      # @since 0.7.0
+      # @api private
+      def run(direction = :up)
+        migration.apply(gateway.connection, direction)
+      end
+    end
+  end
+end

model-main/lib/hanami/model/migrator.rb

@@ -0,0 +1,394 @@
+# frozen_string_literal: true
+
+require "sequel"
+require "sequel/extensions/migration"
+
+module Hanami
+  module Model
+    # Migration error
+    #
+    # @since 0.4.0
+    class MigrationError < Hanami::Model::Error
+    end
+
+    # Database schema migrator
+    #
+    # @since 0.4.0
+    class Migrator
+      require "hanami/model/migrator/connection"
+      require "hanami/model/migrator/adapter"
+
+      # Create database defined by current configuration.
+      #
+      # It's only implemented for the following databases:
+      #
+      #   * SQLite3
+      #   * PostgreSQL
+      #   * MySQL
+      #
+      # @raise [Hanami::Model::MigrationError] if an error occurs
+      #
+      # @since 0.4.0
+      #
+      # @see Hanami::Model::Configuration#adapter
+      #
+      # @example
+      #   require 'hanami/model'
+      #   require 'hanami/model/migrator'
+      #
+      #   Hanami::Model.configure do
+      #     # ...
+      #     adapter :sql, 'postgres://localhost/foo'
+      #   end
+      #
+      #   Hanami::Model::Migrator.create # Creates `foo' database
+      #
+      # NOTE: Class level interface SHOULD be removed in Hanami 2.0
+      def self.create
+        new.create
+      end
+
+      # Drop database defined by current configuration.
+      #
+      # It's only implemented for the following databases:
+      #
+      #   * SQLite3
+      #   * PostgreSQL
+      #   * MySQL
+      #
+      # @raise [Hanami::Model::MigrationError] if an error occurs
+      #
+      # @since 0.4.0
+      #
+      # @see Hanami::Model::Configuration#adapter
+      #
+      # @example
+      #   require 'hanami/model'
+      #   require 'hanami/model/migrator'
+      #
+      #   Hanami::Model.configure do
+      #     # ...
+      #     adapter :sql, 'postgres://localhost/foo'
+      #   end
+      #
+      #   Hanami::Model::Migrator.drop # Drops `foo' database
+      #
+      # NOTE: Class level interface SHOULD be removed in Hanami 2.0
+      def self.drop
+        new.drop
+      end
+
+      # Migrate database schema
+      #
+      # It's possible to migrate "down" by specifying a version
+      # (eg. <tt>"20150610133853"</tt>)
+      #
+      # @param version [String,NilClass] target version
+      #
+      # @raise [Hanami::Model::MigrationError] if an error occurs
+      #
+      # @since 0.4.0
+      #
+      # @see Hanami::Model::Configuration#adapter
+      # @see Hanami::Model::Configuration#migrations
+      # @see Hanami::Model::Configuration#rollback
+      #
+      # @example Migrate Up
+      #   require 'hanami/model'
+      #   require 'hanami/model/migrator'
+      #
+      #   Hanami::Model.configure do
+      #     # ...
+      #     adapter    :sql, 'postgres://localhost/foo'
+      #     migrations 'db/migrations'
+      #   end
+      #
+      #   # Reads all files from "db/migrations" and apply them
+      #   Hanami::Model::Migrator.migrate
+      #
+      # @example Migrate Down
+      #   require 'hanami/model'
+      #   require 'hanami/model/migrator'
+      #
+      #   Hanami::Model.configure do
+      #     # ...
+      #     adapter    :sql, 'postgres://localhost/foo'
+      #     migrations 'db/migrations'
+      #   end
+      #
+      #   # Reads all files from "db/migrations" and apply them
+      #   Hanami::Model::Migrator.migrate
+      #
+      #   # Migrate to a specific version
+      #   Hanami::Model::Migrator.migrate(version: "20150610133853")
+      #
+      # NOTE: Class level interface SHOULD be removed in Hanami 2.0
+      def self.migrate(version: nil)
+        new.migrate(version: version)
+      end
+
+      # Rollback database schema
+      #
+      # @param steps [Number,NilClass] number of versions to rollback
+      #
+      # @raise [Hanami::Model::MigrationError] if an error occurs
+      #
+      # @since 1.1.0
+      #
+      # @see Hanami::Model::Configuration#adapter
+      # @see Hanami::Model::Configuration#migrations
+      # @see Hanami::Model::Configuration#migrate
+      #
+      # @example Rollback
+      #   require 'hanami/model'
+      #   require 'hanami/model/migrator'
+      #
+      #   Hanami::Model.configure do
+      #     # ...
+      #     adapter    :sql, 'postgres://localhost/foo'
+      #     migrations 'db/migrations'
+      #   end
+      #
+      #   # Reads all files from "db/migrations" and apply them
+      #   Hanami::Model::Migrator.migrate
+      #
+      #   # By default only rollback one version
+      #   Hanami::Model::Migrator.rollback
+      #
+      #   # Use a hash passing a number of versions to rollback, it will rollbacks those versions
+      #   Hanami::Model::Migrator.rollback(versions: 2)
+      #
+      # NOTE: Class level interface SHOULD be removed in Hanami 2.0
+      def self.rollback(steps: 1)
+        new.rollback(steps: steps)
+      end
+
+      # Migrate, dump schema, delete migrations.
+      #
+      # This is an experimental feature.
+      # It may change or be removed in the future.
+      #
+      # Actively developed applications accumulate tons of migrations.
+      # In the long term they are hard to maintain and slow to execute.
+      #
+      # "Apply" feature solves this problem.
+      #
+      # It keeps an updated SQL file with the structure of the database.
+      # This file can be used to create fresh databases for developer machines
+      # or during testing. This is faster than to run dozen or hundred migrations.
+      #
+      # When we use "apply", it eliminates all the migrations that are no longer
+      # necessary.
+      #
+      # @raise [Hanami::Model::MigrationError] if an error occurs
+      #
+      # @since 0.4.0
+      #
+      # @see Hanami::Model::Configuration#adapter
+      # @see Hanami::Model::Configuration#migrations
+      #
+      # @example Apply Migrations
+      #   require 'hanami/model'
+      #   require 'hanami/model/migrator'
+      #
+      #   Hanami::Model.configure do
+      #     # ...
+      #     adapter    :sql, 'postgres://localhost/foo'
+      #     migrations 'db/migrations'
+      #     schema     'db/schema.sql'
+      #   end
+      #
+      #   # Reads all files from "db/migrations" and apply and delete them.
+      #   # It generates an updated version of "db/schema.sql"
+      #   Hanami::Model::Migrator.apply
+      #
+      # NOTE: Class level interface SHOULD be removed in Hanami 2.0
+      def self.apply
+        new.apply
+      end
+
+      # Prepare database: drop, create, load schema (if any), migrate.
+      #
+      # This is designed for development machines and testing mode.
+      # It works faster if used with <tt>apply</tt>.
+      #
+      # @raise [Hanami::Model::MigrationError] if an error occurs
+      #
+      # @since 0.4.0
+      #
+      # @see Hanami::Model::Migrator.apply
+      #
+      # @example Prepare Database
+      #   require 'hanami/model'
+      #   require 'hanami/model/migrator'
+      #
+      #   Hanami::Model.configure do
+      #     # ...
+      #     adapter    :sql, 'postgres://localhost/foo'
+      #     migrations 'db/migrations'
+      #   end
+      #
+      #   Hanami::Model::Migrator.prepare # => creates `foo' and runs migrations
+      #
+      # @example Prepare Database (with schema dump)
+      #   require 'hanami/model'
+      #   require 'hanami/model/migrator'
+      #
+      #   Hanami::Model.configure do
+      #     # ...
+      #     adapter    :sql, 'postgres://localhost/foo'
+      #     migrations 'db/migrations'
+      #     schema     'db/schema.sql'
+      #   end
+      #
+      #   Hanami::Model::Migrator.apply   # => updates schema dump
+      #   Hanami::Model::Migrator.prepare # => creates `foo', load schema and run pending migrations (if any)
+      #
+      # NOTE: Class level interface SHOULD be removed in Hanami 2.0
+      def self.prepare
+        new.prepare
+      end
+
+      # Return current database version timestamp
+      #
+      # If no migrations were ran, it returns <tt>nil</tt>.
+      #
+      # @return [String,NilClass] current version, if previously migrated
+      #
+      # @since 0.4.0
+      #
+      # @example
+      #   # Given last migrations is:
+      #   #  20150610133853_create_books.rb
+      #
+      #   Hanami::Model::Migrator.version # => "20150610133853"
+      #
+      # NOTE: Class level interface SHOULD be removed in Hanami 2.0
+      def self.version
+        new.version
+      end
+
+      # Instantiate a new migrator
+      #
+      # @param configuration [Hanami::Model::Configuration] framework configuration
+      #
+      # @return [Hanami::Model::Migrator] a new instance
+      #
+      # @since 0.7.0
+      # @api private
+      def initialize(configuration: self.class.configuration)
+        @configuration = configuration
+        @adapter       = Adapter.for(configuration)
+      end
+
+      # @since 0.7.0
+      # @api private
+      #
+      # @see Hanami::Model::Migrator.create
+      def create
+        adapter.create
+      end
+
+      # @since 0.7.0
+      # @api private
+      #
+      # @see Hanami::Model::Migrator.drop
+      def drop
+        adapter.drop
+      end
+
+      # @since 0.7.0
+      # @api private
+      #
+      # @see Hanami::Model::Migrator.migrate
+      def migrate(version: nil)
+        adapter.migrate(migrations, version) if migrations?
+      end
+
+      # @since 1.1.0
+      # @api private
+      #
+      # @see Hanami::Model::Migrator.rollback
+      def rollback(steps: 1)
+        adapter.rollback(migrations, steps.abs) if migrations?
+      end
+
+      # @since 0.7.0
+      # @api private
+      #
+      # @see Hanami::Model::Migrator.apply
+      def apply
+        migrate
+        adapter.dump
+        delete_migrations
+      end
+
+      # @since 0.7.0
+      # @api private
+      #
+      # @see Hanami::Model::Migrator.prepare
+      def prepare
+        drop
+      rescue # rubocop:disable Lint/SuppressedException
+      ensure
+        create
+        adapter.load
+        migrate
+      end
+
+      # @since 0.7.0
+      # @api private
+      #
+      # @see Hanami::Model::Migrator.version
+      def version
+        adapter.version
+      end
+
+      # Hanami::Model configuration
+      #
+      # @since 0.4.0
+      # @api private
+      def self.configuration
+        Model.configuration
+      end
+
+      private
+
+      # @since 0.7.0
+      # @api private
+      attr_reader :configuration
+
+      # @since 0.7.0
+      # @api private
+      attr_reader :connection
+
+      # @since 0.7.0
+      # @api private
+      attr_reader :adapter
+
+      # Migrations directory
+      #
+      # @since 0.7.0
+      # @api private
+      def migrations
+        configuration.migrations
+      end
+
+      # Check if there are migrations
+      #
+      # @since 0.7.0
+      # @api private
+      def migrations?
+        Dir["#{migrations}/*.rb"].any?
+      end
+
+      # Delete all the migrations
+      #
+      # @since 0.7.0
+      # @api private
+      def delete_migrations
+        migrations.each_child(&:delete)
+      end
+    end
+  end
+end

model-main/lib/hanami/model/migrator/adapter.rb

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+require "uri"
+require "shellwords"
+require "open3"
+
+module Hanami
+  module Model
+    class Migrator
+      # Migrator base adapter
+      #
+      # @since 0.4.0
+      # @api private
+      class Adapter
+        # Migrations table to store migrations metadata.
+        #
+        # @since 0.4.0
+        # @api private
+        MIGRATIONS_TABLE = :schema_migrations
+
+        # Migrations table version column
+        #
+        # @since 0.4.0
+        # @api private
+        MIGRATIONS_TABLE_VERSION_COLUMN = :filename
+
+        # Loads and returns a specific adapter for the given connection.
+        #
+        # @since 0.4.0
+        # @api private
+        def self.for(configuration)
+          connection = Connection.new(configuration)
+
+          case connection.database_type
+          when :sqlite
+            require "hanami/model/migrator/sqlite_adapter"
+            SQLiteAdapter
+          when :postgres
+            require "hanami/model/migrator/postgres_adapter"
+            PostgresAdapter
+          when :mysql
+            require "hanami/model/migrator/mysql_adapter"
+            MySQLAdapter
+          else
+            self
+          end.new(connection)
+        end
+
+        # Initialize an adapter
+        #
+        # @since 0.4.0
+        # @api private
+        def initialize(connection)
+          @connection = connection
+        end
+
+        # Create database.
+        # It must be implemented by subclasses.
+        #
+        # @since 0.4.0
+        # @api private
+        #
+        # @see Hanami::Model::Migrator.create
+        def create
+          raise MigrationError.new("Current adapter (#{connection.database_type}) doesn't support create.")
+        end
+
+        # Drop database.
+        # It must be implemented by subclasses.
+        #
+        # @since 0.4.0
+        # @api private
+        #
+        # @see Hanami::Model::Migrator.drop
+        def drop
+          raise MigrationError.new("Current adapter (#{connection.database_type}) doesn't support drop.")
+        end
+
+        # @since 0.4.0
+        # @api private
+        def migrate(migrations, version)
+          version = Integer(version) unless version.nil?
+
+          Sequel::Migrator.run(connection.raw, migrations, target: version, allow_missing_migration_files: true)
+        rescue Sequel::Migrator::Error => exception
+          raise MigrationError.new(exception.message)
+        end
+
+        # @since 1.1.0
+        # @api private
+        def rollback(migrations, steps)
+          table = migrations_table_dataset
+          version = version_to_rollback(table, steps)
+
+          Sequel::Migrator.run(connection.raw, migrations, target: version, allow_missing_migration_files: true)
+        rescue Sequel::Migrator::Error => exception
+          raise MigrationError.new(exception.message)
+        end
+
+        # Load database schema.
+        # It must be implemented by subclasses.
+        #
+        # @since 0.4.0
+        # @api private
+        #
+        # @see Hanami::Model::Migrator.prepare
+        def load
+          raise MigrationError.new("Current adapter (#{connection.database_type}) doesn't support load.")
+        end
+
+        # Database version.
+        #
+        # @since 0.4.0
+        # @api private
+        def version
+          table = migrations_table_dataset
+          return if table.nil?
+
+          record = table.order(MIGRATIONS_TABLE_VERSION_COLUMN).last
+          return if record.nil?
+
+          record.fetch(MIGRATIONS_TABLE_VERSION_COLUMN).scan(MIGRATIONS_FILE_NAME_PATTERN).first.to_s
+        end
+
+        private
+
+        # @since 1.1.0
+        # @api private
+        MIGRATIONS_FILE_NAME_PATTERN = /\A[\d]{14}/.freeze
+
+        # @since 1.1.0
+        # @api private
+        def version_to_rollback(table, steps)
+          record = table.order(Sequel.desc(MIGRATIONS_TABLE_VERSION_COLUMN)).all[steps]
+          return 0 unless record
+
+          record.fetch(MIGRATIONS_TABLE_VERSION_COLUMN).scan(MIGRATIONS_FILE_NAME_PATTERN).first.to_i
+        end
+
+        # @since 1.1.0
+        # @api private
+        def migrations_table_dataset
+          connection.table(MIGRATIONS_TABLE)
+        end
+
+        # @since 0.5.0
+        # @api private
+        attr_reader :connection
+
+        # @since 0.4.0
+        # @api private
+        def schema
+          connection.schema
+        end
+
+        # Returns a database connection
+        #
+        # Given a DB connection URI we can connect to a specific database or not, we need this when creating
+        # or dropping a database. Important to notice that we can't always open a _global_ DB connection,
+        # because most of the times application's DB user has no rights to do so.
+        #
+        # @param global [Boolean] determine whether or not a connection should specify a database.
+        #
+        # @since 0.5.0
+        # @api private
+        def new_connection(global: false)
+          uri = global ? connection.global_uri : connection.uri
+
+          Sequel.connect(uri)
+        end
+
+        # @since 0.4.0
+        # @api private
+        def database
+          escape connection.database
+        end
+
+        # @since 0.4.0
+        # @api private
+        def port
+          escape connection.port
+        end
+
+        # @since 0.4.0
+        # @api private
+        def host
+          escape connection.host
+        end
+
+        # @since 0.4.0
+        # @api private
+        def username
+          escape connection.user
+        end
+
+        # @since 0.4.0
+        # @api private
+        def password
+          escape connection.password
+        end
+
+        # @since 0.4.0
+        # @api private
+        def migrations_table
+          escape MIGRATIONS_TABLE
+        end
+
+        # @since 0.4.0
+        # @api private
+        def escape(string)
+          Shellwords.escape(string) unless string.nil?
+        end
+
+        # @since 1.0.2
+        # @api private
+        def execute(command, env: {}, error: ->(err) { raise MigrationError.new(err) })
+          Open3.popen3(env, command) do |_, stdout, stderr, wait_thr|
+            error.call(stderr.read) unless wait_thr.value.success?
+            yield stdout if block_given?
+          end
+        end
+      end
+    end
+  end
+end

model-main/lib/hanami/model/migrator/connection.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+require "cgi"
+
+module Hanami
+  module Model
+    class Migrator
+      # Sequel connection wrapper
+      #
+      # Normalize external adapters interfaces
+      #
+      # @since 0.5.0
+      # @api private
+      class Connection
+        # @since 0.5.0
+        # @api private
+        def initialize(configuration)
+          @configuration = configuration
+        end
+
+        # @since 0.7.0
+        # @api private
+        def raw
+          @raw ||= begin
+                     Sequel.connect(
+                       configuration.url,
+                       loggers: [configuration.migrations_logger]
+                     )
+                   rescue Sequel::AdapterNotFound
+                     raise MigrationError.new("Current adapter (#{configuration.adapter.type}) doesn't support SQL database operations.")
+                   end
+        end
+
+        # Returns DB connection host
+        #
+        # Even when adapter doesn't provide it explicitly it tries to parse
+        #
+        # @since 0.5.0
+        # @api private
+        def host
+          @host ||= parsed_uri.host || parsed_opt("host")
+        end
+
+        # Returns DB connection port
+        #
+        # Even when adapter doesn't provide it explicitly it tries to parse
+        #
+        # @since 0.5.0
+        # @api private
+        def port
+          @port ||= parsed_uri.port || parsed_opt("port").to_i.nonzero?
+        end
+
+        # Returns DB name from conenction
+        #
+        # Even when adapter doesn't provide it explicitly it tries to parse
+        #
+        # @since 0.5.0
+        # @api private
+        def database
+          @database ||= parsed_uri.path[1..-1]
+        end
+
+        # Returns DB type
+        #
+        # @example
+        #   connection.database_type
+        #     # => 'postgres'
+        #
+        # @since 0.5.0
+        # @api private
+        def database_type
+          case uri
+          when /sqlite/
+            :sqlite
+          when /postgres/
+            :postgres
+          when /mysql/
+            :mysql
+          end
+        end
+
+        # Returns user from DB connection
+        #
+        # Even when adapter doesn't provide it explicitly it tries to parse
+        #
+        # @since 0.5.0
+        # @api private
+        def user
+          @user ||= parsed_opt("user") || parsed_uri.user
+        end
+
+        # Returns user from DB connection
+        #
+        # Even when adapter doesn't provide it explicitly it tries to parse
+        #
+        # @since 0.5.0
+        # @api private
+        def password
+          @password ||= parsed_opt("password") || parsed_uri.password
+        end
+
+        # Returns DB connection URI directly from adapter
+        #
+        # @since 0.5.0
+        # @api private
+        def uri
+          @configuration.url
+        end
+
+        # Returns DB connection wihout specifying database name
+        #
+        # @since 0.5.0
+        # @api private
+        def global_uri
+          uri.sub(parsed_uri.select(:path).first, "")
+        end
+
+        # Returns a boolean telling if a DB connection is from JDBC or not
+        #
+        # @since 0.5.0
+        # @api private
+        def jdbc?
+          !uri.scan("jdbc:").empty?
+        end
+
+        # Returns database connection URI instance without JDBC namespace
+        #
+        # @since 0.5.0
+        # @api private
+        def parsed_uri
+          @parsed_uri ||= URI.parse(uri.sub("jdbc:", ""))
+        end
+
+        # @api private
+        def schema
+          configuration.schema
+        end
+
+        # Return the database table for the given name
+        #
+        # @since 0.7.0
+        # @api private
+        def table(name)
+          raw[name] if raw.tables.include?(name)
+        end
+
+        private
+
+        # @since 1.0.0
+        # @api private
+        attr_reader :configuration
+
+        # Returns a value of a given query string param
+        #
+        # @param option [String] which option from database connection will be extracted from URI
+        #
+        # @since 0.5.0
+        # @api private
+        def parsed_opt(option, query: parsed_uri.query)
+          return if query.nil?
+
+          @parsed_query_opts ||= CGI.parse(query)
+          @parsed_query_opts[option].to_a.last
+        end
+      end
+    end
+  end
+end

model-main/lib/hanami/model/migrator/logger.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "hanami/logger"
+
+module Hanami
+  module Model
+    class Migrator
+      # Automatic logger for migrations
+      #
+      # @since 1.0.0
+      # @api private
+      class Logger < Hanami::Logger
+        # Formatter for migrations logger
+        #
+        # @since 1.0.0
+        # @api private
+        class Formatter < Hanami::Logger::Formatter
+          private
+
+          # @since 1.0.0
+          # @api private
+          def _format(hash)
+            "[hanami] [#{hash.fetch(:severity)}] #{hash.fetch(:message)}\n"
+          end
+        end
+
+        # @since 1.0.0
+        # @api private
+        def initialize(stream)
+          super(nil, stream: stream, formatter: Formatter.new)
+        end
+      end
+    end
+  end
+end

model-main/lib/hanami/model/migrator/mysql_adapter.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Hanami
+  module Model
+    class Migrator
+      # MySQL adapter
+      #
+      # @since 0.4.0
+      # @api private
+      class MySQLAdapter < Adapter
+        # @since 0.7.0
+        # @api private
+        PASSWORD = "MYSQL_PWD"
+
+        # @since 1.3.3
+        # @api private
+        DEFAULT_PORT = 3306
+
+        # @since 1.0.0
+        # @api private
+        DB_CREATION_ERROR = "Database creation failed. If the database exists, " \
+                            "then its console may be open. See this issue for more details: " \
+                            "https://github.com/hanami/model/issues/250"
+
+        # @since 0.4.0
+        # @api private
+        def create
+          new_connection(global: true).run %(CREATE DATABASE `#{database}`;)
+        rescue Sequel::DatabaseError => exception
+          message = if exception.message.match(/database exists/)
+                      DB_CREATION_ERROR
+                    else
+                      exception.message
+                    end
+
+          raise MigrationError.new(message)
+        end
+
+        # @since 0.4.0
+        # @api private
+        def drop
+          new_connection(global: true).run %(DROP DATABASE `#{database}`;)
+        rescue Sequel::DatabaseError => exception
+          message = if exception.message.match(/doesn\'t exist/)
+                      "Cannot find database: #{database}"
+                    else
+                      exception.message
+                    end
+
+          raise MigrationError.new(message)
+        end
+
+        # @since 0.4.0
+        # @api private
+        def dump
+          dump_structure
+          dump_migrations_data
+        end
+
+        # @since 0.4.0
+        # @api private
+        def load
+          load_structure
+        end
+
+        private
+
+        # @since 0.7.0
+        # @api private
+        def password
+          connection.password
+        end
+
+        def port
+          super || DEFAULT_PORT
+        end
+
+        # @since 0.4.0
+        # @api private
+        def dump_structure
+          execute "mysqldump --host=#{host} --port=#{port} --user=#{username} --no-data --skip-comments --ignore-table=#{database}.#{migrations_table} #{database} > #{schema}", env: {PASSWORD => password}
+        end
+
+        # @since 0.4.0
+        # @api private
+        def load_structure
+          execute("mysql --host=#{host} --port=#{port} --user=#{username} #{database} < #{escape(schema)}", env: {PASSWORD => password}) if schema.exist?
+        end
+
+        # @since 0.4.0
+        # @api private
+        def dump_migrations_data
+          execute "mysqldump --host=#{host} --port=#{port} --user=#{username} --skip-comments #{database} #{migrations_table} >> #{schema}", env: {PASSWORD => password}
+        end
+      end
+    end
+  end
+end

model-main/lib/hanami/model/migrator/postgres_adapter.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require "hanami/utils/blank"
+
+module Hanami
+  module Model
+    class Migrator
+      # PostgreSQL adapter
+      #
+      # @since 0.4.0
+      # @api private
+      class PostgresAdapter < Adapter
+        # @since 0.4.0
+        # @api private
+        HOST     = "PGHOST"
+
+        # @since 0.4.0
+        # @api private
+        PORT     = "PGPORT"
+
+        # @since 0.4.0
+        # @api private
+        USER     = "PGUSER"
+
+        # @since 0.4.0
+        # @api private
+        PASSWORD = "PGPASSWORD"
+
+        # @since 1.0.0
+        # @api private
+        DB_CREATION_ERROR = "createdb: database creation failed. If the database exists, " \
+                            "then its console may be open. See this issue for more details: " \
+                            "https://github.com/hanami/model/issues/250"
+
+        # @since 0.4.0
+        # @api private
+        def create
+          call_db_command("createdb")
+        end
+
+        # @since 0.4.0
+        # @api private
+        def drop
+          call_db_command("dropdb")
+        end
+
+        # @since 0.4.0
+        # @api private
+        def dump
+          dump_structure
+          dump_migrations_data
+        end
+
+        # @since 0.4.0
+        # @api private
+        def load
+          load_structure
+        end
+
+        private
+
+        # @since 1.3.3
+        # @api private
+        def environment_variables
+          {}.tap do |env|
+            env[HOST] = host unless host.nil?
+            env[PORT] = port.to_s unless port.nil?
+            env[PASSWORD] = password unless password.nil?
+            env[USER] = username unless username.nil?
+          end
+        end
+
+        # @since 0.4.0
+        # @api private
+        def dump_structure
+          execute "pg_dump -s -x -O -T #{migrations_table} -f #{escape(schema)} #{database}", env: environment_variables
+        end
+
+        # @since 0.4.0
+        # @api private
+        def load_structure
+          return unless schema.exist?
+
+          execute "psql -X -q -f #{escape(schema)} #{database}", env: environment_variables
+        end
+
+        # @since 0.4.0
+        # @api private
+        def dump_migrations_data
+          error = ->(err) { raise MigrationError.new(err) unless err =~ /no matching tables/i }
+          execute "pg_dump -t #{migrations_table} #{database} >> #{escape(schema)}", error: error, env: environment_variables
+        end
+
+        # @since 0.5.1
+        # @api private
+        def call_db_command(command)
+          require "open3"
+
+          begin
+            Open3.popen3(environment_variables, command, database) do |_stdin, _stdout, stderr, wait_thr|
+              raise MigrationError.new(modified_message(stderr.read)) unless wait_thr.value.success? # wait_thr.value is the exit status
+            end
+          rescue SystemCallError => exception
+            raise MigrationError.new(modified_message(exception.message))
+          end
+        end
+
+        # @since 1.1.0
+        # @api private
+        def modified_message(original_message)
+          case original_message
+          when /already exists/
+            DB_CREATION_ERROR
+          when /does not exist/
+            "Cannot find database: #{database}"
+          when /No such file or directory/
+            "Could not find executable in your PATH: `#{original_message.split.last}`"
+          else
+            original_message
+          end
+        end
+      end
+    end
+  end
+end

model-main/lib/hanami/model/migrator/sqlite_adapter.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "hanami/utils"
+require "English"
+
+module Hanami
+  module Model
+    class Migrator
+      # SQLite3 Migrator
+      #
+      # @since 0.4.0
+      # @api private
+      class SQLiteAdapter < Adapter
+        # No-op for in-memory databases
+        #
+        # @since 0.4.0
+        # @api private
+        module Memory
+          # @since 0.4.0
+          # @api private
+          def create
+          end
+
+          # @since 0.4.0
+          # @api private
+          def drop
+          end
+        end
+
+        # Initialize adapter
+        #
+        # @since 0.4.0
+        # @api private
+        def initialize(configuration)
+          super
+          extend Memory if memory?
+        end
+
+        # @since 0.4.0
+        # @api private
+        def create
+          path.dirname.mkpath
+          FileUtils.touch(path)
+        rescue Errno::EACCES, Errno::EPERM
+          raise MigrationError.new("Permission denied: #{path.sub(/\A\/\//, '')}")
+        end
+
+        # @since 0.4.0
+        # @api private
+        def drop
+          path.delete
+        rescue Errno::ENOENT
+          raise MigrationError.new("Cannot find database: #{path.sub(/\A\/\//, '')}")
+        end
+
+        # @since 0.4.0
+        # @api private
+        def dump
+          dump_structure
+          dump_migrations_data
+        end
+
+        # @since 0.4.0
+        # @api private
+        def load
+          load_structure
+        end
+
+        private
+
+        # @since 0.4.0
+        # @api private
+        def path
+          root.join(
+            @connection.uri.sub(/\A(jdbc:sqlite:\/\/|sqlite:\/\/)/, "")
+          )
+        end
+
+        # @since 0.4.0
+        # @api private
+        def root
+          Hanami::Model.configuration.root
+        end
+
+        # @since 0.4.0
+        # @api private
+        def memory?
+          uri = path.to_s
+          uri.match(/sqlite\:\/\z/) ||
+            uri.match(/\:memory\:/)
+        end
+
+        # @since 0.4.0
+        # @api private
+        def dump_structure
+          execute "sqlite3 #{escape(path)} .schema > #{escape(schema)}"
+        end
+
+        # @since 0.4.0
+        # @api private
+        def load_structure
+          execute "sqlite3 #{escape(path)} < #{escape(schema)}" if schema.exist?
+        end
+
+        # @since 0.4.0
+        # @api private
+        #
+        def dump_migrations_data
+          execute "sqlite3 #{escape(path)} .dump" do |stdout|
+            begin
+              contents = stdout.read.split($INPUT_RECORD_SEPARATOR)
+              contents = contents.grep(/^INSERT INTO "?#{migrations_table}"?/)
+
+              ::File.open(schema, ::File::CREAT | ::File::BINARY | ::File::WRONLY | ::File::APPEND) do |file|
+                file.write(contents.join($INPUT_RECORD_SEPARATOR))
+              end
+            rescue => exception
+              raise MigrationError.new(exception.message)
+            end
+          end
+        end
+      end
+    end
+  end
+end

model-main/lib/hanami/model/plugins.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Hanami
+  module Model
+    # Plugins to extend read/write operations from/to the database
+    #
+    # @since 0.7.0
+    # @api private
+    module Plugins
+      # Wrapping input
+      #
+      # @since 0.7.0
+      # @api private
+      class WrappingInput
+        # @since 0.7.0
+        # @api private
+        def initialize(_relation, input)
+          @input = input || Hash
+        end
+      end
+
+      require "hanami/model/plugins/mapping"
+      require "hanami/model/plugins/schema"
+      require "hanami/model/plugins/timestamps"
+    end
+  end
+end

model-main/lib/hanami/model/plugins/mapping.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Hanami
+  module Model
+    module Plugins
+      # Transform output into model domain types (entities).
+      #
+      # @since 0.7.0
+      # @api private
+      module Mapping
+        # Takes the output and applies the transformations
+        #
+        # @since 0.7.0
+        # @api private
+        class InputWithMapping < WrappingInput
+          # @since 0.7.0
+          # @api private
+          def initialize(relation, input)
+            super
+            @mapping = Hanami::Model.configuration.mappings[relation.name.to_sym]
+          end
+
+          # Processes the output
+          #
+          # @since 0.7.0
+          # @api private
+          def [](value)
+            @input[@mapping.process(value)]
+          end
+        end
+
+        # Class interface
+        #
+        # @since 0.7.0
+        # @api private
+        module ClassMethods
+          # Builds the output processor
+          #
+          # @since 0.7.0
+          # @api private
+          def build(relation, options = {})
+            wrapped_input = InputWithMapping.new(relation, options.fetch(:input) { input })
+            super(relation, options.merge(input: wrapped_input))
+          end
+        end
+
+        # @since 0.7.0
+        # @api private
+        def self.included(klass)
+          super
+
+          klass.extend ClassMethods
+        end
+      end
+    end
+  end
+end

model-main/lib/hanami/model/plugins/schema.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Hanami
+  module Model
+    module Plugins
+      # Transform input values into database specific types (primitives).
+      #
+      # @since 0.7.0
+      # @api private
+      module Schema
+        # Takes the input and applies the values transformations.
+        #
+        # @since 0.7.0
+        # @api private
+        class InputWithSchema < WrappingInput
+          # @since 0.7.0
+          # @api private
+          def initialize(relation, input)
+            super
+            @schema = relation.input_schema
+          end
+
+          # Processes the input
+          #
+          # @since 0.7.0
+          # @api private
+          def [](value)
+            @schema[@input[value]]
+          end
+        end
+
+        # Class interface
+        #
+        # @since 0.7.0
+        # @api private
+        module ClassMethods
+          # Builds the input processor
+          #
+          # @since 0.7.0
+          # @api private
+          def build(relation, options = {})
+            wrapped_input = InputWithSchema.new(relation, options.fetch(:input) { input })
+            super(relation, options.merge(input: wrapped_input))
+          end
+        end
+
+        # @since 0.7.0
+        # @api private
+        def self.included(klass)
+          super
+
+          klass.extend ClassMethods
+        end
+      end
+    end
+  end
+end

model-main/lib/hanami/model/plugins/timestamps.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Hanami
+  module Model
+    module Plugins
+      # Automatically set/update timestamp columns for create/update commands
+      #
+      # @since 0.7.0
+      # @api private
+      module Timestamps
+        # Takes the input and applies the timestamp transformation.
+        # This is an "abstract class", please look at the subclasses for
+        # specific behaviors.
+        #
+        # @since 0.7.0
+        # @api private
+        class InputWithTimestamp < WrappingInput
+          # Conventional timestamp names
+          #
+          # @since 0.7.0
+          # @api private
+          TIMESTAMPS = %i[created_at updated_at].freeze
+
+          # @since 0.7.0
+          # @api private
+          def initialize(relation, input)
+            super
+            @timestamps = relation.columns & TIMESTAMPS
+          end
+
+          # Processes the input
+          #
+          # @since 0.7.0
+          # @api private
+          def [](value)
+            return @input[value] unless timestamps?
+
+            _touch(@input[value], Time.now)
+          end
+
+          protected
+
+          # @since 0.7.0
+          # @api private
+          def _touch(_value)
+            raise NoMethodError
+          end
+
+          private
+
+          # @since 0.7.0
+          # @api private
+          def timestamps?
+            !@timestamps.empty?
+          end
+        end
+
+        # Updates <tt>updated_at</tt> timestamp for update commands
+        #
+        # @since 0.7.0
+        # @api private
+        class InputWithUpdateTimestamp < InputWithTimestamp
+          protected
+
+          # @since 0.7.0
+          # @api private
+          def _touch(value, now)
+            value[:updated_at] ||= now if @timestamps.include?(:updated_at)
+            value
+          end
+        end
+
+        # Sets <tt>created_at</tt> and <tt>updated_at</tt> timestamps for create commands
+        #
+        # @since 0.7.0
+        # @api private
+        class InputWithCreateTimestamp < InputWithUpdateTimestamp
+          protected
+
+          # @since 0.7.0
+          # @api private
+          def _touch(value, now)
+            super
+            value[:created_at] ||= now if @timestamps.include?(:created_at)
+            value
+          end
+        end
+
+        # Class interface
+        #
+        # @since 0.7.0
+        # @api private
+        module ClassMethods
+          # Build an input processor according to the current command (create or update).
+          #
+          # @since 0.7.0
+          # @api private
+          def build(relation, options = {})
+            plugin = if self < ROM::Commands::Create
+                       InputWithCreateTimestamp
+                     else
+                       InputWithUpdateTimestamp
+                     end
+
+            wrapped_input = plugin.new(relation, options.fetch(:input) { input })
+            super(relation, options.merge(input: wrapped_input))
+          end
+        end
+
+        # @since 0.7.0
+        # @api private
+        def self.included(klass)
+          super
+
+          klass.extend ClassMethods
+        end
+      end
+    end
+  end
+end

model-main/lib/hanami/model/relation_name.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative "entity_name"
+require "hanami/utils/string"
+
+module Hanami
+  module Model
+    # Conventional name for relations.
+    #
+    # Given a repository named <tt>SourceFileRepository</tt>, the associated
+    # relation will be <tt>:source_files</tt>.
+    #
+    # @since 0.7.0
+    # @api private
+    class RelationName < EntityName
+      # @param name [Class,String] the class or its name
+      # @return [String] the relation name
+      #
+      # @since 0.7.0
+      # @api private
+      def self.new(name)
+        Utils::String.transform(super, :underscore, :pluralize)
+      end
+    end
+  end
+end

model-main/lib/hanami/model/sql.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+require "rom-sql"
+require "hanami/utils"
+
+module Hanami
+  # Hanami::Model migrations
+  module Model
+    require "hanami/model/error"
+    require "hanami/model/association"
+    require "hanami/model/migration"
+
+    # Define a migration
+    #
+    # It must define an up/down strategy to write schema changes (up) and to
+    # rollback them (down).
+    #
+    # We can use <tt>up</tt> and <tt>down</tt> blocks for custom strategies, or
+    # only one <tt>change</tt> block that automatically implements "down" strategy.
+    #
+    # @param blk [Proc] a block that defines up/down or change database migration
+    #
+    # @since 0.4.0
+    #
+    # @example Use up/down blocks
+    #   Hanami::Model.migration do
+    #     up do
+    #       create_table :books do
+    #         primary_key :id
+    #         column :book, String
+    #       end
+    #     end
+    #
+    #     down do
+    #       drop_table :books
+    #     end
+    #   end
+    #
+    # @example Use change block
+    #   Hanami::Model.migration do
+    #     change do
+    #       create_table :books do
+    #         primary_key :id
+    #         column :book, String
+    #       end
+    #     end
+    #
+    #     # DOWN strategy is automatically generated
+    #   end
+    def self.migration(&blk)
+      Migration.new(configuration.gateways[:default], &blk)
+    end
+
+    # SQL adapter
+    #
+    # @since 0.7.0
+    module Sql
+      require "hanami/model/sql/types"
+      require "hanami/model/sql/entity/schema"
+
+      # Returns a SQL fragment that references a database function by the given name
+      # This is useful for database migrations
+      #
+      # @param name [String,Symbol] the function name
+      # @return [String] the SQL fragment
+      #
+      # @since 0.7.0
+      #
+      # @example
+      #   Hanami::Model.migration do
+      #     up do
+      #       execute 'CREATE EXTENSION IF NOT EXISTS "uuid-ossp"'
+      #
+      #       create_table :source_files do
+      #         column :id, 'uuid', primary_key: true, default: Hanami::Model::Sql.function(:uuid_generate_v4)
+      #         # ...
+      #       end
+      #     end
+      #
+      #     down do
+      #       drop_table :source_files
+      #       execute 'DROP EXTENSION "uuid-ossp"'
+      #     end
+      #   end
+      def self.function(name)
+        Sequel.function(name)
+      end
+
+      # Returns a literal SQL fragment for the given SQL fragment.
+      # This is useful for database migrations
+      #
+      # @param string [String] the SQL fragment
+      # @return [String] the literal SQL fragment
+      #
+      # @since 0.7.0
+      #
+      # @example
+      #   Hanami::Model.migration do
+      #     up do
+      #       execute %{
+      #         CREATE TYPE inventory_item AS (
+      #           name            text,
+      #           supplier_id     integer,
+      #           price           numeric
+      #         );
+      #       }
+      #
+      #       create_table :items do
+      #         column :item, 'inventory_item', default: Hanami::Model::Sql.literal("ROW('fuzzy dice', 42, 1.99)")
+      #         # ...
+      #       end
+      #     end
+      #
+      #     down do
+      #       drop_table :items
+      #       execute 'DROP TYPE inventory_item'
+      #     end
+      #   end
+      def self.literal(string)
+        Sequel.lit(string)
+      end
+
+      # Returns SQL fragment for ascending order for the given column
+      #
+      # @param column [Symbol] the column name
+      # @return [String] the SQL fragment
+      #
+      # @since 0.7.0
+      def self.asc(column)
+        Sequel.asc(column)
+      end
+
+      # Returns SQL fragment for descending order for the given column
+      #
+      # @param column [Symbol] the column name
+      # @return [String] the SQL fragment
+      #
+      # @since 0.7.0
+      def self.desc(column)
+        Sequel.desc(column)
+      end
+    end
+
+    Error.register(ROM::SQL::DatabaseError,             DatabaseError)
+    Error.register(ROM::SQL::ConstraintError,           ConstraintViolationError)
+    Error.register(ROM::SQL::NotNullConstraintError,    NotNullConstraintViolationError)
+    Error.register(ROM::SQL::UniqueConstraintError,     UniqueConstraintViolationError)
+    Error.register(ROM::SQL::CheckConstraintError,      CheckConstraintViolationError)
+    Error.register(ROM::SQL::ForeignKeyConstraintError, ForeignKeyConstraintViolationError)
+    Error.register(ROM::SQL::UnknownDBTypeError,        UnknownDatabaseTypeError)
+    Error.register(ROM::SQL::MissingPrimaryKeyError,    MissingPrimaryKeyError)
+
+    Error.register(Java::JavaSql::SQLException, DatabaseError) if Utils.jruby?
+  end
+end
+
+Sequel.default_timezone = :utc
+
+ROM.plugins do
+  adapter :sql do
+    register :mapping,    Hanami::Model::Plugins::Mapping,    type: :command
+    register :schema,     Hanami::Model::Plugins::Schema,     type: :command
+    register :timestamps, Hanami::Model::Plugins::Timestamps, type: :command
+  end
+end

model-main/lib/hanami/model/sql/console.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module Hanami
+  module Model
+    module Sql
+      # SQL console
+      #
+      # @since 0.7.0
+      # @api private
+      class Console
+        extend Forwardable
+
+        # @since 0.7.0
+        # @api private
+        def_delegator :console, :connection_string
+
+        # @since 0.7.0
+        # @api private
+        def initialize(uri)
+          @uri = URI.parse(uri)
+        end
+
+        private
+
+        # @since 0.7.0
+        # @api private
+        def console
+          case @uri.scheme
+          when "sqlite"
+            require "hanami/model/sql/consoles/sqlite"
+            Sql::Consoles::Sqlite.new(@uri)
+          when "postgres", "postgresql"
+            require "hanami/model/sql/consoles/postgresql"
+            Sql::Consoles::Postgresql.new(@uri)
+          when "mysql", "mysql2"
+            require "hanami/model/sql/consoles/mysql"
+            Sql::Consoles::Mysql.new(@uri)
+          end
+        end
+      end
+    end
+  end
+end

model-main/lib/hanami/model/sql/consoles/abstract.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Hanami
+  module Model
+    module Sql
+      module Consoles
+        # Abstract adapter
+        #
+        # @since 0.7.0
+        # @api private
+        class Abstract
+          # @since 0.7.0
+          # @api private
+          def initialize(uri)
+            @uri = uri
+          end
+
+          private
+
+          # @since 0.7.0
+          # @api private
+          def database_name
+            @uri.path.sub(/^\//, "")
+          end
+
+          # @since 0.7.0
+          # @api private
+          def concat(*tokens)
+            tokens.join
+          end
+        end
+      end
+    end
+  end
+end

model-main/lib/hanami/model/sql/consoles/mysql.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require_relative "abstract"
+
+module Hanami
+  module Model
+    module Sql
+      module Consoles
+        # MySQL adapter
+        #
+        # @since 0.7.0
+        # @api private
+        class Mysql < Abstract
+          # @since 0.7.0
+          # @api private
+          COMMAND = "mysql"
+
+          # @since 0.7.0
+          # @api private
+          def connection_string
+            concat(command, host, database, port, username, password)
+          end
+
+          private
+
+          # @since 0.7.0
+          # @api private
+          def command
+            COMMAND
+          end
+
+          # @since 0.7.0
+          # @api private
+          def host
+            " -h #{@uri.host}"
+          end
+
+          # @since 0.7.0
+          # @api private
+          def database
+            " -D #{database_name}"
+          end
+
+          # @since 0.7.0
+          # @api private
+          def port
+            " -P #{@uri.port}" unless @uri.port.nil?
+          end
+
+          # @since 0.7.0
+          # @api private
+          def username
+            " -u #{@uri.user}" unless @uri.user.nil?
+          end
+
+          # @since 0.7.0
+          # @api private
+          def password
+            " -p #{@uri.password}" unless @uri.password.nil?
+          end
+        end
+      end
+    end
+  end
+end

model-main/lib/hanami/model/sql/consoles/postgresql.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require_relative "abstract"
+require "cgi"
+
+module Hanami
+  module Model
+    module Sql
+      module Consoles
+        # PostgreSQL adapter
+        #
+        # @since 0.7.0
+        # @api private
+        class Postgresql < Abstract
+          # @since 0.7.0
+          # @api private
+          COMMAND = "psql"
+
+          # @since 0.7.0
+          # @api private
+          PASSWORD = "PGPASSWORD"
+
+          # @since 0.7.0
+          # @api private
+          def connection_string
+            configure_password
+            concat(command, host, database, port, username)
+          end
+
+          private
+
+          # @since 0.7.0
+          # @api private
+          def command
+            COMMAND
+          end
+
+          # @since 0.7.0
+          # @api private
+          def host
+            " -h #{query['host'] || @uri.host}"
+          end
+
+          # @since 0.7.0
+          # @api private
+          def database
+            " -d #{database_name}"
+          end
+
+          # @since 0.7.0
+          # @api private
+          def port
+            port = query["port"] || @uri.port
+            " -p #{port}" if port
+          end
+
+          # @since 0.7.0
+          # @api private
+          def username
+            username = query["user"] || @uri.user
+            " -U #{username}" if username
+          end
+
+          # @since 0.7.0
+          # @api private
+          def configure_password
+            password = query["password"] || @uri.password
+            ENV[PASSWORD] = CGI.unescape(query["password"] || @uri.password) if password
+          end
+
+          # @since 1.1.0
+          # @api private
+          def query
+            return {} if @uri.query.nil? || @uri.query.empty?
+
+            parsed_query = @uri.query.split("&").map { |a| a.split("=") }
+            @query ||= Hash[parsed_query]
+          end
+        end
+      end
+    end
+  end
+end

model-main/lib/hanami/model/sql/consoles/sqlite.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative "abstract"
+require "shellwords"
+
+module Hanami
+  module Model
+    module Sql
+      module Consoles
+        # SQLite adapter
+        #
+        # @since 0.7.0
+        # @api private
+        class Sqlite < Abstract
+          # @since 0.7.0
+          # @api private
+          COMMAND = "sqlite3"
+
+          # @since 0.7.0
+          # @api private
+          def connection_string
+            concat(command, " ", host, database)
+          end
+
+          private
+
+          # @since 0.7.0
+          # @api private
+          def command
+            COMMAND
+          end
+
+          # @since 0.7.0
+          # @api private
+          def host
+            @uri.host unless @uri.host.nil?
+          end
+
+          # @since 0.7.0
+          # @api private
+          def database
+            Shellwords.escape(@uri.path)
+          end
+        end
+      end
+    end
+  end
+end

model-main/lib/hanami/model/sql/entity/schema.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require "hanami/entity/schema"
+require "hanami/model/types"
+require "hanami/model/association"
+
+module Hanami
+  module Model
+    module Sql
+      module Entity
+        # SQL Entity schema
+        #
+        # This schema setup is automatic.
+        #
+        # Hanami looks at the database columns, associations and potentially to
+        # the mapping in the repository (optional, only for legacy databases).
+        #
+        # @since 0.7.0
+        # @api private
+        #
+        # @see Hanami::Entity::Schema
+        class Schema < Hanami::Entity::Schema
+          # Build a new instance of Schema according to database columns,
+          # associations and potentially to mapping defined by the repository.
+          #
+          # @param registry [Hash] a registry that keeps reference between
+          #   entities class and their underscored names
+          # @param relation [ROM::Relation] the database relation
+          # @param mapping [Hanami::Model::Mapping] the optional repository
+          #   mapping
+          #
+          # @return [Hanami::Model::Sql::Entity::Schema] the schema
+          #
+          # @since 0.7.0
+          # @api private
+          def initialize(registry, relation, mapping)
+            attributes  = build(registry, relation, mapping)
+            @schema     = Types::Coercible::Hash.schema(attributes)
+            @attributes = Hash[attributes.map { |k, _| [k, true] }]
+            freeze
+          end
+
+          # Process attributes
+          #
+          # @param attributes [#to_hash] the attributes hash
+          #
+          # @raise [TypeError] if the process fails
+          #
+          # @since 1.0.1
+          # @api private
+          def call(attributes)
+            schema.call(attributes)
+          end
+
+          # @since 1.0.1
+          # @api private
+          alias_method :[], :call
+
+          # Check if the attribute is known
+          #
+          # @param name [Symbol] the attribute name
+          #
+          # @return [TrueClass,FalseClass] the result of the check
+          #
+          # @since 0.7.0
+          # @api private
+          def attribute?(name)
+            attributes.key?(name)
+          end
+
+          private
+
+          # @since 0.7.0
+          # @api private
+          attr_reader :attributes
+
+          # Build the schema
+          #
+          # @param registry [Hash] a registry that keeps reference between
+          #   entities class and their underscored names
+          # @param relation [ROM::Relation] the database relation
+          # @param mapping [Hanami::Model::Mapping] the optional repository
+          #   mapping
+          #
+          # @return [Dry::Types::Constructor] the inner schema
+          #
+          # @since 0.7.0
+          # @api private
+          def build(registry, relation, mapping)
+            build_attributes(relation, mapping).merge(
+              build_associations(registry, relation.associations)
+            )
+          end
+
+          # Extract a set of attributes from the database table or from the
+          # optional repository mapping.
+          #
+          # @param relation [ROM::Relation] the database relation
+          # @param mapping [Hanami::Model::Mapping] the optional repository
+          #   mapping
+          #
+          # @return [Hash] a set of attributes
+          #
+          # @since 0.7.0
+          # @api private
+          def build_attributes(relation, mapping)
+            schema = relation.schema.to_h
+            schema.each_with_object({}) do |(attribute, type), result|
+              attribute = mapping.translate(attribute) if mapping.reverse?
+              result[attribute] = coercible(type)
+            end
+          end
+
+          # Merge attributes and associations
+          #
+          # @param registry [Hash] a registry that keeps reference between
+          #   entities class and their underscored names
+          # @param associations [ROM::AssociationSet] a set of associations for
+          #   the current relation
+          #
+          # @return [Hash] attributes with associations
+          #
+          # @since 0.7.0
+          # @api private
+          def build_associations(registry, associations)
+            associations.each_with_object({}) do |(name, association), result|
+              target       = registry.fetch(association.target.to_sym)
+              result[name] = Association.lookup(association).schema_type(target)
+            end
+          end
+
+          # Converts given ROM type into coercible type for entity attribute
+          #
+          # @since 0.7.0
+          # @api private
+          def coercible(type)
+            Types::Schema.coercible(type)
+          end
+        end
+      end
+    end
+  end
+end

model-main/lib/hanami/model/sql/types.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require "hanami/model/types"
+require "rom/types"
+
+module Hanami
+  module Model
+    module Sql
+      # Types definitions for SQL databases
+      #
+      # @since 0.7.0
+      module Types
+        include Dry::Types.module
+
+        # Types for schema definitions
+        #
+        # @since 0.7.0
+        module Schema
+          require "hanami/model/sql/types/schema/coercions"
+
+          String   = Types::Optional::Coercible::String
+
+          Int      = Types::Strict::Nil | Types::Int.constructor(Coercions.method(:int))
+          Float    = Types::Strict::Nil | Types::Float.constructor(Coercions.method(:float))
+          Decimal  = Types::Strict::Nil | Types::Float.constructor(Coercions.method(:decimal))
+
+          Bool     = Types::Strict::Nil | Types::Strict::Bool
+
+          Date     = Types::Strict::Nil | Types::Date.constructor(Coercions.method(:date))
+          DateTime = Types::Strict::Nil | Types::DateTime.constructor(Coercions.method(:datetime))
+          Time     = Types::Strict::Nil | Types::Time.constructor(Coercions.method(:time))
+
+          Array    = Types::Strict::Nil | Types::Array.constructor(Coercions.method(:array))
+          Hash     = Types::Strict::Nil | Types::Hash.constructor(Coercions.method(:hash))
+
+          PG_JSON  = Types::Strict::Nil | Types::Any.constructor(Coercions.method(:pg_json))
+
+          # @since 0.7.0
+          # @api private
+          MAPPING = {
+            Types::String.pristine => Schema::String,
+            Types::Int.pristine => Schema::Int,
+            Types::Float.pristine => Schema::Float,
+            Types::Decimal.pristine => Schema::Decimal,
+            Types::Bool.pristine => Schema::Bool,
+            Types::Date.pristine => Schema::Date,
+            Types::DateTime.pristine => Schema::DateTime,
+            Types::Time.pristine => Schema::Time,
+            Types::Array.pristine => Schema::Array,
+            Types::Hash.pristine => Schema::Hash,
+            Types::String.optional.pristine => Schema::String,
+            Types::Int.optional.pristine => Schema::Int,
+            Types::Float.optional.pristine => Schema::Float,
+            Types::Decimal.optional.pristine => Schema::Decimal,
+            Types::Bool.optional.pristine => Schema::Bool,
+            Types::Date.optional.pristine => Schema::Date,
+            Types::DateTime.optional.pristine => Schema::DateTime,
+            Types::Time.optional.pristine => Schema::Time,
+            Types::Array.optional.pristine => Schema::Array,
+            Types::Hash.optional.pristine => Schema::Hash
+          }.freeze
+
+          # Convert given type into coercible
+          #
+          # @since 0.7.0
+          # @api private
+          def self.coercible(attribute)
+            return attribute if attribute.constrained?
+
+            type      = attribute.type
+            unwrapped = type.optional? ? type.right : type
+
+            # NOTE: In the future rom-sql should be able to always return Ruby
+            # types instead of Sequel types. When that will happen we can get
+            # rid of this logic in the block and fall back to:
+            #
+            #  MAPPING.fetch(unwrapped.pristine, attribute)
+            MAPPING.fetch(unwrapped.pristine) do
+              if pg_json?(unwrapped.pristine)
+                Schema::PG_JSON
+              else
+                attribute
+              end
+            end
+          end
+
+          # @since 1.0.4
+          # @api private
+          def self.pg_json_pristines
+            @pg_json_pristines ||= ::Hash.new do |hash, type|
+              hash[type] = (ROM::SQL::Types::PG.const_get(type).pristine if defined?(ROM::SQL::Types::PG))
+            end
+          end
+
+          # @since 1.0.2
+          # @api private
+          def self.pg_json?(pristine)
+            pristine == pg_json_pristines["JSONB"] || # rubocop:disable Style/MultipleComparison
+              pristine == pg_json_pristines["JSON"]
+          end
+
+          private_class_method :pg_json?
+
+          # Coercer for SQL associations target
+          #
+          # @since 0.7.0
+          # @api private
+          class AssociationType < Hanami::Model::Types::Schema::CoercibleType
+            # Check if value can be coerced
+            #
+            # @param value [Object] the value
+            #
+            # @return [TrueClass,FalseClass] the result of the check
+            #
+            # @since 0.7.0
+            # @api private
+            def valid?(value)
+              value.inspect =~ /\[#{primitive}\]/ || super
+            end
+
+            # @since 0.7.0
+            # @api private
+            def success(*args)
+              result(Dry::Types::Result::Success, primitive.new(args.first.to_h))
+            end
+          end
+        end
+      end
+    end
+  end
+end