@powerhousedao/reactor-api 6.0.0-dev.9 → 6.0.0-dev.91

package/dist/src/graphql/graphql-manager.js

@@ -6,14 +6,14 @@ import { ApolloServerPluginLandingPageLocalDefault } from "@apollo/server/plugin
 import { expressMiddleware } from "@as-integrations/express4";
 import bodyParser from "body-parser";
 import cors from "cors";
-import { childLogger, debounce } from "document-drive";
+import { childLogger, debounce, responseForDrive } from "document-drive";
 import { Router } from "express";
 import path from "node:path";
 import { setTimeout } from "node:timers/promises";
+import { match } from "path-to-regexp";
 import { AuthService } from "../services/auth.service.js";
 import { buildSubgraphSchemaModule, createSchema, } from "../utils/create-schema.js";
-import { DocumentModelSubgraphLegacy } from "./document-model-subgraph.js";
-import { DriveSubgraph } from "./drive-subgraph.js";
+import { DocumentModelSubgraph } from "./document-model-subgraph.js";
 import { useServer } from "./websocket.js";
 class AuthenticatedDataSource extends RemoteGraphQLDataSource {
     willSendRequest(options) {
@@ -24,10 +24,41 @@ class AuthenticatedDataSource extends RemoteGraphQLDataSource {
         }
     }
 }
-const DOCUMENT_MODELS_TO_EXCLUDE = [
-    "powerhouse/document-model",
-    "powerhouse/document-drive",
-];
+const DOCUMENT_MODELS_TO_EXCLUDE = [];
+/**
+ * Check if a document model has any operations with valid schemas.
+ * Document models without valid operation schemas cannot generate valid subgraph schemas.
+ */
+function hasOperationSchemas(documentModel) {
+    const specification = documentModel.documentModel.global.specifications.at(-1);
+    if (!specification)
+        return false;
+    // Check if any operation has a schema with actual GraphQL type definitions
+    const hasValidSchema = (schema) => schema && /\b(input|type|enum|union|interface)\s+\w+/.test(schema);
+    return specification.modules.some((module) => module.operations.some((op) => hasValidSchema(op.schema)));
+}
+/**
+ * Filter document models to keep only the latest version of each unique document model.
+ * When multiple versions exist with the same name, the one with the most recent specification is kept.
+ */
+function filterLatestDocumentModelVersions(documentModels) {
+    const latestByName = new Map();
+    for (const documentModel of documentModels) {
+        const name = documentModel.documentModel.global.name;
+        const existing = latestByName.get(name);
+        if (!existing) {
+            latestByName.set(name, documentModel);
+            continue;
+        }
+        // Compare version numbers from the latest specification
+        const currentVersion = documentModel.documentModel.global.specifications.at(-1)?.version ?? 0;
+        const existingVersion = existing.documentModel.global.specifications.at(-1)?.version ?? 0;
+        if (currentVersion > existingVersion) {
+            latestByName.set(name, documentModel);
+        }
+    }
+    return Array.from(latestByName.values());
+}
 const DefaultFeatureFlags = {
     enableDocumentModelSubgraphs: true,
 };
@@ -36,40 +67,49 @@ export class GraphQLManager {
     app;
     httpServer;
     wsServer;
-    reactor;
     reactorClient;
     relationalDb;
     analyticsStore;
     syncManager;
+    logger;
     authConfig;
     documentPermissionService;
     featureFlags;
+    port;
+    authorizationService;
     initialized = false;
-    coreRouter = Router();
+    router = Router();
     coreSubgraphsMap = new Map();
-    reactorRouter = Router();
     contextFields = {};
     subgraphs = new Map();
     authService = null;
-    logger = childLogger(["reactor-api", "graphql-manager"]);
+    coreApolloServer = null;
+    subgraphServers = new Map();
+    subgraphHandlers = new Map();
+    subgraphWsDisposers = new Map();
+    gatewayOptions = null;
+    /** Cached document models for schema generation - updated on init and regenerate */
+    cachedDocumentModels = [];
     apolloLogger = childLogger([
         "reactor-api",
         "graphql-manager",
         "apollo",
     ]);
-    constructor(path, app, httpServer, wsServer, reactor, reactorClient, relationalDb, analyticsStore, syncManager, authConfig, documentPermissionService, featureFlags = DefaultFeatureFlags) {
+    constructor(path, app, httpServer, wsServer, reactorClient, relationalDb, analyticsStore, syncManager, logger, authConfig, documentPermissionService, featureFlags = DefaultFeatureFlags, port = 4001, authorizationService) {
         this.path = path;
         this.app = app;
         this.httpServer = httpServer;
         this.wsServer = wsServer;
-        this.reactor = reactor;
         this.reactorClient = reactorClient;
         this.relationalDb = relationalDb;
         this.analyticsStore = analyticsStore;
         this.syncManager = syncManager;
+        this.logger = logger;
         this.authConfig = authConfig;
         this.documentPermissionService = documentPermissionService;
         this.featureFlags = featureFlags;
+        this.port = port;
+        this.authorizationService = authorizationService;
         if (this.authConfig) {
             this.authService = new AuthService(this.authConfig);
             this.setAdditionalContextFields(this.authService.getAdditionalContextFields());
@@ -78,34 +118,25 @@ export class GraphQLManager {
     async init(coreSubgraphs) {
         this.logger.debug(`Initializing Subgraph Manager...`);
         // check if Document Drive model is available
-        const models = this.reactor.getDocumentModelModules();
+        const modulesResult = await this.reactorClient.getDocumentModelModules();
+        const models = modulesResult.results;
+        // Cache models for schema generation
+        this.cachedDocumentModels = models;
         const driveModel = models.find((it) => it.documentModel.global.name === "DocumentDrive");
         if (!driveModel) {
             throw new Error("DocumentDrive model required");
         }
-        this.coreRouter.use(cors());
-        this.coreRouter.use(bodyParser.json({ limit: "50mb" }));
-        this.coreRouter.use(bodyParser.urlencoded({ extended: true, limit: "50mb" }));
-        this.app.use("/", (req, res, next) => {
-            this.setAdditionalContextFields({
-                user: req.user,
-                isAdmin: (address) => !req.auth_enabled
-                    ? true
-                    : (req.admins
-                        ?.map((a) => a.toLowerCase())
-                        .includes(address.toLowerCase() ?? "") ?? false),
-                isUser: (address) => !req.auth_enabled
-                    ? true
-                    : (req.users
-                        ?.map((a) => a.toLowerCase())
-                        .includes(address.toLowerCase() ?? "") ?? false),
-                isGuest: (address) => !req.auth_enabled
-                    ? true
-                    : (req.guests
-                        ?.map((a) => a.toLowerCase())
-                        .includes(address.toLowerCase() ?? "") ?? false),
+        this.router.use(cors());
+        this.router.use(bodyParser.json({ limit: "50mb" }));
+        this.router.use(bodyParser.urlencoded({ extended: true, limit: "50mb" }));
+        this.router.use("/graphql", (req, res, next) => {
+            const result = this.subgraphHandlers.values().find(({ matcher }) => {
+                return matcher("/graphql" + req.path);
             });
-            this.coreRouter(req, res, next);
+            if (!result) {
+                return res.status(404).send(`${req.path} subgraph not found`);
+            }
+            return result.handler(req, res, next);
         });
         this.app.use("/", (req, res, next) => {
             this.setAdditionalContextFields({
@@ -115,35 +146,38 @@ export class GraphQLManager {
                     : (req.admins
                         ?.map((a) => a.toLowerCase())
                         .includes(address.toLowerCase() ?? "") ?? false),
-                isUser: (address) => !req.auth_enabled
-                    ? true
-                    : (req.users
-                        ?.map((a) => a.toLowerCase())
-                        .includes(address.toLowerCase() ?? "") ?? false),
-                isGuest: (address) => !req.auth_enabled
-                    ? true
-                    : (req.guests
-                        ?.map((a) => a.toLowerCase())
-                        .includes(address.toLowerCase() ?? "") ?? false),
             });
-            this.reactorRouter(req, res, next);
+            this.router(req, res, next);
         });
         await this.#setupCoreSubgraphs("graphql", coreSubgraphs);
         if (this.featureFlags.enableDocumentModelSubgraphs) {
-            await this.#setupDocumentModelSubgraphs("graphql", this.reactor.getDocumentModelModules());
+            await this.#setupDocumentModelSubgraphs("graphql", models);
         }
-        this.reactor.on("documentModelModules", (documentModels) => {
-            if (this.featureFlags.enableDocumentModelSubgraphs) {
-                this.#setupDocumentModelSubgraphs("graphql", documentModels)
-                    .then(() => this.updateRouter())
-                    .catch((error) => this.logger.error(error));
-            }
-            else {
-                this.updateRouter().catch((error) => this.logger.error(error));
-            }
-        });
+        await this.#createApolloGateway();
         return this.updateRouter();
     }
+    /**
+     * Regenerate document model subgraphs when models are dynamically loaded.
+     * Fetches current modules from reactor client (source of truth).
+     */
+    async regenerateDocumentModelSubgraphs() {
+        if (!this.featureFlags.enableDocumentModelSubgraphs) {
+            return;
+        }
+        try {
+            const modulesResult = await this.reactorClient.getDocumentModelModules();
+            const models = modulesResult.results;
+            // Update cached models for schema generation
+            this.cachedDocumentModels = models;
+            await this.#setupDocumentModelSubgraphs("graphql", models);
+            await this.updateRouter();
+            this.logger.info("Regenerated document model subgraphs with @count models", models.length);
+        }
+        catch (error) {
+            this.logger.error("Failed to regenerate document model subgraphs", error);
+            throw error;
+        }
+    }
     async #setupCoreSubgraphs(supergraph, coreSubgraphs) {
         for (const subgraph of coreSubgraphs) {
             try {
@@ -153,84 +187,103 @@ export class GraphQLManager {
                 this.logger.error(`Failed to setup core subgraph ${subgraph.name}`, error);
             }
         }
-        // special case for drive
-        await this.registerSubgraph(DriveSubgraph, undefined, true);
-        return this.#setupSubgraphs(this.coreSubgraphsMap, this.coreRouter);
+        // REST endpoint for drive info at /d/:drive
+        this.#setupDriveInfoRestEndpoint(this.router);
+        return this.#setupSubgraphs(this.coreSubgraphsMap);
     }
     async #setupDocumentModelSubgraphs(supergraph, documentModels) {
-        for (const documentModel of documentModels) {
+        // Filter to keep only the latest version of each document model
+        const latestDocumentModels = filterLatestDocumentModelVersions(documentModels);
+        for (const documentModel of latestDocumentModels) {
             if (DOCUMENT_MODELS_TO_EXCLUDE.includes(documentModel.documentModel.global.id)) {
                 continue; // Skip the legacy document model
             }
+            if (!hasOperationSchemas(documentModel)) {
+                continue; // Skip document models without operation schemas
+            }
             try {
-                const subgraphInstance = new DocumentModelSubgraphLegacy(documentModel, {
+                const subgraphInstance = new DocumentModelSubgraph(documentModel, {
                     relationalDb: this.relationalDb,
                     analyticsStore: this.analyticsStore,
-                    reactor: this.reactor,
                     reactorClient: this.reactorClient,
                     graphqlManager: this,
                     syncManager: this.syncManager,
                     path: this.path,
                     documentPermissionService: this.documentPermissionService,
+                    authorizationService: this.authorizationService,
                 });
                 await this.#addSubgraphInstance(subgraphInstance, supergraph, false);
             }
             catch (error) {
                 this.logger.error(`Failed to setup document model subgraph for ${documentModel.documentModel.global.id}`, error instanceof Error ? error.message : error);
-                this.logger.debug(error);
+                this.logger.debug("@error", error);
             }
         }
-        // special case for drive
-        await this.registerSubgraph(DriveSubgraph, undefined, true);
-        return this.#setupSubgraphs(this.coreSubgraphsMap, this.coreRouter);
+        return this.#setupSubgraphs(this.coreSubgraphsMap);
     }
     async #addSubgraphInstance(subgraphInstance, supergraph = "", core = false) {
-        await subgraphInstance.onSetup?.();
         const subgraphsMap = core ? this.coreSubgraphsMap : this.subgraphs;
         const subgraphs = subgraphsMap.get(supergraph) ?? [];
         const existingSubgraph = subgraphs.find((it) => it.name === subgraphInstance.name);
+        if (existingSubgraph) {
+            this.logger.debug(`Skipping duplicate subgraph: ${subgraphInstance.name}`);
+            return existingSubgraph;
+        }
+        await subgraphInstance.onSetup?.();
         subgraphs.push(subgraphInstance);
         subgraphsMap.set(supergraph, subgraphs);
         // also add to global graphql supergraph
         if (supergraph !== "" && supergraph !== "graphql") {
             subgraphsMap.get("graphql")?.push(subgraphInstance);
         }
-        const logMessage = `Registered ${this.path.endsWith("/") ? this.path : this.path + "/"}${supergraph ? supergraph + "/" : ""}${subgraphInstance.name} subgraph.`;
-        if (!existingSubgraph) {
-            this.logger.info(logMessage);
-        }
-        else {
-            this.logger.debug(logMessage);
-        }
+        this.logger.info(`Registered ${this.path.endsWith("/") ? this.path : this.path + "/"}${supergraph ? supergraph + "/" : ""}${subgraphInstance.name} subgraph.`);
         return subgraphInstance;
     }
+    /**
+     * Register a pre-constructed subgraph instance.
+     * Use this when you need to pass custom dependencies to a subgraph.
+     */
+    async registerSubgraphInstance(subgraphInstance, supergraph = "", core = false) {
+        return this.#addSubgraphInstance(subgraphInstance, supergraph, core);
+    }
+    /**
+     * Get the base path used for subgraph registration.
+     */
+    getBasePath() {
+        return this.path;
+    }
     async registerSubgraph(subgraph, supergraph = "", core = false) {
         const subgraphInstance = new subgraph({
             relationalDb: this.relationalDb,
             analyticsStore: this.analyticsStore,
-            reactor: this.reactor,
             reactorClient: this.reactorClient,
             graphqlManager: this,
             syncManager: this.syncManager,
             path: this.path,
             documentPermissionService: this.documentPermissionService,
+            authorizationService: this.authorizationService,
         });
         return this.#addSubgraphInstance(subgraphInstance, supergraph, core);
     }
     updateRouter = debounce(this._updateRouter.bind(this), 1000);
     async _updateRouter() {
         this.logger.debug("Updating router");
-        const newRouter = Router();
-        newRouter.use(cors());
-        newRouter.use(bodyParser.json());
         // @todo:
         // if auth enabled, subgraphs are only available to guests, users and admins
         // if auth enabled, set req user to the graphql context
         // if auth disabled, subgraphs are available to all
-        await this.#setupSubgraphs(this.subgraphs, newRouter);
-        this.reactorRouter = newRouter;
-        await this.#createApolloGateway();
-        return;
+        await this.#setupSubgraphs(this.subgraphs);
+        // Update Apollo Gateway's supergraph when subgraphs change
+        if (this.gatewayOptions) {
+            try {
+                const { supergraphSdl } = await this.#buildSupergrahSdl();
+                this.gatewayOptions.update(supergraphSdl);
+                this.logger.debug("Updated Apollo Gateway supergraph");
+            }
+            catch (error) {
+                this.logger.error("Failed to update Apollo Gateway supergraph", error);
+            }
+        }
     }
     getAdditionalContextFields = () => {
         return this.contextFields;
@@ -247,7 +300,6 @@ export class GraphQLManager {
         const context = {
             // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
             headers: connectionParams,
-            driveServer: this.reactor,
             db: this.relationalDb,
             ...this.getAdditionalContextFields(),
         };
@@ -276,8 +328,8 @@ export class GraphQLManager {
             });
         });
     }
-    #createApolloServer(schema) {
-        return new ApolloServer({
+    async #createApolloServer(schema) {
+        const server = new ApolloServer({
             schema,
             logger: this.apolloLogger,
             introspection: true,
@@ -286,6 +338,9 @@ export class GraphQLManager {
                 ApolloServerPluginLandingPageLocalDefault(),
             ],
         });
+        server.startInBackgroundHandlingStartupErrorsByLoggingAndFailingAllRequests();
+        await this.#waitForServer(server);
+        return server;
     }
     async #waitForServer(server) {
         try {
@@ -300,34 +355,50 @@ export class GraphQLManager {
     #getSubgraphPath(subgraph, supergraph) {
         return path.join(subgraph.path ?? "", supergraph, subgraph.name);
     }
-    async #setupSubgraphs(subgraphsMap, router) {
+    async #setupSubgraphs(subgraphsMap) {
         for (const [supergraph, subgraphs] of subgraphsMap.entries()) {
             for (const subgraph of subgraphs) {
                 this.logger.debug(`Setting up subgraph ${subgraph.name}`);
+                const subgraphPath = this.#getSubgraphPath(subgraph, supergraph);
                 try {
+                    // dispose existing websocket server before starting new one
+                    const existingWsDisposer = this.subgraphWsDisposers.get(subgraphPath);
+                    if (existingWsDisposer) {
+                        try {
+                            await existingWsDisposer.dispose();
+                        }
+                        catch {
+                            // ignore error when disposing websocket server
+                        }
+                        this.subgraphWsDisposers.delete(subgraphPath);
+                    }
                     // create subgraph schema
-                    const schema = createSchema(this.reactor, subgraph.resolvers, subgraph.typeDefs);
+                    const schema = createSchema(this.cachedDocumentModels, subgraph.resolvers, subgraph.typeDefs);
                     // create and start apollo server
-                    const server = this.#createApolloServer(schema);
-                    server.startInBackgroundHandlingStartupErrorsByLoggingAndFailingAllRequests();
-                    await this.#waitForServer(server);
+                    const existingServer = this.subgraphServers.get(subgraphPath);
+                    const server = existingServer || (await this.#createApolloServer(schema));
+                    this.subgraphServers.set(subgraphPath, server);
                     if (subgraph.hasSubscriptions) {
-                        useServer({
-                            schema,
-                            context: async (ctx) => {
-                                const connectionParams = (ctx.connectionParams ??
-                                    {});
-                                return this.#createWebSocketContext(connectionParams);
-                            },
-                        }, this.wsServer);
-                        this.logger.info(`WebSocket subscriptions enabled for ${subgraph.name}`);
+                        try {
+                            const wsDisposer = useServer({
+                                schema,
+                                context: async (ctx) => {
+                                    const connectionParams = (ctx.connectionParams ??
+                                        {});
+                                    return this.#createWebSocketContext(connectionParams);
+                                },
+                            }, this.wsServer);
+                            this.subgraphWsDisposers.set(subgraphPath, wsDisposer);
+                            this.logger.debug(`WebSocket subscriptions enabled for ${subgraph.name}`);
+                        }
+                        catch (error) {
+                            this.logger.error("Failed to setup websocket for subgraph @name at path @path: @error", subgraph.name, subgraphPath, error);
+                        }
                     }
-                    const path = this.#getSubgraphPath(subgraph, supergraph);
-                    this.#setupApolloExpressMiddleware(server, router, path);
+                    this.#setupApolloExpressMiddleware(server, subgraphPath);
                 }
                 catch (error) {
-                    this.logger.error(`Failed to setup subgraph ${subgraph.name} at path ${this.#getSubgraphPath(subgraph, supergraph)}`);
-                    this.logger.error(error);
+                    this.logger.error("Failed to setup subgraph @name at path @path: @error", subgraph.name, subgraphPath, error);
                 }
             }
         }
@@ -348,69 +419,103 @@ export class GraphQLManager {
         }
         return subgraphsMap;
     }
+    /**
+     * Setup REST GET endpoint for drive info at /d/:drive
+     * Accepts both drive slug (e.g., "powerhouse") and UUID
+     * Returns DriveInfo JSON: { id, name, slug, icon, meta, graphqlEndpoint }
+     */
+    #setupDriveInfoRestEndpoint(router) {
+        const routePath = path.join(this.path, "d/:drive");
+        router.get(routePath, (req, res) => {
+            const driveIdOrSlug = req.params.drive;
+            if (!driveIdOrSlug) {
+                res.status(400).json({ error: "Drive ID or slug is required" });
+                return;
+            }
+            (async () => {
+                const driveDoc = await this.reactorClient.get(driveIdOrSlug);
+                // Construct the graphqlEndpoint from the request
+                // Use X-Forwarded-Proto header when behind a reverse proxy (Heroku, Traefik, etc.)
+                const forwardedProto = req.get("x-forwarded-proto");
+                const protocol = (forwardedProto ?? req.protocol) + ":";
+                const host = req.get("host") ?? "";
+                const basePath = this.path === "/" ? "" : this.path;
+                const graphqlEndpoint = `${protocol}//${host}${basePath}/graphql/r`;
+                const driveInfo = responseForDrive(driveDoc, graphqlEndpoint);
+                res.json(driveInfo);
+            })().catch((error) => {
+                this.logger.debug(`Drive not found: ${driveIdOrSlug}`, error);
+                res.status(404).json({ error: "Drive not found" });
+            });
+        });
+        this.logger.info(`Registered REST endpoint: GET ${routePath}`);
+    }
     #buildSubgraphSchemaModule(subgraph) {
-        return buildSubgraphSchemaModule(this.reactor, subgraph.resolvers, subgraph.typeDefs);
+        return buildSubgraphSchemaModule(this.cachedDocumentModels, subgraph.resolvers, subgraph.typeDefs);
     }
-    async #createApolloGateway() {
+    async #buildSupergrahSdl() {
+        if (!this.gatewayOptions) {
+            throw new Error("Gateway is not ready");
+        }
         const subgraphs = this.#getAllSubgraphs();
-        try {
-            const herokuOrLocal = process.env.HEROKU_APP_DEFAULT_DOMAIN_NAME
-                ? `https://${process.env.HEROKU_APP_DEFAULT_DOMAIN_NAME}`
-                : `http://localhost:${process.env.PORT ?? 4001}`;
-            const serviceList = Array.from(subgraphs.entries()).map(([path, subgraph]) => ({
-                name: path.replace("/", ":"),
-                typeDefs: this.#buildSubgraphSchemaModule(subgraph).typeDefs,
-                url: `${herokuOrLocal}${path}`,
-            }));
-            const gateway = new ApolloGateway({
-                supergraphSdl: new LocalCompose({
-                    localServiceList: serviceList,
-                }),
-                buildService: (serviceConfig) => {
-                    return new AuthenticatedDataSource(serviceConfig);
-                },
-            });
-            const server = new ApolloServer({
-                gateway,
-                logger: this.apolloLogger,
-                introspection: true,
-                plugins: [
-                    ApolloServerPluginDrainHttpServer({
-                        httpServer: this.httpServer,
-                    }),
-                    ApolloServerPluginInlineTraceDisabled(),
-                    ApolloServerPluginLandingPageLocalDefault(),
-                ],
-            });
-            await server.start();
-            await this.#waitForServer(server);
-            const superGraphPath = path.join(this.path, "graphql");
-            this.#setupApolloExpressMiddleware(server, this.reactorRouter, superGraphPath);
-            if (!this.initialized) {
-                this.logger.info(`Registered ${superGraphPath} supergraph `);
-                this.initialized = true;
-            }
-            return server;
+        const herokuOrLocal = process.env.HEROKU_APP_DEFAULT_DOMAIN_NAME
+            ? `https://${process.env.HEROKU_APP_DEFAULT_DOMAIN_NAME}`
+            : `http://localhost:${this.port}`;
+        const serviceList = Array.from(subgraphs.entries()).map(([path, subgraph]) => ({
+            name: path.replace("/", ":"),
+            typeDefs: this.#buildSubgraphSchemaModule(subgraph).typeDefs,
+            url: `${herokuOrLocal}${path}`,
+        }));
+        const localCompose = new LocalCompose({
+            localServiceList: serviceList,
+        });
+        return await localCompose.initialize(this.gatewayOptions);
+    }
+    async #createApolloGateway() {
+        const gateway = new ApolloGateway({
+            supergraphSdl: async (options) => {
+                this.gatewayOptions = options;
+                return await this.#buildSupergrahSdl();
+            },
+            buildService: (serviceConfig) => {
+                return new AuthenticatedDataSource(serviceConfig);
+            },
+        });
+        if (this.coreApolloServer) {
+            throw new Error("Supergrah server is already running");
         }
-        catch (e) {
-            if (e instanceof Error) {
-                this.logger.error(e.message);
-            }
-            else {
-                this.logger.error("Could not create Apollo Gateway", e);
-            }
+        this.coreApolloServer = new ApolloServer({
+            gateway,
+            logger: this.apolloLogger,
+            introspection: true,
+            plugins: [
+                ApolloServerPluginDrainHttpServer({ httpServer: this.httpServer }),
+                ApolloServerPluginInlineTraceDisabled(),
+                ApolloServerPluginLandingPageLocalDefault(),
+            ],
+        });
+        await this.coreApolloServer.start();
+        await this.#waitForServer(this.coreApolloServer);
+        const superGraphPath = path.join(this.path, "graphql");
+        this.#setupApolloExpressMiddleware(this.coreApolloServer, superGraphPath);
+        if (!this.initialized) {
+            this.logger.info(`Registered ${superGraphPath} supergraph `);
+            this.initialized = true;
         }
+        return;
     }
-    #setupApolloExpressMiddleware(server, router, path) {
-        router.use(path, expressMiddleware(server, {
-            context: ({ req }) => Promise.resolve({
-                headers: req.headers,
-                driveId: req.params.drive ?? undefined,
-                driveServer: this.reactor,
-                db: this.relationalDb,
-                ...this.getAdditionalContextFields(),
+    #setupApolloExpressMiddleware(server, path) {
+        this.subgraphHandlers.set(path, {
+            handler: expressMiddleware(server, {
+                context: ({ req }) => Promise.resolve({
+                    headers: req.headers,
+                    driveId: req.params.drive ?? undefined,
+                    db: this.relationalDb,
+                    ...this.getAdditionalContextFields(),
+                }),
             }),
-        }));
+            matcher: match(path),
+        });
     }
 }
 //# sourceMappingURL=graphql-manager.js.map