cuprum-collections 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 78622fdeb8107cc8df27120e104a7b4ab1239569f8677b648b3462b36b4c008c
-  data.tar.gz: 0ca7eeb33a33d477888851d1a515b9e0c7cae3dc80a7a85f5455747ea1275ddc
+  metadata.gz: dda6613af3def3463515616a0b448dce3ce0fb666b6b81b9c9d54cf9e4f6bef0
+  data.tar.gz: e8cae0cd8e96daf887268b0b467352d34a7a93357729c14115375f7d14d2e2d8
 SHA512:
-  metadata.gz: 40a8281d4232bf7e8e78450d99dde47089dbbc039c7f7c689c579d98bf22d3069e3e9c0f3066ebca1d4ce292fb170738f5ed71afb8b49a875648333d81523f08
-  data.tar.gz: fc9c9d23db953377b34397a89fdd4098e170b1b2db3f84261562c473d932e881dbcc92237d5fb53a8b819a722bef5d89f545418fca9e527e8dfc0271c4aacd3c
+  metadata.gz: 138cf1bd095d6d03e196c90ac4779ee6d8dec8743f8cb321c4114117c707ef0124f378642653beef0e3db1c0d127cebd05967a4356ce5361cd3294bd298642e7
+  data.tar.gz: 968b185b8e1b0447b55acc093387ad527e0ba5154b0e4a24d2ace52cf258ca29939eefa0cc772451703d1b56286dce907c84402a735a360152d3573ea8cb5db7

data/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## 0.3.0
+
+### Collections
+
+Updated `Cuprum::Collections::Basic::Collection`.
+
+- Implemented `#count` method.
+- Implemented `#qualified_name` method.
+
+### Commands
+
+Implemented built-in Commands, which take a `:collection` parameter:
+
+- `Commands::Create`
+- `Commands::FindOneMatching`
+- `Commands::Update`
+- `Commands::Upsert`
+
 ## 0.2.0
 
 Implemented `Cuprum::Collections::Repository`.

data/README.md

@@ -26,7 +26,7 @@ The Ruby ecosystem has a wide variety of tools and libraries for managing data a
 
 ### Compatibility
 
-Cuprum::Collections is tested against Ruby (MRI) 2.6 through 2.7.
+Cuprum::Collections is tested against Ruby (MRI) 2.7 through 3.2.
 
 ### Documentation
 
@@ -34,9 +34,9 @@ Documentation is generated using [YARD](https://yardoc.org/), and can be generat
 
 ### License
 
-Copyright (c) 2020-2021 Rob Smith
+Copyright (c) 2020-2023 Rob Smith
 
-Stannum is released under the [MIT License](https://opensource.org/licenses/MIT).
+Cuprum::Collections is released under the [MIT License](https://opensource.org/licenses/MIT).
 
 ### Contribute
 
@@ -105,6 +105,13 @@ end
 
 Because a collection can represent any sort of data, from a raw Ruby Hash to an ORM record, the term used to indicate "one item in the collection" is an *entity*. Likewise, the class of the items in the collection is the *entity_class*. In our example above, our entities are books, and the entity class is Hash.
 
+Each collection also defines the following methods:
+
+- `#collection_name`: The collection name is a short description of what the collection contains. For example, a collection of `Book` objects might have a collection name of `'books'`, while a collection of `Authorization::Credentials::ApiKey` objects might have a collection name of `'api_keys'`.
+- `#qualified_name`: The qualified name is a full description of the collection, and should be unique. For example, a collection of `Book` objects might have a qualified name of `'books'`, while a collection of `Authorization::Credentials::ApiKey` objects might have a qualified name of `'authorization/credentials/api_keys'`.
+
+As a general rule, the `#collection_name` is used when displaying information to the user, while the `#qualified_name` is used to uniquely identify the collection (such as when adding to or retrieving from a [Repository](#repositories)).
+
 <a id="commands"></a>
 
 #### Commands
@@ -214,7 +221,7 @@ If the collection does not include an entity with each of the specified primary
 
 ##### Find Matching
 
-The `FindMatching` command takes a set of query parameters and queries data from the collection. You can specify filters using the `:where` keyword or by passing a block, sort the results using the `:order` keyword, or return a subset of the results using the `:limit` and `:offset` keywords. For full details on performing queries, see [Queries](#queries), below.
+The `FindMatching` command takes a set of query parameters and queries data from the collection. You can specify filters using the `:where` keyword or by passing a block, sort the results using the `:order` keyword, or return a subset of the results using the `:limit` and `:offset` keywords.
 
 ```ruby
 result =
@@ -260,7 +267,11 @@ The `FindMatching` command has several options:
     #=>  { books: [{ ... }, { ... }, { ... }] }
     ```
 
+- The `:limit` keyword caps the number of results returned.
+- The `:offset` keyword skips the specified number of results.
+- The `:order` keyword specifies the order of results.
 - The `:scope` keyword allows you to pass a query to the command. Only entities that match the given scope will be found and returned by `#find_matching`.
+- The `:where` keyword defines filters for which results are to be returned.
 
 ##### Find One
 
@@ -299,7 +310,7 @@ The `InsertOne` command takes an entity and inserts that entity into the collect
 
 ```ruby
 book       = { 'id' => 10, 'title' => 'Gideon the Ninth', 'author' => 'Tamsyn Muir' }
-result     = collection.insert_one.call(entity: entity)
+result     = collection.insert_one.call(entity: book)
 
 result.value
 #=> {
@@ -369,16 +380,16 @@ If the collection does not specify a default contract and no `:contract` keyword
 require 'cuprum/collections/repository'
 ```
 
-A repository is a group of collections. While a collection might be be a single data set, such as the records in a table, the repository represents all of the data sets in a data source, such as the tables in a database.
+A repository is a group of collections. While a collection might be be a single data set, such as the records in a table, the repository represents all of the data sets in a data source, such as the tables in a database. Each repository uses the `#qualified_name` of its collections as a unique key.
 
 ```ruby
 repository = Cuprum::Collections::Repository.new
-repository.key?('book')
+repository.key?('books')
 #=> false
 
 repository.add(books_collection)
 
-repository.key?('book')
+repository.key?('books')
 #=> true
 repository.keys
 #=> ['books']
@@ -386,6 +397,31 @@ repository['books']
 #=> the books collection
 ```
 
+When accessing a collection with a qualified name, you must pass the qualified name to `#[]` or `#key?`, rather than the collection name.
+
+```ruby
+repository = Cuprum::Collections::Repository.new
+repository.key?('api_keys')
+#=> false
+repository.key?('authorization/credentials/api_keys')
+#=> false
+
+api_keys_collection.collection_name
+#=> 'api_keys'
+api_keys_collection.qualified_name
+#=> 'authorization/credentials/api_keys'
+repository.add(api_keys_collection)
+
+repository.key?('api_keys')
+#=> false
+repository.key?('authorization/credentials/api_keys')
+#=> true
+repository.keys
+#=> ['authorization/credentials/api_keys']
+repository['authorization/credentials/api_keys']
+#=> the api keys collection
+```
+
 #### Basic Collection
 
 ```ruby
@@ -412,6 +448,7 @@ You can also specify some optional keywords:
 - The `:member_name` parameter is used to create an envelope for singular query commands such as the `FindOne` command. If not given, the member name will be generated automatically as a singular form of the collection name.
 - The `:primary_key_name` parameter specifies the attribute that serves as the primary key for the collection entities. The default value is `:id`.
 - The `:primary_key_type` parameter specifies the type of the primary key attribute. The default value is `Integer`.
+- The `:qualified_name` parameter sets the qualified name for the collection. It is used to uniquely identify the collection in a repository.
 
 ##### Basic Repositories
 
@@ -1007,3 +1044,213 @@ query.each.map(&:title)
 #     'The Farthest Shore'
 #   ]
 ```
+
+<a id="builtin-commands"></a>
+
+### Built In Commands
+
+`Cuprum::Collections` defines some basic commands. Each command takes a `:collection` parameter, which is used for performing the data operations.
+
+#### Create
+
+```ruby
+require 'cuprum/collections/commands/create'
+```
+
+The `Create` command takes an attributes Hash and adds an entity with those attributes to the collection. Internally, it calls the `#build_one`, `#validate_one`, and `#insert_one` commands on the collection.
+
+```ruby
+command = Cuprum::Collections::Commands::Create.new(collection: books_collection)
+
+books_collection.count
+#=> 0
+result = command.call(attributes: { 'title' => 'Gideon the Ninth' })
+result.value
+#=> a Book with title "Gideon the Ninth"
+books_collection.count
+#=> 1
+
+books_collection.find_matching.call { { 'title' => 'Gideon the Ninth' } }.value.first
+#=> a Book with title "Gideon the Ninth"
+```
+
+If the contract does not match the entity, the `Create` command will return a failing result with a `ValidationFailed` error.
+
+If the collection does not specify a default contract and no :contract keyword is provided, the `Create` command will return a failing result with a `MissingDefaultContract` error.
+
+If the collection already includes an entity with the specified primary key, the `Create` command will return a failing result with an `AlreadyExists` error.
+
+#### FindOneMatching
+
+```ruby
+require 'cuprum/collections/commands/find_one_matching'
+```
+
+The `FindOneMatching` command takes either an attributes hash or a [Query](#queries) block, and returns the unique entity from the collection with those entities or matching that query.
+
+```ruby
+command = Cuprum::Collections::Commands::FindOneMatching.new(collection: books_collection)
+
+result = command.call(attributes: { 'title' => 'Gideon the Ninth'})
+result.success?
+#=> true
+result.value
+#=> the unique Book with title "Gideon the Ninth"
+
+result = command.call do
+  {
+    'series'       => 'The Locked Tomb',
+    'published_at' => less_than('2020-01-01')
+  }
+end
+result.success?
+#=> true
+result.value
+#=> the unique Book with the given series and published before the given date
+```
+
+If there are no entities in the collection matching the attributes or query, the `FindOneMatching` command returns a failing result with a `Cuprum::Collections::Errors::NotFound` error.
+
+```ruby
+result = command.call(attributes: { 'title' => 'Gideon the Eleventh'})
+result.success?
+#=> false
+result.error
+#=> an instance of Cuprum::Collections::Errors::NotFound
+```
+
+If there are two or more entities in the collection matching the attributes or query, the `FindOneMatching` command returns a failing result with a `Cuprum::Collections::Errors::NotUnique` error.
+
+```ruby
+result = command.call(attributes: { 'author' => 'Tamsyn Muir'})
+result.success?
+#=> false
+result.error
+#=> an instance of Cuprum::Collections::Errors::NotUnique
+```
+
+#### Update
+
+```ruby
+require 'cuprum/collections/commands/update'
+```
+
+The `Update` command takes an attributes Hash and an entity and updates the corresponding entity in the collection with those attributes. Internally, it calls the `#assign_one`, `#validate_one`, and `#update_one` commands on the collection.
+
+```ruby
+command = Cuprum::Collections::Commands::Update.new(collection: books_collection)
+
+entity = books_collection.find_matching.call { { 'title' => 'Gideon the Ninth' } }.value.first
+#=> a Book with title "Gideon the Ninth" and series "The Locked Tomb"
+
+result = command.call(
+  attributes: { 'series' => 'Space Necromancers' },
+  entity:     entity
+)
+result.value
+#=> a Book with title "Gideon the Ninth" and series "Space Necromancers"
+
+books_collection.find_matching.call { { 'title' => 'Gideon the Ninth' } }.value.first
+#=> a Book with title "Gideon the Ninth" and series "Space Necromancers"
+```
+
+If the contract does not match the entity, the `Update` command will return a failing result with a `ValidationFailed` error.
+
+If the collection does not specify a default contract and no :contract keyword is provided, the `Update` command will return a failing result with a `MissingDefaultContract` error.
+
+If the collection does not include an entity with the specified entity's primary key, the `Update` command will return a failing result with a `NotFound` error.
+
+#### Upsert
+
+```ruby
+require 'cuprum/collections/commands/upsert'
+```
+
+The `Upsert` command takes an attributes Hash and checks the collection for an entity with a matching primary key. If an entity is found, it updates the entity with the given attributes, as per the `Update` command (see above); if an entity is not found, it creates a new entity with the given attributes, as per the `Create` command.
+
+```ruby
+command = Cuprum::Collections::Commands::Upsert.new(collection: books_collection)
+
+# Creating An Entity
+books_collection.count
+#=> 0
+result = command.call(attributes: { 'id' => 0, 'title' => 'Gideon the Ninth' })
+result.value
+#=> a Book with id 0 and title "Gideon the Ninth"
+books_collection.count
+#=> 1
+
+books_collection.find_matching.call { { 'title' => 'Gideon the Ninth' } }.value.first
+#=> a Book with id 0 and title "Gideon the Ninth"
+
+# Updating An Entity
+result = command.call(attributes: { 'id' => 0, 'author' => 'Tamsyn Muir' })
+result.value
+#=> a Book with id 0, title "Gideon the Ninth", and author "Tamsyn Muir"
+
+books_collection.find_matching.call { { 'title' => 'Gideon the Ninth' } }.value.first
+#=> a Book with id 0, title "Gideon the Ninth", and author "Tamsyn Muir"
+```
+
+The `Upsert` command can also be configured with an attribute name or list of attribute names; the command will then search for an entity in the collection matching those attributes, rather than by primary key.
+
+```ruby
+command      =
+  Cuprum::Collections::Commands::Upsert
+  .new(attribute_names: %w[title author], collection: books_collection)
+other_entity = books_collection.build_one.call(
+  attributes: {
+    'id'     => 0,
+    'title'  => 'Gideon the Ninth',
+    'author' => 'T. M.'
+  }
+)
+books_collection.insert_one.call(entity: entity)
+
+# Creating An Entity
+books_collection.count
+#=> 1
+result = command.call(
+  attributes: {
+    'id'     => 1,
+    'title'  => 'Gideon the Ninth',
+    'author' => 'Tamsyn Muir'
+  }
+)
+result.value
+#=> a Book with id 1, title "Gideon the Ninth", and author "Tamsyn Muir"
+books_collection.count
+#=> 1
+
+books_collection.find_matching.call { { 'title' => 'Gideon the Ninth' } }.value.count
+#=> 2
+books_collection.find_matching.call { { 'title' => 'Gideon the Ninth' } }.value.map(&:author)
+#=> ['T. M.', 'Tamsyn Muir']
+
+# Updating An Entity
+result = command.call(
+  attributes: {
+    'title'  => 'Gideon the Ninth',
+    'author' => 'Tamsyn Muir',
+    'series' => 'The Locked Tomb'
+  }
+)
+result.value
+#=> a Book with id 1, title "Gideon the Ninth", author "Tamsyn Muir", and series
+#   "The Locked Tomb"
+
+books_collection.find_matching.call do
+  {
+    'title'  => 'Gideon the Ninth',
+    'author' => 'Tamsyn Muir'
+  }
+end.value.first
+#=> a Book with id 1, title "Gideon the Ninth", author "Tamsyn Muir", and series
+#   "The Locked Tomb"
+```
+
+If there are two or more entities in the collection matching the attributes or query, the `Upsert` command returns a failing result with a `Cuprum::Collections::Errors::NotUnique` error.
+
+If the contract does not match the entity, the `Upsert` command will return a failing result with a `ValidationFailed` error.
+
+If the collection does not specify a default contract and no :contract keyword is provided, the `Upsert` command will return a failing result with a `MissingDefaultContract` error.

data/lib/cuprum/collections/basic/collection.rb

@@ -17,6 +17,8 @@ module Cuprum::Collections::Basic
     #   Defaults to :id.
     # @param primary_key_type [Class, Stannum::Constraint] The type of the
     #   primary key attribute. Defaults to Integer.
+    # @param qualified_name [String] The qualified name of the collection, which
+    #   should be unique. Defaults to the collection name.
     # @param options [Hash<Symbol>] Additional options for the command.
     def initialize( # rubocop:disable Metrics/ParameterLists
       collection_name:,
@@ -25,6 +27,7 @@ module Cuprum::Collections::Basic
       member_name:      nil,
       primary_key_name: :id,
       primary_key_type: Integer,
+      qualified_name:   nil,
       **options
     )
       super()
@@ -37,6 +40,7 @@ module Cuprum::Collections::Basic
       @options          = options
       @primary_key_name = primary_key_name
       @primary_key_type = primary_key_type
+      @qualified_name   = qualified_name || @collection_name
     end
 
     # @return [String] the name of the collection.
@@ -62,6 +66,9 @@ module Cuprum::Collections::Basic
     #   attribute.
     attr_reader :primary_key_type
 
+    # @return [String] the qualified name of the collection.
+    attr_reader :qualified_name
+
     command_class :assign_one do
       Cuprum::Collections::Basic::Commands::AssignOne
         .subclass(**command_options)
@@ -107,6 +114,12 @@ module Cuprum::Collections::Basic
         .subclass(**command_options)
     end
 
+    # @return [Integer] the count of items in the collection.
+    def count
+      query.count
+    end
+    alias size count
+
     # A new Query instance, used for querying against the collection data.
     #
     # @return [Cuprum::Collections::Basic::Query] the query.

data/lib/cuprum/collections/basic/commands/destroy_one.rb

@@ -28,9 +28,10 @@ module Cuprum::Collections::Basic::Commands
       return if index
 
       error = Cuprum::Collections::Errors::NotFound.new(
-        collection_name:    collection_name,
-        primary_key_name:   primary_key_name,
-        primary_key_values: [primary_key]
+        attribute_name:  primary_key_name,
+        attribute_value: primary_key,
+        collection_name: collection_name,
+        primary_key:     true
       )
       Cuprum::Result.new(error: error)
     end

data/lib/cuprum/collections/basic/commands/find_many.rb

@@ -47,7 +47,7 @@ module Cuprum::Collections::Basic::Commands
 
     def items_with_primary_keys(items:)
       # :nocov:
-      items.map { |item| [item[primary_key_name.to_s], item] }.to_h
+      items.to_h { |item| [item[primary_key_name.to_s], item] }
       # :nocov:
     end
 

data/lib/cuprum/collections/basic/commands/insert_one.rb

@@ -32,9 +32,10 @@ module Cuprum::Collections::Basic::Commands
       return if index.nil?
 
       error = Cuprum::Collections::Errors::AlreadyExists.new(
-        collection_name:    collection_name,
-        primary_key_name:   primary_key_name,
-        primary_key_values: value
+        attribute_name:  primary_key_name,
+        attribute_value: value,
+        collection_name: collection_name,
+        primary_key:     true
       )
       failure(error)
     end

data/lib/cuprum/collections/basic/commands/update_one.rb

@@ -32,9 +32,10 @@ module Cuprum::Collections::Basic::Commands
       return index unless index.nil?
 
       error = Cuprum::Collections::Errors::NotFound.new(
-        collection_name:    collection_name,
-        primary_key_name:   primary_key_name,
-        primary_key_values: entity[primary_key_name.to_s]
+        attribute_name:  primary_key_name,
+        attribute_value: entity[primary_key_name.to_s],
+        collection_name: collection_name,
+        primary_key:     true
       )
       failure(error)
     end

data/lib/cuprum/collections/basic/query.rb

@@ -151,9 +151,9 @@ module Cuprum::Collections::Basic
     def filtered_data
       @filtered_data ||=
         data
-          .yield_self { |ary| apply_filters(ary) }
-          .yield_self { |ary| apply_order(ary) }
-          .yield_self { |ary| apply_limit_offset(ary) }
+          .then { |ary| apply_filters(ary) }
+          .then { |ary| apply_order(ary) }
+          .then { |ary| apply_limit_offset(ary) }
           .map(&:dup)
     end
   end

data/lib/cuprum/collections/commands/abstract_find_many.rb

@@ -17,39 +17,41 @@ module Cuprum::Collections::Commands
       (scope || build_query).where { { key => one_of(primary_keys) } }
     end
 
-    def handle_missing_items(allow_partial:, items:, primary_keys:)
-      found, missing = match_items(items: items, primary_keys: primary_keys)
+    def build_results(items:, primary_keys:)
+      primary_keys.map do |primary_key_value|
+        next success(items[primary_key_value]) if items.key?(primary_key_value)
 
-      return found if missing.empty?
+        failure(not_found_error(primary_key_value))
+      end
+    end
+
+    def build_result_list(results, allow_partial:, envelope:)
+      unless envelope
+        return Cuprum::ResultList.new(*results, allow_partial: allow_partial)
+      end
 
-      return found if allow_partial && !found.empty?
+      value = envelope ? wrap_items(results.map(&:value)) : nil
 
-      error = Cuprum::Collections::Errors::NotFound.new(
-        collection_name:    collection_name,
-        primary_key_name:   primary_key_name,
-        primary_key_values: missing
+      Cuprum::ResultList.new(
+        *results,
+        allow_partial: allow_partial,
+        value:         value
       )
-      Cuprum::Result.new(error: error)
     end
 
     def items_with_primary_keys(items:)
       # :nocov:
-      items.map { |item| [item.send(primary_key_name), item] }.to_h
+      items.to_h { |item| [item.send(primary_key_name), item] }
       # :nocov:
     end
 
-    def match_items(items:, primary_keys:)
-      items   = items_with_primary_keys(items: items)
-      found   = []
-      missing = []
-
-      primary_keys.each do |key|
-        item = items[key]
-
-        item.nil? ? (missing << key) : (found << item)
-      end
-
-      [found, missing]
+    def not_found_error(primary_key_value)
+      Cuprum::Collections::Errors::NotFound.new(
+        attribute_name:  primary_key_name,
+        attribute_value: primary_key_value,
+        collection_name: collection_name,
+        primary_key:     true
+      )
     end
 
     def process(
@@ -58,16 +60,15 @@ module Cuprum::Collections::Commands
       envelope:      false,
       scope:         nil
     )
-      query = apply_query(primary_keys: primary_keys, scope: scope)
-      items = step do
-        handle_missing_items(
-          allow_partial: allow_partial,
-          items:         query.to_a,
-          primary_keys:  primary_keys
-        )
-      end
-
-      envelope ? wrap_items(items) : items
+      query   = apply_query(primary_keys: primary_keys, scope: scope)
+      items   = items_with_primary_keys(items: query.to_a)
+      results = build_results(items: items, primary_keys: primary_keys)
+
+      build_result_list(
+        results,
+        allow_partial: allow_partial,
+        envelope:      envelope
+      )
     end
 
     def wrap_items(items)

data/lib/cuprum/collections/commands/abstract_find_one.rb

@@ -21,9 +21,10 @@ module Cuprum::Collections::Commands
       return if item
 
       error = Cuprum::Collections::Errors::NotFound.new(
-        collection_name:    collection_name,
-        primary_key_name:   primary_key_name,
-        primary_key_values: [primary_key]
+        attribute_name:  primary_key_name,
+        attribute_value: primary_key,
+        collection_name: collection_name,
+        primary_key:     true
       )
       Cuprum::Result.new(error: error)
     end

data/lib/cuprum/collections/commands/create.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'cuprum/collections/commands'
+
+module Cuprum::Collections::Commands
+  # Command for building, validating and inserting an entity into a collection.
+  #
+  # @example Creating An Entity
+  #   command =
+  #     Cuprum::Collections::Commands::Create.new(collection:)
+  #     .new(collection: books_collection)
+  #
+  #   # With Invalid Attributes
+  #   attributes = { 'title' => '' }
+  #   result     = command.call(attributes: attributes)
+  #   result.success?
+  #   #=> false
+  #   result.error
+  #   #=> an instance of Cuprum::Collections::Errors::FailedValidation
+  #   books_collection.query.count
+  #   #=> 0
+  #
+  #   # With Valid Attributes
+  #   attributes = { 'title' => 'Gideon the Ninth' }
+  #   result     = command.call(attributes: attributes)
+  #   result.success?
+  #   #=> true
+  #   result.value
+  #   #=> a Book with title 'Gideon the Ninth'
+  #   books_collection.query.count
+  #   #=> 1
+  class Create < Cuprum::Command
+    # @param collection [Object] The collection used to store the entity.
+    # @param contract [Stannum::Constraint] The constraint used to validate the
+    #   entity. If not given, defaults to the default contract for the
+    #   collection.
+    def initialize(collection:, contract: nil)
+      super()
+
+      @collection = collection
+      @contract   = contract
+    end
+
+    # @return [Object] the collection used to store the entity.
+    attr_reader :collection
+
+    # @return [Stannum::Constraint] the constraint used to validate the entity.
+    attr_reader :contract
+
+    private
+
+    def process(attributes:)
+      entity = step { collection.build_one.call(attributes: attributes) }
+
+      step { collection.validate_one.call(contract: contract, entity: entity) }
+
+      collection.insert_one.call(entity: entity)
+    end
+  end
+end