@makerx/graphql-core 3.1.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
@@ -370,8 +404,26 @@ This library includes a `subscriptions` module to provide simple setup using the
 
 Wraps an `AsyncIterableIterator` (e.g. one returned by a pubsub `asyncIterableIterator(...)` call) with two optional behaviours:
 
-- `initialPayload` — a single event or array of events yielded before the wrapped iterator's events. Useful when a client subscribes after a state change has already happened, so they don't miss the current state while waiting for the next event.
-- `eventIsFinal` — a predicate that ends iteration eagerly when it returns `true` for an event. The final event is still yielded, then `wrapped.return()` is called to release resources. Only applied to events from the wrapped iterator, not to entries in `initialPayload`.
+- `initialPayload` — a single event, an array of events, or a **factory** (`() => event | event[] | undefined | Promise<…>`) yielded before the wrapped iterator's events. Useful when a client subscribes after a state change has already happened, so they don't miss the current state while waiting for the next event. A factory may return `undefined` (e.g. a `findOne` that yields nothing) to mean "no snapshot", in which case iteration proceeds straight to the wrapped stream.
+- `eventIsFinal` — a predicate that ends iteration eagerly when it returns `true` for an event. The triggering event is still yielded, then `wrapped.return()` is called to release resources. It is checked against every event from the wrapped iterator **and** against the _final_ entry of `initialPayload` (earlier entries are always yielded); if that final entry is terminal, iteration ends after the payload drains — in the value form without ever pulling the wrapped iterator.
+
+#### Prefer the factory form for "snapshot then stream"
+
+pubsub iterators (e.g. `graphql-subscriptions` / `graphql-redis-subscriptions`) subscribe to their channel **lazily, on the first `next()`**. If you read your snapshot (the initial payload) _before_ the iterator is pulled, the channel isn't live yet — any event published between the snapshot read and the subscription going live is **lost** _and_ missing from the snapshot, so the client can be left showing stale state until a manual refetch.
+
+Passing `initialPayload` as a **factory** closes that window: the helper eagerly pulls the wrapped iterator once (establishing the subscription) _before_ invoking the factory to read the snapshot. Events fired during the snapshot read are then buffered by the wrapped iterator and delivered immediately after the snapshot, instead of being dropped.
+
+```ts
+return wrapSubscriptionIterator({
+  iterator: pubsub().asyncIterableIterator(`topic.${id}`),
+  // factory runs AFTER the subscription is kicked, so an event fired during the read isn't lost
+  initialPayload: () => repo.find({ where: { id } }),
+})
+```
+
+> The plain value form (a single event or array) is unchanged and still subscribes lazily — fine when there is no read between subscribe and snapshot (e.g. a cached value already in hand, as below).
+>
+> Detection is via `typeof initialPayload === 'function'`. If your event type is itself callable, wrap a value-form payload in an array (`[value]`) to disambiguate it from a factory.
 
 Typical use is in a subscription resolver that needs to bridge a "current state" (cache or other persisted state lookup) with a live event stream, and close the subscription once a terminal event arrives:
 

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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"}