eventosaurus 1.0.0

data/lib/eventosaurus/models/query.rb

@@ -0,0 +1,51 @@
+module Eventosaurus
+  module Models
+    class Query
+      attr_reader :args, :partition_key_name, :partition_key_type
+
+      def initialize(definition)
+        @partition_key_name = definition[:partition_key].keys[0]
+        @partition_key_type = definition[:partition_key].values[0]
+        @args = { table_name: definition[:full_table_name] }
+      end
+
+      def run
+        Eventosaurus.configuration.dynamodb_client.query(args)
+      end
+
+      def select(attrs)
+        @args[:select] = 'SPECIFIC_ATTRIBUTES'
+        @args[:attributes_to_get] = attrs
+
+        self
+      end
+
+      def count
+        @args[:select] = 'COUNT'
+
+        self
+      end
+
+      def by_partition_key(value:, operator:)
+        @args[:key_conditions] = {
+          partition_key_name => {
+            attribute_value_list: [value],
+            comparison_operator: operator
+          }
+        }
+
+        self
+      end
+
+      def by_local_secondary(name:, value:, operator:)
+        @args[:query_filter] ||= {}
+        @args[:query_filter][name] = {
+          attribute_value_list: [value],
+          comparison_operator: operator
+        }
+
+        self
+      end
+    end
+  end
+end

data/lib/eventosaurus/models/table.rb

@@ -0,0 +1,97 @@
+module Eventosaurus
+  module Models
+    class Table
+      attr_reader :local_indexes,
+        :partition_key_name,
+        :partition_key_type,
+        :read_capacity_units,
+        :table_name,
+        :write_capacity_units
+
+      def initialize(table_name:, partition_key:, local_indexes: {}, args: {})
+        @table_name = table_name
+        @partition_key_name = partition_key.keys.first
+        @partition_key_type = partition_key.values.first.to_s.capitalize
+        @local_indexes = local_indexes
+        @read_capacity_units = args[:read_capacity_units] || 50
+        @write_capacity_units = args[:read_capacity_units] || 100
+      end
+
+      def to_hash
+        {
+          attribute_definitions: attribute_definitions,
+          global_secondary_indexes: global_secondary_indexes,
+          key_schema: table_key_schema,
+          local_secondary_indexes: local_secondary_indexes,
+          provisioned_throughput: provisioned_throughput,
+          table_name: table_name
+        }
+      end
+
+      private
+
+      def attribute_definitions
+        attrs = local_indexes.merge(partition_key_name => partition_key_type)
+        attrs[:event_uuid] = :s
+
+        attr_defs = []
+
+        attrs.each_pair do |name, type|
+          attr_defs << { attribute_name: name, attribute_type: type.to_s.capitalize }
+        end
+
+        attr_defs
+      end
+
+      def local_secondary_indexes
+        secondary_defs = []
+
+        local_indexes[:created_at] = :s
+
+        local_indexes.each_pair do |local_index, _|
+          secondary_defs << {
+            index_name: "Index#{local_index.to_s.camelize}",
+            key_schema: local_key_schema(local_index),
+            projection: { projection_type: 'KEYS_ONLY' }
+          }
+        end
+
+        secondary_defs
+      end
+
+      def local_key_schema(attribute_name)
+        [
+          { attribute_name: partition_key_name, key_type: 'HASH' },
+          { attribute_name: attribute_name, key_type: 'RANGE' }
+        ]
+      end
+
+      def global_secondary_indexes
+        [event_uuid_global_secondary_index]
+      end
+
+      def event_uuid_global_secondary_index
+        {
+          index_name: 'event_uuid',
+          key_schema: [{ attribute_name: 'event_uuid', key_type: 'HASH' }],
+          projection: { projection_type: 'KEYS_ONLY' },
+          provisioned_throughput: provisioned_throughput
+        }
+      end
+
+      def table_key_schema
+        [
+          { attribute_name: partition_key_name, key_type: 'HASH' },
+          { attribute_name: 'event_uuid', key_type: 'RANGE' }
+        ]
+      end
+
+      def provisioned_throughput
+        {
+          read_capacity_units: read_capacity_units,
+          write_capacity_units: write_capacity_units
+        }
+      end
+    end
+  end
+end

data/lib/eventosaurus/persistors/sidekiq.rb

@@ -0,0 +1,12 @@
+require 'sidekiq'
+require 'eventosaurus/workers/sidekiq'
+
+module Eventosaurus
+  module Persistors
+    class Sidekiq
+      def self.persist(klass_name, item)
+        Eventosaurus::Workers::Sidekiq.perform_async(klass_name, item)
+      end
+    end
+  end
+end

data/lib/eventosaurus/persistors/synchronous.rb

@@ -0,0 +1,16 @@
+module Eventosaurus
+  module Persistors
+    class Synchronous
+      def self.persist(klass_name, item)
+        klass = klass_name.constantize
+        klass.put_item(item)
+
+      rescue Aws::DynamoDB::Errors::ConditionalCheckFailedException => e
+        # This must be a double submit. Log it just in case.
+        Eventosaurus.configuration.logger.info(
+          "Duplicate UUID sent to DynamoDB. Details: #{item}. Error: #{e}"
+        )
+      end
+    end
+  end
+end

data/lib/eventosaurus/query_builder.rb

@@ -0,0 +1,67 @@
+module Eventosaurus
+  module QueryBuilder
+    delegate :count, :select, to: :new_query
+
+    def build_query_methods
+      secondary_indexes = definition[:local_indexes] || {}
+      build_partition_key_methods
+      build_local_secondary_methods(secondary_indexes)
+    end
+
+    def build_partition_key_methods
+      method_name = generate_method_name(partition_key_name)
+
+      build_partition_key_event_class_method(method_name)
+      build_partition_key_query_instance_method(method_name)
+    end
+
+    def build_partition_key_event_class_method(method_name)
+      singleton_proc = proc do |value, operator = 'EQ'|
+        new_query.by_partition_key(value: value, operator: operator)
+      end
+
+      define_singleton_method(method_name, singleton_proc)
+    end
+
+    def build_partition_key_query_instance_method(method_name)
+      instance_proc = proc do |value, operator = 'EQ'|
+        by_partition_key(value: value, operator: operator)
+      end
+
+      Eventosaurus::Models::Query.send(:define_method, method_name, instance_proc)
+    end
+
+    def build_local_secondary_methods(secondary_indexes)
+      secondary_indexes.each_pair do |attr_name, _|
+        method_name = generate_method_name(attr_name)
+
+        build_local_secondary_event_class_method(method_name, attr_name)
+        build_local_secondary_query_instance_method(method_name, attr_name)
+      end
+    end
+
+    def build_local_secondary_event_class_method(method_name, attr_name)
+      singleton_proc = proc do |value, operator = 'EQ'|
+        new_query.by_local_secondary(name: attr_name, value: value, operator: operator)
+      end
+
+      define_singleton_method(method_name, singleton_proc)
+    end
+
+    def build_local_secondary_query_instance_method(method_name, attr_name)
+      instance_proc = proc do |value, operator = 'EQ'|
+        by_local_secondary(name: attr_name, value: value, operator: operator)
+      end
+
+      Eventosaurus::Models::Query.send(:define_method, method_name, instance_proc)
+    end
+
+    def new_query
+      Eventosaurus::Models::Query.new(definition)
+    end
+
+    def generate_method_name(attr)
+      "by_#{attr}".to_sym
+    end
+  end
+end

data/lib/eventosaurus/railtie.rb

@@ -0,0 +1,12 @@
+require 'eventosaurus'
+require 'rails'
+
+module Eventosaurus
+  class Railtie < Rails::Railtie
+    railtie_name :eventosaurus
+
+    rake_tasks do
+      load "eventosaurus/tasks/eventosaurus.rake"
+    end
+  end
+end

data/lib/eventosaurus/services/table_manager_service.rb

@@ -0,0 +1,76 @@
+module Eventosaurus
+  class TableManagerService
+    class << self
+      def create_tables
+        load_events
+
+        existing_table_names = list_tables
+        Eventosaurus.event_table_definitions.each do |definition|
+          full_name = full_table_name(definition[:name])
+          next if existing_table_names.include?(full_name)
+
+          new_table = table_from_definition(definition).to_hash
+          api_create_table(new_table.to_hash)
+        end
+      end
+
+      def list_tables
+        prefix = Eventosaurus.configuration.environment_prefix
+        api_list_tables.table_names.select { |table_name| table_name.start_with?(prefix) }
+      end
+
+      def drop_tables
+        api_drop_tables
+      end
+
+      def describe_tables
+        load_events
+
+        Eventosaurus.event_table_definitions.map do |definition|
+          table_from_definition(definition).to_hash
+        end
+      end
+
+      def full_table_name(table_name)
+        "#{Eventosaurus.configuration.environment_prefix}_#{table_name}"
+      end
+
+      private
+
+      def table_from_definition(definition)
+        full_name = full_table_name(definition[:name])
+        partition_key = definition[:partition_key]
+        local_indexes = definition[:local_indexes] || {}
+
+        Eventosaurus::Models::Table.new(
+          table_name: full_name,
+          partition_key: partition_key,
+          local_indexes: local_indexes
+        )
+      end
+
+      # Ensure all table definitions are saved in the module variable @event_table_definitions
+      def load_events
+        Dir["#{Rails.root}/app/models/events/*.rb"].each { |file| require file }
+      end
+
+      def dynamodb_client
+        Eventosaurus.configuration.dynamodb_client
+      end
+
+      def api_list_tables
+        dynamodb_client.list_tables
+      end
+
+      def api_create_table(table_details)
+        dynamodb_client.create_table(table_details)
+      end
+
+      def api_drop_tables
+        list_tables.each do |table_name|
+          dynamodb_client.delete_table(table_name: table_name)
+        end
+      end
+    end
+  end
+end

data/lib/eventosaurus/storable.rb

@@ -0,0 +1,125 @@
+module Eventosaurus
+  class EventError < StandardError; end
+
+  @event_table_definitions = []
+
+  def self.add_table_definition(definition)
+    @event_table_definitions << definition
+    @event_table_definitions.uniq!
+  end
+
+  def self.event_table_definitions
+    @event_table_definitions
+  end
+
+  module Storable
+    def self.included(base)
+      base.extend ClassMethods
+      base.extend Eventosaurus::QueryBuilder
+    end
+
+    module ClassMethods
+      attr_accessor :table_name
+      attr_accessor :definition
+      attr_accessor :partition_key_name
+      attr_accessor :partition_key_type
+      attr_accessor :composite_primary_key_attrs
+
+      def store(*args)
+        item = details(*args)
+        item[:created_at] = Time.now.utc
+        item[:event_uuid] = generate_uuid(item)
+
+        persistor.persist(name, item)
+      rescue StandardError => error
+        on_error(error)
+      end
+
+      def put_item(item)
+        dynamodb_client.put_item(table_name: table_name, item: item, condition_expression: condition_expression)
+      end
+
+      private
+
+      # override in your event class, if your heart desires
+      def on_error(error)
+        raise error
+      end
+
+      # Ensure we do not overwrite. This causes SDK to raise
+      # if UUID is already found in DynamoDB
+      def condition_expression
+        "attribute_not_exists(event_uuid)"
+      end
+
+      def generate_uuid_predigest(item)
+        unless all_composite_primary_key_attrs_found?(item)
+          raise EventError, "missing composite primary key attributes in your item"
+        end
+
+        Array.wrap(composite_primary_key_attrs).each_with_object('') do |key_attr, key|
+          key << "#{key_attr}=#{item[key_attr]}:" if item[key_attr].present?
+        end
+      end
+
+      def generate_uuid(item)
+        created_at_ms = (item[:created_at].to_f * 1000).to_i
+
+        if composite_primary_key_attrs.present?
+          "#{created_at_ms}:#{Digest::SHA256.digest(generate_uuid_predigest(item))}"
+        else
+          "#{created_at_ms}:#{SecureRandom.uuid}"
+        end
+      end
+
+      def all_composite_primary_key_attrs_found?(item)
+        (composite_primary_key_attrs - item.keys).blank?
+      end
+
+      def dynamodb_client
+        Eventosaurus.configuration.dynamodb_client
+      end
+
+      def persistor
+        Eventosaurus.configuration.persistor
+      end
+
+      def table_definition(definition)
+        self.definition = definition
+
+        validate_table_definition
+        store_definition_elements
+        augment_table_with_defaults
+        build_query_methods
+
+        Eventosaurus.add_table_definition(definition)
+      end
+
+      def composite_primary_key(*cpk_attrs)
+        self.composite_primary_key_attrs = Array.wrap(cpk_attrs)
+      end
+
+      def validate_table_definition
+        raise EventError, "No partition key specified" unless definition[:partition_key].present?
+        raise EventError, "No table name specified" unless definition[:name].present?
+      end
+
+      def store_definition_elements
+        self.table_name = Eventosaurus::TableManagerService.full_table_name(definition[:name])
+        self.partition_key_name = definition[:partition_key].keys[0]
+        self.partition_key_type = definition[:partition_key].values[0]
+      end
+
+      def augment_table_with_defaults
+        definition[:full_table_name] = table_name
+        definition[:local_indexes] ||= {}
+        definition[:local_indexes][:event_uuid] = :s
+        definition[:local_indexes][:created_at] = :s
+      end
+
+      def details
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/eventosaurus/tasks/eventosaurus.rake

@@ -0,0 +1,31 @@
+desc 'Create Tables for this environment. Do nothing if table exists'
+namespace :eventosaurus do
+  desc 'create dynamodb tables. If tables exist, do nothing'
+  task create_tables: :environment do
+    Eventosaurus::TableManagerService.create_tables
+    puts "tables created."
+  end
+
+  desc 'list dynamodb tables'
+  task list_tables: :environment do
+    puts "tables: #{ Eventosaurus::TableManagerService.list_tables.join(',') }"
+  end
+
+  desc 'drop dynamodb tables'
+  task drop_tables: :environment do
+    Eventosaurus::TableManagerService.drop_tables
+    puts 'tables destroyed'
+  end
+
+  desc 'describe tables'
+  task describe_tables: :environment do
+    descriptions = Eventosaurus::TableManagerService.describe_tables
+    descriptions.each do |description|
+      puts ""
+      puts "-----------------------------------"
+      puts "TABLE: #{description[:table_name]}"
+      puts ""
+      pp description
+    end
+  end
+end

data/lib/eventosaurus/version.rb

@@ -0,0 +1,7 @@
+module Eventosaurus
+  MAJOR = '1'.freeze
+  MINOR = '0'.freeze
+  PATCH = '0'.freeze
+
+  VERSION = [MAJOR, MINOR, PATCH].join('.')
+end

data/lib/eventosaurus/workers/sidekiq.rb

@@ -0,0 +1,20 @@
+module Eventosaurus
+  module Workers
+    class Sidekiq
+      include ::Sidekiq::Worker
+
+      sidekiq_options retry: 3
+
+      def perform(klass_name, item)
+        klass = klass_name.constantize
+        klass.put_item(item)
+
+      rescue Aws::DynamoDB::Errors::ConditionalCheckFailedException => e
+        # This must be a double submit. Log it just in case.
+        Eventosaurus.configuration.logger.info(
+          "Duplicate UUID sent to DynamoDB. Details: #{item}. Error: #{e}"
+        )
+      end
+    end
+  end
+end

data/lib/eventosaurus.rb

@@ -0,0 +1,10 @@
+require 'active_support'
+require 'active_support/core_ext'
+require 'eventosaurus/railtie' if defined?(Rails)
+require 'eventosaurus/version'
+require 'eventosaurus/configuration'
+require 'eventosaurus/storable'
+require 'eventosaurus/query_builder'
+require 'eventosaurus/services/table_manager_service'
+require 'eventosaurus/models/table.rb'
+require 'eventosaurus/models/query.rb'