@powerhousedao/reactor-api 6.0.0-dev.11 → 6.0.0-dev.111

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

@@ -1,33 +1,13 @@
-import { ApolloGateway, LocalCompose, RemoteGraphQLDataSource, } from "@apollo/gateway";
-import { ApolloServer } from "@apollo/server";
-import { ApolloServerPluginInlineTraceDisabled } from "@apollo/server/plugin/disabled";
-import { ApolloServerPluginDrainHttpServer } from "@apollo/server/plugin/drainHttpServer";
-import { ApolloServerPluginLandingPageLocalDefault } from "@apollo/server/plugin/landingPage/default";
-import { expressMiddleware } from "@as-integrations/express4";
-import bodyParser from "body-parser";
-import cors from "cors";
-import { childLogger, debounce } 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 { debounce } from "../packages/util.js";
 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 { getAuthContext, } from "./gateway/auth-middleware.js";
+import { buildSubgraphSchemaModule, createMergedSchema, createSchema, } from "../utils/create-schema.js";
+import { DocumentModelSubgraph } from "./document-model-subgraph.js";
+import { createGraphQLSSEHandler } from "./sse.js";
 import { useServer } from "./websocket.js";
-class AuthenticatedDataSource extends RemoteGraphQLDataSource {
-    willSendRequest(options) {
-        const { authorization } = options.context.headers;
-        // console.log("context", options.context.headers.authorization);
-        if (authorization && options?.request.http) {
-            options.request.http.headers.set("authorization", authorization);
-        }
-    }
-}
-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.
@@ -36,126 +16,153 @@ 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.
+ */
+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;
+        }
+        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,
 };
 export class GraphQLManager {
     path;
-    app;
     httpServer;
     wsServer;
-    reactor;
     reactorClient;
     relationalDb;
     analyticsStore;
     syncManager;
+    logger;
+    httpAdapter;
+    gatewayAdapter;
     authConfig;
     documentPermissionService;
     featureFlags;
+    port;
+    authorizationService;
     initialized = false;
-    coreRouter = Router();
     coreSubgraphsMap = new Map();
-    reactorRouter = Router();
     contextFields = {};
     subgraphs = new Map();
     authService = null;
-    logger = childLogger(["reactor-api", "graphql-manager"]);
-    apolloLogger = childLogger([
-        "reactor-api",
-        "graphql-manager",
-        "apollo",
-    ]);
-    constructor(path, app, httpServer, wsServer, reactor, reactorClient, relationalDb, analyticsStore, syncManager, authConfig, documentPermissionService, featureFlags = DefaultFeatureFlags) {
+    subgraphWsDisposers = new Map();
+    #authMiddleware;
+    /** Cached document models for schema generation - updated on init and regenerate */
+    cachedDocumentModels = [];
+    subgraphHandlerCache = new Map();
+    constructor(path, httpServer, wsServer, reactorClient, relationalDb, analyticsStore, syncManager, logger, httpAdapter, gatewayAdapter, 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.httpAdapter = httpAdapter;
+        this.gatewayAdapter = gatewayAdapter;
         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());
         }
     }
-    async init(coreSubgraphs) {
+    async init(coreSubgraphs, authMiddleware) {
+        this.#authMiddleware = authMiddleware;
         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.coreRouter(req, res, next);
-        });
-        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.reactorRouter(req, res, next);
+        await this.gatewayAdapter.start(this.httpServer);
+        this.httpAdapter.setupMiddleware({ bodyLimit: "50mb" });
+        // Register REST endpoint for drive info as a framework-agnostic FetchHandler.
+        const driveRoutePath = path.join(this.path, "d/:drive");
+        const driveMatcher = match(driveRoutePath);
+        this.httpAdapter.mount(driveRoutePath, async (request) => {
+            const url = new URL(request.url);
+            const matched = driveMatcher(url.pathname);
+            const driveIdOrSlug = matched ? matched.params.drive : undefined;
+            if (!driveIdOrSlug) {
+                return Response.json({ error: "Drive ID or slug is required" }, { status: 400 });
+            }
+            try {
+                const driveDoc = await this.reactorClient.get(driveIdOrSlug);
+                const forwardedProto = request.headers.get("x-forwarded-proto");
+                const protocol = (forwardedProto ?? url.protocol.replace(":", "")) + ":";
+                const host = request.headers.get("host") ?? "";
+                const basePath = this.path === "/" ? "" : this.path;
+                const graphqlEndpoint = `${protocol}//${host}${basePath}/graphql/r`;
+                return Response.json({
+                    id: driveDoc.header.id,
+                    slug: driveDoc.header.slug,
+                    meta: driveDoc.header.meta,
+                    name: driveDoc.state.global.name,
+                    icon: driveDoc.state.global.icon ?? undefined,
+                    ...(graphqlEndpoint && { graphqlEndpoint }),
+                });
+            }
+            catch (error) {
+                this.logger.debug(`Drive not found: ${driveIdOrSlug}`, error);
+                return Response.json({ error: "Drive not found" }, { status: 404 });
+            }
         });
+        this.logger.info(`Registered REST endpoint: GET ${driveRoutePath}`);
         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.#createSupergraphGateway();
         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 {
@@ -165,87 +172,100 @@ 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);
+        return this.#setupSubgraphs(this.coreSubgraphsMap);
     }
     async #setupDocumentModelSubgraphs(supergraph, documentModels) {
-        for (const documentModel of documentModels) {
+        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
+                continue;
             }
             if (!hasOperationSchemas(documentModel)) {
-                continue; // Skip document models without operation schemas
+                continue;
             }
             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);
+        // Document model subgraph instances are added to this.subgraphs above.
+        // Their handlers are wired in _updateRouter() → #setupSubgraphs(this.subgraphs),
+        // which is called at the end of init() via updateRouter(). We intentionally do
+        // NOT call #setupSubgraphs(this.coreSubgraphsMap) here - doing so would
+        // create duplicate Apollo servers for the same core-subgraph schemas, which
+        // in the new IGatewayAdapter architecture hangs #waitForServer and blocks init().
     }
     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);
+        try {
+            await this.gatewayAdapter.updateSupergraph();
+            this.logger.debug("Updated Apollo Gateway supergraph");
+        }
+        catch (error) {
+            this.logger.error("Failed to update Apollo Gateway supergraph", error);
+        }
+        // Refresh the supergraph-level SSE handler so it picks up
+        // any newly registered subscription-enabled subgraphs.
+        const superGraphPath = path.join(this.path, "graphql");
+        this.#setupSupergraphSSE(superGraphPath);
     }
     getAdditionalContextFields = () => {
         return this.contextFields;
@@ -262,7 +282,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(),
         };
@@ -271,6 +290,29 @@ export class GraphQLManager {
         }
         return context;
     }
+    #makeContextFactory() {
+        return (request) => {
+            const authCtx = getAuthContext(request);
+            const headers = {};
+            request.headers.forEach((v, k) => {
+                headers[k] = v;
+            });
+            return Promise.resolve({
+                headers,
+                db: this.relationalDb,
+                ...this.getAdditionalContextFields(),
+                user: authCtx?.user,
+                isAdmin: authCtx
+                    ? (addr) => !authCtx.auth_enabled
+                        ? true
+                        : authCtx.admins.includes(addr.toLowerCase())
+                    : () => true,
+            });
+        };
+    }
+    #makeWsContextFactory() {
+        return (connectionParams) => this.#createWebSocketContext(connectionParams);
+    }
     setSupergraph(supergraph, subgraphs) {
         this.subgraphs.set(supergraph, subgraphs);
         const globalSubgraphs = this.subgraphs.get("graphql");
@@ -284,6 +326,13 @@ export class GraphQLManager {
     }
     async shutdown() {
         this.logger.info("Shutting down GraphQL Manager");
+        // Dispose per-subgraph WebSocket handlers before closing the WS server.
+        for (const disposer of this.subgraphWsDisposers.values()) {
+            await disposer.dispose();
+        }
+        this.subgraphWsDisposers.clear();
+        // Stop all Apollo servers (per-subgraph + federation gateway) via the adapter.
+        await this.gatewayAdapter.stop();
         return new Promise((resolve) => {
             this.wsServer.close(() => {
                 this.logger.info("WebSocket server closed");
@@ -291,58 +340,53 @@ export class GraphQLManager {
             });
         });
     }
-    #createApolloServer(schema) {
-        return new ApolloServer({
-            schema,
-            logger: this.apolloLogger,
-            introspection: true,
-            plugins: [
-                ApolloServerPluginInlineTraceDisabled(),
-                ApolloServerPluginLandingPageLocalDefault(),
-            ],
-        });
-    }
-    async #waitForServer(server) {
-        try {
-            server.assertStarted("waitForServer");
-            return true;
-        }
-        catch {
-            await setTimeout(100);
-            return this.#waitForServer(server);
-        }
-    }
     #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 {
-                    // create subgraph schema
-                    const schema = createSchema(this.reactor, subgraph.resolvers, subgraph.typeDefs);
-                    // create and start apollo server
-                    const server = this.#createApolloServer(schema);
-                    server.startInBackgroundHandlingStartupErrorsByLoggingAndFailingAllRequests();
-                    await this.#waitForServer(server);
+                    // Skip if handler already cached - subgraphs are deduplicated by name
+                    // in #addSubgraphInstance, so a cached path means the schema is unchanged.
+                    // This prevents unbounded schema/server creation across repeated
+                    // _updateRouter() calls. The handler was already mounted on first setup,
+                    // so no re-mount is needed.
+                    if (this.subgraphHandlerCache.has(subgraphPath)) {
+                        continue;
+                    }
+                    const schema = createSchema(this.cachedDocumentModels, subgraph.resolvers, subgraph.typeDefs);
+                    const rawHandler = await this.gatewayAdapter.createHandler(schema, this.#makeContextFactory());
+                    const fetchHandler = this.#authMiddleware
+                        ? this.#authMiddleware(rawHandler)
+                        : rawHandler;
+                    this.subgraphHandlerCache.set(subgraphPath, fetchHandler);
+                    this.httpAdapter.mount(subgraphPath, fetchHandler);
                     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 = this.gatewayAdapter.attachWebSocket(this.wsServer, schema, this.#makeWsContextFactory());
+                            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);
+                        }
+                        // Set up SSE (Server-Sent Events) transport alongside WebSocket.
+                        // Clients can use SSE by sending POST requests with
+                        // Accept: text/event-stream to the /stream sub-path.
+                        try {
+                            this.#setupSSEHandler(schema, subgraphPath);
+                            this.logger.debug(`SSE subscriptions enabled for ${subgraph.name}`);
+                        }
+                        catch (error) {
+                            this.logger.error("Failed to setup SSE for subgraph @name at path @path: @error", subgraph.name, subgraphPath, error);
+                        }
                     }
-                    const path = this.#getSubgraphPath(subgraph, supergraph);
-                    this.#setupApolloExpressMiddleware(server, router, path);
                 }
                 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);
                 }
             }
         }
@@ -357,75 +401,87 @@ export class GraphQLManager {
                 continue;
             }
             for (const subgraph of subgraphs) {
-                const path = this.#getSubgraphPath(subgraph, supergraph);
-                subgraphsMap.set(path, subgraph);
+                const subgraphPath = this.#getSubgraphPath(subgraph, supergraph);
+                subgraphsMap.set(subgraphPath, subgraph);
             }
         }
         return subgraphsMap;
     }
     #buildSubgraphSchemaModule(subgraph) {
-        return buildSubgraphSchemaModule(this.reactor, subgraph.resolvers, subgraph.typeDefs);
+        return buildSubgraphSchemaModule(this.cachedDocumentModels, subgraph.resolvers, subgraph.typeDefs);
     }
-    async #createApolloGateway() {
+    #getSubgraphDefinitions() {
         const subgraphs = this.#getAllSubgraphs();
+        const herokuOrLocal = process.env.HEROKU_APP_DEFAULT_DOMAIN_NAME
+            ? `https://${process.env.HEROKU_APP_DEFAULT_DOMAIN_NAME}`
+            : `http://localhost:${this.port}`;
+        return Array.from(subgraphs.entries()).map(([subgraphPath, subgraph]) => ({
+            name: subgraphPath.replace("/", ":"),
+            typeDefs: this.#buildSubgraphSchemaModule(subgraph).typeDefs,
+            url: `${herokuOrLocal}${subgraphPath}`,
+        }));
+    }
+    async #createSupergraphGateway() {
+        const superGraphPath = path.join(this.path, "graphql");
+        const rawHandler = await this.gatewayAdapter.createSupergraphHandler(() => this.#getSubgraphDefinitions(), this.httpServer, this.#makeContextFactory());
+        const fetchHandler = this.#authMiddleware
+            ? this.#authMiddleware(rawHandler)
+            : rawHandler;
+        this.httpAdapter.mount(superGraphPath, fetchHandler);
+        // Set up SSE subscriptions at the supergraph level (/graphql/stream).
+        // Build a subscription schema from all subgraphs that define subscriptions.
+        this.#setupSupergraphSSE(superGraphPath);
+        if (!this.initialized) {
+            this.logger.info(`Registered ${superGraphPath} supergraph `);
+            this.initialized = true;
+        }
+        return;
+    }
+    /**
+     * Set up an SSE subscription endpoint at the supergraph level.
+     * Merges the schemas of all subscription-enabled subgraphs so that
+     * clients can subscribe at /graphql/stream without knowing individual
+     * subgraph paths.
+     */
+    #setupSupergraphSSE(superGraphPath) {
+        const allSubgraphs = this.#getAllSubgraphs();
+        const modules = Array.from(allSubgraphs.values())
+            .filter((subgraph) => subgraph.hasSubscriptions)
+            .map((subgraph) => this.#buildSubgraphSchemaModule(subgraph));
+        if (modules.length === 0) {
+            return;
+        }
         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 mergedSchema = createMergedSchema(modules);
+            this.#setupSSEHandler(mergedSchema, superGraphPath);
+            this.logger.debug(`SSE subscriptions enabled at supergraph level (merged from ${modules.length} subgraph(s))`);
         }
-        catch (e) {
-            if (e instanceof Error) {
-                this.logger.error(e.message);
-            }
-            else {
-                this.logger.error("Could not create Apollo Gateway", e);
-            }
+        catch (error) {
+            this.logger.error("Failed to setup supergraph SSE: @error", error);
         }
     }
-    #setupApolloExpressMiddleware(server, router, path) {
-        router.use(path, expressMiddleware(server, {
-            context: ({ req }) => Promise.resolve({
+    /**
+     * Set up a GraphQL-over-SSE handler at `<basePath>/stream`.
+     *
+     * Clients subscribe by sending a POST with `Accept: text/event-stream`
+     * to the `/stream` sub-path. Authentication is handled by the normal
+     * Express middleware (Authorization header), unlike WebSocket which
+     * needs its own connectionParams-based auth.
+     */
+    #setupSSEHandler(schema, basePath) {
+        const ssePath = basePath + "/stream";
+        const sseHandler = createGraphQLSSEHandler({
+            schema,
+            contextFactory: (req) => ({
                 headers: req.headers,
-                driveId: req.params.drive ?? undefined,
-                driveServer: this.reactor,
+                driveId: req.params?.drive ?? undefined,
                 db: this.relationalDb,
                 ...this.getAdditionalContextFields(),
             }),
-        }));
+        });
+        // SSE handler is Express-specific; mount directly on the underlying app.
+        // TODO: replace sse.ts with a Fetch API handler so this can use httpAdapter.mount()
+        this.httpAdapter.handle.use(ssePath, sseHandler);
     }
 }
 //# sourceMappingURL=graphql-manager.js.map