fix: show feature flags for a federated graph under split config

controlplane/src/core/bufservices/feature-flag/getFeatureFlagsInLatestCompositionByFederatedGraph.ts

@@ -67,6 +67,7 @@ export function getFeatureFlagsInLatestCompositionByFederatedGraph(
       // Get feature flag IDs from the latest valid composition
       const ffsInLatestValidComposition = await featureFlagRepo.getFeatureFlagSchemaVersionsByBaseSchemaVersion({
         baseSchemaVersionId: federatedGraph.schemaVersionId,
+        federatedGraphId: federatedGraph.id,
       });
 
       const featureFlags: FeatureFlagDTO[] = [];

controlplane/src/core/bufservices/federated-graph/getCompositionDetails.ts

@@ -58,12 +58,24 @@ export function getCompositionDetails(
       };
     }
 
-    if (composition.targetId) {
-      const graph = await fedRepo.byTargetId(composition.targetId);
-      if (graph && !authContext.rbac.hasFederatedGraphReadAccess(graph)) {
-        throw new UnauthorizedError();
-      }
+    // A composition is always tied to a federated graph (its target is only nulled once the graph is deleted), so an
+    // unresolvable graph means the composition is orphaned — treat it as not found rather than serving it without an
+    // authorization check.
+    const graph = composition.targetId ? await fedRepo.byTargetId(composition.targetId) : undefined;
+    if (!graph) {
+      return {
+        response: {
+          code: EnumStatusCode.ERR_NOT_FOUND,
+          details: `Federated graph for composition '${req.compositionId}' not found`,
+        },
+        compositionSubgraphs: [],
+        featureFlagCompositions: [],
+      };
+    }
+    if (!authContext.rbac.hasFederatedGraphReadAccess(graph)) {
+      throw new UnauthorizedError();
     }
+    const federatedGraphId = graph.id;
 
     const compositionSubgraphs = await compositionRepo.getCompositionSubgraphs({
       compositionId: composition.id,
@@ -87,11 +99,15 @@ export function getCompositionDetails(
       }
     }
 
-    const featureFlagCompositions = await featureFlagRepo.getFeatureFlagCompositionsByBaseSchemaVersion({
-      baseSchemaVersionId: composition.schemaVersionId,
-      namespaceId: namespace.id,
-      organizationId: authContext.organizationId,
-    });
+    // Feature flag compositions are resolved from a base composition, so only a base composition can have them.
+    const featureFlagCompositions = composition.isFeatureFlagComposition
+      ? []
+      : await featureFlagRepo.getFeatureFlagCompositionsByBaseSchemaVersion({
+          baseSchemaVersionId: composition.schemaVersionId,
+          federatedGraphId,
+          namespaceId: namespace.id,
+          organizationId: authContext.organizationId,
+        });
 
     return {
       response: {

controlplane/src/core/bufservices/federated-graph/getFederatedGraphById.ts

@@ -76,6 +76,7 @@ export function getFederatedGraphById(
     if (federatedGraph.schemaVersionId) {
       const ffsInLatestValidComposition = await featureFlagRepo.getFeatureFlagSchemaVersionsByBaseSchemaVersion({
         baseSchemaVersionId: federatedGraph.schemaVersionId,
+        federatedGraphId: federatedGraph.id,
       });
       if (ffsInLatestValidComposition) {
         for (const ff of ffsInLatestValidComposition) {

controlplane/src/core/repositories/FeatureFlagRepository.ts

@@ -1419,43 +1419,73 @@ export class FeatureFlagRepository {
   // input: base schema version id, namespace id
   public async getFeatureFlagCompositionsByBaseSchemaVersion({
     baseSchemaVersionId,
+    federatedGraphId,
     namespaceId,
     organizationId,
   }: {
     baseSchemaVersionId: string;
+    federatedGraphId: string;
     namespaceId: string;
     organizationId: string;
   }) {
     const featureFlagCompositions: FeatureFlagCompositionDTO[] = [];
-    const compositions = await this.db
-      .select({
-        id: graphCompositions.id,
-        featureFlagId: federatedGraphsToFeatureFlagSchemaVersions.featureFlagId,
-        schemaVersionId: graphCompositions.schemaVersionId,
-        isComposable: graphCompositions.isComposable,
-        compositionErrors: graphCompositions.compositionErrors,
-        compositionWarnings: graphCompositions.compositionWarnings,
-        createdAt: graphCompositions.createdAt,
-        createdBy: users.email,
-        createdByEmail: graphCompositions.createdByEmail,
-        routerConfigSignature: graphCompositions.routerConfigSignature,
-        admissionError: graphCompositions.admissionError,
-        deploymentError: graphCompositions.deploymentError,
-      })
-      .from(graphCompositions)
-      .innerJoin(schemaVersion, eq(schemaVersion.id, graphCompositions.schemaVersionId))
-      .innerJoin(
-        federatedGraphsToFeatureFlagSchemaVersions,
-        eq(federatedGraphsToFeatureFlagSchemaVersions.composedSchemaVersionId, schemaVersion.id),
-      )
-      .leftJoin(users, eq(users.id, graphCompositions.createdById))
-      .where(
-        and(
-          eq(federatedGraphsToFeatureFlagSchemaVersions.baseCompositionSchemaVersionId, baseSchemaVersionId),
-          eq(schemaVersion.organizationId, organizationId),
-        ),
-      )
-      .execute();
+
+    const orgRepo = new OrganizationRepository(this.logger, this.db);
+    const splitConfigFeature = await orgRepo.getFeature({
+      organizationId,
+      featureId: 'split-config-loading',
+    });
+
+    const compositionColumns = {
+      id: graphCompositions.id,
+      featureFlagId: federatedGraphsToFeatureFlagSchemaVersions.featureFlagId,
+      schemaVersionId: graphCompositions.schemaVersionId,
+      isComposable: graphCompositions.isComposable,
+      compositionErrors: graphCompositions.compositionErrors,
+      compositionWarnings: graphCompositions.compositionWarnings,
+      createdAt: graphCompositions.createdAt,
+      createdBy: users.email,
+      createdByEmail: graphCompositions.createdByEmail,
+      routerConfigSignature: graphCompositions.routerConfigSignature,
+      admissionError: graphCompositions.admissionError,
+      deploymentError: graphCompositions.deploymentError,
+    };
+
+    const compositions = splitConfigFeature?.enabled
+      ? await this.db
+          .selectDistinctOn([federatedGraphsToFeatureFlagSchemaVersions.featureFlagId], compositionColumns)
+          .from(graphCompositions)
+          .innerJoin(schemaVersion, eq(schemaVersion.id, graphCompositions.schemaVersionId))
+          .innerJoin(
+            federatedGraphsToFeatureFlagSchemaVersions,
+            eq(federatedGraphsToFeatureFlagSchemaVersions.composedSchemaVersionId, schemaVersion.id),
+          )
+          .leftJoin(users, eq(users.id, graphCompositions.createdById))
+          .where(
+            and(
+              isNull(federatedGraphsToFeatureFlagSchemaVersions.baseCompositionSchemaVersionId),
+              eq(federatedGraphsToFeatureFlagSchemaVersions.federatedGraphId, federatedGraphId),
+              eq(schemaVersion.organizationId, organizationId),
+            ),
+          )
+          .orderBy(federatedGraphsToFeatureFlagSchemaVersions.featureFlagId, desc(graphCompositions.createdAt))
+          .execute()
+      : await this.db
+          .select(compositionColumns)
+          .from(graphCompositions)
+          .innerJoin(schemaVersion, eq(schemaVersion.id, graphCompositions.schemaVersionId))
+          .innerJoin(
+            federatedGraphsToFeatureFlagSchemaVersions,
+            eq(federatedGraphsToFeatureFlagSchemaVersions.composedSchemaVersionId, schemaVersion.id),
+          )
+          .leftJoin(users, eq(users.id, graphCompositions.createdById))
+          .where(
+            and(
+              eq(federatedGraphsToFeatureFlagSchemaVersions.baseCompositionSchemaVersionId, baseSchemaVersionId),
+              eq(schemaVersion.organizationId, organizationId),
+            ),
+          )
+          .execute();
 
     for (const composition of compositions) {
       let featureFlagName = '';
@@ -1487,9 +1517,17 @@ export class FeatureFlagRepository {
   // input: base schema version id
   public async getFeatureFlagSchemaVersionsByBaseSchemaVersion({
     baseSchemaVersionId,
+    federatedGraphId,
   }: {
     baseSchemaVersionId: string;
+    federatedGraphId: string;
   }) {
+    const orgRepo = new OrganizationRepository(this.logger, this.db);
+    const splitConfigFeature = await orgRepo.getFeature({
+      organizationId: this.organizationId,
+      featureId: 'split-config-loading',
+    });
+
     // A feature flag can have multiple composed schema versions against the same base schema version
     // (e.g. recomposing the feature flag recomposes it against the unchanged base, so rows accumulate).
     // Deduplicate by feature flag, keeping the latest composed version, so callers get one entry per flag.
@@ -1503,7 +1541,14 @@ export class FeatureFlagRepository {
         schemaVersion,
         eq(schemaVersion.id, federatedGraphsToFeatureFlagSchemaVersions.composedSchemaVersionId),
       )
-      .where(eq(federatedGraphsToFeatureFlagSchemaVersions.baseCompositionSchemaVersionId, baseSchemaVersionId))
+      .where(
+        splitConfigFeature?.enabled
+          ? and(
+              isNull(federatedGraphsToFeatureFlagSchemaVersions.baseCompositionSchemaVersionId),
+              eq(federatedGraphsToFeatureFlagSchemaVersions.federatedGraphId, federatedGraphId),
+            )
+          : eq(federatedGraphsToFeatureFlagSchemaVersions.baseCompositionSchemaVersionId, baseSchemaVersionId),
+      )
       .orderBy(federatedGraphsToFeatureFlagSchemaVersions.featureFlagId, desc(schemaVersion.createdAt))
       .execute();
 

controlplane/test/composition/getCompositionDetails.test.ts

@@ -594,7 +594,10 @@ describe('getCompositionDetails', () => {
       expect(compositionResp.response?.code).toBe(EnumStatusCode.OK);
       expect(compositionResp.composition).toBeDefined();
       expect(compositionResp.compositionSubgraphs).toHaveLength(2);
-      expect(compositionResp.featureFlagCompositions).toHaveLength(0);
+      // Under split config the base composition surfaces the feature flag's compositions (scoped by federated graph,
+      // deduplicated to the latest per flag) even though the base linkage on the rows is null.
+      expect(compositionResp.featureFlagCompositions).toHaveLength(1);
+      expect(compositionResp.featureFlagCompositions[0].featureFlagName).toBe(ffName);
       expect(compositionResp.composition?.isFeatureFlagComposition).toBe(false);
 
       expect(compositionResp.compositionSubgraphs).toEqual([

controlplane/test/feature-flag/get-feature-flags-in-latest-composition-by-federated-graph.test.ts

@@ -68,7 +68,7 @@ describe('GetFeatureFlagsInLatestCompositionByFederatedGraph', () => {
     expect(resp.featureFlags.some((f) => f.name === flagName)).toBe(true);
   });
 
-  test('that feature flag compositions are decoupled when split config loading is enabled', async (testContext) => {
+  test('that feature flags in the latest composition are returned when split config loading is enabled', async (testContext) => {
     const { client, server } = await SetupTest({ dbname, enabledFeatures: ['split-config-loading'] });
     testContext.onTestFinished(() => server.close());
 
@@ -118,7 +118,8 @@ describe('GetFeatureFlagsInLatestCompositionByFederatedGraph', () => {
     });
 
     expect(resp.response?.code).toBe(EnumStatusCode.OK);
-    expect(resp.featureFlags).toHaveLength(0);
+    expect(resp.featureFlags).toHaveLength(1);
+    expect(resp.featureFlags.some((f) => f.name === flagName)).toBe(true);
 
     // Create a second, enabled feature flag
     const secondFlagName = genID('flag');
@@ -129,7 +130,9 @@ describe('GetFeatureFlagsInLatestCompositionByFederatedGraph', () => {
       namespace,
     });
     expect(withSecondFlag.response?.code).toBe(EnumStatusCode.OK);
-    expect(withSecondFlag.featureFlags).toHaveLength(0);
+    expect(withSecondFlag.featureFlags).toHaveLength(2);
+    expect(withSecondFlag.featureFlags.some((f) => f.name === flagName)).toBe(true);
+    expect(withSecondFlag.featureFlags.some((f) => f.name === secondFlagName)).toBe(true);
 
     // Only the base graph composition should show up when excluding feature flag compositions
     let compositionsResp = await client.getCompositions({

controlplane/test/federated-graph/get-federated-graph-by-id.test.ts

@@ -1,3 +1,5 @@
+import fs from 'node:fs';
+import { join } from 'node:path';
 import { EnumStatusCode } from '@wundergraph/cosmo-connect/dist/common/common_pb';
 import { afterAll, beforeAll, describe, expect, onTestFinished, test } from 'vitest';
 import {
@@ -6,8 +8,20 @@ import {
   createTestGroup,
   createTestRBACEvaluator,
   genID,
+  genUniqueLabel,
 } from '../../src/core/test-util.js';
-import { createFederatedGraph, createThenPublishSubgraph, DEFAULT_NAMESPACE, SetupTest } from '../test-util.js';
+import {
+  createAndPublishSubgraph,
+  createFeatureFlag,
+  createFederatedGraph,
+  createNamespace,
+  createThenPublishFeatureSubgraph,
+  createThenPublishSubgraph,
+  DEFAULT_NAMESPACE,
+  DEFAULT_ROUTER_URL,
+  DEFAULT_SUBGRAPH_URL_ONE,
+  SetupTest,
+} from '../test-util.js';
 
 let dbname = '';
 
@@ -177,4 +191,57 @@ describe('GetFederatedGraphById', () => {
       expect(response.response?.code).toBe(EnumStatusCode.ERROR_NOT_AUTHORIZED);
     },
   );
+
+  test('Should return the feature flags in the latest composition when split config loading is enabled', async (testContext) => {
+    const { client, server } = await SetupTest({ dbname, enabledFeatures: ['split-config-loading'] });
+    testContext.onTestFinished(() => server.close());
+
+    const namespace = genID('namespace').toLowerCase();
+    const labels = [genUniqueLabel()];
+    const federatedGraphName = genID('fedGraph');
+
+    await createNamespace(client, namespace);
+
+    await createAndPublishSubgraph(
+      client,
+      'users',
+      namespace,
+      fs.readFileSync(join(process.cwd(), 'test/test-data/feature-flags/users.graphql')).toString(),
+      labels,
+      DEFAULT_SUBGRAPH_URL_ONE,
+    );
+
+    await createThenPublishFeatureSubgraph(
+      client,
+      'users-feature',
+      'users',
+      namespace,
+      fs.readFileSync(join(process.cwd(), 'test/test-data/feature-flags/users-feature.graphql')).toString(),
+      labels,
+      'http://localhost:4101',
+    );
+
+    const federatedGraphLabels = labels.map(({ key, value }) => `${key}=${value}`);
+    await createFederatedGraph(client, federatedGraphName, namespace, federatedGraphLabels, DEFAULT_ROUTER_URL);
+
+    const flagName = genID('flag');
+    await createFeatureFlag(client, flagName, labels, ['users-feature'], namespace, true);
+
+    const graphByName = await client.getFederatedGraphByName({
+      name: federatedGraphName,
+      namespace,
+    });
+    expect(graphByName.response?.code).toBe(EnumStatusCode.OK);
+
+    // Under split config the feature flag composition rows have a null base linkage; getFederatedGraphById must still
+    // resolve them via the federated graph so the flag shows up in the latest composition (COSMO-315).
+    const response = await client.getFederatedGraphById({
+      id: graphByName.graph!.id,
+      includeMetrics: false,
+    });
+
+    expect(response.response?.code).toBe(EnumStatusCode.OK);
+    expect(response.featureFlagsInLatestValidComposition).toHaveLength(1);
+    expect(response.featureFlagsInLatestValidComposition.some((f) => f.name === flagName)).toBe(true);
+  });
 });