Merge branch 'main' into ludwig/eng-7466-add-support-for-deprecated-directive

Author: Noroth

.release-please-manifest.json

@@ -1,4 +1,4 @@
 {
-  "helm/cosmo": "0.13.1",
-  "helm/cosmo/charts/router": "0.13.1"
+  "helm/cosmo": "0.13.2",
+  "helm/cosmo/charts/router": "0.14.0"
 }

cli/CHANGELOG.md

@@ -4,6 +4,10 @@ Binaries are attached to the github release otherwise all images can be found [h
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [0.90.2](https://github.com/wundergraph/cosmo/compare/wgc@0.90.1...wgc@0.90.2) (2025-08-15)
+
+**Note:** Version bump only for package wgc
+
 ## [0.90.1](https://github.com/wundergraph/cosmo/compare/wgc@0.90.0...wgc@0.90.1) (2025-08-12)
 
 ### Bug Fixes

cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wgc",
-  "version": "0.90.1",
+  "version": "0.90.2",
   "description": "The official CLI tool to manage the GraphQL Federation Platform Cosmo",
   "type": "module",
   "main": "dist/src/index.js",
@@ -48,7 +48,7 @@
     "@wundergraph/cosmo-shared": "workspace:*",
     "@wundergraph/protographic": "workspace:*",
     "ajv": "^8.17.1",
-    "axios": "^1.8.4",
+    "axios": "^1.11.0",
     "boxen": "^7.1.1",
     "cli-progress": "^3.12.0",
     "cli-table3": "^0.6.3",
@@ -72,7 +72,7 @@
     "ora": "^8.2.0",
     "pathe": "^1.1.1",
     "picocolors": "^1.0.0",
-    "posthog-node": "^4.17.1",
+    "posthog-node": "^4.18.0",
     "prompts": "^2.4.2",
     "pupa": "^3.1.0",
     "semver": "^7.7.1",

cli/src/commands/router/index.ts

@@ -40,7 +40,11 @@ export default (opts: BaseCommandOptions) => {
   );
 
   cmd.hook('preAction', async (thisCmd) => {
-    if (['compose', 'download-binary', 'compatibility-version', 'plugin'].includes(thisCmd.args[0])) {
+    if (['compose', 'download-binary', 'compatibility-version'].includes(thisCmd.args[0])) {
+      return;
+    }
+
+    if (thisCmd.args[0] === 'plugin' && ['build', 'generate', 'init', 'test'].includes(thisCmd.args[1])) {
       return;
     }
     await checkAuth();

composition-go/index.global.js

@@ -847,8 +847,9 @@ export function undefinedEntityInterfaceImplementationsError(
   entityInterfaceFederationDataByTypeName: Map<string, EntityInterfaceFederationData>,
 ): Error {
   let message =
-    `Federation was unsuccessful because any one subgraph that defines a specific entity interface` +
-    ` must also define each and every entity object that implements that entity interface.\n`;
+    `Federation was unsuccessful because any one subgraph that defines a specific entity Interface` +
+    ` must also define each and every entity Object that implements that entity Interface.\n` +
+    `Each entity Object must also explicitly define its implementation of the entity Interface.\n`;
   for (const [typeName, undefinedImplementations] of invalidEntityInterfacesByTypeName) {
     const entityInterfaceDatas = getOrThrowError(
       entityInterfaceFederationDataByTypeName,
@@ -864,8 +865,8 @@ export function undefinedEntityInterfaceImplementationsError(
       `"\n` +
       ` However, the definition of at least one of these implementations is missing in a subgraph that` +
       ` defines the entity interface "${typeName}":\n`;
-    for (const { subgraphName, concreteTypeNames } of undefinedImplementations) {
-      const disparities = getEntriesNotInHashSet(implementedConcreteTypeNames, concreteTypeNames);
+    for (const { subgraphName, definedConcreteTypeNames } of undefinedImplementations) {
+      const disparities = getEntriesNotInHashSet(implementedConcreteTypeNames, definedConcreteTypeNames);
       message +=
         `  Subgraph "${subgraphName}" does not define the following implementations: "` +
         disparities.join(QUOTATION_JOIN) +

composition/src/errors/errors.ts

@@ -37,8 +37,9 @@ export type InvalidRequiredInputValueData = {
 };
 
 export type InvalidEntityInterface = {
+  definedConcreteTypeNames: Set<string>;
+  requiredConcreteTypeNames: Set<string>;
   subgraphName: string;
-  concreteTypeNames: Set<string>;
 };
 
 export type InputNodeKind = Kind.ENUM_TYPE_DEFINITION | Kind.INPUT_OBJECT_TYPE_DEFINITION | Kind.SCALAR_TYPE_DEFINITION;

composition/src/utils/types.ts

@@ -230,7 +230,7 @@ import {
   InvalidRequiredInputValueData,
 } from '../../utils/types';
 import { FederateSubgraphsContractV1Params, FederateSubgraphsWithContractsV1Params, FederationParams } from './types';
-import { ContractName, FieldCoords, TypeName } from '../../types/types';
+import { ContractName, FieldCoords, SubgraphName, TypeName } from '../../types/types';
 
 export class FederationFactory {
   authorizationDataByParentTypeName: Map<string, AuthorizationData>;
@@ -1617,7 +1617,7 @@ export class FederationFactory {
           if (!isObjectDefinitionData(concreteTypeData)) {
             continue;
           }
-          // The subgraph locations of the interface object must be added to the concrete types that implement it
+          // The subgraph locations of the Interface Object must be added to the concrete types that implement it
           const entityData = getOrThrowError(this.entityDataByTypeName, concreteTypeName, 'entityDataByTypeName');
           entityData.subgraphNames.add(subgraphName);
           const configurationData = configurationDataByTypeName.get(concreteTypeName);
@@ -1673,10 +1673,16 @@ export class FederationFactory {
               }
             }
             const existingFieldData = concreteTypeData.fieldDataByName.get(fieldName);
+            // @shareable and @external need to be propagated (e.g., to satisfy interfaces)
             if (existingFieldData) {
               const isShareable = fieldData.isShareableBySubgraphName.get(subgraphName) ?? false;
               existingFieldData.isShareableBySubgraphName.set(subgraphName, isShareable);
               existingFieldData.subgraphNames.add(subgraphName);
+              const externalData = fieldData.externalFieldDataBySubgraphName.get(subgraphName);
+              if (!externalData) {
+                continue;
+              }
+              existingFieldData.externalFieldDataBySubgraphName.set(subgraphName, { ...externalData });
               continue;
             }
             const isInaccessible =
@@ -3061,18 +3067,31 @@ function initializeFederationFactory({
     }
   }
   const entityInterfaceErrors = new Array<Error>();
+  const definedConcreteTypeNamesBySubgraphName = new Map<SubgraphName, Set<TypeName>>();
   for (const [typeName, entityInterfaceData] of entityInterfaceFederationDataByTypeName) {
     const implementations = entityInterfaceData.concreteTypeNames.size;
     for (const [subgraphName, subgraphData] of entityInterfaceData.subgraphDataByTypeName) {
+      const definedConcreteTypeNames = getValueOrDefault(
+        definedConcreteTypeNamesBySubgraphName,
+        subgraphName,
+        () => new Set<TypeName>(),
+      );
+      addIterableValuesToSet(subgraphData.concreteTypeNames, definedConcreteTypeNames);
       if (!subgraphData.isInterfaceObject) {
         if (subgraphData.resolvable && subgraphData.concreteTypeNames.size !== implementations) {
-          getValueOrDefault(invalidEntityInterfacesByTypeName, typeName, () => []).push({
+          getValueOrDefault(
+            invalidEntityInterfacesByTypeName,
+            typeName,
+            () => new Array<InvalidEntityInterface>(),
+          ).push({
             subgraphName,
-            concreteTypeNames: subgraphData.concreteTypeNames,
+            definedConcreteTypeNames: new Set<TypeName>(subgraphData.concreteTypeNames),
+            requiredConcreteTypeNames: new Set<TypeName>(entityInterfaceData.concreteTypeNames),
           });
         }
         continue;
       }
+      addIterableValuesToSet(entityInterfaceData.concreteTypeNames, definedConcreteTypeNames);
       const { parentDefinitionDataByTypeName } = getOrThrowError(
         result.internalSubgraphBySubgraphName,
         subgraphName,
@@ -3091,6 +3110,26 @@ function initializeFederationFactory({
       }
     }
   }
+  for (const [typeName, invalidInterfaces] of invalidEntityInterfacesByTypeName) {
+    const checkedInvalidInterfaces = new Array<InvalidEntityInterface>();
+    for (const invalidInterface of invalidInterfaces) {
+      const validTypeNames = definedConcreteTypeNamesBySubgraphName.get(invalidInterface.subgraphName);
+      if (!validTypeNames) {
+        checkedInvalidInterfaces.push(invalidInterface);
+        continue;
+      }
+      const definedTypeNames = invalidInterface.requiredConcreteTypeNames.intersection(validTypeNames);
+      if (invalidInterface.requiredConcreteTypeNames.size !== definedTypeNames.size) {
+        invalidInterface.definedConcreteTypeNames = definedTypeNames;
+        checkedInvalidInterfaces.push(invalidInterface);
+      }
+    }
+    if (checkedInvalidInterfaces.length > 0) {
+      invalidEntityInterfacesByTypeName.set(typeName, checkedInvalidInterfaces);
+      continue;
+    }
+    invalidEntityInterfacesByTypeName.delete(typeName);
+  }
   if (invalidEntityInterfacesByTypeName.size > 0) {
     entityInterfaceErrors.push(
       undefinedEntityInterfaceImplementationsError(