apollo-server-core

constructor(config: Config<ContextFunctionParams>);

protected csrfPreventionRequestHeaders: string[];

graphqlPath: string;

protected plugins: ApolloServerPlugin[];

requestOptions: Partial<GraphQLServerOptions<any, any>>;

protected assertStarted: (methodName: string) => void;

protected ensureStarted: () => Promise<void>;

executeOperation: (
    request: Omit<GraphQLRequest, 'query'> & { query?: string | DocumentNode },
    integrationContextArgument?: ContextFunctionParams
) => Promise<import('apollo-server-types').GraphQLResponse>;

protected getLandingPage: () => LandingPage | null;

protected graphQLServerOptions: (
    integrationContextArgument?: any
) => Promise<GraphQLServerOptions>;

protected serverlessFramework: () => boolean;

start: () => Promise<void>;

stop: () => Promise<void>;

constructor(
    statusCode: number,
    message: string,
    isGraphQLError?: boolean,
    headers?: { [key: string]: string }
);

headers?: { [key: string]: string };

isGraphQLError: boolean;

statusCode: number;

calculateHttpHeaders?: boolean;

defaultMaxAge?: number;

httpServer: http.Server;

stopGracePeriodMillis?: number;

rewriteError?: ApolloServerPluginUsageReportingOptions<never>['rewriteError'];

document?: string;

footer?: boolean;

headers?: Record<string, string>;

includeCookies?: boolean;

variables?: Record<string, any>;

version?: string;

endpointUrl?: string;

fetcher?: typeof fetch;

initialDelayMaxMs?: number;

overrideReportedSchema?: string;

calculateSignature?: (ast: DocumentNode, operationName: string) => string;

debugPrintReports?: boolean;

endpointUrl?: string;

experimental_sendOperationAsTrace?: (
    trace: Trace,
    statsReportKey: string
) => boolean;

fetcher?: typeof fetch;

fieldLevelInstrumentation?:
    | number
    | ((
          request: GraphQLRequestContextDidResolveOperation<TContext>
      ) => Promise<number | boolean>);

generateClientInfo?: GenerateClientInfo<TContext>;

includeRequest?: (
    request:
        | GraphQLRequestContextDidResolveOperation<TContext>
        | GraphQLRequestContextWillSendResponse<TContext>
) => Promise<boolean>;

internal_includeTracesContributingToStats?: boolean;

logger?: Logger;

maxAttempts?: number;

maxUncompressedReportSize?: number;

minimumRetryDelayMs?: number;

overrideReportedSchema?: string;

reportErrorFunction?: (err: Error) => void;

reportIntervalMs?: number;

requestAgent?: RequestAgent | false;

requestTimeoutMs?: number;

rewriteError?: (err: GraphQLError) => GraphQLError | null;

sendHeaders?: SendValuesBaseOptions;

sendReportsImmediately?: boolean;

sendUnexecutableOperationDocuments?: boolean;

sendVariableValues?: VariableValueOptions;

clientName?: string;

clientVersion?: string;

apollo?: ApolloConfigInput;

cache?: KeyValueCache | 'bounded';

context?: Context | ContextFunction<ContextFunctionParams>;

csrfPrevention?: CSRFPreventionOptions | boolean;

dangerouslyDisableValidation?: boolean;

documentStore?: DocumentStore | null;

gateway?: GatewayInterface;

introspection?: boolean;

mockEntireSchema?: boolean;

mocks?: boolean | IMocks;

modules?: GraphQLSchemaModule[];

nodeEnv?: string;

parseOptions?: IExecutableSchemaDefinition['parseOptions'];

persistedQueries?: PersistedQueryOptions | false;

plugins?: PluginDefinition[];

resolvers?: IExecutableSchemaDefinition['resolvers'];

schema?: GraphQLSchema;

stopOnTerminationSignals?: boolean;

typeDefs?: IExecutableSchemaDefinition['typeDefs'];

requestHeaders?: string[];

load: (options: { apollo: ApolloConfig }) => Promise<GraphQLServiceConfig>;

onSchemaChange: (callback: SchemaChangeCallback) => Unsubscriber;

onSchemaLoadOrUpdate: (
    callback: (schemaContext: {
        apiSchema: GraphQLSchema;
        coreSupergraphSdl: string;
    }) => void
) => Unsubscriber;

stop: () => Promise<void>;

allowBatchedHttpRequests?: boolean;

cache?: KeyValueCache;

context?: TContext | (() => never);

dangerouslyDisableValidation?: boolean;

dataSources?: () => DataSources<TContext>;

debug?: boolean;

documentStore?: DocumentStore | null;

executor?: GraphQLExecutor;

fieldResolver?: GraphQLFieldResolver<any, TContext>;

formatError?: (error: GraphQLError) => GraphQLFormattedError;

formatResponse?: (
    response: GraphQLResponse,
    requestContext: GraphQLRequestContext<TContext>
) => GraphQLResponse | null;

logger?: Logger;

nodeEnv?: string;

parseOptions?: ParseOptions;

persistedQueries?: PersistedQueryOptions;

plugins?: ApolloServerPlugin[];

rootValue?: ((parsedQuery: DocumentNode) => TRootValue) | TRootValue;

schema: GraphQLSchema;

schemaHash: SchemaHash;

validationRules?: Array<(context: ValidationContext) => any>;

method: string;

options:
    | GraphQLOptions
    | ((...args: Array<any>) => ValueOrPromise<GraphQLOptions>);

query: Record<string, any> | Array<Record<string, any>>;

request: Pick<Request, 'url' | 'method' | 'headers'>;

cache?: KeyValueCache;

ttl?: number | null;