Merge pull request #12201 from apollographql/release-4.0

Release 4.0

Author: jerelmiller

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

@@ -4,171 +4,177 @@
 
 ```ts
 
-import type { GraphQLError } from 'graphql';
-import type { GraphQLErrorExtensions } from 'graphql';
+import type { ApolloLink } from '@apollo/client/link';
+import { ErrorLike } 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;
-    // (undocumented)
-    clientErrors: ReadonlyArray<Error>;
-    // (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 namespace CombinedGraphQLErrors {
+    // (undocumented)
+    export namespace DocumentationTypes {
+        export function formatMessage(errors: ReadonlyArray<GraphQLFormattedError>, options: MessageFormatterOptions): string;
+        // (undocumented)
+        export interface InstanceProperties {
+            readonly data: Record<string, unknown> | null | undefined;
+            readonly errors: ReadonlyArray<GraphQLFormattedError>;
+            readonly extensions: Record<string, unknown> | undefined;
+        }
+        export function is(error: unknown): boolean;
+    }
+    export type MessageFormatter = (errors: ReadonlyArray<GraphQLFormattedError>, options: MessageFormatterOptions) => string;
+    // (undocumented)
+    export interface MessageFormatterOptions {
+        defaultFormatMessage: (errors: ReadonlyArray<GraphQLFormattedError>) => string;
+        result: ApolloLink.Result<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
+export class CombinedGraphQLErrors extends Error {
+    constructor(result: FormattedExecutionResult<any>);
+    constructor(result: ApolloLink.Result<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;
 }
 
 // @public (undocumented)
-interface DefaultContext extends Record<string, any> {
+export namespace CombinedProtocolErrors {
+    // (undocumented)
+    export namespace DocumentationTypes {
+        export function formatMessage(errors: ReadonlyArray<GraphQLFormattedError>, options: MessageFormatterOptions): string;
+        // (undocumented)
+        export interface InstanceProperties {
+            readonly errors: ReadonlyArray<GraphQLFormattedError>;
+        }
+    }
+    export type MessageFormatter = (errors: ReadonlyArray<GraphQLFormattedError>, options: MessageFormatterOptions) => string;
+    // (undocumented)
+    export interface MessageFormatterOptions {
+        defaultFormatMessage: (errors: ReadonlyArray<GraphQLFormattedError>) => string;
+    }
 }
 
-// Warning: (ae-forgotten-export) The symbol "ExecutionPatchResultBase" needs to be exported by the entry point index.d.ts
-//
-// @public @deprecated (undocumented)
-interface ExecutionPatchIncrementalResult<TData = Record<string, any>, TExtensions = Record<string, any>> extends ExecutionPatchResultBase {
-    // (undocumented)
-    data?: never;
-    // (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>[];
+// @public
+export class CombinedProtocolErrors extends Error {
+    constructor(protocolErrors: Array<GraphQLFormattedError> | ReadonlyArray<GraphQLFormattedError>);
+    readonly errors: ReadonlyArray<GraphQLFormattedError>;
+    static formatMessage: CombinedProtocolErrors.MessageFormatter;
+    static is(error: unknown): error is CombinedProtocolErrors;
 }
 
-// @public @deprecated (undocumented)
-interface ExecutionPatchInitialResult<TData = Record<string, any>, TExtensions = Record<string, any>> extends ExecutionPatchResultBase {
-    // (undocumented)
-    data: TData | null | undefined;
-    // (undocumented)
-    errors?: ReadonlyArray<GraphQLFormattedError>;
-    // (undocumented)
-    extensions?: TExtensions;
-    // (undocumented)
-    incremental?: never;
-}
-
-// 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 @deprecated (undocumented)
-type ExecutionPatchResult<TData = Record<string, any>, TExtensions = Record<string, any>> = ExecutionPatchInitialResult<TData, TExtensions> | ExecutionPatchIncrementalResult<TData, TExtensions>;
-
 // @public (undocumented)
-interface ExecutionPatchResultBase {
-    // (undocumented)
-    hasNext?: boolean;
-}
+export function graphQLResultHasProtocolErrors<T extends {}>(result: T): result is T & {
+    extensions: Record<string | symbol, any>;
+};
 
-// 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>;
+export function isErrorLike(error: unknown): error is ErrorLike;
 
-// 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> & {
-    extensions: Record<string | symbol, any>;
+// @public
+export const LinkError: {
+    is: (error: unknown) => boolean;
 };
 
-// @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>;
-
-// @public @deprecated (undocumented)
-interface IncrementalPayload<TData, TExtensions> {
-    // (undocumented)
-    data: TData | null;
-    // (undocumented)
-    errors?: ReadonlyArray<GraphQLFormattedError>;
-    // (undocumented)
-    extensions?: TExtensions;
-    // (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 namespace LocalStateError {
+    // (undocumented)
+    export namespace DocumentationTypes {
+        // (undocumented)
+        export interface InstanceProperties {
+            readonly path?: Array<string | number>;
+        }
+    }
+    // (undocumented)
+    export interface Options {
+        // (undocumented)
+        path?: Array<string | number>;
+        // (undocumented)
+        sourceError?: unknown;
+    }
 }
 
-// @public @deprecated (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 @deprecated (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 namespace DocumentationTypes {
+        // (undocumented)
+        export interface InstanceProperties {
+            readonly bodyText: string;
+            readonly response: Response;
+            readonly statusCode: number;
+        }
+    }
+    // (undocumented)
+    export interface Options {
+        // (undocumented)
+        bodyText: string;
+        // (undocumented)
+        response: Response;
+    }
+}
 
-// @public (undocumented)
-type ServerError = Error & {
-    response: Response;
-    result: Record<string, any> | string;
-    statusCode: number;
-};
+// @public
+export class ServerError extends Error {
+    constructor(message: string, options: ServerError.Options);
+    readonly bodyText: string;
+    static is(error: unknown): error is ServerError;
+    readonly response: Response;
+    readonly statusCode: number;
+}
 
 // @public (undocumented)
-type ServerParseError = Error & {
-    response: Response;
-    statusCode: number;
-    bodyText: string;
-};
+export namespace ServerParseError {
+    // (undocumented)
+    export namespace DocumentationTypes {
+        // (undocumented)
+        export interface InstanceProperties {
+            readonly bodyText: string;
+            readonly response: Response;
+            readonly statusCode: number;
+        }
+    }
+    // (undocumented)
+    export interface Options {
+        // (undocumented)
+        bodyText: string;
+        // (undocumented)
+        response: Response;
+    }
+}
+
+// @public
+export class ServerParseError extends Error {
+    constructor(originalParseError: unknown, options: ServerParseError.Options);
+    readonly bodyText: string;
+    static is(error: unknown): error is ServerParseError;
+    readonly response: Response;
+    readonly statusCode: number;
+}
 
-// 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;
-    // (undocumented)
-    data?: TData | null;
-    // (undocumented)
-    errors?: ReadonlyArray<GraphQLFormattedError>;
-    // (undocumented)
-    extensions?: TExtensions;
+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)