active-dynamo 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1946cead605cf9a2c458ede322635850d0ed2301b315bd03b9687cc667307b22
+  data.tar.gz: 168c5b0352194c504f75339b7209be825599f83d2854369195362974f3078027
+SHA512:
+  metadata.gz: fbffb427e806bf4f3226a9c28a3a93fb4cbdb7b407c891eb165e98762689093ed3f3b6124fff877f1ddf14efdc93477ff17276dd93894edd3b6beecb230f31f8
+  data.tar.gz: b7d1db1d93b20fe29f62b532803cb56665356e7b7b477bf849261e8c74212a3a907802f5d7fcee8607e47988a394f563a381cfd64ebcc492c4c70742dc252b84

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.byebug_history
+.bundle/
+Gemfile.lock

data/Gemfile

@@ -0,0 +1,9 @@
+source "https://rubygems.org"
+
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
+
+gemspec
+
+group :development, :test do
+  gem 'byebug', platforms: [:mri, :mingw, :x64_mingw]
+end

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Ahmed Saleh
+
+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,62 @@
+active-dynamo
+---
+
+An ActiveRecord like ODM for AWS DynamoDB
+
+## Installation
+
+```sh
+gem install active-dynamo
+```
+
+## Usage
+
+Currently, the supported operations are as follows:
+
+- Define a model in a way similar to ActiveRecord, calling `table_name` and
+  `attributes` functions:
+
+```ruby
+class Account < ActiveDynamo::Base
+  table name: 'account', partition_key: :no, sort_key: :balance
+  attributes no: Integer, balance: Integer, kind: String
+end
+```
+
+- Create a new record:
+
+```ruby
+account = Account.new(no: 123, balance: 2000, kind: 'current')
+account.save
+
+# or use `create`
+account = Account.create(no: 123, balance: 2000, kind: 'current')
+```
+
+- Query the table using methods such as:
+
+```ruby
+Account.all
+
+Account.where(no: 123, balance: 2000)
+Account.where("no = 123 and balance >= 2000 and kind = 'current'")
+
+Account.find(no: 123, balance: 2000)
+```
+
+- Update a record
+
+```ruby
+account = Account.first
+account.update(kind: 'savings')
+```
+
+- Delete a record
+
+```ruby
+Account.destroy(no: 123, balance: 2000)
+```
+
+## License
+
+See [LICENSE](https://github.com/aonemd/active-dynamo/blob/master/LICENSE).

data/Rakefile

@@ -0,0 +1,16 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/**/*_test.rb']
+end
+task :default => :test
+
+desc "Make a new build and publish it to RubyGems"
+task :publish do
+  build_name_and_version = "nin-#{ActiveDynamo::VERSION}.gem"
+
+  system "gem build nin.gemspec --silent --output #{build_name_and_version}"
+  system "gem push #{build_name_and_version}"
+end

data/active-dynamo.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+require File.expand_path('../lib/active_dynamo/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors     = ["Ahmed Saleh"]
+  gem.email       = 'aonemdsaleh@gmail.com'
+  gem.description = "An ActiveRecord like ODM for AWS DynamoDB"
+  gem.summary     = "An ActiveRecord like ODM for AWS DynamoDB"
+  gem.homepage    = 'https://github.com/aonemd/active-dynamo'
+
+  gem.files         = `git ls-files`.split($\).reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+
+  gem.name    = 'active-dynamo'
+  gem.version = ActiveDynamo::VERSION
+  gem.license = 'MIT'
+
+  gem.add_dependency 'aws-sdk-dynamodb'
+
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'minitest'
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "active_dynamo"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/lib/active_dynamo.rb

@@ -0,0 +1,10 @@
+require 'aws-sdk-dynamodb'
+
+require 'active_dynamo/version'
+require 'active_dynamo/extensions/class_extensions'
+require 'active_dynamo/extensions/hash_extensions'
+
+require 'active_dynamo/base'
+
+module ActiveDynamo
+end

data/lib/active_dynamo/base.rb

@@ -0,0 +1,63 @@
+require 'active_dynamo/query'
+require 'active_dynamo/persistence'
+
+module ActiveDynamo
+  class Base
+    include Query
+    include Persistence
+
+    class << self
+      def table(options = {})
+        @@table_name    = options.fetch(:name, snake_name)
+        @@partition_key = options.fetch(:partition_key, nil)
+        @@sort_key      = options.fetch(:sort_key, nil)
+        @@primary_key   = [@@partition_key, @@sort_key].compact
+        @@db_conn       = options.fetch(:db_conn, Aws::DynamoDB::Client.new)
+
+        class_variables.each do |var|
+          define_singleton_method(var.to_s.delete('@')) do
+            class_variable_get(var)
+          end
+        end
+      end
+
+      def attributes(**attrs)
+        @@attr_types = attrs
+        @@attrs      = attrs.keys
+        attr_reader(*@@attrs)
+
+        define_method(:initialize) do |**args|
+          @@attrs.each do |name|
+            _type_parser = method(@@attr_types.fetch(name).to_s)
+            _value       = _type_parser.call(args[name])
+            instance_variable_set("@#{name}", _value)
+          end
+        end
+
+        define_singleton_method('attrs') do
+          class_variable_get('@@attrs')
+        end
+
+        define_singleton_method('attr_types') do
+          class_variable_get('@@attr_types')
+        end
+      end
+    end
+
+    def attributes
+      @@attrs.inject({}) do |h, attr|
+        h.update(attr => self.instance_variable_get("@#{attr}"))
+      end
+    end
+
+    def primary_key_attributes
+      self.attributes.slice(*@@primary_key)
+    end
+
+    private
+
+    def update_primary_key(keys)
+      @@primary_key ||= keys
+    end
+  end
+end

data/lib/active_dynamo/extensions/class_extensions.rb

@@ -0,0 +1,5 @@
+class Class
+  def snake_name
+    name.gsub('::', '_').downcase
+  end
+end

data/lib/active_dynamo/extensions/hash_extensions.rb

@@ -0,0 +1,13 @@
+class Hash
+  def symbolize_keys
+    self.inject({}) do |h, (k, v)|
+      if v.is_a? Hash
+        h[k.to_sym] = v.symbolize_keys
+      else
+        h[k.to_sym] = v
+      end
+
+      h
+    end
+  end
+end

data/lib/active_dynamo/persistence.rb

@@ -0,0 +1,35 @@
+require_relative 'persistence/updater'
+
+module ActiveDynamo
+  module Persistence
+    def self.included(klass)
+      klass.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def create(**args)
+        obj = new(**args)
+        obj.save
+        obj
+      end
+
+      def destroy(**key_value)
+        db_conn.delete_item({
+          table_name: table_name,
+          key: key_value
+        })
+      end
+    end
+
+    def save
+      self.class.db_conn.put_item({
+        table_name: self.class.table_name,
+        item: self.attributes
+      })
+    end
+
+    def update(**args)
+      Updater.new(self).call(**args)
+    end
+  end
+end

data/lib/active_dynamo/persistence/updater.rb

@@ -0,0 +1,39 @@
+module ActiveDynamo
+  module Persistence
+    class Updater
+      def initialize(initiator)
+        @initiator = initiator
+      end
+
+      def call(**args)
+        updated_attrs = @initiator.class.db_conn.update_item({
+          table_name: @initiator.class.table_name,
+          key: @initiator.primary_key_attributes,
+          update_expression: update_expression(args),
+          expression_attribute_values: expression_attribute_values(args),
+          return_values: "UPDATED_NEW"
+        }).attributes
+
+        updated_attrs.each do |key, value|
+          @initiator.instance_variable_set("@#{key}", value)
+        end
+
+        @initiator
+      end
+
+      private
+
+      def update_expression(args)
+        args.each_with_index.map do |(key, _), index|
+          "#{key} = :#{key}#{index}"
+        end.join(", ").prepend("SET ")
+      end
+
+      def expression_attribute_values(args)
+        args.each_with_index.inject({}) do |expr, ((key, value), index)|
+          expr.update(":#{key}#{index}" => value)
+        end
+      end
+    end
+  end
+end

data/lib/active_dynamo/query.rb

@@ -0,0 +1,35 @@
+require_relative 'query/query_generator'
+
+module ActiveDynamo
+  module Query
+    def self.included(klass)
+      klass.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def all
+        db_conn.scan({ table_name: table_name }).items.map do |item|
+          new(item.symbolize_keys)
+        end
+      end
+
+      def where(args)
+        query = QueryGenerator.new(self).call(args)
+
+        db_conn.query(query).items.map do |item|
+          new(item.symbolize_keys)
+        end
+      end
+
+      def find(**key_value)
+        obj_hash = db_conn
+          .get_item({ table_name: table_name, key: key_value }).item
+          .symbolize_keys
+
+        obj = new(obj_hash)
+        obj.send(:update_primary_key, key_value.keys)
+        obj
+      end
+    end
+  end
+end

data/lib/active_dynamo/query/query_generator.rb

@@ -0,0 +1,109 @@
+module ActiveDynamo
+  module Query
+    class QueryGenerator
+      def initialize(initiator)
+        @initiator = initiator
+      end
+
+      def call(args)
+        augmented_args = if args.is_a? String
+                           tokenize_string_query(args).map(&:symbolize_keys)
+                          else
+                            args.reduce([]) do |arr, (k, v)|
+                              arr << { key: k, value: v, operator: '=' }
+                            end
+                          end
+
+        key_condition_expression_args = []
+        filter_expression_args        = []
+        expression_attribute_names    = {}
+        expression_attribute_values   = {}
+
+        augmented_args.each_with_index do |arg, index|
+          key      = arg[:key].to_sym
+          operator = arg[:operator] || '='
+
+          key_alias   = "#key_#{key}_#{index}"
+          expression_attribute_names.update(key_alias => key)
+
+          key_type_parser = method(@initiator.attr_types.fetch(key).to_s)
+
+          unless operator == 'BETWEEN'
+            value = key_type_parser.call(arg[:value])
+            value_alias = ":key_#{key}_#{index}_value"
+
+            sub_expression = [key_alias, value_alias].join(" #{operator} ")
+            expression_attribute_values.update(value_alias => value)
+          else
+            value1 = key_type_parser.call(arg[:value1])
+            value2 = key_type_parser.call(arg[:value2])
+
+            value1_alias = ":key_#{key}_#{index}_value_1"
+            value2_alias = ":key_#{key}_#{index}_value_2"
+
+            sub_expression = [key_alias, [value1_alias, value2_alias].join(' AND ')].join(" #{operator} ")
+
+            expression_attribute_values.update(value1_alias => value1)
+            expression_attribute_values.update(value2_alias => value2)
+          end
+
+          if key == @initiator.partition_key || key == @initiator.sort_key
+            key_condition_expression_args.push(sub_expression)
+          else
+            filter_expression_args.push(sub_expression)
+          end
+        end
+
+        query = {
+          table_name: @initiator.table_name,
+          key_condition_expression: key_condition_expression_args.join(' and '),
+          expression_attribute_names: expression_attribute_names,
+          expression_attribute_values: expression_attribute_values
+        }
+
+        unless filter_expression_args.empty?
+          query[:filter_expression] = filter_expression_args.join(' and ')
+        end
+
+        query
+      end
+
+      def tokenize_string_query(query)
+        Lexer.new(query).call()
+      end
+
+      class Lexer
+        # S                  -> PARTION_EXPRESSION SORT_EXPRESSION FILTER_EXPRESSION $
+        # PARTION_EXPRESSION -> partition_key = :value
+        # SORT_EXPRESSION    -> 'and' sort_key = :value | E
+        # FILTER_EXPRESSION  -> 'and' (SINGLE_EXPRESSION | DOUBLE_EXPRESSION) FILTER_EXPRESSION | E
+        # SINGLE_EXPRESSION  -> key (=|<|>|<=|>=) :value
+        # DOUBLE_EXPRESSION  -> key 'BETWEEN' :value1 'AND' :value2
+
+        def initialize(query)
+          @query  = query
+          @tokens = []
+        end
+
+        def call
+          grammar = [
+            /(?<key>[\w\d_.-]+)\s*(?<op>BETWEEN)\s*(?<value1>[\w\d_.-]+)\s*AND\s*(?<value2>[\w\d_.-]+)/,
+            /(?<key>[\w\d_.-]+)\s*(?<op>(>=|<=|>|<))\s*(?<value>[\w\d_.-]+)/,
+            /(?<key>[\w\d_.-]+)\s*(?<op>(=))\s*(?<value>[\w\d_.-]+)/
+          ]
+
+          @query.split('and').each do |sub_query|
+            grammar.each do |g|
+              if g.match(sub_query)
+                @tokens << g.match(sub_query).named_captures
+                break
+              end
+            end
+          end
+
+          @tokens
+        end
+      end
+    end
+  end
+end

data/lib/active_dynamo/version.rb

@@ -0,0 +1,3 @@
+module ActiveDynamo
+  VERSION='0.0.1'
+end

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: active-dynamo
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Ahmed Saleh
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2020-10-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: aws-sdk-dynamodb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: An ActiveRecord like ODM for AWS DynamoDB
+email: aonemdsaleh@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- active-dynamo.gemspec
+- bin/console
+- lib/active_dynamo.rb
+- lib/active_dynamo/base.rb
+- lib/active_dynamo/extensions/class_extensions.rb
+- lib/active_dynamo/extensions/hash_extensions.rb
+- lib/active_dynamo/persistence.rb
+- lib/active_dynamo/persistence/updater.rb
+- lib/active_dynamo/query.rb
+- lib/active_dynamo/query/query_generator.rb
+- lib/active_dynamo/version.rb
+homepage: https://github.com/aonemd/active-dynamo
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key:
+specification_version: 4
+summary: An ActiveRecord like ODM for AWS DynamoDB
+test_files: []