async-matrix 0.1.3 → 1.1.0

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

@@ -7,78 +7,78 @@ require "bundler/setup"
 require "async/matrix"
 
 module Async
-	module Matrix
-		module ApplicationService
-			# In-memory idempotency store for appservice transaction IDs.
-			class TransactionStore
-				DEFAULT_CAPACITY = 1024
+  module Matrix
+    module ApplicationService
+      # In-memory idempotency store for appservice transaction IDs.
+      class TransactionStore
+        DEFAULT_CAPACITY = 1024
 
-				def initialize(capacity: DEFAULT_CAPACITY)
-					@seen     = {}
-					@capacity = capacity
-				end
+        def initialize(capacity: DEFAULT_CAPACITY)
+          @seen     = {}
+          @capacity = capacity
+        end
 
-				def seen?(txn_id)
-					@seen.key?(txn_id)
-				end
+        def seen?(txn_id)
+          @seen.key?(txn_id)
+        end
 
-				def mark_seen(txn_id)
-					prune! if @seen.size >= @capacity
-					@seen[txn_id] = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-				end
+        def mark_seen(txn_id)
+          prune! if @seen.size >= @capacity
+          @seen[txn_id] = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        end
 
-				def size
-					@seen.size
-				end
+        def size
+          @seen.size
+        end
 
-				private
+        private
 
-				def prune!
-					sorted = @seen.sort_by { |_, ts| ts }
-					drop   = sorted.size / 2
-					sorted.first(drop).each { |id, _| @seen.delete(id) }
-				end
-			end
-		end
-	end
+          def prune!
+            sorted = @seen.sort_by { |_, ts| ts }
+            drop   = sorted.size / 2
+            sorted.first(drop).each { |id, _| @seen.delete(id) }
+          end
+      end
+    end
+  end
 end
 
 test do
-	describe "Async::Matrix::ApplicationService::TransactionStore" do
-		it "tracks seen transaction IDs" do
-			store = Async::Matrix::ApplicationService::TransactionStore.new
-			store.seen?("txn1").should == false
-			store.mark_seen("txn1")
-			store.seen?("txn1").should == true
-		end
+  describe "Async::Matrix::ApplicationService::TransactionStore" do
+    it "tracks seen transaction IDs" do
+      store = Async::Matrix::ApplicationService::TransactionStore.new
+      store.seen?("txn1").should == false
+      store.mark_seen("txn1")
+      store.seen?("txn1").should == true
+    end
 
-		it "reports size" do
-			store = Async::Matrix::ApplicationService::TransactionStore.new
-			store.size.should == 0
-			store.mark_seen("a")
-			store.mark_seen("b")
-			store.size.should == 2
-		end
+    it "reports size" do
+      store = Async::Matrix::ApplicationService::TransactionStore.new
+      store.size.should == 0
+      store.mark_seen("a")
+      store.mark_seen("b")
+      store.size.should == 2
+    end
 
-		it "prunes oldest entries when capacity is reached" do
-			store = Async::Matrix::ApplicationService::TransactionStore.new(capacity: 4)
-			store.mark_seen("a")
-			store.mark_seen("b")
-			store.mark_seen("c")
-			store.mark_seen("d")
-			# This triggers prune — drops oldest half (a, b)
-			store.mark_seen("e")
-			store.seen?("a").should == false
-			store.seen?("b").should == false
-			store.seen?("d").should == true
-			store.seen?("e").should == true
-		end
+    it "prunes oldest entries when capacity is reached" do
+      store = Async::Matrix::ApplicationService::TransactionStore.new(capacity: 4)
+      store.mark_seen("a")
+      store.mark_seen("b")
+      store.mark_seen("c")
+      store.mark_seen("d")
+      # This triggers prune — drops oldest half (a, b)
+      store.mark_seen("e")
+      store.seen?("a").should == false
+      store.seen?("b").should == false
+      store.seen?("d").should == true
+      store.seen?("e").should == true
+    end
 
-		it "does not prune below capacity" do
-			store = Async::Matrix::ApplicationService::TransactionStore.new(capacity: 10)
-			5.times { |i| store.mark_seen("txn#{i}") }
-			store.size.should == 5
-			store.seen?("txn0").should == true
-		end
-	end
+    it "does not prune below capacity" do
+      store = Async::Matrix::ApplicationService::TransactionStore.new(capacity: 10)
+      5.times { |i| store.mark_seen("txn#{i}") }
+      store.size.should == 5
+      store.seen?("txn0").should == true
+    end
+  end
 end

data/lib/async/matrix/bridge/discord/db/connection.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+# Released under the Apache License, Version 2.0.
+# Copyright, 2026, by General Intelligence Systems.
+
+require "bundler/setup"
+require "sequel"
+
+module Async
+  module Matrix
+    module Bridge
+      module Discord
+        module DB
+          # Establishes a Sequel database connection from the bridge config's
+          # database section.
+          #
+          # Supports both SQLite (with foreign keys and WAL mode) and PostgreSQL,
+          # matching the mautrix bridgev2 database config schema.
+          #
+          #   db = Connection.establish(config.database)
+          #   db[:users].all  # => [...]
+          #
+          module Connection
+            SQLITE_TYPE  = "sqlite3-fk-wal"
+            POSTGRES_TYPE = "postgres"
+
+            # Establish a database connection from a config.database section.
+            #
+            # @param database_config [Hash, Vivify] config.database with :type, :uri, :max_open_conns
+            # @return [Sequel::Database]
+            def self.establish(database_config)
+              type = database_config.type || SQLITE_TYPE
+              uri  = database_config.uri  || "sqlite://bridge.db"
+
+              db = case type
+                   when SQLITE_TYPE
+                     connect_sqlite(uri, database_config)
+                   when POSTGRES_TYPE
+                     connect_postgres(uri, database_config)
+                   else
+                     raise ArgumentError, "Unknown database type: #{type.inspect}. Expected #{SQLITE_TYPE.inspect} or #{POSTGRES_TYPE.inspect}."
+                   end
+
+              db
+            end
+
+            class << self
+              private
+
+                def connect_sqlite(uri, config)
+                  # Normalize mautrix-style URIs: "file:bridge.db?..." -> "sqlite://bridge.db"
+                  sequel_uri = if uri.start_with?("file:")
+                                 path = uri.sub(%r{\Afile:}, "").split("?").first
+                                 "sqlite://#{path}"
+                               elsif uri.start_with?("sqlite://")
+                                 uri
+                               else
+                                 "sqlite://#{uri}"
+                               end
+
+                  db = Sequel.connect(sequel_uri, max_connections: max_conns(config))
+                  db.run("PRAGMA foreign_keys = ON")
+                  db.run("PRAGMA journal_mode = WAL")
+                  db
+                end
+
+                def connect_postgres(uri, config)
+                  Sequel.connect(uri, max_connections: max_conns(config))
+                end
+
+                def max_conns(config)
+                  val = config.respond_to?(:max_open_conns) ? config.max_open_conns : nil
+                  val && val > 0 ? val : 5
+                end
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+test do
+  describe "Async::Matrix::Bridge::Discord::DB::Connection" do
+    it "connects to an in-memory SQLite database" do
+      config = Object.new
+      config.define_singleton_method(:type) { "sqlite3-fk-wal" }
+      config.define_singleton_method(:uri)  { "sqlite:/" }
+      config.define_singleton_method(:max_open_conns) { 1 }
+
+      db = Async::Matrix::Bridge::Discord::DB::Connection.establish(config)
+      db.should.be.kind_of Sequel::Database
+      db.database_type.should == :sqlite
+      db.disconnect
+    end
+
+    it "enables foreign keys and WAL on SQLite" do
+      config = Object.new
+      config.define_singleton_method(:type) { "sqlite3-fk-wal" }
+      config.define_singleton_method(:uri)  { "sqlite:/" }
+      config.define_singleton_method(:max_open_conns) { 1 }
+
+      db = Async::Matrix::Bridge::Discord::DB::Connection.establish(config)
+      fk = db["PRAGMA foreign_keys"].first
+      fk[:foreign_keys].should == 1
+      db.disconnect
+    end
+
+    it "normalizes mautrix file: URIs to sequel sqlite:// URIs" do
+      config = Object.new
+      config.define_singleton_method(:type) { "sqlite3-fk-wal" }
+      config.define_singleton_method(:uri)  { "file:test.db?_txlock=immediate" }
+      config.define_singleton_method(:max_open_conns) { 1 }
+
+      # Should not raise — the URI is normalized
+      db = Async::Matrix::Bridge::Discord::DB::Connection.establish(config)
+      db.should.be.kind_of Sequel::Database
+      db.disconnect
+    end
+
+    it "defaults to sqlite with 5 connections when config is empty" do
+      config = Object.new
+      config.define_singleton_method(:type) { nil }
+      config.define_singleton_method(:uri)  { nil }
+      config.define_singleton_method(:max_open_conns) { nil }
+
+      db = Async::Matrix::Bridge::Discord::DB::Connection.establish(config)
+      db.should.be.kind_of Sequel::Database
+      db.disconnect
+    end
+
+    it "raises on unknown database type" do
+      config = Object.new
+      config.define_singleton_method(:type) { "mysql" }
+      config.define_singleton_method(:uri)  { "mysql://localhost/db" }
+      config.define_singleton_method(:max_open_conns) { 1 }
+
+      lambda {
+        Async::Matrix::Bridge::Discord::DB::Connection.establish(config)
+      }.should.raise(ArgumentError)
+    end
+  end
+end

data/lib/async/matrix/bridge/discord/db/file.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+# Released under the Apache License, Version 2.0.
+# Copyright, 2026, by General Intelligence Systems.
+
+require "bundler/setup"
+require "async/matrix"
+
+module Async
+  module Matrix
+    module Bridge
+      module Discord
+        module DB
+          # Caches uploaded media to avoid re-uploading the same Discord
+          # attachment to the Matrix homeserver.
+          #
+          # Uses a composite primary key of (url, encrypted) because the same
+          # source URL may be uploaded both encrypted and unencrypted to
+          # different portal rooms.
+          #
+          #   cached = CachedFile.create(
+          #     url: "https://cdn.discordapp.com/...",
+          #     encrypted: false,
+          #     mxc: "mxc://example.com/abc"
+          #   )
+          #
+          class CachedFile < Sequel::Model
+            unrestrict_primary_key
+
+            def validate
+              super
+              errors.add(:url, "cannot be empty") if url.nil? || url.empty?
+              errors.add(:mxc, "cannot be empty") if mxc.nil? || mxc.empty?
+            end
+
+            # Look up a cached file by source URL and encryption status.
+            def self.by_url(url, encrypted: false)
+              first(url: url, encrypted: encrypted)
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+test do
+  describe "Async::Matrix::Bridge::Discord::DB::CachedFile" do
+    def setup_db
+      db = Sequel.sqlite
+      Sequel::Migrator.run(db, File.join(__dir__, "migrations"))
+      db
+    end
+
+    it "creates and retrieves a cached file" do
+      db = setup_db
+      Async::Matrix::Bridge::Discord::DB::CachedFile.dataset = db[:files]
+
+      cached = Async::Matrix::Bridge::Discord::DB::CachedFile.create(
+        url: "https://cdn.discordapp.com/attachments/123/456/image.png",
+        mxc: "mxc://example.com/abc",
+        mime_type: "image/png",
+        size: 102400,
+        width: 800,
+        height: 600
+      )
+      cached.url.should.include "discordapp.com"
+      cached.mxc.should == "mxc://example.com/abc"
+      cached.mime_type.should == "image/png"
+      cached.width.should == 800
+      cached.height.should == 600
+      db.disconnect
+    end
+
+    it "looks up by URL and encryption status" do
+      db = setup_db
+      Async::Matrix::Bridge::Discord::DB::CachedFile.dataset = db[:files]
+
+      Async::Matrix::Bridge::Discord::DB::CachedFile.create(
+        url: "https://example.com/file.png", encrypted: false,
+        mxc: "mxc://x/plain"
+      )
+      Async::Matrix::Bridge::Discord::DB::CachedFile.create(
+        url: "https://example.com/file.png", encrypted: true,
+        mxc: "mxc://x/encrypted",
+        decryption_info: '{"key":"abc"}'
+      )
+
+      plain = Async::Matrix::Bridge::Discord::DB::CachedFile.by_url("https://example.com/file.png")
+      plain.mxc.should == "mxc://x/plain"
+
+      enc = Async::Matrix::Bridge::Discord::DB::CachedFile.by_url("https://example.com/file.png", encrypted: true)
+      enc.mxc.should == "mxc://x/encrypted"
+      enc.decryption_info.should == '{"key":"abc"}'
+      db.disconnect
+    end
+
+    it "defaults encrypted to false" do
+      db = setup_db
+      Async::Matrix::Bridge::Discord::DB::CachedFile.dataset = db[:files]
+
+      cached = Async::Matrix::Bridge::Discord::DB::CachedFile.create(
+        url: "https://example.com/a.jpg", mxc: "mxc://x/y"
+      )
+      cached.encrypted.should == false
+      db.disconnect
+    end
+
+    it "validates required fields" do
+      db = setup_db
+      Async::Matrix::Bridge::Discord::DB::CachedFile.dataset = db[:files]
+
+      f = Async::Matrix::Bridge::Discord::DB::CachedFile.new(url: "", mxc: "")
+      f.valid?.should == false
+      f.errors[:url].should.not.be.empty
+      f.errors[:mxc].should.not.be.empty
+      db.disconnect
+    end
+  end
+end

data/lib/async/matrix/bridge/discord/db/guild.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+# Released under the Apache License, Version 2.0.
+# Copyright, 2026, by General Intelligence Systems.
+
+require "bundler/setup"
+require "async/matrix"
+
+module Async
+  module Matrix
+    module Bridge
+      module Discord
+        module DB
+          # Maps a Discord guild (server) to a Matrix Space room.
+          #
+          # Bridging modes control how aggressively the bridge creates portals:
+          #   BRIDGE_NOTHING         = 0  — never bridge
+          #   BRIDGE_IF_PORTAL_EXISTS = 1  — only bridge existing portals
+          #   BRIDGE_CREATE_ON_MESSAGE = 2 — create portals on first message
+          #   BRIDGE_EVERYTHING      = 3  — proactively create all portals
+          #
+          #   guild = Guild.create(discord_id: "999", name: "My Server", bridging_mode: 3)
+          #   guild.portals  # => [Portal, ...]
+          #
+          class Guild < Sequel::Model
+            unrestrict_primary_key
+
+            BRIDGE_NOTHING           = 0
+            BRIDGE_IF_PORTAL_EXISTS  = 1
+            BRIDGE_CREATE_ON_MESSAGE = 2
+            BRIDGE_EVERYTHING        = 3
+
+            one_to_many :portals,
+              class: "Async::Matrix::Bridge::Discord::DB::Portal",
+              key: :discord_guild_id,
+              primary_key: :discord_id
+
+            def validate
+              super
+              errors.add(:discord_id, "cannot be empty") if discord_id.nil? || discord_id.empty?
+            end
+
+            def bridge_nothing?
+              bridging_mode == BRIDGE_NOTHING
+            end
+
+            def bridge_everything?
+              bridging_mode == BRIDGE_EVERYTHING
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+test do
+  describe "Async::Matrix::Bridge::Discord::DB::Guild" do
+    def setup_db
+      db = Sequel.sqlite
+      Sequel::Migrator.run(db, File.join(__dir__, "migrations"))
+      db
+    end
+
+    it "creates and retrieves a guild" do
+      db = setup_db
+      Async::Matrix::Bridge::Discord::DB::Guild.dataset = db[:guilds]
+
+      guild = Async::Matrix::Bridge::Discord::DB::Guild.create(
+        discord_id: "999",
+        name: "Test Guild",
+        mxid: "!space:example.com"
+      )
+      guild.discord_id.should == "999"
+      guild.name.should == "Test Guild"
+      guild.mxid.should == "!space:example.com"
+      db.disconnect
+    end
+
+    it "defaults bridging_mode to 0 (nothing)" do
+      db = setup_db
+      Async::Matrix::Bridge::Discord::DB::Guild.dataset = db[:guilds]
+
+      guild = Async::Matrix::Bridge::Discord::DB::Guild.create(discord_id: "100")
+      guild.bridging_mode.should == 0
+      guild.bridge_nothing?.should == true
+      guild.bridge_everything?.should == false
+      db.disconnect
+    end
+
+    it "supports all bridging modes" do
+      db = setup_db
+      Async::Matrix::Bridge::Discord::DB::Guild.dataset = db[:guilds]
+
+      guild = Async::Matrix::Bridge::Discord::DB::Guild.create(discord_id: "200", bridging_mode: 3)
+      guild.bridge_everything?.should == true
+      guild.bridge_nothing?.should == false
+      db.disconnect
+    end
+
+    it "validates discord_id is present" do
+      db = setup_db
+      Async::Matrix::Bridge::Discord::DB::Guild.dataset = db[:guilds]
+
+      guild = Async::Matrix::Bridge::Discord::DB::Guild.new(discord_id: "")
+      guild.valid?.should == false
+      guild.errors[:discord_id].should.not.be.empty
+      db.disconnect
+    end
+
+    it "enforces unique mxid" do
+      db = setup_db
+      Async::Matrix::Bridge::Discord::DB::Guild.dataset = db[:guilds]
+
+      Async::Matrix::Bridge::Discord::DB::Guild.create(discord_id: "300", mxid: "!a:x")
+      lambda {
+        Async::Matrix::Bridge::Discord::DB::Guild.create(discord_id: "301", mxid: "!a:x")
+      }.should.raise(Sequel::UniqueConstraintViolation)
+      db.disconnect
+    end
+  end
+end

data/lib/async/matrix/bridge/discord/db/message.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+# Released under the Apache License, Version 2.0.
+# Copyright, 2026, by General Intelligence Systems.
+
+require "bundler/setup"
+require "async/matrix"
+
+module Async
+  module Matrix
+    module Bridge
+      module Discord
+        module DB
+          # Maps a Discord message to one or more Matrix events.
+          #
+          # A single Discord message may produce multiple Matrix events (one per
+          # attachment), distinguished by discord_attachment_id. The composite
+          # unique index on (discord_id, discord_attachment_id, discord_channel_id,
+          # discord_channel_receiver) ensures no duplicates.
+          #
+          #   msg = Message.create(
+          #     discord_id: "msg1", discord_channel_id: "ch1",
+          #     discord_sender: "user1", mxid: "$evt1", timestamp: 1234567890
+          #   )
+          #   msg.portal  # => Portal
+          #
+          class Message < Sequel::Model
+            many_to_one :portal,
+              class: "Async::Matrix::Bridge::Discord::DB::Portal",
+              key: [:discord_channel_id, :discord_channel_receiver],
+              primary_key: [:discord_id, :receiver]
+
+            def validate
+              super
+              errors.add(:discord_id, "cannot be empty") if discord_id.nil? || discord_id.empty?
+              errors.add(:mxid, "cannot be empty") if mxid.nil? || mxid.empty?
+              errors.add(:discord_sender, "cannot be empty") if discord_sender.nil? || discord_sender.empty?
+            end
+
+            # Find all parts of a Discord message (text + attachments).
+            def self.by_discord_id(discord_id, channel_id, receiver = "")
+              where(
+                discord_id: discord_id,
+                discord_channel_id: channel_id,
+                discord_channel_receiver: receiver
+              ).order(:discord_attachment_id).all
+            end
+
+            # Find a message by its Matrix event ID.
+            def self.by_mxid(mxid)
+              first(mxid: mxid)
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+test do
+  describe "Async::Matrix::Bridge::Discord::DB::Message" do
+    def setup_db
+      db = Sequel.sqlite
+      Sequel::Migrator.run(db, File.join(__dir__, "migrations"))
+      db
+    end
+
+    def set_datasets(db)
+      Async::Matrix::Bridge::Discord::DB::Message.dataset = db[:messages]
+      Async::Matrix::Bridge::Discord::DB::Portal.dataset = db[:portals]
+    end
+
+    it "creates and retrieves a message" do
+      db = setup_db
+      set_datasets(db)
+
+      msg = Async::Matrix::Bridge::Discord::DB::Message.create(
+        discord_id: "msg1",
+        discord_channel_id: "ch1",
+        discord_sender: "user1",
+        mxid: "$evt1",
+        timestamp: 1234567890
+      )
+      msg.discord_id.should == "msg1"
+      msg.mxid.should == "$evt1"
+      msg.discord_attachment_id.should == ""
+      db.disconnect
+    end
+
+    it "supports multi-part messages with attachments" do
+      db = setup_db
+      set_datasets(db)
+
+      Async::Matrix::Bridge::Discord::DB::Message.create(
+        discord_id: "msg2", discord_attachment_id: "",
+        discord_channel_id: "ch1", discord_sender: "u1",
+        mxid: "$text", timestamp: 100
+      )
+      Async::Matrix::Bridge::Discord::DB::Message.create(
+        discord_id: "msg2", discord_attachment_id: "att1",
+        discord_channel_id: "ch1", discord_sender: "u1",
+        mxid: "$img1", timestamp: 100
+      )
+      Async::Matrix::Bridge::Discord::DB::Message.create(
+        discord_id: "msg2", discord_attachment_id: "att2",
+        discord_channel_id: "ch1", discord_sender: "u1",
+        mxid: "$img2", timestamp: 100
+      )
+
+      parts = Async::Matrix::Bridge::Discord::DB::Message.by_discord_id("msg2", "ch1")
+      parts.length.should == 3
+      parts.map(&:mxid).should == ["$text", "$img1", "$img2"]
+      db.disconnect
+    end
+
+    it "finds by Matrix event ID" do
+      db = setup_db
+      set_datasets(db)
+
+      Async::Matrix::Bridge::Discord::DB::Message.create(
+        discord_id: "msg3", discord_channel_id: "ch1",
+        discord_sender: "u1", mxid: "$find_me", timestamp: 200
+      )
+
+      found = Async::Matrix::Bridge::Discord::DB::Message.by_mxid("$find_me")
+      found.should.not.be.nil
+      found.discord_id.should == "msg3"
+      db.disconnect
+    end
+
+    it "enforces unique composite key" do
+      db = setup_db
+      set_datasets(db)
+
+      Async::Matrix::Bridge::Discord::DB::Message.create(
+        discord_id: "msg4", discord_attachment_id: "",
+        discord_channel_id: "ch1", discord_channel_receiver: "",
+        discord_sender: "u1", mxid: "$a", timestamp: 300
+      )
+      lambda {
+        Async::Matrix::Bridge::Discord::DB::Message.create(
+          discord_id: "msg4", discord_attachment_id: "",
+          discord_channel_id: "ch1", discord_channel_receiver: "",
+          discord_sender: "u1", mxid: "$b", timestamp: 300
+        )
+      }.should.raise(Sequel::UniqueConstraintViolation)
+      db.disconnect
+    end
+
+    it "validates required fields" do
+      db = setup_db
+      set_datasets(db)
+
+      msg = Async::Matrix::Bridge::Discord::DB::Message.new(discord_id: "", mxid: "", discord_sender: "")
+      msg.valid?.should == false
+      msg.errors[:discord_id].should.not.be.empty
+      msg.errors[:mxid].should.not.be.empty
+      msg.errors[:discord_sender].should.not.be.empty
+      db.disconnect
+    end
+  end
+end