async-matrix 2.1.0-aarch64-linux → 3.0.1-aarch64-linux

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

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-
-# Released under the Apache License, Version 2.0.
-# Copyright, 2026, by General Intelligence Systems.
-
-module Async
-  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 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 size
-          @seen.size
-        end
-
-        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
-end
-
-__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 "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

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

@@ -1,141 +0,0 @@
-# frozen_string_literal: true
-
-# Released under the Apache License, Version 2.0.
-# Copyright, 2026, by General Intelligence Systems.
-
-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
-
-__END__
-  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

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

@@ -1,118 +0,0 @@
-# frozen_string_literal: true
-
-# Released under the Apache License, Version 2.0.
-# Copyright, 2026, by General Intelligence Systems.
-
-require_relative "schema"
-
-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
-
-__END__
-  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

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

@@ -1,120 +0,0 @@
-# frozen_string_literal: true
-
-# Released under the Apache License, Version 2.0.
-# Copyright, 2026, by General Intelligence Systems.
-
-require_relative "schema"
-
-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
-
-__END__
-  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

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

@@ -1,160 +0,0 @@
-# frozen_string_literal: true
-
-# Released under the Apache License, Version 2.0.
-# Copyright, 2026, by General Intelligence Systems.
-
-require_relative "schema"
-
-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
-
-__END__
-  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

data/lib/async/matrix/bridge/discord/db/migrations/001_create_users.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-Sequel.migration do
-  change do
-    create_table(:users) do
-      String :mxid, primary_key: true
-      String :discord_id, unique: true
-      String :discord_token
-      String :management_room
-      String :space_room
-      String :dm_space_room
-    end
-  end
-end

data/lib/async/matrix/bridge/discord/db/migrations/002_create_guilds.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-Sequel.migration do
-  change do
-    create_table(:guilds) do
-      String :discord_id, primary_key: true
-      String :mxid, unique: true
-      String :name
-      String :avatar_hash
-      String :avatar_url
-      Integer :bridging_mode, default: 0, null: false
-    end
-  end
-end

data/lib/async/matrix/bridge/discord/db/migrations/003_create_portals.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-Sequel.migration do
-  change do
-    create_table(:portals) do
-      String :discord_id, null: false
-      String :receiver, null: false, default: ""
-      String :mxid, unique: true
-      String :discord_guild_id
-      String :name
-      String :topic
-      String :avatar_hash
-      String :avatar_url
-      TrueClass :encrypted, default: false, null: false
-      Integer :channel_type, default: 0, null: false
-      String :relay_webhook_id
-      String :relay_webhook_secret
-
-      primary_key [:discord_id, :receiver]
-      foreign_key [:discord_guild_id], :guilds, key: :discord_id
-    end
-  end
-end

data/lib/async/matrix/bridge/discord/db/migrations/004_create_puppets.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-Sequel.migration do
-  change do
-    create_table(:puppets) do
-      String :discord_id, primary_key: true
-      String :name
-      String :avatar_hash
-      String :avatar_url
-      String :username
-      String :global_name
-      TrueClass :is_bot, default: false, null: false
-      TrueClass :is_webhook, default: false, null: false
-      TrueClass :contact_info_set, default: false, null: false
-      String :custom_mxid
-      String :access_token
-    end
-  end
-end