rails-event-sourcing 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6515057a49928dc1c71c0b4767bea5c0a825f2be5f411a8a35457e53d17a9380
+  data.tar.gz: bfe0bc40897dca758f5be3b40118ea2381c400da92f0b4b77597a75351a8f5b7
+SHA512:
+  metadata.gz: 5b025b485eb1d0e456c1818b9d0698a5ab8336a13f21d391230e0ad09315bceaa685b418a046ded7134771e2f4217650236ae6f2df16f276061db54e61bce5e3
+  data.tar.gz: bba96d5db5376ed99fb9695faa2318645633feb6bb12439597932490b3cbb521724a7579d184fa2bcf141d661177c0f261b9f2f8dd95fbf4ade60c7e532cd879

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require rails_helper

data/.rubocop.yml

@@ -0,0 +1,28 @@
+---
+inherit_from:
+  - https://relaxed.ruby.style/rubocop.yml
+
+require:
+  - rubocop-rspec
+
+AllCops:
+  Exclude:
+    - _misc/*
+    - bin/*
+    - spec/dummy/**/*
+  NewCops: enable
+  SuggestExtensions: false
+  TargetRubyVersion: 2.6
+
+Naming/FileName:
+  Exclude:
+    - lib/rails-event-sourcing.rb
+
+RSpec/ExampleLength:
+  Max: 8
+
+RSpec/MultipleMemoizedHelpers:
+  Max: 8
+
+Style/GuardClause:
+  Enabled: false

data/Gemfile

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in rails-event-sourcing.gemspec
+gemspec
+
+gem 'rspec-rails'
+gem 'simplecov'
+gem 'sqlite3'
+
+# Linters
+gem 'rubocop', '~> 1.21'
+gem 'rubocop-rspec'
+
+# Tools
+gem 'awesome_print'
+gem 'pry-rails'

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2021 Mattia Roccoberton
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,126 @@
+# Rails Event Sourcing
+
+This gem provides features to setup an event sourcing application using ActiveRecord.
+ActiveJob is necessary only to use async callbacks.
+
+> DISCLAIMER: this project is in alpha stage
+
+The main components are:
+- **event**: model used to track state changes for an entity;
+- **command**: wrap events creation;
+- **dispatcher**: events' callbacks (sync and async).
+
+This gem adds a layer to handle events for the underlying application models. In short:
+- an event model is created for each "event-ed" application model;
+- every change to an application model (named _aggregate_ in the event perspective) is stored in an event record;
+- querying application models is the same as usual;
+- writing changes to application entities is applied creating events.
+
+A sample workflow can be:
+
+```rb
+# I have a plain Post model:
+post = Post.find(1)
+# When I need to update that post:
+Posts::ChangedDescription.create!(post: post, description: 'My beautiful post content')
+# When I need to create a new post:
+Posts::Created.create!(title: 'New post!', description: 'Another beautiful post')
+# I can query the events for an aggregated entity:
+events = Posts::Event.events_for(post) # Posts::Event is usually a base class for all events for an aggregate (using STI)
+# I can rollback to a specific version of the aggregated entity:
+events[2].rollback! # the aggregated entity is restored to the specific state, the events above that point are removed
+```
+
+The project is based on a [demo app](https://github.com/pcreux/event-sourcing-rails-todo-app-demo) proposed by [Philippe Creux](https://github.com/pcreux) and his video presentation for Rails Conf 2019:
+
+[![Event Sourcing made Simple by Philippe Creux](https://img.youtube.com/vi/ulF6lEFvrKo/0.jpg)](https://www.youtube.com/watch?v=ulF6lEFvrKo "Event Sourcing made Simple by Philippe Creux")
+
+Please :star: if you like it.
+
+## Usage
+
+- Add to your Gemfile: `gem 'rails-event-sourcing'` (and execute `bundle`)
+- Create a migration per model to store the related events, example for User:
+`bin/rails generate migration CreateUserEvents type:string user:reference data:text metadata:text`
+- Create the events, example for `Users::Created`:
+```rb
+module Users
+  class Created < RailsEventSourcing::BaseEvent
+    self.table_name = 'user_events' # usually this fits better in a base class using STI
+
+    belongs_to :user, autosave: false
+
+    data_attributes :name
+
+    def apply(user)
+      # this method will be applied when the event is created
+      user.name = name
+      user
+    end
+  end
+end
+```
+- Invoke an event with: `Users::Created.create!(name: 'Some user')`
+- Optionally create a Command, example:
+```rb
+module Users
+  class CreateCommand
+    include RailsEventSourcing::Command
+
+    attributes :user, :name
+
+    def build_event
+      # this method will be applied when the command is executed
+      Users::Created.new(user_id: user.id, name: name)
+    end
+  end
+end
+```
+- Invoke a command with: `Users::CreateCommand.call(name: 'Some name')`
+
+## Examples
+
+Please take a look at the [dummy app](spec/dummy/app) for a detailed example.
+
+Events:
+```rb
+TodoLists::Created.create!(name: 'My TODO 1')
+TodoLists::NameUpdated.create!(name: 'My TODO!', todo_list: TodoList.first)
+TodoItems::Created.create!(todo_list_id: TodoList.first.id, name: 'First item')
+TodoItems::Completed.create!(todo_item: TodoItem.last)
+```
+
+Commands:
+```rb
+TodoLists::Create.call(name: 'My todo')
+TodoItems::Create.call(todo_list: TodoList.first, name: 'Some task')
+```
+
+Dispatchers:
+```rb
+class TodoItemsDispatcher < RailsEventSourcing::EventDispatcher
+  on TodoItems::Created, trigger: ->(todo_item) { puts ">>> TodoItems::Created [##{todo_item.id}]" }
+  on TodoItems::Completed, async: Notifications::TodoItems::Completed
+end
+# Now when the event TodoItems::Created is created the trigger callback is executed
+```
+
+## To do
+
+- [ ] Generators for events, commands and dispatchers
+- [ ] Database specific optimizations
+- [ ] Add more usage examples
+
+## Do you like it? Star it!
+
+If you use this component just star it. A developer is more motivated to improve a project when there is some interest.
+
+Or consider offering me a coffee, it's a small thing but it is greatly appreciated: [about me](https://www.blocknot.es/about-me).
+
+## Contributors
+
+- [Mattia Roccoberton](https://www.blocknot.es): author
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "rails-event-sourcing"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/pry

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# This file was generated by Bundler.
+#
+# The application 'pry' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "pathname"
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+bundle_binstub = File.expand_path("../bundle", __FILE__)
+
+if File.file?(bundle_binstub)
+  if File.read(bundle_binstub, 300) =~ /This file was generated by Bundler/
+    load(bundle_binstub)
+  else
+    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
+Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
+  end
+end
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("pry", "pry")

data/bin/rails

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# This command will automatically be run when you run "rails" with Rails gems
+# installed from the root of your application.
+
+ENV['RAILS_ENV'] ||= 'test'
+
+ENGINE_ROOT = File.expand_path('..', __dir__)
+APP_PATH = File.expand_path('../spec/dummy/config/application', __dir__)
+
+# Set up gems listed in the Gemfile.
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../Gemfile', __dir__)
+require "bundler/setup" if File.exist?(ENV["BUNDLE_GEMFILE"])
+
+require "rails/all"
+require "rails/engine/commands"

data/bin/rspec

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# This file was generated by Bundler.
+#
+# The application 'rspec' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "pathname"
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+bundle_binstub = File.expand_path("../bundle", __FILE__)
+
+if File.file?(bundle_binstub)
+  if File.read(bundle_binstub, 300) =~ /This file was generated by Bundler/
+    load(bundle_binstub)
+  else
+    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
+Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
+  end
+end
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("rspec-core", "rspec")

data/bin/rubocop

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# This file was generated by Bundler.
+#
+# The application 'rubocop' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "pathname"
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+bundle_binstub = File.expand_path("../bundle", __FILE__)
+
+if File.file?(bundle_binstub)
+  if File.read(bundle_binstub, 300) =~ /This file was generated by Bundler/
+    load(bundle_binstub)
+  else
+    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
+Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
+  end
+end
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("rubocop", "rubocop")

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/rails-event-sourcing/base_event.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module RailsEventSourcing
+  # This is the BaseEvent class that all Events inherit from.
+  # It takes care of serializing `data` and `metadata` via json
+  # It defines setters and accessors for the defined `data_attributes`
+  # After create, it calls `apply` to apply changes.
+  class BaseEvent < ::ActiveRecord::Base
+    self.abstract_class = true
+
+    serialize :data, JSON
+    serialize :metadata, JSON
+
+    before_validation :preset_aggregate
+    before_create :apply_and_persist
+    after_create :dispatch
+
+    after_initialize do
+      self.data ||= {}
+      self.metadata ||= {}
+    end
+
+    scope :recent_first, -> { reorder('id DESC') }
+
+    def aggregate
+      public_send aggregate_name
+    end
+
+    def aggregate=(model)
+      public_send "#{aggregate_name}=", model
+    end
+
+    def aggregate_id=(id)
+      public_send "#{aggregate_name}_id=", id
+    end
+
+    # Apply the event to the aggregate passed in.
+    # Must return the aggregate.
+    def apply(aggregate)
+      raise NotImplementedError
+    end
+
+    def aggregate_id
+      public_send "#{aggregate_name}_id"
+    end
+
+    def build_aggregate
+      public_send "build_#{aggregate_name}"
+    end
+
+    # Rollback an aggregate entity to a specific version
+    #
+    # Update the aggregate with the changes up to the current event and
+    # destroys the events after
+    def rollback!
+      base_class = self.class.superclass == RailsEventSourcing::BaseEvent ? self.class : self.class.superclass
+      new_attributes = aggregate.class.new.attributes
+      preserve_columns = new_attributes.keys - base_class.reserved_column_names
+      new_attributes.slice!(*preserve_columns)
+      aggregate.assign_attributes(new_attributes)
+      aggregate.transaction do
+        base_class.events_for(aggregate).where('id > ?', id).destroy_all
+        base_class.events_for(aggregate).reorder('id ASC').each do |event|
+          event.apply(aggregate)
+        end
+        aggregate.save!
+      end
+    end
+
+    delegate :aggregate_name, to: :class
+
+    class << self
+      def aggregate_name
+        inferred_aggregate = reflect_on_all_associations(:belongs_to).first
+        raise "Events must belong to an aggregate" if inferred_aggregate.nil?
+
+        inferred_aggregate.name
+      end
+
+      # Define attributes to be serialize in the `data` column.
+      # It generates setters and getters for those.
+      #
+      # Example:
+      #
+      # class MyEvent < RailsEventSourcing::BaseEvent
+      #   data_attributes :title, :description, :drop_id
+      # end
+      def data_attributes(*attrs)
+        @data_attributes ||= []
+
+        attrs.map(&:to_s).each do |attr|
+          @data_attributes << attr unless @data_attributes.include?(attr)
+
+          define_method attr do
+            self.data ||= {}
+            self.data[attr]
+          end
+
+          define_method "#{attr}=" do |arg|
+            self.data ||= {}
+            self.data[attr] = arg
+          end
+        end
+
+        @data_attributes
+      end
+
+      # Underscored class name by default. ex: "post/updated"
+      # Used when sending events to the data pipeline
+      def event_name
+        name.underscore
+      end
+
+      def events_for(aggregate)
+        where(aggregate_name => aggregate)
+      end
+
+      def reserved_column_names
+        %w[id created_at updated_at]
+      end
+    end
+
+    private
+
+    # Build aggregate when the event is creating an aggregate
+    def preset_aggregate
+      self.aggregate ||= build_aggregate
+    end
+
+    # Apply the transformation to the aggregate and save it
+    def apply_and_persist
+      aggregate.lock! if aggregate.persisted?
+      self.aggregate = apply(aggregate)
+      aggregate.save!
+      self.aggregate_id = aggregate.id if aggregate_id.nil?
+    end
+
+    def dispatch
+      Dispatcher.dispatch(self)
+    end
+  end
+end

data/lib/rails-event-sourcing/command.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module RailsEventSourcing
+  # The Base command mixin that commands include.
+  #
+  # A Command has the following public api.
+  #
+  # ```
+  #   MyCommand.call(user: ..., post: ...) # shorthand to initialize, validate and execute the command
+  #   command = MyCommand.new(user: ..., post: ...)
+  #   command.valid? # true or false
+  #   command.errors # +> <ActiveModel::Errors ... >
+  #   command.call # validate and execute the command
+  # ```
+  #
+  # `call` will raise an `ActiveRecord::RecordInvalid` error if it fails validations.
+  #
+  # Commands including the `RailsEventSourcing::Command` mixin must:
+  # * list the attributes the command takes
+  # * implement `build_event` which returns a non-persisted event or nil for noop.
+  #
+  # Ex:
+  #
+  # ```
+  #   class MyCommand
+  #     include RailsEventSourcing::Command
+  #
+  #     attributes :user, :post
+  #
+  #     def build_event
+  #       Event.new(...)
+  #     end
+  #   end
+  # ```
+  module Command
+    extend ActiveSupport::Concern
+
+    included do
+      include ActiveModel::Validations
+    end
+
+    class_methods do
+      # Run validations and persist the event.
+      #
+      # On success: returns the event
+      # On noop: returns nil
+      # On failure: raise an ActiveRecord::RecordInvalid error
+      def call(*args)
+        new(*args).call
+      end
+
+      # Define the attributes.
+      # They are set when initializing the command as keyword arguments and
+      # are all accessible as getter methods.
+      #
+      # ex: `attributes :post, :user, :ability`
+      def attributes(*args)
+        attr_reader(*args)
+
+        initialize_method_arguments = args.map { |arg| "#{arg}:" }.join(', ')
+        initialize_method_body = args.map { |arg| "@#{arg} = #{arg}" }.join(";")
+        initialize_definition = <<~CODE
+          def initialize(#{initialize_method_arguments})
+            #{initialize_method_body}
+            after_initialize
+          end
+        CODE
+
+        class_eval(initialize_definition)
+      end
+    end
+
+    def call
+      return nil if event.nil?
+      raise "The event should not be persisted at this stage!" if event.persisted?
+
+      validate!
+      execute!
+
+      event
+    end
+
+    # A new record or nil if noop
+    def event
+      @event ||= (noop? ? nil : build_event)
+    end
+
+    def noop?
+      false
+    end
+
+    private
+
+    # Save the event. Should not be overwritten by the command as side effects
+    # should be implemented via Reactors triggering other Events.
+    def execute!
+      event.save!
+    end
+
+    # Returns a new event record or nil if noop
+    def build_event
+      raise NotImplementedError
+    end
+
+    # Hook to set default values
+    def after_initialize
+      # noop
+    end
+  end
+end

data/lib/rails-event-sourcing/dispatcher.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module RailsEventSourcing
+  # Dispatcher implementation used by Events on after save.
+  class Dispatcher
+    class << self
+      # Register Reactors to Events.
+      # * Reactors registered with `trigger` will be triggered synchronously
+      # * Reactors registered with `async` will be triggered asynchronously via a ActiveJob
+      #
+      # Example:
+      #
+      #   on SomeEvent, trigger: ->(item) { puts "Callable block on #{item.id}" }
+      #   on BaseEvent, trigger: LogEvent, async: TrackEvent
+      #   on PledgeCancelled, PaymentFailed, async: [NotifyAdmin, CreateTask]
+      #   on [PledgeCancelled, PaymentFailed], async: [NotifyAdmin, CreateTask]
+      #
+      def on(*events, trigger: [], async: [])
+        rules.register(events: events.flatten, sync: Array(trigger), async: Array(async))
+      end
+
+      # Dispatches events to matching Reactors once.
+      # Called by all events after they are created.
+      def dispatch(event)
+        reactors = rules.for(event)
+        reactors.sync.each { |reactor| reactor.call(event) }
+        reactors.async.each { |reactor| RailsEventSourcing::ReactorJob.perform_later(event, reactor.to_s) }
+      end
+
+      def rules
+        @@rules ||= RuleSet.new # rubocop:disable Style/ClassVars
+      end
+    end
+
+    class RuleSet
+      def initialize
+        @rules = Hash.new { |h, k| h[k] = ReactorSet.new }
+      end
+
+      def register(events:, sync:, async:)
+        events.each do |event|
+          @rules[event].add_sync(sync)
+          @rules[event].add_async(async)
+        end
+      end
+
+      # Return a ReactorSet containing all Reactors matching an Event
+      def for(event)
+        reactors = ReactorSet.new
+
+        @rules.each do |event_class, rule|
+          # Match event by class including ancestors. e.g. All events match a role for BaseEvent.
+          if event.is_a?(event_class)
+            reactors.add_sync(rule.sync)
+            reactors.add_async(rule.async)
+          end
+        end
+
+        reactors
+      end
+    end
+
+    # Contains sync and async reactors. Used to:
+    # * store reactors via Rules#register
+    # * return a set of matching reactors with Rules#for
+    class ReactorSet
+      attr_reader :sync, :async
+
+      def initialize
+        @sync = Set.new
+        @async = Set.new
+      end
+
+      def add_sync(reactors)
+        @sync += reactors
+      end
+
+      def add_async(reactors)
+        @async += reactors
+      end
+    end
+  end
+end

data/lib/rails-event-sourcing/reactor_job.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+if defined? ActiveJob
+  module RailsEventSourcing
+    class ReactorJob < ActiveJob::Base
+      def perform(event, reactor_class)
+        reactor = reactor_class.constantize
+        if reactor.ancestors.include? RailsEventSourcing::BaseEvent
+          reactor.create!(aggregate: event.aggregate)
+        end
+      end
+    end
+  end
+end

data/lib/rails-event-sourcing/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module RailsEventSourcing
+  VERSION = "0.1.0"
+end

data/lib/rails-event-sourcing.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative 'rails-event-sourcing/version'
+
+require_relative 'rails-event-sourcing/base_event'
+require_relative 'rails-event-sourcing/command'
+require_relative 'rails-event-sourcing/dispatcher'
+require_relative 'rails-event-sourcing/reactor_job'
+
+module RailsEventSourcing
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: rails-event-sourcing
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Mattia Roccoberton
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2021-11-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+description: Setup event sourcing in a Rails application easily
+email:
+- mat@blocknot.es
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- bin/console
+- bin/pry
+- bin/rails
+- bin/rspec
+- bin/rubocop
+- bin/setup
+- lib/rails-event-sourcing.rb
+- lib/rails-event-sourcing/base_event.rb
+- lib/rails-event-sourcing/command.rb
+- lib/rails-event-sourcing/dispatcher.rb
+- lib/rails-event-sourcing/reactor_job.rb
+- lib/rails-event-sourcing/version.rb
+homepage: https://github.com/blocknotes/rails-event-sourcing
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/blocknotes/rails-event-sourcing
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3.1
+signing_key: 
+specification_version: 4
+summary: Rails Event Sourcing library
+test_files: []