dynomite 1.2.6 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6f80bf11d2121217d52d8ceac89defcd4e738b3ff220847f7421b1337fbc104f
-  data.tar.gz: cd1a4fb8c66678458c8e08b3222064ea3153129f31d1a81ff7ee6d25f1ac3928
+  metadata.gz: '0609ff0c2a5e95266162de30b16a2c10a9be1255f1ce4ed23672fea369dc67b0'
+  data.tar.gz: a7e2eb874c3be932c85e04f027d7c5da778bf6cc9671e1d173a169e62109ad83
 SHA512:
-  metadata.gz: 890d2960cd53cec65a93b81b31fb61da535f123f4718d5e870eb2983813811352e2bbf93043007389ee85224590e2484ec0f2b0c5f377b384c5cf886923a87fd
-  data.tar.gz: 1e2ab49bfc684afe96927971d2a57544b9d4898bb1271b920b88969e267b79f5271c4bf71ed07f45b4b160c5f27ef7ff943250c62e42eb1ce1c1c81d720e78ab
+  metadata.gz: 872e734331f516ae93d2c9a89452258ed448058597bfff3854e82d68b6e80bfe8a18a61a65167c3435c20776d8a58f01288787c441a2738cb126ee22db4620ca
+  data.tar.gz: 2f572680129343676ed4a92a9aa58d979f494d2da1fb26592681959ef14a4bd670c0f5cf9ac8705e611ce1d09384ccd78f56b16fbbd6285344c25f74557f9620

data/.gitignore

@@ -1,10 +1,25 @@
+.bundle
+.config
+*.gem
+*.rbc
+/_yardoc/
 /.bundle/
 /.yardoc
-/Gemfile.lock
-/_yardoc/
 /coverage/
 /doc/
+/Gemfile.lock
 /pkg/
 /spec/reports/
 /tmp/
+coverage
+doc/
+Gemfile.lock
+InstalledFiles
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
 vendor/bundle

data/CHANGELOG.md

@@ -3,6 +3,30 @@
 All notable changes to this project will be documented in this file.
 This project *tries* to adhere to [Semantic Versioning](http://semver.org/), even before v1.0.
 
+## [2.0.0] - 2023-12-03
+- [#35](https://github.com/tongueroo/dynomite/pull/35) ActiveModel compatible
+- Breaking change interface to be ActiveModel compatible
+- ActiveModel: validations, callbacks, etc
+- Use zeitwerk for autoloading
+- Typecast support for DateTime-like objects. Store date as iso8601 string.
+- Remove config/dynamodb.yml in favor of Dynomite.configure for use with initializers
+- namespace separator default is _ instead of -
+- Dynomite.logger introduced
+- arel like where query builder interface
+- finder methods: all, first, last, find_by, find, count
+- index finder: automatically use query over scan with where when possible
+- organize query to read and write ruby files
+- Migrations: improved migrate command. No need to specify files.
+- namespaced schema_migrations table tracks ran migrations.
+- Favor ondemand provisioning vs explicit provisioned_throughput
+- Standalone dynamodb cli to generate migrations and run them
+
+## [1.2.7] - 2022-06-12
+- [#23](https://github.com/tongueroo/dynomite/pull/23) #where method refactor to allow Model.index_name('index').where(...)
+- [#24](https://github.com/tongueroo/dynomite/pull/24) Add get_endpoint_ip to db_config.rb
+- [#26](https://github.com/tongueroo/dynomite/pull/26) change pay_per_use to pay_per_request
+- [#27](https://github.com/tongueroo/dynomite/pull/27) Fixed message that tells how to install dynamodb-local
+
 ## [1.2.6]
 - Implement the `PAY_PER_USE` billing mode for table creations and updates. See [DynamoDB On Demand](https://aws.amazon.com/blogs/aws/amazon-dynamodb-on-demand-no-capacity-planning-and-pay-per-request-pricing/).
 

data/Gemfile

@@ -2,9 +2,5 @@ source "https://rubygems.org"
 
 git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
 
-# Specify your gem's dependencies in dynomite.gemspec
+# Specify your gem dependencies in dynomite.gemspec
 gemspec
-
-group :development, :test do
-  gem "activemodel"
-end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) Tung Nguyen
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -1,195 +1,13 @@
 # Dynomite
 
-[![BoltOps Badge](https://img.boltops.com/boltops/badges/boltops-badge.png)](https://www.boltops.com)
-
-NOTE: Am looking for maintainers to help with this gem. Send me an email!  Also [dynamoid](https://github.com/Dynamoid/dynamoid) seems like a good option that should be considered delegating to or straight using. Learning on delegation so we can have better default behavior for a DynamoDB model layer for Jets.
-
-A simple wrapper library to make DynamoDB usage a little more friendly.  The modeling is ActiveRecord-ish but not exactly because DynamoDB is a different type of database.  Examples below explain it best:
-
-## Jets Docs
-
-* [Database DynamoDB](https://rubyonjets.com/docs/database/dynamodb/)
-
-## Examples
-
-First define a class:
-
-```ruby
-class Post < Dynomite::Item
-  # partition_key "id" # optional, defaults to id
-
-  column :id, :title, :desc
-end
-```
-
-### Create
-
-```ruby
-post = Post.new
-post = post.replace(title: "test title")
-post.attrs # {"id" => "generated-id", title" => "test title"}
-```
-
-`post.attrs[:id]` now contain a generated unique partition_key id.  Usually the partition_key is 'id'. You can set your own unique id also by specifying id.
-
-```ruby
-post = Post.new(id: "myid", title: "my title")
-post.replace
-post.attrs # {"id" => "myid", title" => "my title"}
-```
-
-Note that the replace method replaces the entire item, so you need to merge the attributes if you want to keep the other attributes.  Know this is weird, but this is how DynamoDB works.
-
-### Find
-
-```ruby
-post = Post.find("myid")
-post.attrs = post.attrs.deep_merge("desc": "my desc") # keeps title field
-post.replace
-post.attrs # {"id" => "myid", title" => "my title", desc: "my desc"}
-```
-
-The convenience `attrs` method performs a deep_merge:
-
-```ruby
-post = Post.find("myid")
-post.attrs("desc": "my desc 2") # <= does a deep_merge
-post.replace
-post.attrs # {"id" => "myid", title" => "my title", desc: "my desc 2"}
-```
-
-Note, a race condition edge case can exist when several concurrent replace
-calls are happening.  This is why the interface is called replace to
-emphasize that possibility.
-
-### Delete
-
-```ruby
-resp = Post.delete("myid")  # dynamodb client resp
-# or
-post = Post.find("myid")
-resp = post.delete  # dynamodb client resp
-```
-
-### Scan
-
-```ruby
-options = {}
-posts = Post.scan(options)
-posts # Array of Post items.  [Post.new, Post.new, ...]
-```
-
-### Query
-
-```ruby
-posts = Post.query(
-  index_name: 'category-index',
-  expression_attribute_names: { "#category_name" => "category" },
-  expression_attribute_values: { ":category_value" => "Entertainment" },
-  key_condition_expression: "#category_name = :category_value",
-)
-posts # Array of Post items.  [Post.new, Post.new, ...]
-```
-
-### Where
-
-The where could be prettied up. Appreciate any pull requests.
-
-```ruby
-Post.where({category: "Drama"}, {index_name: "category-index"})
-```
-
-Examples are also in [item_spec.rb](spec/lib/dynomite/item_spec.rb).
+[![Gem Version](https://badge.fury.io/rb/dynomite.svg)](http://badge.fury.io/rb/dynomite)
 
-## Column Lists
-
-You can define your column list using the `column` method inside your item class. This gives you
-a possibility to access your column fields using getters and setters. Also, any predefined column
-can be passed to `ActiveModel::Validations` (see Validations).
-
-```ruby
-class Post < Dynomite::Item
-  column :id, :name
-end
-
-post = Post.new
-post.name = "My First Post"
-post.replace
-
-puts post.id # 1962DE7D852298C5CDC809C0FEF50D8262CEDF09
-puts post.name # "My First Post"
-```
-
-Note that any column not defined using the `column` method can still be accessed using the `attrs`
-method.
-
-## Validations
-
-You can add validations known from ActiveRecord to your Dynomite items.
-Just add `include ActiveModel::Validations` at the top of your item class.
-
-```ruby
-class Post < Dynomite::Item
-  include ActiveModel::Validations
-
-  column :id, :name # needed
-
-  validates :id, presence: true
-  validates :name, presence: true
-end
-```
-
-**Be sure to define all validated columns using `column` method**.
-
-Validations are executed by default as soon as you call the `replace` method, returning `false` on
-failure. It also can be ran manually using the `valid?` method just like with ActiveRecord models.
-
-
-## Migration Support
-
-Dynomite supports ActiveRecord-like migrations.  Here's a short example:
-
-```ruby
-class CreateCommentsMigration < Dynomite::Migration
-  def up
-    create_table :comments do |t|
-      t.partition_key "post_id:string" # required
-      t.sort_key  "created_at:string" # optional
-      t.provisioned_throughput(5) # sets both read and write, defaults to 5 when not set
-    end
-  end
-end
-```
-
-More examples are in the [docs/migrations](docs/migrations) folder.
-
-## Installation
-
-Add this line to your application's Gemfile:
-
-```ruby
-gem 'dynomite'
-```
-
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
-
-    $ gem install dynomite
-
-## Development
-
-After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
-
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+[![BoltOps Badge](https://img.boltops.com/boltops/badges/boltops-badge.png)](https://www.boltops.com)
 
-## Contributing
+[![BoltOps Learn Badge](https://img.boltops.com/boltops-learn/boltops-learn.png)](https://learn.boltops.com)
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/tongueroo/dynomite.
+A DynamoDB ORM that is ActiveModel compatible.
 
-### TODO
+## Dynomite Docs
 
-* improve Post.where.  Something like `Post.index_name("user_id").where(category_name: "Entertainment")` would be nice.
-* implement `post.update` with `db.update_item` in a Ruby-ish way
+* [Database Dynomite](https://rubyonjets.com/docs/database/dynamodb/)

data/Rakefile

@@ -1,2 +1,14 @@
 require "bundler/gem_tasks"
-task :default => :spec
+require "rspec/core/rake_task"
+
+task default: :spec
+
+RSpec::Core::RakeTask.new
+
+require_relative "lib/dynomite"
+require "cli_markdown"
+desc "Generates cli reference docs as markdown"
+task :docs do
+  mkdir_p "docs/_includes"
+  CliMarkdown::Creator.create_all(cli_class: Dynomite::CLI, cli_name: "dynomite")
+end

data/dynomite.gemspec

@@ -9,9 +9,9 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Tung Nguyen"]
   spec.email         = ["tongueroo@gmail.com"]
 
-  spec.summary       = %q{ActiveRecord-ish Dynamodb Model}
-  spec.description   = %q{ActiveRecord-ish Dynamodb Model}
+  spec.summary       = "ActiveRecord-ish DynamoDB ORM"
   spec.homepage      = "https://github.com/tongueroo/dynomite"
+  spec.license       = "MIT"
 
   spec.files         = `git ls-files -z`.split("\x0").reject do |f|
     f.match(%r{^(test|spec|features)/})
@@ -20,11 +20,18 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
+  spec.add_dependency "activemodel"
   spec.add_dependency "activesupport"
   spec.add_dependency "aws-sdk-dynamodb"
+  spec.add_dependency "memoist"
   spec.add_dependency "rainbow"
+  spec.add_dependency "thor"
+  spec.add_dependency "zeitwerk"
 
   spec.add_development_dependency "bundler"
+  spec.add_development_dependency "byebug"
+  spec.add_development_dependency "cli_markdown"
+  spec.add_development_dependency "nokogiri"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec"
 end

data/exe/dynomite

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+# Trap ^C
+Signal.trap("INT") {
+  puts "\nCtrl-C detected. Exiting..."
+  sleep 0.1
+  exit
+}
+
+$:.unshift(File.expand_path("../../lib", __FILE__))
+require "dynomite"
+require "dynomite/cli"
+
+Dynomite::CLI.start(ARGV)

data/lib/dynomite/associations/association.rb

@@ -0,0 +1,126 @@
+module Dynomite
+  # The base association module which all associations include. Every association has two very important components: the source and
+  # the target. The source is the object which is calling the association information. It always has the target_ids inside of an attribute on itself.
+  # The target is the object which is referencing by this association.
+  module Associations
+    module Association
+      attr_accessor :name, :options, :source, :loaded
+
+      # Create a new association.
+      #
+      # @param [Class] source the source record of the association; that is, the record that you already have
+      # @param [Symbol] name the name of the association
+      # @param [Hash] options optional parameters for the association
+      # @option options [Class] :class the target class of the association; that is, the class to which the association objects belong
+      # @option options [Symbol] :class_name the name of the target class of the association; only this or Class is necessary
+      # @option options [Symbol] :inverse_of the name of the association on the target class
+      # @option options [Symbol] :foreign_key the name of the field for belongs_to association
+      #
+      # @return [Dynomite::Association] the actual association instance itself
+      def initialize(source, name, options)
+        @source = source
+        @name = name
+        @options = options
+        @loaded = false
+      end
+
+      def coerce_to_id(object)
+        object.respond_to?(:partition_key) ? object.partition_key : object
+      end
+
+      def coerce_to_item(object)
+        object.is_a?(String) ? target_class.find(object) : object
+      end
+
+      def loaded?
+        @loaded
+      end
+
+      def find_target; end
+
+      def target
+        unless loaded?
+          @target = find_target
+          @loaded = true
+        end
+
+        @target
+      end
+
+      def reader_target
+        self
+      end
+
+      def reset
+        @target = nil
+        @loaded = false
+      end
+
+      def declaration_field_name
+        "#{name}_ids"
+      end
+
+      def declaration_field_type
+        :set
+      end
+
+      private
+
+      # The target class name, either inferred through the association's name or specified in options.
+      def target_class_name
+        options[:class_name] || name.to_s.classify
+      end
+
+      # The target class, either inferred through the association's name or specified in options.
+      def target_class
+        options[:class] || target_class_name.constantize
+      end
+
+      # The target attribute: that is, the attribute on each object of the association that should reference the source.
+      def target_attribute
+        # In simple case it's equivalent to
+        # "#{target_association}_ids".to_sym if target_association
+        if target_association
+          target_options = target_class.associations[target_association]
+          assoc = Dynomite::Associations.const_get(target_options[:type].to_s.camelcase).new(nil, target_association, target_options)
+          assoc.send(:source_attribute)
+        end
+      end
+
+      # The ids in the target association.
+      def target_ids
+        target.send(target_attribute) || Set.new
+      end
+
+      # The ids in the target association.
+      def source_class
+        source.class
+      end
+
+      # The source's association attribute: the name of the association with _ids afterwards, like "users_ids".
+      def source_attribute
+        declaration_field_name.to_sym
+      end
+
+      # The ids in the source association.
+      def source_ids
+        # handle case when we store scalar value instead of collection (when foreign_key option is specified)
+        Array(source.send(source_attribute)).compact.to_set || Set.new
+      end
+
+      # Create a new instance of the target class without trying to add it to the association. This creates a base, that caller can update before setting or adding it.
+      #
+      # @param attributes [Hash] attribute values for the new object
+      #
+      # @return [Dynomite::Item] the newly-created object
+      def build(attributes = {})
+        target_class.build(attributes)
+      end
+
+      def association_method_name(name)
+        name = name.to_s.end_with?("_association") ? name : "#{name}_association"
+        name.starts_with?("_") ? name : "_#{name}"
+      end
+    end
+  end
+end

data/lib/dynomite/associations/belongs_to.rb

@@ -0,0 +1,35 @@
+module Dynomite
+  # The belongs_to association. For belongs_to, we reference only a single target instead of multiple records; that target is the
+  # item to which the association item is associated.
+  module Associations
+    class BelongsTo
+      include SingleAssociation
+
+      def declaration_field_type
+        if options[:foreign_key]
+          target_class.attributes[target_class.partition_key][:type]
+        else
+          :set
+        end
+      end
+
+      private
+
+      # Find the target association, either has_many or has_one. Uses either options[:inverse_of] or the source class name and default parsing to
+      # return the most likely name for the target association.
+      def target_association
+        has_many_key_name = options[:inverse_of] || source.class.to_s.underscore.pluralize.to_sym
+        has_one_key_name = options[:inverse_of] || source.class.to_s.underscore.to_sym
+        unless target_class.associations[has_many_key_name].nil?
+          method_name = association_method_name(has_many_key_name)
+          return method_name if target_class.associations[has_many_key_name][:type] == :has_many
+        end
+
+        unless target_class.associations[has_one_key_name].nil?
+          method_name = association_method_name(has_one_key_name)
+          return method_name if target_class.associations[has_one_key_name][:type] == :has_one
+        end
+      end
+    end
+  end
+end

data/lib/dynomite/associations/has_and_belongs_to_many.rb

@@ -0,0 +1,19 @@
+module Dynomite
+  module Associations
+    class HasAndBelongsToMany
+      include ManyAssociation
+
+      private
+
+      # Find the target association, always another :has_and_belongs_to_many association. Uses either options[:inverse_of] or the source class name
+      # and default parsing to return the most likely name for the target association.
+      def target_association
+        key_name = options[:inverse_of] || source.class.to_s.pluralize.underscore.to_sym
+        guess = target_class.associations[key_name]
+        return nil if guess.nil? || guess[:type] != :has_and_belongs_to_many
+
+        association_method_name(key_name)
+      end
+    end
+  end
+end

data/lib/dynomite/associations/has_many.rb

@@ -0,0 +1,19 @@
+module Dynomite
+  module Associations
+    class HasMany
+      include ManyAssociation
+
+      private
+
+      # Find the target association, always a :belongs_to association. Uses either options[:inverse_of] or the source class name
+      # and default parsing to return the most likely name for the target association.
+      def target_association
+        key_name = options[:inverse_of] || source.class.to_s.singularize.underscore.to_sym
+        guess = target_class.associations[key_name]
+        return nil if guess.nil? || guess[:type] != :belongs_to
+
+        association_method_name(key_name)
+      end
+    end
+  end
+end

data/lib/dynomite/associations/has_one.rb

@@ -0,0 +1,19 @@
+module Dynomite
+  module Associations
+    class HasOne
+      include SingleAssociation
+
+      private
+
+      # Find the target association, always a :belongs_to association. Uses either options[:inverse_of] or the source class name
+      # and default parsing to return the most likely name for the target association.
+      def target_association
+        key_name = options[:inverse_of] || source.class.to_s.singularize.underscore.to_sym
+        guess = target_class.associations[key_name]
+        return nil if guess.nil? || guess[:type] != :belongs_to
+
+        association_method_name(key_name)
+      end
+    end
+  end
+end