event_engine-event_definition 0.2.0 → 0.4.0

data/the_local/agents/event_engine-event_definition-develop.md

@@ -0,0 +1,253 @@
+---
+name: event_engine-event_definition-develop
+description: Use PROACTIVELY for declaring a domain event, declaring a lifecycle family of events (created / updated / failed and the like) for one subject, registering the subjects events are about, reading an event's compiled schema or fingerprint, setting where raised events are published, and listing the loaded packs and their schema.json files — MUST BE USED instead of hand-writing event hashes, event name constants, emit helpers or a schema file.
+tools: Read, Write, Edit, Grep
+scope: declaring domain events with a plain-Ruby DSL and generating a pack's typed helper module and committed schema.json from them
+---
+
+You write and change a pack's event definitions, subjects and publisher wiring by
+following the steps below. Where a step says to ask the developer, ask and wait
+for the answer, and after every change to a definition you regenerate and commit
+the pack's helper and `schema.json`.
+
+## What event_engine-event_definition is
+
+A plain-Ruby gem, with no Rails dependency, in which each domain event is declared
+once as a small Ruby class naming the event, the inputs a caller passes, and the
+payload fields the event carries. Generation turns every definition into a typed
+helper method on the pack's root module and one entry in a committed
+`schema.json`.
+
+Fire this local when someone adds, changes or removes an event, adds a subject,
+asks what an event's contract is, or needs raised events to go somewhere. Adding
+the gem, configuring its paths and loading its rake task belongs to the install
+local.
+
+## Interface
+
+- `EventEngine::EventDefinition` — subclass it to declare one event with
+  `event_name`, `event_type`, `domain`, `subject`, `input`, `optional_input`,
+  `required_payload` and `optional_payload`.
+- `EventEngine::LifecycleDefinition` — subclass it to declare one event per verb
+  for a subject with `subject`, `event_type`, `lifecycle`, `on`, the input
+  declarations and the payload declarations.
+- `EventEngine::SubjectRegistry.define` — builds a registry of every subject an
+  event may name, from a block of `subject :name, **metadata` lines.
+- `EventEngine::EventDefinition.schema` — called on a definition class, returns
+  its validated schema, or raises `ArgumentError` listing every problem.
+- `EventEngine::Definition.publisher=` — sets the object every generated helper
+  hands its event to.
+- `EventEngine::Definition.packs` — the root modules of every generated helper
+  required so far, each listed once.
+- `EventEngine::Definition.pack_schema_paths` — the absolute `schema.json` path
+  of each of those packs.
+
+## How to use it
+
+### Declare one event
+
+1. Put the definition in a `.rb` file anywhere under the pack's definitions path,
+   which is the `definitions_path` in the pack's configuration. Every
+   `.rb` file under it, at any depth, is loaded, so one class per file is enough.
+2. Subclass `EventEngine::EventDefinition` and declare the identity:
+
+   ```ruby
+   class LeadCreated < EventEngine::EventDefinition
+     event_name :lead_created
+     event_type :domain
+     domain :marketing
+     subject :lead
+   ```
+
+   - `event_name` is required and must be a snake_case symbol. It becomes the
+     helper method's name.
+   - `event_type` is required. It is a classification symbol with no fixed list,
+     so ask the developer which value the pack uses, such as `:domain` or
+     `:product`.
+   - `domain` is optional. Two events may share an `event_name` only in different
+     domains, and generation raises a duplicate error otherwise. Ask the
+     developer which domain the event belongs to.
+   - `subject` is optional. When set, it must be in the pack's subject registry,
+     or generation raises `EventEngine::SubjectRegistry::UnknownSubjectError`.
+3. Declare the inputs. Each input is one keyword argument on the generated
+   helper, and it holds the whole object the caller already has:
+
+   ```ruby
+     input :lead
+     optional_input :campaign
+   ```
+
+   - `input` makes the keyword required. `optional_input` defaults it to `nil`.
+   - Declaring the same name twice raises `ArgumentError` at once.
+   - An input may not be named `event_version`, `occurred_at`, `metadata`,
+     `idempotency_key`, `aggregate_type`, `aggregate_id` or `aggregate_version`,
+     since the helper already takes those keywords.
+4. Declare the payload fields, the flat values the event carries, each read off
+   one input:
+
+   ```ruby
+     required_payload :lead_id, from: :lead, attr: :id
+     required_payload :email,   from: :lead, attr: :email
+     optional_payload :source,  from: :campaign, attr: :channel
+   end
+   ```
+
+   - `from:` is required and must name an input declared on the same class.
+   - `attr:` names the attribute read off that input.
+   - `required_payload` marks the field as always present, and
+     `optional_payload` marks it as possibly absent. Ask the developer which one
+     each field is, because the choice is part of the event's contract.
+   - Field names must be unique within the event and may not be `event_name`,
+     `event_type`, `event_version`, `occurred_at`, `created_at`, `updated_at`,
+     `published_at`, `metadata`, `idempotency_key`, `attempts`,
+     `dead_lettered_at`, `aggregate_type`, `aggregate_id` or `aggregate_version`.
+   - The definition records the mapping only. Reading `lead.id` and the rest is
+     done by whichever publisher receives the event.
+5. Check the definition by calling `LeadCreated.schema`. It raises
+   `ArgumentError` naming every missing identity field, duplicate field,
+   reserved field name, missing `from:` and unknown input.
+
+### Declare a lifecycle family
+
+Use this when one subject has several events that share their inputs and
+payload, such as a started, completed and failed step.
+
+1. Put it under the definitions path like any other definition.
+2. Subclass `EventEngine::LifecycleDefinition`:
+
+   ```ruby
+   class ImportLifecycle < EventEngine::LifecycleDefinition
+     subject :import
+     event_type :domain
+     lifecycle :started, :completed, :failed
+
+     input :import
+     required_payload :import_id, from: :import, attr: :id
+
+     on :failed do
+       domain :data
+       optional_input :error
+       optional_payload :error_message, from: :error, attr: :message
+     end
+   end
+   ```
+
+   - Each verb becomes one event named `<subject>_<verb>`, such as
+     `import_started`, so the subject and every verb must be snake_case.
+   - Every generated event takes the family's `subject`, `event_type`, inputs
+     and payload fields.
+   - The subject must be in the pack's subject registry.
+   - A `lifecycle` family has no `domain` of its own. Each generated event has
+     no domain unless its `on` block sets one, so ask the developer whether the
+     family's events need a domain, and if they do, add an `on` block for every
+     verb that calls `domain`.
+3. Use `on :<verb> do ... end` to add to one verb's event. The block takes every
+   declaration from "Declare one event", and it may override `event_type`. An
+   `on` block for a verb missing from `lifecycle` has no effect.
+4. Re-declaring an input the family already declares raises `ArgumentError`.
+
+### Register subjects
+
+Do this whenever any event or lifecycle family names a `subject`.
+
+1. Build the registry with every subject used across the pack:
+
+   ```ruby
+   SUBJECTS = EventEngine::SubjectRegistry.define do
+     subject :lead
+     subject :import, owner: "data team"
+   end
+   ```
+
+   Metadata after the name is optional and free-form. Ask the developer whether
+   any subject needs it.
+2. Hand the registry to generation as the pack's configured `subject_registry`,
+   such as `config.subject_registry = SUBJECTS`. If the pack has no
+   configuration yet, the install local sets it up.
+
+### Regenerate after every change
+
+1. Run the pack's generation task, which the install local sets up, from the
+   project root. It raises instead of writing if any definition is invalid.
+2. Commit the regenerated helper and `schema.json` together with the definition
+   change.
+3. Raise the event from consuming code through the generated helper on the
+   pack's root module, passing the inputs as keywords:
+
+   ```ruby
+   MarketingEvents.lead_created(lead: lead, campaign: campaign)
+   ```
+
+   Each helper also takes the optional keywords `event_version`, `occurred_at`,
+   `metadata`, `idempotency_key`, `aggregate_type`, `aggregate_id` and
+   `aggregate_version`, which are passed to the publisher unchanged.
+
+### Read an event's contract
+
+Call `.schema` on the definition class and read from the result:
+
+```ruby
+schema = LeadCreated.schema
+schema.event_name       # => :lead_created
+schema.required_inputs  # => [:lead]
+schema.optional_inputs  # => [:campaign]
+schema.payload_fields   # => [{ name: :lead_id, required: true, from: :lead, attr: :id }, ...]
+schema.fingerprint      # => a SHA-256 hex string
+schema.to_h             # => the same hash written into schema.json
+```
+
+The fingerprint covers the event name, event type, inputs and payload fields,
+including whether each field is required. A change to any of those changes the
+fingerprint, and a change to `domain` or `subject` does not. Compare fingerprints
+to tell whether an event's contract changed.
+
+### Set the publisher
+
+1. Ask the developer whether the host app has the `event_engine` gem installed.
+   If it does, it sets the publisher at boot and nothing is written here.
+2. Otherwise, until a publisher is set, every generated helper raises
+   `EventEngine::Definition::PublisherNotConfigured`. Ask the developer where
+   raised events should go, then write a publisher that responds to:
+
+   ```ruby
+   def publish(event_name, domain:, inputs:, event_version:, occurred_at:,
+               metadata:, idempotency_key:, aggregate_type:, aggregate_id:,
+               aggregate_version:)
+   ```
+
+   `event_name` and `domain` are symbols, and `inputs` is a hash of the input
+   objects exactly as the caller passed them, keyed by input name. The publisher
+   builds the payload from them using the event's `from:` and `attr:` mapping.
+3. Assign it once at boot, after the gem is required and before any helper is
+   called:
+
+   ```ruby
+   EventEngine::Definition.publisher = MyPublisher.new
+   ```
+
+4. In a test that raises events, assign a publisher that records its calls and
+   assert on those calls.
+
+### List the loaded packs
+
+1. Require every pack's generated helper first. A pack is listed only after its
+   helper has been required, and requiring one twice lists it once.
+2. Read `EventEngine::Definition.packs` for the pack root modules, such as
+   `[MarketingEvents, SalesEvents]`.
+3. Read `EventEngine::Definition.pack_schema_paths` for the absolute path of each
+   pack's `schema.json`, in the same order.
+
+## Conventions
+
+- Every definition declares `event_name` and `event_type`, and every payload
+  field declares `from:`.
+- Every `subject` used anywhere in the pack is in its subject registry.
+- Never edit the generated helper or `schema.json` by hand. Regenerate and commit
+  both after every definition change.
+- Raise events only through the generated helpers, never by calling the publisher
+  directly.
+- A definition describes what an event carries, never what happens to it. How a
+  raised event is processed belongs to the publisher.
+- Adding the gem, loading the rake task and setting `definitions_path`,
+  `helper_path` and `root_module` is out of scope here and belongs to the install
+  local.

data/the_local/agents/event_engine-event_definition-info.md

@@ -0,0 +1,62 @@
+---
+name: event_engine-event_definition-info
+description: Use to learn what event_engine-event_definition offers — declaring domain events, lifecycle event families, subjects, packs, and the generated helper and schema.json.
+tools: Read
+scope: declaring domain events with a plain-Ruby DSL and generating a pack's typed helper module and committed schema.json from them
+---
+
+You explain what event_engine-event_definition does, answering only from this
+reference. You make no changes, and you never read the gem's source.
+
+## What event_engine-event_definition is
+
+It is the plain-Ruby foundation of the EventEngine pipeline, with no Rails
+dependency. A team declares each domain event once, as a small Ruby class that
+names the event and lists what it takes in and what it carries. From those
+declarations the gem generates a pack's typed helper module and a committed
+`schema.json` that describes every event in the pack.
+
+Reach for it when writing a lightweight domain pack: a gem or app area that owns
+a set of events and needs their contract written down, without taking on the
+dispatch, registry and Rails engine that live in the full `event_engine` gem.
+
+## Interface
+
+Every entry point is owned by one of the other two locals, and none by this one.
+Adding the gem to a project, configuring it and running the generation task is
+the install local's. Declaring events, lifecycle families and subjects, reading
+an event's schema, and setting the publisher or the pack list is the develop
+local's. Route to those rather than answering here.
+
+## How to use it
+
+Decide what you are doing. Wiring the gem into a pack or app for the first time,
+or regenerating the helper and `schema.json`, needs the install local. Writing
+or changing the events themselves needs the develop local.
+
+## Conventions
+
+- An **event definition** declares one event: its **event name**, its **event
+  type**, and optionally the **subject** it is about and the **domain** it
+  belongs to.
+- An **input** is a value the caller passes when raising the event, either
+  required or optional.
+- A **payload field** is a value the event carries, either required or optional.
+  Every payload field names the input it comes **from**, and may name an
+  **attr** to read off that input.
+- Some payload names are **reserved** because the pipeline stores them itself,
+  such as the event's name, type, version, timestamps, metadata, idempotency key
+  and aggregate identity.
+- A **schema** is the validated form of one event definition. Its
+  **fingerprint** is a hash of the event name, event type, inputs and payload
+  fields, so a change to any of those changes it and a change to subject or
+  domain does not.
+- A **lifecycle definition** declares a family of events for one subject from a
+  list of verbs. Each verb becomes its own event named `<subject>_<verb>`, sharing
+  the family's inputs and payload fields, with per-verb overrides allowed.
+- A **subject registry** lists the subjects a pack knows about, each with
+  optional metadata.
+- A **pack** is one set of event definitions that generates one helper module,
+  under a **root module**, and one `schema.json`.
+- The **publisher** is what receives raised events. Until one is set, raising
+  an event fails with a publisher-not-configured error.

data/the_local/agents/event_engine-event_definition-install.md

@@ -0,0 +1,92 @@
+---
+name: event_engine-event_definition-install
+description: Use to hook event_engine-event_definition into a project — adding the gem, requiring it, loading its rake task, configuring the definitions path, helper path and root module, and running the generation task.
+tools: Bash, Read, Edit
+scope: declaring domain events with a plain-Ruby DSL and generating a pack's typed helper module and committed schema.json from them
+---
+
+You follow these steps exactly and invent none. Where a step says to ask the
+developer, ask and wait for the answer.
+
+## What event_engine-event_definition is
+
+A plain-Ruby gem, with no Rails dependency, that generates a pack's typed helper
+module and `schema.json` from its event definitions; hook it into a domain pack
+gem or a Rails app that owns a set of events.
+
+## Interface
+
+- `gem "event_engine-event_definition"` — adds the gem to the project's bundle.
+- `require "event_engine/definition"` — loads the gem.
+- `load "tasks/event_definition.rake"` — adds the `event_definition:generate`
+  task to the project's Rakefile.
+- `EventEngine::Definition.configure` — sets where definitions are read from,
+  where the helper is written, and the name of the module that wraps it.
+- `rake event_definition:generate` — writes the helper module and `schema.json`
+  from every definition under the definitions path.
+
+## How to use it
+
+1. Ask the developer whether this is a domain pack gem or a Rails app.
+2. Add the gem.
+   - Rails app: add `gem "event_engine-event_definition"` to the `Gemfile`.
+   - Pack gem: add `spec.add_dependency "event_engine-event_definition"` to the
+     pack's `*.gemspec`, since the generated helper requires the gem at runtime.
+   - Run `bundle install`.
+3. Ask the developer for three values. None has a default, and the task fails if
+   any is missing.
+   - `definitions_path` — the directory holding the event definitions, such as
+     `app/event_definitions`. Every `.rb` file under it, at any depth, is loaded.
+   - `helper_path` — the file the helper module is written to, such as
+     `lib/generated/marketing_events.rb`. `schema.json` is written to the same
+     directory.
+   - `root_module` — the Ruby constant name that wraps the helpers, such as
+     `MarketingEvents`.
+4. Add these lines to the project's `Rakefile`, with the three values from step 3:
+
+   ```ruby
+   require "event_engine/definition"
+   load "tasks/event_definition.rake"
+
+   EventEngine::Definition.configure do |config|
+     config.definitions_path = "app/event_definitions"
+     config.helper_path      = "lib/generated/marketing_events.rb"
+     config.root_module      = "MarketingEvents"
+   end
+   ```
+
+   The paths are relative to the directory rake is run from, so run it from the
+   project root.
+5. Ask the developer whether any event declares a subject. If one does, add
+   `config.subject_registry = <a registry naming every subject used>` inside the
+   `configure` block. Writing that registry is the develop local's job. Without
+   it, generation raises an unknown subject error.
+6. Make sure the helper is required once at boot, since it registers its pack
+   when it is required.
+   - Rails app: in `config/application.rb`, add the helper's directory to the
+     autoload ignore list, such as
+     `config.autoload_lib(ignore: %w[assets tasks generated])`, because the
+     helper's file path does not match the constant it defines and eager loading
+     fails in production. Then in `config/initializers/event_engine.rb`, require
+     the helper, such as
+     `require Rails.root.join("lib/generated/marketing_events")`.
+   - Pack gem: ask the developer which of the pack's files should require the
+     helper, and add the `require` there.
+7. Run `bundle exec rake event_definition:generate`. It creates the helper's
+   directory if missing and writes two files:
+   - the helper module at `helper_path`,
+   - `schema.json` next to it.
+8. Commit both generated files.
+
+## Conventions
+
+- A successful run prints two lines, `Wrote <root_module> helper to
+  <helper_path>` and `Wrote <root_module> schema to <dir>/schema.json`. Confirm
+  both files exist.
+- Re-run `rake event_definition:generate` after every change to a definition and
+  commit the result. Never edit the generated files by hand; each run overwrites
+  them.
+- With no definitions under `definitions_path`, the task still runs and writes an
+  empty module and an empty `schema.json`.
+- Writing event definitions, subjects and lifecycle families, and choosing where
+  raised events go, is out of scope here and belongs to the develop local.

data/the_local/interface.yml

@@ -0,0 +1,29 @@
+scope: declaring domain events with a plain-Ruby DSL and generating a pack's typed helper module and committed schema.json from them
+
+install:
+  - gem "event_engine-event_definition"
+  - require "event_engine/definition"
+  - load "tasks/event_definition.rake"
+  - EventEngine::Definition.configure
+  - rake event_definition:generate
+
+develop:
+  - EventEngine::EventDefinition
+  - EventEngine::LifecycleDefinition
+  - EventEngine::SubjectRegistry.define
+  - EventEngine::EventDefinition.schema
+  - EventEngine::Definition.publisher=
+  - EventEngine::Definition.packs
+  - EventEngine::Definition.pack_schema_paths
+
+sources:
+  - lib/event_engine/definition.rb
+  - lib/event_engine/definition/configuration.rb
+  - lib/tasks/event_definition.rake
+  - lib/event_engine/event_definition.rb
+  - lib/event_engine/event_definition/inputs.rb
+  - lib/event_engine/event_definition/payloads.rb
+  - lib/event_engine/event_definition/schemas.rb
+  - lib/event_engine/lifecycle_definition.rb
+  - lib/event_engine/subject_registry.rb
+  - event_engine-event_definition.gemspec

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: event_engine-event_definition
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.4.0
 platform: ruby
 authors:
 - tylercschneider
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-07-20 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
 description: 'The plain-Ruby foundation of the EventEngine pipeline: the EventDefinition
   DSL and the shared schema-contract value objects, with no Rails dependency. Lightweight
@@ -20,14 +19,20 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".claude/agents/the_local-develop.md"
+- ".claude/agents/the_local-info.md"
+- ".claude/agents/the_local-install.md"
 - CHANGELOG.md
+- CLAUDE.md
 - LICENSE.txt
 - README.md
 - Rakefile
 - docs/examples.md
 - lib/event_engine/definition.rb
 - lib/event_engine/definition/configuration.rb
+- lib/event_engine/definition/event_schema.rb
 - lib/event_engine/definition/null_publisher.rb
+- lib/event_engine/definition/schema_registry.rb
 - lib/event_engine/definition/version.rb
 - lib/event_engine/definition_loader.rb
 - lib/event_engine/domain_pack_build.rb
@@ -38,12 +43,14 @@ files:
 - lib/event_engine/event_definition/schemas.rb
 - lib/event_engine/event_definition/validation.rb
 - lib/event_engine/event_engine_helpers_writer.rb
-- lib/event_engine/event_schema.rb
 - lib/event_engine/lifecycle_definition.rb
-- lib/event_engine/schema_registry.rb
 - lib/event_engine/subject_registry.rb
-- lib/tasks/event_engine_definition.rake
+- lib/tasks/event_definition.rake
 - sig/event_engine/definition.rbs
+- the_local/agents/event_engine-event_definition-develop.md
+- the_local/agents/event_engine-event_definition-info.md
+- the_local/agents/event_engine-event_definition-install.md
+- the_local/interface.yml
 homepage: https://eventengine.co
 licenses:
 - MIT
@@ -54,7 +61,6 @@ metadata:
   source_code_uri: https://github.com/DYB-Development/event_engine-event_definition
   bug_tracker_uri: https://github.com/DYB-Development/event_engine-event_definition/issues
   documentation_uri: https://github.com/DYB-Development/event_engine-event_definition#readme
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -69,8 +75,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.16
-signing_key:
+rubygems_version: 4.0.20
 specification_version: 4
 summary: Plain-Ruby event-definition contract for the EventEngine pipeline
 test_files: []

data/lib/event_engine/event_schema.rb

@@ -1,80 +0,0 @@
-module EventEngine
-  class EventSchema
-    class DuplicateEventNameError < StandardError; end
-
-    def self.define(&block)
-      schema = new
-      block.call(schema)
-      schema
-    end
-
-    def initialize
-      @schemas_by_event = {}
-      @finalized = false
-    end
-
-    def register(schema)
-      raise FrozenError, "EventSchema is finalized" if @finalized
-      key = key_for(schema.domain, schema.event_name)
-      version = schema.event_version
-
-      @schemas_by_event[key] ||= {}
-      guard_duplicate_event_name!(@schemas_by_event[key][version], schema)
-      @schemas_by_event[key][version] = schema
-    end
-
-    def guard_duplicate_event_name!(existing, incoming)
-      return unless existing
-
-      raise DuplicateEventNameError,
-            "duplicate (domain, event_name) " \
-            "(#{incoming.domain.inspect}, #{incoming.event_name.inspect}): " \
-            "already registered at version #{existing.event_version.inspect}"
-    end
-
-    def events(domain: nil)
-      @schemas_by_event.keys
-        .select { |(schema_domain, _name)| domain.nil? || schema_domain == domain }
-        .map { |(_domain, event_name)| event_name }
-        .uniq
-    end
-
-    def versions_for(event_name, domain: nil)
-      version_sets_for(event_name, domain).flat_map(&:keys).uniq.sort
-    end
-
-    def schema_for(event_name, version, domain: nil)
-      set = version_sets_for(event_name, domain).find { |versions| versions.key?(version) }
-      set && set[version]
-    end
-
-    def latest_for(event_name, domain: nil)
-      merged = version_sets_for(event_name, domain).reduce({}, :merge)
-      return nil if merged.empty?
-      merged[merged.keys.max]
-    end
-
-    def finalize!
-      @finalized = true
-      @schemas_by_event.each_value(&:freeze)
-      @schemas_by_event.freeze
-      freeze
-    end
-
-    def schemas_by_event
-      @schemas_by_event
-    end
-
-    private
-
-    def key_for(domain, event_name)
-      [domain, event_name]
-    end
-
-    def version_sets_for(event_name, domain = nil)
-      @schemas_by_event.select do |(schema_domain, name), _versions|
-        name == event_name && (domain.nil? || schema_domain == domain)
-      end.values
-    end
-  end
-end

data/lib/event_engine/schema_registry.rb

@@ -1,71 +0,0 @@
-module EventEngine
-  class SchemaRegistry
-    class UnknownEventError < StandardError; end
-
-    class RegistryFrozenError < StandardError; end
-
-    def initialize(event_schema = EventSchema.new)
-      @event_schema = event_schema
-      @loaded = false
-    end
-
-    def register(schema)
-      @event_schema.register(schema)
-    end
-
-    def events
-      @event_schema.events
-    end
-
-    def versions_for(event_name, domain: nil)
-      @event_schema.versions_for(event_name, domain: domain)
-    end
-
-    def load_from_schema!(schema)
-      raise RegistryFrozenError, "EventRegistry already loaded" if loaded?
-      @event_schema = schema
-
-      @loaded = true
-      self
-    end
-
-    def reset!
-      @event_schema = {}
-      @loaded = false
-    end
-
-    def schema(event_name, version: nil, domain: nil)
-      raise RegistryFrozenError, "EventRegistry not loaded" unless loaded?
-
-      schema =
-        if version
-          @event_schema.schema_for(event_name, version, domain: domain)
-        else
-          @event_schema.latest_for(event_name, domain: domain)
-        end
-
-      unless schema
-        raise UnknownEventError,
-              "Unknown #{version ? "version #{version} for " : ""}event: #{event_name}"
-      end
-
-      schema
-    end
-
-    def latest_for(event_name, domain: nil)
-      @event_schema.latest_for(event_name, domain: domain)
-    end
-
-    def event_schema
-      @event_schema
-    end
-
-    def finalize!
-      @event_schema.finalize!
-    end
-
-    def loaded?
-      @loaded == true
-    end
-  end
-end

data/lib/tasks/event_engine_definition.rake

@@ -1,19 +0,0 @@
-require "event_engine/definition"
-
-namespace :event_engine do
-  namespace :definition do
-    desc "Generate the pack's helper and schema.json from its EventDefinitions"
-    task :dump do
-      config = EventEngine::Definition.configuration
-
-      definitions = EventEngine::DefinitionLoader.load!(config.definitions_path)
-
-      EventEngine::DomainPackBuild.run(
-        definitions,
-        helper_path: config.helper_path,
-        root_module: config.root_module,
-        subject_registry: config.subject_registry
-      )
-    end
-  end
-end