smart_domain 0.1.0

data/examples/blog_app/app/domains/post_management/events/post_created_event.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# Event published when a post is created
+class PostCreatedEvent < ApplicationEvent
+  include SmartDomain::Event::ActorMixin
+
+  attribute :post_id, :string
+
+  validates :post_id, presence: true
+
+  # Add domain-specific attributes here
+  # Example:
+  # attribute :email, :string
+  # attribute :name, :string
+end

data/examples/blog_app/app/domains/post_management/events/post_deleted_event.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+# Event published when a post is deleted
+class PostDeletedEvent < ApplicationEvent
+  include SmartDomain::Event::ActorMixin
+
+  attribute :post_id, :string
+
+  validates :post_id, presence: true
+
+  # Add domain-specific attributes here if needed
+  # These should be attributes you want to preserve after deletion
+end

data/examples/blog_app/app/domains/post_management/events/post_updated_event.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+# Event published when a post is updated
+class PostUpdatedEvent < ApplicationEvent
+  include SmartDomain::Event::ActorMixin
+  include SmartDomain::Event::ChangeTrackingMixin
+
+  attribute :post_id, :string
+
+  validates :post_id, presence: true
+
+  # Add domain-specific attributes here if needed
+end

data/examples/blog_app/app/domains/post_management/handlers/post_notification_handler.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# Custom event handler for notifying subscribers when posts are published
+#
+# This handler demonstrates conditional handling based on event data.
+class PostNotificationHandler < SmartDomain::Event::Handler
+  def can_handle?(event_type)
+    event_type == "post.updated"
+  end
+
+  def handle(event)
+    # Only send notifications if the post was just published
+    if post_was_published?(event)
+      Rails.logger.info "[PostNotificationHandler] Post '#{event.post_id}' was published!"
+      Rails.logger.info "[PostNotificationHandler] Would notify subscribers here"
+
+      # In a real application, this would:
+      # - Find all subscribers
+      # - Send push notifications
+      # - Send email digests
+      # - Update RSS feeds
+    end
+  end
+
+  private
+
+  def post_was_published?(event)
+    # Check if 'published' changed from false to true
+    event.respond_to?(:changed_fields) &&
+      event.changed_fields.include?("published") &&
+      event.new_values["published"] == true
+  end
+end

data/examples/blog_app/app/domains/post_management/models/post.rb

@@ -0,0 +1,21 @@
+class Post < ApplicationRecord
+  include SmartDomain::Integration::ActiveRecord
+  include SmartDomain::Integration::TenantScoped
+
+  belongs_to :organization
+  belongs_to :user
+
+  validates :title, presence: true
+  validates :body, presence: true
+
+  scope :published, -> { where(published: true) }
+  scope :draft, -> { where(published: false) }
+
+  def publish!
+    update!(published: true, published_at: Time.current)
+  end
+
+  def unpublish!
+    update!(published: false, published_at: nil)
+  end
+end

data/examples/blog_app/app/domains/post_management/policies/post_policy.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+# Authorization policy for Post
+#
+# Define authorization rules for post operations.
+# These methods are called from services and controllers.
+class PostPolicy < ApplicationPolicy
+  # Can user view list of posts?
+  def index?
+    user_present?
+  end
+
+  # Can user view this post?
+  def show?
+    user_present? && (admin? || same_organization?)
+  end
+
+  # Can user create a post?
+  def create?
+    user_present?
+  end
+
+  # Can user update this post?
+  def update?
+    user_present? && (admin? || owner? || same_organization?)
+  end
+
+  # Can user delete this post?
+  def destroy?
+    user_present? && (admin? || owner?)
+  end
+
+  # Scope for index queries
+  #
+  # Returns only posts the user is authorized to see
+  class Scope < Scope
+    def resolve
+      if user.nil?
+        scope.none
+      elsif user.respond_to?(:admin?) && user.admin?
+        scope.all
+      elsif user.respond_to?(:organization_id)
+        scope.where(organization_id: user.organization_id)
+      else
+        scope.where(user_id: user.id)
+      end
+    end
+  end
+end

data/examples/blog_app/app/domains/post_management/post_service.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module PostManagement
+  # Service for Post business logic
+  #
+  # This service encapsulates all business operations for posts.
+  # Controllers should delegate to this service rather than directly
+  # manipulating Post models.
+  class PostService < ApplicationService
+    # Create a new post
+    #
+    # @param attributes [Hash] Post attributes
+    # @return [Post] Created post
+    # @raise [SmartDomain::Domain::AlreadyExistsError] If post already exists
+    # @raise [SmartDomain::Domain::ValidationError] If validation fails
+    def create_post(attributes)
+      # Example business rule validation
+      # if Post.exists?(email: attributes[:email])
+      #   raise SmartDomain::Domain::AlreadyExistsError.new('Post', 'email', attributes[:email])
+      # end
+
+      Post.transaction do
+        post = Post.create!(attributes)
+
+        # Event is published via ActiveRecord integration
+        # Or manually:
+        # event = build_event(PostCreatedEvent,
+        #   event_type: 'post.created',
+        #   aggregate_id: post.id,
+        #   aggregate_type: 'Post',
+        #   post_id: post.id
+        # )
+        # publish_after_commit(event)
+
+        log(:info, "Post created", post_id: post.id)
+        post
+      end
+    end
+
+    # Update an existing post
+    #
+    # @param post [Post, Integer, String] Post object or ID
+    # @param attributes [Hash] Attributes to update
+    # @return [Post] Updated post
+    # @raise [ActiveRecord::RecordNotFound] If post not found
+    # @raise [SmartDomain::Domain::UnauthorizedError] If not authorized
+    def update_post(post, attributes)
+      post = Post.find(post) unless post.is_a?(Post)
+
+      # Authorization check
+      policy = PostPolicy.new(current_user, post)
+      authorize!(policy, :update?)
+
+      Post.transaction do
+        post.update!(attributes)
+
+        # Event published via ActiveRecord integration
+        log(:info, "Post updated", post_id: post.id, changes: post.saved_changes.keys)
+        post
+      end
+    end
+
+    # Delete a post
+    #
+    # @param post [Post, Integer, String] Post object or ID
+    # @return [Boolean] True if deleted
+    # @raise [ActiveRecord::RecordNotFound] If post not found
+    # @raise [SmartDomain::Domain::UnauthorizedError] If not authorized
+    def delete_post(post)
+      post = Post.find(post) unless post.is_a?(Post)
+
+      # Authorization check
+      policy = PostPolicy.new(current_user, post)
+      authorize!(policy, :destroy?)
+
+      Post.transaction do
+        post.destroy!
+
+        # Event published via ActiveRecord integration
+        log(:info, "Post deleted", post_id: post.id)
+        true
+      end
+    end
+
+    # List posts with policy scope
+    #
+    # @param scope [ActiveRecord::Relation] Optional base scope
+    # @return [ActiveRecord::Relation] Scoped posts
+    def list_posts(scope = Post.all)
+      policy_scope(scope, PostPolicy)
+    end
+  end
+end

data/examples/blog_app/app/domains/post_management/setup.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module PostManagement
+  # Setup event handlers for post domain
+  #
+  # 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!
+    SmartDomain::Event::Registration.register_standard_handlers(
+      domain: 'post',
+      events: %w[created updated deleted],
+      include_audit: true,
+      include_metrics: true
+    )
+
+    # Register custom handlers
+    notification_handler = PostNotificationHandler.new
+    SmartDomain::Event.bus.subscribe('post.updated', notification_handler)
+
+    Rails.logger.info "[PostManagement] Domain setup complete"
+    Rails.logger.info "[PostManagement] Registered handlers: audit, metrics, notifications"
+  end
+end

data/examples/blog_app/app/domains/user_management/events/user_created_event.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# Event published when a user is created
+class UserCreatedEvent < ApplicationEvent
+  include SmartDomain::Event::ActorMixin
+
+  attribute :user_id, :string
+
+  validates :user_id, presence: true
+
+  # Add domain-specific attributes here
+  # Example:
+  # attribute :email, :string
+  # attribute :name, :string
+end

data/examples/blog_app/app/domains/user_management/events/user_deleted_event.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+# Event published when a user is deleted
+class UserDeletedEvent < ApplicationEvent
+  include SmartDomain::Event::ActorMixin
+
+  attribute :user_id, :string
+
+  validates :user_id, presence: true
+
+  # Add domain-specific attributes here if needed
+  # These should be attributes you want to preserve after deletion
+end

data/examples/blog_app/app/domains/user_management/events/user_updated_event.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+# Event published when a user is updated
+class UserUpdatedEvent < ApplicationEvent
+  include SmartDomain::Event::ActorMixin
+  include SmartDomain::Event::ChangeTrackingMixin
+
+  attribute :user_id, :string
+
+  validates :user_id, presence: true
+
+  # Add domain-specific attributes here if needed
+end

data/examples/blog_app/app/domains/user_management/handlers/user_welcome_handler.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: truell
+
+# Custom event handler for sending welcome emails
+#
+# This handler demonstrates how to create custom domain-specific handlers
+# that respond to specific events and trigger side effects.
+class UserWelcomeHandler < SmartDomain::Event::Handler
+  def can_handle?(event_type)
+    event_type == "user.created"
+  end
+
+  def handle(event)
+    Rails.logger.info "[UserWelcomeHandler] Sending welcome email to #{event.email}"
+
+    # In a real application, this would call a mailer:
+    # UserMailer.welcome_email(event.user_id).deliver_later
+
+    # For this example, we'll just log
+    Rails.logger.info "[UserWelcomeHandler] Welcome email sent to #{event.email}"
+  end
+end

data/examples/blog_app/app/domains/user_management/models/user.rb

@@ -0,0 +1,11 @@
+class User < ApplicationRecord
+  include SmartDomain::Integration::ActiveRecord
+  include SmartDomain::Integration::TenantScoped
+
+  belongs_to :organization
+  has_many :posts, dependent: :destroy
+
+  validates :email, presence: true, uniqueness: { scope: :organization_id }
+  validates :name, presence: true
+  validates :role, inclusion: { in: %w[admin editor viewer] }
+end

data/examples/blog_app/app/domains/user_management/policies/user_policy.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+# Authorization policy for User
+#
+# Define authorization rules for user operations.
+# These methods are called from services and controllers.
+class UserPolicy < ApplicationPolicy
+  # Can user view list of users?
+  def index?
+    user_present?
+  end
+
+  # Can user view this user?
+  def show?
+    user_present? && (admin? || same_organization?)
+  end
+
+  # Can user create a user?
+  def create?
+    user_present?
+  end
+
+  # Can user update this user?
+  def update?
+    user_present? && (admin? || owner? || same_organization?)
+  end
+
+  # Can user delete this user?
+  def destroy?
+    user_present? && (admin? || owner?)
+  end
+
+  # Scope for index queries
+  #
+  # Returns only users the user is authorized to see
+  class Scope < Scope
+    def resolve
+      if user.nil?
+        scope.none
+      elsif user.respond_to?(:admin?) && user.admin?
+        scope.all
+      elsif user.respond_to?(:organization_id)
+        scope.where(organization_id: user.organization_id)
+      else
+        scope.where(user_id: user.id)
+      end
+    end
+  end
+end

data/examples/blog_app/app/domains/user_management/setup.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module UserManagement
+  # Setup event handlers for user domain
+  #
+  # 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!
+    SmartDomain::Event::Registration.register_standard_handlers(
+      domain: 'user',
+      events: %w[created updated deleted],
+      include_audit: true,
+      include_metrics: true
+    )
+
+    # Register custom handlers
+    welcome_handler = UserWelcomeHandler.new
+    SmartDomain::Event.bus.subscribe('user.created', welcome_handler)
+
+    Rails.logger.info "[UserManagement] Domain setup complete"
+    Rails.logger.info "[UserManagement] Registered handlers: audit, metrics, welcome email"
+  end
+end

data/examples/blog_app/app/domains/user_management/user_service.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module UserManagement
+  # Service for User business logic
+  #
+  # This service encapsulates all business operations for users.
+  # Controllers should delegate to this service rather than directly
+  # manipulating User models.
+  class UserService < ApplicationService
+    # Create a new user
+    #
+    # @param attributes [Hash] User attributes
+    # @return [User] Created user
+    # @raise [SmartDomain::Domain::AlreadyExistsError] If user already exists
+    # @raise [SmartDomain::Domain::ValidationError] If validation fails
+    def create_user(attributes)
+      # Example business rule validation
+      # if User.exists?(email: attributes[:email])
+      #   raise SmartDomain::Domain::AlreadyExistsError.new('User', 'email', attributes[:email])
+      # end
+
+      User.transaction do
+        user = User.create!(attributes)
+
+        # Event is published via ActiveRecord integration
+        # Or manually:
+        # event = build_event(UserCreatedEvent,
+        #   event_type: 'user.created',
+        #   aggregate_id: user.id,
+        #   aggregate_type: 'User',
+        #   user_id: user.id
+        # )
+        # publish_after_commit(event)
+
+        log(:info, "User created", user_id: user.id)
+        user
+      end
+    end
+
+    # Update an existing user
+    #
+    # @param user [User, Integer, String] User object or ID
+    # @param attributes [Hash] Attributes to update
+    # @return [User] Updated user
+    # @raise [ActiveRecord::RecordNotFound] If user not found
+    # @raise [SmartDomain::Domain::UnauthorizedError] If not authorized
+    def update_user(user, attributes)
+      user = User.find(user) unless user.is_a?(User)
+
+      # Authorization check
+      policy = UserPolicy.new(current_user, user)
+      authorize!(policy, :update?)
+
+      User.transaction do
+        user.update!(attributes)
+
+        # Event published via ActiveRecord integration
+        log(:info, "User updated", user_id: user.id, changes: user.saved_changes.keys)
+        user
+      end
+    end
+
+    # Delete a user
+    #
+    # @param user [User, Integer, String] User object or ID
+    # @return [Boolean] True if deleted
+    # @raise [ActiveRecord::RecordNotFound] If user not found
+    # @raise [SmartDomain::Domain::UnauthorizedError] If not authorized
+    def delete_user(user)
+      user = User.find(user) unless user.is_a?(User)
+
+      # Authorization check
+      policy = UserPolicy.new(current_user, user)
+      authorize!(policy, :destroy?)
+
+      User.transaction do
+        user.destroy!
+
+        # Event published via ActiveRecord integration
+        log(:info, "User deleted", user_id: user.id)
+        true
+      end
+    end
+
+    # List users with policy scope
+    #
+    # @param scope [ActiveRecord::Relation] Optional base scope
+    # @return [ActiveRecord::Relation] Scoped users
+    def list_users(scope = User.all)
+      policy_scope(scope, UserPolicy)
+    end
+  end
+end

data/examples/blog_app/app/events/application_event.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+# Base class for all domain events in this application
+#
+# Inherit from this class to create domain-specific events
+#
+# Example:
+#   class UserCreatedEvent < ApplicationEvent
+#     attribute :user_id, :string
+#     attribute :email, :string
+#     validates :user_id, :email, presence: true
+#   end
+class ApplicationEvent < SmartDomain::Event::Base
+  # Add application-wide event fields here
+  # Example:
+  # attribute :tenant_id, :string
+  # validates :tenant_id, presence: true
+end

data/examples/blog_app/app/helpers/application_helper.rb

@@ -0,0 +1,2 @@
+module ApplicationHelper
+end

data/examples/blog_app/app/javascript/application.js

@@ -0,0 +1,3 @@
+// Configure your import map in config/importmap.rb. Read more: https://github.com/rails/importmap-rails
+import "@hotwired/turbo-rails"
+import "controllers"

data/examples/blog_app/app/javascript/controllers/application.js

@@ -0,0 +1,9 @@
+import { Application } from "@hotwired/stimulus"
+
+const application = Application.start()
+
+// Configure Stimulus development experience
+application.debug = false
+window.Stimulus   = application
+
+export { application }

data/examples/blog_app/app/javascript/controllers/hello_controller.js

@@ -0,0 +1,7 @@
+import { Controller } from "@hotwired/stimulus"
+
+export default class extends Controller {
+  connect() {
+    this.element.textContent = "Hello World!"
+  }
+}

data/examples/blog_app/app/javascript/controllers/index.js

@@ -0,0 +1,4 @@
+// Import and register all your controllers from the importmap via controllers/**/*_controller
+import { application } from "controllers/application"
+import { eagerLoadControllersFrom } from "@hotwired/stimulus-loading"
+eagerLoadControllersFrom("controllers", application)

data/examples/blog_app/app/jobs/application_job.rb

@@ -0,0 +1,7 @@
+class ApplicationJob < ActiveJob::Base
+  # Automatically retry jobs that encountered a deadlock
+  # retry_on ActiveRecord::Deadlocked
+
+  # Most jobs are safe to ignore if the underlying records are no longer available
+  # discard_on ActiveJob::DeserializationError
+end

data/examples/blog_app/app/mailers/application_mailer.rb

@@ -0,0 +1,4 @@
+class ApplicationMailer < ActionMailer::Base
+  default from: "from@example.com"
+  layout "mailer"
+end

data/examples/blog_app/app/models/application_record.rb

@@ -0,0 +1,3 @@
+class ApplicationRecord < ActiveRecord::Base
+  primary_abstract_class
+end

data/examples/blog_app/app/models/organization.rb

@@ -0,0 +1,6 @@
+class Organization < ApplicationRecord
+  has_many :users, dependent: :destroy
+  has_many :posts, dependent: :destroy
+
+  validates :name, presence: true, uniqueness: true
+end

data/examples/blog_app/app/policies/application_policy.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+# Base class for all domain policies in this application
+#
+# Inherit from this class to create domain-specific policies
+#
+# Example:
+#   class UserPolicy < ApplicationPolicy
+#     def update?
+#       user.admin? || owner?
+#     end
+#
+#     def destroy?
+#       user.admin?
+#     end
+#   end
+class ApplicationPolicy < SmartDomain::Domain::Policy
+  # Add application-wide policy methods here
+  # Example:
+  # def manager?
+  #   user.present? && user.role == 'manager'
+  # end
+end

data/examples/blog_app/app/services/application_service.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+# Base class for all domain services in this application
+#
+# Inherit from this class to create domain-specific services
+#
+# Example:
+#   class UserService < ApplicationService
+#     def create_user(attributes)
+#       User.transaction do
+#         user = User.create!(attributes)
+#         event = build_event(UserCreatedEvent, ...)
+#         publish_after_commit(event)
+#         user
+#       end
+#     end
+#   end
+class ApplicationService < SmartDomain::Domain::Service
+  # Add application-wide service methods here
+  # Example:
+  # def current_organization
+  #   @current_organization ||= Organization.find(current_organization_id)
+  # end
+end