dynamoid 3.8.0 → 3.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6e1643f808e93716814d86080198b41cdf26991d9e75614f7d877561590b23d9
-  data.tar.gz: 453bb6e2c52d73cc94db42ba550fc621524ecba4cc4703445a00977d013b5c9a
+  metadata.gz: c2cc1feec6853b756fff467fa687cf2eaa3a2dc5f0a88dac948e5a92a4aa1073
+  data.tar.gz: 7165e081fa9979c45e7402265138e62cb6ee3c1f6f594ab6949c1f984621bc89
 SHA512:
-  metadata.gz: 3cc09e208f6d1be1bf953efda001cb006fa8a752830e192a418ba449807163761427dd443fac32ee3cb34cf690e613c3ff1e34a3cf0515d50f609319b71c69e7
-  data.tar.gz: 8ded4ae6a694788719dfc152adb6890f5cd18ff38acf99e422b824ed28c2d010e54caf05016af230d3cb49e5900618ced303148ebbc6ea5dce391dc838c278b2
+  metadata.gz: e18700ff74b9466e1ec166706446a1dca5248c6b8c33365e469c74e9a67b92f4afc9cacb0a06c2698d5165f4b68a93cdd214b83f5e3b749b92bcaff06fbc7628
+  data.tar.gz: 9b18fb2522f90eb3cf9b0b6014ca24beb08bcdebf403c57487222c46ec71d306f4e85e686aa89607c77ad7d994359a934537e8d22202b145bd478c0862bf497b

data/CHANGELOG.md

@@ -5,15 +5,66 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
-### Fixed
 
+### Fixed
 ### Added
+### Changed
+### Removed
 
+## 3.10.0
+### Fixed
+* [#681](https://github.com/Dynamoid/dynamoid/pull/681) Fixed saving persisted model and deleting attributes with `nil` value if `config.store_attribute_with_nil_value` is `false`
+* [#716](https://github.com/Dynamoid/dynamoid/pull/716), [#691](https://github.com/Dynamoid/dynamoid/pull/691), [#687](https://github.com/Dynamoid/dynamoid/pull/687), [#660](https://github.com/Dynamoid/dynamoid/pull/660) Numerous fixes in README.md and RDoc documentation (@ndjndj, @kiharito, @dunkOnIT)
+### Added
+* [#656](https://github.com/Dynamoid/dynamoid/pull/656) Added a `create_table_on_save` configuration flag to create table on save (@imaximix)
+* [#697](https://github.com/Dynamoid/dynamoid/pull/697) Ensure Ruby 3.3 and Rails 7.1 versions are supported and added them on CI
 ### Changed
+* [#655](https://github.com/Dynamoid/dynamoid/pull/655) Support multiple `where` in the same chain with multiple conditions for the same field
 
-### Removed
+## 3.9.0 / 2023-04-13
+### Fixed
+* [#610](https://github.com/Dynamoid/dynamoid/pull/610) Specs in JRuby; Support for JRuby 9.4.0.0 (@pboling)
+* [#624](https://github.com/Dynamoid/dynamoid/pull/624) Fixed `#increment!`/`#decrement!` methods and made them compatible with Rails counterparts
+* [#626](https://github.com/Dynamoid/dynamoid/pull/626) Fixed saving empty Set and String and replacing with `nil` in `#update`, `#update!`, `.update_fields`, and `.upsert` methods
+* [#628](https://github.com/Dynamoid/dynamoid/pull/628) Fixed `.import` method to mark persisted model attributes as not changed/not dirty
+* [#632](https://github.com/Dynamoid/dynamoid/pull/632) Fixed `#save` called with `touch: false` option to set `updated_at` attribute even for a new record (to comply with Rails)
+* [#634](https://github.com/Dynamoid/dynamoid/pull/634) Fixed model callbacks:
+  * changed order of `save` and `create`/`update` callbacks - `save` callbacks are outer for the `create`/`update` ones
+  * removed `before_initialize` and `around_initialize` callbacks - there should be only `after_initialize` one
+* [#634](https://github.com/Dynamoid/dynamoid/pull/634) Fixed `#touch` method compatibility with a Rails counterpart:
+  * don't save other modified attributes - only timestamps
+  * don't perform validation and don't call `save`/`create`/`update` callbacks
+  * accept a list of attribute names, but not one name
+  * accept a `:time` option
+### Added
+* [#611](https://github.com/Dynamoid/dynamoid/pull/611) Add `rubocop-md` (@pboling)
+* [#612](https://github.com/Dynamoid/dynamoid/pull/612) Add `rubocop-rspec` (@pboling)
+* [#613](https://github.com/Dynamoid/dynamoid/pull/613) Add `rubocop-performance` and `rubocop-rake` (@pboling)
+  * Added `funding_uri` set to open collective: https://opencollective.com/dynamoid
+  * Added `required_ruby_version` as `>= 2.3.0` (which was already the minimum supported version of Ruby)
+* [#616](https://github.com/Dynamoid/dynamoid/pull/616) Upgrade `simplecov` (& remove `coveralls`) (@pboling)
+  * Setup GitHub actions for Code Coverage
+  * Setup GitHub actions for RuboCop linting
+  * Automate coverage feedback on Pull Requests via GitHub Actions and CodeCov
+* [#618](https://github.com/Dynamoid/dynamoid/pull/618) Upgrade README Badges (@pboling)
+* [#624](https://github.com/Dynamoid/dynamoid/pull/624) Added `:touch` option for `.inc` method to be more compatible with the Rails counterpart method `.update_counters`
+* [#627](https://github.com/Dynamoid/dynamoid/pull/627) Made the following methods in the Dirty API public (to comply with Rails):
+  * `clear_changes_information`
+  * `changes_applied`
+  * `clear_attribute_changes`
+* [#630](https://github.com/Dynamoid/dynamoid/pull/630) Added `Dynamoid::Adapter#execute` method to run PartiQL queries
+* [#634](https://github.com/Dynamoid/dynamoid/pull/634) Added `after_touch` callback and run it in the following methods:
+  * `#touch`
+  * `#increment!`
+  * `#decrement!`
+* [#642](https://github.com/Dynamoid/dynamoid/pull/642) Run specs on CI against Ruby 3.2
+* [#645](https://github.com/Dynamoid/dynamoid/pull/645) Added `after_find` callback
+### Changed
+* [#610](https://github.com/Dynamoid/dynamoid/pull/610) Switch to [`rubocop-lts`](https://rubocop-lts.gitlab.io/) (@pboling)
+* [#633](https://github.com/Dynamoid/dynamoid/pull/633) Change `#inspect` method to return only attributes
+* [#623](https://github.com/Dynamoid/dynamoid/pull/623) Optimized performance of persisting to send only changed attributes in a request to DynamoDB
 
-## 3.8.0
+## 3.8.0 / 2022-11-09
 ### Fixed
 * [#525](https://github.com/Dynamoid/dynamoid/pull/525) Don't mark an attribute as changed if new assigned value equals the old one (@a5-stable)
 * Minor changes in the documentation:

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
@@ -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,16 +94,16 @@ 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.credentials = credentials
+                  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 and 3.3, JRuby 9.4.x and against Rails versions: 4.2, 5.0, 5.1,
+5.2, 6.0, 6.1, 7.0 and 7.1.
 
 ## Setup
 
@@ -360,7 +357,6 @@ class User
   field :number, :number
   field :joined_at, :datetime
   field :hash, :serialized
-
 end
 ```
 
@@ -406,7 +402,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 +427,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
 
@@ -550,9 +546,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
@@ -684,14 +689,14 @@ 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
@@ -718,18 +723,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 +740,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 +789,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 +842,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 +856,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)
@@ -921,8 +914,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
@@ -965,6 +958,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 +1047,21 @@ 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*
 
+### 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.
@@ -1116,12 +1132,12 @@ Listed below are all configuration options.
   in ISO 8601 string format. Default is `false`
 * `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`
 * `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 +1155,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 +1296,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
@@ -1406,4 +1432,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.

data/dynamoid.gemspec

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'dynamoid/version'
+
+Gem::Specification.new do |spec|
+  spec.name = 'dynamoid'
+  spec.version = Dynamoid::VERSION
+
+  # Keep in sync with README
+  spec.authors = [
+    'Josh Symonds',
+    'Logan Bowers',
+    'Craig Heneveld',
+    'Anatha Kumaran',
+    'Jason Dew',
+    'Luis Arias',
+    'Stefan Neculai',
+    'Philip White',
+    'Peeyush Kumar',
+    'Sumanth Ravipati',
+    'Pascal Corpet',
+    'Brian Glusman',
+    'Peter Boling',
+    'Andrew Konchin'
+  ]
+  spec.email = ['andry.konchin@gmail.com', 'peter.boling@gmail.com', 'brian@stellaservice.com']
+
+  spec.description = "Dynamoid is an ORM for Amazon's DynamoDB that supports offline development, associations, querying, and everything else you'd expect from an ActiveRecord-style replacement."
+  spec.summary = "Dynamoid is an ORM for Amazon's DynamoDB"
+  # Ignore not commited files
+  spec.files = Dir[
+    'CHANGELOG.md',
+    'dynamoid.gemspec',
+    'lib/**/*',
+    'LICENSE.txt',
+    'README.md',
+    'SECURITY.md'
+  ]
+  spec.homepage = 'http://github.com/Dynamoid/dynamoid'
+  spec.licenses = ['MIT']
+  spec.require_paths = ['lib']
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = "https://github.com/Dynamoid/dynamoid/tree/v#{spec.version}"
+  spec.metadata['changelog_uri'] = "https://github.com/Dynamoid/dynamoid/blob/v#{spec.version}/CHANGELOG.md"
+  spec.metadata['bug_tracker_uri'] = 'https://github.com/Dynamoid/dynamoid/issues'
+  spec.metadata['documentation_uri'] = "https://www.rubydoc.info/gems/dynamoid/#{spec.version}"
+  spec.metadata['funding_uri'] = 'https://opencollective.com/dynamoid'
+  spec.metadata['wiki_uri'] = 'https://github.com/Dynamoid/dynamoid/wiki'
+  spec.metadata['rubygems_mfa_required'] = 'true'
+
+  spec.add_runtime_dependency 'activemodel', '>=4'
+  spec.add_runtime_dependency 'aws-sdk-dynamodb', '~> 1.0'
+  spec.add_runtime_dependency 'concurrent-ruby', '>= 1.0'
+
+  spec.add_development_dependency 'appraisal'
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'pry', '~> 0.14'
+  spec.add_development_dependency 'rake', '~> 13.0'
+  spec.add_development_dependency 'rexml'
+  spec.add_development_dependency 'rspec', '~> 3.12'
+  spec.add_development_dependency 'yard'
+end

data/lib/dynamoid/adapter.rb

@@ -142,7 +142,7 @@ module Dynamoid
       end
     end
 
-    %i[batch_get_item delete_item get_item list_tables put_item truncate batch_write_item batch_delete_item].each do |m|
+    %i[batch_get_item delete_item get_item list_tables put_item truncate batch_write_item batch_delete_item execute].each do |m|
       # Method delegation with benchmark to the underlying adapter. Faster than relying on method_missing.
       #
       # @since 0.2.0
@@ -163,6 +163,7 @@ module Dynamoid
       # https://eregon.me/blog/2019/11/10/the-delegation-challenge-of-ruby27.html
 
       return benchmark(method, *args) { adapter.send(method, *args, &block) } if adapter.respond_to?(method)
+
       super
     end
 
@@ -170,19 +171,25 @@ module Dynamoid
     # only really useful for range queries, since it can only find by one hash key at once. Only provide
     # one range key to the hash.
     #
+    #   Dynamoid.adapter.query('users', { id: [[:eq, '1']], age: [[:between, [10, 30]]] }, { batch_size: 1000 })
+    #
     # @param [String] table_name the name of the table
-    # @param [Hash] opts the options to query the table with
-    # @option opts [String] :hash_value the value of the hash key to find
-    # @option opts [Range] :range_value find the range key within this range
-    # @option opts [Number] :range_greater_than find range keys greater than this
-    # @option opts [Number] :range_less_than find range keys less than this
-    # @option opts [Number] :range_gte find range keys greater than or equal to this
-    # @option opts [Number] :range_lte find range keys less than or equal to this
-    #
-    # @return [Array] an array of all matching items
-    #
-    def query(table_name, opts = {})
-      adapter.query(table_name, opts)
+    # @param [Array[Array]] key_conditions conditions for the primary key attributes
+    # @param [Array[Array]] non_key_conditions (optional) conditions for non-primary key attributes
+    # @param [Hash] options (optional) the options to query the table with
+    # @option options [Boolean] :consistent_read You can set the ConsistentRead parameter to true and obtain a strongly consistent result
+    # @option options [Boolean] :scan_index_forward Specifies the order for index traversal: If true (default), the traversal is performed in ascending order; if false, the traversal is performed in descending order.
+    # @option options [Symbop] :select The attributes to be returned in the result (one of ALL_ATTRIBUTES, ALL_PROJECTED_ATTRIBUTES, ...)
+    # @option options [Symbol] :index_name The name of an index to query. This index can be any local secondary index or global secondary index on the table.
+    # @option options [Hash] :exclusive_start_key The primary key of the first item that this operation will evaluate.
+    # @option options [Integer] :batch_size The number of items to lazily load one by one
+    # @option options [Integer] :record_limit The maximum number of items to return (not necessarily the number of evaluated items)
+    # @option options [Integer] :scan_limit The maximum number of items to evaluate (not necessarily the number of matching items)
+    # @option options [Array[Symbol]] :project The attributes to retrieve from the table
+    #
+    # @return [Enumerable] matching items
+    def query(table_name, key_conditions, non_key_conditions = {}, options = {})
+      adapter.query(table_name, key_conditions, non_key_conditions, options)
     end
 
     def self.adapter_plugin_class

data/lib/dynamoid/adapter_plugin/aws_sdk_v3/create_table.rb

@@ -29,7 +29,7 @@ module Dynamoid
           gs_indexes = options[:global_secondary_indexes]
 
           key_schema = {
-            hash_key_schema: { key => (options[:hash_key_type] || :string) },
+            hash_key_schema: { key => options[:hash_key_type] || :string },
             range_key_schema: options[:range_key]
           }
           attribute_definitions = build_all_attribute_definitions(
@@ -69,7 +69,7 @@ module Dynamoid
             end
           end
           resp = client.create_table(client_opts)
-          options[:sync] = true if !options.key?(:sync) && ls_indexes.present? || gs_indexes.present?
+          options[:sync] = true if (!options.key?(:sync) && ls_indexes.present?) || gs_indexes.present?
 
           if options[:sync]
             status = PARSE_TABLE_STATUS.call(resp, :table_description)

data/lib/dynamoid/adapter_plugin/aws_sdk_v3/execute_statement.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Dynamoid
+  # @private
+  module AdapterPlugin
+    class AwsSdkV3
+      # Excecute a PartiQL query
+      #
+      # Documentation:
+      # - https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_ExecuteStatement.html
+      # - https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/DynamoDB/Client.html#execute_statement-instance_method
+      #
+      # NOTE: For reads result may be paginated. Only pagination with NextToken
+      # is implemented. Currently LastEvaluatedKey in response cannot be fed to
+      # ExecuteStatement to get the next page.
+      #
+      # See also:
+      # - https://repost.aws/questions/QUgNPbBYWiRoOlMsJv-XzrWg/how-to-use-last-evaluated-key-in-execute-statement-request
+      # - https://stackoverflow.com/questions/71438439/aws-dynamodb-executestatement-pagination
+      class ExecuteStatement
+        attr_reader :client, :statement, :parameters, :options
+
+        def initialize(client, statement, parameters, options)
+          @client = client
+          @statement = statement
+          @parameters = parameters
+          @options = options.symbolize_keys.slice(:consistent_read)
+        end
+
+        def call
+          request = {
+            statement: @statement,
+            parameters: @parameters,
+            consistent_read: @options[:consistent_read],
+          }
+
+          response = client.execute_statement(request)
+
+          unless response.next_token
+            return response_to_items(response)
+          end
+
+          Enumerator.new do |yielder|
+            yielder.yield(response_to_items(response))
+
+            while response.next_token
+              request[:next_token] = response.next_token
+              response = client.execute_statement(request)
+              yielder.yield(response_to_items(response))
+            end
+          end
+        end
+
+        private
+
+        def response_to_items(response)
+          response.items.map(&:symbolize_keys)
+        end
+      end
+    end
+  end
+end