@theguild/federation-composition 0.11.4 → 0.12.0-alpha-20240708141320-c066c07

package/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`

package/cjs/supergraph/validation/rules/interface-field-no-implementation-rule.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InterfaceFieldNoImplementationRule = void 0;
+const graphql_1 = require("graphql");
+function InterfaceFieldNoImplementationRule(context, supergraph) {
+    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 = [];
+                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) {
+                    if (nonRequiredFields.includes(fieldName)) {
+                        continue;
+                    }
+                    if (objectTypeState.fields.has(fieldName) && objectTypeState.isEntity) {
+                        continue;
+                    }
+                    for (const [graph, objectTypeInGraph] of objectTypeState.byGraph) {
+                        if (!objectTypeInGraph.interfaces.has(interfaceName)) {
+                            continue;
+                        }
+                        const objectFieldState = objectTypeState.fields.get(fieldName);
+                        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 graphql_1.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',
+                                },
+                            }));
+                        }
+                    }
+                }
+            }
+        },
+    };
+}
+exports.InterfaceFieldNoImplementationRule = InterfaceFieldNoImplementationRule;
+function getTypeFromSupergraph(state, name) {
+    return (state.objectTypes.get(name) ?? state.interfaceTypes.get(name) ?? state.unionTypes.get(name));
+}

package/cjs/supergraph/validation/validate-supergraph.js

@@ -27,6 +27,7 @@ const required_input_field_missing_in_some_subgraph_rule_js_1 = require("./rules
 const required_query_rule_js_1 = require("./rules/required-query-rule.js");
 const satisfiablity_rule_js_1 = require("./rules/satisfiablity-rule.js");
 const subgraph_name_rule_js_1 = require("./rules/subgraph-name-rule.js");
+const interface_field_no_implementation_rule_js_1 = require("./rules/interface-field-no-implementation-rule.js");
 const types_of_the_same_kind_rule_js_1 = require("./rules/types-of-the-same-kind-rule.js");
 const validation_context_js_1 = require("./validation-context.js");
 function validateSupergraph(subgraphStates, state, __internal) {
@@ -46,6 +47,7 @@ function validateSupergraph(subgraphStates, state, __internal) {
         state.visitSubgraphState(subgraphState);
     }
     const postSupergraphRules = [
+        interface_field_no_implementation_rule_js_1.InterfaceFieldNoImplementationRule,
         extension_with_base_js_1.ExtensionWithBaseRule,
         fields_of_the_same_type_rule_js_1.FieldsOfTheSameTypeRule,
         field_arguments_of_the_same_type_rule_js_1.FieldArgumentsOfTheSameTypeRule,

package/esm/supergraph/validation/rules/interface-field-no-implementation-rule.js

@@ -0,0 +1,63 @@
+import { GraphQLError } from 'graphql';
+export function InterfaceFieldNoImplementationRule(context, supergraph) {
+    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 = [];
+                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) {
+                    if (nonRequiredFields.includes(fieldName)) {
+                        continue;
+                    }
+                    if (objectTypeState.fields.has(fieldName) && objectTypeState.isEntity) {
+                        continue;
+                    }
+                    for (const [graph, objectTypeInGraph] of objectTypeState.byGraph) {
+                        if (!objectTypeInGraph.interfaces.has(interfaceName)) {
+                            continue;
+                        }
+                        const objectFieldState = objectTypeState.fields.get(fieldName);
+                        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, name) {
+    return (state.objectTypes.get(name) ?? state.interfaceTypes.get(name) ?? state.unionTypes.get(name));
+}

package/esm/supergraph/validation/validate-supergraph.js

@@ -24,6 +24,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';
 export function validateSupergraph(subgraphStates, state, __internal) {
@@ -43,6 +44,7 @@ export function validateSupergraph(subgraphStates, state, __internal) {
         state.visitSubgraphState(subgraphState);
     }
     const postSupergraphRules = [
+        InterfaceFieldNoImplementationRule,
         ExtensionWithBaseRule,
         FieldsOfTheSameTypeRule,
         FieldArgumentsOfTheSameTypeRule,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@theguild/federation-composition",
-  "version": "0.11.4",
+  "version": "0.12.0-alpha-20240708141320-c066c07",
   "description": "Open Source Composition library for Apollo Federation",
   "peerDependencies": {
     "graphql": "^16.0.0"

package/typings/supergraph/validation/rules/interface-field-no-implementation-rule.d.cts

@@ -0,0 +1,5 @@
+import { SupergraphVisitorMap } from '../../composition/visitor.cjs';
+import { SupergraphState } from '../../state.cjs';
+import { SupergraphValidationContext } from '../validation-context.cjs';
+export declare function InterfaceFieldNoImplementationRule(context: SupergraphValidationContext, supergraph: SupergraphState): SupergraphVisitorMap;
+//# sourceMappingURL=interface-field-no-implementation-rule.d.ts.map

package/typings/supergraph/validation/rules/interface-field-no-implementation-rule.d.ts

@@ -0,0 +1,5 @@
+import { SupergraphVisitorMap } from '../../composition/visitor.js';
+import { SupergraphState } from '../../state.js';
+import { SupergraphValidationContext } from '../validation-context.js';
+export declare function InterfaceFieldNoImplementationRule(context: SupergraphValidationContext, supergraph: SupergraphState): SupergraphVisitorMap;
+//# sourceMappingURL=interface-field-no-implementation-rule.d.ts.map