feat: add support for config splitting

cli/e2e/smoke.test.ts

@@ -27,7 +27,7 @@ describe('Bun CLI', () => {
 
     expect(exitCode, `exited with non-zero:\nstdout:\n${stdout.toString()}\n\nstderr:\n${stderr.toString()}`).toBe(0);
 
-    expect(stdout.toString()).toContain('Router config successfully written');
+    expect(stdout.toString()).toContain('Router execution config successfully written to');
   });
 });
 
@@ -52,6 +52,6 @@ describe('Node CLI', () => {
 
     expect(exitCode, `exited with non-zero:\nstdout:\n${stdout.toString()}\n\nstderr:\n${stderr.toString()}`).toBe(0);
 
-    expect(stdout.toString()).toContain('Router config successfully written');
+    expect(stdout.toString()).toContain('Router execution config successfully written to');
   });
 });

cli/src/commands/auth/utils.ts

@@ -24,11 +24,14 @@ export interface KeycloakTokenResponse {
   refresh_expires_in: number;
 }
 
+export type GraphTokenFeature = 'split-config-loading';
+
 export interface GraphToken {
   iss?: string;
   iat?: number;
   federated_graph_id: string;
   organization_id: string;
+  features?: GraphTokenFeature[];
 }
 
 export interface DecodedAccessToken {

cli/src/commands/graph/federated-graph/commands/fetch.ts

@@ -1,10 +1,21 @@
-import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { existsSync } from 'node:fs';
+import { mkdir, readdir, writeFile } from 'node:fs/promises';
 import { Command } from 'commander';
 import yaml from 'js-yaml';
 import { join, resolve } from 'pathe';
 import pc from 'picocolors';
 import { BaseCommandOptions } from '../../../../core/types/types.js';
-import { fetchRouterConfig, getFederatedGraphSchemas, getSubgraphSDL, getSubgraphsOfFedGraph } from '../utils.js';
+import { getFederatedGraphSchemas, getSubgraphSDL, getSubgraphsOfFedGraph } from '../utils.js';
+import { featureFlagsDir, fetchRouterConfig, writeFeatureFlagConfigToFile } from '../../../router/utils.js';
+
+const cosmoConfigFile = 'cosmoConfig.json';
+const cosmoMapperFile = 'cosmo-mapper.json';
+const cosmoSchemaFile = 'cosmoSchema.graphql';
+const cosmoClientSchemaFile = 'cosmoClientSchema.graphql';
+const cosmoCompositionFile = 'cosmo-composition.yaml';
+const roverCompositionFile = 'rover-composition.yaml';
+const apolloSchemaFile = 'apolloSchema.graphql';
+const apolloScriptFile = 'apollo.sh';
 
 export default (opts: BaseCommandOptions) => {
   const cmd = new Command('fetch');
@@ -29,32 +40,59 @@ export default (opts: BaseCommandOptions) => {
         namespace: options.namespace,
       });
 
-      const basePath = resolve(options.out, `${name}${options.namespace ? `-${options.namespace}` : ''}`);
+      let basePath = options.out ? resolve(options.out) : resolve();
+      basePath = join(basePath, `${name}-${options.namespace || 'default'}`);
+      if (!existsSync(basePath)) {
+        await mkdir(basePath, { recursive: true });
+      }
+
+      const entries = await readdir(basePath);
+      if (entries.length > 0) {
+        console.log(pc.red(`Output directory "${basePath}" is not empty. Please provide an empty directory path.`));
+        process.exitCode = 1;
+        return;
+      }
+
       const superGraphPath = join(basePath, '/supergraph/');
       const subgraphPath = join(basePath, '/subgraphs/');
       const scriptsPath = join(basePath, '/scripts/');
 
       if (!existsSync(superGraphPath)) {
-        mkdirSync(superGraphPath, { recursive: true });
+        await mkdir(superGraphPath, { recursive: true });
       }
       if (!existsSync(subgraphPath)) {
-        mkdirSync(subgraphPath, { recursive: true });
+        await mkdir(subgraphPath, { recursive: true });
       }
       if (!existsSync(scriptsPath) && options.apolloCompatibility) {
-        mkdirSync(scriptsPath, { recursive: true });
+        await mkdir(scriptsPath, { recursive: true });
       }
 
       const routerConfig = await fetchRouterConfig({
         client: opts.client,
         name,
         namespace: options.namespace,
       });
-      writeFileSync(join(superGraphPath, `cosmoConfig.json`), routerConfig);
+      await writeFile(join(superGraphPath, cosmoConfigFile), routerConfig.routerConfig);
+      if (routerConfig.mapper) {
+        // The mapper file is only available when `split-config-loading` is enabled
+        await writeFile(join(basePath, cosmoMapperFile), JSON.stringify(routerConfig.mapper));
+      }
 
-      writeFileSync(join(superGraphPath, `cosmoSchema.graphql`), fedGraphSchemas.sdl);
+      if (routerConfig.featureFlags?.size) {
+        // Same as the mapper, feature flags are only available when `split-config-loading` is enabled
+        const featureFlagsPath = join(basePath, featureFlagsDir);
+        if (!existsSync(featureFlagsPath)) {
+          await mkdir(featureFlagsPath);
+        }
 
+        for (const [featureFlagName, featureFlagConfig] of routerConfig.featureFlags) {
+          await writeFeatureFlagConfigToFile(featureFlagsPath, featureFlagName, featureFlagConfig);
+        }
+      }
+
+      await writeFile(join(superGraphPath, cosmoSchemaFile), fedGraphSchemas.sdl);
       if (fedGraphSchemas.clientSchema) {
-        writeFileSync(join(superGraphPath, `cosmoClientSchema.graphql`), fedGraphSchemas.clientSchema);
+        await writeFile(join(superGraphPath, cosmoClientSchemaFile), fedGraphSchemas.clientSchema);
       }
 
       const subgraphs = await getSubgraphsOfFedGraph({ client: opts.client, name, namespace: options.namespace });
@@ -125,14 +163,14 @@ export default (opts: BaseCommandOptions) => {
             };
           }
         }
-        writeFileSync(filePath, subgraphSDL);
+        await writeFile(filePath, subgraphSDL);
       }
 
       const cosmoCompositionConfig = yaml.dump({
         version: 1,
         subgraphs: cosmoSubgraphsConfig,
       });
-      writeFileSync(join(basePath, `cosmo-composition.yaml`), cosmoCompositionConfig);
+      await writeFile(join(basePath, cosmoCompositionFile), cosmoCompositionConfig);
 
       if (options.apolloCompatibility) {
         const roverCompositionConfig = yaml.dump({
@@ -156,15 +194,14 @@ export default (opts: BaseCommandOptions) => {
                   },
                 },
         });
-        writeFileSync(join(basePath, `rover-composition.yaml`), roverCompositionConfig);
+
+        const absRoverCompositionFile = join(basePath, roverCompositionFile);
+        await writeFile(absRoverCompositionFile, roverCompositionConfig);
 
         const apolloScript = `npm install -g @apollo/rover
-rover supergraph compose --config '${join(basePath, `rover-composition.yaml`)}' --output '${join(
-          superGraphPath,
-          'apolloSchema.graphql',
-        )}'
+rover supergraph compose --config '${absRoverCompositionFile}' --output '${join(superGraphPath, apolloSchemaFile)}'
 `;
-        writeFileSync(join(scriptsPath, `apollo.sh`), apolloScript);
+        await writeFile(join(scriptsPath, apolloScriptFile), apolloScript);
       }
 
       console.log(

cli/src/commands/graph/federated-graph/utils.ts

@@ -1,71 +1,8 @@
 import { EnumStatusCode } from '@wundergraph/cosmo-connect/dist/common/common_pb';
 import { Subgraph as ProtoSubgraph } from '@wundergraph/cosmo-connect/dist/platform/v1/platform_pb';
-import { program } from 'commander';
-import jwtDecode from 'jwt-decode';
 import pc from 'picocolors';
 import { Client } from '../../../core/client/client.js';
-import { config, getBaseHeaders } from '../../../core/config.js';
-import { GraphToken } from '../../auth/utils.js';
-
-export const fetchRouterConfig = async ({
-  client,
-  name,
-  namespace,
-}: {
-  client: Client;
-  name: string;
-  namespace?: string;
-}) => {
-  const resp = await client.platform.generateRouterToken(
-    {
-      fedGraphName: name,
-      namespace,
-    },
-    {
-      headers: getBaseHeaders(),
-    },
-  );
-
-  if (resp.response?.code !== EnumStatusCode.OK) {
-    throw new Error(
-      `${pc.red(`Could not fetch the router config for the graph ${pc.bold(name)}`)} \n${pc.red(
-        pc.bold(resp.response?.details || ''),
-      )}`,
-    );
-  }
-
-  let decoded: GraphToken;
-
-  try {
-    decoded = jwtDecode<GraphToken>(resp.token);
-  } catch {
-    program.error('Could not fetch the router config. Please try again');
-  }
-
-  const requestBody = JSON.stringify({
-    Version: '',
-  });
-
-  const headers = new Headers();
-  headers.append('Content-Type', 'application/json; charset=UTF-8');
-  headers.append('Authorization', 'Bearer ' + resp.token);
-  headers.append('Accept-Encoding', 'gzip');
-
-  const url = new URL(
-    `/${decoded.organization_id}/${decoded.federated_graph_id}/routerconfigs/latest.json`,
-    config.cdnURL,
-  );
-
-  const response = await fetch(url, {
-    method: 'POST',
-    headers,
-    body: requestBody,
-  });
-
-  const routerConfig = await response.text();
-
-  return routerConfig;
-};
+import { getBaseHeaders } from '../../../core/config.js';
 
 export interface Subgraph {
   name: string;

cli/src/commands/mcp/tools/federated-graph-tools.ts

@@ -1,11 +1,8 @@
 import { EnumStatusCode } from '@wundergraph/cosmo-connect/dist/common/common_pb';
 import { z } from 'zod';
 import { getBaseHeaders } from '../../../core/config.js';
-import {
-  fetchRouterConfig,
-  getFederatedGraphSchemas,
-  getSubgraphsOfFedGraph,
-} from '../../graph/federated-graph/utils.js';
+import { getFederatedGraphSchemas, getSubgraphsOfFedGraph } from '../../graph/federated-graph/utils.js';
+import { fetchRouterConfig } from '../../router/utils.js';
 import { ToolContext } from './types.js';
 
 export const registerFederatedGraphTools = ({ server, opts }: ToolContext) => {
@@ -121,14 +118,14 @@ export const registerFederatedGraphTools = ({ server, opts }: ToolContext) => {
     },
     async ({ name, namespace }) => {
       try {
-        const routerConfig = await fetchRouterConfig({
+        const result = await fetchRouterConfig({
           client: opts.client,
           name,
           namespace,
         });
 
         return {
-          content: [{ type: 'text', text: routerConfig }],
+          content: [{ type: 'text', text: result.routerConfig }],
         };
       } catch (e: any) {
         throw new Error(`Failed to fetch router config: ${e.message}`);