Support INTERFACE_FIELD_NO_IMPLEM (#66)

.changeset/light-ligers-jog.md

@@ -0,0 +1,5 @@
+---
+"@theguild/federation-composition": minor
+---
+
+Support INTERFACE_FIELD_NO_IMPLEM

CHANGELOG.md

@@ -4,7 +4,10 @@
 
 ### Patch Changes
 
-- [#64](https://github.com/the-guild-org/federation/pull/64) [`9ec8078`](https://github.com/the-guild-org/federation/commit/9ec80789a8e4926c04dc77d5f5b85347d5934c76) Thanks [@kamilkisiela](https://github.com/kamilkisiela)! - fix: detect incorrect subtypes of interface fields across subgraphs
+- [#64](https://github.com/the-guild-org/federation/pull/64)
+ [`9ec8078`](https://github.com/the-guild-org/federation/commit/9ec80789a8e4926c04dc77d5f5b85347d5934c76)
+ Thanks [@kamilkisiela](https://github.com/kamilkisiela)! - fix: detect incorrect subtypes of
+ interface fields across subgraphs
 
 ## 0.11.3
 

README.md

@@ -182,10 +182,10 @@ Your feedback and bug reports are welcome and appreciated.
 - ✅ `INTERFACE_OBJECT_USAGE_ERROR`
 - ✅ `REQUIRED_INACCESSIBLE`
 - ✅ `SATISFIABILITY_ERROR`
+- ✅ `INTERFACE_FIELD_NO_IMPLEM`
 
 ### TODOs
 
-- [ ] `INTERFACE_FIELD_NO_IMPLEM`
 - [ ] `DISALLOWED_INACCESSIBLE`
 - [ ] `EXTERNAL_ARGUMENT_DEFAULT_MISMATCH`
 - [ ] `EXTERNAL_ARGUMENT_TYPE_MISMATCH`

__tests__/supergraph/errors/INTERFACE_FIELD_NO_IMPLEM.spec.ts

@@ -2,7 +2,7 @@ import { expect, test } from 'vitest';
 import { graphql, testVersions } from '../../shared/testkit.js';
 
 testVersions((api, version) => {
- test.skipIf(api.library === 'guild')('INTERFACE_FIELD_NO_IMPLEM', () => {
+ test('INTERFACE_FIELD_NO_IMPLEM (entity)', () => {
  expect(
  api.composeServices([
  {
@@ -49,7 +49,7 @@ testVersions((api, version) => {
  errors: expect.arrayContaining([
  expect.objectContaining({
  message: expect.stringContaining(
- `Interface field "User.email" is declared in subgraph "users" but type "Author", which implements "User" only in subgraph "feed" does not have field "email".`,
+ `Interface field "User.email" is declared in subgraph "users" but type "Author", which implements "User" ${api.library === 'apollo' ? 'only ' : ''}in subgraph "feed" does not have field "email".`,
  ),
  extensions: expect.objectContaining({
  code: 'INTERFACE_FIELD_NO_IMPLEM',
@@ -58,7 +58,59 @@ testVersions((api, version) => {
  ]),
  }),
  );
+ });
+
+ test('INTERFACE_FIELD_NO_IMPLEM (data)', () => {
+ expect(
+ api.composeServices([
+ {
+ name: 'foo',
+ typeDefs: graphql`
+ type Query {
+ foo: Foo
+ }
+
+ type Foo implements Person {
+ name: String
+ age: Int
+ }
 
- // KNOW: check all interface fields are implemented when one subgraph introduces a new field to the interface
+ interface Person {
+ name: String
+ age: Int
+ }
+ `,
+ },
+ {
+ name: 'bar',
+ typeDefs: graphql`
+ type Query {
+ bar: Bar
+ }
+
+ type Bar implements Person {
+ name: String
+ }
+
+ interface Person {
+ name: String
+ }
+ `,
+ },
+ ]),
+ ).toEqual(
+ expect.objectContaining({
+ errors: expect.arrayContaining([
+ expect.objectContaining({
+ message: expect.stringContaining(
+ `Interface field "Person.age" is declared in subgraph "foo" but type "Bar", which implements "Person" ${api.library === 'apollo' ? 'only ' : ''}in subgraph "bar" does not have field "age".`,
+ ),
+ extensions: expect.objectContaining({
+ code: 'INTERFACE_FIELD_NO_IMPLEM',
+ }),
+ }),
+ ]),
+ }),
+ );
  });
 });

src/supergraph/validation/rules/interface-field-no-implementation-rule.ts

@@ -0,0 +1,101 @@
+import { GraphQLError } from 'graphql';
+import { SupergraphVisitorMap } from '../../composition/visitor.js';
+import { SupergraphState } from '../../state.js';
+import { SupergraphValidationContext } from '../validation-context.js';
+
+export function InterfaceFieldNoImplementationRule(
+ context: SupergraphValidationContext,
+ supergraph: SupergraphState,
+): SupergraphVisitorMap {
+ return {
+ ObjectType(objectTypeState) {
+ if (objectTypeState.interfaces.size === 0) {
+ return;
+ }
+
+ for (const interfaceName of objectTypeState.interfaces) {
+ const interfaceTypeState = getTypeFromSupergraph(supergraph, interfaceName);
+
+ if (!interfaceTypeState) {
+ throw new Error(`Expected an interface to exist in supergraph state`);
+ }
+
+ if (interfaceTypeState.kind !== 'interface') {
+ throw new Error('Expected interface, got ' + interfaceTypeState.kind);
+ }
+
+ const nonRequiredFields: string[] = [];
+
+ for (const [graph, interfaceStateInGraph] of interfaceTypeState.byGraph) {
+ if (!interfaceStateInGraph.isInterfaceObject) {
+ continue;
+ }
+
+ for (const [fieldName, interfaceFieldState] of interfaceTypeState.fields) {
+ const interfaceFieldStateInGraph = interfaceFieldState.byGraph.get(graph);
+ if (!interfaceFieldStateInGraph) {
+ continue;
+ }
+
+ if (interfaceFieldStateInGraph.external) {
+ continue;
+ }
+
+ nonRequiredFields.push(fieldName);
+ }
+ }
+
+ for (const [fieldName, interfaceFieldState] of interfaceTypeState.fields) {
+ // skip fields that are defined in interface objects or in interface entities
+ if (nonRequiredFields.includes(fieldName)) {
+ continue;
+ }
+
+ // TODO: detect if a field is missing in a non-entity object type definition
+ if (objectTypeState.fields.has(fieldName) && objectTypeState.isEntity) {
+ continue;
+ }
+
+ for (const [graph, objectTypeInGraph] of objectTypeState.byGraph) {
+ // check if object in the graph, implements an interface of the same name
+ if (!objectTypeInGraph.interfaces.has(interfaceName)) {
+ // if not, continue
+ continue;
+ }
+
+ const objectFieldState = objectTypeState.fields.get(fieldName);
+
+ // if not, make sure it implements the field
+ // if (!objectFieldState?.byGraph.has(graph)) {
+ if (!objectFieldState) {
+ const interfaceFieldDefinedInGraphs = Array.from(
+ interfaceFieldState.byGraph.keys(),
+ ).map(context.graphIdToName);
+ const declaredIn =
+ interfaceFieldDefinedInGraphs.length === 1
+ ? `subgraph "${interfaceFieldDefinedInGraphs[0]}"`
+ : `subgraphs ${interfaceFieldDefinedInGraphs.map(g => `"${g}"`).join(', ')}`;
+
+ context.reportError(
+ new GraphQLError(
+ `Interface field "${interfaceName}.${fieldName}" is declared in ${declaredIn} but type "${objectTypeState.name}", which implements "${interfaceName}" in subgraph "${context.graphIdToName(graph)}" does not have field "${fieldName}".`,
+ {
+ extensions: {
+ code: 'INTERFACE_FIELD_NO_IMPLEM',
+ },
+ },
+ ),
+ );
+ }
+ }
+ }
+ }
+ },
+ };
+}
+
+function getTypeFromSupergraph(state: SupergraphState, name: string) {
+ return (
+ state.objectTypes.get(name) ?? state.interfaceTypes.get(name) ?? state.unionTypes.get(name)
+ );
+}

src/supergraph/validation/validate-supergraph.ts

@@ -26,6 +26,7 @@ import { RequiredInputFieldMissingInSomeSubgraphRule } from './rules/required-in
 import { RequiredQueryRule } from './rules/required-query-rule.js';
 import { SatisfiabilityRule } from './rules/satisfiablity-rule.js';
 import { SubgraphNameRule } from './rules/subgraph-name-rule.js';
+import { InterfaceFieldNoImplementationRule } from './rules/interface-field-no-implementation-rule.js';
 import { TypesOfTheSameKindRule } from './rules/types-of-the-same-kind-rule.js';
 import { createSupergraphValidationContext } from './validation-context.js';
 
@@ -56,6 +57,7 @@ export function validateSupergraph(
  }
 
  const postSupergraphRules = [
+ InterfaceFieldNoImplementationRule,
  ExtensionWithBaseRule,
  FieldsOfTheSameTypeRule,
  FieldArgumentsOfTheSameTypeRule,