@theguild/federation-composition 0.0.0-alpha-20230916192321-bb37b43

package/esm/supergraph/validation/rules/subgraph-name-rule.js

@@ -0,0 +1,14 @@
+import { GraphQLError } from 'graphql';
+export function SubgraphNameRule(context) {
+    for (const [_, subgraph] of context.subgraphStates) {
+        const id = subgraph.graph.id;
+        if (id.startsWith('__')) {
+            context.reportError(new GraphQLError(`Name "${id}" must not begin with "__", which is reserved by GraphQL introspection.`, {
+                extensions: {
+                    code: 'INVALID_GRAPHQL',
+                },
+            }));
+        }
+    }
+    return {};
+}

package/esm/supergraph/validation/rules/types-of-the-same-kind-rule.js

@@ -0,0 +1,50 @@
+import { GraphQLError } from 'graphql';
+import { TypeKind } from '../../../subgraph/state.js';
+const mapIRKindToString = {
+    [TypeKind.OBJECT]: 'Object',
+    [TypeKind.INTERFACE]: 'Interface',
+    [TypeKind.UNION]: 'Union',
+    [TypeKind.ENUM]: 'Enum',
+    [TypeKind.INPUT_OBJECT]: 'InputObject',
+    [TypeKind.SCALAR]: 'Scalar',
+    [TypeKind.DIRECTIVE]: 'Directive',
+};
+export function TypesOfTheSameKindRule(context) {
+    const typeToKindWithGraphs = new Map();
+    const typesWithConflict = new Set();
+    for (const [graph, state] of context.subgraphStates) {
+        state.types.forEach(type => {
+            const kindToGraphs = typeToKindWithGraphs.get(type.name);
+            if (kindToGraphs) {
+                const graphs = kindToGraphs.get(type.kind);
+                if (graphs) {
+                    graphs.add(graph);
+                }
+                else {
+                    kindToGraphs.set(type.kind, new Set([graph]));
+                }
+                if (kindToGraphs.size > 1) {
+                    typesWithConflict.add(type.name);
+                }
+            }
+            else {
+                typeToKindWithGraphs.set(type.name, new Map([[type.kind, new Set([graph])]]));
+            }
+        });
+    }
+    for (const typeName of typesWithConflict) {
+        const kindToGraphs = typeToKindWithGraphs.get(typeName);
+        const groups = Array.from(kindToGraphs.entries()).map(([kind, graphs]) => {
+            const plural = graphs.size > 1 ? 's' : '';
+            return `${mapIRKindToString[kind]} Type in subgraph${plural} "${Array.from(graphs)
+                .map(context.graphIdToName)
+                .join('", "')}"`;
+        });
+        const [first, second, ...rest] = groups;
+        context.reportError(new GraphQLError(`Type "${typeName}" has mismatched kind: it is defined as ${first} but ${second}${rest.length ? ` and ${rest.join(' and ')}` : ''}`, {
+            extensions: {
+                code: 'TYPE_KIND_MISMATCH',
+            },
+        }));
+    }
+}

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

@@ -0,0 +1,73 @@
+import { visitSupergraphState } from '../composition/visitor.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';
+import { ExtensionWithBaseRule } from './rules/extension-with-base.js';
+import { ExternalArgumentMissingRule } from './rules/external-argument-missing-rule.js';
+import { ExternalMissingOnBaseRule } from './rules/external-missing-on-base-rule.js';
+import { ExternalTypeMismatchRule } from './rules/external-type-mismatch-rule.js';
+import { FieldArgumentDefaultMismatchRule } from './rules/field-argument-default-mismatch-rule.js';
+import { FieldArgumentsOfTheSameTypeRule } from './rules/field-arguments-of-the-same-type-rule.js';
+import { FieldsOfTheSameTypeRule } from './rules/fields-of-the-same-type-rule.js';
+import { InputFieldDefaultMismatchRule } from './rules/input-field-default-mismatch-rule.js';
+import { InputObjectValuesRule } from './rules/input-object-values-rule.js';
+import { InterfaceKeyMissingImplementationTypeRule } from './rules/interface-key-missing-implementation-type.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';
+import { ReferencedInaccessibleRule } from './rules/referenced-inaccessible-rule.js';
+import { RequiredArgumentMissingInSomeSubgraph } from './rules/required-argument-missing-in-some-subgraph-rule.js';
+import { RequiredInputFieldMissingInSomeSubgraphRule } from './rules/required-input-field-missing-in-some-subgraph-rule.js';
+import { RequiredQueryRule } from './rules/required-query-rule.js';
+import { SatisfiabilityRule } from './rules/satisfiablity-rule.js';
+import { SubgraphNameRule } from './rules/subgraph-name-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) {
+    const context = createSupergraphValidationContext(subgraphStates);
+    for (const subgraphState of subgraphStates.values()) {
+        state.addGraph(subgraphState.graph);
+    }
+    const preSupergraphRules = [RequiredQueryRule, TypesOfTheSameKindRule];
+    const rulesToSkip = __internal?.disableValidationRules ?? [];
+    for (const rule of preSupergraphRules) {
+        if (rulesToSkip.includes(rule.name)) {
+            continue;
+        }
+        rule(context);
+    }
+    for (const subgraphState of subgraphStates.values()) {
+        state.visitSubgraphState(subgraphState);
+    }
+    const postSupergraphRules = [
+        ExtensionWithBaseRule,
+        FieldsOfTheSameTypeRule,
+        FieldArgumentsOfTheSameTypeRule,
+        EnumValuesRule,
+        OverrideSourceHasOverrideRule,
+        ExternalMissingOnBaseRule,
+        InputObjectValuesRule,
+        RequiredArgumentMissingInSomeSubgraph,
+        RequiredInputFieldMissingInSomeSubgraphRule,
+        ExternalArgumentMissingRule,
+        InputFieldDefaultMismatchRule,
+        FieldArgumentDefaultMismatchRule,
+        DefaultValueUsesInaccessibleRule,
+        OnlyInaccessibleChildrenRule,
+        ReferencedInaccessibleRule,
+        DirectiveCompositionRule,
+        InterfaceKeyMissingImplementationTypeRule,
+        ExternalTypeMismatchRule,
+        InvalidFieldSharingRule,
+        SatisfiabilityRule,
+        SubgraphNameRule,
+    ];
+    const supergraph = state.getSupergraphState();
+    visitSupergraphState(supergraph, postSupergraphRules.map(rule => {
+        if (rulesToSkip.includes(rule.name)) {
+            return {};
+        }
+        return rule(context, supergraph);
+    }));
+    return context.collectReportedErrors();
+}

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

@@ -0,0 +1,21 @@
+export function createSupergraphValidationContext(subgraphStates) {
+    let reportedErrors = [];
+    return {
+        subgraphStates,
+        graphIdToName(id) {
+            const found = subgraphStates.get(id);
+            if (!found) {
+                throw new Error(`Could not find subgraph with id ${id}`);
+            }
+            return found.graph.name;
+        },
+        reportError(error) {
+            reportedErrors.push(error);
+        },
+        collectReportedErrors() {
+            const errors = reportedErrors;
+            reportedErrors = [];
+            return errors;
+        },
+    };
+}

package/esm/utils/dependency-graph.js

@@ -0,0 +1,222 @@
+function createDFS(edges, leavesOnly, result, circular) {
+    const visited = {};
+    return function (start) {
+        if (visited[start]) {
+            return;
+        }
+        const inCurrentPath = {};
+        const currentPath = [];
+        const todo = [];
+        todo.push({ node: start, processed: false });
+        while (todo.length > 0) {
+            const current = todo[todo.length - 1];
+            const processed = current.processed;
+            const node = current.node;
+            if (!processed) {
+                if (visited[node]) {
+                    todo.pop();
+                    continue;
+                }
+                else if (inCurrentPath[node]) {
+                    if (circular) {
+                        todo.pop();
+                        continue;
+                    }
+                    currentPath.push(node);
+                    throw new DepGraphCycleError(currentPath);
+                }
+                inCurrentPath[node] = true;
+                currentPath.push(node);
+                const nodeEdges = edges[node];
+                for (let i = nodeEdges.length - 1; i >= 0; i--) {
+                    todo.push({ node: nodeEdges[i], processed: false });
+                }
+                current.processed = true;
+            }
+            else {
+                todo.pop();
+                currentPath.pop();
+                inCurrentPath[node] = false;
+                visited[node] = true;
+                if (!leavesOnly || edges[node].length === 0) {
+                    result.push(node);
+                }
+            }
+        }
+    };
+}
+export class DepGraph {
+    nodes = {};
+    outgoingEdges = {};
+    incomingEdges = {};
+    circular;
+    constructor(opts) {
+        this.circular = opts?.circular ?? false;
+    }
+    size() {
+        return Object.keys(this.nodes).length;
+    }
+    addNode(name, data) {
+        if (!this.hasNode(name)) {
+            if (arguments.length === 2) {
+                this.nodes[name] = data;
+            }
+            else {
+                this.nodes[name] = name;
+            }
+            this.outgoingEdges[name] = [];
+            this.incomingEdges[name] = [];
+        }
+    }
+    removeNode(name) {
+        if (this.hasNode(name)) {
+            delete this.nodes[name];
+            delete this.outgoingEdges[name];
+            delete this.incomingEdges[name];
+            [this.incomingEdges, this.outgoingEdges].forEach(edgeList => {
+                Object.keys(edgeList).forEach(key => {
+                    const idx = edgeList[key].indexOf(name);
+                    if (idx >= 0) {
+                        edgeList[key].splice(idx, 1);
+                    }
+                });
+            });
+        }
+    }
+    hasNode(name) {
+        return this.nodes.hasOwnProperty(name);
+    }
+    getNodeData(name) {
+        if (this.hasNode(name)) {
+            return this.nodes[name];
+        }
+        else {
+            throw new Error('Node does not exist: ' + name);
+        }
+    }
+    setNodeData(name, data) {
+        if (this.hasNode(name)) {
+            this.nodes[name] = data;
+        }
+        else {
+            throw new Error('Node does not exist: ' + name);
+        }
+    }
+    addDependency(from, to) {
+        if (!this.hasNode(from)) {
+            throw new Error('Node does not exist: ' + from);
+        }
+        if (!this.hasNode(to)) {
+            throw new Error('Node does not exist: ' + to);
+        }
+        if (this.outgoingEdges[from].indexOf(to) === -1) {
+            this.outgoingEdges[from].push(to);
+        }
+        if (this.incomingEdges[to].indexOf(from) === -1) {
+            this.incomingEdges[to].push(from);
+        }
+        return true;
+    }
+    removeDependency(from, to) {
+        let idx;
+        if (this.hasNode(from)) {
+            idx = this.outgoingEdges[from].indexOf(to);
+            if (idx >= 0) {
+                this.outgoingEdges[from].splice(idx, 1);
+            }
+        }
+        if (this.hasNode(to)) {
+            idx = this.incomingEdges[to].indexOf(from);
+            if (idx >= 0) {
+                this.incomingEdges[to].splice(idx, 1);
+            }
+        }
+    }
+    directDependenciesOf(name) {
+        if (this.hasNode(name)) {
+            return this.outgoingEdges[name].slice(0);
+        }
+        else {
+            throw new Error('Node does not exist: ' + name);
+        }
+    }
+    directDependantsOf(name) {
+        if (this.hasNode(name)) {
+            return this.incomingEdges[name].slice(0);
+        }
+        else {
+            throw new Error('Node does not exist: ' + name);
+        }
+    }
+    dependenciesOf(name, leavesOnly) {
+        if (this.hasNode(name)) {
+            const result = [];
+            const DFS = createDFS(this.outgoingEdges, leavesOnly, result, this.circular);
+            DFS(name);
+            const idx = result.indexOf(name);
+            if (idx >= 0) {
+                result.splice(idx, 1);
+            }
+            return result;
+        }
+        else {
+            throw new Error('Node does not exist: ' + name);
+        }
+    }
+    dependantsOf(name, leavesOnly) {
+        if (this.hasNode(name)) {
+            const result = [];
+            const DFS = createDFS(this.incomingEdges, leavesOnly, result, this.circular);
+            DFS(name);
+            const idx = result.indexOf(name);
+            if (idx >= 0) {
+                result.splice(idx, 1);
+            }
+            return result;
+        }
+        else {
+            throw new Error('Node does not exist: ' + name);
+        }
+    }
+    overallOrder(leavesOnly) {
+        const result = [];
+        const keys = Object.keys(this.nodes);
+        if (keys.length === 0) {
+            return result;
+        }
+        else {
+            if (!this.circular) {
+                const CycleDFS = createDFS(this.outgoingEdges, false, [], this.circular);
+                keys.forEach(function (n) {
+                    CycleDFS(n);
+                });
+            }
+            const DFS = createDFS(this.outgoingEdges, leavesOnly, result, this.circular);
+            keys
+                .filter(node => this.incomingEdges[node].length === 0)
+                .forEach(n => {
+                DFS(n);
+            });
+            if (this.circular) {
+                keys
+                    .filter(node => result.indexOf(node) === -1)
+                    .forEach(function (n) {
+                    DFS(n);
+                });
+            }
+            return result;
+        }
+    }
+    entryNodes() {
+        return Object.keys(this.nodes).filter(node => this.incomingEdges[node].length === 0);
+    }
+    directDependentsOf = this.directDependantsOf;
+    dependentsOf = this.dependantsOf;
+}
+export class DepGraphCycleError extends Error {
+    cyclePath;
+    constructor(cyclePath) {
+        super('Dependency Cycle Found: ' + cyclePath.join(' -> '));
+        this.cyclePath = cyclePath;
+    }
+}

package/esm/utils/format.js

@@ -0,0 +1,23 @@
+export function andList(items, commaBeforeConjunction = true, wrapper) {
+    return formatList('and', items, commaBeforeConjunction, wrapper);
+}
+function formatList(conjunction, items, commaBeforeConjunction = true, wrapper) {
+    if (items.length === 0) {
+        return '';
+    }
+    switch (items.length) {
+        case 1:
+            return withWrapper(items[0], wrapper);
+        case 2:
+            return (withWrapper(items[0], wrapper) + ' ' + conjunction + ' ' + withWrapper(items[1], wrapper));
+    }
+    const allButLast = items.slice(0, -1).map(item => withWrapper(item, wrapper));
+    const lastItem = withWrapper(items.at(-1), wrapper);
+    return (allButLast.join(', ') + (commaBeforeConjunction ? ', ' : ' ') + conjunction + ' ' + lastItem);
+}
+function withWrapper(text, wrapper) {
+    if (!wrapper) {
+        return text;
+    }
+    return wrapper + text + wrapper;
+}

package/esm/utils/helpers.js

@@ -0,0 +1,3 @@
+export function isDefined(value) {
+    return value !== undefined && value !== null;
+}

package/esm/utils/state.js

@@ -0,0 +1,15 @@
+export function stripTypeModifiers(type) {
+    return type.replaceAll('!', '').replaceAll('[', '').replaceAll(']', '');
+}
+export function stripNonNull(type) {
+    return type.replace(/\!$/, '');
+}
+export function stripList(type) {
+    return type.replace(/^\[/, '').replace(/\]$/, '');
+}
+export function isNonNull(type) {
+    return type.endsWith('!');
+}
+export function isList(type) {
+    return type.endsWith(']');
+}

package/esm/validate.js

@@ -0,0 +1,113 @@
+import { constantCase } from 'constant-case';
+import { detectFederationVersion } from './specifications/federation.js';
+import { cleanSubgraphStateFromFederationSpec, cleanSubgraphStateFromLinkSpec, createSubgraphStateBuilder, } from './subgraph/state.js';
+import { validateSubgraph, validateSubgraphCore } from './subgraph/validation/validate-subgraph.js';
+import { createSupergraphStateBuilder } from './supergraph/state.js';
+import { validateSupergraph } from './supergraph/validation/validate-supergraph.js';
+const numberAtStartRegex = /^\d/;
+function startsWithNumber(value) {
+    return numberAtStartRegex.test(value);
+}
+function buildGraphList(subgraphs) {
+    const errors = [];
+    const graphs = [];
+    const names = new Set();
+    const idCounter = new Map();
+    for (const subgraph of subgraphs) {
+        const name = String(subgraph.name);
+        const nameStartsWithNumber = startsWithNumber(name);
+        if (names.has(name)) {
+            throw new Error(`A subgraph named ${name} already exists`);
+        }
+        const { url, typeDefs } = subgraph;
+        names.add(name);
+        let proposedId = constantCase(name.replace(/[^A-Z0-9]/gi, '_'), {
+            stripRegexp: /[^A-Z0-9_]+/gi,
+        });
+        if (nameStartsWithNumber) {
+            proposedId = '_' + proposedId + '_';
+        }
+        let count = idCounter.get(proposedId);
+        if (typeof count === 'number') {
+            if (count === 1) {
+                graphs.find(g => g.id === proposedId).id += '_1';
+            }
+            graphs.push({
+                name,
+                id: proposedId + '_' + (count + 1),
+                url,
+                typeDefs,
+            });
+            idCounter.set(proposedId, count + 1);
+        }
+        else {
+            idCounter.set(proposedId, 1);
+            graphs.push({
+                name,
+                id: proposedId,
+                url,
+                typeDefs,
+            });
+        }
+    }
+    if (errors.length > 0) {
+        return {
+            success: false,
+            errors,
+        };
+    }
+    graphs.sort((a, b) => a.id.localeCompare(b.id));
+    return {
+        success: true,
+        graphs,
+    };
+}
+export function validate(subgraphs, __internal) {
+    const graphList = buildGraphList(subgraphs);
+    if (!graphList.success) {
+        return {
+            success: false,
+            errors: graphList.errors,
+        };
+    }
+    const corePerSubgraph = graphList.graphs.map(subgraph => validateSubgraphCore(subgraph));
+    const coreErrors = corePerSubgraph.map(core => core.errors ?? []).flat(1);
+    if (coreErrors.length > 0) {
+        return {
+            success: false,
+            errors: coreErrors,
+        };
+    }
+    const detectedFederationSpec = new Map(graphList.graphs.map(graph => [graph.id, detectFederationVersion(graph.typeDefs)]));
+    const subgraphStateBuilders = new Map(graphList.graphs.map((graph, i) => [
+        graph.id,
+        createSubgraphStateBuilder(graph, graph.typeDefs, detectedFederationSpec.get(graph.id).version, corePerSubgraph[i].links ?? []),
+    ]));
+    const subgraphErrors = graphList.graphs
+        .map(graph => validateSubgraph(graph, subgraphStateBuilders.get(graph.id), detectedFederationSpec.get(graph.id), __internal))
+        .flat(1);
+    if (subgraphErrors.length > 0) {
+        return {
+            success: false,
+            errors: subgraphErrors,
+        };
+    }
+    const state = createSupergraphStateBuilder();
+    const supergraphErrors = validateSupergraph(new Map(Array.from(subgraphStateBuilders.entries()).map(([id, builder]) => [
+        id,
+        cleanSubgraphStateFromFederationSpec(cleanSubgraphStateFromLinkSpec(builder.state)),
+    ])), state, __internal);
+    if (supergraphErrors.length > 0) {
+        return {
+            success: false,
+            errors: supergraphErrors,
+        };
+    }
+    const nodes = state.build();
+    return {
+        success: true,
+        supergraph: nodes,
+        links: state.links(),
+        specs: state.getSupergraphState().specs,
+    };
+}

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@theguild/federation-composition",
+  "version": "0.0.0-alpha-20230916192321-bb37b43",
+  "description": "",
+  "peerDependencies": {
+    "graphql": "^16.0.0"
+  },
+  "dependencies": {
+    "constant-case": "^3.0.0",
+    "json5": "^2.2.0"
+  },
+  "keywords": [],
+  "author": {
+    "email": "contact@the-guild.dev",
+    "name": "The Guild",
+    "url": "https://the-guild.dev"
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  },
+  "main": "cjs/index.js",
+  "module": "esm/index.js",
+  "typings": "typings/index.d.ts",
+  "typescript": {
+    "definition": "typings/index.d.ts"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "require": {
+        "types": "./typings/index.d.cts",
+        "default": "./cjs/index.js"
+      },
+      "import": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      },
+      "default": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      }
+    },
+    "./package.json": "./package.json"
+  }
+}

package/typings/compose.d.cts

@@ -0,0 +1,16 @@
+import { GraphQLError } from 'graphql';
+import { ServiceDefinition } from './types.cjs';
+export declare function composeServices(services: ServiceDefinition[], __internal?: {
+    disableValidationRules?: string[];
+}): CompositionResult;
+export type CompositionResult = CompositionFailure | CompositionSuccess;
+export interface CompositionFailure {
+    errors: GraphQLError[];
+}
+export interface CompositionSuccess {
+    supergraphSdl: string;
+}
+export declare function assertCompositionSuccess(compositionResult: CompositionResult, message?: string): asserts compositionResult is CompositionSuccess;
+export declare function assertCompositionFailure(compositionResult: CompositionResult, message?: string): asserts compositionResult is CompositionFailure;
+export declare function compositionHasErrors(compositionResult: CompositionResult): compositionResult is CompositionFailure;
+//# sourceMappingURL=compose.d.ts.map

package/typings/compose.d.ts

@@ -0,0 +1,16 @@
+import { GraphQLError } from 'graphql';
+import { ServiceDefinition } from './types.js';
+export declare function composeServices(services: ServiceDefinition[], __internal?: {
+    disableValidationRules?: string[];
+}): CompositionResult;
+export type CompositionResult = CompositionFailure | CompositionSuccess;
+export interface CompositionFailure {
+    errors: GraphQLError[];
+}
+export interface CompositionSuccess {
+    supergraphSdl: string;
+}
+export declare function assertCompositionSuccess(compositionResult: CompositionResult, message?: string): asserts compositionResult is CompositionSuccess;
+export declare function assertCompositionFailure(compositionResult: CompositionResult, message?: string): asserts compositionResult is CompositionFailure;
+export declare function compositionHasErrors(compositionResult: CompositionResult): compositionResult is CompositionFailure;
+//# sourceMappingURL=compose.d.ts.map

package/typings/graphql/helpers.d.cts

@@ -0,0 +1,4 @@
+import { DefinitionNode, DirectiveDefinitionNode, DocumentNode } from 'graphql';
+export declare function isDirectiveDefinition(node: DefinitionNode): node is DirectiveDefinitionNode;
+export declare function stripFederationFromSupergraph(supergraph: DocumentNode): DocumentNode;
+//# sourceMappingURL=helpers.d.ts.map

package/typings/graphql/helpers.d.ts

@@ -0,0 +1,4 @@
+import { DefinitionNode, DirectiveDefinitionNode, DocumentNode } from 'graphql';
+export declare function isDirectiveDefinition(node: DefinitionNode): node is DirectiveDefinitionNode;
+export declare function stripFederationFromSupergraph(supergraph: DocumentNode): DocumentNode;
+//# sourceMappingURL=helpers.d.ts.map

package/typings/graphql/printer.d.cts

@@ -0,0 +1,3 @@
+import { ASTNode } from 'graphql';
+export declare function print(node?: ASTNode): string;
+//# sourceMappingURL=printer.d.ts.map

package/typings/graphql/printer.d.ts

@@ -0,0 +1,3 @@
+import { ASTNode } from 'graphql';
+export declare function print(node?: ASTNode): string;
+//# sourceMappingURL=printer.d.ts.map

package/typings/graphql/type-node-info.d.cts

@@ -0,0 +1,19 @@
+import { ASTNode, ASTVisitor, DirectiveDefinitionNode, EnumValueDefinitionNode, FieldDefinitionNode, InputValueDefinitionNode, TypeDefinitionNode, TypeExtensionNode } from 'graphql';
+type Maybe<T> = T | null | undefined;
+export declare class TypeNodeInfo {
+    private _type;
+    private _field;
+    private _arg;
+    private _value;
+    constructor();
+    get [Symbol.toStringTag](): string;
+    getTypeDef(): Maybe<DirectiveDefinitionNode | TypeDefinitionNode | TypeExtensionNode>;
+    getFieldDef(): Maybe<FieldDefinitionNode | InputValueDefinitionNode>;
+    getArgumentDef(): Maybe<InputValueDefinitionNode>;
+    getValueDef(): Maybe<EnumValueDefinitionNode>;
+    enter(node: ASTNode): void;
+    leave(node: ASTNode): void;
+}
+export declare function visitWithTypeNodeInfo(typeInfo: TypeNodeInfo, visitor: ASTVisitor): ASTVisitor;
+export {};
+//# sourceMappingURL=type-node-info.d.ts.map