async-matrix 2.0.1-x64-mingw-ucrt

data/lib/async/matrix/application_service/config.rb

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+# Released under the Apache License, Version 2.0.
+# Copyright, 2026, by General Intelligence Systems.
+
+require "forwardable"
+require "json_schemer"
+require "pathname"
+require "yaml"
+require_relative "config/vivify"
+
+module Async
+  module Matrix
+    module ApplicationService
+      # Loads, validates, and provides dot-notation access to a mautrix
+      # bridgev2-compatible YAML configuration file.
+      #
+      # The full schema mirrors the Go structs defined in
+      # mautrix/go v0.27.0 bridgev2/bridgeconfig — split across multiple
+      # JSON Schema files under config/schema/ and composed at runtime via $ref.
+      #
+      # Validated config data is exposed through Vivify-enhanced hashes,
+      # giving natural dot-notation access to every nested field:
+      #
+      #   config = Config.load("bridge.yml")
+      #   config.homeserver.address     # => "http://synapse:8008"
+      #   config.homeserver.domain      # => "localhost"
+      #   config.appservice.as_token    # => "secret..."
+      #   config.appservice.bot.username # => "bot"
+      #   config.bot_mxid               # => "@bot:localhost"
+      #
+      class Config
+        extend Forwardable
+
+        SCHEMA_DIR = Pathname.new(__dir__).join("config", "schema").freeze
+
+        # Delegate every top-level config section to the vivified data hash.
+        def_delegators :@data,
+          :network, :bridge, :database, :homeserver, :appservice,
+          :matrix, :analytics, :provisioning, :public_media, :direct_media,
+          :backfill, :double_puppet, :encryption, :logging,
+          :management_room_texts, :env_config_prefix
+
+        def initialize(data)
+          self.class.validate!(data)
+          @data = Vivify.deep_vivify(data)
+        end
+
+        # Load and validate a YAML config file from disk.
+        def self.load(path)
+          raise Async::Matrix::NotFoundError.new(
+            "M_NOT_FOUND", "Config not found: #{path}"
+          ) unless File.exist?(path)
+
+          data = YAML.safe_load_file(path, permitted_classes: [Symbol])
+          new(data)
+        end
+
+        # Convenience: derive the bot's full Matrix ID from
+        # appservice.bot.username + homeserver.domain.
+        def bot_mxid
+          "@#{appservice.bot.username}:#{homeserver.domain}"
+        end
+
+        # ------------------------------------------------------------------
+        # Schema loading & validation
+        # ------------------------------------------------------------------
+
+        def self.schema
+          @schema ||= JSONSchemer.schema(
+            SCHEMA_DIR.join("config.json"),
+            insert_property_defaults: true
+          )
+        end
+
+        def self.validate!(data)
+          errors = schema.validate(data).to_a
+          return if errors.empty?
+
+          messages = errors.map { |e| e["error"] }.join("; ")
+          raise Async::Matrix::BadJsonError.new(
+            "M_BAD_JSON", "Config validation failed: #{messages}"
+          )
+        end
+      end
+    end
+  end
+end
+
+__END__
+  require "tempfile"
+
+  describe "Async::Matrix::ApplicationService::Config" do
+    def minimal_data
+      {
+        "homeserver" => {
+          "address" => "http://localhost:8008",
+          "domain"  => "localhost"
+        },
+        "appservice" => {
+          "as_token" => "as_secret_token_value",
+          "hs_token" => "hs_secret_token_value",
+          "bot"      => { "username" => "bot" }
+        }
+      }
+    end
+
+    it "parses a minimal valid config" do
+      config = Async::Matrix::ApplicationService::Config.new(minimal_data)
+      config.homeserver.address.should == "http://localhost:8008"
+      config.homeserver.domain.should == "localhost"
+      config.appservice.as_token.should == "as_secret_token_value"
+      config.appservice.hs_token.should == "hs_secret_token_value"
+      config.appservice.bot.username.should == "bot"
+    end
+
+    it "derives bot_mxid from appservice.bot.username and homeserver.domain" do
+      config = Async::Matrix::ApplicationService::Config.new(minimal_data)
+      config.bot_mxid.should == "@bot:localhost"
+    end
+
+    it "inserts property defaults from the schema" do
+      config = Async::Matrix::ApplicationService::Config.new(minimal_data)
+      config.appservice.hostname.should == "0.0.0.0"
+      config.appservice.port.should == 29318
+      config.homeserver.software.should == "standard"
+    end
+
+    it "provides dot-notation access to deeply nested fields" do
+      data = minimal_data.merge(
+        "encryption" => {
+          "allow" => true,
+          "rotation" => { "messages" => 200 }
+        }
+      )
+      config = Async::Matrix::ApplicationService::Config.new(data)
+      config.encryption.allow.should == true
+      config.encryption.rotation.messages.should == 200
+    end
+
+    it "autovivifies missing optional sections as empty hashes" do
+      config = Async::Matrix::ApplicationService::Config.new(minimal_data)
+      config.analytics.should.be.kind_of Hash
+      config.analytics.should.be.empty?
+    end
+
+    it "raises BadJsonError when homeserver.address is missing" do
+      data = {
+        "homeserver" => { "domain" => "localhost" },
+        "appservice" => { "as_token" => "a", "hs_token" => "b" }
+      }
+      lambda {
+        Async::Matrix::ApplicationService::Config.new(data)
+      }.should.raise(Async::Matrix::BadJsonError)
+    end
+
+    it "raises BadJsonError when appservice.as_token is empty" do
+      data = {
+        "homeserver" => { "address" => "http://localhost:8008", "domain" => "localhost" },
+        "appservice" => { "as_token" => "", "hs_token" => "b" }
+      }
+      lambda {
+        Async::Matrix::ApplicationService::Config.new(data)
+      }.should.raise(Async::Matrix::BadJsonError)
+    end
+
+    it "raises BadJsonError for unknown top-level keys" do
+      data = minimal_data.merge("bogus" => "nope")
+      lambda {
+        Async::Matrix::ApplicationService::Config.new(data)
+      }.should.raise(Async::Matrix::BadJsonError)
+    end
+
+    it "validates enum constraints (homeserver.software)" do
+      data = minimal_data
+      data["homeserver"]["software"] = "invalid_value"
+      lambda {
+        Async::Matrix::ApplicationService::Config.new(data)
+      }.should.raise(Async::Matrix::BadJsonError)
+    end
+
+    it "loads from a YAML file" do
+      file = Tempfile.new(["config", ".yml"])
+      file.write(<<~YAML)
+        homeserver:
+          address: "http://localhost:8008"
+          domain: "localhost"
+        appservice:
+          as_token: "as123_secret"
+          hs_token: "hs456_secret"
+          bot:
+            username: "testbot"
+      YAML
+      file.close
+
+      config = Async::Matrix::ApplicationService::Config.load(file.path)
+      config.homeserver.address.should == "http://localhost:8008"
+      config.bot_mxid.should == "@testbot:localhost"
+    ensure
+      file.unlink
+    end
+
+    it "raises NotFoundError for missing file" do
+      lambda {
+        Async::Matrix::ApplicationService::Config.load("/nonexistent/path.yml")
+      }.should.raise(Async::Matrix::NotFoundError)
+    end
+
+    it "accepts the full bridge config with permissions as string presets" do
+      data = minimal_data.merge(
+        "bridge" => {
+          "command_prefix" => "!signal",
+          "permissions" => {
+            "*" => "relay",
+            "localhost" => "user",
+            "@admin:localhost" => "admin"
+          }
+        }
+      )
+      config = Async::Matrix::ApplicationService::Config.new(data)
+      config.bridge.command_prefix.should == "!signal"
+      config.bridge.permissions[:"*"].should == "relay"
+      config.bridge.permissions[:"@admin:localhost"].should == "admin"
+    end
+  end

data/lib/async/matrix/application_service/dispatcher.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+# Released under the Apache License, Version 2.0.
+# Copyright, 2026, by General Intelligence Systems.
+
+require "console"
+
+module Async
+  module Matrix
+    module ApplicationService
+      # Routes incoming Matrix events to registered handler objects.
+      #
+      # Each handler declares the event types it handles via `#event_types`.
+      # When an event arrives, the dispatcher finds all matching handlers
+      # and calls them. Errors in one handler do not prevent others from running.
+      class Dispatcher
+        def initialize(txn_store: TransactionStore.new)
+          @handlers  = Hash.new { |h, k| h[k] = [] }
+          @txn_store = txn_store
+        end
+
+        # Register a Bot (responds to #handlers) or a plain handler (responds
+        # to #event_types and #call). Bots are expanded into their handlers.
+        def register(handler)
+          if handler.respond_to?(:handlers)
+            handler.handlers.each { |h| register(h) }
+          else
+            handler.event_types.each do |type|
+              @handlers[type] << handler
+              Console.info(self) { "Registered #{handler.class.name} for #{type}" }
+            end
+          end
+        end
+
+        # Idempotently process a homeserver transaction. Duplicate transaction
+        # IDs (already seen) are skipped. Returns :processed or :duplicate.
+        #
+        # The idempotency store lives here rather than in the HTTP layer because
+        # the Grape server is stateless across requests — the dispatcher is the
+        # stable, long-lived object.
+        def receive_transaction(txn_id, body)
+          if @txn_store.seen?(txn_id)
+            Console.debug(self) { "Duplicate transaction #{txn_id} — skipping" }
+            :duplicate
+          else
+            dispatch_transaction(body)
+            @txn_store.mark_seen(txn_id)
+            :processed
+          end
+        end
+
+        def dispatch_transaction(body)
+          Transaction.new(body).then do |txn|
+            txn.events.each    { |event| dispatch(event) }
+            txn.ephemeral.each { |event| dispatch(event) }
+          end
+        end
+
+          def dispatch(event)
+            type     = event.type
+            handlers = @handlers[type]
+
+            if handlers.empty?
+              Console.debug(self) { "No handler for event type: #{type}" }
+            else
+              handlers.each do |handler|
+                begin
+                  handler.call(event)
+                rescue => e
+                  Console.error(self) { "Handler #{handler.class.name} raised #{e.class}: #{e.message}" }
+                end
+              end
+            end
+          end
+
+          def handler_count
+            @handlers.values.flatten.size
+          end
+      end
+    end
+  end
+end
+
+__END__
+  describe "Async::Matrix::ApplicationService::Dispatcher" do
+    it "registers and dispatches to handlers" do
+      received = []
+      handler = Object.new
+      handler.define_singleton_method(:event_types) { ["m.room.message"] }
+      handler.define_singleton_method(:call) { |event| received << event }
+
+      dispatcher = Async::Matrix::ApplicationService::Dispatcher.new
+      dispatcher.register(handler)
+      dispatcher.handler_count.should == 1
+
+      event = Async::Matrix::ApplicationService::Event.new({
+        "type" => "m.room.message",
+        "content" => {"body" => "hi"}
+      })
+      dispatcher.dispatch(event)
+      received.length.should == 1
+      received.first.content.body.should == "hi"
+    end
+
+    it "ignores events with no matching handler" do
+      dispatcher = Async::Matrix::ApplicationService::Dispatcher.new
+      event = Async::Matrix::ApplicationService::Event.new({"type" => "m.unknown"})
+      lambda { dispatcher.dispatch(event) }.should.not.raise
+    end
+
+    it "continues dispatching when a handler raises" do
+      results = []
+      bad_handler = Object.new
+      bad_handler.define_singleton_method(:event_types) { ["m.room.message"] }
+      bad_handler.define_singleton_method(:call) { |_| raise "boom" }
+
+      good_handler = Object.new
+      good_handler.define_singleton_method(:event_types) { ["m.room.message"] }
+      good_handler.define_singleton_method(:call) { |e| results << e }
+
+      dispatcher = Async::Matrix::ApplicationService::Dispatcher.new
+      dispatcher.register(bad_handler)
+      dispatcher.register(good_handler)
+
+      event = Async::Matrix::ApplicationService::Event.new({
+        "type" => "m.room.message",
+        "content" => {"body" => "test"}
+      })
+      dispatcher.dispatch(event)
+      results.length.should == 1
+    end
+
+    it "dispatches a full transaction" do
+      received = []
+      handler = Object.new
+      handler.define_singleton_method(:event_types) { ["m.room.message"] }
+      handler.define_singleton_method(:call) { |e| received << e }
+
+      dispatcher = Async::Matrix::ApplicationService::Dispatcher.new
+      dispatcher.register(handler)
+
+      dispatcher.dispatch_transaction({
+        "events" => [
+          {"type" => "m.room.message", "content" => {"body" => "one"}},
+          {"type" => "m.room.message", "content" => {"body" => "two"}}
+        ]
+      })
+      received.length.should == 2
+    end
+
+    it "registers a bot (object responding to #handlers)" do
+      received = []
+      handler = Object.new
+      handler.define_singleton_method(:event_types) { ["m.room.message"] }
+      handler.define_singleton_method(:call) { |e| received << e }
+
+      bot = Object.new
+      bot.define_singleton_method(:handlers) { [handler] }
+
+      dispatcher = Async::Matrix::ApplicationService::Dispatcher.new
+      dispatcher.register(bot)
+      dispatcher.handler_count.should == 1
+
+      dispatcher.dispatch_transaction({
+        "events" => [{"type" => "m.room.message", "content" => {"body" => "hi"}}]
+      })
+      received.length.should == 1
+    end
+
+    it "processes a transaction idempotently via receive_transaction" do
+      received = []
+      handler = Object.new
+      handler.define_singleton_method(:event_types) { ["m.room.message"] }
+      handler.define_singleton_method(:call) { |e| received << e }
+
+      dispatcher = Async::Matrix::ApplicationService::Dispatcher.new
+      dispatcher.register(handler)
+
+      body = {"events" => [{"type" => "m.room.message", "content" => {"body" => "hi"}}]}
+
+      dispatcher.receive_transaction("txn1", body).should == :processed
+      dispatcher.receive_transaction("txn1", body).should == :duplicate
+      received.length.should == 1
+    end
+  end

data/lib/async/matrix/application_service/error_response.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+# Released under the Apache License, Version 2.0.
+# Copyright, 2026, by General Intelligence Systems.
+
+module Async
+  module Matrix
+    module ApplicationService
+      class ErrorResponse
+        attr_reader :errcode, :error
+
+        def initialize(data)
+          @errcode = data["errcode"]
+          @error   = data["error"]
+        end
+      end
+    end
+  end
+end
+
+__END__
+  describe "Async::Matrix::ApplicationService::ErrorResponse" do
+    it "parses errcode and error" do
+      resp = Async::Matrix::ApplicationService::ErrorResponse.new({
+        "errcode" => "M_FORBIDDEN",
+        "error" => "Access denied"
+      })
+      resp.errcode.should == "M_FORBIDDEN"
+      resp.error.should == "Access denied"
+    end
+
+    it "handles missing fields" do
+      resp = Async::Matrix::ApplicationService::ErrorResponse.new({})
+      resp.errcode.should.be.nil
+      resp.error.should.be.nil
+    end
+  end