event_engine-store 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: '0888fb8cb32a3a92676f641ce96b85d56753a890bdecf9027c9521d3b642ec9c'
+  data.tar.gz: b488a04eba91857bcc65ae37bdb4cf0608d94a8f8c4bc6d3e42798810fd7a264
+SHA512:
+  metadata.gz: fa6fd5beff74cfcea49f0917bbda4f82448592a2c1893d093d5074c97dc41f4cd506c4536398e4b6fe0061e5397414f44e48ca9cf6c586d14fb95e26a5624bb7
+  data.tar.gz: 964a48580c13ddb2f1be6d0803e8d0ce26b229fe62d6521c0fdd17f82e228ea3485898a2b9b48e2b23cb505e3009e91feac87873f05530e7e2a7e8e249378c3e

data/CHANGELOG.md

@@ -0,0 +1,32 @@
+# Changelog
+
+All notable changes to this project are documented here, following
+[Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and
+[Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.1.0] - 2026-07-29
+
+First published release of `event_engine-store`, the durable event record for the
+EventEngine pipeline.
+
+### Added
+
+- `StoredEvent` — an immutable, append-only table the host owns, with a migration
+  installed via the engine.
+- `Recorder` — a handler registered for every process type, so every dispatched event
+  is written to the record regardless of how it is otherwise processed.
+- `ProjectionDispatcher` — a handler that feeds recorded events to projections.
+- `Replay` — reconstructs `EventEngine::Event` objects from the stored record for
+  event sourcing.
+
+### Notes
+
+- Requires `event_engine >= 0.2.1`. `0.2.0` and earlier raise `UnroutableEventError`
+  on emit once a catalog has been built, which breaks apps like this one that process
+  events through handlers rather than a per-event processor.
+- These are **handlers**, not processors. `event_engine` routes each event to at most
+  one processor, named in the host's rules file; a recorder needs to observe every
+  event, which is what a handler does. An app using only this gem leaves its rules
+  file undecided and nothing routes — the handlers still fire.

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright tylercschneider
+
+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,416 @@
+# EventEngine::Store
+
+The permanent, queryable **event record** for
+[EventEngine](https://github.com/DYB-Development/event_engine).
+
+Where [`event_engine-delivery`](https://github.com/DYB-Development/event_engine-delivery)'s
+outbox is a *transient delivery buffer* (rows are deleted once published and the
+retention window passes), `event_engine-store` is the **durable source of truth**: an
+immutable, append-only event log the host application owns. It registers a handler
+with EventEngine that records **every dispatched event**, and provides
+**event-sourcing replay** — rebuilding state by reading the log back in append order.
+
+It deliberately does **not** aggregate or compute metrics — turning the log into
+rollups is a separate concern.
+
+| Gem | Keeps events…? |
+|---|---|
+| `event_engine-delivery` (outbox) | only until delivered + retention expires — a buffer |
+| `event_engine-store` (this gem) | **forever, append-only** — the record |
+
+The two are complementary; you can run both at once.
+
+---
+
+## Table of contents
+
+- [Installation](#installation)
+- [How it hooks into the core](#how-it-hooks-into-the-core)
+- [The `StoredEvent` table](#the-storedevent-table)
+- [Querying the log](#querying-the-log)
+- [Customizing the store](#customizing-the-store) ← **start here for extensions**
+  - [Expanding the table with your own columns](#expanding-the-table-with-your-own-columns)
+  - [Adding query scopes to the model](#adding-query-scopes-to-the-model)
+  - [Recording only some events](#recording-only-some-events)
+  - [Replacing the recorder entirely](#replacing-the-recorder-entirely)
+  - [Disabling the default recorder](#disabling-the-default-recorder)
+  - [Making recording resilient / async](#making-recording-resilient--async)
+- [Replay](#replay)
+- [Projections](#projections)
+- [License](#license)
+
+---
+
+## Installation
+
+```ruby
+# Gemfile
+gem "event_engine"
+gem "event_engine-store"
+```
+
+```bash
+bundle install
+```
+
+Copy the migration into your app and run it:
+
+```bash
+bin/rails railties:install:migrations   # copies the StoredEvent migration
+bin/rails db:migrate
+```
+
+There is **no install generator, initializer, or configuration** — the store wires
+itself up at boot. Once migrated, every dispatched event is recorded automatically.
+
+---
+
+## How it hooks into the core
+
+At Rails boot the engine registers **two** handlers with the core, for all levels:
+
+```ruby
+# lib/event_engine/store/engine.rb
+initializer "event_engine.store.register_recorder" do
+  config.after_initialize do
+    EventEngine.register_handler(Recorder.new, levels: :all)
+    EventEngine.register_handler(ProjectionDispatcher.new, levels: :all)
+  end
+end
+```
+
+So on every `EventEngine.<event>` call:
+
+1. `Recorder#call(event)` inserts a `StoredEvent` row.
+2. `ProjectionDispatcher#call(event)` calls `apply(event)` on each registered
+   projection.
+
+> Because both register at `levels: :all`, the store records **every** level —
+> including non-durable levels 1 and 2. That's by design: the store is your record of
+> what happened, independent of how it was delivered. If you only want to record some
+> events, see [Recording only some events](#recording-only-some-events).
+
+---
+
+## The `StoredEvent` table
+
+`EventEngine::Store::StoredEvent` (table `event_engine_store_stored_events`) is
+**append-only**: once a row is persisted it is read-only (`readonly?` returns true on
+persisted records), so an attempt to update raises `ActiveRecord::ReadOnlyRecord`.
+
+| Column | Type | Indexed | Notes |
+|---|---|---|---|
+| `event_name` | string | ✓ | NOT NULL |
+| `event_type` | string | | classification |
+| `event_version` | integer | | schema version |
+| `event_level` | integer | | dispatched level |
+| `payload` | json | | event data |
+| `metadata` | json | | context (actor, request id, …) |
+| `occurred_at` | datetime | ✓ | logical event time |
+| `idempotency_key` | string | ✓ | **not unique** — duplicates allowed |
+| `aggregate_type` | string | | aggregate tracking |
+| `aggregate_id` | string | | |
+| `aggregate_version` | integer | | |
+| `created_at` | datetime | | DB insert time (NOT NULL) |
+
+The full event envelope is captured. The default migration:
+
+```ruby
+create_table :event_engine_store_stored_events do |t|
+  t.string   :event_name, null: false
+  t.string   :event_type
+  t.integer  :event_version
+  t.integer  :event_level
+  t.json     :payload
+  t.json     :metadata
+  t.datetime :occurred_at
+  t.string   :idempotency_key
+  t.string   :aggregate_type
+  t.string   :aggregate_id
+  t.integer  :aggregate_version
+  t.datetime :created_at, null: false
+end
+
+add_index :event_engine_store_stored_events, :event_name
+add_index :event_engine_store_stored_events, :occurred_at
+add_index :event_engine_store_stored_events, :idempotency_key
+```
+
+---
+
+## Querying the log
+
+The model ships with **no scopes** — query it with plain ActiveRecord:
+
+```ruby
+SE = EventEngine::Store::StoredEvent
+
+SE.where(event_name: "order_placed")
+SE.where("occurred_at > ?", 7.days.ago)
+SE.where(aggregate_type: "Order", aggregate_id: order.id).order(:id)  # one aggregate's history
+SE.order(:id).find_each { |e| … }                                     # full log, batched
+SE.pluck(:event_name).tally                                           # quick histogram
+```
+
+For richer queries, add your own scopes — see below.
+
+---
+
+## Customizing the store
+
+This is the part most teams need. The store is deliberately minimal, so the
+customization seams are explicit. The most common ask — **"I want more columns on the
+event table"** — has an important catch, covered first.
+
+### Expanding the table with your own columns
+
+You'll often want first-class columns instead of digging into the `payload`/`metadata`
+JSON on every query.
+
+**Why expand the table:**
+
+- **Indexable, fast filtering/joins** — e.g. `actor_id`, `tenant_id`, `correlation_id`
+  as real columns you can index and join on, instead of `metadata->>'actor_id'`.
+- **Reporting & BI tools** that don't grok JSON columns well.
+- **Foreign keys / constraints** to enforce integrity against other tables.
+- **Partitioning / retention** by a real column (e.g. `tenant_id`, `created_at`).
+
+Adding a column is **two** steps: a migration adds the column, and you extend the
+`Recorder` to populate it (the recorder writes a fixed set of attributes, so a new
+column stays `NULL` until the recorder fills it).
+
+**Step 1 — migration** (use a timestamp *after* the gem's `20260605000001`):
+
+```ruby
+# db/migrate/20260701000000_extend_stored_events.rb
+class ExtendStoredEvents < ActiveRecord::Migration[8.0]
+  def change
+    add_column :event_engine_store_stored_events, :actor_id,       :integer
+    add_column :event_engine_store_stored_events, :tenant_id,      :integer
+    add_column :event_engine_store_stored_events, :correlation_id, :string
+
+    add_index :event_engine_store_stored_events, :actor_id
+    add_index :event_engine_store_stored_events, [:tenant_id, :created_at]
+  end
+end
+```
+
+**Step 2 — capture the values.** Wrap the recorder so it pulls your new fields out of
+each event (typically from `metadata`) in addition to the defaults:
+
+```ruby
+# config/initializers/event_engine_store.rb
+require "event_engine/store/recorder"
+
+module EventEngine
+  module Store
+    class Recorder
+      # Re-open #call to add columns. Keep the default capture and extend it.
+      def call(event)
+        meta = event.metadata || {}
+        StoredEvent.create!(
+          event_name:        event.event_name,
+          event_type:        event.event_type,
+          event_version:     event.event_version,
+          event_level:       event.event_level,
+          payload:           event.payload,
+          metadata:          event.metadata,
+          occurred_at:       event.occurred_at,
+          idempotency_key:   event.idempotency_key,
+          aggregate_type:    event.aggregate_type,
+          aggregate_id:      event.aggregate_id,
+          aggregate_version: event.aggregate_version,
+
+          # your added columns:
+          actor_id:          meta[:actor_id]      || meta["actor_id"],
+          tenant_id:         meta[:tenant_id]     || meta["tenant_id"],
+          correlation_id:    meta[:correlation_id] || meta["correlation_id"]
+        )
+      end
+    end
+  end
+end
+```
+
+Now emit with the context in `metadata` and it lands in real columns:
+
+```ruby
+EventEngine.order_placed(order: order, metadata: { actor_id: current_user.id, tenant_id: tenant.id })
+```
+
+> **Tip — an upgrade-resilient alternative.** Re-opening `Recorder#call` replaces it,
+> so it won't pick up changes to the default capture in a future gem version. If you'd
+> rather not re-list the defaults, `prepend` a module that lets the gem do its insert
+> and then patches your columns on the returned record:
+>
+> ```ruby
+> module CaptureContext
+>   def call(event)
+>     record = super
+>     meta = event.metadata || {}
+>     record.update_columns(            # update_columns bypasses the readonly guard
+>       actor_id:  meta[:actor_id]  || meta["actor_id"],
+>       tenant_id: meta[:tenant_id] || meta["tenant_id"]
+>     )
+>     record
+>   end
+> end
+> EventEngine::Store::Recorder.prepend(CaptureContext)
+> ```
+>
+> This is resilient to default-capture changes, at the cost of a second write.
+
+### Adding query scopes to the model
+
+Re-open the model to add scopes/helpers (you can't add columns this way — that needs a
+migration):
+
+```ruby
+# config/initializers/event_engine_store.rb (or app/models/…)
+EventEngine::Store::StoredEvent.class_eval do
+  scope :named,         ->(name) { where(event_name: name) }
+  scope :for_aggregate, ->(type, id) { where(aggregate_type: type, aggregate_id: id).order(:id) }
+  scope :since,         ->(time) { where("occurred_at >= ?", time) }
+end
+
+EventEngine::Store::StoredEvent.named("order_placed").since(1.day.ago)
+```
+
+### Recording only some events
+
+The default records everything. To record a subset, prepend a filter that skips the
+rest:
+
+```ruby
+module RecordDomainOnly
+  RECORDED = %w[order_placed payment_captured].freeze
+  def call(event)
+    return unless RECORDED.include?(event.event_name.to_s)
+    super
+  end
+end
+EventEngine::Store::Recorder.prepend(RecordDomainOnly)
+```
+
+**Why:** keep the log focused on domain/audit-worthy events and avoid recording noisy
+level-1 system pings.
+
+### Replacing the recorder entirely
+
+For a fundamentally different write path (a different table, sharding, an external
+audit service), register your own handler and turn off the default one:
+
+```ruby
+class MyAuditRecorder
+  def call(event)
+    AuditLog.create!(kind: event.event_name, data: event.payload, at: event.occurred_at)
+  end
+end
+
+Rails.application.config.after_initialize do
+  EventEngine.register_handler(MyAuditRecorder.new, levels: :all)
+end
+```
+
+(See [Disabling the default recorder](#disabling-the-default-recorder) to stop the
+built-in one from also writing.)
+
+### Disabling the default recorder
+
+There's no config flag to skip it, so neutralize it in an initializer. Cleanest is to
+make `Recorder#call` a no-op:
+
+```ruby
+module DisableDefaultRecorder
+  def call(_event); end
+end
+EventEngine::Store::Recorder.prepend(DisableDefaultRecorder)
+```
+
+> Avoid `EventEngine.reset_handlers!` for this — it clears **all** handlers, including
+> `event_engine-delivery`'s and the projection dispatcher. Only reach for it if you're
+> fully taking over routing.
+
+### Making recording resilient / async
+
+The default `Recorder` calls `StoredEvent.create!` **synchronously** inside dispatch.
+A DB hiccup will therefore raise straight back into your emitting code. If recording
+must never break emission, wrap it to rescue (and optionally enqueue a retry):
+
+```ruby
+module ResilientRecord
+  def call(event)
+    super
+  rescue => e
+    Rails.logger.error("[store] failed to record #{event.event_name}: #{e.class} #{e.message}")
+    # optional: RecordEventLaterJob.perform_later(event.to_h)
+    nil
+  end
+end
+EventEngine::Store::Recorder.prepend(ResilientRecord)
+```
+
+**Trade-off:** rescuing protects emission but means a recording failure no longer
+surfaces loudly — make sure you alert on the log line.
+
+---
+
+## Replay
+
+`EventEngine::Store::Replay.each` reconstructs `EventEngine::Event` objects from the
+log in append order (ordered by `id`, batched via `find_each`):
+
+```ruby
+EventEngine::Store::Replay.each do |event|
+  # event is a fully-rehydrated EventEngine::Event (symbol-keyed payload)
+  puts "#{event.occurred_at} #{event.event_name}"
+end
+
+# Without a block you get an Enumerator (a *live* query, not a snapshot):
+enum = EventEngine::Store::Replay.each
+enum.count
+```
+
+Use replay to rebuild read models, backfill a new projection, or audit history.
+
+---
+
+## Projections
+
+A projection is any object with `apply(event)`. Register it and it's updated **live**
+as events are dispatched, and can be **rebuilt** from the full log on demand.
+
+```ruby
+class OrdersByDay
+  def initialize; @counts = Hash.new(0); end
+  attr_reader :counts
+
+  def apply(event)
+    @counts[event.occurred_at.to_date] += 1 if event.event_name == :order_placed
+  end
+end
+
+projection = OrdersByDay.new
+EventEngine::Store.register_projection(projection)   # live updates from now on
+
+EventEngine::Store.rebuild(projection)               # replay the whole log into it
+EventEngine::Store.reset_projections!                # clear all (e.g. in tests)
+```
+
+API: `register_projection(p)`, `projections`, `reset_projections!`, `rebuild(p)`.
+
+**Why projections:** maintain a denormalized read model (counters, dashboards,
+search indexes) that you can always recompute from the authoritative log — the core
+event-sourcing payoff.
+
+> **Note:** projections run **synchronously inside dispatch**. If a projection's
+> `apply` raises, it propagates and can break event emission (and stops later
+> handlers). Keep `apply` fast and defensive; for heavy work, have `apply` enqueue a
+> job instead of doing the work inline.
+
+---
+
+## License
+
+Available as open source under the terms of the
+[MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,9 @@
+require "bundler/setup"
+
+APP_RAKEFILE = File.expand_path("test/dummy/Rakefile", __dir__)
+load "rails/tasks/engine.rake"
+
+require "bundler/gem_tasks"
+
+task test: "app:test"
+task default: :test

data/app/assets/stylesheets/event_engine/store/application.css

@@ -0,0 +1,15 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or any plugin's vendor/assets/stylesheets directory can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the bottom of the
+ * compiled file so the styles you add here take precedence over styles defined in any other CSS/SCSS
+ * files in this directory. Styles in this file should be added after the last require_* statement.
+ * It is generally better to create a new file per style scope.
+ *
+ *= require_tree .
+ *= require_self
+ */

data/app/models/event_engine/store/application_record.rb

@@ -0,0 +1,7 @@
+module EventEngine
+  module Store
+    class ApplicationRecord < ActiveRecord::Base
+      self.abstract_class = true
+    end
+  end
+end

data/app/models/event_engine/store/stored_event.rb

@@ -0,0 +1,11 @@
+module EventEngine
+  module Store
+    class StoredEvent < ApplicationRecord
+      self.table_name = "event_engine_store_stored_events"
+
+      def readonly?
+        persisted?
+      end
+    end
+  end
+end

data/app/views/layouts/event_engine/store/application.html.erb

@@ -0,0 +1,17 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Event engine store</title>
+  <%= csrf_meta_tags %>
+  <%= csp_meta_tag %>
+
+  <%= yield :head %>
+
+  <%= stylesheet_link_tag    "event_engine/store/application", media: "all" %>
+</head>
+<body>
+
+<%= yield %>
+
+</body>
+</html>

data/db/migrate/20260605000001_create_event_engine_store_stored_events.rb

@@ -0,0 +1,22 @@
+class CreateEventEngineStoreStoredEvents < ActiveRecord::Migration[8.1]
+  def change
+    create_table :event_engine_store_stored_events do |t|
+      t.string :event_name, null: false
+      t.string :event_type
+      t.integer :event_version
+      t.string :process_type
+      t.json :payload
+      t.json :metadata
+      t.datetime :occurred_at
+      t.string :idempotency_key
+      t.string :aggregate_type
+      t.string :aggregate_id
+      t.integer :aggregate_version
+      t.datetime :created_at, null: false
+    end
+
+    add_index :event_engine_store_stored_events, :event_name
+    add_index :event_engine_store_stored_events, :occurred_at
+    add_index :event_engine_store_stored_events, :idempotency_key
+  end
+end

data/lib/event_engine/store/engine.rb

@@ -0,0 +1,14 @@
+module EventEngine
+  module Store
+    class Engine < ::Rails::Engine
+      isolate_namespace EventEngine::Store
+
+      initializer "event_engine.store.register_recorder" do
+        config.after_initialize do
+          EventEngine.register_handler(Recorder.new, process_types: :all)
+          EventEngine.register_handler(ProjectionDispatcher.new, process_types: :all)
+        end
+      end
+    end
+  end
+end

data/lib/event_engine/store/projection_dispatcher.rb

@@ -0,0 +1,9 @@
+module EventEngine
+  module Store
+    class ProjectionDispatcher
+      def call(event)
+        Store.projections.each { |projection| projection.apply(event) }
+      end
+    end
+  end
+end

data/lib/event_engine/store/recorder.rb

@@ -0,0 +1,21 @@
+module EventEngine
+  module Store
+    class Recorder
+      def call(event)
+        StoredEvent.create!(
+          event_name: event.event_name,
+          event_type: event.event_type,
+          event_version: event.event_version,
+          process_type: event.process_type,
+          payload: event.payload,
+          metadata: event.metadata,
+          occurred_at: event.occurred_at,
+          idempotency_key: event.idempotency_key,
+          aggregate_type: event.aggregate_type,
+          aggregate_id: event.aggregate_id,
+          aggregate_version: event.aggregate_version
+        )
+      end
+    end
+  end
+end

data/lib/event_engine/store/replay.rb

@@ -0,0 +1,25 @@
+module EventEngine
+  module Store
+    module Replay
+      def self.each
+        return to_enum(:each) unless block_given?
+
+        StoredEvent.order(:id).find_each do |stored|
+          yield EventEngine::Event.new(
+            event_name: stored.event_name,
+            event_type: stored.event_type,
+            event_version: stored.event_version,
+            process_type: stored.process_type,
+            payload: stored.payload,
+            metadata: stored.metadata,
+            occurred_at: stored.occurred_at,
+            idempotency_key: stored.idempotency_key,
+            aggregate_type: stored.aggregate_type,
+            aggregate_id: stored.aggregate_id,
+            aggregate_version: stored.aggregate_version
+          )
+        end
+      end
+    end
+  end
+end

data/lib/event_engine/store/version.rb

@@ -0,0 +1,5 @@
+module EventEngine
+  module Store
+    VERSION = "0.1.0"
+  end
+end

data/lib/event_engine/store.rb

@@ -0,0 +1,27 @@
+require "event_engine/store/version"
+require "event_engine/store/engine"
+require "event_engine/store/recorder"
+require "event_engine/store/replay"
+require "event_engine/store/projection_dispatcher"
+
+module EventEngine
+  module Store
+    class << self
+      def projections
+        @projections ||= []
+      end
+
+      def register_projection(projection)
+        projections << projection
+      end
+
+      def reset_projections!
+        projections.clear
+      end
+
+      def rebuild(projection)
+        Replay.each { |event| projection.apply(event) }
+      end
+    end
+  end
+end

data/lib/event_engine-store.rb

@@ -0,0 +1 @@
+require "event_engine/store"

data/lib/tasks/event_engine/store_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :event_engine_store do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,133 @@
+--- !ruby/object:Gem::Specification
+name: event_engine-store
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- tylercschneider
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.1.6
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.1.6
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.1.6
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.1.6
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
+- !ruby/object:Gem::Dependency
+  name: event_engine
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.1
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3'
+description: 'The durable record layer for EventEngine: an immutable, append-only
+  event table the host owns, a handler that records every dispatched event, and event-sourcing
+  replay. Depends on event_engine for event definitions.'
+email:
+- tylercschneider@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- MIT-LICENSE
+- README.md
+- Rakefile
+- app/assets/stylesheets/event_engine/store/application.css
+- app/models/event_engine/store/application_record.rb
+- app/models/event_engine/store/stored_event.rb
+- app/views/layouts/event_engine/store/application.html.erb
+- db/migrate/20260605000001_create_event_engine_store_stored_events.rb
+- lib/event_engine-store.rb
+- lib/event_engine/store.rb
+- lib/event_engine/store/engine.rb
+- lib/event_engine/store/projection_dispatcher.rb
+- lib/event_engine/store/recorder.rb
+- lib/event_engine/store/replay.rb
+- lib/event_engine/store/version.rb
+- lib/tasks/event_engine/store_tasks.rake
+homepage: https://github.com/DYB-Development/event_engine-store
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/DYB-Development/event_engine-store
+  source_code_uri: https://github.com/DYB-Development/event_engine-store
+  changelog_uri: https://github.com/tylercschneider/event_engine-store/blob/main/CHANGELOG.md
+  bug_tracker_uri: https://github.com/tylercschneider/event_engine-store/issues
+  documentation_uri: https://github.com/tylercschneider/event_engine-store#readme
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.20
+specification_version: 4
+summary: Permanent, queryable event record for EventEngine
+test_files: []