@makerx/graphql-core 3.2.0 → 3.3.0

package/README.md

@@ -281,6 +281,38 @@ Refer to the `GraphQLLogOperationInfo` type for the definition of input.
 
 This function can be used across implementations, e.g. in a [GraphQL Envelop plugin](https://www.envelop.dev/docs/plugins) or [ApolloServer plugin](https://github.com/MakerXStudio/graphql-apollo-server/blob/main/src/plugins/graphql-operation-logging-plugin.ts).
 
+## Deprecation usage
+
+### collectDeprecatedElementUsage
+
+Reports every `@deprecated` schema element an operation uses, so you can tell whether a deprecated element is safe to remove.
+
+```ts
+const { elements, truncated } = collectDeprecatedElementUsage({ schema, document, operation, operationName, variables })
+// elements:  [{ kind: 'input-field', name: 'WidgetFilterInput.legacyId', path: '$input.legacyId' }]
+// truncated: false
+```
+
+Five kinds are detected: `output-field`, `argument`, `directive-argument`, `input-field` and `enum-value`.
+
+Output fields and arguments are named in the operation document, so an AST walk finds them. Input fields and enum values are data the caller _supplies_ rather than selects, and can arrive either as a document literal or inside a variable — where the name appears nowhere in the AST — so the supplied variable values are walked too, against their declared input types.
+
+Consumers generally don't call this directly. It is wired into `useSubscriptionsServer` via `includeDeprecatedElements` (below), and into Apollo Server by the `includeDeprecatedElements` option of [`graphqlOperationLoggingPlugin`](https://github.com/MakerXStudio/graphql-apollo-server), which adds the result to the operation log entry as `deprecatedElements`.
+
+Behaviour worth knowing:
+
+- **Results are deduplicated** on kind and name, and sorted. One request produces at most one entry per distinct element, so a 40-element list carrying the same deprecated field yields one record, not 40.
+- **Only the executed operation counts.** A document may hold several operations but only one runs, so the others — and any fragments only they reach — are excluded.
+- **Presence is the signal, explicit `null` included.** A client still sending a field would break if it were removed.
+- **It never throws on malformed variables.** The walk runs before graphql-js coerces variables, so a payload whose shape contradicts its declared type reaches it; such values yield no records rather than an error.
+- **Work is bounded** by `maxVariableDepth` (default 25), `maxVariableNodes` (default 10,000) and `maxElements` (default 50). Whenever any of them stops collection early, `truncated` is `true`.
+- **`truncated` guards against a false negative.** Absence from `elements` only means an element went unused when `truncated` is `false`; on a truncated result the walk stopped before it finished. This matters because reading "nothing uses this" off an incomplete result is exactly how a still-used element gets deleted. Deduplication and null values do not set it — nothing is lost in either case.
+
+Two limitations to design around:
+
+- **This is request-side telemetry.** It observes values a caller _sends_, never values the server returns. A deprecated enum value that only ever appears in responses reads as unused however often the server returns it.
+- **`path` is a best-effort debugging aid, not an aggregation key.** Aggregate on `name`. A field selected inside a fragment definition has no enclosing field in its ancestry, so its path is relative to the fragment rather than the operation — which is the common case for clients that use generated fragments.
+
 ## GraphQL subscriptions
 
 This library includes a `subscriptions` module to provide simple setup using the [GraphQL WS](https://the-guild.dev/graphql/ws) package.
@@ -335,6 +367,8 @@ This library includes a `subscriptions` module to provide simple setup using the
    - GraphQL context creation
    - Logging from the server `onConnect`, `onDisconnect`, `onOperation`, `onNext` and `onError` callbacks
 
+   Pass `includeDeprecatedElements: true` to add [deprecation usage](#collectdeprecatedelementusage) to the operation log entry as `deprecatedElements`. It is collected once, when the subscription is established, rather than per emitted payload — the usage is a property of the operation, not of each event.
+
    Example for Apollo Server (`wsServerCleanup` called in the `drainServer` plugin callback):
 
    ```ts

package/deprecation.d.cts

@@ -0,0 +1,81 @@
+import type { DocumentNode, GraphQLSchema, OperationDefinitionNode } from 'graphql';
+/**
+ * Safety valve for the variable walk. Recursion follows the schema's input types, which may be
+ * mutually recursive, and variables are walked before graphql-js coerces them — so nothing else
+ * bounds how deep a hand-crafted payload can go. Far above any real operation's nesting.
+ */
+export declare const DEFAULT_DEPRECATION_MAX_VARIABLE_DEPTH = 25;
+/**
+ * Bounds the *breadth* of the variable walk, which the depth cap does not: a single large array of
+ * small input objects is shallow but arbitrarily wide.
+ */
+export declare const DEFAULT_DEPRECATION_MAX_VARIABLE_NODES = 10000;
+/**
+ * Caps the collected result so one hostile document cannot blow up a log entry.
+ */
+export declare const DEFAULT_DEPRECATION_MAX_ELEMENTS = 50;
+export type DeprecatedElementKind = 'output-field' | 'argument' | 'directive-argument' | 'input-field' | 'enum-value';
+export interface DeprecatedElementUsage {
+    kind: DeprecatedElementKind;
+    /**
+     * Stable key for aggregating usage, formatted per kind:
+     * `Type.field`, `Type.field(arg)`, `@directive(arg)`, `InputType.field`, `EnumType.VALUE`.
+     */
+    name: string;
+    /**
+     * Best-effort location, for debugging a single record — not an aggregation key. A field selected
+     * inside a fragment definition has no enclosing field in its ancestry, so its path is relative to
+     * the fragment rather than the operation.
+     */
+    path?: string;
+}
+export interface CollectDeprecatedElementUsageOptions {
+    schema: GraphQLSchema;
+    document: DocumentNode;
+    /**
+     * The executed operation. Resolved from `document` and `operationName` when omitted.
+     */
+    operation?: OperationDefinitionNode | null;
+    operationName?: string | null;
+    /**
+     * Raw request variables, as supplied by the client and before graphql-js coerces them.
+     */
+    variables?: Record<string, unknown> | null;
+    maxVariableDepth?: number;
+    maxVariableNodes?: number;
+    maxElements?: number;
+}
+export interface CollectDeprecatedElementUsageResult {
+    elements: DeprecatedElementUsage[];
+    /**
+     * True when a limit — `maxElements`, `maxVariableDepth` or `maxVariableNodes` — stopped
+     * collection before it finished, so `elements` may be missing elements the operation really used.
+     * Absence from a truncated result is not evidence that an element is unused.
+     */
+    truncated: boolean;
+}
+/**
+ * Reports every `@deprecated` schema element an operation uses, across both the document and the
+ * supplied variables.
+ *
+ * Output fields and arguments are named in the document, so an AST walk finds them. Input fields
+ * and enum values are data the caller *supplies* rather than selects: they can arrive as a document
+ * literal, or inside a variable where the name appears nowhere in the AST, so both routes are
+ * walked and the results deduplicated.
+ *
+ * Results are deduplicated on kind and name — at most one entry per distinct element per request,
+ * bounded by the size of the schema rather than the size of the request — and sorted, so records
+ * are stable across requests.
+ *
+ * Returns `truncated` when any limit stopped collection. Absence from `elements` is only evidence
+ * that an element went unused when `truncated` is false — which matters, because concluding
+ * "nothing uses this" from a truncated result is how a still-used element gets deleted.
+ *
+ * The variable walk reads untrusted input before coercion, so a payload whose shape contradicts its
+ * declared type reaches it. Every shape it depends on is guarded: malformed variables yield no
+ * records rather than an error.
+ *
+ * This is request-side telemetry — it observes values a caller *sends*, never values the server
+ * returns. A deprecated element that only ever appears in responses reads as unused.
+ */
+export declare function collectDeprecatedElementUsage({ schema, document, operation, operationName, variables, maxVariableDepth, maxVariableNodes, maxElements, }: CollectDeprecatedElementUsageOptions): CollectDeprecatedElementUsageResult;

package/deprecation.d.mts

@@ -0,0 +1,81 @@
+import type { DocumentNode, GraphQLSchema, OperationDefinitionNode } from 'graphql';
+/**
+ * Safety valve for the variable walk. Recursion follows the schema's input types, which may be
+ * mutually recursive, and variables are walked before graphql-js coerces them — so nothing else
+ * bounds how deep a hand-crafted payload can go. Far above any real operation's nesting.
+ */
+export declare const DEFAULT_DEPRECATION_MAX_VARIABLE_DEPTH = 25;
+/**
+ * Bounds the *breadth* of the variable walk, which the depth cap does not: a single large array of
+ * small input objects is shallow but arbitrarily wide.
+ */
+export declare const DEFAULT_DEPRECATION_MAX_VARIABLE_NODES = 10000;
+/**
+ * Caps the collected result so one hostile document cannot blow up a log entry.
+ */
+export declare const DEFAULT_DEPRECATION_MAX_ELEMENTS = 50;
+export type DeprecatedElementKind = 'output-field' | 'argument' | 'directive-argument' | 'input-field' | 'enum-value';
+export interface DeprecatedElementUsage {
+    kind: DeprecatedElementKind;
+    /**
+     * Stable key for aggregating usage, formatted per kind:
+     * `Type.field`, `Type.field(arg)`, `@directive(arg)`, `InputType.field`, `EnumType.VALUE`.
+     */
+    name: string;
+    /**
+     * Best-effort location, for debugging a single record — not an aggregation key. A field selected
+     * inside a fragment definition has no enclosing field in its ancestry, so its path is relative to
+     * the fragment rather than the operation.
+     */
+    path?: string;
+}
+export interface CollectDeprecatedElementUsageOptions {
+    schema: GraphQLSchema;
+    document: DocumentNode;
+    /**
+     * The executed operation. Resolved from `document` and `operationName` when omitted.
+     */
+    operation?: OperationDefinitionNode | null;
+    operationName?: string | null;
+    /**
+     * Raw request variables, as supplied by the client and before graphql-js coerces them.
+     */
+    variables?: Record<string, unknown> | null;
+    maxVariableDepth?: number;
+    maxVariableNodes?: number;
+    maxElements?: number;
+}
+export interface CollectDeprecatedElementUsageResult {
+    elements: DeprecatedElementUsage[];
+    /**
+     * True when a limit — `maxElements`, `maxVariableDepth` or `maxVariableNodes` — stopped
+     * collection before it finished, so `elements` may be missing elements the operation really used.
+     * Absence from a truncated result is not evidence that an element is unused.
+     */
+    truncated: boolean;
+}
+/**
+ * Reports every `@deprecated` schema element an operation uses, across both the document and the
+ * supplied variables.
+ *
+ * Output fields and arguments are named in the document, so an AST walk finds them. Input fields
+ * and enum values are data the caller *supplies* rather than selects: they can arrive as a document
+ * literal, or inside a variable where the name appears nowhere in the AST, so both routes are
+ * walked and the results deduplicated.
+ *
+ * Results are deduplicated on kind and name — at most one entry per distinct element per request,
+ * bounded by the size of the schema rather than the size of the request — and sorted, so records
+ * are stable across requests.
+ *
+ * Returns `truncated` when any limit stopped collection. Absence from `elements` is only evidence
+ * that an element went unused when `truncated` is false — which matters, because concluding
+ * "nothing uses this" from a truncated result is how a still-used element gets deleted.
+ *
+ * The variable walk reads untrusted input before coercion, so a payload whose shape contradicts its
+ * declared type reaches it. Every shape it depends on is guarded: malformed variables yield no
+ * records rather than an error.
+ *
+ * This is request-side telemetry — it observes values a caller *sends*, never values the server
+ * returns. A deprecated element that only ever appears in responses reads as unused.
+ */
+export declare function collectDeprecatedElementUsage({ schema, document, operation, operationName, variables, maxVariableDepth, maxVariableNodes, maxElements, }: CollectDeprecatedElementUsageOptions): CollectDeprecatedElementUsageResult;

package/deprecation.d.ts

@@ -0,0 +1,81 @@
+import type { DocumentNode, GraphQLSchema, OperationDefinitionNode } from 'graphql';
+/**
+ * Safety valve for the variable walk. Recursion follows the schema's input types, which may be
+ * mutually recursive, and variables are walked before graphql-js coerces them — so nothing else
+ * bounds how deep a hand-crafted payload can go. Far above any real operation's nesting.
+ */
+export declare const DEFAULT_DEPRECATION_MAX_VARIABLE_DEPTH = 25;
+/**
+ * Bounds the *breadth* of the variable walk, which the depth cap does not: a single large array of
+ * small input objects is shallow but arbitrarily wide.
+ */
+export declare const DEFAULT_DEPRECATION_MAX_VARIABLE_NODES = 10000;
+/**
+ * Caps the collected result so one hostile document cannot blow up a log entry.
+ */
+export declare const DEFAULT_DEPRECATION_MAX_ELEMENTS = 50;
+export type DeprecatedElementKind = 'output-field' | 'argument' | 'directive-argument' | 'input-field' | 'enum-value';
+export interface DeprecatedElementUsage {
+    kind: DeprecatedElementKind;
+    /**
+     * Stable key for aggregating usage, formatted per kind:
+     * `Type.field`, `Type.field(arg)`, `@directive(arg)`, `InputType.field`, `EnumType.VALUE`.
+     */
+    name: string;
+    /**
+     * Best-effort location, for debugging a single record — not an aggregation key. A field selected
+     * inside a fragment definition has no enclosing field in its ancestry, so its path is relative to
+     * the fragment rather than the operation.
+     */
+    path?: string;
+}
+export interface CollectDeprecatedElementUsageOptions {
+    schema: GraphQLSchema;
+    document: DocumentNode;
+    /**
+     * The executed operation. Resolved from `document` and `operationName` when omitted.
+     */
+    operation?: OperationDefinitionNode | null;
+    operationName?: string | null;
+    /**
+     * Raw request variables, as supplied by the client and before graphql-js coerces them.
+     */
+    variables?: Record<string, unknown> | null;
+    maxVariableDepth?: number;
+    maxVariableNodes?: number;
+    maxElements?: number;
+}
+export interface CollectDeprecatedElementUsageResult {
+    elements: DeprecatedElementUsage[];
+    /**
+     * True when a limit — `maxElements`, `maxVariableDepth` or `maxVariableNodes` — stopped
+     * collection before it finished, so `elements` may be missing elements the operation really used.
+     * Absence from a truncated result is not evidence that an element is unused.
+     */
+    truncated: boolean;
+}
+/**
+ * Reports every `@deprecated` schema element an operation uses, across both the document and the
+ * supplied variables.
+ *
+ * Output fields and arguments are named in the document, so an AST walk finds them. Input fields
+ * and enum values are data the caller *supplies* rather than selects: they can arrive as a document
+ * literal, or inside a variable where the name appears nowhere in the AST, so both routes are
+ * walked and the results deduplicated.
+ *
+ * Results are deduplicated on kind and name — at most one entry per distinct element per request,
+ * bounded by the size of the schema rather than the size of the request — and sorted, so records
+ * are stable across requests.
+ *
+ * Returns `truncated` when any limit stopped collection. Absence from `elements` is only evidence
+ * that an element went unused when `truncated` is false — which matters, because concluding
+ * "nothing uses this" from a truncated result is how a still-used element gets deleted.
+ *
+ * The variable walk reads untrusted input before coercion, so a payload whose shape contradicts its
+ * declared type reaches it. Every shape it depends on is guarded: malformed variables yield no
+ * records rather than an error.
+ *
+ * This is request-side telemetry — it observes values a caller *sends*, never values the server
+ * returns. A deprecated element that only ever appears in responses reads as unused.
+ */
+export declare function collectDeprecatedElementUsage({ schema, document, operation, operationName, variables, maxVariableDepth, maxVariableNodes, maxElements, }: CollectDeprecatedElementUsageOptions): CollectDeprecatedElementUsageResult;

package/deprecation.js

@@ -0,0 +1,240 @@
+'use strict';
+
+var graphql = require('graphql');
+
+/**
+ * Safety valve for the variable walk. Recursion follows the schema's input types, which may be
+ * mutually recursive, and variables are walked before graphql-js coerces them — so nothing else
+ * bounds how deep a hand-crafted payload can go. Far above any real operation's nesting.
+ */
+const DEFAULT_DEPRECATION_MAX_VARIABLE_DEPTH = 25;
+/**
+ * Bounds the *breadth* of the variable walk, which the depth cap does not: a single large array of
+ * small input objects is shallow but arbitrarily wide.
+ */
+const DEFAULT_DEPRECATION_MAX_VARIABLE_NODES = 10000;
+/**
+ * Caps the collected result so one hostile document cannot blow up a log entry.
+ */
+const DEFAULT_DEPRECATION_MAX_ELEMENTS = 50;
+const UNKNOWN = '<unknown>';
+/**
+ * Reports every `@deprecated` schema element an operation uses, across both the document and the
+ * supplied variables.
+ *
+ * Output fields and arguments are named in the document, so an AST walk finds them. Input fields
+ * and enum values are data the caller *supplies* rather than selects: they can arrive as a document
+ * literal, or inside a variable where the name appears nowhere in the AST, so both routes are
+ * walked and the results deduplicated.
+ *
+ * Results are deduplicated on kind and name — at most one entry per distinct element per request,
+ * bounded by the size of the schema rather than the size of the request — and sorted, so records
+ * are stable across requests.
+ *
+ * Returns `truncated` when any limit stopped collection. Absence from `elements` is only evidence
+ * that an element went unused when `truncated` is false — which matters, because concluding
+ * "nothing uses this" from a truncated result is how a still-used element gets deleted.
+ *
+ * The variable walk reads untrusted input before coercion, so a payload whose shape contradicts its
+ * declared type reaches it. Every shape it depends on is guarded: malformed variables yield no
+ * records rather than an error.
+ *
+ * This is request-side telemetry — it observes values a caller *sends*, never values the server
+ * returns. A deprecated element that only ever appears in responses reads as unused.
+ */
+function collectDeprecatedElementUsage({ schema, document, operation, operationName, variables, maxVariableDepth = DEFAULT_DEPRECATION_MAX_VARIABLE_DEPTH, maxVariableNodes = DEFAULT_DEPRECATION_MAX_VARIABLE_NODES, maxElements = DEFAULT_DEPRECATION_MAX_ELEMENTS, }) {
+    const collected = new Map();
+    const walk = { maxVariableDepth, remaining: maxVariableNodes, truncated: false };
+    const collect = (usage) => {
+        const key = `${usage.kind}:${usage.name}`;
+        // Already recorded is deduplication, not truncation — only a rejected *new* element is a loss.
+        if (collected.has(key))
+            return;
+        if (collected.size >= maxElements) {
+            walk.truncated = true;
+            return;
+        }
+        collected.set(key, usage);
+    };
+    const resolvedOperation = operation ?? graphql.getOperationAST(document, operationName ?? undefined);
+    collectFromDocument(schema, scopeToOperation(document, resolvedOperation), collect);
+    collectFromVariables(schema, resolvedOperation?.variableDefinitions, variables, walk, collect);
+    return {
+        elements: [...collected.values()].sort((a, b) => a.kind.localeCompare(b.kind) || a.name.localeCompare(b.name)),
+        truncated: walk.truncated,
+    };
+}
+/**
+ * A document may carry several operations but only one runs, so anything the others select would be
+ * reported as usage that never happened. `separateOperations` keeps each operation with only the
+ * fragments it can reach, which is exactly the scope wanted here.
+ */
+function scopeToOperation(document, operation) {
+    if (!operation)
+        return document;
+    let operationCount = 0;
+    for (const definition of document.definitions) {
+        if (definition.kind === graphql.Kind.OPERATION_DEFINITION)
+            operationCount++;
+        if (operationCount > 1)
+            return graphql.separateOperations(document)[operation.name?.value ?? ''] ?? document;
+    }
+    return document;
+}
+function collectFromDocument(schema, document, collect) {
+    const typeInfo = new graphql.TypeInfo(schema);
+    graphql.visit(document, graphql.visitWithTypeInfo(typeInfo, {
+        Field(_node, _key, _parent, _path, ancestors) {
+            const field = typeInfo.getFieldDef();
+            if (field?.deprecationReason == null)
+                return;
+            collect({
+                kind: 'output-field',
+                name: `${typeInfo.getParentType()?.name ?? UNKNOWN}.${field.name}`,
+                path: getPath(ancestors, field.name),
+            });
+        },
+        Argument(_node, _key, _parent, _path, ancestors) {
+            const argument = typeInfo.getArgument();
+            if (argument?.deprecationReason == null)
+                return;
+            // TypeInfo resolves an argument against the enclosing directive when there is one, so
+            // without this branch a directive's argument is reported as an argument of the field the
+            // directive is attached to — a field argument that does not exist.
+            const directive = typeInfo.getDirective();
+            collect({
+                kind: directive ? 'directive-argument' : 'argument',
+                name: directive
+                    ? `@${directive.name}(${argument.name})`
+                    : `${typeInfo.getParentType()?.name ?? UNKNOWN}.${typeInfo.getFieldDef()?.name ?? UNKNOWN}(${argument.name})`,
+                path: getPath(ancestors),
+            });
+        },
+        // Input-object fields written as literals in the document, including variable definition
+        // default values, which TypeInfo also tracks as input positions.
+        ObjectField(node, _key, _parent, _path, ancestors) {
+            const parentType = graphql.getNamedType(typeInfo.getParentInputType());
+            if (!graphql.isInputObjectType(parentType))
+                return;
+            const inputField = parentType.getFields()[node.name.value];
+            if (inputField?.deprecationReason == null)
+                return;
+            collect({
+                kind: 'input-field',
+                name: `${parentType.name}.${inputField.name}`,
+                path: getPath(ancestors, inputField.name),
+            });
+        },
+        EnumValue(node, _key, _parent, _path, ancestors) {
+            const enumType = graphql.getNamedType(typeInfo.getInputType());
+            if (!graphql.isEnumType(enumType))
+                return;
+            const enumValue = enumType.getValue(node.value);
+            if (enumValue?.deprecationReason == null)
+                return;
+            collect({
+                kind: 'enum-value',
+                name: `${enumType.name}.${enumValue.name}`,
+                path: getPath(ancestors),
+            });
+        },
+    }));
+}
+function isPathNode(node) {
+    return node.kind === graphql.Kind.FIELD || node.kind === graphql.Kind.OBJECT_FIELD;
+}
+function getPath(ancestors, leaf) {
+    const segments = ancestors
+        .filter((x) => !Array.isArray(x))
+        .filter(isPathNode)
+        .map((x) => x.name.value);
+    if (leaf)
+        segments.push(leaf);
+    return segments.join('.');
+}
+/**
+ * Walks each supplied variable value against its declared type, reporting every deprecated input
+ * field and enum value the client actually sent.
+ *
+ * Takes the definitions of the *resolved* operation rather than scanning the whole document: the
+ * same variable name may be declared with a different type in each operation, so only the executed
+ * one's declarations describe the supplied values.
+ */
+function collectFromVariables(schema, variableDefinitions, variables, state, collect) {
+    if (variables == null)
+        return;
+    for (const variableDefinition of variableDefinitions ?? []) {
+        const variableName = variableDefinition.variable.name.value;
+        if (!Object.hasOwn(variables, variableName))
+            continue;
+        const type = graphql.typeFromAST(schema, variableDefinition.type);
+        if (!graphql.isInputType(type))
+            continue;
+        walkInputValue(type, variables[variableName], `$${variableName}`, 0, state, collect);
+    }
+}
+function walkInputValue(type, value, path, depth, state, collect) {
+    // A limit stopping the descent is a loss of telemetry, so it is recorded; a null value is simply
+    // nothing to walk, and must not be reported as one.
+    if (depth > state.maxVariableDepth || state.remaining <= 0) {
+        state.truncated = true;
+        return;
+    }
+    if (value == null)
+        return;
+    state.remaining--;
+    // Unwrapped inline rather than by recursing, so a nullability wrapper doesn't spend a node from
+    // the budget for a value that has not been descended into yet.
+    const unwrapped = graphql.isNonNullType(type) ? type.ofType : type;
+    if (graphql.isListType(unwrapped)) {
+        // GraphQL accepts a bare value in a list position, so handle both shapes.
+        const items = Array.isArray(value) ? value : [value];
+        for (const [index, item] of items.entries()) {
+            // Checked here rather than relying on the recursive call returning early: the loop itself is
+            // the unbounded part, since list length comes from the payload and each step builds a path.
+            if (state.remaining <= 0) {
+                state.truncated = true;
+                return;
+            }
+            walkInputValue(unwrapped.ofType, item, Array.isArray(value) ? `${path}.${index}` : path, depth + 1, state, collect);
+        }
+        return;
+    }
+    if (graphql.isEnumType(unwrapped)) {
+        // An unknown name is a coercion error graphql-js raises moments later; nothing to record here.
+        if (typeof value !== 'string')
+            return;
+        const enumValue = unwrapped.getValue(value);
+        if (enumValue?.deprecationReason != null) {
+            collect({ kind: 'enum-value', name: `${unwrapped.name}.${enumValue.name}`, path });
+        }
+        return;
+    }
+    // Scalars have no members that could carry a deprecation.
+    if (!graphql.isInputObjectType(unwrapped) || !isRecord(value))
+        return;
+    for (const field of Object.values(unwrapped.getFields())) {
+        if (state.remaining <= 0) {
+            state.truncated = true;
+            return;
+        }
+        if (!Object.hasOwn(value, field.name))
+            continue;
+        const fieldPath = `${path}.${field.name}`;
+        // Presence is the signal, explicit `null` included: a client still sending the field would
+        // break if it were removed from the schema.
+        if (field.deprecationReason != null) {
+            collect({ kind: 'input-field', name: `${unwrapped.name}.${field.name}`, path: fieldPath });
+        }
+        walkInputValue(field.type, value[field.name], fieldPath, depth + 1, state, collect);
+    }
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+exports.DEFAULT_DEPRECATION_MAX_ELEMENTS = DEFAULT_DEPRECATION_MAX_ELEMENTS;
+exports.DEFAULT_DEPRECATION_MAX_VARIABLE_DEPTH = DEFAULT_DEPRECATION_MAX_VARIABLE_DEPTH;
+exports.DEFAULT_DEPRECATION_MAX_VARIABLE_NODES = DEFAULT_DEPRECATION_MAX_VARIABLE_NODES;
+exports.collectDeprecatedElementUsage = collectDeprecatedElementUsage;
+//# sourceMappingURL=deprecation.js.map

package/deprecation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"deprecation.js","sources":["../src/deprecation.ts"],"sourcesContent":["import type {\n  ASTNode,\n  DocumentNode,\n  FieldNode,\n  GraphQLInputType,\n  GraphQLSchema,\n  ObjectFieldNode,\n  OperationDefinitionNode,\n  VariableDefinitionNode,\n} from 'graphql'\nimport {\n  getNamedType,\n  getOperationAST,\n  isEnumType,\n  isInputObjectType,\n  isInputType,\n  isListType,\n  isNonNullType,\n  Kind,\n  separateOperations,\n  typeFromAST,\n  TypeInfo,\n  visit,\n  visitWithTypeInfo,\n} from 'graphql'\n\n/**\n * Safety valve for the variable walk. Recursion follows the schema's input types, which may be\n * mutually recursive, and variables are walked before graphql-js coerces them — so nothing else\n * bounds how deep a hand-crafted payload can go. Far above any real operation's nesting.\n */\nexport const DEFAULT_DEPRECATION_MAX_VARIABLE_DEPTH = 25\n\n/**\n * Bounds the *breadth* of the variable walk, which the depth cap does not: a single large array of\n * small input objects is shallow but arbitrarily wide.\n */\nexport const DEFAULT_DEPRECATION_MAX_VARIABLE_NODES = 10_000\n\n/**\n * Caps the collected result so one hostile document cannot blow up a log entry.\n */\nexport const DEFAULT_DEPRECATION_MAX_ELEMENTS = 50\n\nconst UNKNOWN = '<unknown>'\n\nexport type DeprecatedElementKind = 'output-field' | 'argument' | 'directive-argument' | 'input-field' | 'enum-value'\n\nexport interface DeprecatedElementUsage {\n  kind: DeprecatedElementKind\n  /**\n   * Stable key for aggregating usage, formatted per kind:\n   * `Type.field`, `Type.field(arg)`, `@directive(arg)`, `InputType.field`, `EnumType.VALUE`.\n   */\n  name: string\n  /**\n   * Best-effort location, for debugging a single record — not an aggregation key. A field selected\n   * inside a fragment definition has no enclosing field in its ancestry, so its path is relative to\n   * the fragment rather than the operation.\n   */\n  path?: string\n}\n\nexport interface CollectDeprecatedElementUsageOptions {\n  schema: GraphQLSchema\n  document: DocumentNode\n  /**\n   * The executed operation. Resolved from `document` and `operationName` when omitted.\n   */\n  operation?: OperationDefinitionNode | null\n  operationName?: string | null\n  /**\n   * Raw request variables, as supplied by the client and before graphql-js coerces them.\n   */\n  variables?: Record<string, unknown> | null\n  maxVariableDepth?: number\n  maxVariableNodes?: number\n  maxElements?: number\n}\n\nexport interface CollectDeprecatedElementUsageResult {\n  elements: DeprecatedElementUsage[]\n  /**\n   * True when a limit — `maxElements`, `maxVariableDepth` or `maxVariableNodes` — stopped\n   * collection before it finished, so `elements` may be missing elements the operation really used.\n   * Absence from a truncated result is not evidence that an element is unused.\n   */\n  truncated: boolean\n}\n\n/**\n * Reports every `@deprecated` schema element an operation uses, across both the document and the\n * supplied variables.\n *\n * Output fields and arguments are named in the document, so an AST walk finds them. Input fields\n * and enum values are data the caller *supplies* rather than selects: they can arrive as a document\n * literal, or inside a variable where the name appears nowhere in the AST, so both routes are\n * walked and the results deduplicated.\n *\n * Results are deduplicated on kind and name — at most one entry per distinct element per request,\n * bounded by the size of the schema rather than the size of the request — and sorted, so records\n * are stable across requests.\n *\n * Returns `truncated` when any limit stopped collection. Absence from `elements` is only evidence\n * that an element went unused when `truncated` is false — which matters, because concluding\n * \"nothing uses this\" from a truncated result is how a still-used element gets deleted.\n *\n * The variable walk reads untrusted input before coercion, so a payload whose shape contradicts its\n * declared type reaches it. Every shape it depends on is guarded: malformed variables yield no\n * records rather than an error.\n *\n * This is request-side telemetry — it observes values a caller *sends*, never values the server\n * returns. A deprecated element that only ever appears in responses reads as unused.\n */\nexport function collectDeprecatedElementUsage({\n  schema,\n  document,\n  operation,\n  operationName,\n  variables,\n  maxVariableDepth = DEFAULT_DEPRECATION_MAX_VARIABLE_DEPTH,\n  maxVariableNodes = DEFAULT_DEPRECATION_MAX_VARIABLE_NODES,\n  maxElements = DEFAULT_DEPRECATION_MAX_ELEMENTS,\n}: CollectDeprecatedElementUsageOptions): CollectDeprecatedElementUsageResult {\n  const collected = new Map<string, DeprecatedElementUsage>()\n  const walk: WalkState = { maxVariableDepth, remaining: maxVariableNodes, truncated: false }\n\n  const collect = (usage: DeprecatedElementUsage): void => {\n    const key = `${usage.kind}:${usage.name}`\n    // Already recorded is deduplication, not truncation — only a rejected *new* element is a loss.\n    if (collected.has(key)) return\n    if (collected.size >= maxElements) {\n      walk.truncated = true\n      return\n    }\n    collected.set(key, usage)\n  }\n\n  const resolvedOperation = operation ?? getOperationAST(document, operationName ?? undefined)\n\n  collectFromDocument(schema, scopeToOperation(document, resolvedOperation), collect)\n  collectFromVariables(schema, resolvedOperation?.variableDefinitions, variables, walk, collect)\n\n  return {\n    elements: [...collected.values()].sort((a, b) => a.kind.localeCompare(b.kind) || a.name.localeCompare(b.name)),\n    truncated: walk.truncated,\n  }\n}\n\ntype Collect = (usage: DeprecatedElementUsage) => void\n\n/**\n * A document may carry several operations but only one runs, so anything the others select would be\n * reported as usage that never happened. `separateOperations` keeps each operation with only the\n * fragments it can reach, which is exactly the scope wanted here.\n */\nfunction scopeToOperation(document: DocumentNode, operation: OperationDefinitionNode | null | undefined): DocumentNode {\n  if (!operation) return document\n\n  let operationCount = 0\n  for (const definition of document.definitions) {\n    if (definition.kind === Kind.OPERATION_DEFINITION) operationCount++\n    if (operationCount > 1) return separateOperations(document)[operation.name?.value ?? ''] ?? document\n  }\n  return document\n}\n\nfunction collectFromDocument(schema: GraphQLSchema, document: DocumentNode, collect: Collect): void {\n  const typeInfo = new TypeInfo(schema)\n\n  visit(\n    document,\n    visitWithTypeInfo(typeInfo, {\n      Field(_node, _key, _parent, _path, ancestors) {\n        const field = typeInfo.getFieldDef()\n        if (field?.deprecationReason == null) return\n        collect({\n          kind: 'output-field',\n          name: `${typeInfo.getParentType()?.name ?? UNKNOWN}.${field.name}`,\n          path: getPath(ancestors, field.name),\n        })\n      },\n      Argument(_node, _key, _parent, _path, ancestors) {\n        const argument = typeInfo.getArgument()\n        if (argument?.deprecationReason == null) return\n        // TypeInfo resolves an argument against the enclosing directive when there is one, so\n        // without this branch a directive's argument is reported as an argument of the field the\n        // directive is attached to — a field argument that does not exist.\n        const directive = typeInfo.getDirective()\n        collect({\n          kind: directive ? 'directive-argument' : 'argument',\n          name: directive\n            ? `@${directive.name}(${argument.name})`\n            : `${typeInfo.getParentType()?.name ?? UNKNOWN}.${typeInfo.getFieldDef()?.name ?? UNKNOWN}(${argument.name})`,\n          path: getPath(ancestors),\n        })\n      },\n      // Input-object fields written as literals in the document, including variable definition\n      // default values, which TypeInfo also tracks as input positions.\n      ObjectField(node, _key, _parent, _path, ancestors) {\n        const parentType = getNamedType(typeInfo.getParentInputType())\n        if (!isInputObjectType(parentType)) return\n        const inputField = parentType.getFields()[node.name.value]\n        if (inputField?.deprecationReason == null) return\n        collect({\n          kind: 'input-field',\n          name: `${parentType.name}.${inputField.name}`,\n          path: getPath(ancestors, inputField.name),\n        })\n      },\n      EnumValue(node, _key, _parent, _path, ancestors) {\n        const enumType = getNamedType(typeInfo.getInputType())\n        if (!isEnumType(enumType)) return\n        const enumValue = enumType.getValue(node.value)\n        if (enumValue?.deprecationReason == null) return\n        collect({\n          kind: 'enum-value',\n          name: `${enumType.name}.${enumValue.name}`,\n          path: getPath(ancestors),\n        })\n      },\n    }),\n  )\n}\n\ntype PathNode = FieldNode | ObjectFieldNode\n\nfunction isPathNode(node: ASTNode): node is PathNode {\n  return node.kind === Kind.FIELD || node.kind === Kind.OBJECT_FIELD\n}\n\nfunction getPath(ancestors: readonly (ASTNode | readonly ASTNode[])[], leaf?: string): string {\n  const segments = ancestors\n    .filter((x): x is ASTNode => !Array.isArray(x))\n    .filter(isPathNode)\n    .map((x) => x.name.value)\n\n  if (leaf) segments.push(leaf)\n\n  return segments.join('.')\n}\n\ninterface WalkState {\n  maxVariableDepth: number\n  /** Remaining node budget, shared across every variable of the operation. */\n  remaining: number\n  truncated: boolean\n}\n\n/**\n * Walks each supplied variable value against its declared type, reporting every deprecated input\n * field and enum value the client actually sent.\n *\n * Takes the definitions of the *resolved* operation rather than scanning the whole document: the\n * same variable name may be declared with a different type in each operation, so only the executed\n * one's declarations describe the supplied values.\n */\nfunction collectFromVariables(\n  schema: GraphQLSchema,\n  variableDefinitions: readonly VariableDefinitionNode[] | undefined,\n  variables: Record<string, unknown> | null | undefined,\n  state: WalkState,\n  collect: Collect,\n): void {\n  if (variables == null) return\n\n  for (const variableDefinition of variableDefinitions ?? []) {\n    const variableName = variableDefinition.variable.name.value\n    if (!Object.hasOwn(variables, variableName)) continue\n\n    const type = typeFromAST(schema, variableDefinition.type)\n    if (!isInputType(type)) continue\n\n    walkInputValue(type, variables[variableName], `$${variableName}`, 0, state, collect)\n  }\n}\n\nfunction walkInputValue(type: GraphQLInputType, value: unknown, path: string, depth: number, state: WalkState, collect: Collect): void {\n  // A limit stopping the descent is a loss of telemetry, so it is recorded; a null value is simply\n  // nothing to walk, and must not be reported as one.\n  if (depth > state.maxVariableDepth || state.remaining <= 0) {\n    state.truncated = true\n    return\n  }\n  if (value == null) return\n  state.remaining--\n\n  // Unwrapped inline rather than by recursing, so a nullability wrapper doesn't spend a node from\n  // the budget for a value that has not been descended into yet.\n  const unwrapped = isNonNullType(type) ? type.ofType : type\n\n  if (isListType(unwrapped)) {\n    // GraphQL accepts a bare value in a list position, so handle both shapes.\n    const items = Array.isArray(value) ? value : [value]\n    for (const [index, item] of items.entries()) {\n      // Checked here rather than relying on the recursive call returning early: the loop itself is\n      // the unbounded part, since list length comes from the payload and each step builds a path.\n      if (state.remaining <= 0) {\n        state.truncated = true\n        return\n      }\n      walkInputValue(unwrapped.ofType, item, Array.isArray(value) ? `${path}.${index}` : path, depth + 1, state, collect)\n    }\n    return\n  }\n\n  if (isEnumType(unwrapped)) {\n    // An unknown name is a coercion error graphql-js raises moments later; nothing to record here.\n    if (typeof value !== 'string') return\n    const enumValue = unwrapped.getValue(value)\n    if (enumValue?.deprecationReason != null) {\n      collect({ kind: 'enum-value', name: `${unwrapped.name}.${enumValue.name}`, path })\n    }\n    return\n  }\n\n  // Scalars have no members that could carry a deprecation.\n  if (!isInputObjectType(unwrapped) || !isRecord(value)) return\n\n  for (const field of Object.values(unwrapped.getFields())) {\n    if (state.remaining <= 0) {\n      state.truncated = true\n      return\n    }\n    if (!Object.hasOwn(value, field.name)) continue\n\n    const fieldPath = `${path}.${field.name}`\n    // Presence is the signal, explicit `null` included: a client still sending the field would\n    // break if it were removed from the schema.\n    if (field.deprecationReason != null) {\n      collect({ kind: 'input-field', name: `${unwrapped.name}.${field.name}`, path: fieldPath })\n    }\n\n    walkInputValue(field.type, value[field.name], fieldPath, depth + 1, state, collect)\n  }\n}\n\nfunction isRecord(value: unknown): value is Record<string, unknown> {\n  return typeof value === 'object' && value !== null && !Array.isArray(value)\n}\n"],"names":["getOperationAST","Kind","separateOperations","TypeInfo","visit","visitWithTypeInfo","getNamedType","isInputObjectType","isEnumType","typeFromAST","isInputType","isNonNullType","isListType"],"mappings":"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"}