dynamoid 3.8.0 → 3.12.1

data/README.md

@@ -1,21 +1,18 @@
 # Dynamoid
 
-[![Build Status](https://github.com/Dynamoid/dynamoid/actions/workflows/ci.yml/badge.svg?branch=master)](https://github.com/Dynamoid/dynamoid/actions/workflows/ci.yml/badge.svg?branch=master)
-[![Code Climate](https://codeclimate.com/github/Dynamoid/dynamoid.svg)](https://codeclimate.com/github/Dynamoid/dynamoid)
-[![Coverage Status](https://coveralls.io/repos/github/Dynamoid/dynamoid/badge.svg?branch=master)](https://coveralls.io/github/Dynamoid/dynamoid?branch=master)
-[![CodeTriage Helpers](https://www.codetriage.com/dynamoid/dynamoid/badges/users.svg)](https://www.codetriage.com/dynamoid/dynamoid)
-[![Yard Docs](http://img.shields.io/badge/yard-docs-blue.svg)](https://www.rubydoc.info/github/Dynamoid/dynamoid/frames)
-[![Inline docs](http://inch-ci.org/github/Dynamoid/Dynamoid.svg?branch=master)](http://inch-ci.org/github/Dynamoid/Dynamoid)
-![GitHub](https://img.shields.io/github/license/Dynamoid/dynamoid.svg)
+[![Gem Version][⛳️version-img]][⛳️gem]
+[![Supported Build Status][🏘sup-wf-img]][🏘sup-wf]
+[![Maintainability][⛳cclim-maint-img♻️]][⛳cclim-maint]
+[![Coveralls][🏘coveralls-img]][🏘coveralls]
+[![CodeCov][🖇codecov-img♻️]][🖇codecov]
+[![Helpers][🖇triage-help-img]][🖇triage-help]
+[![Contributors][🖐contributors-img]][🖐contributors]
+[![RubyDoc.info][🚎yard-img]][🚎yard]
+[![License][🖇src-license-img]][🖇src-license]
 [![GitMoji][🖐gitmoji-img]][🖐gitmoji]
-[![SemVer 2.0.0][🧮semver-img]][semver]
+[![SemVer 2.0.0][🧮semver-img]][🧮semver]
 [![Keep-A-Changelog 1.0.0][📗keep-changelog-img]][📗keep-changelog]
-
-[🖐gitmoji]: https://gitmoji.dev
-[🖐gitmoji-img]: https://img.shields.io/badge/gitmoji-3.9.0-FFDD67.svg?style=flat
-[🧮semver-img]: https://img.shields.io/badge/semver-2.0.0-FFDD67.svg?style=flat
-[📗keep-changelog]: https://keepachangelog.com/en/1.0.0/
-[📗keep-changelog-img]: https://img.shields.io/badge/keep--a--changelog-1.0.0-FFDD67.svg?style=flat
+[![Sponsor Project][🖇sponsor-img]][🖇sponsor]
 
 Dynamoid is an ORM for Amazon's DynamoDB for Ruby applications. It
 provides similar functionality to ActiveRecord and improves on Amazon's
@@ -27,8 +24,8 @@ DynamoDB is not like other document-based databases you might know, and
 is very different indeed from relational databases. It sacrifices
 anything beyond the simplest relational queries and transactional
 support to provide a fast, cost-efficient, and highly durable storage
-solution. If your database requires complicated relational queries and
-transaction support, then this modest Gem cannot provide them for you,
+solution. If your database requires complicated relational queries
+then this modest Gem cannot provide them for you
 and neither can DynamoDB. In those cases you would do better to look
 elsewhere for your database needs.
 
@@ -70,10 +67,10 @@ For example, to configure AWS access:
 Create `config/initializers/aws.rb` as follows:
 
 ```ruby
-Aws.config.update({
+Aws.config.update(
   region: 'us-west-2',
   credentials: Aws::Credentials.new('REPLACE_WITH_ACCESS_KEY_ID', 'REPLACE_WITH_SECRET_ACCESS_KEY'),
-})
+)
 ```
 
 Alternatively, if you don't want Aws connection settings to be
@@ -97,15 +94,15 @@ elsewhere in your project, etc.), you may do so:
 require 'dynamoid'
 
 credentials = Aws::AssumeRoleCredentials.new(
-    region: region,
-    access_key_id: key,
-    secret_access_key: secret,
-    role_arn: role_arn,
-    role_session_name: 'our-session'
-  )
+  region: region,
+  access_key_id: key,
+  secret_access_key: secret,
+  role_arn: role_arn,
+  role_session_name: 'our-session'
+)
 
 Dynamoid.configure do |config|
-  config.region = 'us-west-2',
+  config.region = 'us-west-2'
   config.credentials = credentials
 end
 ```
@@ -135,8 +132,8 @@ end
 Dynamoid supports Ruby >= 2.3 and Rails >= 4.2.
 
 Its compatibility is tested against following Ruby versions: 2.3, 2.4,
-2.5, 2.6, 2.7 and 3.0, JRuby 9.2.x and against Rails versions: 4.2, 5.0, 5.1,
-5.2, 6.0, 6.1 and 7.0.
+2.5, 2.6, 2.7, 3.0, 3.1, 3.2, 3.3, and 3.4, JRuby 9.4.x and against Rails versions: 4.2, 5.0, 5.1,
+5.2, 6.0, 6.1, 7.0, 7.1, 7.2, and 8.0.
 
 ## Setup
 
@@ -345,6 +342,24 @@ class Document
 end
 ```
 
+#### Note on binary type
+
+By default binary fields are persisted as DynamoDB String value encoded
+in the Base64 encoding. DynamoDB supports binary data natively. To use
+it instead of String a `store_binary_as_native` field option should be
+set:
+
+```ruby
+class Document
+  include Dynamoid::Document
+
+  field :image, :binary, store_binary_as_native: true
+end
+```
+
+There is also a global config option `store_binary_as_native` that is
+`false` by default as well.
+
 #### Magic Columns
 
 You get magic columns of `id` (`string`), `created_at` (`datetime`), and
@@ -360,7 +375,6 @@ class User
   field :number, :number
   field :joined_at, :datetime
   field :hash, :serialized
-
 end
 ```
 
@@ -406,7 +420,7 @@ class Money
     'serialized representation as a string'
   end
 
-  def self.dynamoid_load(serialized_str)
+  def self.dynamoid_load(_serialized_str)
     # parse serialized representation and return a Money instance
     Money.new(1.23)
   end
@@ -431,7 +445,7 @@ serializing. Example:
 class Money; end
 
 class MoneyAdapter
-  def self.dynamoid_load(money_serialized_str)
+  def self.dynamoid_load(_money_serialized_str)
     Money.new(1.23)
   end
 
@@ -457,6 +471,27 @@ method, which would return either `:string` or `:number`.
 DynamoDB may support some other attribute types that are not yet
 supported by Dynamoid.
 
+If a custom type implements `#==` method you can specify `comparable:
+true` option in a field declaration to specify that an object is safely
+comparable for the purpose of detecting changes. By default old and new
+objects will be compared by their serialized representation.
+
+```ruby
+class Money
+  # ...
+
+  def ==(other)
+    # comparison logic
+  end
+end
+
+class User
+  # ...
+
+  field :balance, Money, comparable: true
+end
+```
+
 ### Sort key
 
 Along with partition key table may have a sort key. In order to declare
@@ -550,9 +585,18 @@ model.save(validate: false)
 
 ### Callbacks
 
-Dynamoid also employs ActiveModel callbacks. Right now, callbacks are
-defined on `save`, `update`, `destroy`, which allows you to do `before_`
-or `after_` any of those.
+Dynamoid also employs ActiveModel callbacks. Right now the following
+callbacks are supported:
+- `save` (before, after, around)
+- `create` (before, after, around)
+- `update` (before, after, around)
+- `validation` (before, after)
+- `destroy` (before, after, around)
+- `after_touch`
+- `after_initialize`
+- `after_find`
+
+Example:
 
 ```ruby
 class User
@@ -597,6 +641,7 @@ with `inheritance_field` table option:
 ```ruby
 class Car
   include Dynamoid::Document
+
   table inheritance_field: :my_new_type
 
   field :my_new_type
@@ -684,19 +729,19 @@ address.save
 To create multiple documents at once:
 
 ```ruby
-User.create([{name: 'Josh'}, {name: 'Nick'}])
+User.create([{ name: 'Josh' }, { name: 'Nick' }])
 ```
 
 There is an efficient and low-level way to create multiple documents
 (without validation and callbacks running):
 
 ```ruby
-users = User.import([{name: 'Josh'}, {name: 'Nick'}])
+users = User.import([{ name: 'Josh' }, { name: 'Nick' }])
 ```
 
 ### Querying
 
-Querying can be done in one of three ways:
+Querying can be done in one of the following ways:
 
 ```ruby
 Address.find(address.id)              # Find directly by ID.
@@ -705,6 +750,27 @@ Address.where(city: 'Chicago').all    # Find by any number of matching criteria.
 Address.find_by_city('Chicago')       # The same as above, but using ActiveRecord's older syntax.
 ```
 
+There is also a way to `#where` with a condition expression:
+
+```ruby
+Address.where('city = :c', c: 'Chicago')
+```
+
+A condition expression may contain operators (e.g. `<`, `>=`, `<>`),
+keywords (e.g. `AND`, `OR`, `BETWEEN`) and built-in functions (e.g.
+`begins_with`, `contains`) (see (documentation
+)[https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html]
+for full syntax description).
+
+**Warning:** Values (specified for a String condition expression) are
+sent as is so Dynamoid field types that aren't supported natively by
+DynamoDB (e.g. `datetime` and `date`) require explicit casting.
+
+**Warning:** String condition expressions will be used by DynamoDB only
+at filtering, so conditions on key attributes should be specified as a
+Hash to perform Query operation instead of Scan. Don't use key
+attributes in `#where`'s String condition expressions.
+
 And you can also query on associations:
 
 ```ruby
@@ -718,18 +784,6 @@ join, but instead finds all the user's addresses and naively filters
 them in Ruby. For large associations this is a performance hit compared
 to relational database engines.
 
-**WARNING:** There is a limitation of conditions passed to `where`
-method. Only one condition for some particular field could be specified.
-The last one only will be applied and others will be ignored. E.g. in
-examples:
-
-```ruby
-User.where('age.gt': 10, 'age.lt': 20)
-User.where(name: 'Mike').where('name.begins_with': 'Ed')
-```
-
-the first one will be ignored and the last one will be used.
-
 **Warning:** There is a caveat with filtering documents by `nil` value
 attribute. By default Dynamoid ignores attributes with `nil` value and
 doesn't store them in a DynamoDB document. This behavior could be
@@ -747,7 +801,7 @@ If Dynamoid keeps `nil` value attributes `eq`/`ne` operators should be
 used instead:
 
 ```ruby
-Address.where('postcode': nil)
+Address.where(postcode: nil)
 Address.where('postcode.ne': nil)
 ```
 
@@ -796,8 +850,8 @@ for requesting documents in batches:
 
 ```ruby
 # Do some maintenance on the entire table without flooding DynamoDB
-Address.batch(100).each { |address| address.do_some_work; sleep(0.01) }
-Address.record_limit(10_000).batch(100).each { … } # Batch specified as part of a chain
+Address.batch(100).each { |addr| addr.do_some_work && sleep(0.01) }
+Address.record_limit(10_000).batch(100).each { |addr| addr.do_some_work && sleep(0.01) } # Batch specified as part of a chain
 ```
 
 The implication of batches is that the underlying requests are done in
@@ -849,13 +903,13 @@ operators are available: `gt`, `lt`, `gte`, `lte`, `begins_with`,
 `between` as well as equality:
 
 ```ruby
-Address.where(latitude: 10212)
-Address.where('latitude.gt': 10212)
-Address.where('latitude.lt': 10212)
-Address.where('latitude.gte': 10212)
-Address.where('latitude.lte': 10212)
+Address.where(latitude: 10_212)
+Address.where('latitude.gt': 10_212)
+Address.where('latitude.lt': 10_212)
+Address.where('latitude.gte': 10_212)
+Address.where('latitude.lte': 10_212)
 Address.where('city.begins_with': 'Lon')
-Address.where('latitude.between': [10212, 20000])
+Address.where('latitude.between': [10_212, 20_000])
 ```
 
 You are able to filter results on the DynamoDB side and specify
@@ -863,7 +917,7 @@ conditions for non-key fields. Following additional operators are
 available: `in`, `contains`, `not_contains`, `null`, `not_null`:
 
 ```ruby
-Address.where('city.in': ['London', 'Edenburg', 'Birmingham'])
+Address.where('city.in': %w[London Edenburg Birmingham])
 Address.where('city.contains': ['on'])
 Address.where('city.not_contains': ['ing'])
 Address.where('postcode.null': false)
@@ -882,6 +936,7 @@ It could be done with `project` method:
 ```ruby
 class User
   include Dynamoid::Document
+
   field :name
 end
 
@@ -921,8 +976,8 @@ If you have a range index, Dynamoid provides a number of additional
 other convenience methods to make your life a little easier:
 
 ```ruby
-User.where("created_at.gt": DateTime.now - 1.day).all
-User.where("created_at.lt": DateTime.now - 1.day).all
+User.where('created_at.gt': DateTime.now - 1.day).all
+User.where('created_at.lt': DateTime.now - 1.day).all
 ```
 
 It also supports `gte` and `lte`. Turning those into symbols and
@@ -941,7 +996,6 @@ validation and callbacks.
 Address.find(id).update_attributes(city: 'Chicago')
 Address.find(id).update_attribute(:city, 'Chicago')
 Address.update(id, city: 'Chicago')
-Address.update(id, { city: 'Chicago' }, if: { deliverable: true })
 ```
 
 There are also some low level methods `#update`, `.update_fields` and
@@ -965,6 +1019,14 @@ Address.upsert(id, city: 'Chicago')
 Address.upsert(id, { city: 'Chicago' }, if: { deliverable: true })
 ```
 
+By default, `#upsert` will update all attributes of the document if it already exists.
+To idempotently create-but-not-update a record, apply the `unless_exists` condition
+to its keys when you upsert.
+
+```ruby
+Address.upsert(id, { city: 'Chicago' }, { unless_exists: [:id] })
+```
+
 ### Deleting
 
 In order to delete some items `delete_all` method should be used. Any
@@ -1046,6 +1108,213 @@ resolving the fields with a second query against the table since a query
 against GSI then a query on base table is still likely faster than scan
 on the base table*
 
+### Transactions in Dynamoid
+
+> [!WARNING]
+> Please note that this API is experimental and can be changed in
+> future releases.
+
+DynamoDB supports modifying and reading operations but there are some
+limitations:
+- read and write operation cannot be combined in the same transaction
+- operations are executed in batch, so operations should be given before
+  actual execution and cannot be changed on the fly
+
+#### Modifying transactions
+
+Multiple modifying actions can be grouped together and submitted as an
+all-or-nothing operation. Atomic modifying operations are supported in
+Dynamoid using transactions. If any action in the transaction fails they
+all fail.
+
+The following actions are supported:
+
+* `#create`/`#create!` - add a new model if it does not already exist
+* `#save`/`#save!` - create or update model
+* `#update_attributes`/`#update_attributes!` - modifies one or more attributes from an existig
+model
+* `#delete` - remove an model without callbacks nor validations
+* `#destroy`/`#destroy!` - remove an model
+* `#upsert` - add a new model or update an existing one, no callbacks
+* `#update_fields` - update a model without its instantiation
+
+These methods are supposed to behave exactly like their
+non-transactional counterparts.
+
+##### Create models
+
+Models can be created inside of a transaction. The partition and sort
+keys, if applicable, are used to determine uniqueness. Creating will
+fail with `Aws::DynamoDB::Errors::TransactionCanceledException` if a
+model already exists.
+
+This example creates a user with a unique id and unique email address by
+creating 2 models. An additional model is upserted in the same
+transaction. Upsert will update `updated_at` but will not create
+`created_at`.
+
+```ruby
+user_id = SecureRandom.uuid
+email = 'bob@bob.bob'
+
+Dynamoid::TransactionWrite.execute do |txn|
+  txn.create(User, id: user_id)
+  txn.create(UserEmail, id: "UserEmail##{email}", user_id: user_id)
+  txn.create(Address, id: 'A#2', street: '456')
+  txn.upsert(Address, 'A#1', street: '123')
+end
+```
+
+##### Save models
+
+Models can be saved in a transaction. New records are created otherwise
+the model is updated. Save, create, update, validate and destroy
+callbacks are called around the transaction as appropriate. Validation
+failures will throw `Dynamoid::Errors::DocumentNotValid`.
+
+```ruby
+user = User.find(1)
+article = Article.new(body: 'New article text', user_id: user.id)
+
+Dynamoid::TransactionWrite.execute do |txn|
+  txn.save(article)
+
+  user.last_article_id = article.id
+  txn.save(user)
+end
+```
+
+##### Update models
+
+A model can be updated by providing a model or primary key, and the fields to update.
+
+```ruby
+Dynamoid::TransactionWrite.execute do |txn|
+  # change name and title for a user
+  txn.update_attributes(user, name: 'bob', title: 'mister')
+
+  # sets the name and title for a user
+  # The user is found by id (that equals 1)
+  txn.update_fields(User, '1', name: 'bob', title: 'mister')
+
+  # sets the name, increments a count and deletes a field
+  txn.update_fields(User, 1) do |t|
+    t.set(name: 'bob')
+    t.add(article_count: 1)
+    t.delete(:title)
+  end
+
+  # adds to a set of integers and deletes from a set of strings
+  txn.update_fields(User, 2) do |t|
+    t.add(friend_ids: [1, 2])
+    t.delete(child_names: ['bebe'])
+  end
+end
+```
+
+##### Destroy or delete models
+
+Models can be used or the model class and key can be specified.
+`#destroy` uses callbacks and validations. Use `#delete` to skip
+callbacks and validations.
+
+```ruby
+article = Article.find('1')
+tag = article.tag
+
+Dynamoid::TransactionWrite.execute do |txn|
+  txn.destroy(article)
+  txn.delete(tag)
+
+  txn.delete(Tag, '2') # delete record with hash key '2' if it exists
+  txn.delete(Tag, 'key#abcd', 'range#1') # when sort key is required
+end
+```
+
+##### Validation failures that don't raise
+
+All of the transaction methods can be called without the `!` which
+results in `false` instead of a raised exception when validation fails.
+Ignoring validation failures can lead to confusion or bugs so always
+check return status when not using a method with `!`.
+
+```ruby
+user = User.find('1')
+user.red = true
+
+Dynamoid::TransactionWrite.execute do |txn|
+  if txn.save(user) # won't raise validation exception
+    txn.update_fields(UserCount, user.id, count: 5)
+  else
+    puts 'ALERT: user not valid, skipping'
+  end
+end
+```
+
+##### Incrementally building a transaction
+
+Transactions can also be built without a block.
+
+```ruby
+transaction = Dynamoid::TransactionWrite.new
+
+transaction.create(User, id: user_id)
+transaction.create(UserEmail, id: "UserEmail##{email}", user_id: user_id)
+transaction.upsert(Address, 'A#1', street: '123')
+
+transaction.commit # changes are persisted in this moment
+```
+
+#### Reading transactions
+
+Multiple reading actions can be grouped together and submitted as an
+all-or-nothing operation. Atomic  operations are supported in Dynamoid
+using transactions. If any action in the transaction fails they all
+fail.
+
+The following actions are supported:
+
+* `#find` - load a single model or multiple models by its primary key
+
+These methods are supposed to behave exactly like their
+non-transactional counterparts.
+
+##### Find a model
+
+The `#find` action can load single model or multiple ones. Different
+model classes can be mixed in the same transactions. Result is returned
+as a plain list of all the found models. The order is preserved.
+
+```ruby
+user, address = Dynamoid::TransactionRead.execute do |t|
+  t.find(User, user_id)
+  t.find(Address, address_id)
+end
+```
+
+Multiple primary keys can be specified at once:
+
+```ruby
+users = Dynamoid::TransactionRead.execute do |t|
+  t.find(User, [id1, id2, id3])
+end
+```
+
+### PartiQL
+
+To run PartiQL statements `Dynamoid.adapter.execute` method should be
+used:
+
+```ruby
+Dynamoid.adapter.execute("UPDATE users SET name = 'Mike' WHERE id = '1'")
+```
+
+Parameters are also supported:
+
+```ruby
+Dynamoid.adapter.execute('SELECT * FROM users WHERE id = ?', ['1'])
+```
+
 ## Configuration
 
 Listed below are all configuration options.
@@ -1078,6 +1347,7 @@ Listed below are all configuration options.
 * `write_capacity` - is used at table or indices creation. Default is 20
   (units)
 * `warn_on_scan` - log warnings when scan table. Default is `true`
+* `error_on_scan` - raises an error when scan table. Default is `false`
 * `endpoint` - if provided, it communicates with the DynamoDB listening
   at the endpoint. This is useful for testing with
   [DynamoDB Local](http://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Tools.DynamoDBLocal.html)
@@ -1114,14 +1384,18 @@ Listed below are all configuration options.
   fields in ISO 8601 string format. Default is `false`
 * `store_date_as_string` - if `true` then Dynamoid stores :date fields
   in ISO 8601 string format. Default is `false`
+* `store_empty_string_as_nil` - store attribute's empty String value as NULL. Default is `true`
 * `store_boolean_as_native` - if `true` Dynamoid stores boolean fields
   as native DynamoDB boolean values. Otherwise boolean fields are stored
-  as string values `'t'` and `'f'`. Default is true
+  as string values `'t'` and `'f'`. Default is `true`
+* `store_binary_as_native` - if `true` Dynamoid stores binary fields
+  as native DynamoDB binary values. Otherwise binary fields are stored
+  as Base64 encoded string values. Default is `false`
 * `backoff` - is a hash: key is a backoff strategy (symbol), value is
   parameters for the strategy. Is used in batch operations. Default id
   `nil`
 * `backoff_strategies`: is a hash and contains all available strategies.
-  Default is { constant: ..., exponential: ...}
+  Default is `{ constant: ..., exponential: ...}`
 * `log_formatter`: overrides default AWS SDK formatter. There are
   several canned formatters: `Aws::Log::Formatter.default`,
   `Aws::Log::Formatter.colored` and `Aws::Log::Formatter.short`. Please
@@ -1139,6 +1413,9 @@ Listed below are all configuration options.
 * `http_read_timeout`:The number of seconds to wait for HTTP response
   data. Default option value is `nil`. If not specified effected value
   is `60`
+* `create_table_on_save`: if `true` then Dynamoid creates a
+  corresponding table in DynamoDB at model persisting if the table
+  doesn't exist yet. Default is `true`
 
 
 ## Concurrency
@@ -1277,11 +1554,18 @@ RSpec.configure do |config|
 end
 ```
 
+In addition, the first test for each model may fail if the relevant models are not included in `included_models`. This can be fixed by adding this line before the `DynamoidReset` module:
+```ruby
+Dir[File.join(Dynamoid::Config.models_dir, '**/*.rb')].sort.each { |file| require file }
+```
+Note that this will require _all_ models in your models folder - you can also explicitly require only certain models if you would prefer to.
+
 In Rails, you may also want to ensure you do not delete non-test data
 accidentally by adding the following to your test environment setup:
 
 ```ruby
 raise "Tests should be run in 'test' environment only" if Rails.env != 'test'
+
 Dynamoid.configure do |config|
   config.namespace = "#{Rails.application.railtie_name}_#{Rails.env}"
 end
@@ -1296,6 +1580,7 @@ order to troubleshoot and debug issues just set it:
 ```ruby
 class User
   include Dynamoid::Document
+
   field name
 end
 
@@ -1324,6 +1609,7 @@ just as accessible to the Ruby world as MongoDB.
 Also, without contributors the project wouldn't be nearly as awesome. So
 many thanks to:
 
+* [Chris Hobbs](https://github.com/ckhsponge)
 * [Logan Bowers](https://github.com/loganb)
 * [Lane LaRue](https://github.com/luxx)
 * [Craig Heneveld](https://github.com/cheneveld)
@@ -1406,4 +1692,29 @@ See [LICENSE][license] for the official [Copyright Notice][copyright-notice-expl
 
 [security]: https://github.com/Dynamoid/dynamoid/blob/master/SECURITY.md
 
-[semver]: http://semver.org/
+[⛳️gem]: https://rubygems.org/gems/dynamoid
+[⛳️version-img]: http://img.shields.io/gem/v/dynamoid.svg
+[⛳cclim-maint]: https://codeclimate.com/github/Dynamoid/dynamoid/maintainability
+[⛳cclim-maint-img♻️]: https://api.codeclimate.com/v1/badges/27fd8b6b7ff338fa4914/maintainability
+[🏘coveralls]: https://coveralls.io/github/Dynamoid/dynamoid?branch=master
+[🏘coveralls-img]: https://coveralls.io/repos/github/Dynamoid/dynamoid/badge.svg?branch=master
+[🖇codecov]: https://codecov.io/gh/Dynamoid/dynamoid
+[🖇codecov-img♻️]: https://codecov.io/gh/Dynamoid/dynamoid/branch/master/graph/badge.svg?token=84WeeoxaN9
+[🖇src-license]: https://github.com/Dynamoid/dynamoid/blob/master/LICENSE.txt
+[🖇src-license-img]: https://img.shields.io/badge/License-MIT-green.svg
+[🖐gitmoji]: https://gitmoji.dev
+[🖐gitmoji-img]: https://img.shields.io/badge/gitmoji-3.9.0-FFDD67.svg?style=flat
+[🚎yard]: https://www.rubydoc.info/gems/dynamoid
+[🚎yard-img]: https://img.shields.io/badge/yard-docs-blue.svg?style=flat
+[🧮semver]: http://semver.org/
+[🧮semver-img]: https://img.shields.io/badge/semver-2.0.0-FFDD67.svg?style=flat
+[🖐contributors]: https://github.com/Dynamoid/dynamoid/graphs/contributors
+[🖐contributors-img]: https://img.shields.io/github/contributors-anon/Dynamoid/dynamoid
+[📗keep-changelog]: https://keepachangelog.com/en/1.0.0/
+[📗keep-changelog-img]: https://img.shields.io/badge/keep--a--changelog-1.0.0-FFDD67.svg?style=flat
+[🖇sponsor-img]: https://img.shields.io/opencollective/all/dynamoid
+[🖇sponsor]: https://opencollective.com/dynamoid
+[🖇triage-help]: https://www.codetriage.com/dynamoid/dynamoid
+[🖇triage-help-img]: https://www.codetriage.com/dynamoid/dynamoid/badges/users.svg
+[🏘sup-wf]: https://github.com/Dynamoid/dynamoid/actions/workflows/ci.yml?query=branch%3Amaster
+[🏘sup-wf-img]: https://github.com/Dynamoid/dynamoid/actions/workflows/ci.yml/badge.svg?branch=master

data/SECURITY.md

@@ -0,0 +1,17 @@
+# Security Policy
+
+## Supported Versions
+
+| Version | Supported |
+|---------|-----------|
+| 3.7.x   | ✅         |
+| <= 3.6  | ❌         |
+| 2.x     | ❌         |
+| 1.x     | ❌         |
+| 0.x     | ❌         |
+
+## Reporting a Vulnerability
+
+Peter Boling is responsible for the security maintenance of this gem. Please find a way
+to [contact him directly](https://railsbling.com/contact) to report the issue. Include as much relevant information as
+possible.