Support a module API surface for custom functionality (#8246)

* Early implementation of module API surface + functions for ILAG module

* Wire up dialog functions and ILAG-needed surface

* Ensure component renders for modules get overridden

* Respond to changes from module API interface

* Use a real module-api dependency

* Update for new Dialogs interface

* Add support for getConfigValue from module API

* Update the remainder of the module API interface

* Docs & cleanup

* Add some unit tests around module stuff

Needs end-to-end tests still.

* Appease early linters

* Break import cycles by not directly depending on Lifecycle

* Appease the linter

* Fix bad merge

src/modules/AppModule.ts

@@ -0,0 +1,45 @@
+/*
+Copyright 2022 The Matrix.org Foundation C.I.C.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+import { RuntimeModule } from "@matrix-org/react-sdk-module-api/lib/RuntimeModule";
+
+import { ModuleFactory } from "./ModuleFactory";
+import { ProxiedModuleApi } from "./ProxiedModuleApi";
+
+/**
+ * Wraps a module factory into a usable module. Acts as a simple container
+ * for the constructs needed to operate a module.
+ */
+export class AppModule {
+    /**
+     * The module instance.
+     */
+    public readonly module: RuntimeModule;
+
+    /**
+     * The API instance used by the module.
+     */
+    public readonly api = new ProxiedModuleApi();
+
+    /**
+     * Converts a factory into an AppModule. The factory will be called
+     * immediately.
+     * @param factory The module factory.
+     */
+    public constructor(factory: ModuleFactory) {
+        this.module = factory(this.api);
+    }
+}

src/modules/ModuleComponents.tsx

@@ -0,0 +1,40 @@
+/*
+Copyright 2022 The Matrix.org Foundation C.I.C.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+import { TextInputField } from "@matrix-org/react-sdk-module-api/lib/components/TextInputField";
+import { Spinner as ModuleSpinner } from "@matrix-org/react-sdk-module-api/lib/components/Spinner";
+import React from "react";
+
+import Field from "../components/views/elements/Field";
+import Spinner from "../components/views/elements/Spinner";
+
+// Here we define all the render factories for the module API components. This file should be
+// imported by the ModuleRunner to load them into the call stack at runtime.
+//
+// If a new component is added to the module API, it should be added here too.
+//
+// Don't forget to add a test to ensure the renderFactory is overridden! See ModuleComponents-test.tsx
+
+TextInputField.renderFactory = (props) => (
+    <Field
+        type="text"
+        value={props.value}
+        onChange={e => props.onChange(e.target.value)}
+        label={props.label}
+        autoComplete="off"
+    />
+);
+ModuleSpinner.renderFactory = () => <Spinner />;

src/modules/ModuleFactory.ts

@@ -0,0 +1,20 @@
+/*
+Copyright 2022 The Matrix.org Foundation C.I.C.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+import { RuntimeModule } from "@matrix-org/react-sdk-module-api/lib/RuntimeModule";
+import { ModuleApi } from "@matrix-org/react-sdk-module-api/lib/ModuleApi";
+
+export type ModuleFactory = (api: ModuleApi) => RuntimeModule;

src/modules/ModuleRunner.ts

@@ -0,0 +1,85 @@
+/*
+Copyright 2022 The Matrix.org Foundation C.I.C.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+import { TranslationStringsObject } from "@matrix-org/react-sdk-module-api/lib/types/translations";
+import { AnyLifecycle } from "@matrix-org/react-sdk-module-api/lib/lifecycles/types";
+
+import { AppModule } from "./AppModule";
+import { ModuleFactory } from "./ModuleFactory";
+import "./ModuleComponents";
+
+/**
+ * Handles and coordinates the operation of modules.
+ */
+export class ModuleRunner {
+    public static readonly instance = new ModuleRunner();
+
+    private modules: AppModule[] = [];
+
+    private constructor() {
+        // we only want one instance
+    }
+
+    /**
+     * Resets the runner, clearing all known modules.
+     *
+     * Intended for test usage only.
+     */
+    public reset() {
+        this.modules = [];
+    }
+
+    /**
+     * All custom translations from all registered modules.
+     */
+    public get allTranslations(): TranslationStringsObject {
+        const merged: TranslationStringsObject = {};
+
+        for (const module of this.modules) {
+            const i18n = module.api.translations;
+            if (!i18n) continue;
+
+            for (const [lang, strings] of Object.entries(i18n)) {
+                if (!merged[lang]) merged[lang] = {};
+                for (const [str, val] of Object.entries(strings)) {
+                    merged[lang][str] = val;
+                }
+            }
+        }
+
+        return merged;
+    }
+
+    /**
+     * Registers a factory which creates a module for later loading. The factory
+     * will be called immediately.
+     * @param factory The module factory.
+     */
+    public registerModule(factory: ModuleFactory) {
+        this.modules.push(new AppModule(factory));
+    }
+
+    /**
+     * Invokes a lifecycle event, notifying registered modules.
+     * @param lifecycleEvent The lifecycle event.
+     * @param args The arguments for the lifecycle event.
+     */
+    public invoke(lifecycleEvent: AnyLifecycle, ...args: any[]): void {
+        for (const module of this.modules) {
+            module.module.emit(lifecycleEvent, ...args);
+        }
+    }
+}

src/modules/ProxiedModuleApi.ts

@@ -0,0 +1,191 @@
+/*
+Copyright 2022 The Matrix.org Foundation C.I.C.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+import { ModuleApi } from "@matrix-org/react-sdk-module-api/lib/ModuleApi";
+import { TranslationStringsObject } from "@matrix-org/react-sdk-module-api/lib/types/translations";
+import { Optional } from "matrix-events-sdk";
+import { DialogProps } from "@matrix-org/react-sdk-module-api/lib/components/DialogContent";
+import React from "react";
+import { AccountAuthInfo } from "@matrix-org/react-sdk-module-api/lib/types/AccountAuthInfo";
+import { PlainSubstitution } from "@matrix-org/react-sdk-module-api/lib/types/translations";
+import * as Matrix from "matrix-js-sdk/src/matrix";
+
+import Modal from "../Modal";
+import { _t } from "../languageHandler";
+import { ModuleUiDialog } from "../components/views/dialogs/ModuleUiDialog";
+import SdkConfig from "../SdkConfig";
+import PlatformPeg from "../PlatformPeg";
+import dispatcher from "../dispatcher/dispatcher";
+import { navigateToPermalink } from "../utils/permalinks/navigator";
+import { parsePermalink } from "../utils/permalinks/Permalinks";
+import { MatrixClientPeg } from "../MatrixClientPeg";
+import { getCachedRoomIDForAlias } from "../RoomAliasCache";
+import { Action } from "../dispatcher/actions";
+import { OverwriteLoginPayload } from "../dispatcher/payloads/OverwriteLoginPayload";
+
+/**
+ * Glue between the `ModuleApi` interface and the react-sdk. Anticipates one instance
+ * to be assigned to a single module.
+ */
+export class ProxiedModuleApi implements ModuleApi {
+    private cachedTranslations: Optional<TranslationStringsObject>;
+
+    /**
+     * All custom translations used by the associated module.
+     */
+    public get translations(): Optional<TranslationStringsObject> {
+        return this.cachedTranslations;
+    }
+
+    /**
+     * @override
+     */
+    public registerTranslations(translations: TranslationStringsObject): void {
+        this.cachedTranslations = translations;
+    }
+
+    /**
+     * @override
+     */
+    public translateString(s: string, variables?: Record<string, PlainSubstitution>): string {
+        return _t(s, variables);
+    }
+
+    /**
+     * @override
+     */
+    public openDialog<
+        M extends object,
+        P extends DialogProps = DialogProps,
+        C extends React.Component = React.Component,
+    >(
+        title: string,
+        body: (props: P, ref: React.RefObject<C>) => React.ReactNode,
+    ): Promise<{ didOkOrSubmit: boolean, model: M }> {
+        return new Promise<{ didOkOrSubmit: boolean, model: M }>((resolve) => {
+            Modal.createDialog(ModuleUiDialog, {
+                title: title,
+                contentFactory: body,
+                contentProps: <DialogProps>{
+                    moduleApi: this,
+                },
+            }, "mx_CompoundDialog").finished.then(([didOkOrSubmit, model]) => {
+                resolve({ didOkOrSubmit, model });
+            });
+        });
+    }
+
+    /**
+     * @override
+     */
+    public async registerSimpleAccount(
+        username: string,
+        password: string,
+        displayName?: string,
+    ): Promise<AccountAuthInfo> {
+        const hsUrl = SdkConfig.get("validated_server_config").hsUrl;
+        const client = Matrix.createClient({ baseUrl: hsUrl });
+        const deviceName = SdkConfig.get("default_device_display_name")
+            || PlatformPeg.get().getDefaultDeviceDisplayName();
+        const req = {
+            username,
+            password,
+            initial_device_display_name: deviceName,
+            auth: undefined,
+            inhibit_login: false,
+        };
+        const creds = await (client.registerRequest(req).catch(resp => client.registerRequest({
+            ...req,
+            auth: {
+                session: resp.data.session,
+                type: "m.login.dummy",
+            },
+        })));
+
+        if (displayName) {
+            const profileClient = Matrix.createClient({
+                baseUrl: hsUrl,
+                userId: creds.user_id,
+                deviceId: creds.device_id,
+                accessToken: creds.access_token,
+            });
+            await profileClient.setDisplayName(displayName);
+        }
+
+        return {
+            homeserverUrl: hsUrl,
+            userId: creds.user_id,
+            deviceId: creds.device_id,
+            accessToken: creds.access_token,
+        };
+    }
+
+    /**
+     * @override
+     */
+    public async overwriteAccountAuth(accountInfo: AccountAuthInfo): Promise<void> {
+        dispatcher.dispatch<OverwriteLoginPayload>({
+            action: Action.OverwriteLogin,
+            credentials: {
+                ...accountInfo,
+                guest: false,
+            },
+        }, true); // require to be sync to match inherited interface behaviour
+    }
+
+    /**
+     * @override
+     */
+    public async navigatePermalink(uri: string, andJoin?: boolean): Promise<void> {
+        navigateToPermalink(uri);
+
+        const parts = parsePermalink(uri);
+        if (parts.roomIdOrAlias && andJoin) {
+            let roomId = parts.roomIdOrAlias;
+            let servers = parts.viaServers;
+            if (roomId.startsWith("#")) {
+                roomId = getCachedRoomIDForAlias(parts.roomIdOrAlias);
+                if (!roomId) {
+                    // alias resolution failed
+                    const result = await MatrixClientPeg.get().getRoomIdForAlias(parts.roomIdOrAlias);
+                    roomId = result.room_id;
+                    if (!servers) servers = result.servers; // use provided servers first, if available
+                }
+            }
+            dispatcher.dispatch({
+                action: Action.ViewRoom,
+                room_id: roomId,
+                via_servers: servers,
+            });
+
+            if (andJoin) {
+                dispatcher.dispatch({
+                    action: Action.JoinRoom,
+                });
+            }
+        }
+    }
+
+    /**
+     * @override
+     */
+    public getConfigValue<T>(namespace: string, key: string): T {
+        // Force cast to `any` because the namespace won't be known to the SdkConfig types
+        const maybeObj = SdkConfig.get(namespace as any);
+        if (!maybeObj || !(typeof maybeObj === "object")) return undefined;
+        return maybeObj[key];
+    }
+}