@theguild/federation-composition 0.20.2 → 0.21.0

package/esm/subgraph/validation/rules/elements/list-size.js

@@ -166,29 +166,29 @@ export function ListSizeRule(context) {
                         const outputType = namedTypeFromTypeNode(fieldDef.type);
                         const targetType = knownObjectsAndInterfaces.get(outputType.name.value);
                         if (!targetType) {
-                            context.reportError(new GraphQLError(`${coordinate} has @listSize(sizedFields:) applied, but the output type is not an object`, {
+                            context.reportError(new GraphQLError(`${coordinate} has @listSize(sizedFields:) applied, but the output type is not a composite type`, {
                                 extensions: {
                                     code: "LIST_SIZE_INVALID_SIZED_FIELD",
                                 },
                             }));
                             return;
                         }
-                        const nonIntFields = [];
+                        const nonListFields = [];
                         const nonExistingFields = [];
                         for (const sizedField of sizedFields) {
                             const targetField = targetType.fields?.find((f) => f.name.value === sizedField);
                             if (!targetField) {
                                 nonExistingFields.push(sizedField);
                             }
-                            else if (!isIntTypeOrNullableIntType(targetField.type)) {
-                                nonIntFields.push(sizedField);
+                            else if (!isListType(targetField.type)) {
+                                nonListFields.push(sizedField);
                             }
                         }
-                        if (nonIntFields.length || nonExistingFields.length) {
-                            nonIntFields.forEach((fieldName) => {
-                                context.reportError(new GraphQLError(`${coordinate} references "${fieldName}" field in @listSize(sizedFields:) argument that is not an integer.`, {
+                        if (nonListFields.length || nonExistingFields.length) {
+                            nonListFields.forEach((fieldName) => {
+                                context.reportError(new GraphQLError(`${coordinate} references "${fieldName}" field in @listSize(sizedFields:) argument that is not a list.`, {
                                     extensions: {
-                                        code: "LIST_SIZE_INVALID_SIZED_FIELD",
+                                        code: "LIST_SIZE_APPLIED_TO_NON_LIST",
                                     },
                                 }));
                             });
@@ -235,6 +235,7 @@ export function ListSizeRule(context) {
                     if (typeDef.kind === Kind.OBJECT_TYPE_DEFINITION ||
                         typeDef.kind === Kind.OBJECT_TYPE_EXTENSION) {
                         context.stateBuilder.objectType.field.setListSize(typeDef.name.value, parent.name.value, {
+                            printRequireOneSlicingArgument: false,
                             assumedSize,
                             slicingArguments,
                             sizedFields,
@@ -244,6 +245,7 @@ export function ListSizeRule(context) {
                     if (typeDef.kind === Kind.INTERFACE_TYPE_DEFINITION ||
                         typeDef.kind === Kind.INTERFACE_TYPE_EXTENSION) {
                         context.stateBuilder.interfaceType.field.setListSize(typeDef.name.value, parent.name.value, {
+                            printRequireOneSlicingArgument: false,
                             assumedSize,
                             slicingArguments,
                             sizedFields,

package/esm/subgraph/validation/rules/elements/policy.js

@@ -1,4 +1,4 @@
-import { Kind } from "graphql";
+import { GraphQLError, Kind } from "graphql";
 import { print } from "../../../../graphql/printer.js";
 import { validateDirectiveAgainstOriginal } from "../../../helpers.js";
 export function PolicyRule(context) {
@@ -52,21 +52,41 @@ export function PolicyRule(context) {
                     if (!typeDef) {
                         throw new Error("Could not find the parent type of the field annotated with @policy");
                     }
-                    if ((typeDef.kind === Kind.OBJECT_TYPE_DEFINITION ||
-                        typeDef.kind === Kind.OBJECT_TYPE_EXTENSION) &&
-                        !context.stateBuilder.isInterfaceObject(typeDef.name.value)) {
+                    if (typeDef.kind === Kind.INTERFACE_TYPE_DEFINITION ||
+                        typeDef.kind === Kind.INTERFACE_TYPE_EXTENSION) {
+                        context.reportError(new GraphQLError(`Invalid use of @policy on field "${typeDef.name.value}.${parent.name.value}": @policy cannot be applied on interfaces, interface fields and interface objects`, {
+                            extensions: {
+                                code: "AUTH_REQUIREMENTS_APPLIED_ON_INTERFACE",
+                            },
+                        }));
+                        return;
+                    }
+                    if (typeDef.kind === Kind.OBJECT_TYPE_DEFINITION ||
+                        typeDef.kind === Kind.OBJECT_TYPE_EXTENSION) {
                         context.stateBuilder.objectType.field.setPolicies(typeDef.name.value, parent.name.value, policies);
                     }
                     break;
                 }
                 case Kind.OBJECT_TYPE_DEFINITION:
                 case Kind.OBJECT_TYPE_EXTENSION:
+                    if (context.stateBuilder.isInterfaceObject(parent.name.value)) {
+                        context.reportError(new GraphQLError(`Invalid use of @policy on interface object "${parent.name.value}": @policy cannot be applied on interfaces, interface fields and interface objects`, {
+                            extensions: {
+                                code: "AUTH_REQUIREMENTS_APPLIED_ON_INTERFACE",
+                            },
+                        }));
+                        return;
+                    }
                     context.stateBuilder.objectType.setPolicies(parent.name.value, policies);
                     break;
                 case Kind.INTERFACE_TYPE_DEFINITION:
                 case Kind.INTERFACE_TYPE_DEFINITION:
-                    context.stateBuilder.interfaceType.setPolicies(parent.name.value, policies);
-                    break;
+                    context.reportError(new GraphQLError(`Invalid use of @policy on interface "${parent.name.value}": @policy cannot be applied on interfaces, interface fields and interface objects`, {
+                        extensions: {
+                            code: "AUTH_REQUIREMENTS_APPLIED_ON_INTERFACE",
+                        },
+                    }));
+                    return;
                 case Kind.SCALAR_TYPE_DEFINITION:
                 case Kind.SCALAR_TYPE_EXTENSION:
                     context.stateBuilder.scalarType.setPolicies(parent.name.value, policies);

package/esm/subgraph/validation/rules/elements/requires-scopes.js

@@ -1,4 +1,4 @@
-import { Kind } from "graphql";
+import { GraphQLError, Kind } from "graphql";
 import { print } from "../../../../graphql/printer.js";
 import { validateDirectiveAgainstOriginal } from "../../../helpers.js";
 export function RequiresScopesRule(context) {
@@ -52,6 +52,15 @@ export function RequiresScopesRule(context) {
                     if (!typeDef) {
                         throw new Error("Could not find the parent type of the field annotated with @requiresScopes");
                     }
+                    if (typeDef.kind === Kind.INTERFACE_TYPE_DEFINITION ||
+                        typeDef.kind === Kind.INTERFACE_TYPE_EXTENSION) {
+                        context.reportError(new GraphQLError(`Invalid use of @requiresScopes on field "${typeDef.name.value}.${parent.name.value}": @requiresScopes cannot be applied on interfaces, interface fields and interface objects`, {
+                            extensions: {
+                                code: "AUTH_REQUIREMENTS_APPLIED_ON_INTERFACE",
+                            },
+                        }));
+                        return;
+                    }
                     if (typeDef.kind === Kind.OBJECT_TYPE_DEFINITION ||
                         typeDef.kind === Kind.OBJECT_TYPE_EXTENSION) {
                         context.stateBuilder.objectType.field.setScopes(typeDef.name.value, parent.name.value, scopes);
@@ -60,12 +69,24 @@ export function RequiresScopesRule(context) {
                 }
                 case Kind.OBJECT_TYPE_DEFINITION:
                 case Kind.OBJECT_TYPE_EXTENSION:
+                    if (context.stateBuilder.isInterfaceObject(parent.name.value)) {
+                        context.reportError(new GraphQLError(`Invalid use of @requiresScopes on interface object "${parent.name.value}": @requiresScopes cannot be applied on interfaces, interface fields and interface objects`, {
+                            extensions: {
+                                code: "AUTH_REQUIREMENTS_APPLIED_ON_INTERFACE",
+                            },
+                        }));
+                        return;
+                    }
                     context.stateBuilder.objectType.setScopes(parent.name.value, scopes);
                     break;
                 case Kind.INTERFACE_TYPE_DEFINITION:
                 case Kind.INTERFACE_TYPE_DEFINITION:
-                    context.stateBuilder.interfaceType.setScopes(parent.name.value, scopes);
-                    break;
+                    context.reportError(new GraphQLError(`Invalid use of @requiresScopes on interface "${parent.name.value}": @requiresScopes cannot be applied on interfaces, interface fields and interface objects`, {
+                        extensions: {
+                            code: "AUTH_REQUIREMENTS_APPLIED_ON_INTERFACE",
+                        },
+                    }));
+                    return;
                 case Kind.SCALAR_TYPE_DEFINITION:
                 case Kind.SCALAR_TYPE_EXTENSION:
                     context.stateBuilder.scalarType.setScopes(parent.name.value, scopes);

package/esm/supergraph/composition/ast.js

@@ -515,16 +515,6 @@ function createAuthenticatedDirectiveNode() {
         arguments: [],
     };
 }
-function deduplicatePoliciesOrScopes(items) {
-    const stringified = items.map((group) => group.sort().join("ɵ"));
-    const indexesToRemove = [];
-    for (let index = 0; index < stringified.length; index++) {
-        if (stringified.indexOf(stringified[index]) !== index) {
-            indexesToRemove.push(index);
-        }
-    }
-    return items.filter((_, index) => !indexesToRemove.includes(index));
-}
 function createPolicyDirectiveNode(policies) {
     return {
         kind: Kind.DIRECTIVE,
@@ -541,7 +531,7 @@ function createPolicyDirectiveNode(policies) {
                 },
                 value: {
                     kind: Kind.LIST,
-                    values: deduplicatePoliciesOrScopes(policies).map((group) => ({
+                    values: policies.map((group) => ({
                         kind: Kind.LIST,
                         values: group.map((policy) => ({
                             kind: Kind.STRING,
@@ -569,7 +559,7 @@ function createRequiresScopesDirectiveNode(scopes) {
                 },
                 value: {
                     kind: Kind.LIST,
-                    values: deduplicatePoliciesOrScopes(scopes).map((group) => ({
+                    values: scopes.map((group) => ({
                         kind: Kind.LIST,
                         values: group.map((scope) => ({
                             kind: Kind.STRING,
@@ -713,7 +703,8 @@ function createCostDirectiveNode(input) {
 }
 function createListSizeDirectiveNode(input) {
     const args = [];
-    if (input.requireOneSlicingArgument === false) {
+    if (input.requireOneSlicingArgument === false ||
+        input.printRequireOneSlicingArgument === true) {
         args.push({
             kind: Kind.ARGUMENT,
             name: {
@@ -722,7 +713,7 @@ function createListSizeDirectiveNode(input) {
             },
             value: {
                 kind: Kind.BOOLEAN,
-                value: false,
+                value: input.requireOneSlicingArgument === true,
             },
         });
     }

package/esm/supergraph/composition/enum-type.js

@@ -1,6 +1,7 @@
 import { ensureValue, mathMax } from "../../utils/helpers.js";
 import { createEnumTypeNode } from "./ast.js";
 import { convertToConst } from "./common.js";
+import { mergeScopePolicies } from "../../utils/auth.js";
 export function enumTypeBuilder() {
     return {
         visitSubgraphState(graph, state, typeName, type) {
@@ -13,10 +14,10 @@ export function enumTypeBuilder() {
                 enumTypeState.authenticated = true;
             }
             if (type.policies) {
-                enumTypeState.policies.push(...type.policies);
+                enumTypeState.policies = mergeScopePolicies(enumTypeState.policies, type.policies);
             }
             if (type.scopes) {
-                enumTypeState.scopes.push(...type.scopes);
+                enumTypeState.scopes = mergeScopePolicies(enumTypeState.scopes, type.scopes);
             }
             if (type.cost !== null) {
                 enumTypeState.cost = mathMax(type.cost, enumTypeState.cost);

package/esm/supergraph/composition/interface-type.js

@@ -1,6 +1,7 @@
-import { ensureValue, mathMax, mathMaxNullable, nullableArrayUnion, } from "../../utils/helpers.js";
+import { ensureValue, isDefined, mathMax, mathMaxNullable, nullableArrayUnion, } from "../../utils/helpers.js";
 import { createInterfaceTypeNode } from "./ast.js";
 import { convertToConst } from "./common.js";
+import { mergeScopePolicies } from "../../utils/auth.js";
 export function interfaceTypeBuilder() {
     return {
         visitSubgraphState(graph, state, typeName, type) {
@@ -9,15 +10,6 @@ export function interfaceTypeBuilder() {
             if (type.inaccessible) {
                 interfaceTypeState.inaccessible = true;
             }
-            if (type.authenticated) {
-                interfaceTypeState.authenticated = true;
-            }
-            if (type.policies) {
-                interfaceTypeState.policies.push(...type.policies);
-            }
-            if (type.scopes) {
-                interfaceTypeState.scopes.push(...type.scopes);
-            }
             if (type.isDefinition) {
                 interfaceTypeState.hasDefinition = true;
             }
@@ -59,16 +51,17 @@ export function interfaceTypeBuilder() {
                     fieldState.authenticated = true;
                 }
                 if (field.policies) {
-                    fieldState.policies.push(...field.policies);
+                    fieldState.policies = mergeScopePolicies(fieldState.policies, field.policies);
                 }
                 if (field.scopes) {
-                    fieldState.scopes.push(...field.scopes);
+                    fieldState.scopes = mergeScopePolicies(fieldState.scopes, field.scopes);
                 }
                 if (field.cost !== null) {
                     fieldState.cost = mathMax(field.cost, fieldState.cost);
                 }
                 if (field.listSize !== null) {
                     fieldState.listSize = {
+                        printRequireOneSlicingArgument: false,
                         assumedSize: mathMaxNullable(fieldState.listSize?.assumedSize, field.listSize.assumedSize),
                         requireOneSlicingArgument: (fieldState.listSize?.requireOneSlicingArgument ?? true) &&
                             field.listSize.requireOneSlicingArgument,
@@ -98,6 +91,9 @@ export function interfaceTypeBuilder() {
                     version: graph.version,
                     external: field.external,
                     shareable: field.shareable,
+                    authenticated: field.authenticated,
+                    policies: field.policies,
+                    scopes: field.scopes,
                     usedAsKey,
                 });
                 for (const arg of field.args.values()) {
@@ -131,6 +127,31 @@ export function interfaceTypeBuilder() {
                 }
             }
         },
+        composeSupergraphState(interfaceType, graphs, { supergraphState }) {
+            const implementors = Array.from(interfaceType.implementedBy)
+                .map((typeName) => supergraphState.objectTypes.get(typeName))
+                .filter(isDefined);
+            for (const implementor of implementors) {
+                interfaceType.scopes = mergeScopePolicies(interfaceType.scopes, implementor.scopes);
+                interfaceType.policies = mergeScopePolicies(interfaceType.policies, implementor.policies);
+                if (implementor.authenticated) {
+                    interfaceType.authenticated = true;
+                }
+            }
+            for (const field of interfaceType.fields.values()) {
+                for (const implementor of implementors) {
+                    let implementorField = implementor.fields.get(field.name);
+                    if (!implementorField) {
+                        continue;
+                    }
+                    field.scopes = mergeScopePolicies(field.scopes, implementorField.scopes);
+                    field.policies = mergeScopePolicies(field.policies, implementorField.policies);
+                    if (implementorField.authenticated) {
+                        field.authenticated = true;
+                    }
+                }
+            }
+        },
         composeSupergraphNode(interfaceType, graphs, { supergraphState }) {
             return createInterfaceTypeNode({
                 name: interfaceType.name,

package/esm/supergraph/composition/object-type.js

@@ -1,6 +1,7 @@
 import { ensureValue, isDefined, mathMax, mathMaxNullable, nullableArrayUnion, } from "../../utils/helpers.js";
 import { createObjectTypeNode } from "./ast.js";
 import { convertToConst } from "./common.js";
+import { mergeScopePolicies } from "../../utils/auth.js";
 export function isRealExtension(meta, version) {
     const hasExtendsDirective = meta.extensionType === "@extends";
     if (meta.extension) {
@@ -29,10 +30,10 @@ export function objectTypeBuilder() {
                 objectTypeState.authenticated = true;
             }
             if (type.policies) {
-                objectTypeState.policies.push(...type.policies);
+                objectTypeState.policies = mergeScopePolicies(objectTypeState.policies, type.policies);
             }
             if (type.scopes) {
-                objectTypeState.scopes.push(...type.scopes);
+                objectTypeState.scopes = mergeScopePolicies(objectTypeState.scopes, type.scopes);
             }
             if (type.cost !== null) {
                 objectTypeState.cost = mathMax(type.cost, objectTypeState.cost);
@@ -64,6 +65,9 @@ export function objectTypeBuilder() {
                 shareable: type.shareable,
                 interfaces: type.interfaces,
                 version: graph.version,
+                authenticated: type.authenticated,
+                policies: type.policies.slice(),
+                scopes: type.scopes.slice(),
             });
             const typeInGraph = objectTypeState.byGraph.get(graph.id);
             for (const field of type.fields.values()) {
@@ -96,16 +100,17 @@ export function objectTypeBuilder() {
                     fieldState.authenticated = true;
                 }
                 if (field.policies) {
-                    fieldState.policies.push(...field.policies);
+                    fieldState.policies = mergeScopePolicies(fieldState.policies, field.policies);
                 }
                 if (field.scopes) {
-                    fieldState.scopes.push(...field.scopes);
+                    fieldState.scopes = mergeScopePolicies(fieldState.scopes, field.scopes);
                 }
                 if (field.cost !== null) {
                     fieldState.cost = mathMax(field.cost, fieldState.cost);
                 }
                 if (field.listSize !== null) {
                     fieldState.listSize = {
+                        printRequireOneSlicingArgument: false,
                         assumedSize: mathMaxNullable(fieldState.listSize?.assumedSize, field.listSize.assumedSize),
                         requireOneSlicingArgument: (fieldState.listSize?.requireOneSlicingArgument ?? true) &&
                             field.listSize.requireOneSlicingArgument,
@@ -141,6 +146,9 @@ export function objectTypeBuilder() {
                     required: field.required,
                     shareable: field.shareable,
                     extension: field.extension,
+                    authenticated: field.authenticated,
+                    policies: field.policies,
+                    scopes: field.scopes,
                     used: field.used,
                     usedAsKey,
                     version: graph.version,
@@ -180,6 +188,27 @@ export function objectTypeBuilder() {
                 }
             }
         },
+        composeSupergraphState(objectType, _graphs, { supergraphState }) {
+            for (const interfaceName of objectType.interfaces) {
+                const interfaceState = supergraphState.interfaceTypes.get(interfaceName);
+                if (!interfaceState) {
+                    throw new Error(`Interface "${interfaceName}" not found in Supergraph state`);
+                }
+                for (const [interfaceFieldName, interfaceField,] of interfaceState.fields) {
+                    if (!interfaceState.hasInterfaceObject) {
+                        continue;
+                    }
+                    const fieldState = objectType.fields.get(interfaceFieldName);
+                    if (fieldState) {
+                        fieldState.scopes = mergeScopePolicies(fieldState.scopes, interfaceField.scopes);
+                        fieldState.policies = mergeScopePolicies(fieldState.policies, interfaceField.policies);
+                        if (interfaceField.authenticated) {
+                            fieldState.authenticated = true;
+                        }
+                    }
+                }
+            }
+        },
         composeSupergraphNode(objectType, graphs, { graphNameToId, supergraphState }) {
             const isQuery = objectType.name === "Query";
             const joinTypes = isQuery
@@ -569,13 +598,23 @@ export function objectTypeBuilder() {
                     .concat(resolvableFieldsFromInterfaceObjects
                     .filter((f) => !objectType.fields.has(f.name))
                     .map((field) => {
+                    let scopes = [];
+                    let policies = [];
+                    let authenticated = false;
+                    for (const fieldInGraph of field.byGraph.values()) {
+                        scopes = mergeScopePolicies(scopes, fieldInGraph.scopes);
+                        policies = mergeScopePolicies(policies, fieldInGraph.policies);
+                        if (fieldInGraph.authenticated) {
+                            authenticated = true;
+                        }
+                    }
                     return {
                         name: field.name,
                         type: field.type,
                         inaccessible: field.inaccessible,
-                        authenticated: field.authenticated,
-                        policies: field.policies,
-                        scopes: field.scopes,
+                        authenticated,
+                        policies,
+                        scopes,
                         cost: field.cost !== null
                             ? {
                                 cost: field.cost,

package/esm/supergraph/composition/scalar-type.js

@@ -1,6 +1,7 @@
 import { ensureValue, mathMax } from "../../utils/helpers.js";
 import { createScalarTypeNode } from "./ast.js";
 import { convertToConst } from "./common.js";
+import { mergeScopePolicies } from "../../utils/auth.js";
 export function scalarTypeBuilder() {
     return {
         visitSubgraphState(graph, state, typeName, type) {
@@ -13,10 +14,10 @@ export function scalarTypeBuilder() {
                 scalarTypeState.authenticated = true;
             }
             if (type.policies) {
-                scalarTypeState.policies.push(...type.policies);
+                scalarTypeState.policies = mergeScopePolicies(scalarTypeState.policies, type.policies);
             }
             if (type.scopes) {
-                scalarTypeState.scopes.push(...type.scopes);
+                scalarTypeState.scopes = mergeScopePolicies(scalarTypeState.scopes, type.scopes);
             }
             if (type.cost !== null) {
                 scalarTypeState.cost = mathMax(type.cost, scalarTypeState.cost);

package/esm/supergraph/state.js

@@ -46,6 +46,12 @@ export function createSupergraphStateBuilder() {
     const unionType = unionTypeBuilder();
     const subgraphStates = new Map();
     const graphNameToIdMap = {};
+    const helpers = {
+        graphNameToId(graphName) {
+            return graphNameToIdMap[graphName] ?? null;
+        },
+        supergraphState: state,
+    };
     return {
         addSubgraph(subgraph) {
             if (state.subgraphs.has(subgraph.graph.id)) {
@@ -57,6 +63,43 @@ export function createSupergraphStateBuilder() {
         getGraph(id) {
             return state.subgraphs.get(id);
         },
+        composeSupergraphState() {
+            if (directive.composeSupergraphState) {
+                state.directives.forEach((s) => {
+                    directive.composeSupergraphState(s, state.subgraphs, helpers);
+                });
+            }
+            if (scalarType.composeSupergraphState) {
+                state.scalarTypes.forEach((s) => {
+                    scalarType.composeSupergraphState(s, state.subgraphs, helpers);
+                });
+            }
+            if (enumType.composeSupergraphState) {
+                state.enumTypes.forEach((s) => {
+                    enumType.composeSupergraphState(s, state.subgraphs, helpers);
+                });
+            }
+            if (inputObjectType.composeSupergraphState) {
+                state.inputObjectTypes.forEach((s) => {
+                    inputObjectType.composeSupergraphState(s, state.subgraphs, helpers);
+                });
+            }
+            if (objectType.composeSupergraphState) {
+                state.objectTypes.forEach((s) => {
+                    objectType.composeSupergraphState(s, state.subgraphs, helpers);
+                });
+            }
+            if (interfaceType.composeSupergraphState) {
+                state.interfaceTypes.forEach((s) => {
+                    interfaceType.composeSupergraphState(s, state.subgraphs, helpers);
+                });
+            }
+            if (unionType.composeSupergraphState) {
+                state.unionTypes.forEach((s) => {
+                    unionType.composeSupergraphState(s, state.subgraphs, helpers);
+                });
+            }
+        },
         visitSubgraphState(subgraphState) {
             subgraphStates.set(subgraphState.graph.id, subgraphState);
             for (const link of subgraphState.links) {
@@ -131,12 +174,6 @@ export function createSupergraphStateBuilder() {
         },
         build() {
             const transformFields = createFieldsTransformer(state);
-            const helpers = {
-                graphNameToId(graphName) {
-                    return graphNameToIdMap[graphName] ?? null;
-                },
-                supergraphState: state,
-            };
             for (const directiveState of state.directives.values()) {
                 if (!directiveState.isExecutable || !directiveState.byGraph.size) {
                     continue;