seams 0.1.0

data/lib/generators/seams/install/templates/rubocop.yml.tt

@@ -0,0 +1,33 @@
+# Host application RuboCop config.
+#
+# Engines under engines/<name>/ ship their own self-contained
+# .rubocop.yml — they do NOT inherit from this file (this is
+# intentional so a host using rubocop-rails-omakase doesn't force
+# engine code through application-style rules).
+#
+# Add your own host rules here; the engine boundary cops are loaded
+# per-engine via engines/<name>/.rubocop.yml, not globally.
+
+AllCops:
+  TargetRubyVersion: 4.0
+  NewCops: enable
+  SuggestExtensions: false
+  Exclude:
+    - "bin/**/*"
+    - "db/schema.rb"
+    - "tmp/**/*"
+    - "vendor/**/*"
+    - "engines/**/*"          # engines lint themselves
+    - "lib/tasks/seams.rake"  # gem-generated; uses default rubocop array style
+
+Style/Documentation:
+  Enabled: false
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Layout/LineLength:
+  Max: 120
+
+Metrics/MethodLength:
+  Max: 25

data/lib/generators/seams/install/templates/ruby-version.tt

@@ -0,0 +1 @@
+4.0.3

data/lib/generators/seams/install/templates/script/collate_coverage.rb.tt

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# Aggregates SimpleCov result files from every engine spec run into
+# one combined report at coverage/.
+#
+# Each engine writes its own coverage/.resultset.json when its specs
+# run. CI runs the engines in parallel (each on its own dummy app), so
+# we end up with N partial reports. SimpleCov.collate merges them.
+#
+# Usage:
+#
+#   bin/rails seams:test         # writes per-engine coverage/.resultset.json
+#   ruby script/collate_coverage.rb
+#   open coverage/index.html
+#
+# Idempotent — re-running overwrites the merged report.
+require "simplecov"
+
+# Glob every engine's resultset, plus the host's, into one collation.
+result_files = Dir.glob("engines/*/coverage/.resultset.json")
+result_files << "coverage/.resultset.json" if File.exist?("coverage/.resultset.json")
+
+if result_files.empty?
+  warn "No coverage/.resultset.json files found. Run specs first."
+  exit 1
+end
+
+puts "Collating #{result_files.size} resultset(s)..."
+SimpleCov.collate(result_files) do
+  formatter SimpleCov::Formatter::HTMLFormatter
+end
+
+puts "Merged report: coverage/index.html"

data/lib/generators/seams/install/templates/script/run_affected_tests.sh.tt

@@ -0,0 +1,64 @@
+#!/usr/bin/env bash
+# Detects which engines changed vs the merge base with `main` and runs
+# only those engines' specs. Falls back to running every engine when
+# the diff is empty (a noop branch) or when invoked with --all.
+#
+# Usage:
+#
+#   script/run_affected_tests.sh            # diff against main
+#   script/run_affected_tests.sh --all      # run every engine
+#   BASE_BRANCH=develop script/run_affected_tests.sh
+#
+# Exit code is the OR of every engine spec run — first failure aborts.
+
+set -euo pipefail
+
+BASE_BRANCH="${BASE_BRANCH:-main}"
+RUN_ALL=0
+
+if [[ "${1:-}" == "--all" ]]; then
+  RUN_ALL=1
+fi
+
+# Resolve the merge base so we ignore commits already on main.
+merge_base="$(git merge-base "$BASE_BRANCH" HEAD 2>/dev/null || echo "")"
+if [[ -z "$merge_base" ]]; then
+  echo "Could not resolve merge base with $BASE_BRANCH — running all engines."
+  RUN_ALL=1
+fi
+
+if [[ "$RUN_ALL" == "1" ]]; then
+  changed_engines=$(ls -1 engines/ 2>/dev/null || true)
+else
+  changed_engines=$(git diff --name-only "$merge_base" HEAD -- 'engines/*' \
+                      | awk -F/ '{print $2}' | sort -u)
+fi
+
+if [[ -z "$changed_engines" ]]; then
+  echo "No engines changed since $BASE_BRANCH. Nothing to test."
+  exit 0
+fi
+
+echo "Engines to test:"
+echo "$changed_engines" | sed 's/^/  - /'
+echo
+
+failed=()
+for engine in $changed_engines; do
+  if [[ ! -d "engines/$engine" ]]; then
+    continue
+  fi
+  echo "=== running engines/$engine specs ==="
+  if ! bundle exec rspec "engines/$engine/spec"; then
+    failed+=("$engine")
+  fi
+done
+
+if (( ${#failed[@]} > 0 )); then
+  echo
+  echo "Failed engines: ${failed[*]}"
+  exit 1
+fi
+
+echo
+echo "All affected engine specs passed."

data/lib/generators/seams/install/templates/seams.rake.tt

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+namespace :seams do
+  ENGINE_NAME_PATTERN = /\A[a-z][a-z0-9_]*\z/
+
+  desc "List installed engines, the events they emit, and their dependencies"
+  task list: :environment do
+    require "seams/cli/list"
+    Seams::CLI::List.new.call
+  end
+
+  desc "Run RSpec for a single engine: rake seams:test[billing]"
+  task :test, [:engine] => :environment do |_t, args|
+    name = args[:engine] or abort("Usage: rake seams:test[billing]")
+    abort("Invalid engine name: #{name.inspect}") unless ENGINE_NAME_PATTERN.match?(name)
+    # Array form: no shell interpolation, no injection.
+    sh "bundle", "exec", "rspec", "engines/#{name}/spec"
+  end
+
+  desc "Run RuboCop for a single engine: rake seams:quality[billing]"
+  task :quality, [:engine] => :environment do |_t, args|
+    name = args[:engine] or abort("Usage: rake seams:quality[billing]")
+    abort("Invalid engine name: #{name.inspect}") unless ENGINE_NAME_PATTERN.match?(name)
+    sh "bundle", "exec", "rubocop", "engines/#{name}"
+  end
+
+  namespace :test do
+    desc "Run specs only for engines changed vs $BASE (default: main)"
+    task changed: :environment do
+      require "seams/cli"
+      base = ENV.fetch("BASE", "main")
+      abort("seams:test:changed failed.") unless Seams::CLI.test_changed(base: base)
+    end
+  end
+
+  namespace :quality do
+    desc "Aggregate RuboCop + Brakeman + bundle-audit + SimpleCov collation across the host"
+    task all: :environment do
+      require "seams/cli"
+      abort("seams:quality:all reported failures.") unless Seams::CLI.quality
+    end
+  end
+
+  desc "Pre-push verification: rubocop, host + per-engine specs, brakeman, bundle-audit, orphan-event check"
+  task audit: :environment do
+    Rake::Task["environment"].invoke
+    sh "bundle", "exec", "rubocop", "--parallel"
+    sh "bundle", "exec", "rspec", "spec"
+    Dir["engines/*"].select { |d| File.directory?(d) }.sort.each do |dir|
+      next if Dir.glob("#{dir}/spec/**/*_spec.rb").empty?
+
+      engine_name = File.basename(dir)
+      sh "bundle", "exec", "rspec",
+         "--default-path", "engines/#{engine_name}/spec",
+         "engines/#{engine_name}/spec"
+    end
+    sh "bundle", "exec", "brakeman", "--no-pager", "--no-progress", "--quiet"
+    sh "bundle", "exec", "bundle-audit", "check", "--update"
+
+    orphans = Seams::Events::Publisher.orphan_subscriptions
+    abort "orphan event subscriptions detected: #{orphans.inspect}" unless orphans.empty?
+
+    puts "All audit checks passed."
+  end
+end

data/lib/generators/seams/install/templates/seams.rb.tt

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+# Seams configuration. Both adapters can be replaced with custom
+# implementations — see https://github.com/Davidslv/seams for details.
+Seams.configure do |config|
+  config.event_bus_adapter      = "Seams::Events::Adapters::ActiveSupport"
+  config.observability_adapter  = "Seams::Observability::Adapters::RailsLogger"
+  config.host_app_name          = (Rails.application.class.module_parent_name rescue nil)
+end

data/lib/generators/seams/install/templates/seams_engines.rb.tt

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# Load every engine under engines/ as if it were a Gemfile entry. Must
+# run before Rails.application.initialize! so each engine's Railtie
+# registers its initializers + paths (db/migrate, app/*) with the host.
+# Required from config/application.rb after Bundler.require.
+Dir[File.expand_path("../engines/*", __dir__)].sort.each do |engine_path|
+  next unless File.directory?(engine_path)
+
+  $LOAD_PATH.unshift File.join(engine_path, "lib")
+
+  engine_name = File.basename(engine_path)
+  main = File.join(engine_path, "lib", "#{engine_name}.rb")
+  require engine_name if File.exist?(main)
+end

data/lib/generators/seams/notifications/notifications_generator.rb

@@ -0,0 +1,395 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "rails/generators"
+require "seams"
+require "generators/seams/engine/engine_generator"
+require "seams/generators/host_injector"
+require "seams/generators/eject_aware"
+require "seams/generators/dummy_app_writer"
+
+module Seams
+  module Generators
+    # Generates a canonical Notifications engine on top of the generic
+    # engine scaffold.
+    #
+    # Notifications uses STI: a single +Notifications::Notification+
+    # base with three concrete subclasses under +Strategies+ — InApp,
+    # Email, Sms — each implementing its own +#dispatch!+. The
+    # schedule lives in a jsonb column populated by ice_cube;
+    # +next_delivery_at+ is the indexed cache the recurring sweeper
+    # reads from.
+    #
+    # Run with: bin/rails generate seams:notifications
+    # rubocop:disable Metrics/ClassLength
+    class NotificationsGenerator < Rails::Generators::Base
+      include Seams::Generators::HostInjector
+      include Seams::Generators::EjectAware
+
+      source_root File.expand_path("templates", __dir__)
+
+      ENGINE_NAME      = "notifications"
+      DEFAULT_CHANNELS = %w[in_app email sms].freeze
+      BILLING_TEMPLATES = %w[
+        subscription_started
+        subscription_updated
+        subscription_canceled
+        invoice_paid
+        invoice_failed
+        lifetime_granted
+        lifetime_purchased
+      ].freeze
+
+      class_option :channels, type: :string, default: "all",
+                              desc: "Comma-separated channels to enable: in_app,email,sms (or 'all')"
+
+      def create_base_engine
+        EngineGenerator.start([ENGINE_NAME], destination_root: destination_root)
+      end
+
+      def overwrite_engine_entry_point
+        # engine.rb stays framework-managed.
+        template "lib/engine.rb.tt", engine_path("lib/notifications/engine.rb"), force: true
+      end
+
+      def overwrite_routes
+        # Routes ship with an explicit Engine.routes.draw block — the
+        # generic engine scaffold leaves it empty, but notifications
+        # needs the canonical /notifications + /preferences surface +
+        # the Wave 10 `notifications.routes.after_preferences`
+        # insertion-point marker so follow-up generators can splice
+        # admin-side digest / opt-out routes.
+        template_unless_ejected "config/routes.rb.tt", engine_path("config/routes.rb"), force: true
+      end
+
+      def create_configuration
+        template_unless_ejected "lib/configuration.rb.tt",
+                                engine_path("lib/notifications/configuration.rb")
+        template_unless_ejected "lib/type_registry.rb.tt",
+                                engine_path("lib/notifications/type_registry.rb")
+        # lib/notifications.rb stays framework-managed (root require file).
+        template "lib/notifications.rb.tt", engine_path("lib/notifications.rb"), force: true
+      end
+
+      def create_adapters
+        template_unless_ejected "lib/adapters/abstract.rb.tt",
+                                engine_path("lib/notifications/adapters/abstract.rb")
+        template_unless_ejected "lib/adapters/action_mailer.rb.tt",
+                                engine_path("lib/notifications/adapters/action_mailer.rb")
+        # SMS adapter only ships when the sms channel is enabled.
+        return unless channels.include?("sms")
+
+        template_unless_ejected "lib/adapters/null_sms.rb.tt",
+                                engine_path("lib/notifications/adapters/null_sms.rb")
+      end
+
+      def create_concern
+        template_unless_ejected "lib/concerns/notifiable.rb.tt",
+                                engine_path("lib/notifications/concerns/notifiable.rb")
+      end
+
+      def create_models
+        template_unless_ejected "app/models/application_record.rb.tt",
+                                engine_path("app/models/notifications/application_record.rb")
+        template_unless_ejected "app/models/notification.rb.tt",
+                                engine_path("app/models/notifications/notification.rb")
+        template_unless_ejected "app/models/notification_preference.rb.tt",
+                                engine_path("app/models/notifications/notification_preference.rb")
+        template_unless_ejected "app/models/delivery.rb.tt",
+                                engine_path("app/models/notifications/delivery.rb")
+        create_strategy_models
+      end
+
+      def create_strategy_models
+        # STI strategy subclasses ship per --channels selection.
+        # STRATEGY_CLASSES in the Notifiable concern is conditionally
+        # rendered (in_app/email/sms) to match.
+        channels.each do |channel|
+          template_unless_ejected "app/models/strategies/#{channel}.rb.tt",
+                                  engine_path("app/models/notifications/strategies/#{channel}.rb")
+        end
+      end
+
+      def create_jobs
+        template_unless_ejected "app/jobs/application_job.rb.tt",
+                                engine_path("app/jobs/notifications/application_job.rb")
+        template_unless_ejected "app/jobs/send_due_notifications_job.rb.tt",
+                                engine_path("app/jobs/notifications/send_due_notifications_job.rb")
+        template_unless_ejected "app/jobs/send_notification_job.rb.tt",
+                                engine_path("app/jobs/notifications/send_notification_job.rb")
+        template_unless_ejected "app/jobs/create_notification_job.rb.tt",
+                                engine_path("app/jobs/notifications/create_notification_job.rb")
+      end
+
+      def create_subscriber
+        template_unless_ejected "app/subscribers/auth_subscriber.rb.tt",
+                                engine_path("app/subscribers/notifications/auth_subscriber.rb")
+        template_unless_ejected "app/subscribers/billing_subscriber.rb.tt",
+                                engine_path("app/subscribers/notifications/billing_subscriber.rb")
+      end
+
+      def create_controllers
+        template_unless_ejected "app/controllers/notifications_controller.rb.tt",
+                                engine_path("app/controllers/notifications/notifications_controller.rb")
+        template_unless_ejected "app/controllers/preferences_controller.rb.tt",
+                                engine_path("app/controllers/notifications/preferences_controller.rb")
+      end
+
+      def create_views
+        template_unless_ejected "app/views/notifications/_bell.html.erb.tt",
+                                engine_path("app/views/notifications/notifications/_bell.html.erb")
+        template_unless_ejected "app/views/notifications/index.html.erb.tt",
+                                engine_path("app/views/notifications/notifications/index.html.erb")
+      end
+
+      def create_channel_and_stimulus
+        template_unless_ejected "app/channels/notification_channel.rb.tt",
+                                engine_path("app/channels/notifications/notification_channel.rb")
+        template_unless_ejected "app/javascript/controllers/notification_bell_controller.js.tt",
+                                engine_path("app/javascript/notifications/controllers/notification_bell_controller.js")
+      end
+
+      def create_mailer
+        template_unless_ejected "app/mailers/application_mailer.rb.tt",
+                                engine_path("app/mailers/notifications/application_mailer.rb")
+        template_unless_ejected "app/mailers/notification_mailer.rb.tt",
+                                engine_path("app/mailers/notifications/notification_mailer.rb")
+      end
+
+      def create_default_templates
+        # Each notification template ships in two formats — .text.erb
+        # for SMS / plain-text email + .html.erb for HTML email and
+        # in-app rendering. Hosts override either or both by dropping
+        # files at app/views/notifications/templates/<name>.<format>.erb.
+        %i[text html].each do |format|
+          template_unless_ejected "app/views/templates/default.#{format}.erb.tt",
+                                  engine_path("app/views/notifications/templates/default.#{format}.erb")
+          template_unless_ejected "app/views/templates/welcome.#{format}.erb.tt",
+                                  engine_path("app/views/notifications/templates/welcome.#{format}.erb")
+          BILLING_TEMPLATES.each do |name|
+            template_unless_ejected "app/views/templates/billing/#{name}.#{format}.erb.tt",
+                                    engine_path("app/views/notifications/templates/billing/#{name}.#{format}.erb")
+          end
+        end
+
+        # Mailer layout — wraps every notification email so hosts get
+        # consistent header/footer chrome without per-template repetition.
+        template_unless_ejected "app/views/layouts/notifications/mailer.html.erb.tt",
+                                engine_path("app/views/layouts/notifications/mailer.html.erb")
+        template_unless_ejected "app/views/layouts/notifications/mailer.text.erb.tt",
+                                engine_path("app/views/layouts/notifications/mailer.text.erb")
+      end
+
+      def create_migrations
+        template "db/migrate/create_notifications.rb.tt",
+                 engine_path("db/migrate/#{timestamp(0)}_create_notifications.rb")
+        template "db/migrate/create_notification_preferences.rb.tt",
+                 engine_path("db/migrate/#{timestamp(1)}_create_notification_preferences.rb")
+        template "db/migrate/create_notification_deliveries.rb.tt",
+                 engine_path("db/migrate/#{timestamp(2)}_create_notification_deliveries.rb")
+      end
+
+      def create_specs
+        # Phase 2B finish — coverage for the engine's three core models.
+        template_unless_ejected "spec/factories/notifications.rb.tt",
+                                engine_path("spec/factories/notifications.rb")
+        template_unless_ejected "spec/models/notification_spec.rb.tt",
+                                engine_path("spec/models/notifications/notification_spec.rb")
+        template_unless_ejected "spec/models/delivery_spec.rb.tt",
+                                engine_path("spec/models/notifications/delivery_spec.rb")
+        template_unless_ejected "spec/models/notification_preference_spec.rb.tt",
+                                engine_path("spec/models/notifications/notification_preference_spec.rb")
+      end
+
+      def create_dummy_app
+        Seams::Generators::DummyAppWriter.write!(
+          engine_path: File.join(destination_root, "engines", ENGINE_NAME),
+          engine_module: "Notifications",
+          mount_at: "/notifications",
+          schema: dummy_schema,
+          host_user: dummy_host_user,
+          host_user_path: "app/models/auth/identity.rb"
+        )
+        # Wire the runtime spec templates into the generator output —
+        # they were orphaned in templates/ pre-Wave-12 (the integration
+        # test silently skipped them).
+        template "spec/runtime/boot_spec.rb.tt",
+                 engine_path("spec/runtime/notifications_boot_spec.rb")
+        template "spec/runtime/schedule_round_trip_spec.rb.tt",
+                 engine_path("spec/runtime/notifications_schedule_round_trip_spec.rb")
+        # The BillingSubscriber emits a deliberately-loud
+        # `notifications.billing_subscriber.skip` warn line when a
+        # billing event arrives without an `account_id` — that's the
+        # only signal a host operator gets that notifications are
+        # silently failing for that tenant. Spec it.
+        template "spec/runtime/billing_subscriber_skip_spec.rb.tt",
+                 engine_path("spec/runtime/notifications_billing_subscriber_skip_spec.rb")
+        # Phase 2B (3/3) — bell + ActionCable broadcast verification.
+        return unless channels.include?("in_app")
+
+        template "spec/runtime/bell_broadcast_spec.rb.tt",
+                 engine_path("spec/runtime/notifications_bell_broadcast_spec.rb")
+      end
+
+      def overwrite_readme
+        template "README.md.tt", engine_path("README.md"), force: true
+      end
+
+      def update_exposed_concerns
+        rubocop_path = engine_path(".rubocop.yml")
+        return unless File.exist?(rubocop_path)
+
+        contents = File.read(rubocop_path)
+        replacement = "  ExposedConcerns:\n    - Notifications::Notifiable"
+        contents.sub!(/^  ExposedConcerns: \[\]$/, replacement)
+        File.write(rubocop_path, contents)
+      end
+
+      def create_initializer
+        # Host-side initializer — documents the configure-adapters
+        # entry point AND the optional Notifiable concern include
+        # patterns. Wave 9 dropped the auto-include into the host
+        # User; hosts now opt in by uncommenting one of the patterns
+        # below (or leave the concern uninvoked — the polymorphic
+        # owner column doesn't require it).
+        template "config/initializers/notifications.rb.tt",
+                 File.join(destination_root, "config/initializers/notifications.rb")
+      end
+
+      def wire_into_host
+        host_inject_gem("ice_cube", ">= 0.16")
+        # factory_bot_rails powers the engine's spec/factories/*. Lives
+        # in the host's test group only.
+        host_inject_gem("factory_bot_rails", "~> 6.4", group: :test)
+        host_inject_mount(engine_class: "Notifications::Engine", at: "/notifications")
+        # Wave 9: no auto-include into a host User. The canonical demo
+        # has no host User after Wave 9 (the "human" is Auth::Identity).
+        # Hosts wire `Notifications::Notifiable` themselves via the
+        # initializer template — see config/initializers/notifications.rb.
+      end
+
+      def report_summary
+        say ""
+        say "  Notifications engine generated at engines/notifications/", :green
+        say ""
+        say "  Next steps:", :yellow
+        say "    1. bundle install   (picks up ice_cube)"
+        say "    2. bin/rails db:migrate"
+        say "    3. Schedule the sweeper. With Solid Queue, add to config/recurring.yml:"
+        say "         notifications_dispatcher:"
+        say "           class: Notifications::SendDueNotificationsJob"
+        say "           schedule: every minute"
+        say "    4. Configure adapters in config/initializers/notifications.rb"
+        say "    5. (optional) Include Notifications::Notifiable on Auth::Identity"
+        say "       via the same initializer — see the file's comments."
+        say ""
+        say "  Subscribed to: identity.signed_up.auth (creates an InApp + Email Notification)"
+        say ""
+      end
+
+      private
+
+      # Resolved list of channels the host opted into via --channels.
+      # "all" (or empty / unrecognised) → all three. Memoised per
+      # generator run so conditional template branches stay consistent.
+      def channels
+        @channels ||= begin
+          raw = options[:channels].to_s.downcase.strip
+          if raw.empty? || raw == "all"
+            DEFAULT_CHANNELS.dup
+          else
+            requested = raw.split(",").map(&:strip).reject(&:empty?)
+            allowed   = requested & DEFAULT_CHANNELS
+            allowed.empty? ? DEFAULT_CHANNELS.dup : allowed
+          end
+        end
+      end
+
+      def engine_path(relative)
+        File.join(destination_root, "engines", ENGINE_NAME, relative)
+      end
+
+      # Add 100+offset to the packed timestamp so this engine's
+      # migrations don't collide with another engine generated in the
+      # same second.
+      def timestamp(offset = 0)
+        base = Time.now.utc.strftime("%Y%m%d%H%M%S").to_i
+        (base + 100 + offset).to_s
+      end
+
+      def dummy_schema
+        # Wave 9: the dummy ships an `auth_identities` table (not
+        # `users`) so spec fixtures can construct a realistic owner
+        # for polymorphic Notifications. The dummy doesn't load the
+        # auth gem itself — a slim Auth::Identity stub model lives in
+        # spec/dummy/app/models/auth/identity.rb (see dummy_host_user
+        # below) and includes Notifiable so existing helpers
+        # (`unread_in_app_notifications`, etc.) keep working.
+        # The schema mirrors the auth + accounts engine shape (text
+        # email, password_digest, staff flag + partial index) so
+        # cross-engine fixture sharing doesn't drift.
+        <<~SCHEMA
+          create_table :auth_identities do |t|
+            t.text    :email,            null: false
+            t.string  :password_digest,  null: false, default: ""
+            t.boolean :staff,            null: false, default: false
+            t.timestamps
+          end
+          add_index :auth_identities, :email, unique: true
+          add_index :auth_identities, :staff, where: "staff = true"
+
+          create_table :notifications do |t|
+            t.string  :type,             null: false
+            # Polymorphic owner stored as strings so the column holds
+            # bigint Identity IDs and UUID Account IDs simultaneously.
+            t.string  :owner_type,       null: false
+            t.string  :owner_id,         null: false
+            t.string  :recipient
+            t.string  :template,         null: false
+            t.jsonb   :schedule_data
+            t.datetime :next_delivery_at
+            t.datetime :read_at
+            t.timestamps
+          end
+          add_index :notifications, %i[owner_type owner_id]
+          add_index :notifications, :next_delivery_at
+
+          create_table :notification_preferences do |t|
+            t.bigint  :identity_id,       null: false
+            t.string  :channel,           null: false
+            t.string  :notification_type
+            t.boolean :enabled,           null: false, default: true
+            t.timestamps
+          end
+          add_index :notification_preferences, %i[identity_id channel notification_type], unique: true,
+                                                                                           name: "index_notification_prefs_unique"
+
+          create_table :notification_deliveries do |t|
+            t.references :notification, null: false, foreign_key: true, index: true
+            t.datetime   :sent_at,      null: false
+            t.timestamps
+          end
+        SCHEMA
+      end
+
+      # Slim Auth::Identity stub for the dummy app. Stands in for the
+      # real Auth::Identity (which lives in the auth engine, not loaded
+      # by the dummy) so notifications specs can build a polymorphic
+      # owner. Includes Notifiable so the bell + #notify helpers
+      # exercise the same code path the canonical seams host uses.
+      def dummy_host_user
+        <<~RB
+          # frozen_string_literal: true
+
+          module Auth
+            class Identity < ApplicationRecord
+              self.table_name = "auth_identities"
+              include Notifications::Notifiable
+            end
+          end
+        RB
+      end
+    end
+    # rubocop:enable Metrics/ClassLength
+  end
+end