Class: ROM::Repository

Inherits:
Object
  • Object
show all
Extended by:
Dry::Core::Cache, Dry::Core::ClassAttributes, Initializer, ClassInterface
Defined in:
lib/rom/repository.rb,
lib/rom/repository/root.rb,
lib/rom/repository/class_interface.rb,
lib/rom/repository/relation_reader.rb

Overview

Abstract repository class to inherit from

A repository provides access to composable relations and commands. Its job is to provide application-specific data that is already materialized, so that relations don't leak into your application layer.

Typically, you're going to work with Repository::Root that is configured to use a single relation as its root, and compose aggregates and use changesets and commands against the root relation.

Examples:

rom = ROM.setup(:sql, 'sqlite::memory') do |conf|
  conf.default.create_table(:users) do
    primary_key :id
    column :name, String
  end

  conf.default.create_table(:tasks) do
    primary_key :id
    column :user_id, Integer
    column :title, String
  end

  conf.relation(:users) do
    associations do
      has_many :tasks
    end
  end
end

class UserRepo < ROM::Repository[:users]
  def users_with_tasks
    aggregate(:tasks).to_a
  end
end

user_repo = UserRepo.new(rom)
user_repo.users_with_tasks

See Also:

Direct Known Subclasses

Root

Defined Under Namespace

Modules: ClassInterface Classes: RelationReader, Root

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize ⇒ Repository

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Initializes a new repository object



106
107
108
109
 
# File 'lib/rom/repository.rb', line 106

def initialize(*)
  super
  @relations = {}
end

Instance Attribute Details

#auto_struct ⇒ Boolean (readonly)

Returns The container used to set up a repo.

Returns:

  • (Boolean) —

    The container used to set up a repo



97
 
# File 'lib/rom/repository.rb', line 97

option :auto_struct, default: -> { self.class.auto_struct }

#container ⇒ ROM::Container (readonly)

Returns The container used to set up a repo.

Returns:



89
 
# File 'lib/rom/repository.rb', line 89

option :container, allow: ROM::Container

#relations ⇒ Object (readonly) 



101
102
103
 
# File 'lib/rom/repository.rb', line 101

def relations
  @relations
end

#struct_namespace ⇒ Module, Class (readonly)

Returns The namespace for auto-generated structs.

Returns:

  • (Module, Class) —

    The namespace for auto-generated structs



93
 
# File 'lib/rom/repository.rb', line 93

option :struct_namespace, default: -> { self.class.struct_namespace }

Class Method Details

.[](name) ⇒ Class Originally defined in module ClassInterface

Create a root-repository class and set its root relation

Examples:

# where :users is the relation name in your rom container
class UserRepo < ROM::Repository[:users]
end

Parameters:

  • name (Symbol) —

    The relation register_as value

Returns:

  • (Class) —

    descendant of ROM::Repository::Root

.auto_struct ⇒ Object

Get or set struct namespace



72
 
# File 'lib/rom/repository.rb', line 72

defines :auto_struct

.commands(*names, mapper: nil, use: nil, plugins_options: EMPTY_HASH, **opts) ⇒ Array<Symbol> Originally defined in module ClassInterface

Defines command methods on a root repository

Examples:

class UserRepo < ROM::Repository[:users]
  commands :create, update: :by_pk, delete: :by_pk
end

# with custom command plugin
class UserRepo < ROM::Repository[:users]
  commands :create, use: :my_command_plugin
end

# with custom mapper
class UserRepo < ROM::Repository[:users]
  commands :create, mapper: :my_custom_mapper
end

Parameters:

  • names (Array<Symbol>) —

    A list of command names

  • :mapper (Hash) —

    a customizable set of options

  • :use (Hash) —

    a customizable set of options

Returns:

  • (Array<Symbol>) —

    A list of defined command names

.inherited(klass) ⇒ Object Originally defined in module ClassInterface

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Inherits configured relations and commands

#new(container, **options) ⇒ Object #new(**options) ⇒ Object Originally defined in module ClassInterface

Initialize a new repository object, establishing configured relation proxies from the passed container

Overloads:

  • #new(container, **options) ⇒ Object

    Initialize with container as leading parameter

    Parameters:

    • container (ROM::Container) —

      Finalized rom container

    • options (Hash) —

      Repository options

    Options Hash (**options):

    • :struct_namespace (Module) —

      Custom struct namespace

    • :auto_struct (Boolean) —

      Enable/Disable auto-struct mapping

  • #new(**options) ⇒ Object

    Inititalize with container as option

    Parameters:

    • options (Hash) —

      Repository options

    Options Hash (**options):

    • :container (ROM::Container) —

      Finalized rom container

    • :struct_namespace (Module) —

      Custom struct namespace

    • :auto_struct (Boolean) —

      Enable/Disable auto-struct mapping

.relation_reader ⇒ RelationReader

Get or set relation reader module

Returns:



83
 
# File 'lib/rom/repository.rb', line 83

defines :relation_reader

.use(plugin, **options) ⇒ Object Originally defined in module ClassInterface

Instance Method Details

#inspect ⇒ String

Return a string representation of a repository object

Returns:

  • (String) 


156
157
158
 
# File 'lib/rom/repository.rb', line 156

def inspect
  %(#<#{self.class} struct_namespace=#{struct_namespace} auto_struct=#{auto_struct}>)
end

#transaction(gateway: :default, **opts, &block) ⇒ Object

Open a database transaction

Examples:

commited transaction

user = transaction do |t|
  create(changeset(name: 'Jane'))
end

user
# => #<ROM::Struct::User id=1 name="Jane">

with a rollback

user = transaction do |t|
  changeset(name: 'Jane').commit
  t.rollback!
end

user
# nil

with automatic savepoints

user = transaction(auto_savepoint: true) do
  create(changeset(name: 'Jane'))

  transaction do |t|
    update(changeset(name: 'John'))
    t.rollback!
  end
end

user
# => #<ROM::Struct::User id=1 name="Jane">

Parameters:

  • gateway (Hash) (defaults to: :default) —

    a customizable set of options

Options Hash (gateway:):

  • gateway (Symbol) —

    key. For Repository::Root descendants it's taken from the root relation



147
148
149
 
# File 'lib/rom/repository.rb', line 147

def transaction(gateway: :default, **opts, &block)
  container.gateways[gateway].transaction(**opts, &block)
end