apollo-server-core

  • Version 2.25.1
  • Published
  • 1.11 MB
  • 25 dependencies
  • MIT license

Install

npm i apollo-server-core
yarn add apollo-server-core
pnpm add apollo-server-core

Overview

Core engine for Apollo GraphQL server

Index

Variables

Functions

Classes

Interfaces

Type Aliases

Variables

variable defaultPlaygroundOptions

const defaultPlaygroundOptions: {
version: string;
settings: {
'general.betaUpdates': boolean;
'editor.theme': Theme;
'editor.cursorShape': CursorShape;
'editor.reuseHeaders': boolean;
'tracing.hideTracingResponse': boolean;
'queryPlan.hideQueryPlanResponse': boolean;
'editor.fontSize': number;
'editor.fontFamily': string;
'request.credentials': string;
};
};

    variable GraphQLUpload

    const GraphQLUpload: any;

      variable processFileUploads

      const processFileUploads: any;

        Functions

        function ApolloServerPluginInlineTrace

        ApolloServerPluginInlineTrace: (
        options?: ApolloServerPluginInlineTraceOptions
        ) => any;

          function ApolloServerPluginInlineTraceDisabled

          ApolloServerPluginInlineTraceDisabled: () => any;

            function ApolloServerPluginSchemaReporting

            ApolloServerPluginSchemaReporting: (
            options?: ApolloServerPluginSchemaReportingOptions
            ) => any;

              function ApolloServerPluginUsageReporting

              ApolloServerPluginUsageReporting: <TContext>(
              options?: ApolloServerPluginUsageReportingOptions<TContext>
              ) => any;

                function ApolloServerPluginUsageReportingDisabled

                ApolloServerPluginUsageReportingDisabled: () => any;

                  function ApolloServerPluginUsageReportingFromLegacyOptions

                  ApolloServerPluginUsageReportingFromLegacyOptions: <TContext>(
                  options?: EngineReportingOptions<TContext>
                  ) => any;

                    function convertNodeHttpToRequest

                    convertNodeHttpToRequest: (req: any) => any;

                      function createPlaygroundOptions

                      createPlaygroundOptions: (
                      playground?: PlaygroundConfig
                      ) => PlaygroundRenderPageOptions | undefined;

                        function gql

                        gql: (template: TemplateStringsArray | string, ...substitutions: any[]) => any;

                          function resolveGraphqlOptions

                          resolveGraphqlOptions: (
                          options:
                          | GraphQLServerOptions<Record<string, any>, any>
                          | ((...args: Array<any>) => any),
                          ...args: Array<any>
                          ) => Promise<GraphQLServerOptions>;

                            function runHttpQuery

                            runHttpQuery: (
                            handlerArguments: Array<any>,
                            request: HttpQueryRequest
                            ) => Promise<HttpQueryResponse>;

                              Classes

                              class ApolloServerBase

                              class ApolloServerBase {}

                                constructor

                                constructor(config: Config);

                                  property graphqlPath

                                  graphqlPath: string;

                                    property playgroundOptions

                                    protected playgroundOptions?: any;

                                      property plugins

                                      protected plugins: any[];

                                        property requestOptions

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

                                          property schema

                                          protected schema?: any;

                                            property subscriptionServerOptions

                                            protected subscriptionServerOptions?: SubscriptionServerOptions;

                                              property subscriptionsPath

                                              subscriptionsPath?: string;

                                                property uploadsConfig

                                                protected uploadsConfig?: FileUploadOptions;

                                                  method ensureStarting

                                                  protected ensureStarting: () => void;

                                                    method executeOperation

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

                                                      method graphQLServerOptions

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

                                                        method installSubscriptionHandlers

                                                        installSubscriptionHandlers: (
                                                        server:
                                                        | HttpServer
                                                        | HttpsServer
                                                        | Http2Server
                                                        | Http2SecureServer
                                                        | WebSocket.Server
                                                        ) => void;

                                                          method serverlessFramework

                                                          protected serverlessFramework: () => boolean;

                                                            method setGraphQLPath

                                                            setGraphQLPath: (path: string) => void;

                                                              method start

                                                              start: () => Promise<void>;

                                                                method stop

                                                                stop: () => Promise<void>;

                                                                  method supportsSubscriptions

                                                                  protected supportsSubscriptions: () => boolean;

                                                                    method supportsUploads

                                                                    protected supportsUploads: () => boolean;

                                                                      method willStart

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

                                                                        class HttpQueryError

                                                                        class HttpQueryError extends Error {}

                                                                          constructor

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

                                                                            property headers

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

                                                                              property isGraphQLError

                                                                              isGraphQLError: boolean;

                                                                                property statusCode

                                                                                statusCode: number;

                                                                                  Interfaces

                                                                                  interface ApolloServerPluginInlineTraceOptions

                                                                                  interface ApolloServerPluginInlineTraceOptions {}

                                                                                    property rewriteError

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

                                                                                      interface ApolloServerPluginSchemaReportingOptions

                                                                                      interface ApolloServerPluginSchemaReportingOptions {}

                                                                                        property endpointUrl

                                                                                        endpointUrl?: string;

                                                                                          property fetcher

                                                                                          fetcher?: typeof fetch;

                                                                                            property initialDelayMaxMs

                                                                                            initialDelayMaxMs?: number;

                                                                                              property overrideReportedSchema

                                                                                              overrideReportedSchema?: string;

                                                                                                interface ApolloServerPluginUsageReportingOptions

                                                                                                interface ApolloServerPluginUsageReportingOptions<TContext> {}

                                                                                                  property calculateSignature

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

                                                                                                    property debugPrintReports

                                                                                                    debugPrintReports?: boolean;

                                                                                                      property endpointUrl

                                                                                                      endpointUrl?: string;

                                                                                                        property experimental_sendOperationAsTrace

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

                                                                                                          property fetcher

                                                                                                          fetcher?: typeof fetch;

                                                                                                            property generateClientInfo

                                                                                                            generateClientInfo?: GenerateClientInfo<TContext>;

                                                                                                              property includeRequest

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

                                                                                                                property internal_includeTracesContributingToStats

                                                                                                                internal_includeTracesContributingToStats?: boolean;

                                                                                                                  property logger

                                                                                                                  logger?: Logger;

                                                                                                                    property maxAttempts

                                                                                                                    maxAttempts?: number;

                                                                                                                      property maxUncompressedReportSize

                                                                                                                      maxUncompressedReportSize?: number;

                                                                                                                        property minimumRetryDelayMs

                                                                                                                        minimumRetryDelayMs?: number;

                                                                                                                          property overrideReportedSchema

                                                                                                                          overrideReportedSchema?: string;

                                                                                                                            property reportErrorFunction

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

                                                                                                                              property reportIntervalMs

                                                                                                                              reportIntervalMs?: number;

                                                                                                                                property requestAgent

                                                                                                                                requestAgent?: RequestAgent | false;

                                                                                                                                  property rewriteError

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

                                                                                                                                    property sendHeaders

                                                                                                                                    sendHeaders?: SendValuesBaseOptions;

                                                                                                                                      property sendReportsImmediately

                                                                                                                                      sendReportsImmediately?: boolean;

                                                                                                                                        property sendUnexecutableOperationDocuments

                                                                                                                                        sendUnexecutableOperationDocuments?: boolean;

                                                                                                                                          property sendVariableValues

                                                                                                                                          sendVariableValues?: VariableValueOptions;

                                                                                                                                            interface ClientInfo

                                                                                                                                            interface ClientInfo {}

                                                                                                                                              property clientName

                                                                                                                                              clientName?: string;

                                                                                                                                                property clientReferenceId

                                                                                                                                                clientReferenceId?: string;

                                                                                                                                                  property clientVersion

                                                                                                                                                  clientVersion?: string;

                                                                                                                                                    interface Config

                                                                                                                                                    interface Config extends BaseConfig {}

                                                                                                                                                      property apollo

                                                                                                                                                      apollo?: ApolloConfigInput;

                                                                                                                                                        property cacheControl

                                                                                                                                                        cacheControl?: CacheControlExtensionOptions | boolean;

                                                                                                                                                          property context

                                                                                                                                                          context?: Context | ContextFunction;

                                                                                                                                                            property engine

                                                                                                                                                            engine?: boolean | EngineReportingOptions<Context>;

                                                                                                                                                              property experimental_approximateDocumentStoreMiB

                                                                                                                                                              experimental_approximateDocumentStoreMiB?: number;

                                                                                                                                                                property extensions

                                                                                                                                                                extensions?: Array<() => GraphQLExtension>;

                                                                                                                                                                  property gateway

                                                                                                                                                                  gateway?: GraphQLService;

                                                                                                                                                                    property introspection

                                                                                                                                                                    introspection?: boolean;

                                                                                                                                                                      property mockEntireSchema

                                                                                                                                                                      mockEntireSchema?: boolean;

                                                                                                                                                                        property mocks

                                                                                                                                                                        mocks?: boolean | IMocks;

                                                                                                                                                                          property modules

                                                                                                                                                                          modules?: GraphQLSchemaModule[];

                                                                                                                                                                            property parseOptions

                                                                                                                                                                            parseOptions?: GraphQLParseOptions;

                                                                                                                                                                              property persistedQueries

                                                                                                                                                                              persistedQueries?: PersistedQueryOptions | false;

                                                                                                                                                                                property playground

                                                                                                                                                                                playground?: PlaygroundConfig;

                                                                                                                                                                                  property plugins

                                                                                                                                                                                  plugins?: PluginDefinition[];

                                                                                                                                                                                    property resolvers

                                                                                                                                                                                    resolvers?: IResolvers | Array<IResolvers>;

                                                                                                                                                                                      property schema

                                                                                                                                                                                      schema?: GraphQLSchema;

                                                                                                                                                                                        property schemaDirectives

                                                                                                                                                                                        schemaDirectives?: Record<string, typeof SchemaDirectiveVisitor>;

                                                                                                                                                                                          property stopOnTerminationSignals

                                                                                                                                                                                          stopOnTerminationSignals?: boolean;

                                                                                                                                                                                            property subscriptions

                                                                                                                                                                                            subscriptions?: Partial<SubscriptionServerOptions> | string | false;

                                                                                                                                                                                              property typeDefs

                                                                                                                                                                                              typeDefs?: DocumentNode | Array<DocumentNode> | string | Array<string>;

                                                                                                                                                                                                property uploads

                                                                                                                                                                                                uploads?: boolean | FileUploadOptions;

                                                                                                                                                                                                  interface EngineReportingOptions

                                                                                                                                                                                                  interface EngineReportingOptions<TContext> {}

                                                                                                                                                                                                    property apiKey

                                                                                                                                                                                                    apiKey?: string;

                                                                                                                                                                                                      property calculateSignature

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

                                                                                                                                                                                                        property debugPrintReports

                                                                                                                                                                                                        debugPrintReports?: boolean;

                                                                                                                                                                                                          property endpointUrl

                                                                                                                                                                                                          endpointUrl?: string;

                                                                                                                                                                                                            property experimental_overrideReportedSchema

                                                                                                                                                                                                            experimental_overrideReportedSchema?: string;

                                                                                                                                                                                                              property experimental_schemaReporting

                                                                                                                                                                                                              experimental_schemaReporting?: boolean;

                                                                                                                                                                                                                property experimental_schemaReportingInitialDelayMaxMs

                                                                                                                                                                                                                experimental_schemaReportingInitialDelayMaxMs?: number;

                                                                                                                                                                                                                  property generateClientInfo

                                                                                                                                                                                                                  generateClientInfo?: GenerateClientInfo<TContext>;

                                                                                                                                                                                                                    property graphVariant

                                                                                                                                                                                                                    graphVariant?: string;

                                                                                                                                                                                                                      property handleSignals

                                                                                                                                                                                                                      handleSignals?: boolean;

                                                                                                                                                                                                                        property logger

                                                                                                                                                                                                                        logger?: Logger;

                                                                                                                                                                                                                          property maskErrorDetails

                                                                                                                                                                                                                          maskErrorDetails?: boolean;

                                                                                                                                                                                                                            property maxAttempts

                                                                                                                                                                                                                            maxAttempts?: number;

                                                                                                                                                                                                                              property maxUncompressedReportSize

                                                                                                                                                                                                                              maxUncompressedReportSize?: number;

                                                                                                                                                                                                                                property minimumRetryDelayMs

                                                                                                                                                                                                                                minimumRetryDelayMs?: number;

                                                                                                                                                                                                                                  property overrideReportedSchema

                                                                                                                                                                                                                                  overrideReportedSchema?: string;

                                                                                                                                                                                                                                    property privateHeaders

                                                                                                                                                                                                                                    privateHeaders?: Array<String> | boolean;

                                                                                                                                                                                                                                      property privateVariables

                                                                                                                                                                                                                                      privateVariables?: Array<String> | boolean;

                                                                                                                                                                                                                                        property reportErrorFunction

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

                                                                                                                                                                                                                                          property reportIntervalMs

                                                                                                                                                                                                                                          reportIntervalMs?: number;

                                                                                                                                                                                                                                            property reportSchema

                                                                                                                                                                                                                                            reportSchema?: boolean;

                                                                                                                                                                                                                                              property reportTiming

                                                                                                                                                                                                                                              reportTiming?: ReportTimingOptions<TContext>;

                                                                                                                                                                                                                                                property requestAgent

                                                                                                                                                                                                                                                requestAgent?: RequestAgent | false;

                                                                                                                                                                                                                                                  property rewriteError

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

                                                                                                                                                                                                                                                    property schemaReportingInitialDelayMaxMs

                                                                                                                                                                                                                                                    schemaReportingInitialDelayMaxMs?: number;

                                                                                                                                                                                                                                                      property schemaReportingUrl

                                                                                                                                                                                                                                                      schemaReportingUrl?: string;

                                                                                                                                                                                                                                                        property schemaTag

                                                                                                                                                                                                                                                        schemaTag?: string;

                                                                                                                                                                                                                                                          property sendHeaders

                                                                                                                                                                                                                                                          sendHeaders?: SendValuesBaseOptions;

                                                                                                                                                                                                                                                            property sendReportsImmediately

                                                                                                                                                                                                                                                            sendReportsImmediately?: boolean;

                                                                                                                                                                                                                                                              property sendVariableValues

                                                                                                                                                                                                                                                              sendVariableValues?: VariableValueOptions;

                                                                                                                                                                                                                                                                property tracesEndpointUrl

                                                                                                                                                                                                                                                                tracesEndpointUrl?: string;

                                                                                                                                                                                                                                                                  interface FileUploadOptions

                                                                                                                                                                                                                                                                  interface FileUploadOptions {}

                                                                                                                                                                                                                                                                    property maxFieldSize

                                                                                                                                                                                                                                                                    maxFieldSize?: number;

                                                                                                                                                                                                                                                                      property maxFiles

                                                                                                                                                                                                                                                                      maxFiles?: number;

                                                                                                                                                                                                                                                                        property maxFileSize

                                                                                                                                                                                                                                                                        maxFileSize?: number;

                                                                                                                                                                                                                                                                          interface GraphQLOptions

                                                                                                                                                                                                                                                                          interface GraphQLServerOptions<TContext = Record<string, any>, TRootValue = any> {}

                                                                                                                                                                                                                                                                            property cache

                                                                                                                                                                                                                                                                            cache?: KeyValueCache;

                                                                                                                                                                                                                                                                              property cacheControl

                                                                                                                                                                                                                                                                              cacheControl?: CacheControlExtensionOptions;

                                                                                                                                                                                                                                                                                property context

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

                                                                                                                                                                                                                                                                                  property dataSources

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

                                                                                                                                                                                                                                                                                    property debug

                                                                                                                                                                                                                                                                                    debug?: boolean;

                                                                                                                                                                                                                                                                                      property documentStore

                                                                                                                                                                                                                                                                                      documentStore?: InMemoryLRUCache<DocumentNode>;

                                                                                                                                                                                                                                                                                        property executor

                                                                                                                                                                                                                                                                                        executor?: GraphQLExecutor;

                                                                                                                                                                                                                                                                                          property extensions

                                                                                                                                                                                                                                                                                          extensions?: Array<() => GraphQLExtension>;

                                                                                                                                                                                                                                                                                            property fieldResolver

                                                                                                                                                                                                                                                                                            fieldResolver?: GraphQLFieldResolver<any, TContext>;

                                                                                                                                                                                                                                                                                              property formatError

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

                                                                                                                                                                                                                                                                                                property formatResponse

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

                                                                                                                                                                                                                                                                                                  property logger

                                                                                                                                                                                                                                                                                                  logger?: Logger;

                                                                                                                                                                                                                                                                                                    property parseOptions

                                                                                                                                                                                                                                                                                                    parseOptions?: GraphQLParseOptions;

                                                                                                                                                                                                                                                                                                      property persistedQueries

                                                                                                                                                                                                                                                                                                      persistedQueries?: PersistedQueryOptions;

                                                                                                                                                                                                                                                                                                        property plugins

                                                                                                                                                                                                                                                                                                        plugins?: ApolloServerPlugin[];

                                                                                                                                                                                                                                                                                                          property rootValue

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

                                                                                                                                                                                                                                                                                                            property schema

                                                                                                                                                                                                                                                                                                            schema: GraphQLSchema;

                                                                                                                                                                                                                                                                                                              property schemaHash

                                                                                                                                                                                                                                                                                                              schemaHash: SchemaHash;

                                                                                                                                                                                                                                                                                                                property tracing

                                                                                                                                                                                                                                                                                                                tracing?: boolean;

                                                                                                                                                                                                                                                                                                                  property validationRules

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

                                                                                                                                                                                                                                                                                                                    interface GraphQLService

                                                                                                                                                                                                                                                                                                                    interface GraphQLService {}

                                                                                                                                                                                                                                                                                                                      method executor

                                                                                                                                                                                                                                                                                                                      executor: <TContext>(requestContext: any) => any;

                                                                                                                                                                                                                                                                                                                        method load

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

                                                                                                                                                                                                                                                                                                                          method onSchemaChange

                                                                                                                                                                                                                                                                                                                          onSchemaChange: (callback: SchemaChangeCallback) => Unsubscriber;

                                                                                                                                                                                                                                                                                                                            method stop

                                                                                                                                                                                                                                                                                                                            stop: () => Promise<void>;

                                                                                                                                                                                                                                                                                                                              interface HttpQueryRequest

                                                                                                                                                                                                                                                                                                                              interface HttpQueryRequest {}

                                                                                                                                                                                                                                                                                                                                property method

                                                                                                                                                                                                                                                                                                                                method: string;

                                                                                                                                                                                                                                                                                                                                  property options

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

                                                                                                                                                                                                                                                                                                                                    property query

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

                                                                                                                                                                                                                                                                                                                                      property request

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

                                                                                                                                                                                                                                                                                                                                        interface PersistedQueryOptions

                                                                                                                                                                                                                                                                                                                                        interface PersistedQueryOptions {}

                                                                                                                                                                                                                                                                                                                                          property cache

                                                                                                                                                                                                                                                                                                                                          cache?: KeyValueCache;

                                                                                                                                                                                                                                                                                                                                            property ttl

                                                                                                                                                                                                                                                                                                                                            ttl?: number | null;

                                                                                                                                                                                                                                                                                                                                              interface SubscriptionServerOptions

                                                                                                                                                                                                                                                                                                                                              interface SubscriptionServerOptions {}

                                                                                                                                                                                                                                                                                                                                                property keepAlive

                                                                                                                                                                                                                                                                                                                                                keepAlive?: number;

                                                                                                                                                                                                                                                                                                                                                  property onConnect

                                                                                                                                                                                                                                                                                                                                                  onConnect?: (
                                                                                                                                                                                                                                                                                                                                                  connectionParams: Object,
                                                                                                                                                                                                                                                                                                                                                  websocket: WebSocket,
                                                                                                                                                                                                                                                                                                                                                  context: ConnectionContext
                                                                                                                                                                                                                                                                                                                                                  ) => any;

                                                                                                                                                                                                                                                                                                                                                    property onDisconnect

                                                                                                                                                                                                                                                                                                                                                    onDisconnect?: (websocket: WebSocket, context: ConnectionContext) => any;

                                                                                                                                                                                                                                                                                                                                                      property path

                                                                                                                                                                                                                                                                                                                                                      path: string;

                                                                                                                                                                                                                                                                                                                                                        Type Aliases

                                                                                                                                                                                                                                                                                                                                                        type Context

                                                                                                                                                                                                                                                                                                                                                        type Context<T = object> = T;

                                                                                                                                                                                                                                                                                                                                                          type ContextFunction

                                                                                                                                                                                                                                                                                                                                                          type ContextFunction<FunctionParams = any, ProducedContext = object> = (
                                                                                                                                                                                                                                                                                                                                                          context: FunctionParams
                                                                                                                                                                                                                                                                                                                                                          ) => ValueOrPromise<Context<ProducedContext>>;

                                                                                                                                                                                                                                                                                                                                                            type GenerateClientInfo

                                                                                                                                                                                                                                                                                                                                                            type GenerateClientInfo<TContext> = (
                                                                                                                                                                                                                                                                                                                                                            requestContext: GraphQLRequestContext<TContext>
                                                                                                                                                                                                                                                                                                                                                            ) => ClientInfo;

                                                                                                                                                                                                                                                                                                                                                              type GraphQLServiceConfig

                                                                                                                                                                                                                                                                                                                                                              type GraphQLServiceConfig = {
                                                                                                                                                                                                                                                                                                                                                              schema: GraphQLSchema;
                                                                                                                                                                                                                                                                                                                                                              executor: GraphQLExecutor;
                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                type GraphQLServiceEngineConfig

                                                                                                                                                                                                                                                                                                                                                                type GraphQLServiceEngineConfig = {
                                                                                                                                                                                                                                                                                                                                                                apiKeyHash: string;
                                                                                                                                                                                                                                                                                                                                                                graphId: string;
                                                                                                                                                                                                                                                                                                                                                                graphVariant?: string;
                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                  type PlaygroundConfig

                                                                                                                                                                                                                                                                                                                                                                  type PlaygroundConfig = RecursivePartial<PlaygroundRenderPageOptions> | boolean;

                                                                                                                                                                                                                                                                                                                                                                    type PluginDefinition

                                                                                                                                                                                                                                                                                                                                                                    type PluginDefinition = ApolloServerPlugin | (() => ApolloServerPlugin);

                                                                                                                                                                                                                                                                                                                                                                      type SchemaChangeCallback

                                                                                                                                                                                                                                                                                                                                                                      type SchemaChangeCallback = (schema: GraphQLSchema) => void;

                                                                                                                                                                                                                                                                                                                                                                        type SendValuesBaseOptions

                                                                                                                                                                                                                                                                                                                                                                        type SendValuesBaseOptions =
                                                                                                                                                                                                                                                                                                                                                                        | {
                                                                                                                                                                                                                                                                                                                                                                        onlyNames: Array<String>;
                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                        | {
                                                                                                                                                                                                                                                                                                                                                                        exceptNames: Array<String>;
                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                        | {
                                                                                                                                                                                                                                                                                                                                                                        all: true;
                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                        | {
                                                                                                                                                                                                                                                                                                                                                                        none: true;
                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                          type Unsubscriber

                                                                                                                                                                                                                                                                                                                                                                          type Unsubscriber = () => void;

                                                                                                                                                                                                                                                                                                                                                                            type VariableValueOptions

                                                                                                                                                                                                                                                                                                                                                                            type VariableValueOptions =
                                                                                                                                                                                                                                                                                                                                                                            | {
                                                                                                                                                                                                                                                                                                                                                                            transform: (options: VariableValueTransformOptions) => Record<string, any>;
                                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                                            | SendValuesBaseOptions;

                                                                                                                                                                                                                                                                                                                                                                              Package Files (13)

                                                                                                                                                                                                                                                                                                                                                                              Dependencies (25)

                                                                                                                                                                                                                                                                                                                                                                              Dev Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                              No dev dependencies.

                                                                                                                                                                                                                                                                                                                                                                              Peer Dependencies (1)

                                                                                                                                                                                                                                                                                                                                                                              Badge

                                                                                                                                                                                                                                                                                                                                                                              To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                                                                                                                                                                              You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/apollo-server-core.

                                                                                                                                                                                                                                                                                                                                                                              • Markdown
                                                                                                                                                                                                                                                                                                                                                                                [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/apollo-server-core)
                                                                                                                                                                                                                                                                                                                                                                              • HTML
                                                                                                                                                                                                                                                                                                                                                                                <a href="https://www.jsdocs.io/package/apollo-server-core"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>