dynomite 1.2.7 → 2.0.0

data/lib/dynomite/associations/many_association.rb

@@ -0,0 +1,257 @@
+module Dynomite
+  module Associations
+    module ManyAssociation
+      include Association
+
+      attr_accessor :query
+
+      def initialize(*args)
+        @query = {}
+        super
+      end
+
+      include Enumerable
+
+      # Delegate methods to the records the association represents.
+      delegate :first, :last, :empty?, :size, :class, to: :records
+
+      # @return the has many association. IE: user.posts
+      def find_target
+        return [] if source_ids.empty?
+
+        # IE: user.posts - target class is Post
+        if target_class.partition_key_field == "id" && target_class.sort_key_field.nil?
+          # Quick find lookup
+          Array(target_class.find(source_ids.to_a, raise_error: false))
+        else
+          relation.to_a
+        end
+      end
+
+      def relation
+        return [] if source_ids.empty? # check again in case user calls relation directly. IE: user.posts.relation
+        # Slow scan lookup because of the in operator
+        target_class.where("id.in": source_ids.to_a)
+      end
+
+      def records
+        if query.empty?
+          target
+        else
+          results_with_query(target)
+        end
+      end
+
+      # Alias convenience methods for the associations.
+      alias all records
+      alias count size
+      alias nil? empty?
+
+      # Delegate include? to the records.
+      def include?(item)
+        records.include?(item)
+      end
+
+      # Add an item or array of items to an association.
+      #
+      #   tag.posts << post
+      #   tag.posts << [post1, post2, post3]
+      #
+      # This preserves the current records in the association (if any) and adds
+      # the item to the target association if it is detected to exist.
+      #
+      # It saves both models immediately - the source model and the target one
+      # so any not saved changes will be saved as well.
+      #
+      # @param item [Dynomite::Item|Array] model (or array of models) to add to the association
+      # @return [Dynomite::Item] the added model
+      def <<(item)
+        item = coerce_to_item(item)
+        # normal relationship
+        associate_one_way(item)
+
+        # inverse relationship
+        if target_association
+          Array(item).each { |obj| obj.send(target_association).associate_one_way(source) }
+        end
+
+        item
+      end
+      alias associate <<
+
+      def associate_one_way(item)
+        items = Array(item)
+        ids = items.collect { |o| coerce_to_id(o) }
+        ids = source_ids.merge(ids)
+        source.update_attribute_presence(source_attribute, ids)
+      end
+
+      # Removes an item or array of items from the association.
+      #
+      #   tag.posts.disassociate(post)
+      #   tag.posts.disassociate(post1, post2, post3)
+      #   tag.posts.disassociate([post1, post2, post3])
+      #
+      # This removes their records from the association field on the source,
+      # and attempts to remove the source from the target association if it is
+      # detected to exist.
+      #
+      # It saves both models immediately - the source model and the target one
+      # so any not saved changes will be saved as well.
+      #
+      # @param item [Dynomite::Item|Array] model (or array of models) to remove from the association
+      # @return [Dynomite::Item|Array] the deleted model
+      def disassociate(*items)
+        items.flatten!
+        items.map! { |item| coerce_to_item(item) }
+        # normal relationship
+        items.each { |item| disassociate_one_way(item) }
+
+        # inverse relationship
+        if target_association
+          items.each { |obj| obj.send(target_association).disassociate_one_way(source) }
+        end
+      end
+
+      def disassociate_one_way(item)
+        ids = source_ids - Array(coerce_to_id(item))
+        source.update_attribute_presence(source_attribute, ids)
+      end
+
+      def disassociate_all
+        # target is all items. IE: user.posts
+        target.each do |item|
+          disassociate(item)
+        end
+      end
+
+      # Replace an association with item or array of items. This removes all of the existing associated records and replaces them with
+      # the passed item(s), and associates the target association if it is detected to exist.
+      #
+      # @param [Dynomite::Item] item the item (or array of items) to add to the association
+      #
+      # @return [Dynomite::Item|Array] the added item
+      def setter(item)
+        target.each { |i| disassociate(i) }
+        self << item
+        item
+      end
+
+      # Create a new instance of the target class, persist it and add directly
+      # to the association.
+      #
+      #   tag.posts.create!(title: 'foo')
+      #
+      # Several models can be created at once when an array of attributes
+      # specified:
+      #
+      #   tag.posts.create!([{ title: 'foo' }, {title: 'bar'} ])
+      #
+      # If the creation fails an exception will be raised.
+      #
+      # @param attributes [Hash] attribute values for the new item
+      # @return [Dynomite::Item|Array] the newly-created item
+      def create!(attributes = {})
+        self << target_class.create!(attributes)
+      end
+
+      # Create a new instance of the target class, persist it and add directly
+      # to the association.
+      #
+      #   tag.posts.create(title: 'foo')
+      #
+      # Several models can be created at once when an array of attributes
+      # specified:
+      #
+      #   tag.posts.create([{ title: 'foo' }, {title: 'bar'} ])
+      #
+      # @param attributes [Hash] attribute values for the new item
+      # @return [Dynomite::Item|Array] the newly-created item
+      def create(attributes = {})
+        self << target_class.create(attributes)
+      end
+
+      # Create a new instance of the target class and add it directly to the association. If the create fails an exception will be raised.
+      #
+      # @return [Dynomite::Item] the newly-created item
+      def each(&block)
+        records.each(&block)
+      end
+
+      # Destroys all members of the association and removes them from the
+      # association.
+      #
+      #   tag.posts.destroy_all
+      #
+      def destroy_all
+        objs = target
+        source.update_attribute_presence(source_attribute, nil)
+        objs.each(&:destroy)
+      end
+
+      # Deletes all members of the association and removes them from the
+      # association.
+      #
+      #   tag.posts.delete_all
+      #
+      def delete_all
+        objs = target
+        source.update_attribute_presence(source_attribute, nil)
+        objs.each(&:delete)
+      end
+
+      def destroy_all
+        objs = target
+        source.update_attribute_presence(source_attribute, nil)
+        objs.each(&:destroy)
+      end
+
+      # Naive association filtering.
+      #
+      #   tag.posts.where(title: 'foo')
+      #
+      # It loads lazily all the associated models and checks provided
+      # conditions. That's why only equality conditions can be specified.
+      #
+      # @param args [Hash] A hash of attributes; each must match every returned item's attribute exactly.
+      # @return [Dynomite::Association] the association this method was called on (for chaining purposes)
+      def where(args)
+        filtered = clone
+        filtered.query = query.clone
+        args.each { |k, v| filtered.query[k] = v }
+        filtered
+      end
+
+      # Is this array equal to the association's records?
+      #
+      # @return [Boolean] true/false
+      def ==(other)
+        records == Array(other)
+      end
+
+      # Delegate methods we don't find directly to the records array.
+      def method_missing(method, *args)
+        if records.respond_to?(method)
+          records.send(method, *args)
+        else
+          super
+        end
+      end
+
+      private
+
+      # If a query exists, filter all existing results based on that query.
+      #
+      # @param [Array] results the raw results for the association
+      #
+      # @return [Array] the filtered results for the query
+      def results_with_query(results)
+        results.find_all do |result|
+          query.all? do |attribute, value|
+            result.send(attribute) == value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dynomite/associations/single_association.rb

@@ -0,0 +1,157 @@
+module Dynomite
+  module Associations
+    module SingleAssociation
+      include Association
+
+      # target field name. IE: posts.user_id
+      def declaration_field_name
+        options[:foreign_key] || "#{name}_id"
+      end
+
+      def reader_target
+        target
+      end
+
+      def setter(item)
+        if item.nil?
+          disassociate
+        else
+          associate(item)
+        end
+      end
+
+      def associate(item)
+        item = coerce_to_item(item)
+        associate_one_way(item)
+
+        # inverse relationship
+        should_reload = false
+        Array(target).each do |target_entry|
+          if target_entry && target_association
+            target_entry.send(target_association).associate_one_way(source)
+            should_reload = true
+          end
+        end
+        target.reload if should_reload
+
+        self.target = item
+      end
+
+      def associate_one_way(item)
+        # normal relationship
+        source.update_attribute_presence(source_attribute, coerce_to_id(item))
+      end
+
+      def disassociate(_ = nil)
+        # inverse relationship: user.posts removal. run first before target is nil
+        should_reload = false
+        Array(target).each do |target_entry|
+          if target_entry && target_association
+            target_entry.send(target_association).disassociate_one_way(source)
+            should_reload = true
+          end
+        end
+        target.reload if should_reload
+
+        # normal relationship: post.user removal
+        disassociate_one_way
+
+        self.target = nil
+      end
+
+      # Delete a model from the association.
+      #
+      #   post.logo.disassociate # => nil
+      #
+      # Saves both models immediately - a source model and a target one so any
+      # unsaved changes will be saved. Doesn't delete an associated model from
+      # DynamoDB.
+      #
+      #   _ = nil so can keep the same interface for removing has_many_and_belongs_to associations
+      #
+      def disassociate_one_way(_ = nil)
+        # normal relationship: post.user removal
+        source.update_attribute_presence(source_attribute, nil)
+      end
+
+      # Create a new instance of the target class, persist it and associate.
+      #
+      #   post.logo.create!(hight: 50, width: 90)
+      #
+      # If the creation fails an exception will be raised.
+      #
+      # @param attributes [Hash] attributes of a model to create
+      # @return [Dynomite::Item] created model
+      def create!(attributes = {})
+        setter(target_class.create!(attributes))
+      end
+
+      # Create a new instance of the target class, persist it and associate.
+      #
+      #   post.logo.create(hight: 50, width: 90)
+      #
+      # @param attributes [Hash] attributes of a model to create
+      # @return [Dynomite::Item] created model
+      def create(attributes = {})
+        setter(target_class.create(attributes))
+      end
+
+      # Is this item equal to the association's target?
+      #
+      # @return [Boolean] true/false
+      def ==(other)
+        target == other
+      end
+
+      if ::RUBY_VERSION < '2.7'
+        # Delegate methods we don't find directly to the target.
+        def method_missing(method, *args, &block)
+          if target.respond_to?(method)
+            target.send(method, *args, &block)
+          else
+            super
+          end
+        end
+      else
+        # Delegate methods we don't find directly to the target.
+        def method_missing(method, *args, **kwargs, &block)
+          if target.respond_to?(method)
+            target.send(method, *args, **kwargs, &block)
+          else
+            super
+          end
+        end
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        target.respond_to?(method_name, include_private) || super
+      end
+
+      def nil?
+        target.nil?
+      end
+
+      def empty?
+        # This is needed to that ActiveSupport's #blank? and #present?
+        # methods work as expected for SingleAssociations.
+        target.nil?
+      end
+
+      private
+
+      # Find the target of the has_one association.
+      #
+      # @return [Dynomite::Item] the found target (or nil if nothing)
+      def find_target
+        return if source_ids.empty?
+
+        target_class.find(source_ids.first, raise_error: false)
+      end
+
+      def target=(item)
+        @target = item
+        @loaded = true
+      end
+    end
+  end
+end

data/lib/dynomite/associations.rb

@@ -0,0 +1,248 @@
+# frozen_string_literal: true
+
+module Dynomite
+  # Connects models together through the magic of associations. We enjoy four different kinds of associations presently:
+  #   * belongs_to
+  #   * has_and_belongs_to_many
+  #   * has_many
+  #   * has_one
+  module Associations
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      # Create the association tracking attribute and initialize it to an empty hash.
+      def inherited(base)
+        base.class_attribute :associations, instance_accessor: false
+        base.associations = {}
+      end
+
+      # Declare a +has_many+ association for this document.
+      #
+      #   class Category < ApplicationItem
+      #     has_many :posts
+      #   end
+      #
+      # Association is an enumerable collection and supports following addition
+      # operations:
+      #
+      # * +create+
+      # * +create!+
+      # * +destroy_all+
+      # * +delete_all+
+      # * +delete+
+      # * +<<+
+      # * +where+
+      # * +all+
+      # * +empty?+
+      # * +size+
+      #
+      # When a name of an associated class doesn't match an association name a
+      # class name should be specified explicitly either with +class+ or
+      # +class_name+ option:
+      #
+      #   has_many :labels, class: Tag
+      #   has_many :labels, class_name: 'Tag'
+      #
+      # When associated class has own +belongs_to+ association to
+      # the current class and the name doesn't match a name of the current
+      # class this name can be specified with +inverse_of+ option:
+      #
+      #   class Post < ApplicationItem
+      #     belongs_to :item, class_name: 'Tag'
+      #   end
+      #
+      #   class Tag < ApplicationItem
+      #     has_many :posts, inverse_of: :item
+      #   end
+      #
+      # @param name [Symbol] the name of the association
+      # @param options [Hash] options to pass to the association constructor
+      # @option options [Class] :class the target class of the has_many association; that is, the belongs_to class
+      # @option options [String] :class_name the name of the target class of the association; that is, the name of the belongs_to class
+      # @option options [Symbol] :inverse_of the name of the association on the target class; that is, if the class has a belongs_to association, the name of that association
+      #
+      # @since 0.2.0
+      def has_many(name, options = {})
+        association(:has_many, name, options)
+      end
+
+      # Declare a +has_one+ association for this document.
+      #
+      #   class Image < ApplicationItem
+      #     has_one :post
+      #   end
+      #
+      # Association supports following operations:
+      #
+      # * +create+
+      # * +create!+
+      # * +delete+
+      #
+      # When a name of an associated class doesn't match an association name a
+      # class name should be specified explicitly either with +class+ or
+      # +class_name+ option:
+      #
+      #   has_one :item, class: Post
+      #   has_one :item, class_name: 'Post'
+      #
+      # When associated class has own +belong_to+ association to the current
+      # class and the name doesn't match a name of the current class this name
+      # can be specified with +inverse_of+ option:
+      #
+      #   class Post < ApplicationItem
+      #     belongs_to :logo, class_name: 'Image'
+      #   end
+      #
+      #   class Image < ApplicationItem
+      #     has_one :post, inverse_of: :logo
+      #   end
+      #
+      # @param name [Symbol] the name of the association
+      # @param options [Hash] options to pass to the association constructor
+      # @option options [Class] :class the target class of the has_one association; that is, the belongs_to class
+      # @option options [String] :class_name the name of the target class of the association; that is, the name of the belongs_to class
+      # @option options [Symbol] :inverse_of the name of the association on the target class; that is, if the class has a belongs_to association, the name of that association
+      #
+      # @since 0.2.0
+      def has_one(name, options = {})
+        association(:has_one, name, options)
+      end
+
+      # Declare a +belongs_to+ association for this document.
+      #
+      #   class Post < ApplicationItem
+      #     belongs_to :categories
+      #   end
+      #
+      # Association supports following operations:
+      #
+      # * +create+
+      # * +create!+
+      # * +delete+
+      #
+      # When a name of an associated class doesn't match an association name a
+      # class name should be specified explicitly either with +class+ or
+      # +class_name+ option:
+      #
+      #   belongs_to :item, class: Post
+      #   belongs_to :item, class_name: 'Post'
+      #
+      # When associated class has own +has_many+ or +has_one+ association to
+      # the current class and the name doesn't match a name of the current
+      # class this name can be specified with +inverse_of+ option:
+      #
+      #   class Category < ApplicationItem
+      #     has_many :items, class_name: 'Post'
+      #   end
+      #
+      #   class Post < ApplicationItem
+      #     belongs_to :categories, inverse_of: :items
+      #   end
+      #
+      # By default a hash key attribute name is +id+. If an associated class
+      # uses another name for a hash key attribute it should be specified in
+      # the +belongs_to+ association:
+      #
+      #   belongs_to :categories, foreign_key: :uuid
+      #
+      # @param name [Symbol] the name of the association
+      # @param options [Hash] options to pass to the association constructor
+      # @option options [Class] :class the target class of the has_one association; that is, the has_many or has_one class
+      # @option options [String] :class_name the name of the target class of the association; that is, the name of the has_many or has_one class
+      # @option options [Symbol] :inverse_of the name of the association on the target class; that is, if the class has a has_many or has_one association, the name of that association
+      # @option options [Symbol] :foreign_key the name of a hash key attribute in the target class
+      #
+      # @since 0.2.0
+      def belongs_to(name, options = {})
+        association(:belongs_to, name, options)
+      end
+
+      # Declare a +has_and_belongs_to_many+ association for this document.
+      #
+      #   class Post < ApplicationItem
+      #     has_and_belongs_to_many :tags
+      #   end
+      #
+      # Association is an enumerable collection and supports following addition
+      # operations:
+      #
+      # * +create+
+      # * +create!+
+      # * +destroy_all+
+      # * +delete_all+
+      # * +delete+
+      # * +<<+
+      # * +where+
+      # * +all+
+      # * +empty?+
+      # * +size+
+      #
+      # When a name of an associated class doesn't match an association name a
+      # class name should be specified explicitly either with +class+ or
+      # +class_name+ option:
+      #
+      #   has_and_belongs_to_many :labels, class: Tag
+      #   has_and_belongs_to_many :labels, class_name: 'Tag'
+      #
+      # When associated class has own +has_and_belongs_to_many+ association to
+      # the current class and the name doesn't match a name of the current
+      # class this name can be specified with +inverse_of+ option:
+      #
+      #   class Tag < ApplicationItem
+      #     has_and_belongs_to_many :items, class_name: 'Post'
+      #   end
+      #
+      #   class Post < ApplicationItem
+      #     has_and_belongs_to_many :tags, inverse_of: :items
+      #   end
+      #
+      # @param name [Symbol] the name of the association
+      # @param options [Hash] options to pass to the association constructor
+      # @option options [Class] :class the target class of the has_and_belongs_to_many association; that is, the belongs_to class
+      # @option options [String] :class_name the name of the target class of the association; that is, the name of the belongs_to class
+      # @option options [Symbol] :inverse_of the name of the association on the target class; that is, if the class has a belongs_to association, the name of that association
+      #
+      # @since 0.2.0
+      def has_and_belongs_to_many(name, options = {})
+        association(:has_and_belongs_to_many, name, options)
+      end
+
+      private
+
+      # create getters and setters for an association.
+      #
+      # @param type [Symbol] the type (:has_one, :has_many, :has_and_belongs_to_many, :belongs_to) of the association
+      # @param name [Symbol] the name of the association
+      # @param options [Hash] options to pass to the association constructor; see above for all valid options
+      #
+      # @since 0.2.0
+      def association(type, name, options = {})
+        # Declare document field.
+        # In simple case it's equivalent to
+        # field "#{name}_ids".to_sym, :set
+        assoc = Dynomite::Associations.const_get(type.to_s.camelcase).new(nil, name, options)
+        field_name = assoc.declaration_field_name
+        field_type = assoc.declaration_field_type
+
+        field field_name.to_sym, type: field_type
+
+        associations[name] = options.merge(type: type)
+
+        define_method(name) do
+          # Do not cache reader method. it causes issues with user.posts << post. The user.posts is stale.
+          Dynomite::Associations.const_get(type.to_s.camelcase).new(self, name, options).reader_target
+        end
+
+        # hidden method so we still have access to the association object
+        define_method("_#{name}_association") do
+          @associations[:"#{name}_association"] ||= Dynomite::Associations.const_get(type.to_s.camelcase).new(self, name, options)
+        end
+
+        define_method("#{name}=".to_sym) do |objects|
+          @associations[:"#{name}_association"] ||= Dynomite::Associations.const_get(type.to_s.camelcase).new(self, name, options)
+          @associations[:"#{name}_association"].setter(objects)
+        end
+      end
+    end
+  end
+end

data/lib/dynomite/autoloader.rb

@@ -0,0 +1,25 @@
+require "zeitwerk"
+
+module Dynomite
+  class Autoloader
+    class Inflector < Zeitwerk::Inflector
+      def camelize(basename, _abspath)
+        map = { cli: "CLI", version: "VERSION" }
+        map[basename.to_sym] || super
+      end
+    end
+
+    class << self
+      def setup
+        loader = Zeitwerk::Loader.new
+        loader.inflector = Inflector.new
+        loader.push_dir(File.dirname(__dir__)) # lib
+        loader.ignore("#{File.dirname(__dir__)}/jets/commands")
+        loader.ignore("#{__dir__}/migration/internal/*")
+        loader.ignore("#{__dir__}/migration/templates/*")
+        loader.ignore("#{__dir__}/reserved_words.rb")
+        loader.setup
+      end
+    end
+  end
+end