dynamodb_record 0.2.2 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e0019712191d0f7ba069ba581bd04a59a5c9dd985d34bc5f7cb2865f08820ac4
-  data.tar.gz: 02ebcbed904cfeca08deb41a315ea9a018068f1be9747a8e884b289e782a132e
+  metadata.gz: 90c0fa26f80217dbc4d6a3f2e3fa0197a485fdcaf4bb845232c276d67c2c678e
+  data.tar.gz: 61d5b4ca06cfb8906902aee1ae6bafc0c4613f03edfb402447514f9877317143
 SHA512:
-  metadata.gz: f6ea7a0acbdf7f5eaa2ebecd8aef15613fafe0337af8ab67d31b648572ed51cf0b08fd24b06dc137895ebd6f2d6e6789cf942b961e708d5e33c67f32a9bbb27e
-  data.tar.gz: 8cbd27b3dc8a12546aadeeabff96d94a4b8e3a562dbef7f2d980acdf7dea7f73ef863a17c62e4b5e662e7661383f5da59d54dadaad556881d3fcdfcae744e8a5
+  metadata.gz: ea0d8a245f9f6a41c47d4cf0ef9f5ba056c31712588146b9b14f0c0886f36b487fa691c79383e93bbe34e3c87ceebdd5e8b80bb3b4f1a4ed48812944a9970985
+  data.tar.gz: 3c734251bd6e00ebc3ab048e702b9ed133296e0acdc09690b6da12b8c9ec7edb3f13d09a28c837d2393dc637359e228c36e334365e1a497f11890145d8db92e9

data/.rubocop.yml

@@ -0,0 +1,55 @@
+AllCops:
+  TargetRubyVersion: 3.2
+  NewCops: enable
+  Exclude:
+    - 'spec/dummy/bin/*'
+    - vendor/**
+    - 'vendor/**/*'
+    - vendor/bundle/**/*
+    - bin/**
+Layout/SpaceInsideHashLiteralBraces:
+  EnforcedStyle: no_space
+Metrics/BlockLength:
+  Max: 36
+  Exclude:
+    - spec/**/*.rb
+    - fleteo.gemspec
+
+Lint/ConstantDefinitionInBlock:
+  Exclude:
+    - spec/**/**/*.rb
+Metrics/BlockNesting:
+  Max: 2
+Metrics/MethodLength:
+  CountComments: false
+  Max: 15
+Metrics/ModuleLength:
+  Max: 120
+Metrics/ClassLength:
+  Max: 120
+Metrics/ParameterLists:
+  Max: 5
+  CountKeywordArgs: true
+Style/CollectionMethods:
+  Enabled: true
+  PreferredMethods:
+    collect:  'map'
+    collect!: 'map!'
+    inject:   'reduce'
+    find:     'detect'
+    find_all: 'select'
+    delete:   'gsub'
+Layout/DotPosition:
+  EnforcedStyle: trailing
+
+#Layout/LineLength:
+#  Max: 100
+
+Style/TrailingCommaInArrayLiteral:
+  EnforcedStyleForMultiline: 'no_comma'
+
+Style/TrailingCommaInHashLiteral:
+  EnforcedStyleForMultiline: 'no_comma'
+
+Gemspec/DevelopmentDependencies:
+  EnforcedStyle: gemspec

data/dynamodb_record.gemspec

@@ -16,7 +16,6 @@ Gem::Specification.new do |spec|
 
   spec.files         = `git ls-files -z`.split("\x0")
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ['lib']
 
   spec.add_dependency 'activesupport', '~> 7.1', '>= 7.1.3.2'
@@ -29,4 +28,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'rubocop', '~> 1.62'
   spec.add_development_dependency 'vcr', '~> 6.2'
   spec.add_development_dependency 'webmock', '~> 3.23'
+  spec.metadata['rubygems_mfa_required'] = 'true'
 end

data/lib/dynamodb_record/associations.rb

@@ -5,24 +5,66 @@ module DynamodbRecord
     extend ActiveSupport::Concern
 
     class_methods do
+      def belongs_to(association)
+        association = association.to_s
+
+        define_method(association) do
+          id = send("#{association}_id")
+          klass = Object.const_get(association.capitalize)
+          klass.find!(id)
+        end
+      end
+
+      # rubocop:disable Naming/PredicateName
       def has_many(associations)
-        model = associations.to_s.upcase.chop
-        define_method(associations) do
-          # options = self.class.default_options
-          field = self.class.to_s.downcase
-          options = { table_name: associations }
-          options.merge!(key_condition_expression: "##{field}_id = :#{field}_id")
-          options.merge!(expression_attribute_names: { "##{field}_id": "#{field}_id" })
-          options.merge!(expression_attribute_values: { ":#{field}_id" => id })
+        base_model = to_s.downcase
+        model = associations.to_s.chop
+        # field = self.class.to_s.downcase
+        table = Config.namespace ? "#{Config.namespace}-#{associations}" : associations
 
-          options.merge!(index_name: "#{self.class.to_s.downcase}_id_index")
+        options = {table_name: table}
+        options.merge!(key_condition_expression: "##{base_model}_id = :#{base_model}_id")
+        options.merge!(expression_attribute_names: {"##{base_model}_id": "#{base_model}_id"})
+        options.merge!(index_name: "#{base_model}_id_index")
 
+        define_method(associations) do
+          options.merge!(expression_attribute_values: {":#{base_model}_id" => id})
           klass = Object.const_get(model.capitalize)
-          # puts options
-          response = self.class.client.query(options)
+          query = QueryPager.new(options, klass)
+          HasManyCollection.new(query, self)
+        end
+      end
 
-          # pager = DynamodbRecord::Pager.new(self.class.client, options, clase)
-          DynamodbRecord::Collection.new(response, klass, options)
+      def has_many_through(associations, table)
+        base_model = to_s.downcase
+        relation_model = associations.to_s.chop
+        list = []
+        list << base_model
+        list << relation_model
+        sorted_list = list.sort
+        options = {table_name: table.to_s}
+
+        field = if sorted_list.first == base_model
+                  sorted_list.first
+                else
+                  sorted_list.last
+                end
+        options.merge!(index_name: "#{field}_id_index")
+        options.merge!(key_condition_expression: "##{field}_id = :#{field}_id")
+        options.merge!(expression_attribute_names: {"##{field}_id": "#{field}_id"})
+
+        define_method(associations) do
+          options.merge!(expression_attribute_values: {":#{field}_id" => id})
+          # p options
+
+          klass = Object.const_get(relation_model.capitalize)
+
+          # options.merge!(limit: 1)
+          # p options
+
+          query = QueryPager.new(options, klass)
+
+          HasManyThroughCollection.new(query, self)
         end
       end
 
@@ -33,27 +75,34 @@ module DynamodbRecord
         list << base_model
         list << relation_model
         sorted_list = list.sort
-        table = sorted_list.map(&:pluralize).join('_')
+        options = {}
+        pluralize_name = sorted_list.map(&:pluralize).join('-')
+
+        table = Config.namespace ? "#{Config.namespace}-#{pluralize_name}" : pluralize_name
+        options[:table_name] = table
+        if sorted_list.first == base_model
+          field = sorted_list.first
+        else
+          field = sorted_list.last
+          options.merge!(index_name: "#{table}-index")
+        end
+
+        options.merge!(key_condition_expression: "##{field}_id = :#{field}_id")
+        options.merge!(expression_attribute_names: {"##{field}_id": "#{field}_id"})
 
         define_method(associations) do
-          options = { table_name: table }
-
-          if sorted_list.first == base_model
-            field = sorted_list.first
-          else
-            field = sorted_list.last
-            options.merge!(index_name: "#{table}_index")
-          end
-          options.merge!(key_condition_expression: "##{field}_id = :#{field}_id")
-          options.merge!(expression_attribute_names: { "##{field}_id": "#{field}_id" })
-          options.merge!(expression_attribute_values: { ":#{field}_id" => id })
+          options.merge!(expression_attribute_values: {":#{field}_id" => id})
 
           klass = Object.const_get(relation_model.capitalize)
-          response = self.class.client.query(options)
 
-          DynamodbRecord::Collection.new(response, klass, options)
+          # options.merge!(limit: 1)
+          # p options
+
+          query = QueryPager.new(options, klass)
+          HasAndBelongsToManyCollection.new(query, self)
         end
       end
+      # rubocop:enable Naming/PredicateName
     end
   end
 end

data/lib/dynamodb_record/collection.rb

@@ -6,42 +6,33 @@ module DynamodbRecord
 
     # attr_reader :last_evaluated_key
 
-    def initialize(pager, klass, options = {})
-      @klass = klass
-      @table_name = options[:table_name]
-      @foreign_key = options[:expression_attribute_values].transform_keys { |k| k.delete_prefix(':').to_sym } rescue nil
-      @items = pager.items.map { |item| klass.send(:from_database, item) }
-      @last_evaluated_key = pager.last_evaluated_key
-    end
-
-    def last_evaluated_key
-      if @last_evaluated_key.nil?
-        nil
-      else
-        json_string = JSON.dump(@last_evaluated_key)
-        Base64.urlsafe_encode64(json_string)
-      end
+    def initialize(pager, base_object)
+      @base_object = base_object
+      @pager = pager
+      @klass = @pager.klass
+      @options = @pager.options
+      items = @pager.items
+      @items = items.map { |item| @klass.send(:from_database, item) }
     end
 
     def each(&)
       @items.each(&)
     end
 
+    def last_evaluated_key
+      @pager.last_evaluated_key
+    end
+
     def next_page?
-      last_evaluated_key ? true : false
+      @pager ? @pager.next_page? : false
+    end
+
+    def next_page
+      self.class.new(@pager.next_page, @base_object)
     end
 
-    def create!(items = {})
-      items.merge!(@foreign_key)
-      object = @klass.create!(items)
-      unless @klass.to_s.pluralize.downcase == @table_name.to_s
-
-        client = @klass.client
-        @foreign_key.merge!({ "#{@klass.to_s.downcase}_id": object.id, created_at: Time.now.to_i })
-        client.put_item({ table_name: @table_name, item: @foreign_key })
-      end
-      @items << object
-      object
+    def page(last_key)
+      self.class.new(@pager.next_page(last_key), @base_object) if last_key
     end
   end
 end

data/lib/dynamodb_record/config.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module DynamodbRecord
   module Config
     extend self

data/lib/dynamodb_record/fields.rb

@@ -19,7 +19,7 @@ module DynamodbRecord
       def field(name, type = :string, opts = {})
         named = name.to_s
         # Add attributes
-        attributes.merge!(name => { type:, options: opts })
+        attributes.merge!(name => {type:, options: opts})
 
         # self.hash_key = name if opts[:hash_key]
         # self.range_key = name if opts[:range_key]
@@ -60,11 +60,10 @@ module DynamodbRecord
             DateTime.parse(value)
           end
         when :array
-          if value.is_a?(Array)
-            value
-          else
-            raise ArgumentError, 'Array column'
-          end
+          raise ArgumentError, 'Array column' unless value.is_a?(Array)
+
+          value
+
         else
           raise ArgumentError, "Unknown type #{options[:type]}"
         end
@@ -84,21 +83,21 @@ module DynamodbRecord
       def unload(attrs)
         {}.tap do |hash|
           attrs.each do |key, value|
-            # if attributes[key.to_sym][:options][:hash_key]
-            #   hash[:pk] = dump_field(value, attributes[key.to_sym])
-            # end
-
             hash[key] = dump_field(value, attributes[key.to_sym])
           end
         end
       end
 
       def hash_key
-        @hash_key = attributes.select { |_k,v| v[:options][:hash_key] }.keys.first || :id
+        @hash_key = attributes.select { |_k, v| v[:options][:hash_key] }.keys.first || :id
       end
 
       def range_key
-        @range_key ||= attributes.select { |_k,v| v[:options][:range_key] }.keys.first rescue nil
+        @range_key ||= begin
+          attributes.select { |_k, v| v[:options][:range_key] }.keys.first
+        rescue StandardError
+          nil
+        end
       end
 
       def secondary_indexes

data/lib/dynamodb_record/finders.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 module DynamodbRecord
+  # +Dynamodb::Finders+ is a class that represent a Finders
   module Finders
     extend ActiveSupport::Concern
 

data/lib/dynamodb_record/has_and_belongs_to_many_collection.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module DynamodbRecord
+  # +Dynamodb::ManyToManyCollection+ is a class that represent a ManyToManyCollection
+  class HasAndBelongsToManyCollection
+    include Enumerable
+
+    def initialize(pager, base_object)
+      @base_object = base_object
+      @pager = pager
+      @klass = @pager.klass
+      @options = @pager.options
+      @items = []
+      @pager.items.each do |item|
+        # p item
+        object = @klass.client.get_item(
+          table_name: @klass.table_name,
+          key: {id: item["#{@klass.to_s.downcase}_id"]}
+        )
+        @items << @klass.send(:from_database, object.item)
+      end
+    end
+
+    def each(&)
+      @items.each(&)
+    end
+
+    def last_evaluated_key
+      @pager.last_evaluated_key
+    end
+
+    def next_page?
+      @pager ? @pager.next_page? : false
+    end
+
+    def next_page
+      self.class.new(@pager.next_page, @base_object)
+    end
+
+    def page(last_key)
+      self.class.new(@pager.next_page(last_key), @base_object) if last_key
+    end
+
+    def <<(object)
+      table_name = @options[:table_name]
+      item = @options[:expression_attribute_values].transform_keys { |k| k.delete_prefix(':').to_sym }
+      item[:"#{@klass.to_s.downcase}_id"] = object.id
+      key = {table_name:, item:}
+      @klass.client.put_item(key)
+      @items << object
+    end
+
+    def create!(params = {})
+      raise "#{@base_object.class} must be saved" if @base_object.new_record
+
+      object = @klass.send(:from_database, params)
+      object.save!
+      table_name = @options[:table_name]
+      item = @options[:expression_attribute_values].transform_keys { |k| k.delete_prefix(':').to_sym }
+
+      item[:"#{@klass.to_s.downcase}_id"] = object.id
+      key = {table_name:, item:}
+      @klass.client.put_item(key)
+      object
+    end
+  end
+end

data/lib/dynamodb_record/has_many_collection.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module DynamodbRecord
+  # +Dynamodb::ManyToManyCollection+ is a class that represent a ManyToManyCollection
+  class HasManyCollection
+    include Enumerable
+
+    def initialize(pager, base_object)
+      @base_object = base_object
+      @pager = pager
+      @klass = @pager.klass
+      @options = @pager.options
+      @foreign_key = @options[:expression_attribute_values].transform_keys { |k| k.delete_prefix(':').to_sym }
+      @items = []
+      @pager.items.each do |object|
+        @items << @klass.send(:from_database, object)
+      end
+    end
+
+    def each(&)
+      @items.each(&)
+    end
+
+    def last_evaluated_key
+      @pager.last_evaluated_key
+    end
+
+    def next_page?
+      @pager ? @pager.next_page? : false
+    end
+
+    def next_page
+      self.class.new(@pager.next_page, @base_object)
+    end
+
+    def page(last_key)
+      self.class.new(@pager.next_page(last_key), @base_object) if last_key
+    end
+
+    def create!(params = {})
+      raise "#{@base_object.class} must be saved" if @base_object.new_record
+
+      params.merge!(@foreign_key)
+      object = @klass.send(:from_database, params)
+      object.save!
+      @items << object
+      object
+    end
+  end
+end

data/lib/dynamodb_record/has_many_through_collection.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module DynamodbRecord
+  # +Dynamodb::HasManyThroughCollection+ is a class that represent a ManyToManyCollection
+  class HasManyThroughCollection
+    include Enumerable
+
+    def initialize(pager, base_object)
+      @base_object = base_object
+      @pager = pager
+      @klass = @pager.klass
+      @options = @pager.options
+      @items = []
+      @pager.items.each do |item|
+        # p item
+        object = @klass.client.get_item(
+          table_name: @klass.table_name,
+          key: {id: item["#{@klass.to_s.downcase}_id"]}
+        )
+        @items << @klass.send(:from_database, object.item)
+      end
+    end
+
+    def each(&)
+      @items.each(&)
+    end
+
+    def last_evaluated_key
+      @pager.last_evaluated_key
+    end
+
+    def next_page?
+      @pager ? @pager.next_page? : false
+    end
+
+    def next_page
+      self.class.new(@pager.next_page, @base_object)
+    end
+
+    def page(last_key)
+      self.class.new(@pager.next_page(last_key), @base_object) if last_key
+    end
+  end
+end

data/lib/dynamodb_record/pager.rb

@@ -0,0 +1,15 @@
+module DynamodbRecord
+  # +Dynamodb::Pager+ is a abstract class to paginate
+  class Pager
+    attr_reader :klass
+
+    def initialize(options, klass)
+      @options = options
+      @klass = klass
+    end
+
+    def last_evaluated_key
+      raise NotImplementedError, 'Este método debe ser implementado por las subclases'
+    end
+  end
+end

data/lib/dynamodb_record/persistence.rb

@@ -12,7 +12,7 @@ module DynamodbRecord
       end
 
       def client
-        opts = { region: DynamodbRecord::Config.region }
+        opts = {region: DynamodbRecord::Config.region}
         opts[:endpoint] = DynamodbRecord::Config.endpoint if DynamodbRecord::Config.endpoint
         opts[:access_key_id] = DynamodbRecord::Config.access_key_id if DynamodbRecord::Config.access_key_id
         opts[:secret_access_key] = DynamodbRecord::Config.access_key_id if DynamodbRecord::Config.secret_access_key
@@ -20,7 +20,7 @@ module DynamodbRecord
       end
 
       def default_options
-        { table_name: }
+        {table_name:}
       end
 
       def describe_table
@@ -36,16 +36,16 @@ module DynamodbRecord
         key_schema = []
 
         # Default id hash key
-        attribute_definitions << { attribute_name: 'id',
-                                   attribute_type: 'S' }
-        key_schema << { attribute_name: 'id',
-                        key_type: 'HASH' }
+        attribute_definitions << {attribute_name: 'id',
+                                  attribute_type: 'S'}
+        key_schema << {attribute_name: 'id',
+                       key_type: 'HASH'}
 
         if range_key
-          attribute_definitions << { attribute_name: range_key.to_s,
-                                     attribute_type: dynamodb_type(attributes[range_key][:type]) }
-          key_schema << { attribute_name: range_key.to_s,
-                          key_type: 'RANGE' }
+          attribute_definitions << {attribute_name: range_key.to_s,
+                                    attribute_type: dynamodb_type(attributes[range_key][:type])}
+          key_schema << {attribute_name: range_key.to_s,
+                         key_type: 'RANGE'}
         end
 
         # Global secondary indexes
@@ -54,20 +54,20 @@ module DynamodbRecord
           indexes << key if value[:options][:index]
         end
 
-        global_secoglobal_secondary_indexesndary_indexes = []
+        # global_secoglobal_secondary_indexesndary_indexes = []
         indexes.each do |index|
           index_definition = {}
           index_definition[:index_name] = "#{index}_index"
-          index_definition[:key_schema] = [{ attribute_name: index, key_type: 'HASH' },
-                                           { attribute_name: 'id', key_type: 'RANGE' }]
-          index_definition[:projection] = { projection_type: 'ALL' }
+          index_definition[:key_schema] = [{attribute_name: index, key_type: 'HASH'},
+                                           {attribute_name: 'id', key_type: 'RANGE'}]
+          index_definition[:projection] = {projection_type: 'ALL'}
           index_definition[:provisioned_throughput] = {
             read_capacity_units: 1,
             write_capacity_units: 1
           }
           global_secondary_indexes << index_definition
-          attribute_definitions << { attribute_name: index.to_s,
-                                     attribute_type: dynamodb_type(attributes[index][:type]) }
+          attribute_definitions << {attribute_name: index.to_s,
+                                    attribute_type: dynamodb_type(attributes[index][:type])}
         end
 
         options = {
@@ -113,7 +113,7 @@ module DynamodbRecord
       self.updated_at = time
 
       if @new_record # New item. Don't overwrite if id exists
-        options.merge!(condition_expression: 'id <> :s', expression_attribute_values: { ':s' => id })
+        options.merge!(condition_expression: 'id <> :s', expression_attribute_values: {':s' => id})
       end
 
       options.merge!(item: self.class.unload(attributes))
@@ -127,10 +127,10 @@ module DynamodbRecord
       hash_key = self.class.hash_key
       range_key = self.class.range_key
       key = {}
-      key[hash_key] = self.class.dump_field(self.read_attribute(hash_key), self.class.attributes[hash_key])
+      key[hash_key] = self.class.dump_field(read_attribute(hash_key), self.class.attributes[hash_key])
 
       if range_key.present?
-        key[range_key] = self.class.dump_field(self.read_attribute(range_key), self.class.attributes[range_key])
+        key[range_key] = self.class.dump_field(read_attribute(range_key), self.class.attributes[range_key])
       end
 
       self.class.client.delete_item(options.merge(key:))

data/lib/dynamodb_record/query.rb

@@ -1,3 +1,4 @@
+# rubocop:disable Style/FrozenStringLiteralComment
 
 module DynamodbRecord
   # Query Module
@@ -9,8 +10,8 @@ module DynamodbRecord
       def all(opts = {})
         options = default_options
         options.merge!(opts.slice(:limit))
-        response = client.scan(options)
-        DynamodbRecord::Collection.new(response, self)
+        scan_pager = ScanPager.new(options, self)
+        Collection.new(scan_pager, self)
       end
 
       # search table
@@ -23,7 +24,7 @@ module DynamodbRecord
         expression_attribute_values = {}
         filter_expression = ''
         opts.each do |key, value|
-          expression_attribute_names["##{key}".to_sym] = key.to_s
+          expression_attribute_names[:"##{key}"] = key.to_s
           expression_attribute_values[":#{key}"] = value
           filter_expression << if filter_expression.empty?
                                  "##{key} = :#{key}"
@@ -37,13 +38,15 @@ module DynamodbRecord
         options.merge!(expression_attribute_names:) if expression_attribute_names.present?
         options.merge!(expression_attribute_values:) if expression_attribute_values.present?
         options.merge!(filter_expression:) if filter_expression.present?
-        if exclusive_start_key.present?
-          json_string_decode = Base64.urlsafe_decode64(exclusive_start_key)
-          decode = JSON.parse(json_string_decode)
-          options.merge!(exclusive_start_key: decode)
-        end
-        DynamodbRecord::Collection.new(client.scan(options), self)
+
+        options.merge!(exclusive_start_key:) if exclusive_start_key
+
+        scan_pager = ScanPager.new(options, self)
+        Collection.new(scan_pager, self)
+
+        # DynamodbRecord::Collection.new(client.scan(options), self)
       end
     end
   end
 end
+# rubocop:enable Style/FrozenStringLiteralComment