dynamodb_record 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: bafe4b334f021f466ddd622e5568d05e0b01a3b5524e7ab144b702d8370fbd58
+  data.tar.gz: 9eab54f02aee3d337c9e714843d397e9de8caf094a0e458964c2aece056bee85
+SHA512:
+  metadata.gz: 4f60d3f15b9abf2a73411c6482c4fe0fefa42c386cf61190419d43cbd971b487d8c7d8d0fdd35e710fb3c9229e2e3a5515fd0f41cca682ad30c6d08801e5a460
+  data.tar.gz: cf7ecd56ff1bd2865c9acefa52c3340ceb7ac3d672a005070b5838f8295564e89e7babc8bf03074c01563396148e92cf975de2e34803d3e9afb85893fc7cd180

data/.github/workflows/ci.yml

@@ -0,0 +1,44 @@
+name: CI
+
+on:
+  push:
+    branches:
+      - main
+jobs:
+  test:
+    runs-on: ubuntu-22.04
+
+    steps:
+    - uses: actions/checkout@v4
+    - uses: actions/setup-node@v4
+    - uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: 3.2.3
+
+    - name: Install dependencies
+      run: |
+        gem install rspec -v 3.7.0
+        gem install rubocop
+        gem install vcr -v 6.2
+        gem install webmock -v 3.23
+        gem install rexml -v 3.2.6
+        gem install jwt -v 2.8.1
+        gem install aws-sdk-sqs -v 1.70.0
+        gem install aws-sdk-dynamodb -v 1.105.0
+        gem install activesupport -v 7.1.3.2
+
+    - name: Run tests
+      run: bundle exec rspec
+
+#    - name: Bundle install
+#      run: |
+#        bundle config path vendor/bundle
+#        bundle install --jobs 4 --retry 3
+
+#    - run: bundle exec rake
+#    - name: Install dependencies
+#      run: bundle install
+#
+#    - name: Run RuboCop
+#      run: bundle exec rubocop
+#

data/.gitignore

@@ -0,0 +1,30 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+*.gem
+mkmf.log
+.env
+.DS_Store
+.idea/*
+log/*
+measurement/*
+pkg/*
+*~
+.rvmrc
+.bundle
+demo.rb
+coverage/*
+spec/dummy/tmp/*
+spec/dummy/log/*.log
+vendor/bundle
+vendor

data/.ruby-version

@@ -0,0 +1 @@
+3.2.3

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+# Changelog
+
+## 0.0.1 (10-Mar-2024)
+
+* initial release

data/Gemfile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gemspec
+
+# group :test do
+#   gem 'rspec', '~> 3.7'
+#   gem 'rubocop', '~> 1.62'
+# end

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Cars Ok
+
+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

@@ -0,0 +1,82 @@
+# DynamoRecord
+
+A simple DynamoDB ORM container on aws-sdk v3 forked from https://github.com/yetanothernguyen/dynamo_record
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'dynamo_record'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install dynamo_record
+
+## Usage
+
+### Models
+
+To create a model with DynamoRecord, simply include the DynamoRecord::Document mixin in your class as such::
+
+```ruby
+class User
+  include DynamoRecord::Document
+end
+```
+
+### Fields
+Declaring a field is done by using the `field` method. For example, the following defines a User model with a first and last name:
+
+```ruby
+class User
+  include DynamoRecord::Document
+
+  field :first_name, :string
+  field :last_name, :string
+end
+```
+
+`field` accepts the following options:
+- :default to specify a default value
+- :hash_key to specify a DynamoDB hash key
+- :range_key to specify a DynamoDB range key
+- :index to specify an index
+
+### Persistence
+DynamoRecord provides a similar persistence interface compared to other ORMs.
+
+```ruby
+user = User.new(first_name: 'John', last_name: 'Doe')
+user.save
+
+user = User.create(first_name: 'John', last_name: 'Doe')
+
+user.destroy
+```
+
+### Querying
+
+```ruby
+users = User.all
+
+users = User.where(first_name: 'John')
+
+users = User.where(first_name: 'John', limit: 5)
+
+user = User.find('f9b351b0-d06d-4fff-b8d4-8af162e2b8ba')
+```
+
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/dynamo_record/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/dynamodb_record.gemspec

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'dynamodb_record/version'
+
+Gem::Specification.new do |spec|
+  spec.name = 'dynamodb_record'
+  spec.version = DynamodbRecord::VERSION
+  spec.author = ['Henry Guzman', 'Jhon Santander']
+  spec.email = ['hguzman10@gmail.com', 'jsantander1219@gmail.com']
+  spec.summary = 'A simple DynamoDB ORM'
+  spec.homepage = 'https://github.com/CarsOk/dynamodb-record'
+  spec.license = 'MIT'
+  spec.required_ruby_version = '>= 3.2.0'
+
+  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'
+  spec.add_dependency 'aws-sdk-dynamodb', '~> 1.105'
+  spec.add_dependency 'aws-sdk-sqs', '~> 1.70'
+  spec.add_dependency 'jwt', '~> 2.8', '>= 2.8.1'
+  spec.add_dependency 'rexml', '~> 3.2', '>= 3.2.6'
+
+  spec.add_development_dependency 'rspec', '~> 3.7'
+  spec.add_development_dependency 'rubocop', '~> 1.62'
+  spec.add_development_dependency 'vcr', '~> 6.2'
+  spec.add_development_dependency 'webmock', '~> 3.23'
+end

data/lib/dynamodb_record/associations.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module DynamodbRecord
+  module Associations
+    extend ActiveSupport::Concern
+
+    class_methods do
+      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 })
+
+          options.merge!(index_name: "#{self.class.to_s.downcase}_id_index")
+
+          klass = Object.const_get(model.capitalize)
+          # puts options
+          response = self.class.client.query(options)
+
+          # pager = DynamodbRecord::Pager.new(self.class.client, options, clase)
+          DynamodbRecord::Collection.new(response, klass, options)
+        end
+      end
+
+      def has_and_belongs_to_many(associations)
+        base_model = to_s.downcase
+        relation_model = associations.to_s.chop
+        list = []
+        list << base_model
+        list << relation_model
+        sorted_list = list.sort
+        table = sorted_list.map(&:pluralize).join('_')
+
+        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 })
+
+          klass = Object.const_get(relation_model.capitalize)
+          response = self.class.client.query(options)
+
+          DynamodbRecord::Collection.new(response, klass, options)
+        end
+      end
+    end
+  end
+end

data/lib/dynamodb_record/collection.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module DynamodbRecord
+  class Collection
+    include Enumerable
+
+    # 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 }
+      @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
+    end
+
+    def each(&)
+      @items.each(&)
+    end
+
+    def next_page?
+      last_evaluated_key ? true : false
+    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
+    end
+  end
+end

data/lib/dynamodb_record/config.rb

@@ -0,0 +1,16 @@
+module DynamodbRecord
+  module Config
+    extend self
+
+    attr_accessor :access_key_id, :secret_access_key, :region, :namespace, :endpoint, :read_capacity_units,
+                  :write_capacity_units, :compute_checksums
+
+    def set_defaults
+      self.region = 'us-east-1'
+      self.read_capacity_units = 20
+      self.write_capacity_units = 20
+      self.namespace = nil
+    end
+    set_defaults
+  end
+end

data/lib/dynamodb_record/document.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module DynamodbRecord
+  module Document
+    extend ActiveSupport::Concern
+    include DynamodbRecord::Fields
+    include DynamodbRecord::Persistence
+    include DynamodbRecord::Finders
+    include DynamodbRecord::Query
+    include DynamodbRecord::Associations
+
+    included do
+      class_attribute :base_class
+      self.base_class = self
+    end
+
+    module ClassMethods
+      def from_database(attrs)
+        new(attrs, true).tap { |r| r.new_record = false }
+      end
+    end
+
+    attr_accessor :new_record
+
+    def initialize(params = {}, ignore_unknown_field = false)
+      @new_record = true
+      @attributes = {} # Validar esta linea
+
+      # Set default
+      self.class.attributes.each do |key, value|
+        send("#{key}=", value[:options][:default]) if value[:options][:default]
+      end
+
+      load(params, ignore_unknown_field)
+    end
+
+    def load(params, ignore_unknown_field = false)
+      params.each do |key, value|
+        next if ignore_unknown_field && !respond_to?("#{key}=")
+
+        send("#{key}=", value)
+      end
+    end
+  end
+end

data/lib/dynamodb_record/fields.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module DynamodbRecord
+  module Fields
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :attributes, :hash_key, instance_writer: true
+      self.attributes = {}
+      self.hash_key = nil
+
+      # default hash key
+      field :id, :string
+    end
+
+    class_methods do
+      def field(name, type = :string, opts = {})
+        named = name.to_s
+        # Add attributes
+        attributes.merge!(name => { type:, options: opts })
+
+        self.hash_key = name if opts[:hash_key]
+
+        # Generate methods to field
+        define_method("#{named}=") { |value| write_attribute(named, value) }
+        define_method(name.to_s) { read_attribute(named) }
+        define_method("#{name}?") do
+          value = read_attribute(named)
+          return value != 'false' if value.is_a?(String)
+
+          !!value
+        end
+      end
+
+      def undump_field(value, options)
+        return nil if options.nil?
+
+        case options[:type]
+        when :integer
+          value.to_i
+        when :string
+          value.to_s
+        when :big_decimal
+          value.to_d
+        when :boolean
+          if ['true', true].include?(value)
+            true
+          elsif ['false', false].include?(value)
+            false
+          else
+            raise ArgumentError, 'Boolean column neither true nor false'
+          end
+        when :datetime
+          if value.is_a?(Date) || value.is_a?(DateTime) || value.is_a?(Time)
+            value
+          else
+            DateTime.parse(value)
+          end
+        else
+          raise ArgumentError, "Unknown type #{options[:type]}"
+        end
+      end
+
+      def dump_field(value, options)
+        return value if options.nil?
+
+        case options[:type]
+        when :datetime
+          value.iso8601
+        else
+          value # aws-sdk supports the rest of data Types
+        end
+      end
+
+      def unload(attrs)
+        {}.tap do |hash|
+          attrs.each do |key, value|
+            if attributes[key.to_sym][:options][:hash_key]
+              # puts "KEY #{key} | #{dump_field(value, self.attributes[key.to_sym])}"
+              hash[:pk] = dump_field(value, attributes[key.to_sym])
+            end
+
+            # puts "KEY #{key}|#{value}|#{self.attributes[key.to_sym]}"
+            hash[key] = dump_field(value, attributes[key.to_sym])
+            # puts "HASH: #{hash}"
+          end
+        end
+      end
+
+      def hash_key
+        :id # default hash key
+      end
+
+      def range_key
+        @range_key ||= begin
+          attributes.select { |_k, v| v[:options][:range_key] }.keys.first
+        rescue StandardError
+          nil
+        end
+      end
+
+      def secondary_indexes
+        @secondary_indexes ||= begin
+          attributes.select { |_k, v| v[:options][:index] }.keys
+        rescue StandardError
+          nil
+        end
+      end
+
+      def dynamodb_type(type)
+        case type
+        when :integer, :big_decimal
+          'N'
+        when :string, :datetime
+          'S'
+          # else
+          #   'S'
+        end
+      end
+    end
+
+    # Return a value
+    def write_attribute(name, value)
+      attributes[name.to_sym] = self.class.undump_field(value, self.class.attributes[name.to_sym])
+    end
+
+    def read_attribute(name)
+      attributes[name.to_sym]
+    end
+  end
+end

data/lib/dynamodb_record/finders.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module DynamodbRecord
+  module Finders
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def find(id, range_key = nil)
+        key = { 'id' => id }
+
+        key[self.range_key] = range_key if self.range_key
+        puts table_name
+        response = client.get_item(
+          table_name:,
+          key:
+        )
+        response.item ? from_database(response.item) : nil
+      end
+    end
+  end
+end

data/lib/dynamodb_record/persistence.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module DynamodbRecord
+  # Persistence Module
+  module Persistence
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def table_name
+        name = ActiveSupport::Inflector.tableize(base_class.name)
+        @table_name ||= DynamodbRecord::Config.namespace ? "#{DynamodbRecord::Config.namespace}-#{name}" : name
+      end
+
+      def client
+        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
+        @client ||= Aws::DynamoDB::Client.new(opts)
+      end
+
+      def default_options
+        { table_name: }
+      end
+
+      def describe_table
+        client.describe_table(default_options)
+      end
+
+      def create_table(opts = {})
+        table_name = opts[:table_name] || self.table_name
+        read_capacity = opts[:read_capacity] || DynamodbRecord::Config.read_capacity_units
+        write_capacity = opts[:write_capacity] || DynamodbRecord::Config.write_capacity_units
+
+        attribute_definitions = []
+        key_schema = []
+
+        # Default id hash key
+        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' }
+        end
+
+        # Global secondary indexes
+        indexes = []
+        attributes.each do |key, value|
+          indexes << key if value[:options][:index]
+        end
+
+        global_secondary_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[: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]) }
+        end
+
+        options = {
+          attribute_definitions:,
+          table_name:,
+          key_schema:,
+          provisioned_throughput: {
+            read_capacity_units: read_capacity,
+            write_capacity_units: write_capacity
+          }
+        }
+
+        options.merge!(global_secondary_indexes:) unless global_secondary_indexes.empty?
+        client.create_table(options)
+      end
+
+      def create(key = {})
+        create!(key)
+      rescue StandardError
+        nil
+      end
+
+      def create!(key = {})
+        object = new(key)
+        object.save!
+        object
+      end
+    end
+
+    def save
+      save!
+      true
+    rescue StandardError
+      false
+    end
+
+    def save!
+      options = self.class.default_options
+
+      self.id = SecureRandom.uuid if id.nil?
+
+      if @new_record # New item. Don't overwrite if id exists
+        options.merge!(condition_expression: 'id <> :s', expression_attribute_values: { ':s' => id })
+      end
+
+      options.merge!(item: self.class.unload(attributes))
+      self.class.client.put_item(options)
+      @new_record = false
+    end
+
+    def destroy
+      options = self.class.default_options
+      key = { 'pk' => pk, 'sk' => sk }
+      self.class.client.delete_item(options.merge(key:))
+    end
+  end
+end