dynomite 1.2.7 → 2.0.0

data/lib/dynomite/item/components.rb

@@ -0,0 +1,33 @@
+class Dynomite::Item
+  module Components
+    extend ActiveSupport::Concern
+
+    included do
+      extend Indexes
+      extend Memoist
+      extend TableNamespace
+
+      include ActiveModel::Validations::Callbacks
+
+      define_model_callbacks :initialize, :find, :touch, only: :after
+      define_model_callbacks :save, :create, :update, :destroy
+
+      include PrimaryKey
+      include MagicFields # created_at, updated_at, partition_key (primary_key: id)
+      include Id
+    end
+
+    include Dynomite::Client
+    include Dsl
+    include ActiveModel::Model
+    include ActiveModel::Callbacks
+    include ActiveModel::Dirty
+    include ActiveModel::Serialization
+    include WaiterMethods
+    include Sti
+    include Locking
+    include Dynomite::Associations
+    include Read
+    include Write
+  end
+end

data/lib/dynomite/item/dsl.rb

@@ -0,0 +1,101 @@
+require "dynomite/reserved_words"
+
+class Dynomite::Item
+  module Dsl
+    extend ActiveSupport::Concern
+
+    class_methods do
+      # Defines column. Defined column can be accessed by getter and setter methods of the same
+      # name (e.g. [model.my_column]). Attributes with undefined columns can be accessed by
+      # [model.attrs] method.
+      def fields(*names)
+        if names.empty? # getter
+          fields_meta # meta info for all fields
+        else # setter
+          names.each(&method(:add_field))
+        end
+      end
+      alias_method :columns, :fields
+
+      # @see Item.column
+      def add_field(name, options={})
+        name = name.to_sym
+        return if self.field_names.include?(name)
+        self.fields_map[name] = options # store original options for reference for fields_meta
+
+        if Dynomite::RESERVED_WORDS.include?(name.to_s)
+          raise Dynomite::Error::ReservedWord, "'#{name}' is a reserved word"
+        end
+
+        # https://guides.rubyonrails.org/active_model_basics.html#dirty
+        # Dirty support. IE: changed? and changed_attributes
+        # Requires us to define the attribute method this way
+        define_attribute_methods name # for dirty support
+
+        define_method(name) do
+          @attrs ||= {}
+          value = @attrs[name]
+          typecaster = Typecaster.new(self)
+          type = options[:type] || Dynomite.config.default_field_type
+          typecaster.cast_to_type(type, value)
+        end
+
+        define_method("#{name}=") do |value|
+          @attrs ||= {}
+
+          typecaster = Typecaster.new(self)
+          type = options[:type] || Dynomite.config.default_field_type
+          value_casted = typecaster.cast_to_type(type, value, on: :write)
+          old_value = read_attribute(name)
+          old_value = typecaster.cast_to_type(type, old_value, on: :write)
+
+          send "#{name}_will_change!" if old_value != value_casted # from define_attribute_methods *names
+          @attrs[name] = value_casted
+        end
+
+        define_method("#{name}?") do
+          !!send(name)
+        end if options[:type] == :boolean
+
+        if default = options[:default]
+          method_name = "set_#{name}_default".to_sym
+          define_method(method_name) do
+            return unless read_attribute(name).nil?
+            value = case default
+                    when Symbol
+                      send(default)
+                    when Proc
+                      default.call
+                    else
+                      default
+                    end
+            send("#{name}=", value)
+          end
+          before_save method_name
+        end
+      end
+      alias_method :field, :add_field
+      alias_method :column, :add_field
+
+      def field_names
+        klass, field_names = self, []
+        while klass.respond_to?(:fields_map)
+          current_field_names = klass.fields_map.keys || []
+          field_names += current_field_names
+          klass = klass.superclass
+        end
+        field_names.sort
+      end
+      alias_method :column_names, :field_names
+
+      def fields_meta
+        klass, fields_meta = self, {}
+        while klass.respond_to?(:fields_map)
+          fields_meta.merge!(klass.fields_map)
+          klass = klass.superclass
+        end
+        fields_meta
+      end
+    end
+  end
+end

data/lib/dynomite/item/id.rb

@@ -0,0 +1,41 @@
+class Dynomite::Item
+  module Id
+    extend ActiveSupport::Concern
+
+    included do
+      field :id
+      before_save :set_id
+    end
+
+    def set_id
+      return if self.class.disable_id?
+      self.id ||= generate_id
+    end
+
+    def generate_id
+      "#{id_prefix}-#{SecureRandom.alphanumeric(16)}"
+    end
+
+    def id_prefix
+      self.class.id_prefix_value
+    end
+
+    class_methods do
+      def disable_id?
+        !!@disable_id
+      end
+
+      def disable_id!
+        @disable_id = true
+      end
+
+      def id_prefix(value=nil)
+        if value.nil?
+          self.id_prefix_value
+        else
+          self.id_prefix_value = value
+        end
+      end
+    end
+  end
+end

data/lib/dynomite/item/indexes/finder.rb

@@ -0,0 +1,58 @@
+module Dynomite::Item::Indexes
+  class Finder
+    extend Memoist
+    include Dynomite::Client
+
+    def initialize(source, query)
+      @source, @query = source, query
+    end
+
+    def find(index_name=nil)
+      if index_name # explicit index name
+        index = @source.indexes.find { |i| i.index_name == index_name }
+        if index
+          return index
+        else
+          logger.info <<~EOL
+            WARN: Index #{index_name} specified but not found for table #{@source.table_name}
+            Falling back to auto-discovery of indexes
+          EOL
+        end
+      end
+
+      # auto-discover
+      find_primary_key_index || find_secondary_index
+    end
+
+    def find_primary_key_index
+      PrimaryIndex.new(@source.primary_key_fields) if primary_key_found?
+    end
+
+    def primary_key_found?
+      if @source.composite_key?
+        query_fields.include?(@source.partition_key_field) && query_fields.include?(@source.sort_key_field)
+      else
+        query_fields.include?(@source.partition_key_field)
+      end
+    end
+
+    # It's possible to have multiple indexes with the same partition and sort key.
+    # Will use the first one we find.
+    def find_secondary_index
+      @source.indexes.find do |i|
+        # If query field has comparision expression like
+        #   Product.where("category.in": ["Electronics"]).count
+        # then it wont match, which is correct.
+        intersect = query_fields & i.fields
+        intersect == i.fields
+      end
+    end
+
+    def query_fields
+      @query[:where].inject([]) do |result, where_group|
+        result += where_group.fields
+      end.uniq.sort.map(&:to_s)
+    end
+    memoize :query_fields
+  end
+end

data/lib/dynomite/item/indexes/index.rb

@@ -0,0 +1,21 @@
+module Dynomite::Item::Indexes
+  class Index
+    delegate :index_name, :key_schema, :projection, :index_status, :index_size_bytes, :item_count, :index_arn,
+      to: :data
+
+    attr_reader :data
+    def initialize(data)
+      @data = data # from describe_table.table.global_secondary_indexes items
+    end
+
+    def fields
+      key_schema.map do |hash|
+        hash.attribute_name
+      end.sort
+    end
+
+    def primary?
+      false
+    end
+  end
+end

data/lib/dynomite/item/indexes/primary_index.rb

@@ -0,0 +1,18 @@
+module Dynomite::Item::Indexes
+  class PrimaryIndex
+    attr_reader :fields
+    def initialize(fields)
+      @fields = fields
+    end
+
+    # primary index is the table itself
+    # no name. LSI and GSI have names.
+    def index_name
+      "primary_key (fields: #{fields.join(", ")})"
+    end
+
+    def primary?
+      true
+    end
+  end
+end

data/lib/dynomite/item/indexes.rb

@@ -0,0 +1,25 @@
+class Dynomite::Item
+  module Indexes
+    def index_names
+      indexes.map(&:index_name)
+    end
+
+    # Sorted by indexes with composite keys with partition and sort keys first
+    # so they take priority for Indexes::Finder#find
+    def indexes
+      lsi = local_secondary_indexes.map { |i| Index.new(i) }.sort_by { |i| i.fields.size * -1 }
+      gsi = global_secondary_indexes.map { |i| Index.new(i) }.sort_by { |i| i.fields.size * -1 }
+      lsi + gsi
+    end
+
+    def local_secondary_indexes
+      table = desc_table(table_name)
+      table.local_secondary_indexes.to_a
+    end
+
+    def global_secondary_indexes
+      table = desc_table(table_name)
+      table.global_secondary_indexes.to_a.select { |i| i.index_status == "ACTIVE" }
+    end
+  end
+end

data/lib/dynomite/item/locking.rb

@@ -0,0 +1,53 @@
+class Dynomite::Item
+  module Locking
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :locking_field_name
+    end
+
+    class_methods do
+      def enable_locking(field_name=:lock_version)
+        class_eval do
+          field field_name, type: :integer
+          self.locking_field_name = field_name
+          before_save :increment_lock_version
+        end
+      end
+      alias enable_optimistic_locking enable_locking
+      alias locking_field enable_locking
+
+      def locking_enabled?
+        locking_field_name.present?
+      end
+    end
+
+    def increment_lock_version
+      return unless changed?
+      reader = self.class.locking_field_name
+      setter = "#{reader}="
+      send(setter, 0) if send(reader).nil?
+      send(setter, send(reader) + 1)
+    end
+
+    # Tricky: Must use dot notation for dirty tracking so old values are stored in case of a
+    # exceptional failure in the DynamoDB API put_item call in write/save.rb
+    # Example:
+    #
+    #   post.update_attribute(:title, nil) # update attribute bypasses validations
+    #
+    #   AWS Error:
+    #
+    # The AttributeValue for a key attribute cannot contain an empty string value.
+    # IndexName: title-index, IndexKey: title (Aws::DynamoDB::Errors::ValidationException)
+    #
+    # This allows the old value to be restored. And then the next update with a corrected
+    # title value saves successfully.
+    #
+    def reset_lock_version_was
+      reader = self.class.locking_field_name
+      setter = "#{reader}="
+      send(setter, send("#{reader}_was"))
+    end
+  end
+end

data/lib/dynomite/item/magic_fields.rb

@@ -0,0 +1,66 @@
+class Dynomite::Item
+  module MagicFields
+    extend ActiveSupport::Concern
+
+    included do
+      field :created_at, type: :time
+      field :updated_at, type: :time
+      before_save :set_created_at
+      before_save :set_updated_at
+      before_save :set_sort_key
+      before_save :set_partition_key
+    end
+
+    def set_sort_key
+      return unless sort_key_field
+      return if @attrs[sort_key_field]
+      @attrs.merge!(sort_key_field => generate_random_key_schema_value("RANGE")) # RANGE is the sort key
+    end
+
+    def set_partition_key
+      return if @attrs[partition_key_field]
+      if partition_key_field.to_s == "id"
+        @attrs.merge!(partition_key_field => generate_id) # IE: post-0GKjo3Ck0OBL6nAi
+      else
+        @attrs.merge!(partition_key_field => generate_random_key_schema_value("HASH")) # HASH is the partition key
+      end
+    end
+
+    def generate_random_key_schema_value(key_type)
+      attribute_name = key_schema.find { |a| a.key_type == key_type }.attribute_name
+      attribute_type = attribute_definitions.find { |a| a.attribute_name == attribute_name }.attribute_type
+      case attribute_type
+      when "N" # number
+        # 40 digit number that does not start with 0
+        first_digit = rand(1..9) # Generate a random digit from 1 to 9
+        rest_of_digits = Array.new(39) { rand(0..9) }.join # Generate the remaining 39 digits
+        random_number = "#{first_digit}#{rest_of_digits}"
+        random_number.to_i
+      when "S" # string
+        # 40 character string
+        Digest::SHA1.hexdigest([Time.now, rand].join) # IE: fead3c000892e9e8c78e821411bbaa9dc3cb938c
+      end
+    end
+
+    def set_created_at
+      self.created_at ||= Time.now
+    end
+
+    def set_updated_at
+      self.updated_at = Time.now if changed?
+    end
+
+    class_methods do
+      # Called in dynomite/engine.rb since need table name
+      def discover_fields!
+        return if abstract? # IE: ApplicationItem Dynomite::Item
+        attribute_definitions.each do |attr|
+          method_name = attr.attribute_name.to_sym
+          field method_name unless public_method_defined?(method_name)
+        end
+      rescue Aws::DynamoDB::Errors::ResourceNotFoundException => e
+        nil # Table does not exist yet
+      end
+    end
+  end
+end

data/lib/dynomite/item/primary_key.rb

@@ -0,0 +1,85 @@
+class Dynomite::Item
+  module PrimaryKey
+    extend ActiveSupport::Concern
+
+    delegate :partition_key_field, :hash_key_field, :sort_key_field, :range_key_field,
+             :primary_key_fields, :primary_key, :composite_key, :composite_key?,
+             :attribute_definitions, :hash_key, :range_key, :key_schema,
+             to: :class
+
+    included do
+      before_update :check_primary_key_changed!
+    end
+
+    def check_primary_key_changed!
+      if primary_key_changed?
+        changed_primary_keys = changed & primary_key_fields
+        raise Dynomite::Error::PrimaryKeyChangedError, "Cannot change the primary key of an existing record: #{changed_primary_keys}"
+      end
+    end
+
+    def partition_key
+      send(partition_key_field) if partition_key_field
+    end
+    alias hash_key partition_key
+
+    def sort_key
+      send(sort_key_field) if sort_key_field
+    end
+    alias range_key sort_key
+
+    # Example: {category: "books", sku: "302"}
+    def primary_key
+      primary_key = {}
+      primary_key[partition_key_field.to_sym] = partition_key
+      primary_key[sort_key_field.to_sym] = sort_key if sort_key_field
+      primary_key
+    end
+
+    def primary_key_changed?
+      !(changed & primary_key_fields).empty?
+    end
+
+    class_methods do
+      extend Memoist
+
+      def partition_key_field
+        discover_schema_key("HASH") unless abstract?
+      end
+      alias hash_key_field partition_key_field
+
+      def sort_key_field
+        discover_schema_key("RANGE") unless abstract?
+      end
+      alias range_key_field sort_key_field
+
+      def primary_key_fields
+        composite_key? ? composite_key : [partition_key_field] # ensure Array to make interface consistent
+      end
+
+      def composite_key
+        [partition_key_field, sort_key_field] if composite_key?
+      end
+
+      def composite_key?
+        !!sort_key_field
+      end
+
+      def attribute_definitions
+        table = desc_table(table_name)
+        table.attribute_definitions
+      end
+
+      def key_schema
+        table = desc_table(table_name)
+        table.key_schema
+      end
+
+      def discover_schema_key(key_type)
+        table = desc_table(table_name)
+        table.key_schema.find { |a| a.key_type == key_type }&.attribute_name
+      end
+      memoize :discover_schema_key
+    end
+  end
+end

data/lib/dynomite/item/query/delegates.rb

@@ -0,0 +1,28 @@
+module Dynomite::Item::Query
+  module Delegates
+    extend ActiveSupport::Concern
+
+    # Makes Relation methods like where, or, not, limit, etc available as model class methods.
+    # Post.where(category: 'ruby').limit(10)
+    class_methods do
+      delegates = Relation::Chain.public_instance_methods(false) +
+                  Relation::Math.public_instance_methods(false) +
+                  Relation::Ids.public_instance_methods(false) +
+                  Relation::Delete.public_instance_methods(false)
+      delegates.each do |method|
+        delegate method, to: :all
+      end
+
+      # Most of thoese methods are free from Enumerable, except: last
+      delegate :last, :any?, :many?, :each_page, :pages, :raw_pages,
+               to: :all
+
+      # point of entry for query
+      def all
+        relation = Relation.new(self)
+        relation.where(type: name) if sti_enabled?
+        relation
+      end
+    end
+  end
+end

data/lib/dynomite/item/query/params/base.rb

@@ -0,0 +1,42 @@
+class Dynomite::Item::Query::Params
+  class Base
+    extend Memoist
+    include Dynomite::Types
+    include Helpers
+
+    # To add function example:
+    # 1. params/base.rb function_names
+    # 2. query/chain.rb: add method
+    # 3. params/function/begins_with.rb: filter_expression, attribute_names, attribute_values
+    def function_names
+      %w[attribute_exists attribute_type begins_with contains size_fn]
+    end
+
+    def join_expressions
+      joined = ''
+      @expressions.each do |expression|
+        string = expression_string(expression)
+        if joined.empty? # first pass
+          joined << string
+        else
+          if !expression.is_a?(String) && expression.or?
+            joined << " OR #{string}"
+          else
+            joined << " AND #{string}"
+          end
+        end
+      end
+      joined
+    end
+
+    def expression_string(expression)
+      if expression.is_a?(String)
+        # Function filter expression is simple String
+        expression
+      else
+        # Else expression is CompressionExpression object with extra info like .or?
+        expression.build  # build the string
+      end
+    end
+  end
+end

data/lib/dynomite/item/query/params/expression_attribute.rb

@@ -0,0 +1,79 @@
+class Dynomite::Item::Query::Params
+  class ExpressionAttribute < Base
+    def initialize(relation)
+      @relation = relation
+      @names, @values = {}, {}
+    end
+
+    def names
+      build
+      @names
+    end
+
+    def values
+      build
+      @values
+    end
+
+    def build
+      build_where
+      build_functions
+      build_project_expression
+    end
+    memoize :build
+
+    def build_where
+      with_where_groups do |where_group|
+        where_group.each do |where_field|
+          field = where_field.field
+          reference = where_field.reference
+          value = where_field.value
+          @names["##{reference}"] = field
+
+          model_class = @relation.source
+          meta = model_class.fields_meta[field.to_sym] # can be nil if field is not defined
+          type = meta ? meta[:type] : :infer
+
+          if where_field.operator == "in" || value.is_a?(Array)
+            array = Array(value)
+            array.each_with_index do |v, i|
+              @values[":#{reference}_#{i}"] = cast_to_type(type, v, on: :query)
+            end
+          else
+            @values[":#{reference}"] = cast_to_type(type, value, on: :query)
+          end
+        end
+      end
+    end
+
+    # https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html
+    def build_functions
+      # Essentially
+      #    @names.merge!(Function::AttributeExists.new(@query).attribute_names)
+      #    @names.merge!(Function::AttributeType.new(@query).attribute_names)
+      #    @names.merge!(Function::BeginsWith.new(@query).attribute_names)
+      function_names.each do |function_name|
+        function = Function.const_get(function_name.camelize).new(@relation.query)
+        @names.merge!(function.attribute_names)
+        @values.merge!(function.attribute_values)
+      end
+    end
+
+    def build_project_expression
+      return if @relation.query[:projection_expression].nil?
+      projection_expression = normalize_project_expression(@relation.query[:projection_expression])
+      projection_expression.each do |field|
+        field = field.to_s
+        @names["##{field}"] = field
+      end
+    end
+
+  private
+
+    delegate :cast_to_type, to: :typecaster
+    def typecaster
+      Dynomite::Item::Typecaster.new(@relation.source)
+    end
+    memoize :typecaster
+  end
+end

data/lib/dynomite/item/query/params/filter.rb

@@ -0,0 +1,41 @@
+class Dynomite::Item::Query::Params
+  class Filter < Base
+    def initialize(relation, index)
+      @relation, @index = relation, index
+      @expressions = []
+    end
+
+    def build
+      build_where
+      build_functions
+    end
+    memoize :build
+
+    def expression
+      build
+      join_expressions
+    end
+
+    def build_where
+      with_where_groups do |where_group|
+        expression = where_group.build_compare_expression_if do |field|
+          @index.nil? || !@index.fields.include?(field)
+        end
+        @expressions << expression if expression
+      end
+    end
+
+    # https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html
+    def build_functions
+      # Essentially
+      #    @expressions += Function::AttributeExists.new(@query).filter_expression
+      #    @expressions += Function::AttributeType.new(@query).filter_expression
+      #    @expressions += Function::BeginsWith.new(@query).filter_expression
+      function_names.each do |function_name|
+        function = Function.const_get(function_name.camelize).new(@relation.query)
+        filter_expression = function.filter_expression
+        @expressions += filter_expression
+      end
+    end
+  end
+end