Update doc blocks for utilities

.api-reports/api-report-utilities.api.md

@@ -87,26 +87,22 @@ type DeepPartialReadonlySet<T> = {} & ReadonlySet<DeepPartial<T>>;
 // @public (undocumented)
 type DeepPartialSet<T> = {} & Set<DeepPartial<T>>;
 
-// @public (undocumented)
+// @public
 export class DocumentTransform {
     // Warning: (ae-forgotten-export) The symbol "TransformFn" needs to be exported by the entry point index.d.ts
     // Warning: (ae-forgotten-export) The symbol "DocumentTransformOptions" needs to be exported by the entry point index.d.ts
     constructor(transform: TransformFn, options?: DocumentTransformOptions);
-    // (undocumented)
     concat(otherTransform: DocumentTransform): DocumentTransform;
-    // (undocumented)
     static identity(): DocumentTransform;
     // @internal @deprecated
     readonly left?: DocumentTransform;
     resetCache(): void;
     // @internal @deprecated
     readonly right?: DocumentTransform;
-    // (undocumented)
     static split(predicate: (document: DocumentNode) => boolean, left: DocumentTransform, right?: DocumentTransform): DocumentTransform & {
         left: DocumentTransform;
         right: DocumentTransform;
     };
-    // (undocumented)
     transformDocument(document: DocumentNode): DocumentNode;
 }
 
@@ -135,7 +131,7 @@ export interface HKT {
     return: unknown;
 }
 
-// @public (undocumented)
+// @public
 export function isFormattedExecutionResult(result?: object): result is FormattedExecutionResult;
 
 // @public

.api-reports/api-report-utilities_internal.api.md

@@ -279,7 +279,7 @@ export const getInMemoryCacheMemoryInternals: (() => {
     };
 }) | undefined;
 
-// @internal @deprecated
+// @public
 export function getMainDefinition(queryDoc: DocumentNode): OperationDefinitionNode | FragmentDefinitionNode;
 
 // @internal @deprecated (undocumented)

.api-reports/api-report.api.md

@@ -948,26 +948,22 @@ type DistributedRequiredExclude<T, U> = T extends any ? Required<T> extends Requ
 
 export { DocumentNode }
 
-// @public (undocumented)
+// @public
 export class DocumentTransform {
     // Warning: (ae-forgotten-export) The symbol "TransformFn" needs to be exported by the entry point index.d.ts
     // Warning: (ae-forgotten-export) The symbol "DocumentTransformOptions" needs to be exported by the entry point index.d.ts
     constructor(transform: TransformFn, options?: DocumentTransformOptions);
-    // (undocumented)
     concat(otherTransform: DocumentTransform): DocumentTransform;
-    // (undocumented)
     static identity(): DocumentTransform;
     // @internal @deprecated
     readonly left?: DocumentTransform;
     resetCache(): void;
     // @internal @deprecated
     readonly right?: DocumentTransform;
-    // (undocumented)
     static split(predicate: (document: DocumentNode) => boolean, left: DocumentTransform, right?: DocumentTransform): DocumentTransform & {
         left: DocumentTransform;
         right: DocumentTransform;
     };
-    // (undocumented)
     transformDocument(document: DocumentNode): DocumentNode;
 }
 

src/utilities/common/stripTypename.ts

@@ -5,6 +5,17 @@ import { omitDeep } from "@apollo/client/utilities/internal";
  *
  * @param value - The object or array that should have `__typename` removed.
  * @returns The object with all `__typename` properties removed.
+ *
+ * @example
+ *
+ * ```ts
+ * stripTypename({
+ *   __typename: "User",
+ *   id: 1,
+ *   profile: { __typename: "Profile", name: "John Doe" },
+ * });
+ * // => { id: 1, profile: { name: "John Doe"}}
+ * ```
  */
 export function stripTypename<T>(value: T) {
   return omitDeep(value, "__typename");

src/utilities/graphql/DocumentTransform.ts

@@ -14,17 +14,23 @@ type TransformFn = (document: DocumentNode) => DocumentNode;
 
 interface DocumentTransformOptions {
   /**
-   * Determines whether to cache the transformed GraphQL document. Caching can speed up repeated calls to the document transform for the same input document. Set to `false` to completely disable caching for the document transform. When disabled, this option takes precedence over the [`getCacheKey`](#getcachekey) option.
+   * Determines whether to cache the transformed GraphQL document. Caching can
+   * speed up repeated calls to the document transform for the same input
+   * document. Set to `false` to completely disable caching for the document
+   * transform. When disabled, this option takes precedence over the [`getCacheKey`](#getcachekey)
+   * option.
    *
-   * The default value is `true`.
+   * @defaultValue `true`
    */
   cache?: boolean;
   /**
    * Defines a custom cache key for a GraphQL document that will determine whether to re-run the document transform when given the same input GraphQL document. Returns an array that defines the cache key. Return `undefined` to disable caching for that GraphQL document.
    *
-   * > **Note:** The items in the array may be any type, but also need to be referentially stable to guarantee a stable cache key.
+   * > [!NOTE]
+   * > The items in the array can be any type, but each item needs to be
+   * > referentially stable to guarantee a stable cache key.
    *
-   * The default implementation of this function returns the `document` as the cache key.
+   * @defaultValue `(document) => [document]`
    */
   getCacheKey?: (
     document: DocumentNode
@@ -35,6 +41,25 @@ function identity(document: DocumentNode) {
   return document;
 }
 
+/**
+ * A class for transforming GraphQL documents. See the [Document transforms
+ * documentation](https://www.apollographql.com/docs/react/data/document-transforms) for more details on using them.
+ *
+ * @example
+ *
+ * ```ts
+ * import { DocumentTransform } from "@apollo/client/utilities";
+ * import { visit } from "graphql";
+ *
+ * const documentTransform = new DocumentTransform((doc) => {
+ *   return visit(doc, {
+ *     // ...
+ *   });
+ * });
+ *
+ * const transformedDoc = documentTransform.transformDocument(myDocument);
+ * ```
+ */
 export class DocumentTransform {
   private readonly transform: TransformFn;
   private cached: boolean;
@@ -52,13 +77,38 @@ export class DocumentTransform {
     return [document];
   }
 
+  /**
+   * Creates a DocumentTransform that returns the input document unchanged.
+   *
+   * @returns The input document
+   */
   static identity() {
     // No need to cache this transform since it just returns the document
     // unchanged. This should save a bit of memory that would otherwise be
     // needed to populate the `documentCache` of this transform.
     return new DocumentTransform(identity, { cache: false });
   }
 
+  /**
+   * Creates a DocumentTransform that conditionally applies one of two transforms.
+   *
+   * @param predicate - Function that determines which transform to apply
+   * @param left - Transform to apply when `predicate` returns `true`
+   * @param right - Transform to apply when `predicate` returns `false`. If not provided, it defaults to `DocumentTransform.identity()`.
+   * @returns A DocumentTransform that conditionally applies a document transform based on the predicate
+   *
+   * @example
+   *
+   * ```ts
+   * import { isQueryOperation } from "@apollo/client/utilities";
+   *
+   * const conditionalTransform = DocumentTransform.split(
+   *   (document) => isQueryOperation(document),
+   *   queryTransform,
+   *   mutationTransform
+   * );
+   * ```
+   */
   static split(
     predicate: (document: DocumentNode) => boolean,
     left: DocumentTransform,
@@ -91,7 +141,7 @@ export class DocumentTransform {
   }
 
   /**
-   * Resets the internal cache of this transform, if it has one.
+   * Resets the internal cache of this transform, if it is cached.
    */
   resetCache() {
     if (this.cached) {
@@ -121,6 +171,29 @@ export class DocumentTransform {
     return this.transform(document);
   }
 
+  /**
+   * Transforms a GraphQL document using the configured transform function.
+   *
+   * @remarks
+   *
+   * Note that `transformDocument` caches the transformed document. Calling
+   * `transformDocument` again with the already-transformed document will
+   * immediately return it.
+   *
+   * @param document - The GraphQL document to transform
+   * @returns The transformed document
+   *
+   * @example
+   *
+   * ```ts
+   * const document = gql`
+   *   # ...
+   * `;
+   *
+   * const documentTransform = new DocumentTransform(transformFn);
+   * const transformedDocument = documentTransform.transformDocument(document);
+   * ```
+   */
   transformDocument(document: DocumentNode) {
     // If a user passes an already transformed result back to this function,
     // immediately return it.
@@ -135,6 +208,22 @@ export class DocumentTransform {
     return transformedDocument;
   }
 
+  /**
+   * Combines this document transform with another document transform. The
+   * returned document transform first applies the current document transform,
+   * then applies the other document transform.
+   *
+   * @param otherTransform - The transform to apply after this one
+   * @returns A new DocumentTransform that applies both transforms in sequence
+   *
+   * @example
+   *
+   * ```ts
+   * const combinedTransform = addTypenameTransform.concat(
+   *   removeDirectivesTransform
+   * );
+   * ```
+   */
   concat(otherTransform: DocumentTransform): DocumentTransform {
     return Object.assign(
       new DocumentTransform(

src/utilities/graphql/isFormattedExecutionResult.ts

@@ -1,5 +1,32 @@
 import type { FormattedExecutionResult } from "graphql";
 
+/**
+ * Determines whether the given object is a valid GraphQL execution result
+ * according to the GraphQL specification.
+ *
+ * @remarks
+ *
+ * A valid execution result must be an object that contains only `data`,
+ * `errors`, and/or `extensions` properties. At least one of `data` or `errors`
+ * must be present.
+ *
+ * @param result - The object to test
+ * @returns `true` if the object conforms to the GraphQL execution result format
+ *
+ * @example
+ *
+ * ```ts
+ * import { isFormattedExecutionResult } from "@apollo/client/utilities";
+ *
+ * // Valid execution result
+ * const validResult = { data: { user: { name: "John" } } };
+ * console.log(isFormattedExecutionResult(validResult)); // true
+ *
+ * // Invalid - contains non-standard properties
+ * const invalidResult = { data: {}, customField: "value" };
+ * console.log(isFormattedExecutionResult(invalidResult)); // false
+ * ```
+ */
 export function isFormattedExecutionResult(
   result?: object
 ): result is FormattedExecutionResult {

src/utilities/graphql/operations.ts

@@ -11,9 +11,26 @@ function isOperation(
 /**
  * Determine if a document is a mutation document.
  *
+ * @remarks
+ * If you are authoring an Apollo link, you might not need this utility.
+ * Prefer using the `operationType` property the `operation` object instead.
+ *
  * @param document - The GraphQL document to check
+ * @returns A boolean indicating if the document is a mutation operation
+ *
+ * @example
+ *
+ * ```ts
+ * import { isMutationOperation } from "@apollo/client/utilities";
  *
- * @since 3.8.0
+ * const mutation = gql`
+ *   mutation MyMutation {
+ *     # ...
+ *   }
+ * `;
+ *
+ * isMutationOperation(mutation); // true
+ * ```
  */
 export function isMutationOperation(document: DocumentNode) {
   return isOperation(document, "mutation");
@@ -22,9 +39,26 @@ export function isMutationOperation(document: DocumentNode) {
 /**
  * Determine if a document is a query document.
  *
+ * @remarks
+ * If you are authoring an Apollo link, you might not need this utility.
+ * Prefer using the `operationType` property the `operation` object instead.
+ *
  * @param document - The GraphQL document to check
+ * @returns A boolean indicating if the document is a query operation
+ *
+ * @example
  *
- * @since 3.8.0
+ * ```ts
+ * import { isQueryOperation } from "@apollo/client/utilities";
+ *
+ * const query = gql`
+ *   query MyQuery {
+ *     # ...
+ *   }
+ * `;
+ *
+ * isQueryOperation(query); // true
+ * ```
  */
 export function isQueryOperation(document: DocumentNode) {
   return isOperation(document, "query");
@@ -33,9 +67,26 @@ export function isQueryOperation(document: DocumentNode) {
 /**
  * Determine if a document is a subscription document.
  *
+ * @remarks
+ * If you are authoring an Apollo link, you might not need this utility.
+ * Prefer using the `operationType` property the `operation` object instead.
+ *
  * @param document - The GraphQL document to check
+ * @returns A boolean indicating if the document is a subscription operation
+ *
+ * @example
+ *
+ * ```ts
+ * import { isSubscriptionOperation } from "@apollo/client/utilities";
+ *
+ * const subscription = gql`
+ *   subscription MySubscription {
+ *     # ...
+ *   }
+ * `;
  *
- * @since 3.8.0
+ * isSubscriptionOperation(subscription); // true
+ * ```
  */
 export function isSubscriptionOperation(document: DocumentNode) {
   return isOperation(document, "subscription");

src/utilities/graphql/storeUtils.ts

@@ -9,6 +9,15 @@ export interface Reference {
  * Determines if a given object is a reference object.
  *
  * @param obj - The object to check if its a reference object
+ *
+ * @example
+ *
+ * ```ts
+ * import { isReference } from "@apollo/client/utilities";
+ *
+ * isReference({ __ref: "User:1" }); // true
+ * isReference({ __typename: "User", id: 1 }); // false
+ * ```
  */
 export function isReference(obj: any): obj is Reference {
   return Boolean(