async-matrix 0.1.3 → 1.0.0

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

@@ -4,134 +4,225 @@
 # Copyright, 2026, by General Intelligence Systems.
 
 require "bundler/setup"
+require "forwardable"
+require "json_schemer"
+require "pathname"
 require "yaml"
 require "async/matrix"
+require_relative "config/vivify"
 
 module Async
-	module Matrix
-		module ApplicationService
-			# Loads and validates an Application Service YAML configuration file.
-			#
-			# Expected YAML structure:
-			#
-			#   homeserver:
-			#     url: "http://synapse:8008"
-			#     domain: "localhost"
-			#   appservice:
-			#     as_token: "..."
-			#     hs_token: "..."
-			#     bot_mxid: "@bot:localhost"
-			#   server:
-			#     bind: "http://0.0.0.0:9292"  # optional
-			#
-			class Config
-				attr_reader :homeserver_url, :domain, :as_token, :hs_token, :bot_mxid, :bind
-
-				def initialize(data)
-					hs = data.fetch("homeserver")
-					as = data.fetch("appservice")
-					sv = data.fetch("server", {})
-
-					@homeserver_url = hs.fetch("url").chomp("/")
-					@domain         = hs.fetch("domain")
-					@as_token       = as.fetch("as_token")
-					@hs_token       = as.fetch("hs_token")
-					@bot_mxid       = as.fetch("bot_mxid")
-					@bind           = sv.fetch("bind", "http://0.0.0.0:9292")
-
-					validate!
-				end
-
-				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
-
-				private
-
-				def validate!
-					raise Async::Matrix::BadJsonError.new("M_BAD_JSON", "homeserver.url is required")     if @homeserver_url.empty?
-					raise Async::Matrix::BadJsonError.new("M_BAD_JSON", "appservice.as_token is required") if @as_token.empty?
-					raise Async::Matrix::BadJsonError.new("M_BAD_JSON", "appservice.hs_token is required") if @hs_token.empty?
-					raise Async::Matrix::BadJsonError.new("M_BAD_JSON", "appservice.bot_mxid is required") if @bot_mxid.empty?
-
-					if @as_token.include?("CHANGE_ME") || @hs_token.include?("CHANGE_ME")
-						raise Async::Matrix::AuthError.new("M_FORBIDDEN", "Replace placeholder tokens in config before starting")
-					end
-				end
-			end
-		end
-	end
+  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
 
 test do
-	require "tempfile"
-
-	describe "Async::Matrix::ApplicationService::Config" do
-		it "parses a valid config hash" do
-			config = Async::Matrix::ApplicationService::Config.new({
-				"homeserver" => {"url" => "http://localhost:8008", "domain" => "localhost"},
-				"appservice" => {"as_token" => "as123", "hs_token" => "hs456", "bot_mxid" => "@bot:localhost"}
-			})
-			config.homeserver_url.should == "http://localhost:8008"
-			config.domain.should == "localhost"
-			config.as_token.should == "as123"
-			config.hs_token.should == "hs456"
-			config.bot_mxid.should == "@bot:localhost"
-			config.bind.should == "http://0.0.0.0:9292"
-		end
-
-		it "strips trailing slash from homeserver_url" do
-			config = Async::Matrix::ApplicationService::Config.new({
-				"homeserver" => {"url" => "http://localhost:8008/", "domain" => "localhost"},
-				"appservice" => {"as_token" => "as123", "hs_token" => "hs456", "bot_mxid" => "@bot:localhost"}
-			})
-			config.homeserver_url.should == "http://localhost:8008"
-		end
-
-		it "raises BadJsonError for empty as_token" do
-			lambda {
-				Async::Matrix::ApplicationService::Config.new({
-					"homeserver" => {"url" => "http://localhost:8008", "domain" => "localhost"},
-					"appservice" => {"as_token" => "", "hs_token" => "hs456", "bot_mxid" => "@bot:localhost"}
-				})
-			}.should.raise(Async::Matrix::BadJsonError)
-		end
-
-		it "raises AuthError for placeholder tokens" do
-			lambda {
-				Async::Matrix::ApplicationService::Config.new({
-					"homeserver" => {"url" => "http://localhost:8008", "domain" => "localhost"},
-					"appservice" => {"as_token" => "CHANGE_ME", "hs_token" => "hs456", "bot_mxid" => "@bot:localhost"}
-				})
-			}.should.raise(Async::Matrix::AuthError)
-		end
-
-		it "loads from a YAML file" do
-			file = Tempfile.new(["config", ".yml"])
-			file.write(<<~YAML)
-				homeserver:
-				  url: "http://localhost:8008"
-				  domain: "localhost"
-				appservice:
-				  as_token: "as123"
-				  hs_token: "hs456"
-				  bot_mxid: "@bot:localhost"
-			YAML
-			file.close
-
-			config = Async::Matrix::ApplicationService::Config.load(file.path)
-			config.homeserver_url.should == "http://localhost:8008"
-		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
-	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
 end

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

@@ -8,120 +8,122 @@ require "console"
 require "async/matrix"
 
 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
-					@handlers = Hash.new { |h, k| h[k] = [] }
-				end
-
-				def register(handler)
-					handler.event_types.each do |type|
-						@handlers[type] << handler
-						Console.info(self) { "Registered #{handler.class.name} for #{type}" }
-					end
-				end
-
-				def dispatch(event)
-					type     = event.type
-					handlers = @handlers[type]
-
-					if handlers.empty?
-						Console.debug(self) { "No handler for event type: #{type}" }
-						return
-					end
-
-					handlers.each do |handler|
-						handler.call(event)
-					rescue => e
-						Console.error(self) { "Handler #{handler.class.name} raised #{e.class}: #{e.message}" }
-					end
-				end
-
-				def dispatch_transaction(body)
-					txn = Transaction.new(body)
-					txn.events.each    { |event| dispatch(event) }
-					txn.ephemeral.each { |event| dispatch(event) }
-				end
-
-				def handler_count
-					@handlers.values.flatten.size
-				end
-			end
-		end
-	end
+  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
+          @handlers = Hash.new { |h, k| h[k] = [] }
+        end
+
+        def register(handler)
+          handler.event_types.each do |type|
+            @handlers[type] << handler
+            Console.info(self) { "Registered #{handler.class.name} for #{type}" }
+          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
 
 test do
-	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
-	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
+  end
 end

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

@@ -7,35 +7,35 @@ require "bundler/setup"
 require "async/matrix"
 
 module Async
-	module Matrix
-		module ApplicationService
-			class ErrorResponse
-				attr_reader :errcode, :error
+  module Matrix
+    module ApplicationService
+      class ErrorResponse
+        attr_reader :errcode, :error
 
-				def initialize(data)
-					@errcode = data["errcode"]
-					@error   = data["error"]
-				end
-			end
-		end
-	end
+        def initialize(data)
+          @errcode = data["errcode"]
+          @error   = data["error"]
+        end
+      end
+    end
+  end
 end
 
 test do
-	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
+  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
+    it "handles missing fields" do
+      resp = Async::Matrix::ApplicationService::ErrorResponse.new({})
+      resp.errcode.should.be.nil
+      resp.error.should.be.nil
+    end
+  end
 end