sequent 0.1.10 → 1.0.0

data/lib/sequent/core/sequent_oj.rb

@@ -4,8 +4,10 @@ module Sequent
   module Core
     # small wrapper class to centralize oj and its settings.
     class Oj
-
-      ::Oj.default_options={mode: :compat}
+      ::Oj.default_options = {
+        bigdecimal_as_decimal: false,
+        mode: :compat,
+      }
 
       def self.strict_load(json)
         ::Oj.strict_load(json, {})
@@ -14,7 +16,6 @@ module Sequent
       def self.dump(obj)
         ::Oj.dump(obj)
       end
-
     end
   end
 end

data/lib/sequent/core/stream_record.rb

@@ -20,7 +20,7 @@ module Sequent
       validates_presence_of :aggregate_type, :aggregate_id
       validates_numericality_of :snapshot_threshold, only_integer: true, greater_than: 0, allow_nil: true
 
-      has_many :events
+      has_many :event_records
 
       def event_stream
         EventStream.new(aggregate_type: aggregate_type, aggregate_id: aggregate_id, snapshot_threshold: snapshot_threshold, stream_record_id: id)

data/lib/sequent/core/transactions/active_record_transaction_provider.rb

@@ -4,7 +4,7 @@ module Sequent
 
       class ActiveRecordTransactionProvider
         def transactional
-          ActiveRecord::Base.transaction do
+          ActiveRecord::Base.transaction(requires_new: true) do
             yield
           end
         end

data/lib/sequent/migrations/migrate_events.rb

@@ -31,26 +31,33 @@ module Sequent
       #
       # @param current_version The current version of the application. E.g. 10
       # @param new_version The version to migrate to. E.g. 11
-      # @param &after_migration_block an optional block to run after the migrations run. E.g. close resources
+      # @param &after_migration_block an optional block (with the current upgrade version as param) to run after the migrations run. E.g. close resources
       #
       def execute_migrations(current_version, new_version, &after_migration_block)
-        if current_version != new_version and current_version > 0
-          ((current_version + 1)..new_version).each do |upgrade_to_version|
-            migration_class = begin
-                                Class.const_get("Database::MigrateToVersion#{upgrade_to_version}")
-                              rescue NameError
-                                nil
-                              end
-            if migration_class
-              begin
-                migration_class.new(@env).migrate
-              ensure
-                after_migration_block.call if after_migration_block
-              end
-            end
+        migrations(current_version, new_version).each do |migration_class|
+          migration = migration_class.new(@env)
+          begin
+            migration.migrate
+          ensure
+            yield(migration.version) if block_given?
           end
         end
       end
+
+      def migrations(current_version, new_version)
+        return [] if current_version == 0
+        ((current_version + 1)..new_version).map do |upgrade_to_version|
+          begin
+            Class.const_get("Database::MigrateToVersion#{upgrade_to_version}")
+          rescue NameError
+            nil
+          end
+        end.compact
+      end
+
+      def has_migrations?(current_version, new_version)
+        migrations(current_version, new_version).any?
+      end
     end
   end
 end

data/lib/sequent/rake/tasks.rb

@@ -0,0 +1,102 @@
+require 'active_record'
+require 'rake'
+require 'rake/tasklib'
+
+require 'sequent/support'
+
+module Sequent
+  module Rake
+    class Tasks < ::Rake::TaskLib
+      include ::Rake::DSL
+
+      DEFAULT_OPTIONS = {
+        migrations_path: 'db/migrate',
+        event_store_schema: 'public'
+      }
+
+      attr_reader :options
+
+      def initialize(options)
+        @options = DEFAULT_OPTIONS.merge(options)
+      end
+
+      def register!
+        register_db_tasks!
+        register_view_schema_tasks!
+      end
+
+      def register_db_tasks!
+        namespace :db do
+          desc 'Create the database'
+          task :create do
+            current_environments.each do |env|
+              env_db = db_config(env)
+              puts "Create database #{env_db['database']}"
+              Sequent::Support::Database.create!(env_db)
+            end
+          end
+
+          desc 'Drop the database'
+          task :drop do
+            current_environments.each do |env|
+              env_db = db_config(env)
+              puts "Drop database #{env_db['database']}"
+              Sequent::Support::Database.drop!(env_db)
+            end
+          end
+
+          task :establish_connection do
+            env_db = db_config(options.fetch(:environment))
+            Sequent::Support::Database.establish_connection(env_db)
+          end
+
+          desc 'Migrate the database'
+          task migrate: :establish_connection do
+            database.create_schema!(options.fetch(:event_store_schema))
+            database.migrate(options.fetch(:migrations_path))
+          end
+        end
+      end
+
+      def register_view_schema_tasks!
+        namespace :view_schema do
+          desc 'Build the view schema'
+          task build: :'db:establish_connection' do
+            if database.schema_exists?(view_projection.schema_name)
+              puts "View version #{view_projection.version} already exists; no need to build it"
+            else
+              database.create_schema!(view_projection.schema_name)
+              view_projection.build!
+            end
+          end
+
+          desc 'Drop the view schema'
+          task drop: :'db:establish_connection' do
+            database.drop_schema!(view_projection.schema_name)
+          end
+        end
+      end
+
+      private
+
+      def current_environments
+        environment = options.fetch(:environment)
+        envs = [environment]
+        envs << 'test' if environment == 'development'
+        envs
+      end
+
+      def database
+        @database ||= Sequent::Support::Database.new
+      end
+
+      def db_config(environment)
+        options.fetch(:db_config_supplier)[environment] or fail "No database config for #{environment}"
+      end
+
+      def view_projection
+        options.fetch(:view_projection)
+      end
+    end
+  end
+end

data/lib/sequent/sequent.rb

@@ -5,6 +5,10 @@ require_relative 'configuration'
 require 'logger'
 
 module Sequent
+  def self.new_uuid
+    Sequent.configuration.uuid_generator.uuid
+  end
+
   def self.logger
     @logger ||= Logger.new(STDOUT).tap {|l| l.level = Logger::INFO }
   end

data/lib/sequent/support.rb

@@ -0,0 +1,3 @@
+require_relative 'support/database'
+require_relative 'support/view_projection'
+require_relative 'support/view_schema'

data/lib/sequent/support/database.rb

@@ -0,0 +1,55 @@
+module Sequent
+  module Support
+    # Offers support operations for a postgres database.
+    #
+    # Class methods do establish their own database connections (and therefore
+    # take in a database configuration). Instance methods assume that a database
+    # connection yet is established.
+    class Database
+      attr_reader :db_config
+
+      def self.create!(db_config)
+        ActiveRecord::Base.establish_connection(db_config.merge('database' => 'postgres'))
+        ActiveRecord::Base.connection.create_database(db_config['database'])
+      end
+
+      def self.drop!(db_config)
+        ActiveRecord::Base.establish_connection(db_config.merge('database' => 'postgres'))
+        ActiveRecord::Base.connection.drop_database(db_config['database'])
+      end
+
+      def self.establish_connection(db_config)
+        ActiveRecord::Base.establish_connection(db_config)
+      end
+
+      def self.disconnect!
+        ActiveRecord::Base.connection_pool.disconnect!
+      end
+
+      def schema_exists?(schema)
+        ActiveRecord::Base.connection.execute(
+          "SELECT schema_name FROM information_schema.schemata WHERE schema_name like '#{schema}'"
+        ).count == 1
+      end
+
+      def create_schema!(schema)
+        sql = "CREATE SCHEMA IF NOT EXISTS #{schema}"
+        if user = ActiveRecord::Base.connection_config[:username]
+          sql += " AUTHORIZATION #{user}"
+        end
+        ActiveRecord::Base.connection.execute(sql)
+      end
+
+      def drop_schema!(schema)
+        ActiveRecord::Base.connection.execute(
+          "DROP SCHEMA IF EXISTS #{schema} CASCADE"
+        )
+      end
+
+      def migrate(migrations_path, verbose: true)
+        ActiveRecord::Migration.verbose = verbose
+        ActiveRecord::Migrator.migrate(migrations_path)
+      end
+    end
+  end
+end

data/lib/sequent/support/view_projection.rb

@@ -0,0 +1,58 @@
+require 'postgresql_cursor'
+
+module Sequent
+  module Support
+    class ViewProjection
+      attr_reader :name, :version, :schema_definition
+      def initialize(options)
+        @name = options.fetch(:name)
+        @version = options.fetch(:version)
+        @schema_definition = options.fetch(:definition)
+        @replay_event_handlers = options.fetch(:event_handlers)
+      end
+
+      def build!
+        with_default_configuration do
+          Sequent.configuration.event_handlers = @replay_event_handlers
+
+          load schema_definition
+          event_store = Sequent.configuration.event_store
+          ordering = Events::ORDERED_BY_STREAM
+          event_store.replay_events_from_cursor(
+            block_size: 10_000,
+            get_events: ->() { ordering[event_store] }
+          )
+        end
+      end
+
+      def schema_name
+        "#{name}_#{version}"
+      end
+
+      private
+
+      def with_default_configuration
+        original_configuration = Sequent.configuration
+        Sequent::Configuration.reset
+        yield
+        Sequent::Configuration.restore(original_configuration)
+      end
+    end
+
+    module Events
+      extend ActiveRecord::ConnectionAdapters::Quoting
+
+      ORDERED_BY_STREAM = lambda do |event_store|
+        event_records = quote_table_name(event_store.event_record_class.table_name)
+        stream_records = quote_table_name(event_store.stream_record_class.table_name)
+        snapshot_event_type = quote(event_store.snapshot_event_class)
+
+        event_store.event_record_class
+          .select("event_type, event_json")
+          .joins("INNER JOIN #{stream_records} ON #{event_records}.stream_record_id = #{stream_records}.id")
+          .where("event_type <> #{snapshot_event_type}")
+          .order!("#{stream_records}.id, #{event_records}.sequence_number")
+      end
+    end
+  end
+end

data/lib/sequent/support/view_schema.rb

@@ -0,0 +1,22 @@
+module Sequent
+  module Support
+    class ViewSchema < ActiveRecord::Schema
+      def define(info, &block)
+        view_projection = info[:view_projection]
+        switch_to_schema(view_projection) if view_projection
+        super
+      ensure
+        switch_back_to_original_schema if view_projection
+      end
+
+      def switch_to_schema(view_projection)
+        @original_schema_search_path = connection.schema_search_path
+        connection.schema_search_path = view_projection.schema_name
+      end
+
+      def switch_back_to_original_schema
+        connection.schema_search_path = @original_schema_search_path
+      end
+    end
+  end
+end

data/lib/sequent/test/command_handler_helpers.rb

@@ -44,9 +44,17 @@ module Sequent
         end
 
         def load_events(aggregate_id)
-          event_stream = @event_streams[aggregate_id]
-          return nil unless event_stream
-          [event_stream, deserialize_events(@all_events[aggregate_id])]
+          load_events_for_aggregates([aggregate_id])[0]
+        end
+
+        def load_events_for_aggregates(aggregate_ids)
+          return [] if aggregate_ids.none?
+
+          aggregate_ids.map do |aggregate_id|
+            @event_streams[aggregate_id]
+          end.compact.map do |event_stream|
+            [event_stream, deserialize_events(@all_events[event_stream.aggregate_id])]
+          end
         end
 
         def find_event_stream(aggregate_id)
@@ -119,16 +127,21 @@ module Sequent
 
       def when_command command
         raise "@command_handler is mandatory when using the #{self.class}" unless @command_handler
-        raise "Command handler #{@command_handler} cannot handle command #{command}, please configure the command type (forgot an include in the command class?)" unless @command_handler.handles_message?(command)
+        raise "Command handler #{@command_handler} cannot handle command #{command}, please configure the command type (forgot an include in the command class?)" unless @command_handler.class.handles_message?(command)
         @command_handler.handle_message(command)
         @repository.commit(command)
         @repository.clear
       end
 
-      def then_events *events
-        expect(@event_store.stored_events.map(&:class)).to eq(events.flatten(1).map(&:class))
-        @event_store.stored_events.zip(events.flatten(1)).each do |actual, expected|
-          expect(Sequent::Core::Oj.strict_load(Sequent::Core::Oj.dump(actual.payload))).to eq(Sequent::Core::Oj.strict_load(Sequent::Core::Oj.dump(expected.payload))) if expected
+      def then_events(*expected_events)
+        expected_classes = expected_events.flatten(1).map { |event| event.class == Class ? event : event.class }
+        expect(@event_store.stored_events.map(&:class)).to eq(expected_classes)
+
+        @event_store.stored_events.zip(expected_events.flatten(1)).each_with_index do |(actual, expected), index|
+          next if expected.class == Class
+          _actual = Sequent::Core::Oj.strict_load(Sequent::Core::Oj.dump(actual.payload))
+          _expected = Sequent::Core::Oj.strict_load(Sequent::Core::Oj.dump(expected.payload))
+          expect(_actual).to eq(_expected), "#{index+1}th Event of type #{actual.class} not equal\nexpected: #{_expected.inspect}\n     got: #{_actual.inspect}" if expected
         end
       end
 

data/lib/sequent/test/event_handler_helpers.rb

@@ -39,9 +39,12 @@ module Sequent
         end
       end
 
-      def then_events *events
-        expect(@event_store.stored_events.map(&:class)).to eq(events.flatten(1).map(&:class))
-        @event_store.stored_events.zip(events.flatten(1)).each do |actual, expected|
+      def then_events(*expected_events)
+        expected_classes = expected_events.flatten(1).map { |event| event.class == Class ? event : event.class }
+        expect(@event_store.stored_events.map(&:class)).to eq(expected_classes)
+
+        @event_store.stored_events.zip(expected_events.flatten(1)).each do |actual, expected|
+          next if expected.class == Class
           expect(Sequent::Core::Oj.strict_load(Sequent::Core::Oj.dump(actual.payload))).to eq(Sequent::Core::Oj.strict_load(Sequent::Core::Oj.dump(expected.payload))) if expected
         end
       end
@@ -58,6 +61,7 @@ module Sequent
         recorded = fake_command_service.recorded_commands
         expect(recorded.map(&:class)).to eq(commands.flatten(1).map(&:class))
         expect(fake_command_service.recorded_commands).to eq(commands.flatten(1))
+        expect(recorded).to all(be_valid)
       end
 
       def self.included(spec)

data/lib/version.rb

@@ -1,3 +1,3 @@
 module Sequent
-  VERSION = '0.1.10'
+  VERSION = '1.0.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sequent
 version: !ruby/object:Gem::Version
-  version: 0.1.10
+  version: 1.0.0
 platform: ruby
 authors:
 - Lars Vonk
@@ -10,36 +10,48 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-12 00:00:00.000000000 Z
+date: 2017-06-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '4.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '4.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.2'
 - !ruby/object:Gem::Dependency
   name: activemodel
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '4.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '4.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.2'
 - !ruby/object:Gem::Dependency
   name: pg
   requirement: !ruby/object:Gem::Requirement
@@ -54,20 +66,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.18'
+- !ruby/object:Gem::Dependency
+  name: postgresql_cursor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
 - !ruby/object:Gem::Dependency
   name: oj
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.10'
+        version: 2.17.5
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.10'
+        version: 2.17.5
 - !ruby/object:Gem::Dependency
   name: thread_safe
   requirement: !ruby/object:Gem::Requirement
@@ -152,6 +178,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.10'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.14.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.14.1
 description: Sequent is a CQRS and event sourcing framework for Ruby.
 email:
 - lars.vonk@gmail.com
@@ -194,13 +234,13 @@ files:
 - lib/sequent/core/helpers/type_conversion_support.rb
 - lib/sequent/core/helpers/uuid_helper.rb
 - lib/sequent/core/helpers/value_validators.rb
+- lib/sequent/core/random_uuid_generator.rb
 - lib/sequent/core/record_sessions/active_record_session.rb
 - lib/sequent/core/record_sessions/record_sessions.rb
 - lib/sequent/core/record_sessions/replay_events_session.rb
 - lib/sequent/core/sequent_oj.rb
 - lib/sequent/core/snapshots.rb
 - lib/sequent/core/stream_record.rb
-- lib/sequent/core/tenant_event_store.rb
 - lib/sequent/core/transactions/active_record_transaction_provider.rb
 - lib/sequent/core/transactions/no_transactions.rb
 - lib/sequent/core/transactions/transactions.rb
@@ -208,7 +248,12 @@ files:
 - lib/sequent/core/workflow.rb
 - lib/sequent/migrations/migrate_events.rb
 - lib/sequent/migrations/migrations.rb
+- lib/sequent/rake/tasks.rb
 - lib/sequent/sequent.rb
+- lib/sequent/support.rb
+- lib/sequent/support/database.rb
+- lib/sequent/support/view_projection.rb
+- lib/sequent/support/view_schema.rb
 - lib/sequent/test.rb
 - lib/sequent/test/command_handler_helpers.rb
 - lib/sequent/test/event_handler_helpers.rb