smart_domain 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e5e5a4574b90ca06fb1e2747b2da47b7a5168794f4e80901ee2688930f2e6ad8
-  data.tar.gz: e1ada977da14eb9f8ec6092dcfee612f7283847d4a36b136faeca0dc4d51b92a
+  metadata.gz: dc4986884824f0ebda3f3ea7051e7303bb416b7497f1b3213a749bdbd2a80918
+  data.tar.gz: 5a65d52f74b31c7ebc0da5d8a63d8b8942b5262746de39826f185d61129f32e7
 SHA512:
-  metadata.gz: 03d5fe8c7ad6be23ee69b9d11139ade594130151d12d7ea30f68156c90fa1dc05c1e133da427bc71e0a852eab0455a5c4d2d11f16345c05397b2856842898961
-  data.tar.gz: 9aeb909c122d04cf2677aceb63d7f2b43b9b1a7d86c92264e9a4096cd1ee69470501c1e1e57b082fe73d6d48dbc5d4e40195d12df7a68116c12a73e0cf74a00c
+  metadata.gz: 06015b7d5dc2598a35fa0ebda62d2c2ece2b1c7a1cfc4719713d70e54fdebde7b713c84f713334853d9244d9f994b88d6a4937cc6b7dcedb25f8800bd7d87551
+  data.tar.gz: 2af6c6ee30a91e21947907885f4662b3565576b9a53631eb216a799167e2ff88f5088bee7b6bf6c5e04c01b9062bec243518aee6f556eb023cda2b784d6f5ea5

data/.rubocop.yml

@@ -0,0 +1,65 @@
+AllCops:
+  NewCops: enable
+  TargetRubyVersion: 3.0
+  SuggestExtensions: false
+  Exclude:
+    - 'vendor/**/*'
+    - 'bin/**/*'
+    - 'node_modules/**/*'
+    - 'examples/**/*'
+
+# Allow longer lines in tests
+Layout/LineLength:
+  Max: 120
+  Exclude:
+    - 'spec/**/*'
+
+# Allow long blocks in specs and rake tasks
+Metrics/BlockLength:
+  Exclude:
+    - 'spec/**/*'
+    - '*.gemspec'
+    - 'lib/**/*.rake'
+
+# Allow longer methods for generators and complex logic
+Metrics/MethodLength:
+  Max: 30
+
+# Allow more complex methods
+Metrics/AbcSize:
+  Max: 30
+  Exclude:
+    - 'lib/generators/**/*'
+
+# Allow more cyclomatic complexity
+Metrics/CyclomaticComplexity:
+  Max: 10
+
+# Allow higher perceived complexity
+Metrics/PerceivedComplexity:
+  Max: 10
+
+# Allow longer classes for handlers
+Metrics/ClassLength:
+  Max: 150
+
+# Allow defining constants in test blocks
+Lint/ConstantDefinitionInBlock:
+  Exclude:
+    - 'spec/**/*'
+
+# Allow duplicate branches (false positives)
+Lint/DuplicateBranch:
+  Enabled: false
+
+# Allow development dependencies in gemspec
+Gemspec/DevelopmentDependencies:
+  Enabled: false
+
+# Allow more than one class per file in specs
+Style/ClassAndModuleChildren:
+  Enabled: false
+
+# Don't require documentation for all classes
+Style/Documentation:
+  Enabled: false

data/CHANGELOG.md

@@ -7,14 +7,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-### Added
-- Initial gem structure
-- Event system (DomainEvent, EventBus, Event Mixins)
-- Generic handlers (Audit, Metrics)
-- Domain service pattern
-- ActiveRecord integration
-- Rails generators for domain scaffolding
-- Comprehensive documentation
+## [0.1.1] - 2025-12-31
+
+### Changed
+- Enhanced README with AI-augmented development advantages section
+- Explained how DDD/EDA architecture reduces context windows by 93%
+- Added concrete examples of reduced cognitive load for AI assistants
 
 ## [0.1.0] - 2025-12-29
 

data/README.md

@@ -1,5 +1,10 @@
 # SmartDomain
 
+[![Gem Version](https://badge.fury.io/rb/smart_domain.svg)](https://badge.fury.io/rb/smart_domain)
+[![Downloads](https://img.shields.io/gem/dt/smart_domain.svg)](https://rubygems.org/gems/smart_domain)
+[![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+[![Ruby](https://img.shields.io/badge/ruby-%3E%3D%203.0-ruby.svg)](https://www.ruby-lang.org)
+
 **Domain-Driven Design and Event-Driven Architecture for Rails**
 
 SmartDomain brings battle-tested DDD/EDA patterns from platform to Ruby on Rails applications. It provides domain events, an event bus, generic handlers, and Rails generators for rapid domain scaffolding.
@@ -15,6 +20,53 @@ SmartDomain brings battle-tested DDD/EDA patterns from platform to Ruby on Rails
 - ✅ **Multi-tenancy Support** - Built-in support for multi-tenant applications
 - ✅ **Audit Compliance** - Automatic audit logging for compliance requirements
 
+## Why SmartDomain for AI-Augmented Development?
+
+SmartDomain's architecture is uniquely suited for AI-augmented development workflows:
+
+**Reduced Context Windows**
+- Domain-driven design creates **loosely coupled bounded contexts**
+- Each domain (User, Order, Product) is self-contained with its own services, events, and policies
+- AI tools can focus on one domain at a time, drastically reducing context requirements
+- Clear boundaries mean AI understands exactly what code is relevant
+
+**Event-Driven Decoupling**
+- Events decouple domains from each other
+- Changes in one domain don't cascade through the codebase
+- AI can modify a single domain without understanding the entire system
+- Explicit event contracts make dependencies transparent
+
+**Explicit Patterns**
+- Standardized structure (Service → Events → Handlers) makes code predictable
+- AI learns the pattern once, applies it everywhere
+- Generators scaffold domains with consistent architecture
+- Less cognitive load for both humans and AI
+
+**Example: AI Working with SmartDomain**
+
+When an AI needs to add a "suspend user" feature:
+
+```
+Traditional monolithic approach:
+- AI must understand: User model, callbacks, mailers, notifications, audit logs,
+  related models, 15+ files across different layers
+- Context window: ~3000 lines of code
+
+SmartDomain approach:
+- AI focuses on: UserService (150 lines), UserSuspendedEvent (20 lines)
+- Events automatically trigger audit, metrics, emails via handlers
+- Context window: ~200 lines of code
+- 93% reduction in context requirements
+```
+
+**Benefits for Your Development Workflow**
+- **Faster iterations** - AI assistants work with smaller, focused contexts
+- **Better code quality** - Consistent patterns reduce hallucinations
+- **Easier maintenance** - Clear boundaries make changes predictable
+- **Natural collaboration** - AI and human developers work with the same mental model
+
+SmartDomain isn't just better architecture—it's architecture optimized for the AI development era.
+
 ## Installation
 
 Add this line to your application's Gemfile:

data/Rakefile

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
 
 RSpec::Core::RakeTask.new(:spec)
 
-require "rubocop/rake_task"
+require 'rubocop/rake_task'
 
 RuboCop::RakeTask.new
 

data/lib/generators/{active_domain → smart_domain}/domain/domain_generator.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require "rails/generators"
-require "rails/generators/named_base"
+require 'rails/generators'
+require 'rails/generators/named_base'
 
 module SmartDomain
   module Generators
@@ -22,18 +22,18 @@ module SmartDomain
     #     user_updated_event.rb
     #     user_deleted_event.rb
     class DomainGenerator < Rails::Generators::NamedBase
-      source_root File.expand_path("templates", __dir__)
+      source_root File.expand_path('templates', __dir__)
 
-      desc "Generate a complete domain structure with service, events, and policy"
+      desc 'Generate a complete domain structure with service, events, and policy'
 
       class_option :skip_service, type: :boolean, default: false,
-                                   desc: "Skip generating domain service"
+                                  desc: 'Skip generating domain service'
       class_option :skip_policy, type: :boolean, default: false,
-                                  desc: "Skip generating domain policy"
+                                 desc: 'Skip generating domain policy'
       class_option :skip_events, type: :boolean, default: false,
-                                  desc: "Skip generating domain events"
+                                 desc: 'Skip generating domain events'
       class_option :skip_setup, type: :boolean, default: false,
-                                 desc: "Skip generating setup file"
+                                desc: 'Skip generating setup file'
 
       # Generate domain directory structure
       def create_domain_directory
@@ -44,30 +44,30 @@ module SmartDomain
       def create_service
         return if options[:skip_service]
 
-        template "service.rb.tt", "#{domain_path}/#{file_name}_service.rb"
+        template 'service.rb.tt', "#{domain_path}/#{file_name}_service.rb"
       end
 
       # Generate domain events in app/events/
       def create_events
         return if options[:skip_events]
 
-        template "events/created_event.rb.tt", "app/events/#{file_name}_created_event.rb"
-        template "events/updated_event.rb.tt", "app/events/#{file_name}_updated_event.rb"
-        template "events/deleted_event.rb.tt", "app/events/#{file_name}_deleted_event.rb"
+        template 'events/created_event.rb.tt', "app/events/#{file_name}_created_event.rb"
+        template 'events/updated_event.rb.tt', "app/events/#{file_name}_updated_event.rb"
+        template 'events/deleted_event.rb.tt', "app/events/#{file_name}_deleted_event.rb"
       end
 
       # Generate domain policy
       def create_policy
         return if options[:skip_policy]
 
-        template "policy.rb.tt", "app/policies/#{file_name}_policy.rb"
+        template 'policy.rb.tt', "app/policies/#{file_name}_policy.rb"
       end
 
       # Generate setup file for event registration
       def create_setup
         return if options[:skip_setup]
 
-        template "setup.rb.tt", "#{domain_path}/setup.rb"
+        template 'setup.rb.tt', "#{domain_path}/setup.rb"
       end
 
       # Show instructions
@@ -84,10 +84,10 @@ module SmartDomain
         say "  #{domain_path}/setup.rb" unless options[:skip_setup]
 
         say "\nNext steps:"
-        say "  1. Review and customize the generated files"
+        say '  1. Review and customize the generated files'
         say "  2. Add business logic to #{class_name}Service"
         say "  3. Customize authorization rules in #{class_name}Policy"
-        say "  4. Restart your Rails server to load the domain setup"
+        say '  4. Restart your Rails server to load the domain setup'
       end
 
       private

data/lib/generators/{active_domain → smart_domain}/domain/templates/events/created_event.rb.tt

@@ -2,7 +2,7 @@
 
 # Event published when a <%= file_name %> is created
 class <%= class_name %>CreatedEvent < ApplicationEvent
-  include ActiveDomain::Event::ActorMixin
+  include SmartDomain::Event::ActorMixin
 
   attribute :<%= file_name %>_id, :string
 

data/lib/generators/{active_domain → smart_domain}/domain/templates/events/deleted_event.rb.tt

@@ -2,7 +2,7 @@
 
 # Event published when a <%= file_name %> is deleted
 class <%= class_name %>DeletedEvent < ApplicationEvent
-  include ActiveDomain::Event::ActorMixin
+  include SmartDomain::Event::ActorMixin
 
   attribute :<%= file_name %>_id, :string
 

data/lib/generators/{active_domain → smart_domain}/domain/templates/events/updated_event.rb.tt

@@ -2,8 +2,8 @@
 
 # Event published when a <%= file_name %> is updated
 class <%= class_name %>UpdatedEvent < ApplicationEvent
-  include ActiveDomain::Event::ActorMixin
-  include ActiveDomain::Event::ChangeTrackingMixin
+  include SmartDomain::Event::ActorMixin
+  include SmartDomain::Event::ChangeTrackingMixin
 
   attribute :<%= file_name %>_id, :string
 

data/lib/generators/{active_domain → smart_domain}/domain/templates/service.rb.tt

@@ -11,12 +11,12 @@ module <%= domain_module_name %>
     #
     # @param attributes [Hash] <%= class_name %> attributes
     # @return [<%= class_name %>] Created <%= file_name %>
-    # @raise [ActiveDomain::Domain::AlreadyExistsError] If <%= file_name %> already exists
-    # @raise [ActiveDomain::Domain::ValidationError] If validation fails
+    # @raise [SmartDomain::Domain::AlreadyExistsError] If <%= file_name %> already exists
+    # @raise [SmartDomain::Domain::ValidationError] If validation fails
     def create_<%= file_name %>(attributes)
       # Example business rule validation
       # if <%= class_name %>.exists?(email: attributes[:email])
-      #   raise ActiveDomain::Domain::AlreadyExistsError.new('<%= class_name %>', 'email', attributes[:email])
+      #   raise SmartDomain::Domain::AlreadyExistsError.new('<%= class_name %>', 'email', attributes[:email])
       # end
 
       <%= class_name %>.transaction do
@@ -43,7 +43,7 @@ module <%= domain_module_name %>
     # @param attributes [Hash] Attributes to update
     # @return [<%= class_name %>] Updated <%= file_name %>
     # @raise [ActiveRecord::RecordNotFound] If <%= file_name %> not found
-    # @raise [ActiveDomain::Domain::UnauthorizedError] If not authorized
+    # @raise [SmartDomain::Domain::UnauthorizedError] If not authorized
     def update_<%= file_name %>(<%= file_name %>_id, attributes)
       <%= file_name %> = <%= class_name %>.find(<%= file_name %>_id)
 
@@ -65,7 +65,7 @@ module <%= domain_module_name %>
     # @param <%= file_name %>_id [Integer, String] <%= class_name %> ID
     # @return [Boolean] True if deleted
     # @raise [ActiveRecord::RecordNotFound] If <%= file_name %> not found
-    # @raise [ActiveDomain::Domain::UnauthorizedError] If not authorized
+    # @raise [SmartDomain::Domain::UnauthorizedError] If not authorized
     def delete_<%= file_name %>(<%= file_name %>_id)
       <%= file_name %> = <%= class_name %>.find(<%= file_name %>_id)
 

data/lib/generators/{active_domain → smart_domain}/domain/templates/setup.rb.tt

@@ -3,12 +3,12 @@
 module <%= domain_module_name %>
   # Setup event handlers for <%= file_name %> domain
   #
-  # This file is automatically loaded by ActiveDomain::Railtie
+  # This file is automatically loaded by SmartDomain::Railtie
   # when the Rails application starts.
   def self.setup!
     # Register standard handlers (audit and metrics)
     # This one line replaces ~50 lines of boilerplate!
-    ActiveDomain::Event::Registration.register_standard_handlers(
+    SmartDomain::Event::Registration.register_standard_handlers(
       domain: '<%= file_name %>',
       events: %w[created updated deleted],
       include_audit: true,
@@ -19,8 +19,8 @@ module <%= domain_module_name %>
     # Example:
     #
     # email_handler = <%= class_name %>EmailHandler.new
-    # ActiveDomain::Event.bus.subscribe('<%= file_name %>.created', email_handler)
-    # ActiveDomain::Event.bus.subscribe('<%= file_name %>.updated', email_handler)
+    # SmartDomain::Event.bus.subscribe('<%= file_name %>.created', email_handler)
+    # SmartDomain::Event.bus.subscribe('<%= file_name %>.updated', email_handler)
 
     Rails.logger.info "[<%= domain_module_name %>] Domain setup complete"
   end

data/lib/generators/{active_domain → smart_domain}/install/install_generator.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "rails/generators"
+require 'rails/generators'
 
 module SmartDomain
   module Generators
@@ -16,42 +16,42 @@ module SmartDomain
     #   - app/handlers/ directory
     #   - app/policies/ directory
     class InstallGenerator < Rails::Generators::Base
-      source_root File.expand_path("templates", __dir__)
+      source_root File.expand_path('templates', __dir__)
 
-      desc "Install SmartDomain into your Rails application"
+      desc 'Install SmartDomain into your Rails application'
 
       # Create initializer
       def create_initializer
-        template "initializer.rb", "config/initializers/smart_domain.rb"
+        template 'initializer.rb', 'config/initializers/smart_domain.rb'
       end
 
       # Create directory structure
       def create_directory_structure
-        create_file "app/domains/.keep"
-        create_file "app/events/.keep"
-        create_file "app/handlers/.keep"
-        create_file "app/policies/.keep"
-        create_file "app/services/.keep"
+        create_file 'app/domains/.keep'
+        create_file 'app/events/.keep'
+        create_file 'app/handlers/.keep'
+        create_file 'app/policies/.keep'
+        create_file 'app/services/.keep'
       end
 
       # Create base event class
       def create_application_event
-        template "application_event.rb", "app/events/application_event.rb"
+        template 'application_event.rb', 'app/events/application_event.rb'
       end
 
       # Create base policy class
       def create_application_policy
-        template "application_policy.rb", "app/policies/application_policy.rb"
+        template 'application_policy.rb', 'app/policies/application_policy.rb'
       end
 
       # Create base service class
       def create_application_service
-        template "application_service.rb", "app/services/application_service.rb"
+        template 'application_service.rb', 'app/services/application_service.rb'
       end
 
       # Show post-install message
       def show_readme
-        readme "README" if behavior == :invoke
+        readme 'README' if behavior == :invoke
       end
     end
   end

data/lib/smart_domain/configuration.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "logger"
+require 'logger'
 
 module SmartDomain
   # Configuration for SmartDomain gem.

data/lib/smart_domain/domain/exceptions.rb

@@ -84,7 +84,7 @@ module SmartDomain
     #   )
     class BusinessRuleError < Error
       def initialize(message, code: :business_rule_violation, details: {})
-        super(message, code: code, details: details)
+        super
       end
     end
 
@@ -134,7 +134,7 @@ module SmartDomain
     #     'User does not have permission to delete this resource'
     #   )
     class UnauthorizedError < Error
-      def initialize(message = "Unauthorized", action: nil, resource: nil)
+      def initialize(message = 'Unauthorized', action: nil, resource: nil)
         super(
           message,
           code: :unauthorized,

data/lib/smart_domain/domain/service.rb

@@ -150,7 +150,7 @@ module SmartDomain
         attributes[:organization_id] ||= current_organization_id
 
         # Auto-fill actor fields if event includes ActorMixin
-        if event_class.instance_methods.include?(:actor_id)
+        if event_class.method_defined?(:actor_id)
           attributes[:actor_id] ||= current_user_id&.to_s
           attributes[:actor_email] ||= current_user&.email
         end

data/lib/smart_domain/event/adapters/memory.rb

@@ -18,7 +18,10 @@ module SmartDomain
       class Memory
         def initialize
           @handlers = Hash.new { |h, k| h[k] = [] }
-          @logger = ActiveSupport::TaggedLogging.new(Logger.new($stdout))
+        end
+
+        def logger
+          @logger ||= SmartDomain.configuration.logger
         end
 
         # Subscribe a handler to an event type
@@ -30,16 +33,30 @@ module SmartDomain
 
         # Publish an event to all subscribed handlers
         # @param event [SmartDomain::Event::Base] Event to publish
+        # @raise [ValidationError] If event is invalid
         def publish(event)
+          # Validate event before publishing
+          unless event.is_a?(SmartDomain::Event::Base)
+            raise SmartDomain::Event::ValidationError, 'Event must be a SmartDomain::Event::Base'
+          end
+
+          begin
+            unless event.valid?
+              raise SmartDomain::Event::ValidationError, "Invalid event: #{event.errors.full_messages.join(', ')}"
+            end
+          rescue NoMethodError => e
+            raise SmartDomain::Event::ValidationError, "Malformed event: #{e.message}"
+          end
+
           # Find all matching handlers (exact match + wildcard patterns)
           matching_handlers = find_matching_handlers(event.event_type)
 
           if matching_handlers.empty?
-            @logger.debug "[SmartDomain::Memory] No handlers for event type: #{event.event_type}"
+            logger.debug "[SmartDomain::Memory] No handlers for event type: #{event.event_type}"
             return
           end
 
-          @logger.debug "[SmartDomain::Memory] Notifying #{matching_handlers.size} handler(s) for #{event.event_type}"
+          logger.debug "[SmartDomain::Memory] Notifying #{matching_handlers.size} handler(s) for #{event.event_type}"
 
           matching_handlers.each do |handler|
             handle_event(handler, event)
@@ -69,9 +86,7 @@ module SmartDomain
           handlers = []
 
           @handlers.each do |pattern, pattern_handlers|
-            if event_type_matches?(event_type, pattern)
-              handlers.concat(pattern_handlers)
-            end
+            handlers.concat(pattern_handlers) if event_type_matches?(event_type, pattern)
           end
 
           handlers.uniq
@@ -86,7 +101,7 @@ module SmartDomain
           return true if event_type == pattern
 
           # Wildcard pattern match (e.g., "user.*" matches "user.created")
-          if pattern.end_with?(".*")
+          if pattern.end_with?('.*')
             prefix = pattern[0..-3] # Remove ".*"
             return event_type.start_with?("#{prefix}.")
           end
@@ -100,8 +115,8 @@ module SmartDomain
         def handle_event(handler, event)
           handler.handle(event)
         rescue StandardError => e
-          @logger.error "[SmartDomain::Memory] Handler #{handler.class.name} failed: #{e.message}"
-          @logger.error e.backtrace.join("\n")
+          logger.error "[SmartDomain::Memory] Error in event handler #{handler.class.name}: #{e.message}"
+          logger.error e.backtrace.join("\n")
           # Swallow exception to not affect other handlers
         end
       end

data/lib/smart_domain/event/base.rb

@@ -1,12 +1,15 @@
 # frozen_string_literal: true
 
-require "active_model"
-require "active_support/core_ext/object/blank"
-require "securerandom"
-require "logger"
+require 'active_model'
+require 'active_support/core_ext/object/blank'
+require 'securerandom'
+require 'logger'
 
 module SmartDomain
   module Event
+    # Validation error for domain events
+    class ValidationError < StandardError; end
+
     # Base class for all domain events in the system.
     #
     # Domain events represent significant business occurrences that other
@@ -58,7 +61,9 @@ module SmartDomain
       def initialize(attributes = {})
         super
         freeze_event
-        validate!
+        return if valid?
+
+        raise ValidationError, "Event validation failed: #{errors.full_messages.join(', ')}"
       end
 
       # Convert event to hash
@@ -101,13 +106,16 @@ module SmartDomain
     #   event = UserCreatedEvent.new(...)
     #   bus.publish(event)
     class Bus
-      attr_reader :adapter, :logger
+      attr_reader :adapter
 
       # Initialize event bus with optional adapter
       # @param adapter [Object, Symbol] Event bus adapter or adapter name (default: Memory adapter)
       def initialize(adapter: nil)
         @adapter = resolve_adapter(adapter)
-        @logger = ActiveSupport::TaggedLogging.new(Logger.new($stdout))
+      end
+
+      def logger
+        @logger ||= SmartDomain.configuration.logger
       end
 
       # Subscribe a handler to a specific event type
@@ -115,7 +123,7 @@ module SmartDomain
       # @param handler [Object] Handler object that responds to #handle(event)
       def subscribe(event_type, handler)
         @adapter.subscribe(event_type, handler)
-        @logger.info "[SmartDomain] Event handler subscribed: #{handler.class.name} -> #{event_type}"
+        logger.info "[SmartDomain] Event handler subscribed: #{handler.class.name} -> #{event_type}"
       end
 
       # Publish an event to all registered handlers
@@ -124,8 +132,8 @@ module SmartDomain
       def publish(event)
         validate_event!(event)
 
-        @logger.info "[SmartDomain] Publishing event: #{event.event_type} (#{event.event_id})"
-        @logger.debug "[SmartDomain] Event details: #{event.to_h}"
+        logger.info "[SmartDomain] Publishing event: #{event.event_type} (#{event.event_id})"
+        logger.debug "[SmartDomain] Event details: #{event.to_h}"
 
         @adapter.publish(event)
       end
@@ -149,15 +157,20 @@ module SmartDomain
 
       # Validate event before publishing
       # @param event [Object] Event to validate
-      # @raise [ArgumentError] If event is not valid
+      # @raise [ArgumentError] If event is not a Base instance
+      # @raise [ValidationError] If event validation fails
       def validate_event!(event)
         unless event.is_a?(Base)
           raise ArgumentError, "Event must be a SmartDomain::Event::Base, got #{event.class.name}"
         end
 
-        return if event.valid?
+        begin
+          return if event.valid?
 
-        raise ArgumentError, "Event validation failed: #{event.errors.full_messages.join(', ')}"
+          raise ValidationError, "Event validation failed: #{event.errors.full_messages.join(', ')}"
+        rescue NoMethodError => e
+          raise ValidationError, "Malformed event: #{e.message}"
+        end
       end
     end