@theguild/federation-composition 0.20.2 → 0.21.0

package/esm/supergraph/validation/rules/auth-on-requires-rule.js

@@ -0,0 +1,208 @@
+import { GraphQLError, Kind, specifiedScalarTypes, } from "graphql";
+import { parseFields } from "../../../subgraph/helpers.js";
+import { mergeScopePolicies } from "../../../utils/auth.js";
+export function AuthOnRequiresRule(context, supergraph) {
+    return {
+        ObjectTypeField(objectTypeState, fieldState) {
+            for (const [graphId, fieldInGraph] of fieldState.byGraph) {
+                if (!fieldInGraph.requires) {
+                    continue;
+                }
+                const selectionSet = parseFields(fieldInGraph.requires);
+                if (!selectionSet) {
+                    continue;
+                }
+                const provisionedAccess = new ProvisionedAccess(objectTypeState, fieldState);
+                let fieldLackingAccess = ensureAccessToSelectionSet(supergraph, objectTypeState, selectionSet, provisionedAccess);
+                if (fieldLackingAccess) {
+                    context.reportError(createAccessRequirementError(context.graphIdToName(graphId), `${objectTypeState.name}.${fieldState.name}`, fieldLackingAccess));
+                    return;
+                }
+            }
+        },
+    };
+}
+function ensureAccessToSelectionSet(supergraph, currentType, selectionSet, provisionedAccess) {
+    for (const selection of selectionSet.selections) {
+        switch (selection.kind) {
+            case Kind.FIELD: {
+                if (currentType.kind === "union") {
+                    throw new Error("Cannot select fields directly on union types.");
+                }
+                const fieldLackingAccess = ensureAccessToField(supergraph, currentType, selection, provisionedAccess);
+                if (fieldLackingAccess) {
+                    return fieldLackingAccess;
+                }
+                break;
+            }
+            case Kind.INLINE_FRAGMENT: {
+                const fieldLackingAccess = ensureAccessToInlineFragment(supergraph, currentType, selection, provisionedAccess);
+                if (fieldLackingAccess) {
+                    return fieldLackingAccess;
+                }
+                break;
+            }
+            case Kind.FRAGMENT_SPREAD: {
+                throw new Error("Fragment spreads are not supported in @requires.");
+            }
+        }
+    }
+}
+function ensureAccessToField(supergraph, currentType, fieldNode, provisionedAccess) {
+    if (fieldNode.name.value === "__typename") {
+        return;
+    }
+    let fieldName = fieldNode.name.value;
+    let fieldState = currentType.fields.get(fieldNode.name.value);
+    let fieldDetails = null;
+    if (fieldState) {
+        fieldDetails = {
+            type: fieldState.type,
+            scopes: fieldState.scopes,
+            policies: fieldState.policies,
+            authenticated: fieldState.authenticated,
+        };
+    }
+    else {
+        if (currentType.kind === "interface") {
+            throw new Error(`Field "${fieldNode.name.value}" not found on interface type "${currentType.name}".`);
+        }
+        for (const interfaceName of currentType.interfaces) {
+            const interfaceType = supergraph.interfaceTypes.get(interfaceName);
+            if (!interfaceType) {
+                throw new Error(`Interface "${interfaceName}" implemented by "${currentType.name}" not found in supergraph.`);
+            }
+            const interfaceFieldState = interfaceType.fields.get(fieldNode.name.value);
+            if (interfaceFieldState) {
+                if (!fieldDetails) {
+                    fieldDetails = {
+                        type: interfaceFieldState.type,
+                        scopes: mergeScopePolicies([], interfaceFieldState.scopes),
+                        policies: mergeScopePolicies([], interfaceFieldState.policies),
+                        authenticated: interfaceFieldState.authenticated,
+                    };
+                }
+                else {
+                    fieldDetails = {
+                        type: interfaceFieldState.type,
+                        scopes: mergeScopePolicies(fieldDetails.scopes, interfaceFieldState.scopes),
+                        policies: mergeScopePolicies(fieldDetails.policies, interfaceFieldState.policies),
+                        authenticated: interfaceFieldState.authenticated
+                            ? true
+                            : fieldDetails.authenticated,
+                    };
+                }
+            }
+        }
+    }
+    if (fieldDetails === null) {
+        throw new Error(`Field "${fieldName}" not found on type "${currentType.name}".`);
+    }
+    if (!provisionedAccess.canAccess(fieldDetails)) {
+        return `${currentType.name}.${fieldName}`;
+    }
+    const outputTypeName = extractNamedTypeName(fieldDetails.type);
+    if (!outputTypeName) {
+        throw new Error(`Unable to extract output type name from field "${currentType.name}.${fieldName}" type "${fieldDetails.type}".`);
+    }
+    if (specifiedScalarTypes.some((s) => s.name === outputTypeName)) {
+        return;
+    }
+    const outputType = supergraph.objectTypes.get(outputTypeName) ??
+        supergraph.interfaceTypes.get(outputTypeName) ??
+        supergraph.enumTypes.get(outputTypeName) ??
+        supergraph.scalarTypes.get(outputTypeName) ??
+        supergraph.unionTypes.get(outputTypeName);
+    if (!outputType) {
+        throw new Error(`Output type "${outputTypeName}" of field "${currentType.name}.${fieldName}" not found in supergraph.`);
+    }
+    if (outputType.kind !== "union" && !provisionedAccess.canAccess(outputType)) {
+        return `${currentType.name}.${fieldName}`;
+    }
+    if (!fieldNode.selectionSet) {
+        return;
+    }
+    if (outputType.kind === "enum" || outputType.kind === "scalar") {
+        throw new Error(`Field "${currentType.name}.${fieldName}" of type "${outputType.name}" cannot have a selection set.`);
+    }
+    return ensureAccessToSelectionSet(supergraph, outputType, fieldNode.selectionSet, provisionedAccess);
+}
+function ensureAccessToInlineFragment(supergraph, currentType, inlineFragment, provisionedAccess) {
+    const concreteType = inlineFragment.typeCondition
+        ? (supergraph.objectTypes.get(inlineFragment.typeCondition.name.value) ??
+            supergraph.interfaceTypes.get(inlineFragment.typeCondition.name.value))
+        : currentType;
+    if (!concreteType) {
+        throw new Error(`Type "${currentType.name}" not found in supergraph for inline fragment.`);
+    }
+    if (concreteType.kind == "union") {
+        throw new Error("Cannot have inline fragments on union types without type conditions.");
+    }
+    if (!provisionedAccess.canAccess(concreteType)) {
+        return concreteType.name;
+    }
+    return ensureAccessToSelectionSet(supergraph, concreteType, inlineFragment.selectionSet, provisionedAccess);
+}
+function createAccessRequirementError(graphName, fieldWithRequiresCoordinate, authCoordinate) {
+    const strDataRef = authCoordinate.includes(".")
+        ? `field "${authCoordinate}"`
+        : `type "${authCoordinate}"`;
+    return new GraphQLError(`[${graphName}] Field "${fieldWithRequiresCoordinate}" does not specify necessary @authenticated, @requiresScopes and/or @policy auth requirements to access the transitive ${strDataRef} data from @requires selection set.`, {
+        extensions: {
+            code: "MISSING_TRANSITIVE_AUTH_REQUIREMENTS",
+        },
+    });
+}
+function extractNamedTypeName(typeStr) {
+    let typeName = typeStr;
+    if (!typeName)
+        return null;
+    typeName = typeName.replace(/[![\]]/g, "");
+    return typeName || null;
+}
+class ProvisionedAccess {
+    scopes;
+    policies;
+    authenticated;
+    constructor(objectTypeState, fieldState) {
+        this.scopes = [];
+        this.policies = [];
+        this.authenticated = false;
+        if (objectTypeState.authenticated) {
+            this.authenticated = true;
+        }
+        if (objectTypeState.scopes.length > 0) {
+            this.scopes = objectTypeState.scopes.slice();
+        }
+        if (objectTypeState.policies.length > 0) {
+            this.policies = objectTypeState.policies.slice();
+        }
+        if (fieldState.authenticated) {
+            this.authenticated = true;
+        }
+        if (fieldState.scopes.length > 0) {
+            this.scopes = mergeScopePolicies(this.scopes, fieldState.scopes);
+        }
+        if (fieldState.policies.length > 0) {
+            this.policies = mergeScopePolicies(this.policies, fieldState.policies);
+        }
+    }
+    canAccess(required) {
+        if (required.authenticated && !this.authenticated) {
+            return false;
+        }
+        for (const requiredScopeGroup of required.scopes) {
+            const satisfiedByAny = this.scopes.some((providedGroup) => requiredScopeGroup.every((scope) => providedGroup.includes(scope)));
+            if (!satisfiedByAny) {
+                return false;
+            }
+        }
+        for (const requiredPolicyGroup of required.policies) {
+            const satisfiedByAny = this.policies.some((providedGroup) => requiredPolicyGroup.every((policy) => providedGroup.includes(policy)));
+            if (!satisfiedByAny) {
+                return false;
+            }
+        }
+        return true;
+    }
+}

package/esm/supergraph/validation/rules/external-missing-on-base-rule.js

@@ -1,6 +1,6 @@
 import { GraphQLError } from "graphql";
 import { andList } from "../../../utils/format.js";
-export function ExternalMissingOnBaseRule(context) {
+export function ExternalMissingOnBaseRule(context, supergraph) {
     return {
         ObjectType(objectTypeState) {
             if (Array.from(objectTypeState.byGraph).every(([_, stateInGraph]) => stateInGraph.external === true)) {
@@ -29,6 +29,31 @@ export function ExternalMissingOnBaseRule(context) {
                 }
                 return fieldStateInGraph.external === true;
             })) {
+                for (let interfaceName of objectState.interfaces) {
+                    let interfaceState = supergraph.interfaceTypes.get(interfaceName);
+                    if (!interfaceState) {
+                        continue;
+                    }
+                    if (!interfaceState.hasInterfaceObject) {
+                        continue;
+                    }
+                    for (let [graphId, interfaceStateInGraph] of interfaceState.byGraph) {
+                        if (!interfaceStateInGraph.isInterfaceObject) {
+                            continue;
+                        }
+                        let interfaceFieldState = interfaceState.fields.get(fieldState.name);
+                        if (!interfaceFieldState) {
+                            continue;
+                        }
+                        let interfaceFieldInGraph = interfaceFieldState.byGraph.get(graphId);
+                        if (!interfaceFieldInGraph) {
+                            continue;
+                        }
+                        if (interfaceFieldInGraph.external !== true) {
+                            return;
+                        }
+                    }
+                }
                 const subgraphs = fieldState.byGraph.size > 1 ? "subgraphs" : "subgraph";
                 context.reportError(new GraphQLError(`Field "${objectState.name}.${fieldState.name}" is marked @external on all the subgraphs in which it is listed (${subgraphs} ${andList(Array.from(fieldState.byGraph.keys()).map(context.graphIdToName), true, '"')}).`, {
                     extensions: {

package/esm/supergraph/validation/rules/list-size-slicing-arguments-rule.js

@@ -0,0 +1,66 @@
+import { GraphQLError } from "graphql";
+export function ListSizeSlicingArgumentsRule(context, supergraph) {
+    return {
+        ObjectTypeField(objectState, fieldState) {
+            let error = ensureSlicingArgumentsExist(objectState.name, fieldState);
+            if (error) {
+                context.reportError(error);
+            }
+        },
+        InterfaceTypeField(interfaceState, fieldState) {
+            let error = ensureSlicingArgumentsExist(interfaceState.name, fieldState);
+            if (error) {
+                context.reportError(error);
+                return;
+            }
+            if (!fieldState?.listSize ||
+                !fieldState?.listSize.slicingArguments?.length) {
+                return;
+            }
+            for (const implementorName of interfaceState.implementedBy) {
+                const implementorType = supergraph.objectTypes.get(implementorName);
+                if (!implementorType) {
+                    continue;
+                }
+                let implementorField = implementorType.fields.get(fieldState.name);
+                if (!implementorField) {
+                    continue;
+                }
+                if (!implementorField.listSize) {
+                    continue;
+                }
+                if (!implementorField.listSize.slicingArguments?.length) {
+                    continue;
+                }
+                fieldState.listSize.printRequireOneSlicingArgument = true;
+            }
+        },
+    };
+}
+function ensureSlicingArgumentsExist(typeName, fieldState) {
+    if (!fieldState.listSize?.slicingArguments?.length) {
+        return;
+    }
+    const newslicingArguments = [];
+    for (const argName of fieldState.listSize.slicingArguments) {
+        const argState = fieldState.args.get(argName);
+        if (!argState) {
+            throw new Error("Could not find the argument in the field annotated with @listSize");
+        }
+        if (argState.byGraph.size !== fieldState.byGraph.size) {
+            continue;
+        }
+        newslicingArguments.push(argName);
+    }
+    if (!newslicingArguments.length) {
+        return new GraphQLError([
+            `All arguments for @listSize(slicingArguments:) on field "${typeName}.${fieldState.name}" were disregarded.`,
+            `For an argument to be valid, it must be defined in every subgraph where the field exists.`,
+        ].join(" "), {
+            extensions: {
+                code: "LIST_SIZE_INVALID_SLICING_ARGUMENT",
+            },
+        });
+    }
+    fieldState.listSize.slicingArguments = newslicingArguments;
+}

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

@@ -1,4 +1,5 @@
 import { visitSupergraphState } from "../composition/visitor.js";
+import { AuthOnRequiresRule } from "./rules/auth-on-requires-rule.js";
 import { DefaultValueUsesInaccessibleRule } from "./rules/default-value-uses-inaccessible-rule.js";
 import { DirectiveCompositionRule } from "./rules/directive-composition-rule.js";
 import { EnumValuesRule } from "./rules/enum-values-rule.js";
@@ -17,6 +18,7 @@ import { InterfaceObjectUsageErrorRule } from "./rules/interface-object-usage-er
 import { InterfaceSubtypeRule } from "./rules/interface-subtype-rule.js";
 import { InvalidFieldSharingRule } from "./rules/invalid-field-sharing-rule.js";
 import { LinkImportNameMismatchRule } from "./rules/link-import-name-mismatch-rule.js";
+import { ListSizeSlicingArgumentsRule } from "./rules/list-size-slicing-arguments-rule.js";
 import { NoInaccessibleOnImplementedInterfaceFieldsRule } from "./rules/no-inaccessible-on-implemented-interface-fields-rule.js";
 import { OnlyInaccessibleChildrenRule } from "./rules/only-inaccessible-children-rule.js";
 import { OverrideSourceHasOverrideRule } from "./rules/override-source-has-override.js";
@@ -49,6 +51,7 @@ export function validateSupergraph(subgraphStates, state, __internal) {
     for (const subgraphState of subgraphStates.values()) {
         state.visitSubgraphState(subgraphState);
     }
+    state.composeSupergraphState();
     const postSupergraphRules = [
         InterfaceFieldNoImplementationRule,
         ExtensionWithBaseRule,
@@ -76,6 +79,8 @@ export function validateSupergraph(subgraphStates, state, __internal) {
         RequiredArgumentOrFieldIsNotInaccessibleRule,
         InterfaceSubtypeRule,
         NoInaccessibleOnImplementedInterfaceFieldsRule,
+        ListSizeSlicingArgumentsRule,
+        AuthOnRequiresRule,
     ];
     const supergraph = state.getSupergraphState();
     visitSupergraphState(supergraph, postSupergraphRules.map((rule) => {

package/esm/utils/auth.js

@@ -0,0 +1,31 @@
+export function mergeScopePolicies(policyA, policyB) {
+    if (policyA.length === 0 || policyB.length === 0) {
+        return policyA.length
+            ? policyA.map((group) => [...group])
+            : policyB.map((group) => [...group]);
+    }
+    const groupMap = new Map();
+    for (const groupA of policyA) {
+        for (const groupB of policyB) {
+            const merged = Array.from(new Set([...groupA, ...groupB])).sort();
+            const key = merged.join(",");
+            groupMap.set(key, merged);
+        }
+    }
+    const candidates = Array.from(groupMap.values()).sort((a, b) => a.length - b.length);
+    const finalGroups = [];
+    for (const candidate of candidates) {
+        if (!finalGroups.some((existing) => isSubset(existing, candidate))) {
+            finalGroups.push(candidate);
+        }
+    }
+    finalGroups.sort((a, b) => a.length - b.length || a.join(",").localeCompare(b.join(",")));
+    return finalGroups;
+}
+function isSubset(subset, superset) {
+    if (subset.length > superset.length) {
+        return false;
+    }
+    const supersetSet = new Set(superset);
+    return subset.every((item) => supersetSet.has(item));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@theguild/federation-composition",
-  "version": "0.20.2",
+  "version": "0.21.0",
   "description": "Open Source Composition library for Apollo Federation",
   "peerDependencies": {
     "graphql": "^16.0.0"

package/typings/subgraph/state.d.cts

@@ -73,9 +73,6 @@ export interface InterfaceType {
     extension: boolean;
     keys: Key[];
     inaccessible: boolean;
-    authenticated: boolean;
-    policies: string[][];
-    scopes: string[][];
     tags: Set<string>;
     interfaces: Set<string>;
     isDefinition: boolean;
@@ -211,6 +208,7 @@ export interface Deprecated {
     deprecated: true;
 }
 export type ListSize = {
+    printRequireOneSlicingArgument: boolean;
     assumedSize: number | null;
     slicingArguments: string[] | null;
     sizedFields: string[] | null;
@@ -339,9 +337,6 @@ export declare function createSubgraphStateBuilder(graph: {
         setInterfaceObject(typeName: string): void;
         setKey(typeName: string, fields: string, fieldsUsedInKey: Set<string>, resolvable: boolean): void;
         setInaccessible(typeName: string): void;
-        setAuthenticated(typeName: string): void;
-        setPolicies(typeName: string, policies: string[][]): void;
-        setScopes(typeName: string, scopes: string[][]): void;
         setTag(typeName: string, tag: string): void;
         setDirective(typeName: string, directive: DirectiveNode): void;
         setDescription(typeName: string, description: Description): void;

package/typings/subgraph/state.d.ts

@@ -73,9 +73,6 @@ export interface InterfaceType {
     extension: boolean;
     keys: Key[];
     inaccessible: boolean;
-    authenticated: boolean;
-    policies: string[][];
-    scopes: string[][];
     tags: Set<string>;
     interfaces: Set<string>;
     isDefinition: boolean;
@@ -211,6 +208,7 @@ export interface Deprecated {
     deprecated: true;
 }
 export type ListSize = {
+    printRequireOneSlicingArgument: boolean;
     assumedSize: number | null;
     slicingArguments: string[] | null;
     sizedFields: string[] | null;
@@ -339,9 +337,6 @@ export declare function createSubgraphStateBuilder(graph: {
         setInterfaceObject(typeName: string): void;
         setKey(typeName: string, fields: string, fieldsUsedInKey: Set<string>, resolvable: boolean): void;
         setInaccessible(typeName: string): void;
-        setAuthenticated(typeName: string): void;
-        setPolicies(typeName: string, policies: string[][]): void;
-        setScopes(typeName: string, scopes: string[][]): void;
         setTag(typeName: string, tag: string): void;
         setDirective(typeName: string, directive: DirectiveNode): void;
         setDescription(typeName: string, description: Description): void;

package/typings/subgraph/validation/validation-context.d.cts

@@ -105,9 +105,6 @@ export declare function createSubgraphValidationContext(subgraph: {
             setInterfaceObject(typeName: string): void;
             setKey(typeName: string, fields: string, fieldsUsedInKey: Set<string>, resolvable: boolean): void;
             setInaccessible(typeName: string): void;
-            setAuthenticated(typeName: string): void;
-            setPolicies(typeName: string, policies: string[][]): void;
-            setScopes(typeName: string, scopes: string[][]): void;
             setTag(typeName: string, tag: string): void;
             setDirective(typeName: string, directive: import("graphql").DirectiveNode): void;
             setDescription(typeName: string, description: import("../state.js").Description): void;

package/typings/subgraph/validation/validation-context.d.ts

@@ -105,9 +105,6 @@ export declare function createSubgraphValidationContext(subgraph: {
             setInterfaceObject(typeName: string): void;
             setKey(typeName: string, fields: string, fieldsUsedInKey: Set<string>, resolvable: boolean): void;
             setInaccessible(typeName: string): void;
-            setAuthenticated(typeName: string): void;
-            setPolicies(typeName: string, policies: string[][]): void;
-            setScopes(typeName: string, scopes: string[][]): void;
             setTag(typeName: string, tag: string): void;
             setDirective(typeName: string, directive: import("graphql").DirectiveNode): void;
             setDescription(typeName: string, description: import("../state.js").Description): void;

package/typings/supergraph/composition/ast.d.cts

@@ -236,6 +236,7 @@ declare function createListSizeDirectiveNode(input: {
     slicingArguments: string[] | null;
     sizedFields: string[] | null;
     requireOneSlicingArgument: boolean;
+    printRequireOneSlicingArgument: boolean;
     directiveName: string;
 }): ConstDirectiveNode;
 declare function createLinkDirectiveNode(link: {

package/typings/supergraph/composition/ast.d.ts

@@ -236,6 +236,7 @@ declare function createListSizeDirectiveNode(input: {
     slicingArguments: string[] | null;
     sizedFields: string[] | null;
     requireOneSlicingArgument: boolean;
+    printRequireOneSlicingArgument: boolean;
     directiveName: string;
 }): ConstDirectiveNode;
 declare function createLinkDirectiveNode(link: {

package/typings/supergraph/composition/common.d.cts

@@ -15,6 +15,10 @@ export interface Graph {
 }
 export interface TypeBuilder<T, S> {
     visitSubgraphState(graph: Graph, state: Map<string, S>, typeName: string, type: T): void;
+    composeSupergraphState?(type: S, graphMap: Map<string, SubgraphState>, helpers: {
+        graphNameToId(graphName: string): string | null;
+        supergraphState: SupergraphState;
+    }): void;
     composeSupergraphNode(type: S, graphMap: Map<string, SubgraphState>, helpers: {
         graphNameToId(graphName: string): string | null;
         supergraphState: SupergraphState;

package/typings/supergraph/composition/common.d.ts

@@ -15,6 +15,10 @@ export interface Graph {
 }
 export interface TypeBuilder<T, S> {
     visitSubgraphState(graph: Graph, state: Map<string, S>, typeName: string, type: T): void;
+    composeSupergraphState?(type: S, graphMap: Map<string, SubgraphState>, helpers: {
+        graphNameToId(graphName: string): string | null;
+        supergraphState: SupergraphState;
+    }): void;
     composeSupergraphNode(type: S, graphMap: Map<string, SubgraphState>, helpers: {
         graphNameToId(graphName: string): string | null;
         supergraphState: SupergraphState;

package/typings/supergraph/composition/interface-type.d.cts

@@ -75,6 +75,9 @@ type FieldStateInGraph = {
     external: boolean;
     requires: string | null;
     version: FederationVersion;
+    authenticated: boolean;
+    policies: string[][];
+    scopes: string[][];
 };
 type ArgStateInGraph = {
     type: string;

package/typings/supergraph/composition/interface-type.d.ts

@@ -75,6 +75,9 @@ type FieldStateInGraph = {
     external: boolean;
     requires: string | null;
     version: FederationVersion;
+    authenticated: boolean;
+    policies: string[][];
+    scopes: string[][];
 };
 type ArgStateInGraph = {
     type: string;

package/typings/supergraph/composition/object-type.d.cts

@@ -68,6 +68,9 @@ export type ObjectTypeStateInGraph = {
     extension: boolean;
     extensionType?: "@extends" | "extend";
     external: boolean;
+    authenticated: boolean;
+    policies: string[][];
+    scopes: string[][];
     keys: Key[];
     interfaces: Set<string>;
     inaccessible: boolean;
@@ -86,6 +89,9 @@ type FieldStateInGraph = {
     requires: string | null;
     provided: boolean;
     required: boolean;
+    authenticated: boolean;
+    policies: string[][];
+    scopes: string[][];
     shareable: boolean;
     usedAsKey: boolean;
     extension: boolean;

package/typings/supergraph/composition/object-type.d.ts

@@ -68,6 +68,9 @@ export type ObjectTypeStateInGraph = {
     extension: boolean;
     extensionType?: "@extends" | "extend";
     external: boolean;
+    authenticated: boolean;
+    policies: string[][];
+    scopes: string[][];
     keys: Key[];
     interfaces: Set<string>;
     inaccessible: boolean;
@@ -86,6 +89,9 @@ type FieldStateInGraph = {
     requires: string | null;
     provided: boolean;
     required: boolean;
+    authenticated: boolean;
+    policies: string[][];
+    scopes: string[][];
     shareable: boolean;
     usedAsKey: boolean;
     extension: boolean;

package/typings/supergraph/state.d.cts

@@ -39,6 +39,7 @@ export type SupergraphStateBuilder = ReturnType<typeof createSupergraphStateBuil
 export declare function createSupergraphStateBuilder(): {
     addSubgraph(subgraph: SubgraphState): void;
     getGraph(id: string): SubgraphState | undefined;
+    composeSupergraphState(): void;
     visitSubgraphState(subgraphState: SubgraphState): void;
     getSupergraphState(): SupergraphState;
     getSubgraphState(graphId: string): SubgraphState | undefined;

package/typings/supergraph/state.d.ts

@@ -39,6 +39,7 @@ export type SupergraphStateBuilder = ReturnType<typeof createSupergraphStateBuil
 export declare function createSupergraphStateBuilder(): {
     addSubgraph(subgraph: SubgraphState): void;
     getGraph(id: string): SubgraphState | undefined;
+    composeSupergraphState(): void;
     visitSubgraphState(subgraphState: SubgraphState): void;
     getSupergraphState(): SupergraphState;
     getSubgraphState(graphId: string): SubgraphState | undefined;

package/typings/supergraph/validation/rules/auth-on-requires-rule.d.cts

@@ -0,0 +1,5 @@
+import type { SupergraphVisitorMap } from "../../composition/visitor.cjs";
+import type { SupergraphState } from "../../state.cjs";
+import type { SupergraphValidationContext } from "../validation-context.cjs";
+export declare function AuthOnRequiresRule(context: SupergraphValidationContext, supergraph: SupergraphState): SupergraphVisitorMap;
+//# sourceMappingURL=auth-on-requires-rule.d.ts.map

package/typings/supergraph/validation/rules/auth-on-requires-rule.d.ts

@@ -0,0 +1,5 @@
+import type { SupergraphVisitorMap } from "../../composition/visitor.js";
+import type { SupergraphState } from "../../state.js";
+import type { SupergraphValidationContext } from "../validation-context.js";
+export declare function AuthOnRequiresRule(context: SupergraphValidationContext, supergraph: SupergraphState): SupergraphVisitorMap;
+//# sourceMappingURL=auth-on-requires-rule.d.ts.map

package/typings/supergraph/validation/rules/external-missing-on-base-rule.d.cts

@@ -1,4 +1,5 @@
 import { SupergraphVisitorMap } from "../../composition/visitor.cjs";
 import { SupergraphValidationContext } from "../validation-context.cjs";
-export declare function ExternalMissingOnBaseRule(context: SupergraphValidationContext): SupergraphVisitorMap;
+import { SupergraphState } from "../../state.cjs";
+export declare function ExternalMissingOnBaseRule(context: SupergraphValidationContext, supergraph: SupergraphState): SupergraphVisitorMap;
 //# sourceMappingURL=external-missing-on-base-rule.d.ts.map

package/typings/supergraph/validation/rules/external-missing-on-base-rule.d.ts

@@ -1,4 +1,5 @@
 import { SupergraphVisitorMap } from "../../composition/visitor.js";
 import { SupergraphValidationContext } from "../validation-context.js";
-export declare function ExternalMissingOnBaseRule(context: SupergraphValidationContext): SupergraphVisitorMap;
+import { SupergraphState } from "../../state.js";
+export declare function ExternalMissingOnBaseRule(context: SupergraphValidationContext, supergraph: SupergraphState): SupergraphVisitorMap;
 //# sourceMappingURL=external-missing-on-base-rule.d.ts.map

package/typings/supergraph/validation/rules/list-size-slicing-arguments-rule.d.cts

@@ -0,0 +1,5 @@
+import type { SupergraphVisitorMap } from "../../composition/visitor.cjs";
+import type { SupergraphState } from "../../state.cjs";
+import type { SupergraphValidationContext } from "../validation-context.cjs";
+export declare function ListSizeSlicingArgumentsRule(context: SupergraphValidationContext, supergraph: SupergraphState): SupergraphVisitorMap;
+//# sourceMappingURL=list-size-slicing-arguments-rule.d.ts.map

package/typings/supergraph/validation/rules/list-size-slicing-arguments-rule.d.ts

@@ -0,0 +1,5 @@
+import type { SupergraphVisitorMap } from "../../composition/visitor.js";
+import type { SupergraphState } from "../../state.js";
+import type { SupergraphValidationContext } from "../validation-context.js";
+export declare function ListSizeSlicingArgumentsRule(context: SupergraphValidationContext, supergraph: SupergraphState): SupergraphVisitorMap;
+//# sourceMappingURL=list-size-slicing-arguments-rule.d.ts.map

package/typings/utils/auth.d.cts

@@ -0,0 +1,2 @@
+export declare function mergeScopePolicies(policyA: string[][], policyB: string[][]): string[][];
+//# sourceMappingURL=auth.d.ts.map

package/typings/utils/auth.d.ts

@@ -0,0 +1,2 @@
+export declare function mergeScopePolicies(policyA: string[][], policyB: string[][]): string[][];
+//# sourceMappingURL=auth.d.ts.map