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

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

@@ -55,18 +55,10 @@ export function getFeatureFlagsInLatestCompositionByFederatedGraph(
         throw new UnauthorizedError();
       }
 
-      if (!federatedGraph.schemaVersionId) {
-        return {
-          response: {
-            code: EnumStatusCode.OK,
-          },
-          featureFlags: [],
-        };
-      }
-
       // Get feature flag IDs from the latest valid composition
-      const ffsInLatestValidComposition = await featureFlagRepo.getFeatureFlagSchemaVersionsByBaseSchemaVersion({
-        baseSchemaVersionId: federatedGraph.schemaVersionId,
+      const ffsInLatestValidComposition = await featureFlagRepo.getFeatureFlagSchemaVersionsInLatestComposition({
+        federatedGraphId: federatedGraph.id,
+        federatedGraphTargetId: federatedGraph.targetId,
       });
 
       const featureFlags: FeatureFlagDTO[] = [];
@@ -83,7 +75,8 @@ export function getFeatureFlagsInLatestCompositionByFederatedGraph(
           // A disabled feature flag is no longer served in the latest composition (its router config is
           // removed without recomposing), so exclude it even though its schema version rows still exist.
           if (flag && flag.isEnabled) {
-            featureFlags.push(flag);
+            // True means the composition reported for this flag is its last successful one, not its latest.
+            featureFlags.push({ ...flag, hasFailedLatestComposition: ff.hasFailedLatestComposition });
           }
         }
       }

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

@@ -58,11 +58,22 @@ 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 compositionSubgraphs = await compositionRepo.getCompositionSubgraphs({

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

@@ -73,16 +73,15 @@ export function getFederatedGraphById(
 
     const featureFlagsInLatestValidComposition: FeatureFlagDTO[] = [];
 
-    if (federatedGraph.schemaVersionId) {
-      const ffsInLatestValidComposition = await featureFlagRepo.getFeatureFlagSchemaVersionsByBaseSchemaVersion({
-        baseSchemaVersionId: federatedGraph.schemaVersionId,
-      });
-      if (ffsInLatestValidComposition) {
-        for (const ff of ffsInLatestValidComposition) {
-          const flag = featureFlags.find((f) => f.id === ff.featureFlagId);
-          if (flag) {
-            featureFlagsInLatestValidComposition.push(flag);
-          }
+    const ffsInLatestValidComposition = await featureFlagRepo.getFeatureFlagSchemaVersionsInLatestComposition({
+      federatedGraphId: federatedGraph.id,
+      federatedGraphTargetId: federatedGraph.targetId,
+    });
+    if (ffsInLatestValidComposition) {
+      for (const ff of ffsInLatestValidComposition) {
+        const flag = featureFlags.find((f) => f.id === ff.featureFlagId);
+        if (flag) {
+          featureFlagsInLatestValidComposition.push(flag);
         }
       }
     }

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

@@ -77,6 +77,15 @@ export function getFederatedGraphSDLByName(
         };
       }
 
+      if (!featureFlag.isEnabled) {
+        return {
+          response: {
+            code: EnumStatusCode.ERR_NOT_FOUND,
+            details: `Feature flag ${req.featureFlagName} is disabled`,
+          },
+        };
+      }
+
       const ffSchemaVersion = await featureFlagRepo.getFeatureFlagSchemaVersionByBaseSchemaVersion({
         baseSchemaVersionId: schemaVersion.schemaVersionId,
         federatedGraphId: federatedGraph.id,

controlplane/src/core/repositories/FeatureFlagRepository.ts

@@ -1,6 +1,6 @@
 import { Subgraph } from '@wundergraph/composition';
 import { joinLabel, splitLabel } from '@wundergraph/cosmo-shared';
-import { SQL, and, asc, count, desc, eq, inArray, like, or, sql, arrayOverlaps, isNull } from 'drizzle-orm';
+import { SQL, and, asc, count, desc, eq, inArray, like, or, sql, arrayOverlaps, isNull, isNotNull } from 'drizzle-orm';
 import { PostgresJsDatabase } from 'drizzle-orm/postgres-js';
 import { FastifyBaseLogger } from 'fastify';
 import { validate as isValidUuid } from 'uuid';
@@ -1493,17 +1493,44 @@ export class FeatureFlagRepository {
     return featureFlagCompositions;
   }
 
-  // return all the feature flag schema versions associated with the base schema version
-  // input: base schema version id
-  public async getFeatureFlagSchemaVersionsByBaseSchemaVersion({
-    baseSchemaVersionId,
+  public async getFeatureFlagSchemaVersionsInLatestComposition({
+    federatedGraphId,
+    federatedGraphTargetId,
   }: {
-    baseSchemaVersionId: string;
+    federatedGraphId: string;
+    federatedGraphTargetId: string;
   }) {
-    // 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.
-    const ffSchemaVersions = await this.db
+    const orgRepo = new OrganizationRepository(this.logger, this.db);
+    const splitConfigFeature = await orgRepo.getFeature({
+      organizationId: this.organizationId,
+      featureId: 'split-config-loading',
+    });
+
+    let baseLinkageCondition;
+    if (splitConfigFeature?.enabled) {
+      // Flag compositions are decoupled from the base composition, so the base schema version is irrelevant here.
+      baseLinkageCondition = and(
+        isNull(federatedGraphsToFeatureFlagSchemaVersions.baseCompositionSchemaVersionId),
+        eq(federatedGraphsToFeatureFlagSchemaVersions.federatedGraphId, federatedGraphId),
+      );
+    } else {
+      const federatedGraphRepo = new FederatedGraphRepository(this.logger, this.db, this.organizationId);
+      const latestValidBaseSchemaVersion = await federatedGraphRepo.getLatestValidSchemaVersion({
+        targetId: federatedGraphTargetId,
+      });
+
+      if (!latestValidBaseSchemaVersion) {
+        return;
+      }
+
+      baseLinkageCondition = eq(
+        federatedGraphsToFeatureFlagSchemaVersions.baseCompositionSchemaVersionId,
+        latestValidBaseSchemaVersion.schemaVersionId,
+      );
+    }
+
+    // The latest composition per flag that actually succeeded and deployed; this is what we return.
+    const validSchemaVersions = await this.db
       .selectDistinctOn([federatedGraphsToFeatureFlagSchemaVersions.featureFlagId], {
         id: federatedGraphsToFeatureFlagSchemaVersions.composedSchemaVersionId,
         featureFlagId: federatedGraphsToFeatureFlagSchemaVersions.featureFlagId,
@@ -1513,15 +1540,51 @@ export class FeatureFlagRepository {
         schemaVersion,
         eq(schemaVersion.id, federatedGraphsToFeatureFlagSchemaVersions.composedSchemaVersionId),
       )
-      .where(eq(federatedGraphsToFeatureFlagSchemaVersions.baseCompositionSchemaVersionId, baseSchemaVersionId))
+      .innerJoin(graphCompositions, eq(graphCompositions.schemaVersionId, schemaVersion.id))
+      .where(
+        and(
+          baseLinkageCondition,
+          isNotNull(federatedGraphsToFeatureFlagSchemaVersions.featureFlagId),
+          eq(graphCompositions.isComposable, true),
+          or(isNull(graphCompositions.deploymentError), eq(graphCompositions.deploymentError, '')),
+          or(isNull(graphCompositions.admissionError), eq(graphCompositions.admissionError, '')),
+        ),
+      )
       .orderBy(federatedGraphsToFeatureFlagSchemaVersions.featureFlagId, desc(schemaVersion.createdAt))
       .execute();
 
-    if (ffSchemaVersions.length === 0) {
+    if (validSchemaVersions.length === 0) {
       return;
     }
 
-    return ffSchemaVersions;
+    if (!splitConfigFeature?.enabled) {
+      return validSchemaVersions.map((version) => ({
+        ...version,
+        hasFailedLatestComposition: false,
+      }));
+    }
+
+    // The latest composition per flag regardless of status, used only to detect a newer failed composition.
+    const latestSchemaVersions = await this.db
+      .selectDistinctOn([federatedGraphsToFeatureFlagSchemaVersions.featureFlagId], {
+        id: federatedGraphsToFeatureFlagSchemaVersions.composedSchemaVersionId,
+        featureFlagId: federatedGraphsToFeatureFlagSchemaVersions.featureFlagId,
+      })
+      .from(federatedGraphsToFeatureFlagSchemaVersions)
+      .innerJoin(
+        schemaVersion,
+        eq(schemaVersion.id, federatedGraphsToFeatureFlagSchemaVersions.composedSchemaVersionId),
+      )
+      .where(and(baseLinkageCondition, isNotNull(federatedGraphsToFeatureFlagSchemaVersions.featureFlagId)))
+      .orderBy(federatedGraphsToFeatureFlagSchemaVersions.featureFlagId, desc(schemaVersion.createdAt))
+      .execute();
+
+    const latestIdByFeatureFlagId = new Map(latestSchemaVersions.map((version) => [version.featureFlagId, version.id]));
+
+    return validSchemaVersions.map((version) => ({
+      ...version,
+      hasFailedLatestComposition: latestIdByFeatureFlagId.get(version.featureFlagId) !== version.id,
+    }));
   }
 
   /*
@@ -1598,16 +1661,22 @@ export class FeatureFlagRepository {
         schemaVersion,
         eq(schemaVersion.id, federatedGraphsToFeatureFlagSchemaVersions.composedSchemaVersionId),
       )
+      .innerJoin(graphCompositions, eq(graphCompositions.schemaVersionId, schemaVersion.id))
       .where(
         /**
          * When split config is enabled, the feature flag composition will not be tied to the base schema version, so
-         * we need to check that the baseCompositionSchemaVersionId is null
+         * we need to check that the baseCompositionSchemaVersionId is null. We also require the composition to have
+         * succeeded, otherwise a failed latest composition resolves to a null SDL and the caller 404s instead of
+         * serving the last valid schema.
          */
         splitConfigFeature?.enabled
           ? and(
               isNull(federatedGraphsToFeatureFlagSchemaVersions.baseCompositionSchemaVersionId),
               eq(federatedGraphsToFeatureFlagSchemaVersions.featureFlagId, featureFlagId),
               eq(federatedGraphsToFeatureFlagSchemaVersions.federatedGraphId, federatedGraphId),
+              eq(graphCompositions.isComposable, true),
+              or(isNull(graphCompositions.deploymentError), eq(graphCompositions.deploymentError, '')),
+              or(isNull(graphCompositions.admissionError), eq(graphCompositions.admissionError, '')),
             )
           : and(
               eq(federatedGraphsToFeatureFlagSchemaVersions.baseCompositionSchemaVersionId, baseSchemaVersionId),

controlplane/src/types/index.ts

@@ -194,6 +194,7 @@ export interface FeatureFlagDTO {
   createdAt: string;
   updatedAt: string;
   featureSubgraphs: FeatureSubgraphDTO[];
+  hasFailedLatestComposition?: boolean;
 }
 
 export interface MigrationSubgraph {