@jeongsu816/matrix-bot-sdk 0.0.0-stage → 0.8.1

package/src/storage/RustSdkCryptoStorageProvider.ts

@@ -0,0 +1,81 @@
+import * as lowdb from "lowdb";
+import * as FileSync from "lowdb/adapters/FileSync";
+import * as mkdirp from "mkdirp";
+import * as path from "path";
+import * as sha512 from "hash.js/lib/hash/sha/512";
+import * as sha256 from "hash.js/lib/hash/sha/256";
+import { StoreType as RustSdkCryptoStoreType } from "@matrix-org/matrix-sdk-crypto-nodejs";
+
+import { ICryptoStorageProvider } from "./ICryptoStorageProvider";
+import { IAppserviceCryptoStorageProvider } from "./IAppserviceStorageProvider";
+import { ICryptoRoomInformation } from "../e2ee/ICryptoRoomInformation";
+
+export { RustSdkCryptoStoreType };
+
+/**
+ * A crypto storage provider for the file-based rust-sdk store.
+ * @category Storage providers
+ */
+export class RustSdkCryptoStorageProvider implements ICryptoStorageProvider {
+    private db: lowdb.LowdbSync<any>;
+
+    /**
+     * Creates a new rust-sdk storage provider.
+     * @param storagePath The *directory* to persist database details to.
+     * @param storageType The storage type to use. Must be supported by the rust-sdk.
+     */
+    public constructor(
+        public readonly storagePath: string,
+        public readonly storageType: RustSdkCryptoStoreType,
+    ) {
+        this.storagePath = path.resolve(this.storagePath);
+        mkdirp.sync(storagePath);
+
+        const adapter = new FileSync(path.join(storagePath, "bot-sdk.json"));
+        this.db = lowdb(adapter);
+
+        this.db.defaults({
+            deviceId: null,
+            rooms: {},
+        });
+    }
+
+    public async getDeviceId(): Promise<string> {
+        return this.db.get('deviceId').value();
+    }
+
+    public async setDeviceId(deviceId: string): Promise<void> {
+        this.db.set('deviceId', deviceId).write();
+    }
+
+    public async getRoom(roomId: string): Promise<ICryptoRoomInformation> {
+        const key = sha512().update(roomId).digest('hex');
+        return this.db.get(`rooms.${key}`).value();
+    }
+
+    public async storeRoom(roomId: string, config: ICryptoRoomInformation): Promise<void> {
+        const key = sha512().update(roomId).digest('hex');
+        this.db.set(`rooms.${key}`, config).write();
+    }
+}
+
+/**
+ * An appservice crypto storage provider for the file-based rust-sdk store.
+ * @category Storage providers
+ */
+export class RustSdkAppserviceCryptoStorageProvider extends RustSdkCryptoStorageProvider implements IAppserviceCryptoStorageProvider {
+    /**
+     * Creates a new rust-sdk storage provider.
+     * @param baseStoragePath The *directory* to persist database details to.
+     * @param storageType The storage type to use. Must be supported by the rust-sdk.
+     */
+    public constructor(private baseStoragePath: string, storageType: RustSdkCryptoStoreType) {
+        super(path.join(baseStoragePath, "_default"), storageType);
+    }
+
+    public storageForUser(userId: string): ICryptoStorageProvider {
+        // sha256 because sha512 is a bit big for some operating systems
+        const key = sha256().update(userId).digest('hex');
+        return new RustSdkCryptoStorageProvider(path.join(this.baseStoragePath, key), this.storageType);
+    }
+}

package/src/storage/SimpleFsStorageProvider.ts

@@ -0,0 +1,142 @@
+import * as lowdb from "lowdb";
+import * as FileSync from "lowdb/adapters/FileSync";
+import * as sha512 from "hash.js/lib/hash/sha/512";
+import * as mkdirp from "mkdirp";
+import * as path from "path";
+
+import { IAppserviceStorageProvider } from "./IAppserviceStorageProvider";
+import { IFilterInfo } from "../IFilter";
+import { IStorageProvider } from "./IStorageProvider";
+
+/**
+ * A storage provider that uses the disk to store information.
+ * @category Storage providers
+ */
+export class SimpleFsStorageProvider implements IStorageProvider, IAppserviceStorageProvider {
+    private db: any;
+    private completedTransactions = [];
+
+    /**
+     * Creates a new simple file system storage provider.
+     * @param {string} filename The file name (typically 'storage.json') to store data within.
+     * @param {boolean} trackTransactionsInMemory True (default) to track all received appservice transactions rather than on disk.
+     * @param {int} maxInMemoryTransactions The maximum number of transactions to hold in memory before rotating the oldest out. Defaults to 20.
+     */
+    constructor(filename: string, private trackTransactionsInMemory = true, private maxInMemoryTransactions = 20) {
+        mkdirp.sync(path.dirname(filename));
+
+        const adapter = new FileSync(filename);
+        this.db = lowdb(adapter);
+
+        this.db.defaults({
+            syncToken: null,
+            filter: null,
+            appserviceUsers: {}, // userIdHash => { data }
+            appserviceTransactions: {}, // txnIdHash => { data }
+            kvStore: {}, // key => value (str)
+        }).write();
+    }
+
+    setSyncToken(token: string | null): void {
+        this.db.set('syncToken', token).write();
+    }
+
+    getSyncToken(): string | null {
+        return this.db.get('syncToken').value();
+    }
+
+    setFilter(filter: IFilterInfo): void {
+        this.db.set('filter', filter).write();
+    }
+
+    getFilter(): IFilterInfo {
+        return this.db.get('filter').value();
+    }
+
+    addRegisteredUser(userId: string) {
+        const key = sha512().update(userId).digest('hex');
+        this.db
+            .set(`appserviceUsers.${key}.userId`, userId)
+            .set(`appserviceUsers.${key}.registered`, true)
+            .write();
+    }
+
+    isUserRegistered(userId: string): boolean {
+        const key = sha512().update(userId).digest('hex');
+        return this.db.get(`appserviceUsers.${key}.registered`).value();
+    }
+
+    isTransactionCompleted(transactionId: string): boolean {
+        if (this.trackTransactionsInMemory) {
+            return this.completedTransactions.indexOf(transactionId) !== -1;
+        }
+
+        const key = sha512().update(transactionId).digest('hex');
+        return this.db.get(`appserviceTransactions.${key}.completed`).value();
+    }
+
+    setTransactionCompleted(transactionId: string) {
+        if (this.trackTransactionsInMemory) {
+            if (this.completedTransactions.indexOf(transactionId) === -1) {
+                this.completedTransactions.push(transactionId);
+            }
+            if (this.completedTransactions.length > this.maxInMemoryTransactions) {
+                this.completedTransactions = this.completedTransactions.reverse().slice(0, this.maxInMemoryTransactions).reverse();
+            }
+            return;
+        }
+
+        const key = sha512().update(transactionId).digest('hex');
+        this.db
+            .set(`appserviceTransactions.${key}.txnId`, transactionId)
+            .set(`appserviceTransactions.${key}.completed`, true)
+            .write();
+    }
+
+    readValue(key: string): string | null | undefined {
+        return this.db.get("kvStore").value()[key];
+    }
+
+    storeValue(key: string, value: string): void {
+        const kvStore = this.db.get("kvStore").value();
+        kvStore[key] = value;
+        this.db.set("kvStore", kvStore).write();
+    }
+
+    storageForUser(userId: string): IStorageProvider {
+        return new NamespacedFsProvider(userId, this);
+    }
+}
+
+/**
+ * A namespaced storage provider that uses the disk to store information.
+ * @category Storage providers
+ */
+class NamespacedFsProvider implements IStorageProvider {
+    constructor(private prefix: string, private parent: SimpleFsStorageProvider) {
+    }
+
+    setFilter(filter: IFilterInfo): Promise<any> | void {
+        return this.parent.storeValue(`${this.prefix}_int_filter`, JSON.stringify(filter));
+    }
+
+    getFilter(): IFilterInfo | Promise<IFilterInfo> {
+        return Promise.resolve(this.parent.readValue(`${this.prefix}_int_filter`)).then(r => r ? JSON.parse(r) : r);
+    }
+
+    setSyncToken(token: string | null): Promise<any> | void {
+        return this.parent.storeValue(`${this.prefix}_int_syncToken`, token);
+    }
+
+    getSyncToken(): string | Promise<string | null> | null {
+        return Promise.resolve(this.parent.readValue(`${this.prefix}_int_syncToken`)).then(r => r ?? null);
+    }
+
+    readValue(key: string): string | Promise<string | null | undefined> | null | undefined {
+        return this.parent.readValue(`${this.prefix}_kv_${key}`);
+    }
+
+    storeValue(key: string, value: string): Promise<any> | void {
+        return this.parent.storeValue(`${this.prefix}_kv_${key}`, value);
+    }
+}

package/src/storage/SimplePostgresStorageProvider.ts

@@ -0,0 +1,168 @@
+import * as postgres from "postgres";
+
+import { IStorageProvider } from "./IStorageProvider";
+import { IAppserviceStorageProvider } from "./IAppserviceStorageProvider";
+import { IFilterInfo } from "../IFilter";
+
+/**
+ * A barebones postgresql storage provider. It is not efficient, but it does work.
+ * @category Storage providers
+ */
+export class SimplePostgresStorageProvider implements IStorageProvider, IAppserviceStorageProvider {
+    private readonly db: postgres.Sql;
+    private readonly waitPromise: Promise<void>;
+    private completedTransactions = [];
+
+    /**
+     * Creates a new simple postgresql storage provider.
+     * @param connectionString The `postgres://` connection string to use.
+     * @param trackTransactionsInMemory True (default) to track all received appservice transactions rather than on disk.
+     * @param maxInMemoryTransactions The maximum number of transactions to hold in memory before rotating the oldest out. Defaults to 20.
+     */
+    constructor(connectionString: string, private trackTransactionsInMemory = true, private maxInMemoryTransactions = 20) {
+        this.db = postgres(connectionString);
+
+        this.waitPromise = Promise.all([
+            this.db`
+                CREATE TABLE IF NOT EXISTS bot_metadata (key TEXT NOT NULL PRIMARY KEY, value TEXT);
+            `,
+            this.db`
+                CREATE TABLE IF NOT EXISTS bot_kv (key TEXT NOT NULL PRIMARY KEY, value TEXT);
+            `,
+            this.db`
+                CREATE TABLE IF NOT EXISTS appservice_users (user_id TEXT NOT NULL PRIMARY KEY, registered BOOLEAN NOT NULL);
+            `,
+            this.db`
+                CREATE TABLE IF NOT EXISTS appservice_transactions (txn_id TEXT NOT NULL PRIMARY KEY, completed BOOLEAN NOT NULL);
+            `,
+        ]).then();
+    }
+
+    public async setSyncToken(token: string | null): Promise<any> {
+        await this.waitPromise;
+        return this.db`
+            INSERT INTO bot_metadata (key, value) VALUES ('syncToken', ${token}) 
+            ON CONFLICT (key) DO UPDATE SET value = ${token};
+        `;
+    }
+
+    public async getSyncToken(): Promise<string | null> {
+        await this.waitPromise;
+        return (await this.db`
+            SELECT value FROM bot_metadata WHERE key = 'syncToken';
+        `)[0]?.value;
+    }
+
+    public async setFilter(filter: IFilterInfo): Promise<any> {
+        await this.waitPromise;
+        const filterStr = filter ? JSON.stringify(filter) : null;
+        return this.db`
+            INSERT INTO bot_metadata (key, value) VALUES ('filter', ${filterStr}) 
+            ON CONFLICT (key) DO UPDATE SET value = ${filterStr};
+        `;
+    }
+
+    public async getFilter(): Promise<IFilterInfo> {
+        await this.waitPromise;
+        const value = (await this.db`
+            SELECT value FROM bot_metadata WHERE key = 'filter';
+        `)[0]?.value;
+        return typeof value === "string" ? JSON.parse(value) : value;
+    }
+
+    public async addRegisteredUser(userId: string): Promise<any> {
+        await this.waitPromise;
+        return this.db`
+            INSERT INTO appservice_users (user_id, registered) VALUES (${userId}, TRUE) 
+            ON CONFLICT (user_id) DO UPDATE SET registered = TRUE;
+        `;
+    }
+
+    public async isUserRegistered(userId: string): Promise<boolean> {
+        await this.waitPromise;
+        return !!(await this.db`
+            SELECT registered FROM appservice_users WHERE user_id = ${userId};
+        `)[0]?.registered;
+    }
+
+    public async setTransactionCompleted(transactionId: string): Promise<any> {
+        await this.waitPromise;
+        if (this.trackTransactionsInMemory) {
+            if (this.completedTransactions.indexOf(transactionId) === -1) {
+                this.completedTransactions.push(transactionId);
+            }
+            if (this.completedTransactions.length > this.maxInMemoryTransactions) {
+                this.completedTransactions = this.completedTransactions.reverse().slice(0, this.maxInMemoryTransactions).reverse();
+            }
+            return;
+        }
+
+        return this.db`
+            INSERT INTO appservice_transactions (txn_id, completed) VALUES (${transactionId}, TRUE) 
+            ON CONFLICT (txn_id) DO UPDATE SET completed = TRUE;
+        `;
+    }
+
+    public async isTransactionCompleted(transactionId: string): Promise<boolean> {
+        await this.waitPromise;
+        if (this.trackTransactionsInMemory) {
+            return this.completedTransactions.includes(transactionId);
+        }
+
+        return (await this.db`
+            SELECT completed FROM appservice_transactions WHERE txn_id = ${transactionId};
+        `)[0]?.completed;
+    }
+
+    public async readValue(key: string): Promise<string | null | undefined> {
+        await this.waitPromise;
+        return (await this.db`
+            SELECT value FROM bot_kv WHERE key = ${key};
+        `)[0]?.value;
+    }
+
+    public async storeValue(key: string, value: string): Promise<void> {
+        await this.waitPromise;
+        return this.db`
+            INSERT INTO bot_kv (key, value) VALUES (${key}, ${value}) 
+            ON CONFLICT (key) DO UPDATE SET value = ${value};            
+        `.then();
+    }
+
+    public storageForUser(userId: string): IStorageProvider {
+        return new NamespacedPostgresProvider(userId, this);
+    }
+}
+
+/**
+ * A namespaced storage provider that uses postgres to store information.
+ * @category Storage providers
+ */
+class NamespacedPostgresProvider implements IStorageProvider {
+    constructor(private prefix: string, private parent: SimplePostgresStorageProvider) {
+    }
+
+    public setFilter(filter: IFilterInfo): Promise<any> | void {
+        return this.parent.storeValue(`${this.prefix}_internal_filter`, JSON.stringify(filter));
+    }
+
+    public async getFilter(): Promise<IFilterInfo> {
+        return this.parent.readValue(`${this.prefix}_internal_filter`).then(r => r ? JSON.parse(r) : r);
+    }
+
+    public setSyncToken(token: string | null): Promise<any> | void {
+        return this.parent.storeValue(`${this.prefix}_internal_syncToken`, token ?? "");
+    }
+
+    public async getSyncToken(): Promise<string> {
+        return this.parent.readValue(`${this.prefix}_internal_syncToken`).then(r => r === "" ? null : r);
+    }
+
+    public storeValue(key: string, value: string): Promise<any> | void {
+        return this.parent.storeValue(`${this.prefix}_internal_kv_${key}`, value);
+    }
+
+    public readValue(key: string): string | Promise<string | null | undefined> | null | undefined {
+        return this.parent.readValue(`${this.prefix}_internal_kv_${key}`);
+    }
+}

package/src/strategies/AppserviceJoinRoomStrategy.ts

@@ -0,0 +1,47 @@
+import { IJoinRoomStrategy } from "./JoinRoomStrategy";
+import { Appservice } from "../appservice/Appservice";
+
+/**
+ * A join strategy for application services that proxies joins to an underlying join
+ * strategy while also trying to use the appservice's bot user to invite the underlying
+ * user if needed.
+ * @category Join strategies
+ */
+export class AppserviceJoinRoomStrategy implements IJoinRoomStrategy {
+    constructor(private underlyingStrategy: IJoinRoomStrategy, private appservice: Appservice) {
+    }
+
+    public async joinRoom(roomIdOrAlias: string, userId: string, apiCall: (targetRoomIdOrAlias: string) => Promise<string>): Promise<string> {
+        try {
+            // First just try joining via the apiCall
+            return await apiCall(roomIdOrAlias);
+        } catch (err) {
+            // If the user being joined is *not* the bridge bot, try and get the bridge bot to
+            // join them to the room.
+            if (userId !== this.appservice.botUserId) {
+                const client = this.appservice.botIntent.underlyingClient;
+                const roomId = await client.resolveRoom(roomIdOrAlias);
+                try {
+                    // First start with having the bridge bot invite the user to the room
+                    await client.inviteUser(userId, roomId);
+                } catch (inviteErr) {
+                    // The invite failed - use the underlying join strategy to join the room, just in case.
+                    // If there's no join strategy, we want to fall through to an error.
+                    if (this.underlyingStrategy) return this.underlyingStrategy.joinRoom(roomId, userId, apiCall);
+                    throw inviteErr;
+                }
+
+                // The invite succeeded - use the underlying join strategy to join the room or just call use
+                // the apiCall if no strategy exists. We are expecting success.
+                if (this.underlyingStrategy) return this.underlyingStrategy.joinRoom(roomId, userId, apiCall);
+                else return apiCall(roomId);
+            } else if (this.underlyingStrategy) {
+                // If the user being joined *is* the bridge bot, try and use the join strategy to join.
+                return this.underlyingStrategy.joinRoom(roomIdOrAlias, userId, apiCall);
+            }
+
+            // Finally, if all else fails, throw.
+            throw err;
+        }
+    }
+}

package/src/strategies/JoinRoomStrategy.ts

@@ -0,0 +1,45 @@
+import { extractRequestError, LogService } from "..";
+
+export interface IJoinRoomStrategy {
+    joinRoom(roomIdOrAlias: string, userId: string, apiCall: (targetRoomIdOrAlias: string) => Promise<string>): Promise<string>;
+}
+
+/**
+ * A join strategy that keeps trying to join the room on a set interval.
+ * @category Join strategies
+ */
+export class SimpleRetryJoinStrategy implements IJoinRoomStrategy {
+    // Note: The schedule must not have duplicate values to avoid problems in positioning.
+    private schedule = [
+        0,              // Right away
+        1000,           // 1 second
+        30 * 1000,      // 30 seconds
+        5 * 60 * 1000,  // 5 minutes
+        15 * 60 * 1000, // 15 minutes
+    ];
+
+    public joinRoom(roomIdOrAlias: string, userId: string, apiCall: (targetRoomIdOrAlias: string) => Promise<string>): Promise<string> {
+        let currentSchedule = this.schedule[0];
+
+        const doJoin = () => waitPromise(currentSchedule).then(() => apiCall(roomIdOrAlias));
+        const errorHandler = err => {
+            LogService.error("SimpleRetryJoinStrategy", extractRequestError(err));
+            const idx = this.schedule.indexOf(currentSchedule);
+            if (idx === this.schedule.length - 1) {
+                LogService.warn("SimpleRetryJoinStrategy", "Failed to join room " + roomIdOrAlias);
+                return Promise.reject(err);
+            } else {
+                currentSchedule = this.schedule[idx + 1];
+                return doJoin().catch(errorHandler);
+            }
+        };
+
+        return doJoin().catch(errorHandler);
+    }
+}
+
+function waitPromise(interval: number): Promise<any> {
+    return new Promise((resolve, reject) => {
+        setTimeout(resolve, interval);
+    });
+}

package/tsconfig.json

@@ -0,0 +1,22 @@
+{
+  "compilerOptions": {
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "module": "commonjs",
+    "moduleResolution": "node",
+    "target": "es2020",
+    "noImplicitAny": false,
+    "sourceMap": true,
+    "outDir": "./lib",
+    "declaration": true,
+    "types": [
+      "node",
+      "express",
+      "jest"
+    ]
+  },
+  "include": [
+    "./src/**/*",
+    "./test/**/*"
+  ]
+}