Release 4.0

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

@@ -4,171 +4,138 @@
 
 ```ts
 
-import type { GraphQLError } from 'graphql';
-import type { GraphQLErrorExtensions } from 'graphql';
+import { ErrorLike } from '@apollo/client';
+import type { FetchResult } from '@apollo/client';
+import type { FormattedExecutionResult } from 'graphql';
 import type { GraphQLFormattedError } from 'graphql';
 
 // @public (undocumented)
-export class ApolloError extends Error {
-    constructor({ graphQLErrors, protocolErrors, clientErrors, networkError, errorMessage, extraInfo, }: ApolloErrorOptions);
-    cause: ({
-        readonly message: string;
-        extensions?: GraphQLErrorExtensions[] | GraphQLFormattedError["extensions"];
-    } & Omit<Partial<Error> & Partial<GraphQLFormattedError>, "extensions">) | null;
+export namespace CombinedGraphQLErrors {
     // (undocumented)
-    clientErrors: ReadonlyArray<Error>;
+    export type MessageFormatter = (errors: ReadonlyArray<GraphQLFormattedError>, options: MessageFormatterOptions) => string;
     // (undocumented)
-    extraInfo: any;
-    // (undocumented)
-    graphQLErrors: ReadonlyArray<GraphQLFormattedError>;
-    // (undocumented)
-    message: string;
-    // (undocumented)
-    name: string;
-    // Warning: (ae-forgotten-export) The symbol "ServerParseError" needs to be exported by the entry point index.d.ts
-    // Warning: (ae-forgotten-export) The symbol "ServerError" needs to be exported by the entry point index.d.ts
-    //
-    // (undocumented)
-    networkError: Error | ServerParseError | ServerError | null;
-    // (undocumented)
-    protocolErrors: ReadonlyArray<GraphQLFormattedError>;
+    export interface MessageFormatterOptions {
+        // (undocumented)
+        defaultFormatMessage: (errors: ReadonlyArray<GraphQLFormattedError>) => string;
+        // (undocumented)
+        result: FetchResult<unknown>;
+    }
 }
 
-// @public (undocumented)
-export interface ApolloErrorOptions {
-    // (undocumented)
-    clientErrors?: ReadonlyArray<Error>;
-    // (undocumented)
-    errorMessage?: string;
-    // (undocumented)
-    extraInfo?: any;
-    // (undocumented)
-    graphQLErrors?: ReadonlyArray<GraphQLFormattedError>;
-    // (undocumented)
-    networkError?: Error | ServerParseError | ServerError | null;
-    // (undocumented)
-    protocolErrors?: ReadonlyArray<GraphQLFormattedError>;
-}
-
-// @public (undocumented)
-interface DefaultContext extends Record<string, any> {
+// @public
+export class CombinedGraphQLErrors extends Error {
+    constructor(result: FormattedExecutionResult<any>);
+    constructor(result: FetchResult<any>, errors: ReadonlyArray<GraphQLFormattedError>);
+    readonly data: Record<string, unknown> | null | undefined;
+    readonly errors: ReadonlyArray<GraphQLFormattedError>;
+    readonly extensions: Record<string, unknown> | undefined;
+    static formatMessage: CombinedGraphQLErrors.MessageFormatter;
+    static is(error: unknown): error is CombinedGraphQLErrors;
 }
 
-// Warning: (ae-forgotten-export) The symbol "ExecutionPatchResultBase" needs to be exported by the entry point index.d.ts
-//
 // @public (undocumented)
-interface ExecutionPatchIncrementalResult<TData = Record<string, any>, TExtensions = Record<string, any>> extends ExecutionPatchResultBase {
+export namespace CombinedProtocolErrors {
     // (undocumented)
-    data?: never;
+    export type MessageFormatter = (errors: ReadonlyArray<GraphQLFormattedError>, options: MessageFormatterOptions) => string;
     // (undocumented)
-    errors?: never;
-    // (undocumented)
-    extensions?: never;
-    // Warning: (ae-forgotten-export) The symbol "IncrementalPayload" needs to be exported by the entry point index.d.ts
-    //
-    // (undocumented)
-    incremental?: IncrementalPayload<TData, TExtensions>[];
+    export interface MessageFormatterOptions {
+        // (undocumented)
+        defaultFormatMessage: (errors: ReadonlyArray<GraphQLFormattedError>) => string;
+    }
 }
 
-// @public (undocumented)
-interface ExecutionPatchInitialResult<TData = Record<string, any>, TExtensions = Record<string, any>> extends ExecutionPatchResultBase {
-    // (undocumented)
-    data: TData | null | undefined;
+// @public
+export class CombinedProtocolErrors extends Error {
+    constructor(protocolErrors: Array<GraphQLFormattedError> | ReadonlyArray<GraphQLFormattedError>);
     // (undocumented)
-    errors?: ReadonlyArray<GraphQLFormattedError>;
+    errors: ReadonlyArray<GraphQLFormattedError>;
     // (undocumented)
-    extensions?: TExtensions;
-    // (undocumented)
-    incremental?: never;
+    static formatMessage: CombinedProtocolErrors.MessageFormatter;
+    static is(error: unknown): error is CombinedProtocolErrors;
 }
 
-// Warning: (ae-forgotten-export) The symbol "ExecutionPatchInitialResult" needs to be exported by the entry point index.d.ts
-// Warning: (ae-forgotten-export) The symbol "ExecutionPatchIncrementalResult" needs to be exported by the entry point index.d.ts
-//
-// @public (undocumented)
-type ExecutionPatchResult<TData = Record<string, any>, TExtensions = Record<string, any>> = ExecutionPatchInitialResult<TData, TExtensions> | ExecutionPatchIncrementalResult<TData, TExtensions>;
-
 // @public (undocumented)
-interface ExecutionPatchResultBase {
-    // (undocumented)
-    hasNext?: boolean;
-}
-
-// Warning: (ae-forgotten-export) The symbol "SingleExecutionResult" needs to be exported by the entry point index.d.ts
-// Warning: (ae-forgotten-export) The symbol "ExecutionPatchResult" needs to be exported by the entry point index.d.ts
-//
-// @public (undocumented)
-type FetchResult<TData = Record<string, any>, TContext = Record<string, any>, TExtensions = Record<string, any>> = SingleExecutionResult<TData, TContext, TExtensions> | ExecutionPatchResult<TData, TExtensions>;
-
-// Warning: (ae-forgotten-export) The symbol "FetchResult" needs to be exported by the entry point index.d.ts
-//
-// @public (undocumented)
-type FetchResultWithSymbolExtensions<T> = FetchResult<T> & {
+export function graphQLResultHasProtocolErrors<T extends {}>(result: T): result is T & {
     extensions: Record<string | symbol, any>;
 };
 
-// @public @deprecated (undocumented)
-export type GraphQLErrors = ReadonlyArray<GraphQLError>;
-
-// Warning: (ae-forgotten-export) The symbol "FetchResultWithSymbolExtensions" needs to be exported by the entry point index.d.ts
-//
 // @public (undocumented)
-export function graphQLResultHasProtocolErrors<T>(result: FetchResult<T>): result is FetchResultWithSymbolExtensions<T>;
+export function isErrorLike(error: unknown): error is ErrorLike;
+
+// @public
+export const LinkError: {
+    is: (error: unknown) => boolean;
+};
 
 // @public (undocumented)
-interface IncrementalPayload<TData, TExtensions> {
-    // (undocumented)
-    data: TData | null;
-    // (undocumented)
-    errors?: ReadonlyArray<GraphQLFormattedError>;
-    // (undocumented)
-    extensions?: TExtensions;
+export namespace LocalStateError {
     // (undocumented)
-    label?: string;
-    // Warning: (ae-forgotten-export) The symbol "Path" needs to be exported by the entry point index.d.ts
-    //
-    // (undocumented)
-    path: Path;
+    export interface Options {
+        // (undocumented)
+        path?: Array<string | number>;
+        // (undocumented)
+        sourceError?: unknown;
+    }
 }
 
-// @public (undocumented)
-export function isApolloError(err: Error): err is ApolloError;
+// @public
+export class LocalStateError extends Error {
+    constructor(message: string, options?: LocalStateError.Options);
+    static is(error: unknown): error is LocalStateError;
+    readonly path?: Array<string | number>;
+}
 
 // @public (undocumented)
-export type NetworkError = Error | ServerParseError | ServerError | null;
+export const PROTOCOL_ERRORS_SYMBOL: unique symbol;
 
-// @public (undocumented)
-type Path = ReadonlyArray<string | number>;
+// @internal @deprecated
+export function registerLinkError(error: ErrorLike): void;
 
 // @public (undocumented)
-export const PROTOCOL_ERRORS_SYMBOL: unique symbol;
+export namespace ServerError {
+    // (undocumented)
+    export interface Options {
+        // (undocumented)
+        bodyText: string;
+        // (undocumented)
+        response: Response;
+    }
+}
 
-// @public (undocumented)
-type ServerError = Error & {
+// @public
+export class ServerError extends Error {
+    constructor(message: string, options: ServerError.Options);
+    bodyText: string;
+    static is(error: unknown): error is ServerError;
     response: Response;
-    result: Record<string, any> | string;
     statusCode: number;
-};
+}
 
-// @public (undocumented)
-type ServerParseError = Error & {
+// @public
+export class ServerParseError extends Error {
+    // Warning: (ae-forgotten-export) The symbol "ServerParseErrorOptions" needs to be exported by the entry point index.d.ts
+    constructor(originalParseError: unknown, options: ServerParseErrorOptions);
+    bodyText: string;
+    static is(error: unknown): error is ServerParseError;
     response: Response;
     statusCode: number;
-    bodyText: string;
-};
+}
 
-// Warning: (ae-forgotten-export) The symbol "DefaultContext" needs to be exported by the entry point index.d.ts
-//
 // @public (undocumented)
-interface SingleExecutionResult<TData = Record<string, any>, TContext = DefaultContext, TExtensions = Record<string, any>> {
-    // (undocumented)
-    context?: TContext;
+interface ServerParseErrorOptions {
     // (undocumented)
-    data?: TData | null;
-    // (undocumented)
-    errors?: ReadonlyArray<GraphQLFormattedError>;
+    bodyText: string;
     // (undocumented)
-    extensions?: TExtensions;
+    response: Response;
+}
+
+// @public (undocumented)
+export function toErrorLike(error: unknown): ErrorLike;
+
+// @public
+export class UnconventionalError extends Error {
+    constructor(errorType: unknown);
+    static is(error: unknown): error is UnconventionalError;
 }
 
 // (No @packageDocumentation comment for this package)

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

@@ -0,0 +1,109 @@
+## API Report File for "@apollo/client"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+import type { DeepPartial } from '@apollo/client/utilities';
+import type { DocumentNode } from 'graphql';
+import type { FetchResult } from '@apollo/client';
+import type { FormattedExecutionResult } from 'graphql';
+import type { GraphQLFormattedError } from 'graphql';
+import type { GraphQLRequest } from '@apollo/client';
+
+// @public (undocumented)
+namespace Defer20220824Handler {
+    // (undocumented)
+    type Chunk<TData extends Record<string, unknown>> = InitialResult<TData> | SubsequentResult<TData>;
+    // (undocumented)
+    type IncrementalDeferPayload<TData = Record<string, unknown>> = {
+        data?: TData | null | undefined;
+        errors?: ReadonlyArray<GraphQLFormattedError>;
+        extensions?: Record<string, unknown>;
+        path?: Incremental.Path;
+        label?: string;
+    };
+    // (undocumented)
+    type InitialResult<TData = Record<string, unknown>> = {
+        data?: TData | null | undefined;
+        errors?: ReadonlyArray<GraphQLFormattedError>;
+        extensions?: Record<string, unknown>;
+        hasNext: boolean;
+    };
+    // (undocumented)
+    type SubsequentResult<TData = Record<string, unknown>> = {
+        data?: TData | null | undefined;
+        errors?: ReadonlyArray<GraphQLFormattedError>;
+        extensions?: Record<string, unknown>;
+        hasNext: boolean;
+        incremental?: Array<IncrementalDeferPayload<TData>>;
+    };
+}
+
+// @public
+class Defer20220824Handler implements Incremental.Handler<Defer20220824Handler.Chunk<any>> {
+    // (undocumented)
+    extractErrors(result: FetchResult<any>): GraphQLFormattedError[] | undefined;
+    // (undocumented)
+    isIncrementalResult(result: Record<string, any>): result is Defer20220824Handler.SubsequentResult | Defer20220824Handler.InitialResult;
+    // (undocumented)
+    prepareRequest(request: GraphQLRequest): GraphQLRequest;
+    // Warning: (ae-forgotten-export) The symbol "DeferRequest" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    startRequest<TData extends Record<string, unknown>>(_: {
+        query: DocumentNode;
+    }): DeferRequest<TData>;
+}
+export { Defer20220824Handler }
+export { Defer20220824Handler as GraphQL17Alpha2Handler }
+
+// @public (undocumented)
+class DeferRequest<TData extends Record<string, unknown>> implements Incremental.IncrementalRequest<Defer20220824Handler.Chunk<TData>, TData> {
+    // (undocumented)
+    handle(cacheData: TData | DeepPartial<TData> | null | undefined, chunk: Defer20220824Handler.Chunk<TData>): FormattedExecutionResult<TData>;
+    // (undocumented)
+    hasNext: boolean;
+}
+
+// @public (undocumented)
+export namespace Incremental {
+    // @internal @deprecated (undocumented)
+    export interface Handler<Chunk extends Record<string, unknown> = Record<string, unknown>> {
+        // (undocumented)
+        extractErrors: (result: FetchResult<any>) => readonly GraphQLFormattedError[] | undefined | void;
+        // (undocumented)
+        isIncrementalResult: (result: FetchResult<any>) => result is Chunk;
+        // (undocumented)
+        prepareRequest: (request: GraphQLRequest) => GraphQLRequest;
+        // (undocumented)
+        startRequest: <TData extends Record<string, unknown>>(request: {
+            query: DocumentNode;
+        }) => IncrementalRequest<Chunk, TData>;
+    }
+    // (undocumented)
+    export interface IncrementalRequest<Chunk extends Record<string, unknown>, TData> {
+        // (undocumented)
+        handle: (cacheData: TData | DeepPartial<TData> | undefined | null, chunk: Chunk) => FormattedExecutionResult<TData>;
+        // (undocumented)
+        hasNext: boolean;
+    }
+    // (undocumented)
+    export type Path = ReadonlyArray<string | number>;
+}
+
+// @public (undocumented)
+export class NotImplementedHandler implements Incremental.Handler<never> {
+    // (undocumented)
+    extractErrors(): void;
+    // (undocumented)
+    isIncrementalResult(_: any): _ is never;
+    // (undocumented)
+    prepareRequest(request: GraphQLRequest): GraphQLRequest<Record<string, any>>;
+    // (undocumented)
+    startRequest: any;
+}
+
+// (No @packageDocumentation comment for this package)
+
+```