eventsimple 1.8.0 → 2.0.0

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,9 +125,24 @@ 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
+      def inherited(subclass)
+        super
+        subclass.attribute :data, Eventsimple::DataType.new(subclass)
+      end
+
       def validate_with(form_klass)
         @validate_with = form_klass
       end
@@ -164,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 }
@@ -180,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,23 +1,193 @@
 # frozen_string_literal: true
 
 module Eventsimple
-  class Message < Dry::Struct
-    transform_keys(&:to_sym)
+  class Message # rubocop:disable Metrics/ClassLength
+    class << self
+      def attribute(name, type)
+        validate_type(type)
+        optional = type.respond_to?(:optional?) ? type.optional? : false
+        define_attribute(name.to_sym, type, optional: optional, required: true)
+      end
+
+      def attribute?(name, type)
+        validate_type(type)
+        optional = type.respond_to?(:optional?) ? type.optional? : false
+        define_attribute(name.to_sym, type, optional: optional, required: false)
+      end
+
+      def schema
+        @schema ||= if superclass.respond_to?(:schema)
+                      Schema.new(superclass.schema)
+                    else
+                      Schema.new
+                    end
+      end
+
+      private
+
+      def validate_type(type)
+        return if valid_eventsimple_type?(type)
+
+        deprecator = ActiveSupport::Deprecation.new
+        deprecator.behavior = Rails.application.config.active_support.deprecation
+
+        deprecator.warn(
+          "Only Eventsimple::Types are allowed in Message attributes. " \
+          "Received: #{type.inspect}. " \
+          "Use Eventsimple::Types::String, Eventsimple::Types::Integer, etc.",
+        )
+      end
+
+      def valid_eventsimple_type?(type)
+        return true if Eventsimple::Types.constants(false).any? { |const_name|
+          next if const_name == :BuilderExtension
+
+          const = Eventsimple::Types.const_get(const_name, false)
+          const == type || const.equal?(type)
+        }
+
+        # For Default types, check the underlying type
+        if type.respond_to?(:default?) && type.default? && type.respond_to?(:type)
+          underlying_type = type.type
+          return valid_eventsimple_type?(underlying_type)
+        end
+
+        # For Sum types (optional), check the right side
+        if type.respond_to?(:right)
+          return valid_eventsimple_type?(type.right)
+        end
+
+        # For EncryptedType, check the wrapped type
+        if type.is_a?(Eventsimple::Types::EncryptedType)
+          return valid_eventsimple_type?(type.instance_variable_get(:@type))
+        end
 
-    # dry types will apply default values only on missing keys
-    # modify the behaviour so the default is used even when the key is present but nil
-    transform_types do |type|
-      if type.default?
-        type.constructor do |value|
-          value.nil? ? Dry::Types::Undefined : value
+        # For Enum types, check the underlying type
+        if type.respond_to?(:type) && type.respond_to?(:values)
+          return valid_eventsimple_type?(type.type)
+        end
+
+        # Check if the type's primitive matches any base type's primitive
+        # This allows Enum, Constrained, and other derived types
+        if type.respond_to?(:primitive)
+          type_primitive = type.primitive
+          return true if Eventsimple::Types.constants(false).any? { |const_name|
+            next if const_name == :BuilderExtension
+
+            base_type = Eventsimple::Types.const_get(const_name, false)
+            base_type.respond_to?(:primitive) && base_type.primitive == type_primitive
+          }
+        end
+
+        false
+      end
+
+      def define_attribute(name, type, optional:, required:)
+        schema.register(name, type, optional: optional, required: required)
+        define_method(name) { @attributes[name] }
+        define_method("#{name}=") do |value|
+          new_value = coerce(name, value, type)
+          @attributes[name] = new_value
         end
-      else
-        type
       end
     end
 
+    class Schema
+      def initialize(parent_schema = nil)
+        @definitions = parent_schema ? parent_schema.definitions.dup : {}
+      end
+
+      def register(name, type, optional:, required:)
+        @definitions[name] = { type: type, optional: optional, required: required }
+      end
+
+      def keys
+        @definitions.map { |name, definition| AttributeKey.new(name, definition[:type]) }
+      end
+
+      def [](name) # rubocop:disable Rails/Delegate
+        @definitions[name]
+      end
+
+      attr_reader :definitions
+
+      class AttributeKey
+        attr_reader :name, :type
+
+        def initialize(name, type)
+          @name = name
+          @type = type
+        end
+      end
+    end
+
+    def initialize(attributes = {})
+      @attributes = {}
+      attributes = attributes.transform_keys(&:to_sym)
+
+      self.class.schema.keys.each do |key| # rubocop:disable Style/HashEachMethods
+        name = key.name
+        definition = self.class.schema[name]
+
+        if !definition[:required] && !attributes.key?(name)
+          next unless default?(definition[:type])
+
+          value = nil
+        else
+          value = attributes[name]
+        end
+
+        @attributes[name] = coerce(name, value, definition[:type])
+      end
+    end
+
+    def attributes
+      @attributes.dup
+    end
+
+    def to_h
+      attributes
+    end
+
+    def as_json(*)
+      attributes.transform_keys(&:to_s)
+    end
+
     def inspect
-      as_json
+      "#<#{self.class.name} #{as_json}>"
+    end
+
+    def ==(other)
+      return false unless other.is_a?(self.class)
+
+      attributes == other.attributes
+    end
+
+    private
+
+    def coerce(name, value, type)
+      return get_default_value(type) if value.nil? && default?(type)
+      return nil if value.nil? && optional?(type)
+      raise ArgumentError, "Missing required attribute: #{name}" if value.nil?
+
+      type.call(value)
+    rescue StandardError => e
+      raise ArgumentError, "Invalid value for #{name}: #{e.message}"
+    end
+
+    def get_default_value(type)
+      return type.default_value if type.respond_to?(:default_value)
+
+      default_val = type.value
+      default_val.respond_to?(:call) ? default_val.call : default_val
+    end
+
+    def default?(type)
+      type.respond_to?(:default?) && type.default?
+    end
+
+    def optional?(type)
+      type.respond_to?(:optional?) && type.optional?
     end
   end
 end

data/lib/eventsimple/metadata.rb

@@ -3,9 +3,7 @@
 # Event metadata store information on the event, for example the user who triggered the event.
 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,36 @@
+# 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 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,32 @@
+# frozen_string_literal: true
+
+require 'eventsimple/types/encrypted_type'
+
+module Eventsimple
+  module DryTypes
+    include Dry.Types(:strict, :json)
+  end
+
+  module Types
+    Bool = DryTypes::Strict::Bool
+    Array = DryTypes::Strict::Array
+    Hash = DryTypes::Strict::Hash
+    Integer = DryTypes::Strict::Integer
+    String = DryTypes::Strict::String
+
+    Decimal = DryTypes::JSON::Decimal
+    Date = DryTypes::JSON::Date
+    DateTime = DryTypes::JSON::DateTime
+    Time = DryTypes::JSON::Time
+
+    module BuilderExtension
+      def encrypted
+        raise ArgumentError, "encrypted is only supported for String types" unless self == String
+
+        EncryptedType.new(self)
+      end
+    end
+
+    Dry::Types::Builder.include(BuilderExtension)
+  end
+end

data/lib/eventsimple/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Eventsimple
-  VERSION = '1.8.0'
+  VERSION = '2.0.0'
 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.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Zulfiqar Ali
@@ -23,34 +23,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 1.2.3
-- !ruby/object:Gem::Dependency
-  name: dry-struct
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.6'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.6'
 - !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 +326,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 +349,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