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.container(: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

#initializeRepository

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


111
112
113
114
# File 'lib/rom/repository.rb', line 111

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

Instance Attribute Details

#auto_structBoolean (readonly)

Returns The container used to set up a repo.

Returns:

  • (Boolean)

    The container used to set up a repo


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

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

#containerROM::Container (readonly)

Returns The container used to set up a repo.

Returns:


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

option :container, allow: ROM::Container

#relationsObject (readonly)


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

def relations
  @relations
end

#struct_namespaceModule, Class (readonly)

Returns The namespace for auto-generated structs.

Returns:

  • (Module, Class)

    The namespace for auto-generated structs


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

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_structObject

Get or set struct namespace


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

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_readerRelationReader

Get or set relation reader module

Returns:


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

defines :relation_reader

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

Instance Method Details

#inspectString

Return a string representation of a repository object

Returns:

  • (String)

161
162
163
# File 'lib/rom/repository.rb', line 161

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


152
153
154
# File 'lib/rom/repository.rb', line 152

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