eventsimple 1.8.1 → 2.0.1

data/lib/eventsimple/data_type.rb

@@ -17,22 +17,22 @@ module Eventsimple
       case value
       when String
         decoded = ActiveSupport::JSON.decode(value)
-        return event_klass::Message.new(decoded) if event_klass.const_defined?(:Message)
-
-        decoded
+        prepare_data(decoded)
       when Hash
-        return event_klass::Message.new(value) if event_klass.const_defined?(:Message)
-
-        value
-      when event_klass::Message
+        prepare_data(value)
+      when message_class
         value
       end
     end
 
     def serialize(value)
       case value
-      when Hash, event_klass::Message
-        ActiveSupport::JSON.encode(value)
+      when Hash
+        encrypted_data = encrypt_message_data(value)
+        ActiveSupport::JSON.encode(encrypted_data)
+      when event_klass::Message
+        encrypted_data = encrypt_message_data(value.attributes)
+        ActiveSupport::JSON.encode(encrypted_data)
       else
         super
       end
@@ -40,9 +40,62 @@ module Eventsimple
 
     def deserialize(value)
       decoded = ActiveSupport::JSON.decode(value)
-      return event_klass::Message.new(decoded) if event_klass.const_defined?(:Message)
+      decrypted_data = decrypt_message_data(decoded)
+      message_class ? message_class.new(decrypted_data) : decrypted_data
+    end
+
+    def changed_in_place?(raw_old_value, new_value)
+      old_value = deserialize(raw_old_value)
+      old_value != new_value
+    end
+
+    def mutable?
+      true
+    end
+
+    private
+
+    def message_class
+      event_klass.const_defined?(:Message) ? event_klass::Message : nil
+    end
+
+    def prepare_data(data_hash)
+      decrypted_data = decrypt_message_data(data_hash)
+      message_class ? message_class.new(decrypted_data) : decrypted_data
+    end
+
+    def encrypt_message_data(data_hash)
+      transform_message_data(data_hash, :encrypt)
+    end
+
+    def decrypt_message_data(data_hash)
+      transform_message_data(data_hash, :decrypt)
+    end
+
+    def transform_message_data(data_hash, operation)
+      return data_hash unless message_class
+
+      schema = message_class.schema
+      result = data_hash.transform_keys(&:to_sym).dup
+
+      schema.keys.each do |key| # rubocop:disable Style/HashEachMethods
+        attr_name = key.name
+        type = find_type_with_operation(key.type, operation)
+        value = result[attr_name]
+
+        next if value.nil? || type.nil?
+
+        result[attr_name] = type.public_send(operation, value.to_s)
+      end
+
+      result
+    end
+
+    def find_type_with_operation(type, operation)
+      return type if type.respond_to?(operation)
 
-      decoded
+      # For Sum types (optional), check if the right side has the operation
+      type.respond_to?(:right) && type.right.respond_to?(operation) ? type.right : nil
     end
   end
 end

data/lib/eventsimple/event.rb

@@ -51,10 +51,13 @@ module Eventsimple
 
       default_scope { order(:created_at) }
 
+      after_initialize :readonly!, if: :persisted?
+
       before_validation :extend_validation
-      after_validation :perform_transition_checks
+      after_validation :perform_transition_checks, on: :create
       before_create :apply_and_persist
       after_create :dispatch
+      after_create :readonly!
 
       include InstanceMethods
       extend ClassMethods
@@ -73,7 +76,6 @@ module Eventsimple
         false
       end
 
-      # Apply the event to the aggregate passed in. The default behaviour is a no-op
       def apply(aggregate); end
 
       def can_apply?(_aggregate)
@@ -101,12 +103,10 @@ module Eventsimple
         self.aggregate = aggregate.extend(validate_form) if validate_form
       end
 
-      # Apply the transformation to the aggregate and save it.
       def apply_and_persist
         apply_timestamps(aggregate)
         apply(aggregate)
 
-        # Persist!
         aggregate.enable_writes!
         aggregate.save!
         aggregate.readonly!
@@ -125,6 +125,16 @@ module Eventsimple
       def aggregate=(aggregate)
         public_send(:"#{_aggregate_klass.model_name.element}=", aggregate)
       end
+
+      def enable_writes!(&block)
+        was_readonly = @readonly
+        @readonly = false
+
+        return unless block
+
+        yield self
+        @readonly = was_readonly
+      end
     end
 
     module ClassMethods
@@ -169,8 +179,7 @@ module Eventsimple
 
       # We want to automatically retry writes on concurrency failures. However events with sync
       # reactors may have multiple nested events that are written within the same transaction.
-      # We can only catch and retry writes when they the outermost event encapsulating the whole
-      # transaction.
+      # We can only catch and retry writes when we are in the outermost transaction.
       def create(*args, &block)
         with_locks do
           with_retries(args) { super }
@@ -185,7 +194,7 @@ module Eventsimple
 
       def with_locks(&)
         if _outbox_enabled
-          base_class.with_advisory_lock(base_class.name, { transaction: true }, &)
+          base_class.with_advisory_lock(base_class.name, { transaction: existing_transaction_in_progress? }, &)
         else
           yield
         end

data/lib/eventsimple/message.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'dry-struct'
+
 module Eventsimple
   class Message < Dry::Struct
     transform_keys(&:to_sym)
@@ -19,5 +21,46 @@ module Eventsimple
     def inspect
       as_json
     end
+
+    def self.attribute(name, type = Dry::Types::Any, **options)
+      validate_type(type)
+      super
+    end
+
+    def self.attribute?(name, type = Dry::Types::Any, **options)
+      validate_type(type)
+      super
+    end
+
+    class << self
+      def validate_type(type)
+        return if valid_eventsimple_type?(type)
+
+        source_location = begin
+          source = const_source_location(name)&.first if respond_to?(:const_source_location) && name
+          source || caller_locations.find { |loc| !loc.path.include?('eventsimple') }&.path
+        rescue StandardError
+          'unknown'
+        end
+
+        message = [
+          "Only Eventsimple::Types are allowed in Message attributes. \n",
+          "File: #{source_location} \n",
+          "Received: #{type.inspect} \n",
+          "Use Eventsimple::Types::String, Eventsimple::Types::Integer, etc. \n",
+        ].join(' ')
+
+        deprecator = ActiveSupport::Deprecation.new
+        deprecator.behavior = Rails.application.config.active_support.deprecation
+        deprecator.warn(message)
+      end
+
+      def valid_eventsimple_type?(type)
+        return true if type.respond_to?(:meta) && type.meta[:eventsimple] == true
+        return true if type.is_a?(Class) && type < Eventsimple::Message
+
+        false
+      end
+    end
   end
 end

data/lib/eventsimple/metadata.rb

@@ -5,7 +5,7 @@ module Eventsimple
   class Metadata < Eventsimple::Message
     schema schema.strict
 
-    attribute? :actor_id, DryTypes::Strict::String
-    attribute? :reason, DryTypes::Strict::String
+    attribute? :actor_id, Eventsimple::Types::String.optional
+    attribute? :reason, Eventsimple::Types::String.optional
   end
 end

data/lib/eventsimple/types/encrypted_type.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+# require 'active_support/core_ext/object/blank'
+
+module Eventsimple
+  module Types
+    # Encrypted decorator type that wraps any type and adds encryption methods
+    class EncryptedType
+      include Dry::Types::Type
+      include Dry::Types::Decorator
+      include Dry::Types::Builder
+
+      def initialize(type, **options)
+        super
+        @type = type
+        freeze
+      end
+
+      def meta(data = nil)
+        return { eventsimple: true } if data.nil?
+
+        self.class.new(@type.meta(data))
+      end
+
+      def encrypt(value)
+        return value if value.blank?
+
+        return value if ActiveRecord::Encryption::Encryptor.new.encrypted?(value)
+
+        ActiveRecord::Encryption::Encryptor.new.encrypt(value)
+      end
+
+      def decrypt(value)
+        return value if value.blank?
+
+        ActiveRecord::Encryption::Encryptor.new.decrypt(value)
+      rescue StandardError
+        value
+      end
+    end
+  end
+end

data/lib/eventsimple/types.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'eventsimple/types/encrypted_type'
+
+module Eventsimple
+  module DryTypes
+    include Dry.Types(:strict, :json)
+  end
+
+  module Types
+    EVENTSIMPLE_META = { eventsimple: true }.freeze
+
+    # Extension that preserves eventsimple meta through all type transformations
+    module MetaPreservingBuilder
+      CHAINABLE_METHODS = %i[optional default enum constrained of].freeze
+
+      CHAINABLE_METHODS.each do |method_name|
+        define_method(method_name) do |*args, &block|
+          result = super(*args, &block)
+          # Re-apply eventsimple meta if the original type had it
+          if respond_to?(:meta) && meta[:eventsimple]
+            result.meta(EVENTSIMPLE_META)
+          else
+            result
+          end
+        end
+      end
+
+      def encrypted
+        is_string_type = respond_to?(:primitive) && primitive == ::String
+        raise ArgumentError, "encrypted is only supported for String types" unless is_string_type
+
+        EncryptedType.new(self)
+      end
+    end
+
+    # Include the meta-preserving builder in Dry::Types
+    Dry::Types::Builder.prepend(MetaPreservingBuilder)
+
+    Bool = DryTypes::Strict::Bool.meta(EVENTSIMPLE_META)
+    Array = DryTypes::Strict::Array.meta(EVENTSIMPLE_META)
+    Hash = DryTypes::Strict::Hash.meta(EVENTSIMPLE_META)
+    Integer = DryTypes::Strict::Integer.meta(EVENTSIMPLE_META)
+    String = DryTypes::Strict::String.meta(EVENTSIMPLE_META)
+
+    Decimal = DryTypes::JSON::Decimal.meta(EVENTSIMPLE_META)
+    Date = DryTypes::JSON::Date.meta(EVENTSIMPLE_META)
+    DateTime = DryTypes::JSON::DateTime.meta(EVENTSIMPLE_META)
+    Time = DryTypes::JSON::Time.meta(EVENTSIMPLE_META)
+  end
+end

data/lib/eventsimple/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Eventsimple
-  VERSION = '1.8.1'
+  VERSION = '2.0.1'
 end

data/lib/eventsimple.rb

@@ -7,13 +7,11 @@ require 'active_model'
 require 'active_job'
 require 'active_support'
 require 'dry-types'
-require 'dry-struct'
 require 'retriable'
 
-require 'dry_types'
-
 require 'eventsimple/active_job/arguments'
 require 'eventsimple/configuration'
+require 'eventsimple/types'
 require 'eventsimple/message'
 require 'eventsimple/data_type'
 require 'eventsimple/metadata_type'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: eventsimple
 version: !ruby/object:Gem::Version
-  version: 1.8.1
+  version: 2.0.1
 platform: ruby
 authors:
 - Zulfiqar Ali
@@ -27,30 +27,30 @@ dependencies:
   name: dry-struct
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.6'
+        version: 1.8.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.6'
+        version: 1.8.0
 - !ruby/object:Gem::Dependency
   name: dry-types
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.7'
+        version: 1.7.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.7'
+        version: 1.7.0
 - !ruby/object:Gem::Dependency
   name: pg
   requirement: !ruby/object:Gem::Requirement
@@ -340,7 +340,6 @@ files:
 - catalog-info.yaml
 - config/routes.rb
 - eventsimple.gemspec
-- lib/dry_types.rb
 - lib/eventsimple.rb
 - lib/eventsimple/active_job/arguments.rb
 - lib/eventsimple/configuration.rb
@@ -364,6 +363,8 @@ files:
 - lib/eventsimple/reactor.rb
 - lib/eventsimple/reactor_worker.rb
 - lib/eventsimple/support/spec_helpers.rb
+- lib/eventsimple/types.rb
+- lib/eventsimple/types/encrypted_type.rb
 - lib/eventsimple/version.rb
 - log/development.log
 - sonar-project.properties

data/lib/dry_types.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-module DryTypes
-  include Dry.Types()
-end