@theguild/federation-composition 0.11.3 → 0.11.4-alpha-20240626075710-a99d3f0

package/cjs/subgraph/validation/validate-state.js

@@ -344,7 +344,7 @@ function validateTypeImplementsInterface(state, implementationsMap, reportError,
         }
         if (!isTypeSubTypeOf(state, implementationsMap, typeField.type, ifaceField.type)) {
             reportError(`Interface field ${interfaceType.name}.${fieldName} expects type ` +
-                `${ifaceField.type} but ${type.name}.${fieldName} is type ${typeField.type}.`);
+                `${ifaceField.type} but ${type.name}.${fieldName} of type ${typeField.type} is not a proper subtype.`);
         }
         for (const ifaceArg of ifaceField.args.values()) {
             const argName = ifaceArg.name;

package/cjs/supergraph/validation/rules/interface-subtype-rule.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTypeSubTypeOf = exports.InterfaceSubtypeRule = void 0;
+const graphql_1 = require("graphql");
+const state_js_1 = require("../../../utils/state.js");
+function InterfaceSubtypeRule(context, supergraph) {
+    const implementationsMap = new Map();
+    for (const type of supergraph.interfaceTypes.values()) {
+        for (const iface of type.interfaces) {
+            const interfaceType = getTypeFromSupergraph(supergraph, iface);
+            if (interfaceType && isInterfaceType(interfaceType)) {
+                let implementations = implementationsMap.get(iface);
+                if (implementations === undefined) {
+                    implementationsMap.set(iface, new Set([type.name]));
+                }
+                else {
+                    implementations.add(type.name);
+                }
+            }
+        }
+    }
+    for (const type of supergraph.objectTypes.values()) {
+        for (const iface of type.interfaces) {
+            const interfaceType = getTypeFromSupergraph(supergraph, iface);
+            if (interfaceType && isInterfaceType(interfaceType)) {
+                let implementations = implementationsMap.get(iface);
+                if (implementations === undefined) {
+                    implementationsMap.set(iface, new Set([type.name]));
+                }
+                else {
+                    implementations.add(type.name);
+                }
+            }
+        }
+    }
+    return {
+        ObjectTypeField(objectTypeState, fieldState) {
+            if (objectTypeState.interfaces.size === 0) {
+                return;
+            }
+            const interfaceNames = Array.from(objectTypeState.interfaces.values());
+            for (const interfaceName of interfaceNames) {
+                const interfaceState = supergraph.interfaceTypes.get(interfaceName);
+                if (!interfaceState) {
+                    continue;
+                }
+                const interfaceField = interfaceState.fields.get(fieldState.name);
+                if (!interfaceField) {
+                    continue;
+                }
+                if (!isTypeSubTypeOf(supergraph, implementationsMap, fieldState.type, interfaceField.type)) {
+                    context.reportError(new graphql_1.GraphQLError(`Interface field ${interfaceName}.${interfaceField.name} expects type ${interfaceField.type} but ${objectTypeState.name}.${fieldState.name} of type ${fieldState.type} is not a proper subtype.`, {
+                        extensions: {
+                            code: 'INVALID_GRAPHQL',
+                        },
+                    }));
+                }
+            }
+        },
+    };
+}
+exports.InterfaceSubtypeRule = InterfaceSubtypeRule;
+function isTypeSubTypeOf(state, implementationsMap, maybeSubTypeName, superTypeName) {
+    if (maybeSubTypeName === superTypeName) {
+        return true;
+    }
+    if ((0, state_js_1.isNonNull)(superTypeName)) {
+        if ((0, state_js_1.isNonNull)(maybeSubTypeName)) {
+            return isTypeSubTypeOf(state, implementationsMap, (0, state_js_1.stripNonNull)(maybeSubTypeName), (0, state_js_1.stripNonNull)(superTypeName));
+        }
+        return false;
+    }
+    if ((0, state_js_1.isNonNull)(maybeSubTypeName)) {
+        return isTypeSubTypeOf(state, implementationsMap, (0, state_js_1.stripNonNull)(maybeSubTypeName), superTypeName);
+    }
+    if ((0, state_js_1.isList)(superTypeName)) {
+        if ((0, state_js_1.isList)(maybeSubTypeName)) {
+            return isTypeSubTypeOf(state, implementationsMap, (0, state_js_1.stripList)(maybeSubTypeName), (0, state_js_1.stripList)(superTypeName));
+        }
+        return false;
+    }
+    if ((0, state_js_1.isList)(maybeSubTypeName)) {
+        return false;
+    }
+    const superType = getTypeFromSupergraph(state, superTypeName);
+    const maybeSubType = getTypeFromSupergraph(state, maybeSubTypeName);
+    if (!superType || !maybeSubType) {
+        return false;
+    }
+    return (isAbstractType(superType) &&
+        (isInterfaceType(maybeSubType) || isObjectType(maybeSubType)) &&
+        isSubType(implementationsMap, superType, maybeSubType));
+}
+exports.isTypeSubTypeOf = isTypeSubTypeOf;
+function getTypeFromSupergraph(state, name) {
+    return (state.objectTypes.get(name) ?? state.interfaceTypes.get(name) ?? state.unionTypes.get(name));
+}
+function isSubType(implementationsMap, abstractType, maybeSubType) {
+    if (isUnionType(abstractType)) {
+        return abstractType.members.has(maybeSubType.name);
+    }
+    return implementationsMap.get(abstractType.name)?.has(maybeSubType.name) ?? false;
+}
+function isAbstractType(type) {
+    return isInterfaceType(type) || isUnionType(type);
+}
+function isObjectType(type) {
+    return type.kind === 'object';
+}
+function isInterfaceType(type) {
+    return type.kind === 'interface';
+}
+function isUnionType(type) {
+    return type.kind === 'union';
+}

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

@@ -16,6 +16,7 @@ const input_field_default_mismatch_rule_js_1 = require("./rules/input-field-defa
 const input_object_values_rule_js_1 = require("./rules/input-object-values-rule.js");
 const interface_key_missing_implementation_type_js_1 = require("./rules/interface-key-missing-implementation-type.js");
 const interface_object_usage_error_js_1 = require("./rules/interface-object-usage-error.js");
+const interface_subtype_rule_js_1 = require("./rules/interface-subtype-rule.js");
 const invalid_field_sharing_rule_js_1 = require("./rules/invalid-field-sharing-rule.js");
 const only_inaccessible_children_rule_js_1 = require("./rules/only-inaccessible-children-rule.js");
 const override_source_has_override_js_1 = require("./rules/override-source-has-override.js");
@@ -68,6 +69,7 @@ function validateSupergraph(subgraphStates, state, __internal) {
         satisfiablity_rule_js_1.SatisfiabilityRule,
         subgraph_name_rule_js_1.SubgraphNameRule,
         required_argument_or_field_is_not_inaccessible_rule_js_1.RequiredArgumentOrFieldIsNotInaccessibleRule,
+        interface_subtype_rule_js_1.InterfaceSubtypeRule,
     ];
     const supergraph = state.getSupergraphState();
     (0, visitor_js_1.visitSupergraphState)(supergraph, postSupergraphRules.map(rule => {

package/esm/graphql/contains-supergraph-spec.js

@@ -1,4 +1,4 @@
-import { federationDirectives, federationEnums, federationScalars } from "./transform-supergraph-to-public-schema.js";
+import { federationDirectives, federationEnums, federationScalars, } from './transform-supergraph-to-public-schema.js';
 const supergraphSpecDetectionRegex = new RegExp(Array.from(federationScalars)
     .concat(Array.from(federationEnums))
     .map(name => [`\\[${name}`, `\\s${name}`])

package/esm/subgraph/validation/validate-state.js

@@ -340,7 +340,7 @@ function validateTypeImplementsInterface(state, implementationsMap, reportError,
         }
         if (!isTypeSubTypeOf(state, implementationsMap, typeField.type, ifaceField.type)) {
             reportError(`Interface field ${interfaceType.name}.${fieldName} expects type ` +
-                `${ifaceField.type} but ${type.name}.${fieldName} is type ${typeField.type}.`);
+                `${ifaceField.type} but ${type.name}.${fieldName} of type ${typeField.type} is not a proper subtype.`);
         }
         for (const ifaceArg of ifaceField.args.values()) {
             const argName = ifaceArg.name;

package/esm/supergraph/validation/rules/interface-subtype-rule.js

@@ -0,0 +1,110 @@
+import { GraphQLError } from 'graphql';
+import { isList, isNonNull, stripList, stripNonNull } from '../../../utils/state.js';
+export function InterfaceSubtypeRule(context, supergraph) {
+    const implementationsMap = new Map();
+    for (const type of supergraph.interfaceTypes.values()) {
+        for (const iface of type.interfaces) {
+            const interfaceType = getTypeFromSupergraph(supergraph, iface);
+            if (interfaceType && isInterfaceType(interfaceType)) {
+                let implementations = implementationsMap.get(iface);
+                if (implementations === undefined) {
+                    implementationsMap.set(iface, new Set([type.name]));
+                }
+                else {
+                    implementations.add(type.name);
+                }
+            }
+        }
+    }
+    for (const type of supergraph.objectTypes.values()) {
+        for (const iface of type.interfaces) {
+            const interfaceType = getTypeFromSupergraph(supergraph, iface);
+            if (interfaceType && isInterfaceType(interfaceType)) {
+                let implementations = implementationsMap.get(iface);
+                if (implementations === undefined) {
+                    implementationsMap.set(iface, new Set([type.name]));
+                }
+                else {
+                    implementations.add(type.name);
+                }
+            }
+        }
+    }
+    return {
+        ObjectTypeField(objectTypeState, fieldState) {
+            if (objectTypeState.interfaces.size === 0) {
+                return;
+            }
+            const interfaceNames = Array.from(objectTypeState.interfaces.values());
+            for (const interfaceName of interfaceNames) {
+                const interfaceState = supergraph.interfaceTypes.get(interfaceName);
+                if (!interfaceState) {
+                    continue;
+                }
+                const interfaceField = interfaceState.fields.get(fieldState.name);
+                if (!interfaceField) {
+                    continue;
+                }
+                if (!isTypeSubTypeOf(supergraph, implementationsMap, fieldState.type, interfaceField.type)) {
+                    context.reportError(new GraphQLError(`Interface field ${interfaceName}.${interfaceField.name} expects type ${interfaceField.type} but ${objectTypeState.name}.${fieldState.name} of type ${fieldState.type} is not a proper subtype.`, {
+                        extensions: {
+                            code: 'INVALID_GRAPHQL',
+                        },
+                    }));
+                }
+            }
+        },
+    };
+}
+export function isTypeSubTypeOf(state, implementationsMap, maybeSubTypeName, superTypeName) {
+    if (maybeSubTypeName === superTypeName) {
+        return true;
+    }
+    if (isNonNull(superTypeName)) {
+        if (isNonNull(maybeSubTypeName)) {
+            return isTypeSubTypeOf(state, implementationsMap, stripNonNull(maybeSubTypeName), stripNonNull(superTypeName));
+        }
+        return false;
+    }
+    if (isNonNull(maybeSubTypeName)) {
+        return isTypeSubTypeOf(state, implementationsMap, stripNonNull(maybeSubTypeName), superTypeName);
+    }
+    if (isList(superTypeName)) {
+        if (isList(maybeSubTypeName)) {
+            return isTypeSubTypeOf(state, implementationsMap, stripList(maybeSubTypeName), stripList(superTypeName));
+        }
+        return false;
+    }
+    if (isList(maybeSubTypeName)) {
+        return false;
+    }
+    const superType = getTypeFromSupergraph(state, superTypeName);
+    const maybeSubType = getTypeFromSupergraph(state, maybeSubTypeName);
+    if (!superType || !maybeSubType) {
+        return false;
+    }
+    return (isAbstractType(superType) &&
+        (isInterfaceType(maybeSubType) || isObjectType(maybeSubType)) &&
+        isSubType(implementationsMap, superType, maybeSubType));
+}
+function getTypeFromSupergraph(state, name) {
+    return (state.objectTypes.get(name) ?? state.interfaceTypes.get(name) ?? state.unionTypes.get(name));
+}
+function isSubType(implementationsMap, abstractType, maybeSubType) {
+    if (isUnionType(abstractType)) {
+        return abstractType.members.has(maybeSubType.name);
+    }
+    return implementationsMap.get(abstractType.name)?.has(maybeSubType.name) ?? false;
+}
+function isAbstractType(type) {
+    return isInterfaceType(type) || isUnionType(type);
+}
+function isObjectType(type) {
+    return type.kind === 'object';
+}
+function isInterfaceType(type) {
+    return type.kind === 'interface';
+}
+function isUnionType(type) {
+    return type.kind === 'union';
+}

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

@@ -13,6 +13,7 @@ import { InputFieldDefaultMismatchRule } from './rules/input-field-default-misma
 import { InputObjectValuesRule } from './rules/input-object-values-rule.js';
 import { InterfaceKeyMissingImplementationTypeRule } from './rules/interface-key-missing-implementation-type.js';
 import { InterfaceObjectUsageErrorRule } from './rules/interface-object-usage-error.js';
+import { InterfaceSubtypeRule } from './rules/interface-subtype-rule.js';
 import { InvalidFieldSharingRule } from './rules/invalid-field-sharing-rule.js';
 import { OnlyInaccessibleChildrenRule } from './rules/only-inaccessible-children-rule.js';
 import { OverrideSourceHasOverrideRule } from './rules/override-source-has-override.js';
@@ -65,6 +66,7 @@ export function validateSupergraph(subgraphStates, state, __internal) {
         SatisfiabilityRule,
         SubgraphNameRule,
         RequiredArgumentOrFieldIsNotInaccessibleRule,
+        InterfaceSubtypeRule,
     ];
     const supergraph = state.getSupergraphState();
     visitSupergraphState(supergraph, postSupergraphRules.map(rule => {

package/package.json

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

package/typings/supergraph/validation/rules/interface-subtype-rule.d.cts

@@ -0,0 +1,6 @@
+import { SupergraphVisitorMap } from '../../composition/visitor.cjs';
+import { SupergraphState } from '../../state.cjs';
+import { SupergraphValidationContext } from '../validation-context.cjs';
+export declare function InterfaceSubtypeRule(context: SupergraphValidationContext, supergraph: SupergraphState): SupergraphVisitorMap;
+export declare function isTypeSubTypeOf(state: SupergraphState, implementationsMap: Map<string, Set<string>>, maybeSubTypeName: string, superTypeName: string): boolean;
+//# sourceMappingURL=interface-subtype-rule.d.ts.map

package/typings/supergraph/validation/rules/interface-subtype-rule.d.ts

@@ -0,0 +1,6 @@
+import { SupergraphVisitorMap } from '../../composition/visitor.js';
+import { SupergraphState } from '../../state.js';
+import { SupergraphValidationContext } from '../validation-context.js';
+export declare function InterfaceSubtypeRule(context: SupergraphValidationContext, supergraph: SupergraphState): SupergraphVisitorMap;
+export declare function isTypeSubTypeOf(state: SupergraphState, implementationsMap: Map<string, Set<string>>, maybeSubTypeName: string, superTypeName: string): boolean;
+//# sourceMappingURL=interface-subtype-rule.d.ts.map