@powerhousedao/reactor-api 6.0.0-dev.107 → 6.0.0-dev.109

package/dist/src/graphql/graphql-manager.d.ts

@@ -1,21 +1,20 @@
 import type { IAnalyticsStore } from "@powerhousedao/analytics-engine-core";
-import type { IReactorClient, ISyncManager } from "@powerhousedao/reactor";
-import type { ISubgraph, SubgraphClass } from "@powerhousedao/reactor-api";
-import type { IRelationalDbLegacy } from "document-drive";
-import { type ILogger } from "document-model";
-import type express from "express";
+import type { IReactorClient, IRelationalDb, ISyncManager } from "@powerhousedao/reactor";
+import type { Context, ISubgraph, SubgraphClass } from "@powerhousedao/reactor-api";
+import type { ILogger } from "document-model";
 import type http from "node:http";
 import type { WebSocketServer } from "ws";
 import type { AuthConfig } from "../services/auth.service.js";
+import { type AuthFetchMiddleware } from "./gateway/auth-middleware.js";
 import type { AuthorizationService } from "../services/authorization.service.js";
 import type { DocumentPermissionService } from "../services/document-permission.service.js";
+import type { IGatewayAdapter, IHttpAdapter } from "./gateway/types.js";
 export type GraphqlManagerFeatureFlags = {
     enableDocumentModelSubgraphs?: boolean;
 };
 export declare class GraphQLManager {
     #private;
     private readonly path;
-    private readonly app;
     private readonly httpServer;
     private readonly wsServer;
     private readonly reactorClient;
@@ -23,27 +22,24 @@ export declare class GraphQLManager {
     private readonly analyticsStore;
     private readonly syncManager;
     private readonly logger;
+    private readonly httpAdapter;
+    private readonly gatewayAdapter;
     private readonly authConfig?;
     private readonly documentPermissionService?;
     private readonly featureFlags;
     private readonly port;
     private readonly authorizationService?;
     private initialized;
-    private router;
     private coreSubgraphsMap;
     private contextFields;
     private readonly subgraphs;
     private authService;
-    private coreApolloServer;
-    private readonly subgraphServers;
-    private readonly subgraphHandlers;
     private readonly subgraphWsDisposers;
-    private gatewayOptions;
     /** Cached document models for schema generation - updated on init and regenerate */
     private cachedDocumentModels;
-    private readonly apolloLogger;
-    constructor(path: string, app: express.Express, httpServer: http.Server, wsServer: WebSocketServer, reactorClient: IReactorClient, relationalDb: IRelationalDbLegacy, analyticsStore: IAnalyticsStore, syncManager: ISyncManager, logger: ILogger, authConfig?: AuthConfig | undefined, documentPermissionService?: DocumentPermissionService | undefined, featureFlags?: GraphqlManagerFeatureFlags, port?: number, authorizationService?: AuthorizationService | undefined);
-    init(coreSubgraphs: SubgraphClass[]): Promise<void>;
+    private readonly subgraphHandlerCache;
+    constructor(path: string, httpServer: http.Server, wsServer: WebSocketServer, reactorClient: IReactorClient, relationalDb: IRelationalDb, analyticsStore: IAnalyticsStore, syncManager: ISyncManager, logger: ILogger, httpAdapter: IHttpAdapter, gatewayAdapter: IGatewayAdapter<Context>, authConfig?: AuthConfig | undefined, documentPermissionService?: DocumentPermissionService | undefined, featureFlags?: GraphqlManagerFeatureFlags, port?: number, authorizationService?: AuthorizationService | undefined);
+    init(coreSubgraphs: SubgraphClass[], authMiddleware?: AuthFetchMiddleware): Promise<void>;
     /**
      * Regenerate document model subgraphs when models are dynamically loaded.
      * Fetches current modules from reactor client (source of truth).

package/dist/src/graphql/graphql-manager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graphql-manager.d.ts","sourceRoot":"","sources":["../../../src/graphql/graphql-manager.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"graphql-manager.d.ts","sourceRoot":"","sources":["../../../src/graphql/graphql-manager.ts"],"names":[],"mappings":"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"}

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

@@ -1,32 +1,12 @@
-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 {} from "@powerhousedao/shared/document-model";
-import bodyParser from "body-parser";
-import cors from "cors";
-import { debounce, responseForDrive } from "document-drive";
-import { childLogger } from "document-model";
-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 { 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 = [];
 /**
  * Check if a document model has any operations with valid schemas.
@@ -36,13 +16,11 @@ 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();
@@ -53,7 +31,6 @@ function filterLatestDocumentModelVersions(documentModels) {
             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) {
@@ -67,7 +44,6 @@ const DefaultFeatureFlags = {
 };
 export class GraphQLManager {
     path;
-    app;
     httpServer;
     wsServer;
     reactorClient;
@@ -75,32 +51,25 @@ export class GraphQLManager {
     analyticsStore;
     syncManager;
     logger;
+    httpAdapter;
+    gatewayAdapter;
     authConfig;
     documentPermissionService;
     featureFlags;
     port;
     authorizationService;
     initialized = false;
-    router = Router();
     coreSubgraphsMap = new Map();
     contextFields = {};
     subgraphs = new Map();
     authService = null;
-    coreApolloServer = null;
-    subgraphServers = new Map();
-    subgraphHandlers = new Map();
     subgraphWsDisposers = new Map();
-    gatewayOptions = null;
+    #authMiddleware;
     /** Cached document models for schema generation - updated on init and regenerate */
     cachedDocumentModels = [];
-    apolloLogger = childLogger([
-        "reactor-api",
-        "graphql-manager",
-        "apollo",
-    ]);
-    constructor(path, app, httpServer, wsServer, reactorClient, relationalDb, analyticsStore, syncManager, logger, authConfig, documentPermissionService, featureFlags = DefaultFeatureFlags, port = 4001, authorizationService) {
+    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.reactorClient = reactorClient;
@@ -108,6 +77,8 @@ export class GraphQLManager {
         this.analyticsStore = analyticsStore;
         this.syncManager = syncManager;
         this.logger = logger;
+        this.httpAdapter = httpAdapter;
+        this.gatewayAdapter = gatewayAdapter;
         this.authConfig = authConfig;
         this.documentPermissionService = documentPermissionService;
         this.featureFlags = featureFlags;
@@ -115,10 +86,10 @@ export class GraphQLManager {
         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 modulesResult = await this.reactorClient.getDocumentModelModules();
@@ -129,34 +100,45 @@ export class GraphQLManager {
         if (!driveModel) {
             throw new Error("DocumentDrive model required");
         }
-        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);
-            });
-            if (!result) {
-                return res.status(404).send(`${req.path} subgraph not found`);
+        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 });
             }
-            return result.handler(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),
-            });
-            this.router(req, res, next);
         });
+        this.logger.info(`Registered REST endpoint: GET ${driveRoutePath}`);
         await this.#setupCoreSubgraphs("graphql", coreSubgraphs);
         if (this.featureFlags.enableDocumentModelSubgraphs) {
             await this.#setupDocumentModelSubgraphs("graphql", models);
         }
-        await this.#createApolloGateway();
+        await this.#createSupergraphGateway();
         return this.updateRouter();
     }
     /**
@@ -190,19 +172,16 @@ export class GraphQLManager {
                 this.logger.error(`Failed to setup core subgraph ${subgraph.name}`, error);
             }
         }
-        // REST endpoint for drive info at /d/:drive
-        this.#setupDriveInfoRestEndpoint(this.router);
         return this.#setupSubgraphs(this.coreSubgraphsMap);
     }
     async #setupDocumentModelSubgraphs(supergraph, 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
+                continue;
             }
             if (!hasOperationSchemas(documentModel)) {
-                continue; // Skip document models without operation schemas
+                continue;
             }
             try {
                 const subgraphInstance = new DocumentModelSubgraph(documentModel, {
@@ -222,7 +201,12 @@ export class GraphQLManager {
                 this.logger.debug("@error", error);
             }
         }
-        return this.#setupSubgraphs(this.coreSubgraphsMap);
+        // 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) {
         const subgraphsMap = core ? this.coreSubgraphsMap : this.subgraphs;
@@ -235,7 +219,6 @@ export class GraphQLManager {
         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);
         }
@@ -271,21 +254,13 @@ export class GraphQLManager {
     updateRouter = debounce(this._updateRouter.bind(this), 1000);
     async _updateRouter() {
         this.logger.debug("Updating router");
-        // @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);
-        // 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);
-            }
+        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.
@@ -315,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");
@@ -328,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");
@@ -335,30 +340,6 @@ export class GraphQLManager {
             });
         });
     }
-    async #createApolloServer(schema) {
-        const server = new ApolloServer({
-            schema,
-            logger: this.apolloLogger,
-            introspection: true,
-            plugins: [
-                ApolloServerPluginInlineTraceDisabled(),
-                ApolloServerPluginLandingPageLocalDefault(),
-            ],
-        });
-        server.startInBackgroundHandlingStartupErrorsByLoggingAndFailingAllRequests();
-        await this.#waitForServer(server);
-        return server;
-    }
-    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);
     }
@@ -368,36 +349,24 @@ export class GraphQLManager {
                 this.logger.debug(`Setting up subgraph ${subgraph.name}`);
                 const subgraphPath = this.#getSubgraphPath(subgraph, supergraph);
                 try {
-                    // Clean up existing graphql-ws protocol handlers before starting new one.
-                    // We must NOT call dispose() here because it closes the underlying
-                    // WebSocketServer, removing its upgrade listener from the HTTP server.
-                    // Instead, we close existing clients and remove only the connection/error
-                    // listeners that graphql-ws added, preserving the upgrade listener.
-                    const existingWsDisposer = this.subgraphWsDisposers.get(subgraphPath);
-                    if (existingWsDisposer) {
-                        for (const client of this.wsServer.clients) {
-                            client.close(1001, "Going away");
-                        }
-                        this.wsServer.removeAllListeners("connection");
-                        this.wsServer.removeAllListeners("error");
-                        this.subgraphWsDisposers.delete(subgraphPath);
+                    // 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;
                     }
-                    // create subgraph schema
                     const schema = createSchema(this.cachedDocumentModels, subgraph.resolvers, subgraph.typeDefs);
-                    // create and start apollo server
-                    const existingServer = this.subgraphServers.get(subgraphPath);
-                    const server = existingServer || (await this.#createApolloServer(schema));
-                    this.subgraphServers.set(subgraphPath, server);
+                    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) {
                         try {
-                            const wsDisposer = useServer({
-                                schema,
-                                context: async (ctx) => {
-                                    const connectionParams = (ctx.connectionParams ??
-                                        {});
-                                    return this.#createWebSocketContext(connectionParams);
-                                },
-                            }, this.wsServer);
+                            const wsDisposer = this.gatewayAdapter.attachWebSocket(this.wsServer, schema, this.#makeWsContextFactory());
                             this.subgraphWsDisposers.set(subgraphPath, wsDisposer);
                             this.logger.debug(`WebSocket subscriptions enabled for ${subgraph.name}`);
                         }
@@ -415,7 +384,6 @@ export class GraphQLManager {
                             this.logger.error("Failed to setup SSE for subgraph @name at path @path: @error", subgraph.name, subgraphPath, error);
                         }
                     }
-                    this.#setupApolloExpressMiddleware(server, subgraphPath);
                 }
                 catch (error) {
                     this.logger.error("Failed to setup subgraph @name at path @path: @error", subgraph.name, subgraphPath, error);
@@ -433,91 +401,33 @@ 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;
     }
-    /**
-     * 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.cachedDocumentModels, subgraph.resolvers, subgraph.typeDefs);
     }
-    async #buildSupergrahSdl() {
-        if (!this.gatewayOptions) {
-            throw new Error("Gateway is not ready");
-        }
+    #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}`;
-        const serviceList = Array.from(subgraphs.entries()).map(([path, subgraph]) => ({
-            name: path.replace("/", ":"),
+        return Array.from(subgraphs.entries()).map(([subgraphPath, subgraph]) => ({
+            name: subgraphPath.replace("/", ":"),
             typeDefs: this.#buildSubgraphSchemaModule(subgraph).typeDefs,
-            url: `${herokuOrLocal}${path}`,
+            url: `${herokuOrLocal}${subgraphPath}`,
         }));
-        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");
-        }
-        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);
+    async #createSupergraphGateway() {
         const superGraphPath = path.join(this.path, "graphql");
-        this.#setupApolloExpressMiddleware(this.coreApolloServer, superGraphPath);
+        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);
@@ -550,19 +460,6 @@ export class GraphQLManager {
             this.logger.error("Failed to setup supergraph SSE: @error", error);
         }
     }
-    #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),
-        });
-    }
     /**
      * Set up a GraphQL-over-SSE handler at `<basePath>/stream`.
      *
@@ -582,10 +479,9 @@ export class GraphQLManager {
                 ...this.getAdditionalContextFields(),
             }),
         });
-        this.subgraphHandlers.set(ssePath, {
-            handler: sseHandler,
-            matcher: match(ssePath),
-        });
+        // 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