dynamodb_model 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: afe935d182837391daa3ca740b280d338f6bc458
-  data.tar.gz: 536563d9d5e036a46dfdcc3a1a9f47f6df24eff9
+  metadata.gz: 4e369807797f7eeb8eef8476828b0760a85e8076
+  data.tar.gz: 23f014fb766cda2c085bbc932ab9961946155150
 SHA512:
-  metadata.gz: 6a7281afdba6068ec75af043d66c3490be35ed8beb39af7c0d60e13196bed14003a9c9142db616ca575e848fe7391467dcb70ba68a656ab5f74b5c28c205a118
-  data.tar.gz: c56348d9fda4a5ac732251e48f8924b50970488db1cfdb0a6090eb301a6084ec94bdce07f4f8e60168a4c538f7e335801cd05928f3fe693afe8afe5da0f78617
+  metadata.gz: aa48e2bf21ff32e98640a3264f35c2b9e77ae51d1e8638c912404041fc68b1da336b24c3005dc703457ff013eec49fea9234ea516ac1473d611b90dc5f59cd06
+  data.tar.gz: eaebb86f390ce9e2035af5e50f71f3235c5459284ee4cf540425272f0d511b826b568ad925da367fa9b47c2749e950bac56692901f805a3247cb31cc9e43818e

data/CHANGELOG.md

@@ -0,0 +1,8 @@
+# Change Log
+
+All notable changes to this project will be documented in this file.
+This project *tries* to adhere to [Semantic Versioning](http://semver.org/), even before v1.0.
+
+## [0.3.0]
+- DSL methods now available: create_table, update_table
+- Also can add GSI indexes within update_table with: i.gsi

data/docs/migrations-long.rb

@@ -0,0 +1,72 @@
+class CreateCommentsMigration < DynamodbModel::Migration
+  def up
+    create_table :comments do |t|
+      t.partition_key "post_id:string" # required
+      t.sort_key  "created_at:string" # optional
+      t.provisioned_throughput(5) # sets both read and write, defaults to 5 when not set
+    end
+  end
+end
+
+class UpdateCommentsMigration < DynamodbModel::Migration
+  def up
+    update_table :comments do |t|
+
+      # t.global_secondary_index do
+      # t.gsi(METHOD, INDEX_NAME) do
+
+      # You normally create an index like so:
+      #
+      #  t.gsi(:create) do |i|
+      #    i.partition_key = "post_id:string" # partition_key is required
+      #    i.sort_key = "updated_at:string" # sort_key is optional
+      #  end
+      #
+      # The index name will be inferred from the partition_key and sort_key when
+      # not explicitly set.  Examples:
+      #
+      #   index_name = "#{partition_key}-#{sort_key}-index"
+      #   index_name = "post_id-index" # no sort key
+      #   index_name = "post_id-updated_at-index" # has sort key
+      #
+      # The inference allows you to not have to worry about the index
+      # naming scheme. You can still set the index_name explicitly like so:
+      #
+      #  t.gsi(:create, "post_id-updated_at-index") do |i|
+      #    i.partition_key = "post_id:string" # partition_key is required
+      #    i.sort_key = "updated_at:string" # sort_key is optional
+      #  end
+      #
+      t.gsi(:create) do |i|
+        i.partition_key "post_id:string"
+        i.sort_key "updated_at:string" # optional
+
+        # translates to
+        # i.key_schema({...})
+        # also makes sure that the schema_keys are added to the attributes_definitions
+
+        # t.projected_attributes(:all) # default if not called
+        # t.projected_attributes(:keys_only) # other ways to call
+        # t.projected_attributes([:id, :body, :tags, :updated_at])
+        # translates to:
+        # Valid Values: ALL | KEYS_ONLY | INCLUDE
+        # t.projection(
+        #   projection_type: :all, # defaults to all
+        # )
+        # t.projection(
+        #   projection_type: :include, # defaults to all
+        #   non_key_attributes: [:id, :body, :tags, :updated_at], # defaults to all
+        # )
+
+        i.provisioned_throughput(10)
+      end
+
+      t.gsi(:update, "category-index") do |i|
+        i.provisioned_throughput(10)
+      end
+
+      t.gsi(:delete, "category-index")
+    end
+  end
+end
+

data/docs/migrations-short.rb

@@ -0,0 +1,29 @@
+class CreateCommentsMigration < DynamodbModel::Migration
+  def up
+    create_table :comments do |t|
+      t.partition_key "post_id:string" # required
+      t.sort_key  "created_at:string" # optional
+      t.provisioned_throughput(5) # sets both read and write, defaults to 5 when not set
+    end
+  end
+end
+
+class UpdateCommentsMigration < DynamodbModel::Migration
+  def up
+    update_table :comments do |t|
+      t.gsi(:create) do |i|
+        i.partition_key "post_id:string"
+        i.sort_key "updated_at:string" # optional
+
+        i.provisioned_throughput(10)
+      end
+
+      t.gsi(:update, "update-me-index") do |i|
+        i.provisioned_throughput(10)
+      end
+
+      t.gsi(:delete, "delete-me-index")
+    end
+  end
+end
+

data/lib/dynamodb_model/db_config.rb

@@ -12,6 +12,11 @@ module DynamodbModel::DbConfig
     self.class.db
   end
 
+  # NOTE: Class including DynamodbModel::DbConfig is required to have table_name method defined
+  def namespaced_table_name
+    [self.class.table_namespace, table_name].reject {|s| s.nil? || s.empty?}.join('-')
+  end
+
   module ClassMethods
     @@db = nil
     def db
@@ -30,21 +35,71 @@ module DynamodbModel::DbConfig
     end
 
     def db_config
+      return @db_config if @db_config
+
       if defined?(Jets)
-        YAML.load_file("#{Jets.root}config/dynamodb.yml")[Jets.env] || {}
+        config_path = "#{Jets.root}config/dynamodb.yml"
+        env = Jets.env
       else
         config_path = ENV['DYNAMODB_MODEL_CONFIG'] || "./config/dynamodb.yml"
         env = ENV['DYNAMODB_MODEL_ENV'] || "development"
-        YAML.load_file(config_path)[env] || {}
+      end
+
+      config = YAML.load(erb_result(config_path))
+      @db_config ||= config[env] || {}
+    end
+
+    def table_namespace(*args)
+      case args.size
+      when 0
+        get_table_namespace
+      when 1
+        set_table_namespace(args[0])
       end
     end
 
-    @table_namespace = nil
-    def table_namespace
-      return @table_namespace if @table_namespace
+    def get_table_namespace
+      return @table_namespace if defined?(@table_namespace)
 
       config = db_config
       @table_namespace = config['table_namespace']
     end
+
+    def set_table_namespace(value)
+      @table_namespace = value
+    end
+
+    def erb_result(path)
+      template = IO.read(path)
+      begin
+        ERB.new(template, nil, "-").result(binding)
+      rescue Exception => e
+        puts e
+        puts e.backtrace if ENV['DEBUG']
+
+        # how to know where ERB stopped? - https://www.ruby-forum.com/topic/182051
+        # syntax errors have the (erb):xxx info in e.message
+        # undefined variables have (erb):xxx info in e.backtrac
+        error_info = e.message.split("\n").grep(/\(erb\)/)[0]
+        error_info ||= e.backtrace.grep(/\(erb\)/)[0]
+        raise unless error_info # unable to find the (erb):xxx: error line
+        line = error_info.split(':')[1].to_i
+        puts "Error evaluating ERB template on line #{line.to_s.colorize(:red)} of: #{path.sub(/^\.\//, '').colorize(:green)}"
+
+        template_lines = template.split("\n")
+        context = 5 # lines of context
+        top, bottom = [line-context-1, 0].max, line+context-1
+        spacing = template_lines.size.to_s.size
+        template_lines[top..bottom].each_with_index do |line_content, index|
+          line_number = top+index+1
+          if line_number == line
+            printf("%#{spacing}d %s\n".colorize(:red), line_number, line_content)
+          else
+            printf("%#{spacing}d %s\n", line_number, line_content)
+          end
+        end
+        exit 1 unless ENV['TEST']
+      end
+    end
   end
 end

data/lib/dynamodb_model/item.rb

@@ -8,25 +8,25 @@ require "yaml"
 #
 # Examples:
 #
-#   post = Post.new
+#   post = MyModel.new
 #   post = post.replace(title: "test title")
 #
 # post.attrs[:id] now contain a generaetd unique partition_key id.
 # Usually the partition_key is 'id'. You can set your own unique id also:
 #
-#   post = Post.new(id: "myid", title: "my title")
+#   post = MyModel.new(id: "myid", title: "my title")
 #   post.replace
 #
 # Note that the replace method replaces the entire item, so you
 # need to merge the attributes if you want to keep the other attributes.
 #
-#   post = Post.find("myid")
+#   post = MyModel.find("myid")
 #   post.attrs = post.attrs.deep_merge("desc": "my desc") # keeps title field
 #   post.replace
 #
 # The convenience `attrs` method performs a deep_merge:
 #
-#   post = Post.find("myid")
+#   post = MyModel.find("myid")
 #   post.attrs("desc": "my desc") # <= does a deep_merge
 #   post.replace
 #
@@ -100,10 +100,16 @@ module DynamodbModel
       @attributes
     end
 
-    # AWS Docs examples: http://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GettingStarted.Ruby.04.html
-    # Usage:
+    # Adds very little wrapper logic to scan.
+    #
+    # * Automatically add table_name to options for convenience.
+    # * Decorates return value.  Returns Array of [MyModel.new] instead of the
+    #   dynamodb client response.
+    #
+    # Other than that, usage is same was using the dynamodb client scan method
+    # directly.  Example:
     #
-    #   Post.scan(
+    #   MyModel.scan(
     #     expression_attribute_names: {"#updated_at"=>"updated_at"},
     #     filter_expression: "#updated_at between :start_time and :end_time",
     #     expression_attribute_values: {
@@ -112,20 +118,78 @@ module DynamodbModel
     #     }
     #   )
     #
-    # TODO: pretty lame interface, improve it somehow. Maybe:
-    #
-    #   Post.scan(filter: "updated_at between :start_time and :end_time")
-    #
-    # which automatically maps the structure.
+    # AWS Docs examples: http://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GettingStarted.Ruby.04.html
     def self.scan(params={})
       puts("Should not use scan for production. It's slow and expensive. You should create either a LSI or GSI and use query the index instead.")
+      params = { table_name: table_name }.merge(params)
+      resp = db.scan(params)
+      resp.items.map {|i| self.new(i) }
+    end
 
-      defaults = {
-        table_name: table_name
+    # Adds very little wrapper logic to query.
+    #
+    # * Automatically add table_name to options for convenience.
+    # * Decorates return value.  Returns Array of [MyModel.new] instead of the
+    #   dynamodb client response.
+    #
+    # Other than that, usage is same was using the dynamodb client query method
+    # directly.  Example:
+    #
+    #   MyModel.query(
+    #     index_name: 'category-index',
+    #     expression_attribute_names: { "#category_name" => "category" },
+    #     expression_attribute_values: { ":category_value" => "Entertainment" },
+    #     key_condition_expression: "#category_name = :category_value",
+    #   )
+    #
+    # AWS Docs examples: http://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GettingStarted.Ruby.04.html
+    def self.query(params={})
+      params = { table_name: table_name }.merge(params)
+      resp = db.query(params)
+      resp.items.map {|i| self.new(i) }
+    end
+
+    # Translates simple query searches:
+    #
+    #   Post.where({category: "Drama"}, index_name: "category-index")
+    #
+    # translates to
+    #
+    #   resp = db.query(
+    #     table_name: "proj-dev-post",
+    #     index_name: 'category-index',
+    #     expression_attribute_names: { "#category_name" => "category" },
+    #     expression_attribute_values: { ":category_value" => category },
+    #     key_condition_expression: "#category_name = :category_value",
+    #   )
+    #
+    # TODO: Implement nicer where syntax with index_name as a chained method.
+    #
+    #   Post.where({category: "Drama"}, {index_name: "category-index"})
+    #     VS
+    #   Post.where(category: "Drama").index_name("category-index")
+    def self.where(attributes, options={})
+      raise "attributes.size == 1 only supported for now" if attributes.size != 1
+
+      attr_name = attributes.keys.first
+      attr_value = attributes[attr_name]
+
+      # params = {
+      #   expression_attribute_names: { "#category_name" => "category" },
+      #   expression_attribute_values: { ":category_value" => "Entertainment" },
+      #   key_condition_expression: "#category_name = :category_value",
+      # }
+      name_key, value_key = "##{attr_name}_name", ":#{attr_name}_value"
+      params = {
+        expression_attribute_names: { name_key => attr_name },
+        expression_attribute_values: { value_key => attr_value },
+        key_condition_expression: "#{name_key} = #{value_key}",
       }
-      params = defaults.merge(params)
-      resp = db.scan(params)
-      resp.items.map {|i| Post.new(i) }
+      # Allow direct access to override params passed to dynamodb query options.
+      # This is is how index_name is passed:
+      params = params.merge(options)
+
+      query(params)
     end
 
     def self.replace(attrs)
@@ -156,7 +220,7 @@ module DynamodbModel
         key: {partition_key => id}
       )
       attributes = resp.item # unwraps the item's attributes
-      Post.new(attributes) if attributes
+      self.new(attributes) if attributes
     end
 
     # Two ways to use the delete method:
@@ -203,9 +267,23 @@ module DynamodbModel
       end
     end
 
-    def self.table_name
-      @table_name = self.name.pluralize.underscore
+    def self.table_name(*args)
+      case args.size
+      when 0
+        get_table_name
+      when 1
+        set_table_name(args[0])
+      end
+    end
+
+    def self.get_table_name
+      @table_name ||= self.name.pluralize.underscore
       [table_namespace, @table_name].reject {|s| s.nil? || s.empty?}.join('-')
     end
+
+    def self.set_table_name(value)
+      @table_name = value
+    end
+
   end
 end

data/lib/dynamodb_model/migration.rb

@@ -2,15 +2,26 @@ module DynamodbModel
   class Migration
     autoload :Dsl, "dynamodb_model/migration/dsl"
     autoload :Generator, "dynamodb_model/migration/generator"
+    autoload :Executor, "dynamodb_model/migration/executor"
 
     def up
       puts "Should defined an up method for your migration: #{self.class.name}"
     end
 
-    def create_table(table_name)
-      dsl = Dsl.new(table_name)
-      yield(dsl)
-      dsl.execute
+    def create_table(table_name, &block)
+      execute_with_dsl_params(table_name, :create_table, &block)
+    end
+
+    def update_table(table_name, &block)
+      execute_with_dsl_params(table_name, :update_table, &block)
+    end
+
+  private
+    def execute_with_dsl_params(table_name, method_name, &block)
+      dsl = Dsl.new(method_name, table_name, &block)
+      params = dsl.params
+      executor = Executor.new(table_name, method_name, params)
+      executor.run
     end
   end
 end

data/lib/dynamodb_model/migration/common.rb

@@ -0,0 +1,84 @@
+class DynamodbModel::Migration::Dsl
+  module Common
+    # http://docs.aws.amazon.com/sdkforruby/api/Aws/DynamoDB/Types/KeySchemaElement.html
+    # partition_key is required
+    def partition_key(identifier)
+      @partition_key_identifier = identifier # for later use. useful for conventional_index_name
+      adjust_schema_and_attributes(identifier, "hash")
+    end
+
+    # sort_key is optional
+    def sort_key(identifier)
+      @sort_key_identifier = identifier # for later use. useful for conventional_index_name
+      adjust_schema_and_attributes(identifier, "range")
+    end
+
+    # Parameters:
+    #   identifier: "id:string" or "id"
+    #   key_type: "hash" or "range"
+    #
+    # Adjusts the parameters for create_table to add the
+    # partition_key and sort_key
+    def adjust_schema_and_attributes(identifier, key_type)
+      name, attribute_type = identifier.split(':')
+      attribute_type = "string" if attribute_type.nil?
+
+      partition_key = {
+        attribute_name: name,
+        key_type: key_type.upcase
+      }
+      @key_schema << partition_key
+
+      attribute_definition = {
+        attribute_name: name,
+        attribute_type: ATTRIBUTE_TYPE_MAP[attribute_type]
+      }
+      @attribute_definitions << attribute_definition
+    end
+
+    # t.provisioned_throughput(5) # both
+    # t.provisioned_throughput(:read, 5)
+    # t.provisioned_throughput(:write, 5)
+    # t.provisioned_throughput(:both, 5)
+    def provisioned_throughput(*params)
+      case params.size
+      when 0 # reader method
+        return @provisioned_throughput # early return
+      when 1
+        # @provisioned_throughput_set_called useful for update_table
+        # only provide a provisioned_throughput settings if explicitly called for update_table
+        @provisioned_throughput_set_called = true
+        arg = params[0]
+        if arg.is_a?(Hash)
+          # Case:
+          # provisioned_throughput(
+          #   read_capacity_units: 10,
+          #   write_capacity_units: 10
+          # )
+          @provisioned_throughput = arg # set directly
+          return # early return
+        else # assume parameter is an Integer
+          # Case: provisioned_throughput(10)
+          capacity_type = :both
+          capacity_units = arg
+        end
+      when 2
+        @provisioned_throughput_set_called = true
+        # Case: provisioned_throughput(:read, 5)
+        capacity_type, capacity_units = params
+      end
+
+      map = {
+        read: :read_capacity_units,
+        write: :write_capacity_units,
+      }
+
+      if capacity_type = :both
+        @provisioned_throughput[map[:read]] = capacity_units
+        @provisioned_throughput[map[:write]] = capacity_units
+      else
+        @provisioned_throughput[capacity_type] = capacity_units
+      end
+    end
+  end
+end

data/lib/dynamodb_model/migration/dsl.rb

@@ -1,6 +1,10 @@
 class DynamodbModel::Migration
   class Dsl
+    autoload :GlobalSecondaryIndex, "dynamodb_model/migration/dsl/global_secondary_index"
+    autoload :Common, "dynamodb_model/migration/common"
+
     include DynamodbModel::DbConfig
+    include Common
 
     ATTRIBUTE_TYPE_MAP = {
       'string' => 'S',
@@ -12,100 +16,119 @@ class DynamodbModel::Migration
     }
 
     attr_accessor :key_schema, :attribute_definitions
-    # db is the dynamodb client
-    def initialize(table_name)
+    attr_accessor :table_name
+    def initialize(method_name, table_name, &block)
+      @method_name = method_name
       @table_name = table_name
-      @key_schema = []
+      @block = block
+
+      # Dsl fills in atttributes in as methods are called within the block.
+      # Attributes for both create_table and updated_table:
       @attribute_definitions = []
       @provisioned_throughput = {
-        read_capacity_units: 10,
-        write_capacity_units: 10
+        read_capacity_units: 5,
+        write_capacity_units: 5
       }
-    end
 
-    # http://docs.aws.amazon.com/sdkforruby/api/Aws/DynamoDB/Types/KeySchemaElement.html
-    # partition_key is required
-    def partition_key(identifier)
-      adjust_schema_and_attributes(identifier, "hash")
-    end
+      # Attributes for create_table only:
+      @key_schema = []
 
-    # sort_key is optional
-    def sort_key(identifier)
-      adjust_schema_and_attributes(identifier, "range")
+      # Attributes for update_table only:
+      @gsi_indexes = []
     end
 
-    # Parameters:
-    #   identifier: "id:string" or "id"
-    #   key_type: "hash" or "range"
-    #
-    # Adjusts the parameters for create_table to add the
-    # partition_key and sort_key
-    def adjust_schema_and_attributes(identifier, key_type)
-      name, attribute_type = identifier.split(':')
-      attribute_type = "string" if attribute_type.nil?
-
-      partition_key = {
-        attribute_name: name,
-        key_type: key_type.upcase
-      }
-      @key_schema << partition_key
-
-      attribute_definition = {
-        attribute_name: name,
-        attribute_type: ATTRIBUTE_TYPE_MAP[attribute_type]
-      }
-      @attribute_definitions << attribute_definition
+    # t.gsi(:create) do |i|
+    #   i.partition_key = "category:string"
+    #   i.sort_key = "created_at:string" # optional
+    # end
+    def gsi(action, index_name=nil, &block)
+      gsi_index = GlobalSecondaryIndex.new(action, index_name, &block)
+      @gsi_indexes << gsi_index # store @gsi_index for the parent Dsl to use
     end
+    alias_method :global_secondary_index, :gsi
 
-    # t.provisioned_throughput(5) # both
-    # t.provisioned_throughput(:read, 5)
-    # t.provisioned_throughput(:write, 5)
-    # t.provisioned_throughput(:both, 5)
-    def provisioned_throughput(*params)
-      case params.size
-      when 2
-        capacity_type, capacity_units = params
-      when 1
-        arg = params[0]
-        if arg.is_a?(Hash)
-          @provisioned_throughput = arg # set directly
-          return
-        else # assume parameter is an Integer
-          capacity_type = :both
-          capacity_units = arg
-        end
-      when 0 # reader method
-        return @provisioned_throughput
-      end
+    def evaluate
+      return if @evaluated
+      @block.call(self) if @block
+      @evaluated = true
+    end
 
-      map = {
-        read: :read_capacity_units,
-        write: :write_capacity_units,
-      }
+    # http://docs.aws.amazon.com/sdk-for-ruby/v3/developer-guide/dynamo-example-create-table.html
+    # build the params up from dsl in memory and provides params to the
+      # executor
+    def params
+      evaluate # lazy evaluation: wait until as long as possible before evaluating code block
 
-      if capacity_type = :both
-        @provisioned_throughput[map[:read]] = capacity_units
-        @provisioned_throughput[map[:write]] = capacity_units
-      else
-        @provisioned_throughput[capacity_type] = capacity_units
+      # Not using send because think its clearer in this case
+      case @method_name
+      when :create_table
+        params_create_table
+      when :update_table
+        params_update_table
       end
     end
 
-    # http://docs.aws.amazon.com/sdk-for-ruby/v3/developer-guide/dynamo-example-create-table.html
-    def execute
-      params = {
-        table_name: @table_name,
+    def params_create_table
+      {
+        table_name: namespaced_table_name,
         key_schema: @key_schema,
         attribute_definitions: @attribute_definitions,
         provisioned_throughput: @provisioned_throughput
       }
-      begin
-        result = db.create_table(params)
+    end
+
+    def params_update_table
+      params = {
+        table_name: namespaced_table_name,
+        # update table take values only some values for the "parent" table
+        attribute_definitions: gsi_create_attribute_definitions, # This is only a partial
+        # key_schema: @key_schema, # update_table does not handle key_schema for the "parent" table,
+      }
+      # only set "parent" table provisioned_throughput if user actually invoked
+      # it in the dsl
+      params[:provisioned_throughput] =  @provisioned_throughput if @provisioned_throughput_set_called
+      params[:global_secondary_index_updates] = global_secondary_index_updates
+      params
+    end
 
-        puts "DynamoDB Table: #{@table_name} Status: #{result.table_description.table_status}"
-      rescue Aws::DynamoDB::Errors::ServiceError => error
-        puts "Unable to create table: #{error.message}"
+    # Goes thorugh all the gsi_indexes that have been built up in memory.
+    # Find the gsi object that creates an index and then grab the
+    # attribute_definitions from it.
+    def gsi_create_attribute_definitions
+      gsi = @gsi_indexes.find { |gsi| gsi.action == :create }
+      if gsi
+        gsi.evaluate # force early evaluate since we need the params to
+          # add: current_attribute_definitions + gsi_attrs
+        gsi_attrs = gsi.attribute_definitions
       end
+      all_attrs = if gsi_attrs
+                    current_attribute_definitions + gsi_attrs
+                  else
+                    current_attribute_definitions
+                  end
+      all_attrs.uniq
+    end
+
+    # maps each gsi to the hash structure expected by dynamodb update_table
+    # under the global_secondary_index_updates key:
+    #
+    #   { create: {...} }
+    #   { update: {...} }
+    #   { delete: {...} }
+    def global_secondary_index_updates
+      @gsi_indexes.map do |gsi|
+        { gsi.action => gsi.params }
+      end
+    end
+
+    # >> resp = Post.db.describe_table(table_name: "proj-dev-posts")
+    # >> resp.table.attribute_definitions.map(&:to_h)
+    # => [{:attribute_name=>"id", :attribute_type=>"S"}]
+    def current_attribute_definitions
+      return @current_attribute_definitions if @current_attribute_definitions
+
+      resp = db.describe_table(table_name: namespaced_table_name)
+      @current_attribute_definitions = resp.table.attribute_definitions.map(&:to_h)
     end
   end
 end

data/lib/dynamodb_model/migration/dsl/global_secondary_index.rb

@@ -0,0 +1,71 @@
+class DynamodbModel::Migration::Dsl
+  class GlobalSecondaryIndex
+    include Common
+
+    ATTRIBUTE_TYPE_MAP = DynamodbModel::Migration::Dsl::ATTRIBUTE_TYPE_MAP
+
+    attr_accessor :action, :key_schema, :attribute_definitions
+    attr_accessor :index_name
+    def initialize(action, index_name=nil, &block)
+      @action = action.to_sym # :create, :update, :index
+      @index_name = index_name
+      @block = block
+
+      # Dsl fills these atttributes in as methods are called within
+      # the block
+      @key_schema = []
+      @attribute_definitions = []
+      # default provisioned_throughput
+      @provisioned_throughput = {
+        read_capacity_units: 5,
+        write_capacity_units: 5
+      }
+    end
+
+    def index_name
+      @index_name || conventional_index_name
+    end
+
+    def conventional_index_name
+      # @partition_key_identifier and @sort_key_identifier are set as immediately
+      # when the partition_key and sort_key methods are called in the dsl block.
+      # Usually look like this:
+      #
+      #   @partition_key_identifier: post_id:string
+      #   @sort_key_identifier: updated_at:string
+      #
+      # We strip the :string portion in case it is provided
+      #
+      partition_key = @partition_key_identifier.split(':').first
+      sort_key = @sort_key_identifier.split(':').first if @sort_key_identifier
+      [partition_key, sort_key, "index"].compact.join('-')
+    end
+
+    def evaluate
+      return if @evaluated
+      @block.call(self) if @block
+      @evaluated = true
+    end
+
+    def params
+      evaluate # lazy evaluation: wait until as long as possible before evaluating code block
+
+      params = { index_name: index_name } # required for all actions
+
+      if @action == :create
+        params[:key_schema] = @key_schema # required for create action
+        # hardcode to ALL for now
+        params[:projection] = { # required
+          projection_type: "ALL", # accepts ALL, KEYS_ONLY, INCLUDE
+          # non_key_attributes: ["NonKeyAttributeName"],
+        }
+      end
+
+      if [:create, :update].include?(@action)
+        params[:provisioned_throughput] = @provisioned_throughput
+      end
+
+      params
+    end
+  end
+end

data/lib/dynamodb_model/migration/executor.rb

@@ -0,0 +1,30 @@
+class DynamodbModel::Migration
+  class Executor
+    include DynamodbModel::DbConfig
+
+    # Examples:
+    #  Executor.new(:create_table, params) or
+    #  Executor.new(:update_table, params)
+    #
+    # The params are generated frmo the dsl.params
+    attr_accessor :table_name
+    def initialize(table_name, method_name, params)
+      @table_name = table_name
+      @method_name = method_name # create_table or update_table
+      @params = params
+    end
+
+    def run
+      begin
+        # Examples:
+        #   result = db.create_table(@params)
+        #   result = db.update_table(@params)
+        result = db.send(@method_name, @params)
+
+        puts "DynamoDB Table: #{@table_name} Status: #{result.table_description.table_status}"
+      rescue Aws::DynamoDB::Errors::ServiceError => error
+        puts "Unable to #{@method_name.to_s.gsub('_',' ')}: #{error.message}"
+      end
+    end
+  end
+end

data/lib/dynamodb_model/migration/generator.rb

@@ -12,21 +12,24 @@ class DynamodbModel::Migration
     end
 
     def generate
-      puts "Generating migration" unless @options[:quiet]
+      puts "Generating migration for #{@table_name}" unless @options[:quiet]
       return if @options[:noop]
       create_migration
     end
 
     def create_migration
-      migration_path = "#{DynamodbModel.root}db/migrate/#{migration_file_name}.rb"
+      migration_relative_path = "db/migrate/#{migration_file_name}.rb"
+      migration_path = "#{DynamodbModel.root}#{migration_relative_path}"
       dir = File.dirname(migration_path)
       FileUtils.mkdir_p(dir) unless File.exist?(dir)
       IO.write(migration_path, migration_code)
+      puts "Migration file created: #{migration_relative_path}. To run:"
+      puts "  jets db migrate #{migration_relative_path}"
     end
 
     def migration_code
       # @table_name already set
-      @migration_class_name = migration_file_name.classify
+      @migration_class_name = "#{@table_name}_migration".classify
       @partition_key = @options[:partition_key]
       @sort_key = @options[:sort_key]
       @provisioned_throughput = @options[:provisioned_throughput] || 5
@@ -39,7 +42,7 @@ class DynamodbModel::Migration
     end
 
     def timestamp
-      "timestamp"
+      @timestamp ||= Time.now.strftime("%Y%m%d%H%M%S")
     end
   end
 end

data/lib/dynamodb_model/version.rb

@@ -1,3 +1,3 @@
 module DynamodbModel
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dynamodb_model
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Tung Nguyen
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-11-04 00:00:00.000000000 Z
+date: 2017-11-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -89,17 +89,23 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".rspec"
+- CHANGELOG.md
 - Gemfile
 - README.md
 - Rakefile
 - bin/console
 - bin/setup
+- docs/migrations-long.rb
+- docs/migrations-short.rb
 - dynamodb_model.gemspec
 - lib/dynamodb_model.rb
 - lib/dynamodb_model/db_config.rb
 - lib/dynamodb_model/item.rb
 - lib/dynamodb_model/migration.rb
+- lib/dynamodb_model/migration/common.rb
 - lib/dynamodb_model/migration/dsl.rb
+- lib/dynamodb_model/migration/dsl/global_secondary_index.rb
+- lib/dynamodb_model/migration/executor.rb
 - lib/dynamodb_model/migration/generator.rb
 - lib/dynamodb_model/migration/template.rb
 - lib/dynamodb_model/util.rb
@@ -123,7 +129,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.14
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: ActiveRecord-ish Dynamodb Model