synapse-core 0.1.2

data/lib/synapse/repository/repository.rb

@@ -0,0 +1,109 @@
+module Synapse
+  module Repository
+    # Represents a mechanism for loading and storing aggregates
+    # @abstract
+    class Repository
+      # @return [EventBus]
+      attr_accessor :event_bus
+
+      # @return [UnitOfWorkProvider]
+      attr_accessor :unit_provider
+
+      # Loads an aggregate with the given aggregate identifier
+      #
+      # If an expected version is specified and the aggregate's actual version doesn't equal the
+      # expected version, the implementation can choose to do one of the following:
+      #
+      # - Raise an exception immediately
+      # - Raise an exception at any other time while the aggregate is registered with the current
+      #   unit of work.
+      #
+      # @abstract
+      # @raise [AggregateNotFoundError]
+      #   If the aggregate with the given identifier could not be found
+      # @raise [ConflictingModificationError]
+      #   If the expected version doesn't match the aggregate's actual version
+      # @param [Object] aggregate_id
+      # @param [Integer] expected_version If this is nil, no version validation is performed
+      # @return [AggregateRoot]
+      def load(aggregate_id, expected_version = nil); end
+
+      # Adds a new, unmanaged aggregate to the repository
+      #
+      # This method will not force the repository to save the aggregate immediately. Instead, it is
+      # registered with the current unit of work. To force storage of an aggregate, commit the
+      # current unit of work.
+      #
+      # @abstract
+      # @raise [ArgumentError] If the version of the aggregate is not null
+      # @param [AggregateRoot] aggregate
+      # @return [undefined]
+      def add(aggregate); end
+
+    protected
+
+      # Returns the type of aggregate that this repository handles
+      #
+      # @abstract
+      # @return [Class]
+      def aggregate_type; end
+
+      # Returns the listener that handles aggregate storage
+      #
+      # @abstract
+      # @return [StorageListener]
+      def storage_listener; end
+
+      # Asserts that an aggregate being added is compatible with this repository and is newly
+      # created
+      #
+      # @raise [ArgumentError] If aggregate is not of the correct type
+      # @raise [ArgumentError] If aggregate has a version number
+      # @param [AggregateRoot] aggregate
+      # @return [undefined]
+      def assert_compatible(aggregate)
+        unless aggregate.is_a? aggregate_type
+          raise ArgumentError, 'Incompatible aggregate type'
+        end
+
+        if aggregate.version
+          raise ArgumentError, 'Only newly created aggregates may be added'
+        end
+      end
+
+      # Asserts that a loaded aggregate has the expected version
+      #
+      # @raise [ConflictingAggregateVersionError]
+      #   If aggregate version is later than the expected version
+      # @param [AggregateRoot] aggregate
+      # @param [Integer] expected_version
+      # @return [undefined]
+      def assert_version_expected(aggregate, expected_version)
+        if expected_version and aggregate.version and aggregate.version > expected_version
+          raise ConflictingAggregateVersionError.new aggregate, expected_version
+        end
+      end
+
+      # Registers the given aggregate with the current unit of work
+      #
+      # @param [AggregateRoot] aggregate
+      # @return [undefined]
+      def register_aggregate(aggregate)
+        current_unit.register_aggregate aggregate, @event_bus, storage_listener
+      end
+
+      # Registers the given unit of work listener with the current unit of work
+      #
+      # @param [UnitOfWorkListener] listener
+      # @return [undefined]
+      def register_listener(listener)
+        current_unit.register_listener listener
+      end
+
+      # @return [UnitOfWork]
+      def current_unit
+        @unit_provider.current
+      end
+    end
+  end
+end

data/lib/synapse/serialization/converter.rb

@@ -0,0 +1,39 @@
+module Synapse
+  module Serialization
+    # Represents a mechanism for converting content of one type to another type for the purposes
+    # of serialization, deserialization and upcasting.
+    module Converter
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :source_type
+        class_attribute :target_type
+      end
+
+      module ClassMethods
+        # @param [Class] source_type
+        # @param [Class] target_type
+        # @return [undefined]
+        def converts(source_type, target_type)
+          self.source_type = source_type
+          self.target_type = target_type
+        end
+      end
+
+      def initialize(options = {})
+        @options = options
+      end
+
+      # @param [SerializedObject] original
+      # @return [SerializedObject]
+      def convert(original)
+        SerializedObject.new(convert_content(original.content), target_type, original.type)
+      end
+
+      # @abstract
+      # @param [Object] original
+      # @return [Object]
+      def convert_content(original); end
+    end
+  end
+end

data/lib/synapse/serialization/converter/chain.rb

@@ -0,0 +1,45 @@
+module Synapse
+  module Serialization
+    # Converter implementation that chains together two or more converters
+    class ConverterChain
+      include Converter
+
+      # @return [Array<Converter>]
+      attr_reader :delegates
+
+      # @return [Class]
+      attr_reader :source_type
+
+      # @return [Class]
+      attr_reader :target_type
+
+      # @param [Array<Converter>] delegates
+      # @return [undefined]
+      def initialize(delegates)
+        @delegates = delegates
+        @source_type = delegates.first.source_type
+        @target_type = delegates.last.target_type
+      end
+
+      # @param [SerializedObject] original
+      # @return [SerializedObject]
+      def convert(original)
+        intermediate = original
+        @delegates.each do |delegate|
+          intermediate = delegate.convert intermediate
+        end
+        intermediate
+      end
+
+      # @param [Object] original
+      # @return [Object]
+      def convert_content(original)
+        intermediate = original
+        @delegates.each do |delegate|
+          intermediate = delegate.convert_content intermediate
+        end
+        intermediate
+      end
+    end
+  end
+end

data/lib/synapse/serialization/converter/factory.rb

@@ -0,0 +1,68 @@
+module Synapse
+  module Serialization
+    # Represents a mechanism for storing and retrieving converters capable of converting content
+    # of one type to another type, for the purpose of serialization and upcasting.
+    class ConverterFactory
+      attr_reader :converters
+
+      def initialize
+        @converters = Array.new
+      end
+
+      # Adds the given converter to this converter factory
+      #
+      # @param [Converter] converter
+      # @return [undefined]
+      def register(converter)
+        @converters.push converter
+      end
+
+      # Convenience method for converting a given serialized object to the given target type
+      #
+      # @param [SerializedObject] serialized_object
+      # @param [Class] target_type
+      # @return [SerializedObject]
+      def convert(serialized_object, target_type)
+        converter = converter serialized_object.content_type, target_type
+        converter.convert serialized_object
+      end
+
+      # Returns a converter that is capable of converting content of the given source type to
+      # the given target type, if one exists.
+      #
+      # @raise [ConversionError] If no converter is capable of performing the conversion
+      # @param [Class] source_type
+      # @param [Class] target_type
+      # @return [Converter]
+      def converter(source_type, target_type)
+        if source_type == target_type
+          return IdentityConverter.new source_type
+        end
+
+        @converters.each do |converter|
+          if converter.source_type == source_type && converter.target_type == target_type
+            return converter
+          end
+        end
+
+        raise ConversionError, 'No converter capable of [%s] -> [%s]' % [source_type, target_type]
+      end
+
+      # Returns true if this factory contains a converter capable of converting content from the
+      # given source type to the given target type.
+      #
+      # @param [Class] source_type
+      # @param [Class] target_type
+      # @return [Boolean]
+      def has_converter?(source_type, target_type)
+        if source_type == target_type
+          return true
+        end
+
+        @converters.any? do |converter|
+          converter.source_type == source_type && converter.target_type == target_type
+        end
+      end
+    end
+  end
+end

data/lib/synapse/serialization/converter/identity.rb

@@ -0,0 +1,29 @@
+module Synapse
+  module Serialization
+    # Implementation of a converter that does no conversion
+    class IdentityConverter
+      include Converter
+
+      attr_reader :source_type
+      attr_reader :target_type
+
+      # @param [Class] type
+      # @return [undefined]
+      def initialize(type)
+        @source_type = @target_type = type
+      end
+
+      # @param [SerializedObject] original
+      # @return [SerializedObject]
+      def convert(original)
+        original
+      end
+
+      # @param [Object] original
+      # @return [Object]
+      def convert_content(original)
+        original
+      end
+    end
+  end
+end

data/lib/synapse/serialization/converter/json.rb

@@ -0,0 +1,31 @@
+require 'json'
+
+module Synapse
+  module Serialization
+    # Converter that converts a JSON string into a Ruby data structure
+    class JsonToObjectConverter
+      include Converter
+
+      converts String, Object
+
+      # @param [Object] original
+      # @return [Object]
+      def convert_content(original)
+        JSON.parse original, @options
+      end
+    end
+
+    # Converter that converts a Ruby data structure into a JSON string
+    class ObjectToJsonConverter
+      include Converter
+
+      converts Object, String
+
+      # @param [Object] original
+      # @return [Object]
+      def convert_content(original)
+        JSON.generate original, @options
+      end
+    end
+  end
+end

data/lib/synapse/serialization/converter/ox.rb

@@ -0,0 +1,31 @@
+require 'ox'
+
+module Synapse
+  module Serialization
+    # Converter that converts an Ox document into an XML string
+    class OxDocumentToXmlConverter
+      include Converter
+
+      converts Ox::Document, String
+
+      # @param [Object] original
+      # @return [Object]
+      def convert_content(original)
+        Ox.dump original, @options
+      end
+    end
+
+    # Converter that converts an XML string into an Ox document
+    class XmlToOxDocumentConverter
+      include Converter
+
+      converts String, Ox::Document
+
+      # @param [Object] original
+      # @return [Object]
+      def convert_content(original)
+        Ox.load original, @options
+      end
+    end
+  end
+end

data/lib/synapse/serialization/errors.rb

@@ -0,0 +1,12 @@
+module Synapse
+  module Serialization
+    # Raised when conversion between two types is not supported
+    class ConversionError < NonTransientError; end
+
+    # Raised when an error occurs during serialization
+    class SerializationError < NonTransientError; end
+
+    # Raised when a serialized type can't be found in the current environment
+    class UnknownSerializedTypeError < SerializationError; end
+  end
+end

data/lib/synapse/serialization/lazy_object.rb

@@ -0,0 +1,61 @@
+module Synapse
+  module Serialization
+    # Provides a generic lazy deserializing object
+    class LazyObject
+      # @return [SerializedObject]
+      attr_reader :serialized_object
+
+      # @return [Serializer]
+      attr_reader :serializer
+
+      # @return [Class]
+      attr_reader :type
+
+      # @param [SerializedObject] serialized_object
+      # @param [Serializer] serializer
+      # @return [undefined]
+      def initialize(serialized_object, serializer)
+        @serialized_object = serialized_object
+        @serializer = serializer
+        @type = serializer.class_for serialized_object.type
+      end
+
+      # Returns the deserialized version of the contained serialized object
+      # @return [Object]
+      def deserialized
+        @deserialized ||= @serializer.deserialize @serialized_object
+      end
+
+      # Returns true if this object has been deserialized already
+      # @return [Boolean]
+      def deserialized?
+        !!@deserialized
+      end
+    end
+
+    # Deserialized object that has (nearly) the same interface as a lazy object
+    class DeserializedObject
+      # @return [Object]
+      attr_reader :deserialized
+
+      # @return [Serializer] This will always be nil
+      attr_reader :serializer
+
+      # @return [Class]
+      attr_reader :type
+
+      # @param [Object] deserialized
+      # @return [undefined]
+      def initialize(deserialized)
+        @deserialized = deserialized
+        @type = deserialized.class
+      end
+
+      # Returns true if this object has been deserialized already; always true
+      # @return [Boolean]
+      def deserialized?
+        true
+      end
+    end
+  end
+end

data/lib/synapse/serialization/message/data.rb

@@ -0,0 +1,25 @@
+module Synapse
+  module Serialization
+    # Describes the properties that a serialized domain event should have
+    # @abstract
+    class SerializedDomainEventData
+      # @return [String] Identifier of the serialized event
+      def id; end
+
+      # @return [SerializedObject] Serialized metadata of the serialized event
+      def metadata; end
+
+      # @return [SerializedObject] Serialized payload of the serialized event
+      def payload; end
+
+      # @return [Time] Timestamp of the serialized event
+      def timestamp; end
+
+      # @return [Object] Identifier of the aggregate that the event was applied to
+      def aggregate_id; end
+
+      # @return [Integer] Sequence number of the event in the aggregate
+      def sequence_number; end
+    end
+  end
+end