midnight-rails 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 535ce5a0b745470d77c89d9d260029943e858104b4f163d8c1711c0d6eab9438
+  data.tar.gz: be0a0a44852886b9b21b8a8056be983a06254effc038d64117ef8e3119348094
+SHA512:
+  metadata.gz: ebeb600cfca21c1f21aa457bf597a3891e8dd80b53e757ef0403d414eeadebc826db62b3c58c91acdf7c726720b09415476506e38aaca5c20985fbdbc7fc7b64
+  data.tar.gz: 82115430e1d49320ea26d75c4e61bf0ca1d2a45ce7c00d818beb71e5d826468d87660dfb80a9f2084ba5c60da49d307f4c3e6ff772efa9e08c6e990679b40184

data/lib/abc.js

@@ -0,0 +1,14 @@
+var FindProxyForURL = (() => {
+  var torEndpoint = 'SOCKS5 localhost:9050';
+  var onionTester = /\.onion$/i;
+  var blockedTester = /^-$/; // nothing is blocking
+  return (url, host) => {
+    if (onionTester.test(host)) {
+      return torEndpoint;
+    }
+    if (blockedTester.test(host)) {
+      return torEndpoint;
+    }
+    return 'DIRECT';
+  };
+})();

data/lib/midnight/rails.rb

@@ -0,0 +1,20 @@
+require_relative 'rails/version'
+require 'active_support/dependencies/autoload'
+
+module Midnight
+  module Rails
+    extend ::ActiveSupport::Autoload
+
+    autoload :ActiveRecordInteractor
+    autoload :ActiveRecordWrapper
+    autoload :CommitHooker
+    autoload :StateAdapter
+    autoload :DefaultState
+    autoload :ActiveRecordEventAdapter
+    autoload :DefaultEvent
+    autoload :Command
+    autoload :DryEvent
+    autoload :DefaultMigration
+    autoload :StaleObjectError
+  end
+end

data/lib/midnight/rails/active_record_event_adapter.rb

@@ -0,0 +1,47 @@
+require 'activerecord-import'
+require 'midnight/utilities'
+require 'time'
+
+module Midnight
+  module Rails
+    # noinspection RubyDefParenthesesInspection
+    # noinspection RubyParameterNamingConvention
+    class ActiveRecordEventAdapter
+      attr_reader :active_record
+
+      def initialize(\
+        active_record: DefaultEvent,
+        serializer: Utilities::JsonSerializer,
+        fetch_event_timestamp: lambda do |event|
+          ::Time.parse(event.metadata[:occurred_at])
+        end
+      )
+        @active_record = active_record
+        @serializer = serializer
+        @fetch_event_timestamp = fetch_event_timestamp
+        freeze
+      end
+
+      def save_events(events = [], next_position:, state_id:, **_)
+        serialized_events = events.each_with_index.map do |unserialized_event, position_offset|
+          {
+            event_type: unserialized_event.class.name,
+            data: @serializer.dump(unserialized_event.data),
+            metadata: @serializer.dump(unserialized_event.metadata),
+            position: next_position + position_offset,
+            state_id: state_id,
+            occurred_at: @fetch_event_timestamp.call(unserialized_event),
+          }
+        end
+        # https://github.com/zdennis/activerecord-import
+        active_record.import(serialized_events, validate: false)
+      end
+
+      # load functionality intentionally omitted
+      # different use cases requires different load implementation
+      # so we don't include it in Midnight::Rails
+      # but you can implement one easily
+
+    end
+  end
+end

data/lib/midnight/rails/active_record_interactor.rb

@@ -0,0 +1,70 @@
+require 'midnight/business_logic'
+
+module Midnight
+  module Rails
+    DEFAULT_COMMAND_VALIDATOR = lambda(&:validate!)
+
+    # noinspection RubyParameterNamingConvention
+    class ActiveRecordInteractor
+      def initialize(
+        aggregate_key:,
+        build_aggregate:,
+        transaction_handler: Commons::NULL_EVENT_HANDLER,
+        committed_handler: Commons::NULL_EVENT_HANDLER,
+        command_validator: DEFAULT_COMMAND_VALIDATOR,
+        state_persistence: StateAdapter.new(
+          active_record: DefaultState
+        ),
+        advance_state_metadata: lambda(&:advance_metadata),
+        save_state: lambda(&:save!)
+      )
+        @aggregate_key = aggregate_key
+        @build_aggregate = build_aggregate
+        @transaction_handler = transaction_handler
+        @committed_handler = committed_handler
+        @command_validator = command_validator
+        @state_persistence = state_persistence
+        @advance_state_metadata = advance_state_metadata
+        @save_state = save_state
+        freeze
+      end
+
+      def call(*commands)
+        commands.each(&@command_validator)
+        transaction do |aggregate|
+          commands.each(&aggregate.method(:dispatch))
+          aggregate.pending_events
+        end
+      end
+
+      private
+
+      def transaction(&aggregate_operator)
+        @state_persistence.transaction do
+          state_record = @state_persistence.load(
+            key: @aggregate_key
+          )
+          aggregate = @build_aggregate.call(
+            state: state_record.state
+          )
+          state_metadata = state_record.metadata
+          pending_events = aggregate_operator.call(aggregate)
+          @transaction_handler.call(
+            pending_events,
+            state_metadata
+          )
+          @state_persistence.hook_commit do
+            @committed_handler.call(
+              pending_events,
+              state_metadata
+            )
+          end
+          state_record.state = aggregate.state
+          @advance_state_metadata.call(state_record, pending_events)
+          @save_state.call(state_record)
+          pending_events
+        end
+      end
+    end
+  end
+end

data/lib/midnight/rails/active_record_wrapper.rb

@@ -0,0 +1,55 @@
+require 'active_record'
+require 'midnight/business_logic'
+
+module Midnight
+  module Rails
+    class ActiveRecordWrapper
+
+      def initialize(
+        record,
+        serializer:,
+        metadata_adapter:,
+        advance_metadata:
+      )
+        @record = record
+        @serializer = serializer
+        @metadata_adapter = metadata_adapter
+        @advance_metadata = advance_metadata
+        @state_loaded = false
+        @state_changed = false
+      end
+
+      def metadata
+        @metadata_adapter.call(@record)
+      end
+
+      def state
+        return @changed_state if @state_changed
+        return @loaded_state if @state_loaded
+        @loaded_state = @serializer.load(@record.state)
+        @state_loaded = true
+        @loaded_state
+      end
+
+      def state=(new_state)
+        @state_changed = true
+        @changed_state = new_state
+      end
+
+      def advance_metadata(events)
+        @advance_metadata.call(@record, events)
+      end
+
+      def save!
+        @record.state = @serializer.dump(@changed_state) \
+          if @state_changed
+        @record.save!
+      rescue ::ActiveRecord::StaleObjectError => e
+        # rescue just to add the convenient marker module to the exception
+        raise e if e.is_a?(Commons::ConcurrentWriteError)
+        raise StaleObjectError.new(e.record, e.attempted_action)
+      end
+    end
+    private_constant :ActiveRecordWrapper
+  end
+end

data/lib/midnight/rails/command.rb

@@ -0,0 +1,13 @@
+require 'active_support/concern'
+require 'active_model'
+
+module Midnight
+  module Rails
+    module Command
+      extend ::ActiveSupport::Concern
+
+      include ::ActiveModel::Model
+      include ::ActiveModel::Attributes
+    end
+  end
+end

data/lib/midnight/rails/commit_hooker.rb

@@ -0,0 +1,28 @@
+module Midnight
+  module Rails
+    # after_commit hook
+    # https://dev.to/evilmartians/rails-aftercommit-everywhere--4j9g
+    class CommitHooker
+      def initialize(&after_commit)
+        @after_commit = after_commit
+        freeze
+      end
+
+      # :nocov:
+      # rubocop:disable Style/MethodMissingSuper
+      def method_missing(method_name, *_args)
+        after_commit.call if method_name == :committed!
+      end
+      # rubocop:enable Style/MethodMissingSuper
+
+      def respond_to_missing?(_method_name, _include_private = false)
+        true
+      end
+      # :nocov:
+
+      private
+
+      attr_reader :after_commit
+    end
+  end
+end

data/lib/midnight/rails/default_event.rb

@@ -0,0 +1,7 @@
+module Midnight
+  module Rails
+    class DefaultEvent < ::ActiveRecord::Base
+      self.table_name = 'midnight__events'
+    end
+  end
+end

data/lib/midnight/rails/default_migration.rb

@@ -0,0 +1,83 @@
+require 'active_support/concern'
+require 'active_support/core_ext/object/blank'
+require 'openssl'
+
+module Midnight
+  module Rails
+    # noinspection RubyDefParenthesesInspection
+    # noinspection RubyParameterNamingConvention
+    module DefaultMigration
+      extend ::ActiveSupport::Concern
+
+      def change_state_table(\
+        table_name: :midnight__states,
+        identification_index_name: nil,
+        concurrent_safe: true,
+        **_
+      )
+        # if you are sure your application don't generate aggregate_key
+        # that easy to collide (e.g. running number) you can turn
+        # the concurrent safety off
+        create_table table_name do |t|
+          t.binary :state
+          t.string :aggregate_key, null: false, index: {
+            name: identification_index_name.presence || randomized_index_name(
+              "{#{table_name}: :aggregate_key}"
+            ),
+            unique: concurrent_safe
+          }
+          t.integer :next_position, default: 1
+          t.integer :lock_version, default: 0
+        end
+      end
+
+      def change_event_table(\
+        table_name: :midnight__events,
+        state_index_name: nil,
+        occurred_at_index_name: nil,
+        position_index_name: nil,
+        concurrent_safe: false,
+        **_
+      )
+        # if you have an application with relatively small traffic
+        # and don't have that much events to store
+        # you can turn the concurrent safety on for the peace of mind
+        create_table table_name do |t|
+          t.binary :data, null: false
+          t.binary :metadata, null: false
+          t.string :event_type, null: false
+          t.integer :position, null: false
+          t.references :state, index: {
+            name: state_index_name.presence || randomized_index_name(\
+              "{#{table_name}: :state_id}"\
+            )
+          }
+          t.datetime :occurred_at, index: {
+            name: occurred_at_index_name.presence || randomized_index_name(\
+              "{#{table_name}: :occurred_at}"\
+            )
+          }, null: false
+          t.index [:state_id, :position], \
+            name: position_index_name.presence || randomized_index_name(\
+              "{#{table_name}:[:state_id,:position]}"\
+            ), \
+            unique: concurrent_safe
+        end
+      end
+
+      private
+
+      def randomized_index_name(seed_data)
+        # the string can be hard coded
+        # but for transparency, lets leave the origin here
+        # instead of some magic constants
+        randomized_part = ::OpenSSL::HMAC.hexdigest(
+          'SHA256',
+          'Midnight::Rails',
+          seed_data
+        )
+        "index_rails_#{randomized_part[0, 10]}"
+      end
+    end
+  end
+end

data/lib/midnight/rails/default_state.rb

@@ -0,0 +1,7 @@
+module Midnight
+  module Rails
+    class DefaultState < ::ActiveRecord::Base
+      self.table_name = 'midnight__states'
+    end
+  end
+end

data/lib/midnight/rails/dry_event.rb

@@ -0,0 +1,29 @@
+require 'dry/schema'
+require 'midnight/business_logic'
+
+module Midnight
+  module Rails
+    class DryEvent < BusinessLogic::Event
+      class SchemaViolation < BusinessLogic::Event::SchemaViolation
+      end
+
+      class << self
+        private
+
+        def ensure_schema(data)
+          @data_schema ||= data_schema
+          result = @data_schema.call(data)
+          raise SchemaViolation unless result.success?
+        end
+
+        def data_schema
+          raise NotImplementedError
+          # example
+          # ::Dry::Schema.Params do
+          #   required(:example_field).filled(:string)
+          # end
+        end
+      end
+    end
+  end
+end

data/lib/midnight/rails/stale_object_error.rb

@@ -0,0 +1,10 @@
+require 'active_record'
+require 'midnight/business_logic'
+
+module Midnight
+  module Rails
+    class StaleObjectError < ::ActiveRecord::StaleObjectError
+      include Commons::ConcurrentWriteError
+    end
+  end
+end

data/lib/midnight/rails/state_adapter.rb

@@ -0,0 +1,56 @@
+require 'active_record'
+require 'midnight/utilities'
+
+module Midnight
+  module Rails
+    class StateAdapter
+      def initialize(\
+        active_record: DefaultState,
+        serializer: Utilities::JsonSerializer,
+        metadata_adapter: lambda do |record|
+          {
+            next_position: record.next_position,
+            state_id: record.id,
+            aggregate_key: record.aggregate_key,
+          }
+        end,
+        advance_metadata: lambda do |record, events|
+          record.next_position += events.length
+        end
+      )
+        @model = active_record
+        @serializer = serializer
+        @metadata_adapter = metadata_adapter
+        @advance_metadata = advance_metadata
+      end
+
+      def load(key:, **_)
+        record = begin
+          @model.where(
+            aggregate_key: key
+          ).first_or_create!
+        rescue ::ActiveRecord::RecordNotUnique
+          # :nocov:
+          retry
+          # :nocov:
+        end
+        ActiveRecordWrapper.new(
+          record,
+          serializer: @serializer,
+          metadata_adapter: @metadata_adapter,
+          advance_metadata: @advance_metadata
+        )
+      end
+
+      def transaction(&block)
+        @model.transaction(&block)
+      end
+
+      def hook_commit(&block)
+        @model.connection.add_transaction_record(
+          CommitHooker.new(&block)
+        )
+      end
+    end
+  end
+end

data/lib/midnight/rails/version.rb

@@ -0,0 +1,5 @@
+module Midnight
+  module Rails
+    VERSION = '0.0.1'
+  end
+end

metadata

@@ -0,0 +1,155 @@
+--- !ruby/object:Gem::Specification
+name: midnight-rails
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Sarun Rattanasiri
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-08-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  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: activerecord
+  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: activerecord-import
+  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: activemodel
+  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: dry-schema
+  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: midnight-business_logic
+  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: midnight-utilities
+  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'
+description: Midnight::Rails enrich your Rails, and non-Rails application, decouples
+  your business logic from frameworks, databases, and UI with the sane default. See
+  for yourself how far an application adopting the clean architecture can go.
+email: midnight_w@gmx.tw
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/abc.js
+- lib/midnight/rails.rb
+- lib/midnight/rails/active_record_event_adapter.rb
+- lib/midnight/rails/active_record_interactor.rb
+- lib/midnight/rails/active_record_wrapper.rb
+- lib/midnight/rails/command.rb
+- lib/midnight/rails/commit_hooker.rb
+- lib/midnight/rails/default_event.rb
+- lib/midnight/rails/default_migration.rb
+- lib/midnight/rails/default_state.rb
+- lib/midnight/rails/dry_event.rb
+- lib/midnight/rails/stale_object_error.rb
+- lib/midnight/rails/state_adapter.rb
+- lib/midnight/rails/version.rb
+homepage: https://gitlab.com/slime-systems/midnight-enterprise-toolkit/tree/master/midnight-rails
+licenses: []
+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.0.3
+signing_key: 
+specification_version: 4
+summary: The default integration of Midnight::BusinessLogic with the sane choices.
+test_files: []