initial update

node_modules/@apollo/server/README.md

@@ -0,0 +1,158 @@
+# `@apollo/server`
+
+> This `@apollo/server` package is new with Apollo Server 4. Previous major versions of Apollo Server used a set of package names starting with `apollo-server`, such as `apollo-server`, `apollo-server-express`, `apollo-server-core`, etc.
+
+[![npm version](https://badge.fury.io/js/%40apollo%2Fserver.svg)](https://badge.fury.io/js/%40apollo%2Fserver)
+[![Build Status](https://circleci.com/gh/apollographql/apollo-server.svg?style=svg)](https://circleci.com/gh/apollographql/apollo-server)
+[![Join the community](https://img.shields.io/discourse/status?label=Join%20the%20community&server=https%3A%2F%2Fcommunity.apollographql.com)](https://community.apollographql.com)
+
+---
+
+**Announcement:**
+Join 1000+ engineers at GraphQL Summit 2025 by Apollo for talks, workshops, and office hours. Oct 6-8, 2025 in San Francisco. [Get your pass here ->](https://www.apollographql.com/graphql-summit-2025?utm_campaign=2025-03-04_graphql-summit-github-announcement&utm_medium=github&utm_source=apollo-server)
+
+---
+
+## A TypeScript/JavaScript GraphQL server
+
+**Apollo Server is an [open-source](https://github.com/apollographql/apollo-server), spec-compliant GraphQL server** that's compatible with any GraphQL client, including [Apollo Client](https://www.apollographql.com/docs/react). It's the best way to build a production-ready, self-documenting GraphQL API that can use data from any source.
+
+
+You can use Apollo Server as:
+
+* A stand-alone GraphQL server
+* The GraphQL server for a [subgraph](https://www.apollographql.com/docs/federation/subgraphs/) in a federated supergraph
+* The gateway for a [federated supergraph](https://www.apollographql.com/docs/federation/)
+
+Apollo Server provides a simple API for integrating with any Node.js web framework or serverless environment. The `@apollo/server` package itself ships with a minimally-configurable, standalone web server which handles CORS and body parsing out of the box. Integrations with other environments are community-maintained.
+
+Apollo Server provides:
+
+*  **Straightforward setup**, so your client developers can start fetching data quickly
+*  **Incremental adoption**, enabling you to add features as they're needed
+*  **Universal compatibility** with any data source, any build tool, and any GraphQL client
+*  **Production readiness**, enabling you to confidently run your graph in production
+
+## Documentation
+
+Full documentation for Apollo Server is available on [our documentation site](https://www.apollographql.com/docs/apollo-server/). This README shows the basics of getting a server running (both standalone and with Express), but most features are only documented on our docs site.
+
+
+## Getting started: standalone server
+
+> You can also check out the [getting started](https://www.apollographql.com/docs/apollo-server/getting-started) guide in the Apollo Server docs for more details, including examples in both TypeScript and JavaScript.
+
+Apollo Server's standalone server lets you get a GraphQL server up and running quickly without needing to set up an HTTP server yourself. It allows all the same configuration of GraphQL logic as the Express integration, but does not provide the ability to make fine-grained tweaks to the HTTP-specific behavior of your server.
+
+First, install Apollo Server and the JavaScript implementation of the core GraphQL algorithms:
+
+```
+npm install @apollo/server graphql
+```
+
+Then, write the following to `server.mjs`. (By using the `.mjs` extension, Node lets you use the `await` keyword at the top level.)
+
+```js
+import { ApolloServer } from '@apollo/server';
+import { startStandaloneServer } from '@apollo/server/standalone';
+
+// The GraphQL schema
+const typeDefs = `#graphql
+  type Query {
+    hello: String
+  }
+`;
+
+// A map of functions which return data for the schema.
+const resolvers = {
+  Query: {
+    hello: () => 'world',
+  },
+};
+
+const server = new ApolloServer({
+  typeDefs,
+  resolvers,
+});
+
+const { url } = await startStandaloneServer(server);
+console.log(`🚀 Server ready at ${url}`);
+```
+
+Now run your server with:
+
+```
+node server.mjs
+```
+
+Open the URL it prints in a web browser. It will show [Apollo Sandbox](https://www.apollographql.com/docs/studio/explorer/sandbox/), a web-based tool for running GraphQL operations. Try running the operation `query { hello }`!
+
+
+## Getting started: Express middleware
+
+Apollo Server's Express middleware lets you run your GraphQL server as part of an app built with [Express](https://expressjs.com/), the most popular web framework for Node.
+
+First, install Apollo Server, its Express middleware, the JavaScript implementation of the core GraphQL algorithms, Express, and the standard Express middleware package for CORS headers:
+
+```
+npm install @apollo/server @as-integrations/express5 graphql express cors
+```
+
+If using Typescript you may also need to install additional type declaration packages as development dependencies to avoid common errors when importing the above packages (i.e. Could not find a declaration file for module '`cors`'):
+
+```
+npm install --save-dev @types/cors @types/express
+```
+
+Then, write the following to `server.mjs`. (By using the `.mjs` extension, Node lets you use the `await` keyword at the top level.)
+
+```js
+import { ApolloServer } from '@apollo/server';
+import { expressMiddleware } from '@as-integrations/express5';
+import { ApolloServerPluginDrainHttpServer } from '@apollo/server/plugin/drainHttpServer'
+import express from 'express';
+import http from 'http';
+import cors from 'cors';
+
+// The GraphQL schema
+const typeDefs = `#graphql
+  type Query {
+    hello: String
+  }
+`;
+
+// A map of functions which return data for the schema.
+const resolvers = {
+  Query: {
+    hello: () => 'world',
+  },
+};
+
+const app = express();
+const httpServer = http.createServer(app);
+
+// Set up Apollo Server
+const server = new ApolloServer({
+  typeDefs,
+  resolvers,
+  plugins: [ApolloServerPluginDrainHttpServer({ httpServer })],
+});
+await server.start();
+
+app.use(
+  cors(),
+  express.json(),
+  expressMiddleware(server),
+);
+
+await new Promise((resolve) => httpServer.listen({ port: 4000 }, resolve));
+console.log(`🚀 Server ready at http://localhost:4000`);
+```
+
+Now run your server with:
+
+```
+node server.mjs
+```
+
+Open the URL it prints in a web browser. It will show [Apollo Sandbox](https://www.apollographql.com/docs/studio/explorer/sandbox/), a web-based tool for running GraphQL operations. Try running the operation `query { hello }`!

node_modules/@apollo/server/dist/cjs/ApolloServer.d.ts

@@ -0,0 +1,120 @@
+import type { GatewayExecutor } from '@apollo/server-gateway-interface';
+import { type KeyValueCache } from '@apollo/utils.keyvaluecache';
+import type { Logger } from '@apollo/utils.logger';
+import type { WithRequired } from '@apollo/utils.withrequired';
+import { type Resolvable } from './utils/resolvable.js';
+import { type DocumentNode, type FormattedExecutionResult, type GraphQLFieldResolver, type GraphQLFormattedError, type GraphQLSchema, type ParseOptions, type TypedQueryDocumentNode, type ValidationRule } from 'graphql';
+import type { ExecuteOperationOptions, VariableValues } from './externalTypes/graphql.js';
+import type { ApolloConfig, ApolloServerOptions, ApolloServerPlugin, BaseContext, ContextThunk, DocumentStore, GraphQLRequest, GraphQLResponse, HTTPGraphQLHead, HTTPGraphQLRequest, HTTPGraphQLResponse, LandingPage, PersistedQueryOptions } from './externalTypes/index.js';
+import type { GraphQLExperimentalIncrementalExecutionResults } from './incrementalDeliveryPolyfill.js';
+import { SchemaManager } from './utils/schemaManager.js';
+export type SchemaDerivedData = {
+    schema: GraphQLSchema;
+    documentStore: DocumentStore | null;
+    documentStoreKeyPrefix: string;
+};
+type RunningServerState = {
+    schemaManager: SchemaManager;
+    landingPage: LandingPage | null;
+};
+type ServerState = {
+    phase: 'initialized';
+    schemaManager: SchemaManager;
+} | {
+    phase: 'starting';
+    barrier: Resolvable<void>;
+    schemaManager: SchemaManager;
+    startedInBackground: boolean;
+} | {
+    phase: 'failed to start';
+    error: Error;
+} | ({
+    phase: 'started';
+    drainServers: (() => Promise<void>) | null;
+    toDispose: (() => Promise<void>)[];
+    toDisposeLast: (() => Promise<void>)[];
+} & RunningServerState) | ({
+    phase: 'draining';
+    barrier: Resolvable<void>;
+} & RunningServerState) | {
+    phase: 'stopping';
+    barrier: Resolvable<void>;
+} | {
+    phase: 'stopped';
+    stopError: Error | null;
+};
+export interface ApolloServerInternals<TContext extends BaseContext> {
+    state: ServerState;
+    gatewayExecutor: GatewayExecutor | null;
+    dangerouslyDisableValidation?: boolean;
+    formatError?: (formattedError: GraphQLFormattedError, error: unknown) => GraphQLFormattedError;
+    includeStacktraceInErrorResponses: boolean;
+    persistedQueries?: WithRequired<PersistedQueryOptions, 'cache'>;
+    nodeEnv: string;
+    allowBatchedHttpRequests: boolean;
+    apolloConfig: ApolloConfig;
+    plugins: ApolloServerPlugin<TContext>[];
+    parseOptions: ParseOptions;
+    stopOnTerminationSignals: boolean | undefined;
+    csrfPreventionRequestHeaders: string[] | null;
+    rootValue?: ((parsedQuery: DocumentNode) => unknown) | unknown;
+    validationRules: Array<ValidationRule>;
+    laterValidationRules?: Array<ValidationRule>;
+    hideSchemaDetailsFromClientErrors: boolean;
+    fieldResolver?: GraphQLFieldResolver<any, TContext>;
+    status400ForVariableCoercionErrors?: boolean;
+    __testing_incrementalExecutionResults?: GraphQLExperimentalIncrementalExecutionResults;
+    stringifyResult: (value: FormattedExecutionResult) => string | Promise<string>;
+}
+export declare class ApolloServer<in out TContext extends BaseContext = BaseContext> {
+    private internals;
+    readonly cache: KeyValueCache<string>;
+    readonly logger: Logger;
+    constructor(config: ApolloServerOptions<TContext>);
+    start(): Promise<void>;
+    startInBackgroundHandlingStartupErrorsByLoggingAndFailingAllRequests(): void;
+    private _start;
+    private maybeRegisterTerminationSignalHandlers;
+    private _ensureStarted;
+    assertStarted(expressionForError: string): void;
+    private logStartupError;
+    private static constructSchema;
+    private static generateSchemaDerivedData;
+    stop(): Promise<void>;
+    private addDefaultPlugins;
+    addPlugin(plugin: ApolloServerPlugin<TContext>): void;
+    executeHTTPGraphQLRequest({ httpGraphQLRequest, context, }: {
+        httpGraphQLRequest: HTTPGraphQLRequest;
+        context: ContextThunk<TContext>;
+    }): Promise<HTTPGraphQLResponse>;
+    private errorResponse;
+    private prefersHTML;
+    executeOperation<TData = Record<string, unknown>, TVariables extends VariableValues = VariableValues>(this: ApolloServer<BaseContext>, request: Omit<GraphQLRequest<TVariables>, 'query'> & {
+        query?: string | DocumentNode | TypedQueryDocumentNode<TData, TVariables>;
+    }): Promise<GraphQLResponse<TData>>;
+    executeOperation<TData = Record<string, unknown>, TVariables extends VariableValues = VariableValues>(request: Omit<GraphQLRequest<TVariables>, 'query'> & {
+        query?: string | DocumentNode | TypedQueryDocumentNode<TData, TVariables>;
+    }, options?: ExecuteOperationOptions<TContext>): Promise<GraphQLResponse<TData>>;
+}
+export declare function internalExecuteOperation<TContext extends BaseContext>({ server, graphQLRequest, internals, schemaDerivedData, sharedResponseHTTPGraphQLHead, }: {
+    server: ApolloServer<TContext>;
+    graphQLRequest: GraphQLRequest;
+    internals: ApolloServerInternals<TContext>;
+    schemaDerivedData: SchemaDerivedData;
+    sharedResponseHTTPGraphQLHead: HTTPGraphQLHead | null;
+}, options: ExecuteOperationOptions<TContext>): Promise<GraphQLResponse>;
+export type ImplicitlyInstallablePlugin<TContext extends BaseContext> = ApolloServerPlugin<TContext> & {
+    __internal_installed_implicitly__: boolean;
+};
+export declare function isImplicitlyInstallablePlugin<TContext extends BaseContext>(p: ApolloServerPlugin<TContext>): p is ImplicitlyInstallablePlugin<TContext>;
+export declare const MEDIA_TYPES: {
+    APPLICATION_JSON: string;
+    APPLICATION_JSON_GRAPHQL_CALLBACK: string;
+    APPLICATION_GRAPHQL_RESPONSE_JSON: string;
+    MULTIPART_MIXED_NO_DEFER_SPEC: string;
+    MULTIPART_MIXED_EXPERIMENTAL: string;
+    TEXT_HTML: string;
+};
+export declare function chooseContentTypeForSingleResultResponse(head: HTTPGraphQLHead): string | null;
+export {};
+//# sourceMappingURL=ApolloServer.d.ts.map

node_modules/@apollo/server/dist/cjs/ApolloServer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApolloServer.d.ts","sourceRoot":"","sources":["../../src/ApolloServer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AAExE,OAAO,EAGL,KAAK,aAAa,EACnB,MAAM,6BAA6B,CAAC;AACrC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAE/D,OAAmB,EAAE,KAAK,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACpE,OAAO,EAKL,KAAK,YAAY,EACjB,KAAK,wBAAwB,EAC7B,KAAK,oBAAoB,EACzB,KAAK,qBAAqB,EAC1B,KAAK,aAAa,EAClB,KAAK,YAAY,EACjB,KAAK,sBAAsB,EAC3B,KAAK,cAAc,EACpB,MAAM,SAAS,CAAC;AAYjB,OAAO,KAAK,EACV,uBAAuB,EACvB,cAAc,EACf,MAAM,4BAA4B,CAAC;AACpC,OAAO,KAAK,EACV,YAAY,EACZ,mBAAmB,EACnB,kBAAkB,EAClB,WAAW,EACX,YAAY,EACZ,aAAa,EACb,cAAc,EAEd,eAAe,EAGf,eAAe,EACf,kBAAkB,EAClB,mBAAmB,EACnB,WAAW,EACX,qBAAqB,EACtB,MAAM,0BAA0B,CAAC;AAElC,OAAO,KAAK,EAAE,8CAA8C,EAAE,MAAM,kCAAkC,CAAC;AAYvG,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAOzD,MAAM,MAAM,iBAAiB,GAAG;IAC9B,MAAM,EAAE,aAAa,CAAC;IAItB,aAAa,EAAE,aAAa,GAAG,IAAI,CAAC;IAMpC,sBAAsB,EAAE,MAAM,CAAC;CAChC,CAAC;AAEF,KAAK,kBAAkB,GAAG;IACxB,aAAa,EAAE,aAAa,CAAC;IAC7B,WAAW,EAAE,WAAW,GAAG,IAAI,CAAC;CACjC,CAAC;AAEF,KAAK,WAAW,GACZ;IACE,KAAK,EAAE,aAAa,CAAC;IACrB,aAAa,EAAE,aAAa,CAAC;CAC9B,GACD;IACE,KAAK,EAAE,UAAU,CAAC;IAClB,OAAO,EAAE,UAAU,CAAC,IAAI,CAAC,CAAC;IAC1B,aAAa,EAAE,aAAa,CAAC;IAM7B,mBAAmB,EAAE,OAAO,CAAC;CAC9B,GACD;IACE,KAAK,EAAE,iBAAiB,CAAC;IACzB,KAAK,EAAE,KAAK,CAAC;CACd,GACD,CAAC;IACC,KAAK,EAAE,SAAS,CAAC;IACjB,YAAY,EAAE,CAAC,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC;IAC3C,SAAS,EAAE,CAAC,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC;IACnC,aAAa,EAAE,CAAC,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC;CACxC,GAAG,kBAAkB,CAAC,GACvB,CAAC;IACC,KAAK,EAAE,UAAU,CAAC;IAClB,OAAO,EAAE,UAAU,CAAC,IAAI,CAAC,CAAC;CAC3B,GAAG,kBAAkB,CAAC,GACvB;IACE,KAAK,EAAE,UAAU,CAAC;IAClB,OAAO,EAAE,UAAU,CAAC,IAAI,CAAC,CAAC;CAC3B,GACD;IACE,KAAK,EAAE,SAAS,CAAC;IACjB,SAAS,EAAE,KAAK,GAAG,IAAI,CAAC;CACzB,CAAC;AAEN,MAAM,WAAW,qBAAqB,CAAC,QAAQ,SAAS,WAAW;IACjE,KAAK,EAAE,WAAW,CAAC;IACnB,eAAe,EAAE,eAAe,GAAG,IAAI,CAAC;IACxC,4BAA4B,CAAC,EAAE,OAAO,CAAC;IACvC,WAAW,CAAC,EAAE,CACZ,cAAc,EAAE,qBAAqB,EACrC,KAAK,EAAE,OAAO,KACX,qBAAqB,CAAC;IAC3B,iCAAiC,EAAE,OAAO,CAAC;IAC3C,gBAAgB,CAAC,EAAE,YAAY,CAAC,qBAAqB,EAAE,OAAO,CAAC,CAAC;IAChE,OAAO,EAAE,MAAM,CAAC;IAChB,wBAAwB,EAAE,OAAO,CAAC;IAClC,YAAY,EAAE,YAAY,CAAC;IAC3B,OAAO,EAAE,kBAAkB,CAAC,QAAQ,CAAC,EAAE,CAAC;IACxC,YAAY,EAAE,YAAY,CAAC;IAI3B,wBAAwB,EAAE,OAAO,GAAG,SAAS,CAAC;IAC9C,4BAA4B,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;IAE9C,SAAS,CAAC,EAAE,CAAC,CAAC,WAAW,EAAE,YAAY,KAAK,OAAO,CAAC,GAAG,OAAO,CAAC;IAC/D,eAAe,EAAE,KAAK,CAAC,cAAc,CAAC,CAAC;IACvC,oBAAoB,CAAC,EAAE,KAAK,CAAC,cAAc,CAAC,CAAC;IAC7C,iCAAiC,EAAE,OAAO,CAAC;IAC3C,aAAa,CAAC,EAAE,oBAAoB,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC;IAGpD,kCAAkC,CAAC,EAAE,OAAO,CAAC;IAC7C,qCAAqC,CAAC,EAAE,8CAA8C,CAAC;IACvF,eAAe,EAAE,CACf,KAAK,EAAE,wBAAwB,KAC5B,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;CAC/B;AA6BD,qBAAa,YAAY,CAAC,EAAE,CAAC,GAAG,CAAC,QAAQ,SAAS,WAAW,GAAG,WAAW;IACzE,OAAO,CAAC,SAAS,CAAkC;IAEnD,SAAgB,KAAK,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAC7C,SAAgB,MAAM,EAAE,MAAM,CAAC;gBAEnB,MAAM,EAAE,mBAAmB,CAAC,QAAQ,CAAC;IA4KpC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAI5B,oEAAoE,IAAI,IAAI;YAIrE,MAAM;IAsJpB,OAAO,CAAC,sCAAsC;YAsEhC,cAAc;IAgErB,aAAa,CAAC,kBAAkB,EAAE,MAAM;IAwB/C,OAAO,CAAC,eAAe;IAQvB,OAAO,CAAC,MAAM,CAAC,eAAe;IAsB9B,OAAO,CAAC,MAAM,CAAC,yBAAyB;IAoC3B,IAAI;YAoFH,iBAAiB;IAkLxB,SAAS,CAAC,MAAM,EAAE,kBAAkB,CAAC,QAAQ,CAAC;IAOxC,yBAAyB,CAAC,EACrC,kBAAkB,EAClB,OAAO,GACR,EAAE;QACD,kBAAkB,EAAE,kBAAkB,CAAC;QACvC,OAAO,EAAE,YAAY,CAAC,QAAQ,CAAC,CAAC;KACjC,GAAG,OAAO,CAAC,mBAAmB,CAAC;YAwGlB,aAAa;IAuC3B,OAAO,CAAC,WAAW;IAwCN,gBAAgB,CAC3B,KAAK,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,UAAU,SAAS,cAAc,GAAG,cAAc,EAElD,IAAI,EAAE,YAAY,CAAC,WAAW,CAAC,EAC/B,OAAO,EAAE,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC,GAAG;QACnD,KAAK,CAAC,EAAE,MAAM,GAAG,YAAY,GAAG,sBAAsB,CAAC,KAAK,EAAE,UAAU,CAAC,CAAC;KAC3E,GACA,OAAO,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC;IACrB,gBAAgB,CAC3B,KAAK,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,UAAU,SAAS,cAAc,GAAG,cAAc,EAElD,OAAO,EAAE,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC,GAAG;QACnD,KAAK,CAAC,EAAE,MAAM,GAAG,YAAY,GAAG,sBAAsB,CAAC,KAAK,EAAE,UAAU,CAAC,CAAC;KAC3E,EACD,OAAO,CAAC,EAAE,uBAAuB,CAAC,QAAQ,CAAC,GAC1C,OAAO,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC;CAkDnC;AAID,wBAAsB,wBAAwB,CAAC,QAAQ,SAAS,WAAW,EACzE,EACE,MAAM,EACN,cAAc,EACd,SAAS,EACT,iBAAiB,EACjB,6BAA6B,GAC9B,EAAE;IACD,MAAM,EAAE,YAAY,CAAC,QAAQ,CAAC,CAAC;IAC/B,cAAc,EAAE,cAAc,CAAC;IAC/B,SAAS,EAAE,qBAAqB,CAAC,QAAQ,CAAC,CAAC;IAC3C,iBAAiB,EAAE,iBAAiB,CAAC;IACrC,6BAA6B,EAAE,eAAe,GAAG,IAAI,CAAC;CACvD,EACD,OAAO,EAAE,uBAAuB,CAAC,QAAQ,CAAC,GACzC,OAAO,CAAC,eAAe,CAAC,CAuD1B;AAQD,MAAM,MAAM,2BAA2B,CAAC,QAAQ,SAAS,WAAW,IAClE,kBAAkB,CAAC,QAAQ,CAAC,GAAG;IAC7B,iCAAiC,EAAE,OAAO,CAAC;CAC5C,CAAC;AAEJ,wBAAgB,6BAA6B,CAAC,QAAQ,SAAS,WAAW,EACxE,CAAC,EAAE,kBAAkB,CAAC,QAAQ,CAAC,GAC9B,CAAC,IAAI,2BAA2B,CAAC,QAAQ,CAAC,CAE5C;AAED,eAAO,MAAM,WAAW;;;;;;;CAWvB,CAAC;AAEF,wBAAgB,wCAAwC,CACtD,IAAI,EAAE,eAAe,GACpB,MAAM,GAAG,IAAI,CAqBf"}

node_modules/@apollo/server/dist/cjs/ApolloServer.js

@@ -0,0 +1,697 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chooseContentTypeForSingleResultResponse = exports.MEDIA_TYPES = exports.isImplicitlyInstallablePlugin = exports.internalExecuteOperation = exports.ApolloServer = void 0;
+const utils_isnodelike_1 = require("@apollo/utils.isnodelike");
+const utils_keyvaluecache_1 = require("@apollo/utils.keyvaluecache");
+const schema_1 = require("@graphql-tools/schema");
+const resolvable_js_1 = __importDefault(require("./utils/resolvable.js"));
+const graphql_1 = require("graphql");
+const loglevel_1 = __importDefault(require("loglevel"));
+const negotiator_1 = __importDefault(require("negotiator"));
+const cachePolicy_js_1 = require("./cachePolicy.js");
+const determineApolloConfig_js_1 = require("./determineApolloConfig.js");
+const errorNormalize_js_1 = require("./errorNormalize.js");
+const index_js_1 = require("./errors/index.js");
+const httpBatching_js_1 = require("./httpBatching.js");
+const internalPlugin_js_1 = require("./internalPlugin.js");
+const preventCsrf_js_1 = require("./preventCsrf.js");
+const requestPipeline_js_1 = require("./requestPipeline.js");
+const runHttpQuery_js_1 = require("./runHttpQuery.js");
+const HeaderMap_js_1 = require("./utils/HeaderMap.js");
+const UnreachableCaseError_js_1 = require("./utils/UnreachableCaseError.js");
+const computeCoreSchemaHash_js_1 = require("./utils/computeCoreSchemaHash.js");
+const isDefined_js_1 = require("./utils/isDefined.js");
+const schemaManager_js_1 = require("./utils/schemaManager.js");
+const index_js_2 = require("./validationRules/index.js");
+function defaultLogger() {
+    const loglevelLogger = loglevel_1.default.getLogger('apollo-server');
+    loglevelLogger.setLevel(loglevel_1.default.levels.INFO);
+    return loglevelLogger;
+}
+class ApolloServer {
+    constructor(config) {
+        const nodeEnv = config.nodeEnv ?? process.env.NODE_ENV ?? '';
+        this.logger = config.logger ?? defaultLogger();
+        const apolloConfig = (0, determineApolloConfig_js_1.determineApolloConfig)(config.apollo, this.logger);
+        const isDev = nodeEnv !== 'production';
+        if (config.cache &&
+            config.cache !== 'bounded' &&
+            utils_keyvaluecache_1.PrefixingKeyValueCache.prefixesAreUnnecessaryForIsolation(config.cache)) {
+            throw new Error('You cannot pass a cache returned from ' +
+                '`PrefixingKeyValueCache.cacheDangerouslyDoesNotNeedPrefixesForIsolation`' +
+                'to `new ApolloServer({ cache })`, because Apollo Server may use it for ' +
+                'multiple features whose cache keys must be distinct from each other.');
+        }
+        const state = config.gateway
+            ?
+                {
+                    phase: 'initialized',
+                    schemaManager: new schemaManager_js_1.SchemaManager({
+                        gateway: config.gateway,
+                        apolloConfig,
+                        schemaDerivedDataProvider: (schema) => ApolloServer.generateSchemaDerivedData(schema, config.documentStore),
+                        logger: this.logger,
+                    }),
+                }
+            :
+                {
+                    phase: 'initialized',
+                    schemaManager: new schemaManager_js_1.SchemaManager({
+                        apiSchema: ApolloServer.constructSchema(config),
+                        schemaDerivedDataProvider: (schema) => ApolloServer.generateSchemaDerivedData(schema, config.documentStore),
+                        logger: this.logger,
+                    }),
+                };
+        const introspectionEnabled = config.introspection ?? isDev;
+        const hideSchemaDetailsFromClientErrors = config.hideSchemaDetailsFromClientErrors ?? false;
+        this.cache =
+            config.cache === undefined || config.cache === 'bounded'
+                ? new utils_keyvaluecache_1.InMemoryLRUCache()
+                : config.cache;
+        const maxRecursiveSelectionsRule = config.maxRecursiveSelections === true
+            ? [(0, index_js_2.createMaxRecursiveSelectionsRule)(index_js_2.DEFAULT_MAX_RECURSIVE_SELECTIONS)]
+            : typeof config.maxRecursiveSelections === 'number'
+                ? [(0, index_js_2.createMaxRecursiveSelectionsRule)(config.maxRecursiveSelections)]
+                : [];
+        const validationRules = [
+            ...(introspectionEnabled ? [] : [index_js_2.NoIntrospection]),
+            ...maxRecursiveSelectionsRule,
+        ];
+        let laterValidationRules;
+        if (maxRecursiveSelectionsRule.length > 0) {
+            laterValidationRules = config.validationRules;
+        }
+        else {
+            validationRules.push(...(config.validationRules ?? []));
+        }
+        this.internals = {
+            formatError: config.formatError,
+            rootValue: config.rootValue,
+            validationRules,
+            laterValidationRules,
+            hideSchemaDetailsFromClientErrors,
+            dangerouslyDisableValidation: config.dangerouslyDisableValidation ?? false,
+            fieldResolver: config.fieldResolver,
+            includeStacktraceInErrorResponses: config.includeStacktraceInErrorResponses ??
+                (nodeEnv !== 'production' && nodeEnv !== 'test'),
+            persistedQueries: config.persistedQueries === false
+                ? undefined
+                : {
+                    ...config.persistedQueries,
+                    cache: new utils_keyvaluecache_1.PrefixingKeyValueCache(config.persistedQueries?.cache ?? this.cache, requestPipeline_js_1.APQ_CACHE_PREFIX),
+                },
+            nodeEnv,
+            allowBatchedHttpRequests: config.allowBatchedHttpRequests ?? false,
+            apolloConfig,
+            plugins: config.plugins ?? [],
+            parseOptions: config.parseOptions ?? {},
+            state,
+            stopOnTerminationSignals: config.stopOnTerminationSignals,
+            gatewayExecutor: null,
+            csrfPreventionRequestHeaders: config.csrfPrevention === true || config.csrfPrevention === undefined
+                ? preventCsrf_js_1.recommendedCsrfPreventionRequestHeaders
+                : config.csrfPrevention === false
+                    ? null
+                    : (config.csrfPrevention.requestHeaders ??
+                        preventCsrf_js_1.recommendedCsrfPreventionRequestHeaders),
+            status400ForVariableCoercionErrors: config.status400ForVariableCoercionErrors ?? false,
+            __testing_incrementalExecutionResults: config.__testing_incrementalExecutionResults,
+            stringifyResult: config.stringifyResult ?? runHttpQuery_js_1.prettyJSONStringify,
+        };
+    }
+    async start() {
+        return await this._start(false);
+    }
+    startInBackgroundHandlingStartupErrorsByLoggingAndFailingAllRequests() {
+        this._start(true).catch((e) => this.logStartupError(e));
+    }
+    async _start(startedInBackground) {
+        if (this.internals.state.phase !== 'initialized') {
+            throw new Error(`You should only call 'start()' or ` +
+                `'startInBackgroundHandlingStartupErrorsByLoggingAndFailingAllRequests()' ` +
+                `once on your ApolloServer.`);
+        }
+        const schemaManager = this.internals.state.schemaManager;
+        const barrier = (0, resolvable_js_1.default)();
+        this.internals.state = {
+            phase: 'starting',
+            barrier,
+            schemaManager,
+            startedInBackground,
+        };
+        try {
+            await this.addDefaultPlugins();
+            const toDispose = [];
+            const executor = await schemaManager.start();
+            if (executor) {
+                this.internals.gatewayExecutor = executor;
+            }
+            toDispose.push(async () => {
+                await schemaManager.stop();
+            });
+            const schemaDerivedData = schemaManager.getSchemaDerivedData();
+            const service = {
+                logger: this.logger,
+                cache: this.cache,
+                schema: schemaDerivedData.schema,
+                apollo: this.internals.apolloConfig,
+                startedInBackground,
+            };
+            const taggedServerListeners = (await Promise.all(this.internals.plugins.map(async (plugin) => ({
+                serverListener: plugin.serverWillStart && (await plugin.serverWillStart(service)),
+                installedImplicitly: isImplicitlyInstallablePlugin(plugin) &&
+                    plugin.__internal_installed_implicitly__,
+            })))).filter((maybeTaggedServerListener) => typeof maybeTaggedServerListener.serverListener === 'object');
+            taggedServerListeners.forEach(({ serverListener: { schemaDidLoadOrUpdate } }) => {
+                if (schemaDidLoadOrUpdate) {
+                    schemaManager.onSchemaLoadOrUpdate(schemaDidLoadOrUpdate);
+                }
+            });
+            const serverWillStops = taggedServerListeners
+                .map((l) => l.serverListener.serverWillStop)
+                .filter(isDefined_js_1.isDefined);
+            if (serverWillStops.length) {
+                toDispose.push(async () => {
+                    await Promise.all(serverWillStops.map((serverWillStop) => serverWillStop()));
+                });
+            }
+            const drainServerCallbacks = taggedServerListeners
+                .map((l) => l.serverListener.drainServer)
+                .filter(isDefined_js_1.isDefined);
+            const drainServers = drainServerCallbacks.length
+                ? async () => {
+                    await Promise.all(drainServerCallbacks.map((drainServer) => drainServer()));
+                }
+                : null;
+            let taggedServerListenersWithRenderLandingPage = taggedServerListeners.filter((l) => l.serverListener.renderLandingPage);
+            if (taggedServerListenersWithRenderLandingPage.length > 1) {
+                taggedServerListenersWithRenderLandingPage =
+                    taggedServerListenersWithRenderLandingPage.filter((l) => !l.installedImplicitly);
+            }
+            let landingPage = null;
+            if (taggedServerListenersWithRenderLandingPage.length > 1) {
+                throw Error('Only one plugin can implement renderLandingPage.');
+            }
+            else if (taggedServerListenersWithRenderLandingPage.length) {
+                landingPage =
+                    await taggedServerListenersWithRenderLandingPage[0].serverListener
+                        .renderLandingPage();
+            }
+            const toDisposeLast = this.maybeRegisterTerminationSignalHandlers(['SIGINT', 'SIGTERM'], startedInBackground);
+            this.internals.state = {
+                phase: 'started',
+                schemaManager,
+                drainServers,
+                landingPage,
+                toDispose,
+                toDisposeLast,
+            };
+        }
+        catch (maybeError) {
+            const error = (0, errorNormalize_js_1.ensureError)(maybeError);
+            try {
+                await Promise.all(this.internals.plugins.map(async (plugin) => plugin.startupDidFail?.({ error })));
+            }
+            catch (pluginError) {
+                this.logger.error(`startupDidFail hook threw: ${pluginError}`);
+            }
+            this.internals.state = {
+                phase: 'failed to start',
+                error,
+            };
+            throw error;
+        }
+        finally {
+            barrier.resolve();
+        }
+    }
+    maybeRegisterTerminationSignalHandlers(signals, startedInBackground) {
+        const toDisposeLast = [];
+        if (this.internals.stopOnTerminationSignals === false ||
+            (this.internals.stopOnTerminationSignals === undefined &&
+                !(utils_isnodelike_1.isNodeLike &&
+                    this.internals.nodeEnv !== 'test' &&
+                    !startedInBackground))) {
+            return toDisposeLast;
+        }
+        let receivedSignal = false;
+        const signalHandler = async (signal) => {
+            if (receivedSignal) {
+                return;
+            }
+            receivedSignal = true;
+            try {
+                await this.stop();
+            }
+            catch (e) {
+                this.logger.error(`stop() threw during ${signal} shutdown`);
+                this.logger.error(e);
+                process.exit(1);
+            }
+            process.kill(process.pid, signal);
+        };
+        signals.forEach((signal) => {
+            process.on(signal, signalHandler);
+            toDisposeLast.push(async () => {
+                process.removeListener(signal, signalHandler);
+            });
+        });
+        return toDisposeLast;
+    }
+    async _ensureStarted() {
+        while (true) {
+            switch (this.internals.state.phase) {
+                case 'initialized':
+                    throw new Error('You need to call `server.start()` before using your Apollo Server.');
+                case 'starting':
+                    await this.internals.state.barrier;
+                    break;
+                case 'failed to start':
+                    this.logStartupError(this.internals.state.error);
+                    throw new Error('This data graph is missing a valid configuration. More details may be available in the server logs.');
+                case 'started':
+                case 'draining':
+                    return this.internals.state;
+                case 'stopping':
+                case 'stopped':
+                    this.logger.warn('A GraphQL operation was received during server shutdown. The ' +
+                        'operation will fail. Consider draining the HTTP server on shutdown; ' +
+                        'see https://go.apollo.dev/s/drain for details.');
+                    throw new Error(`Cannot execute GraphQL operations ${this.internals.state.phase === 'stopping'
+                        ? 'while the server is stopping'
+                        : 'after the server has stopped'}.'`);
+                default:
+                    throw new UnreachableCaseError_js_1.UnreachableCaseError(this.internals.state);
+            }
+        }
+    }
+    assertStarted(expressionForError) {
+        if (this.internals.state.phase !== 'started' &&
+            this.internals.state.phase !== 'draining' &&
+            !(this.internals.state.phase === 'starting' &&
+                this.internals.state.startedInBackground)) {
+            throw new Error('You must `await server.start()` before calling `' +
+                expressionForError +
+                '`');
+        }
+    }
+    logStartupError(err) {
+        this.logger.error('An error occurred during Apollo Server startup. All GraphQL requests ' +
+            'will now fail. The startup error was: ' +
+            (err?.message || err));
+    }
+    static constructSchema(config) {
+        if (config.schema) {
+            return config.schema;
+        }
+        const { typeDefs, resolvers } = config;
+        const augmentedTypeDefs = Array.isArray(typeDefs) ? typeDefs : [typeDefs];
+        return (0, schema_1.makeExecutableSchema)({
+            typeDefs: augmentedTypeDefs,
+            resolvers,
+        });
+    }
+    static generateSchemaDerivedData(schema, providedDocumentStore) {
+        (0, graphql_1.assertValidSchema)(schema);
+        return {
+            schema,
+            documentStore: providedDocumentStore === undefined
+                ? new utils_keyvaluecache_1.InMemoryLRUCache()
+                : providedDocumentStore,
+            documentStoreKeyPrefix: providedDocumentStore
+                ? `${(0, computeCoreSchemaHash_js_1.computeCoreSchemaHash)((0, graphql_1.printSchema)(schema))}:`
+                : '',
+        };
+    }
+    async stop() {
+        switch (this.internals.state.phase) {
+            case 'initialized':
+            case 'starting':
+            case 'failed to start':
+                throw Error('apolloServer.stop() should only be called after `await apolloServer.start()` has succeeded');
+            case 'stopped':
+                if (this.internals.state.stopError) {
+                    throw this.internals.state.stopError;
+                }
+                return;
+            case 'stopping':
+            case 'draining': {
+                await this.internals.state.barrier;
+                const state = this.internals.state;
+                if (state.phase !== 'stopped') {
+                    throw Error(`Surprising post-stopping state ${state.phase}`);
+                }
+                if (state.stopError) {
+                    throw state.stopError;
+                }
+                return;
+            }
+            case 'started':
+                break;
+            default:
+                throw new UnreachableCaseError_js_1.UnreachableCaseError(this.internals.state);
+        }
+        const barrier = (0, resolvable_js_1.default)();
+        const { schemaManager, drainServers, landingPage, toDispose, toDisposeLast, } = this.internals.state;
+        this.internals.state = {
+            phase: 'draining',
+            barrier,
+            schemaManager,
+            landingPage,
+        };
+        try {
+            await drainServers?.();
+            this.internals.state = { phase: 'stopping', barrier };
+            await Promise.all([...toDispose].map((dispose) => dispose()));
+            await Promise.all([...toDisposeLast].map((dispose) => dispose()));
+        }
+        catch (stopError) {
+            this.internals.state = {
+                phase: 'stopped',
+                stopError: stopError,
+            };
+            barrier.resolve();
+            throw stopError;
+        }
+        this.internals.state = { phase: 'stopped', stopError: null };
+    }
+    async addDefaultPlugins() {
+        const { plugins, apolloConfig, nodeEnv, hideSchemaDetailsFromClientErrors, } = this.internals;
+        const isDev = nodeEnv !== 'production';
+        const alreadyHavePluginWithInternalId = (id) => plugins.some((p) => (0, internalPlugin_js_1.pluginIsInternal)(p) && p.__internal_plugin_id__ === id);
+        const pluginsByInternalID = new Map();
+        for (const p of plugins) {
+            if ((0, internalPlugin_js_1.pluginIsInternal)(p)) {
+                const id = p.__internal_plugin_id__;
+                if (!pluginsByInternalID.has(id)) {
+                    pluginsByInternalID.set(id, {
+                        sawDisabled: false,
+                        sawNonDisabled: false,
+                    });
+                }
+                const seen = pluginsByInternalID.get(id);
+                if (p.__is_disabled_plugin__) {
+                    seen.sawDisabled = true;
+                }
+                else {
+                    seen.sawNonDisabled = true;
+                }
+                if (seen.sawDisabled && seen.sawNonDisabled) {
+                    throw new Error(`You have tried to install both ApolloServerPlugin${id} and ` +
+                        `ApolloServerPlugin${id}Disabled in your server. Please choose ` +
+                        `whether or not you want to disable the feature and install the ` +
+                        `appropriate plugin for your use case.`);
+                }
+            }
+        }
+        {
+            if (!alreadyHavePluginWithInternalId('CacheControl')) {
+                const { ApolloServerPluginCacheControl } = await Promise.resolve().then(() => __importStar(require('./plugin/cacheControl/index.js')));
+                plugins.push(ApolloServerPluginCacheControl());
+            }
+        }
+        {
+            const alreadyHavePlugin = alreadyHavePluginWithInternalId('UsageReporting');
+            if (!alreadyHavePlugin && apolloConfig.key) {
+                if (apolloConfig.graphRef) {
+                    const { ApolloServerPluginUsageReporting } = await Promise.resolve().then(() => __importStar(require('./plugin/usageReporting/index.js')));
+                    plugins.unshift(ApolloServerPluginUsageReporting({
+                        __onlyIfSchemaIsNotSubgraph: true,
+                    }));
+                }
+                else {
+                    this.logger.warn('You have specified an Apollo key but have not specified a graph ref; usage ' +
+                        'reporting is disabled. To enable usage reporting, set the `APOLLO_GRAPH_REF` ' +
+                        'environment variable to `your-graph-id@your-graph-variant`. To disable this ' +
+                        'warning, install `ApolloServerPluginUsageReportingDisabled`.');
+                }
+            }
+        }
+        {
+            const alreadyHavePlugin = alreadyHavePluginWithInternalId('SchemaReporting');
+            const enabledViaEnvVar = process.env.APOLLO_SCHEMA_REPORTING === 'true';
+            if (!alreadyHavePlugin && enabledViaEnvVar) {
+                if (apolloConfig.key) {
+                    const { ApolloServerPluginSchemaReporting } = await Promise.resolve().then(() => __importStar(require('./plugin/schemaReporting/index.js')));
+                    plugins.push(ApolloServerPluginSchemaReporting());
+                }
+                else {
+                    throw new Error("You've enabled schema reporting by setting the APOLLO_SCHEMA_REPORTING " +
+                        'environment variable to true, but you also need to provide your ' +
+                        'Apollo API key, via the APOLLO_KEY environment ' +
+                        'variable or via `new ApolloServer({apollo: {key})');
+                }
+            }
+        }
+        {
+            const alreadyHavePlugin = alreadyHavePluginWithInternalId('InlineTrace');
+            if (!alreadyHavePlugin) {
+                const { ApolloServerPluginInlineTrace } = await Promise.resolve().then(() => __importStar(require('./plugin/inlineTrace/index.js')));
+                plugins.push(ApolloServerPluginInlineTrace({ __onlyIfSchemaIsSubgraph: true }));
+            }
+        }
+        const alreadyHavePlugin = alreadyHavePluginWithInternalId('LandingPageDisabled');
+        if (!alreadyHavePlugin) {
+            const { ApolloServerPluginLandingPageLocalDefault, ApolloServerPluginLandingPageProductionDefault, } = await Promise.resolve().then(() => __importStar(require('./plugin/landingPage/default/index.js')));
+            const plugin = isDev
+                ? ApolloServerPluginLandingPageLocalDefault()
+                : ApolloServerPluginLandingPageProductionDefault();
+            if (!isImplicitlyInstallablePlugin(plugin)) {
+                throw Error('default landing page plugin should be implicitly installable?');
+            }
+            plugin.__internal_installed_implicitly__ = true;
+            plugins.push(plugin);
+        }
+        {
+            const alreadyHavePlugin = alreadyHavePluginWithInternalId('DisableSuggestions');
+            if (hideSchemaDetailsFromClientErrors && !alreadyHavePlugin) {
+                const { ApolloServerPluginDisableSuggestions } = await Promise.resolve().then(() => __importStar(require('./plugin/disableSuggestions/index.js')));
+                plugins.push(ApolloServerPluginDisableSuggestions());
+            }
+        }
+    }
+    addPlugin(plugin) {
+        if (this.internals.state.phase !== 'initialized') {
+            throw new Error("Can't add plugins after the server has started");
+        }
+        this.internals.plugins.push(plugin);
+    }
+    async executeHTTPGraphQLRequest({ httpGraphQLRequest, context, }) {
+        try {
+            let runningServerState;
+            try {
+                runningServerState = await this._ensureStarted();
+            }
+            catch (error) {
+                return await this.errorResponse(error, httpGraphQLRequest);
+            }
+            if (runningServerState.landingPage &&
+                this.prefersHTML(httpGraphQLRequest)) {
+                let renderedHtml;
+                if (typeof runningServerState.landingPage.html === 'string') {
+                    renderedHtml = runningServerState.landingPage.html;
+                }
+                else {
+                    try {
+                        renderedHtml = await runningServerState.landingPage.html();
+                    }
+                    catch (maybeError) {
+                        const error = (0, errorNormalize_js_1.ensureError)(maybeError);
+                        this.logger.error(`Landing page \`html\` function threw: ${error}`);
+                        return await this.errorResponse(error, httpGraphQLRequest);
+                    }
+                }
+                return {
+                    headers: new HeaderMap_js_1.HeaderMap([['content-type', 'text/html']]),
+                    body: {
+                        kind: 'complete',
+                        string: renderedHtml,
+                    },
+                };
+            }
+            if (this.internals.csrfPreventionRequestHeaders) {
+                (0, preventCsrf_js_1.preventCsrf)(httpGraphQLRequest.headers, this.internals.csrfPreventionRequestHeaders);
+            }
+            let contextValue;
+            try {
+                contextValue = await context();
+            }
+            catch (maybeError) {
+                const error = (0, errorNormalize_js_1.ensureError)(maybeError);
+                try {
+                    await Promise.all(this.internals.plugins.map(async (plugin) => plugin.contextCreationDidFail?.({
+                        error,
+                    })));
+                }
+                catch (pluginError) {
+                    this.logger.error(`contextCreationDidFail hook threw: ${pluginError}`);
+                }
+                return await this.errorResponse((0, errorNormalize_js_1.ensureGraphQLError)(error, 'Context creation failed: '), httpGraphQLRequest);
+            }
+            return await (0, httpBatching_js_1.runPotentiallyBatchedHttpQuery)(this, httpGraphQLRequest, contextValue, runningServerState.schemaManager.getSchemaDerivedData(), this.internals);
+        }
+        catch (maybeError_) {
+            const maybeError = maybeError_;
+            if (maybeError instanceof graphql_1.GraphQLError &&
+                maybeError.extensions.code === index_js_1.ApolloServerErrorCode.BAD_REQUEST) {
+                try {
+                    await Promise.all(this.internals.plugins.map(async (plugin) => plugin.invalidRequestWasReceived?.({ error: maybeError })));
+                }
+                catch (pluginError) {
+                    this.logger.error(`invalidRequestWasReceived hook threw: ${pluginError}`);
+                }
+            }
+            return await this.errorResponse(maybeError, httpGraphQLRequest);
+        }
+    }
+    async errorResponse(error, requestHead) {
+        const { formattedErrors, httpFromErrors } = (0, errorNormalize_js_1.normalizeAndFormatErrors)([error], {
+            includeStacktraceInErrorResponses: this.internals.includeStacktraceInErrorResponses,
+            formatError: this.internals.formatError,
+        });
+        return {
+            status: httpFromErrors.status ?? 500,
+            headers: new HeaderMap_js_1.HeaderMap([
+                ...httpFromErrors.headers,
+                [
+                    'content-type',
+                    chooseContentTypeForSingleResultResponse(requestHead) ??
+                        exports.MEDIA_TYPES.APPLICATION_JSON,
+                ],
+            ]),
+            body: {
+                kind: 'complete',
+                string: await this.internals.stringifyResult({
+                    errors: formattedErrors,
+                }),
+            },
+        };
+    }
+    prefersHTML(request) {
+        const acceptHeader = request.headers.get('accept');
+        return (request.method === 'GET' &&
+            !!acceptHeader &&
+            new negotiator_1.default({
+                headers: { accept: acceptHeader },
+            }).mediaType([
+                exports.MEDIA_TYPES.APPLICATION_JSON,
+                exports.MEDIA_TYPES.APPLICATION_GRAPHQL_RESPONSE_JSON,
+                exports.MEDIA_TYPES.MULTIPART_MIXED_EXPERIMENTAL,
+                exports.MEDIA_TYPES.MULTIPART_MIXED_NO_DEFER_SPEC,
+                exports.MEDIA_TYPES.TEXT_HTML,
+            ]) === exports.MEDIA_TYPES.TEXT_HTML);
+    }
+    async executeOperation(request, options = {}) {
+        if (this.internals.state.phase === 'initialized') {
+            await this.start();
+        }
+        const schemaDerivedData = (await this._ensureStarted()).schemaManager.getSchemaDerivedData();
+        const graphQLRequest = {
+            ...request,
+            query: request.query && typeof request.query !== 'string'
+                ? (0, graphql_1.print)(request.query)
+                : request.query,
+        };
+        const response = await internalExecuteOperation({
+            server: this,
+            graphQLRequest,
+            internals: this.internals,
+            schemaDerivedData,
+            sharedResponseHTTPGraphQLHead: null,
+        }, options);
+        return response;
+    }
+}
+exports.ApolloServer = ApolloServer;
+async function internalExecuteOperation({ server, graphQLRequest, internals, schemaDerivedData, sharedResponseHTTPGraphQLHead, }, options) {
+    const requestContext = {
+        logger: server.logger,
+        cache: server.cache,
+        schema: schemaDerivedData.schema,
+        request: graphQLRequest,
+        response: {
+            http: sharedResponseHTTPGraphQLHead ?? (0, runHttpQuery_js_1.newHTTPGraphQLHead)(),
+        },
+        contextValue: cloneObject(options?.contextValue ?? {}),
+        metrics: {},
+        overallCachePolicy: (0, cachePolicy_js_1.newCachePolicy)(),
+        requestIsBatched: sharedResponseHTTPGraphQLHead !== null,
+    };
+    try {
+        return await (0, requestPipeline_js_1.processGraphQLRequest)(schemaDerivedData, server, internals, requestContext);
+    }
+    catch (maybeError) {
+        const error = (0, errorNormalize_js_1.ensureError)(maybeError);
+        await Promise.all(internals.plugins.map(async (plugin) => plugin.unexpectedErrorProcessingRequest?.({
+            requestContext,
+            error,
+        })));
+        server.logger.error(`Unexpected error processing request: ${error}`);
+        throw new Error('Internal server error');
+    }
+}
+exports.internalExecuteOperation = internalExecuteOperation;
+function isImplicitlyInstallablePlugin(p) {
+    return '__internal_installed_implicitly__' in p;
+}
+exports.isImplicitlyInstallablePlugin = isImplicitlyInstallablePlugin;
+exports.MEDIA_TYPES = {
+    APPLICATION_JSON: 'application/json; charset=utf-8',
+    APPLICATION_JSON_GRAPHQL_CALLBACK: 'application/json; callbackSpec=1.0; charset=utf-8',
+    APPLICATION_GRAPHQL_RESPONSE_JSON: 'application/graphql-response+json; charset=utf-8',
+    MULTIPART_MIXED_NO_DEFER_SPEC: 'multipart/mixed',
+    MULTIPART_MIXED_EXPERIMENTAL: 'multipart/mixed; deferSpec=20220824',
+    TEXT_HTML: 'text/html',
+};
+function chooseContentTypeForSingleResultResponse(head) {
+    const acceptHeader = head.headers.get('accept');
+    if (!acceptHeader) {
+        return exports.MEDIA_TYPES.APPLICATION_JSON;
+    }
+    else {
+        const preferred = new negotiator_1.default({
+            headers: { accept: head.headers.get('accept') },
+        }).mediaType([
+            exports.MEDIA_TYPES.APPLICATION_JSON,
+            exports.MEDIA_TYPES.APPLICATION_GRAPHQL_RESPONSE_JSON,
+            exports.MEDIA_TYPES.APPLICATION_JSON_GRAPHQL_CALLBACK,
+        ]);
+        if (preferred) {
+            return preferred;
+        }
+        else {
+            return null;
+        }
+    }
+}
+exports.chooseContentTypeForSingleResultResponse = chooseContentTypeForSingleResultResponse;
+function cloneObject(object) {
+    return Object.assign(Object.create(Object.getPrototypeOf(object)), object);
+}
+//# sourceMappingURL=ApolloServer.js.map

node_modules/@apollo/server/dist/cjs/cachePolicy.d.ts

@@ -0,0 +1,3 @@
+import type { CachePolicy } from '@apollo/cache-control-types';
+export declare function newCachePolicy(): CachePolicy;
+//# sourceMappingURL=cachePolicy.d.ts.map

node_modules/@apollo/server/dist/cjs/cachePolicy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cachePolicy.d.ts","sourceRoot":"","sources":["../../src/cachePolicy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAa,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAE1E,wBAAgB,cAAc,IAAI,WAAW,CA8B5C"}

node_modules/@apollo/server/dist/cjs/cachePolicy.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.newCachePolicy = void 0;
+function newCachePolicy() {
+    return {
+        maxAge: undefined,
+        scope: undefined,
+        restrict(hint) {
+            if (hint.maxAge !== undefined &&
+                (this.maxAge === undefined || hint.maxAge < this.maxAge)) {
+                this.maxAge = hint.maxAge;
+            }
+            if (hint.scope !== undefined && this.scope !== 'PRIVATE') {
+                this.scope = hint.scope;
+            }
+        },
+        replace(hint) {
+            if (hint.maxAge !== undefined) {
+                this.maxAge = hint.maxAge;
+            }
+            if (hint.scope !== undefined) {
+                this.scope = hint.scope;
+            }
+        },
+        policyIfCacheable() {
+            if (this.maxAge === undefined || this.maxAge === 0) {
+                return null;
+            }
+            return { maxAge: this.maxAge, scope: this.scope ?? 'PUBLIC' };
+        },
+    };
+}
+exports.newCachePolicy = newCachePolicy;
+//# sourceMappingURL=cachePolicy.js.map

node_modules/@apollo/server/dist/cjs/cachePolicy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cachePolicy.js","sourceRoot":"","sources":["../../src/cachePolicy.ts"],"names":[],"mappings":";;;AAEA,SAAgB,cAAc;IAC5B,OAAO;QACL,MAAM,EAAE,SAAS;QACjB,KAAK,EAAE,SAAS;QAChB,QAAQ,CAAC,IAAe;YACtB,IACE,IAAI,CAAC,MAAM,KAAK,SAAS;gBACzB,CAAC,IAAI,CAAC,MAAM,KAAK,SAAS,IAAI,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,EACxD,CAAC;gBACD,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC;YAC5B,CAAC;YACD,IAAI,IAAI,CAAC,KAAK,KAAK,SAAS,IAAI,IAAI,CAAC,KAAK,KAAK,SAAS,EAAE,CAAC;gBACzD,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC;YAC1B,CAAC;QACH,CAAC;QACD,OAAO,CAAC,IAAe;YACrB,IAAI,IAAI,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;gBAC9B,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC;YAC5B,CAAC;YACD,IAAI,IAAI,CAAC,KAAK,KAAK,SAAS,EAAE,CAAC;gBAC7B,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC;YAC1B,CAAC;QACH,CAAC;QACD,iBAAiB;YACf,IAAI,IAAI,CAAC,MAAM,KAAK,SAAS,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;gBACnD,OAAO,IAAI,CAAC;YACd,CAAC;YACD,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,IAAI,QAAQ,EAAE,CAAC;QAChE,CAAC;KACF,CAAC;AACJ,CAAC;AA9BD,wCA8BC"}

node_modules/@apollo/server/dist/cjs/determineApolloConfig.d.ts

@@ -0,0 +1,4 @@
+import type { ApolloConfig, ApolloConfigInput } from './externalTypes/index.js';
+import type { Logger } from '@apollo/utils.logger';
+export declare function determineApolloConfig(input: ApolloConfigInput | undefined, logger: Logger): ApolloConfig;
+//# sourceMappingURL=determineApolloConfig.d.ts.map

node_modules/@apollo/server/dist/cjs/determineApolloConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"determineApolloConfig.d.ts","sourceRoot":"","sources":["../../src/determineApolloConfig.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAChF,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAInD,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,iBAAiB,GAAG,SAAS,EACpC,MAAM,EAAE,MAAM,GACb,YAAY,CAuEd"}

node_modules/@apollo/server/dist/cjs/determineApolloConfig.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.determineApolloConfig = void 0;
+const utils_createhash_1 = require("@apollo/utils.createhash");
+function determineApolloConfig(input, logger) {
+    const apolloConfig = {};
+    const { APOLLO_KEY, APOLLO_GRAPH_REF, APOLLO_GRAPH_ID, APOLLO_GRAPH_VARIANT, } = process.env;
+    if (input?.key) {
+        apolloConfig.key = input.key.trim();
+    }
+    else if (APOLLO_KEY) {
+        apolloConfig.key = APOLLO_KEY.trim();
+    }
+    if ((input?.key ?? APOLLO_KEY) !== apolloConfig.key) {
+        logger.warn('The provided API key has unexpected leading or trailing whitespace. ' +
+            'Apollo Server will trim the key value before use.');
+    }
+    if (apolloConfig.key) {
+        assertValidHeaderValue(apolloConfig.key);
+    }
+    if (apolloConfig.key) {
+        apolloConfig.keyHash = (0, utils_createhash_1.createHash)('sha512')
+            .update(apolloConfig.key)
+            .digest('hex');
+    }
+    if (input?.graphRef) {
+        apolloConfig.graphRef = input.graphRef;
+    }
+    else if (APOLLO_GRAPH_REF) {
+        apolloConfig.graphRef = APOLLO_GRAPH_REF;
+    }
+    const graphId = input?.graphId ?? APOLLO_GRAPH_ID;
+    const graphVariant = input?.graphVariant ?? APOLLO_GRAPH_VARIANT;
+    if (apolloConfig.graphRef) {
+        if (graphId) {
+            throw new Error('Cannot specify both graph ref and graph ID. Please use ' +
+                '`apollo.graphRef` or `APOLLO_GRAPH_REF` without also setting the graph ID.');
+        }
+        if (graphVariant) {
+            throw new Error('Cannot specify both graph ref and graph variant. Please use ' +
+                '`apollo.graphRef` or `APOLLO_GRAPH_REF` without also setting the graph variant.');
+        }
+    }
+    else if (graphId) {
+        apolloConfig.graphRef = graphVariant
+            ? `${graphId}@${graphVariant}`
+            : graphId;
+    }
+    return apolloConfig;
+}
+exports.determineApolloConfig = determineApolloConfig;
+function assertValidHeaderValue(value) {
+    const invalidHeaderCharRegex = /[^\t\x20-\x7e\x80-\xff]/g;
+    if (invalidHeaderCharRegex.test(value)) {
+        const invalidChars = value.match(invalidHeaderCharRegex);
+        throw new Error(`The API key provided to Apollo Server contains characters which are invalid as HTTP header values. The following characters found in the key are invalid: ${invalidChars.join(', ')}. Valid header values may only contain ASCII visible characters. If you think there is an issue with your key, please contact Apollo support.`);
+    }
+}
+//# sourceMappingURL=determineApolloConfig.js.map

node_modules/@apollo/server/dist/cjs/determineApolloConfig.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"determineApolloConfig.js","sourceRoot":"","sources":["../../src/determineApolloConfig.ts"],"names":[],"mappings":";;;AAAA,+DAAsD;AAMtD,SAAgB,qBAAqB,CACnC,KAAoC,EACpC,MAAc;IAEd,MAAM,YAAY,GAAiB,EAAE,CAAC;IAEtC,MAAM,EACJ,UAAU,EACV,gBAAgB,EAChB,eAAe,EACf,oBAAoB,GACrB,GAAG,OAAO,CAAC,GAAG,CAAC;IAGhB,IAAI,KAAK,EAAE,GAAG,EAAE,CAAC;QACf,YAAY,CAAC,GAAG,GAAG,KAAK,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC;IACtC,CAAC;SAAM,IAAI,UAAU,EAAE,CAAC;QACtB,YAAY,CAAC,GAAG,GAAG,UAAU,CAAC,IAAI,EAAE,CAAC;IACvC,CAAC;IACD,IAAI,CAAC,KAAK,EAAE,GAAG,IAAI,UAAU,CAAC,KAAK,YAAY,CAAC,GAAG,EAAE,CAAC;QACpD,MAAM,CAAC,IAAI,CACT,sEAAsE;YACpE,mDAAmD,CACtD,CAAC;IACJ,CAAC;IAID,IAAI,YAAY,CAAC,GAAG,EAAE,CAAC;QACrB,sBAAsB,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC;IAC3C,CAAC;IAGD,IAAI,YAAY,CAAC,GAAG,EAAE,CAAC;QACrB,YAAY,CAAC,OAAO,GAAG,IAAA,6BAAU,EAAC,QAAQ,CAAC;aACxC,MAAM,CAAC,YAAY,CAAC,GAAG,CAAC;aACxB,MAAM,CAAC,KAAK,CAAC,CAAC;IACnB,CAAC;IAGD,IAAI,KAAK,EAAE,QAAQ,EAAE,CAAC;QACpB,YAAY,CAAC,QAAQ,GAAG,KAAK,CAAC,QAAQ,CAAC;IACzC,CAAC;SAAM,IAAI,gBAAgB,EAAE,CAAC;QAC5B,YAAY,CAAC,QAAQ,GAAG,gBAAgB,CAAC;IAC3C,CAAC;IAGD,MAAM,OAAO,GAAG,KAAK,EAAE,OAAO,IAAI,eAAe,CAAC;IAClD,MAAM,YAAY,GAAG,KAAK,EAAE,YAAY,IAAI,oBAAoB,CAAC;IAEjE,IAAI,YAAY,CAAC,QAAQ,EAAE,CAAC;QAC1B,IAAI,OAAO,EAAE,CAAC;YACZ,MAAM,IAAI,KAAK,CACb,yDAAyD;gBACvD,4EAA4E,CAC/E,CAAC;QACJ,CAAC;QACD,IAAI,YAAY,EAAE,CAAC;YACjB,MAAM,IAAI,KAAK,CACb,8DAA8D;gBAC5D,iFAAiF,CACpF,CAAC;QACJ,CAAC;IACH,CAAC;SAAM,IAAI,OAAO,EAAE,CAAC;QAKnB,YAAY,CAAC,QAAQ,GAAG,YAAY;YAClC,CAAC,CAAC,GAAG,OAAO,IAAI,YAAY,EAAE;YAC9B,CAAC,CAAC,OAAO,CAAC;IACd,CAAC;IAED,OAAO,YAAY,CAAC;AACtB,CAAC;AA1ED,sDA0EC;AAED,SAAS,sBAAsB,CAAC,KAAa;IAG3C,MAAM,sBAAsB,GAAG,0BAA0B,CAAC;IAC1D,IAAI,sBAAsB,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;QACvC,MAAM,YAAY,GAAG,KAAK,CAAC,KAAK,CAAC,sBAAsB,CAAE,CAAC;QAC1D,MAAM,IAAI,KAAK,CACb,6JAA6J,YAAY,CAAC,IAAI,CAC5K,IAAI,CACL,+IAA+I,CACjJ,CAAC;IACJ,CAAC;AACH,CAAC"}

node_modules/@apollo/server/dist/cjs/errorNormalize.d.ts

@@ -0,0 +1,12 @@
+import { GraphQLError, type GraphQLFormattedError } from 'graphql';
+import type { HTTPGraphQLHead } from './externalTypes/http.js';
+export declare function normalizeAndFormatErrors(errors: ReadonlyArray<unknown>, options?: {
+    formatError?: (formattedError: GraphQLFormattedError, error: unknown) => GraphQLFormattedError;
+    includeStacktraceInErrorResponses?: boolean;
+}): {
+    formattedErrors: Array<GraphQLFormattedError>;
+    httpFromErrors: HTTPGraphQLHead;
+};
+export declare function ensureError(maybeError: unknown): Error;
+export declare function ensureGraphQLError(maybeError: unknown, messagePrefixIfNotGraphQLError?: string): GraphQLError;
+//# sourceMappingURL=errorNormalize.d.ts.map

node_modules/@apollo/server/dist/cjs/errorNormalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errorNormalize.d.ts","sourceRoot":"","sources":["../../src/errorNormalize.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,YAAY,EAEZ,KAAK,qBAAqB,EAC3B,MAAM,SAAS,CAAC;AAEjB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAY/D,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,aAAa,CAAC,OAAO,CAAC,EAC9B,OAAO,GAAE;IACP,WAAW,CAAC,EAAE,CACZ,cAAc,EAAE,qBAAqB,EACrC,KAAK,EAAE,OAAO,KACX,qBAAqB,CAAC;IAC3B,iCAAiC,CAAC,EAAE,OAAO,CAAC;CACxC,GACL;IACD,eAAe,EAAE,KAAK,CAAC,qBAAqB,CAAC,CAAC;IAC9C,cAAc,EAAE,eAAe,CAAC;CACjC,CAqDA;AAED,wBAAgB,WAAW,CAAC,UAAU,EAAE,OAAO,GAAG,KAAK,CAItD;AAED,wBAAgB,kBAAkB,CAChC,UAAU,EAAE,OAAO,EACnB,8BAA8B,GAAE,MAAW,GAC1C,YAAY,CAQd"}

node_modules/@apollo/server/dist/cjs/errorNormalize.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureGraphQLError = exports.ensureError = exports.normalizeAndFormatErrors = void 0;
+const graphql_1 = require("graphql");
+const index_js_1 = require("./errors/index.js");
+const runHttpQuery_js_1 = require("./runHttpQuery.js");
+const HeaderMap_js_1 = require("./utils/HeaderMap.js");
+function normalizeAndFormatErrors(errors, options = {}) {
+    const formatError = options.formatError ?? ((error) => error);
+    const httpFromErrors = (0, runHttpQuery_js_1.newHTTPGraphQLHead)();
+    return {
+        httpFromErrors,
+        formattedErrors: errors.map((error) => {
+            try {
+                return formatError(enrichError(error), error);
+            }
+            catch (formattingError) {
+                if (options.includeStacktraceInErrorResponses) {
+                    return enrichError(formattingError);
+                }
+                else {
+                    return {
+                        message: 'Internal server error',
+                        extensions: { code: index_js_1.ApolloServerErrorCode.INTERNAL_SERVER_ERROR },
+                    };
+                }
+            }
+        }),
+    };
+    function enrichError(maybeError) {
+        const graphqlError = ensureGraphQLError(maybeError);
+        const extensions = {
+            ...graphqlError.extensions,
+            code: graphqlError.extensions.code ??
+                index_js_1.ApolloServerErrorCode.INTERNAL_SERVER_ERROR,
+        };
+        if (isPartialHTTPGraphQLHead(extensions.http)) {
+            (0, runHttpQuery_js_1.mergeHTTPGraphQLHead)(httpFromErrors, {
+                headers: new HeaderMap_js_1.HeaderMap(),
+                ...extensions.http,
+            });
+            delete extensions.http;
+        }
+        if (options.includeStacktraceInErrorResponses) {
+            extensions.stacktrace = graphqlError.stack?.split('\n');
+        }
+        return { ...graphqlError.toJSON(), extensions };
+    }
+}
+exports.normalizeAndFormatErrors = normalizeAndFormatErrors;
+function ensureError(maybeError) {
+    return maybeError instanceof Error
+        ? maybeError
+        : new graphql_1.GraphQLError('Unexpected error value: ' + String(maybeError));
+}
+exports.ensureError = ensureError;
+function ensureGraphQLError(maybeError, messagePrefixIfNotGraphQLError = '') {
+    const error = ensureError(maybeError);
+    return error instanceof graphql_1.GraphQLError
+        ? error
+        : new graphql_1.GraphQLError(messagePrefixIfNotGraphQLError + error.message, {
+            originalError: error,
+        });
+}
+exports.ensureGraphQLError = ensureGraphQLError;
+function isPartialHTTPGraphQLHead(x) {
+    return (!!x &&
+        typeof x === 'object' &&
+        (!('status' in x) || typeof x.status === 'number') &&
+        (!('headers' in x) || x.headers instanceof Map));
+}
+//# sourceMappingURL=errorNormalize.js.map

node_modules/@apollo/server/dist/cjs/errorNormalize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errorNormalize.js","sourceRoot":"","sources":["../../src/errorNormalize.ts"],"names":[],"mappings":";;;AAEA,qCAIiB;AACjB,gDAA0D;AAE1D,uDAA6E;AAC7E,uDAAiD;AAUjD,SAAgB,wBAAwB,CACtC,MAA8B,EAC9B,UAMI,EAAE;IAKN,MAAM,WAAW,GAAG,OAAO,CAAC,WAAW,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC;IAC9D,MAAM,cAAc,GAAG,IAAA,oCAAkB,GAAE,CAAC;IAE5C,OAAO;QACL,cAAc;QACd,eAAe,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE;YACpC,IAAI,CAAC;gBACH,OAAO,WAAW,CAAC,WAAW,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC,CAAC;YAChD,CAAC;YAAC,OAAO,eAAe,EAAE,CAAC;gBACzB,IAAI,OAAO,CAAC,iCAAiC,EAAE,CAAC;oBAG9C,OAAO,WAAW,CAAC,eAAe,CAAC,CAAC;gBACtC,CAAC;qBAAM,CAAC;oBAEN,OAAO;wBACL,OAAO,EAAE,uBAAuB;wBAChC,UAAU,EAAE,EAAE,IAAI,EAAE,gCAAqB,CAAC,qBAAqB,EAAE;qBAClE,CAAC;gBACJ,CAAC;YACH,CAAC;QACH,CAAC,CAAC;KACH,CAAC;IAEF,SAAS,WAAW,CAAC,UAAmB;QACtC,MAAM,YAAY,GAAG,kBAAkB,CAAC,UAAU,CAAC,CAAC;QAEpD,MAAM,UAAU,GAA2B;YACzC,GAAG,YAAY,CAAC,UAAU;YAC1B,IAAI,EACF,YAAY,CAAC,UAAU,CAAC,IAAI;gBAC5B,gCAAqB,CAAC,qBAAqB;SAC9C,CAAC;QAEF,IAAI,wBAAwB,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC;YAC9C,IAAA,sCAAoB,EAAC,cAAc,EAAE;gBACnC,OAAO,EAAE,IAAI,wBAAS,EAAE;gBACxB,GAAG,UAAU,CAAC,IAAI;aACnB,CAAC,CAAC;YACH,OAAO,UAAU,CAAC,IAAI,CAAC;QACzB,CAAC;QAED,IAAI,OAAO,CAAC,iCAAiC,EAAE,CAAC;YAK9C,UAAU,CAAC,UAAU,GAAG,YAAY,CAAC,KAAK,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC;QAC1D,CAAC;QAED,OAAO,EAAE,GAAG,YAAY,CAAC,MAAM,EAAE,EAAE,UAAU,EAAE,CAAC;IAClD,CAAC;AACH,CAAC;AAjED,4DAiEC;AAED,SAAgB,WAAW,CAAC,UAAmB;IAC7C,OAAO,UAAU,YAAY,KAAK;QAChC,CAAC,CAAC,UAAU;QACZ,CAAC,CAAC,IAAI,sBAAY,CAAC,0BAA0B,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC,CAAC;AACxE,CAAC;AAJD,kCAIC;AAED,SAAgB,kBAAkB,CAChC,UAAmB,EACnB,iCAAyC,EAAE;IAE3C,MAAM,KAAK,GAAU,WAAW,CAAC,UAAU,CAAC,CAAC;IAE7C,OAAO,KAAK,YAAY,sBAAY;QAClC,CAAC,CAAC,KAAK;QACP,CAAC,CAAC,IAAI,sBAAY,CAAC,8BAA8B,GAAG,KAAK,CAAC,OAAO,EAAE;YAC/D,aAAa,EAAE,KAAK;SACrB,CAAC,CAAC;AACT,CAAC;AAXD,gDAWC;AAED,SAAS,wBAAwB,CAAC,CAAU;IAC1C,OAAO,CACL,CAAC,CAAC,CAAC;QACH,OAAO,CAAC,KAAK,QAAQ;QACrB,CAAC,CAAC,CAAC,QAAQ,IAAI,CAAC,CAAC,IAAI,OAAQ,CAAS,CAAC,MAAM,KAAK,QAAQ,CAAC;QAC3D,CAAC,CAAC,CAAC,SAAS,IAAI,CAAC,CAAC,IAAK,CAAS,CAAC,OAAO,YAAY,GAAG,CAAC,CACzD,CAAC;AACJ,CAAC"}

node_modules/@apollo/server/dist/cjs/errors/index.d.ts

@@ -0,0 +1,16 @@
+export declare enum ApolloServerErrorCode {
+    INTERNAL_SERVER_ERROR = "INTERNAL_SERVER_ERROR",
+    GRAPHQL_PARSE_FAILED = "GRAPHQL_PARSE_FAILED",
+    GRAPHQL_VALIDATION_FAILED = "GRAPHQL_VALIDATION_FAILED",
+    PERSISTED_QUERY_NOT_FOUND = "PERSISTED_QUERY_NOT_FOUND",
+    PERSISTED_QUERY_NOT_SUPPORTED = "PERSISTED_QUERY_NOT_SUPPORTED",
+    BAD_USER_INPUT = "BAD_USER_INPUT",
+    OPERATION_RESOLUTION_FAILURE = "OPERATION_RESOLUTION_FAILURE",
+    BAD_REQUEST = "BAD_REQUEST"
+}
+export declare enum ApolloServerValidationErrorCode {
+    INTROSPECTION_DISABLED = "INTROSPECTION_DISABLED",
+    MAX_RECURSIVE_SELECTIONS_EXCEEDED = "MAX_RECURSIVE_SELECTIONS_EXCEEDED"
+}
+export declare function unwrapResolverError(error: unknown): unknown;
+//# sourceMappingURL=index.d.ts.map

node_modules/@apollo/server/dist/cjs/errors/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/errors/index.ts"],"names":[],"mappings":"AAEA,oBAAY,qBAAqB;IAC/B,qBAAqB,0BAA0B;IAC/C,oBAAoB,yBAAyB;IAC7C,yBAAyB,8BAA8B;IACvD,yBAAyB,8BAA8B;IACvD,6BAA6B,kCAAkC;IAC/D,cAAc,mBAAmB;IACjC,4BAA4B,iCAAiC;IAC7D,WAAW,gBAAgB;CAC5B;AAED,oBAAY,+BAA+B;IACzC,sBAAsB,2BAA2B;IACjD,iCAAiC,sCAAsC;CACxE;AAWD,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAK3D"}

node_modules/@apollo/server/dist/cjs/errors/index.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unwrapResolverError = exports.ApolloServerValidationErrorCode = exports.ApolloServerErrorCode = void 0;
+const graphql_1 = require("graphql");
+var ApolloServerErrorCode;
+(function (ApolloServerErrorCode) {
+    ApolloServerErrorCode["INTERNAL_SERVER_ERROR"] = "INTERNAL_SERVER_ERROR";
+    ApolloServerErrorCode["GRAPHQL_PARSE_FAILED"] = "GRAPHQL_PARSE_FAILED";
+    ApolloServerErrorCode["GRAPHQL_VALIDATION_FAILED"] = "GRAPHQL_VALIDATION_FAILED";
+    ApolloServerErrorCode["PERSISTED_QUERY_NOT_FOUND"] = "PERSISTED_QUERY_NOT_FOUND";
+    ApolloServerErrorCode["PERSISTED_QUERY_NOT_SUPPORTED"] = "PERSISTED_QUERY_NOT_SUPPORTED";
+    ApolloServerErrorCode["BAD_USER_INPUT"] = "BAD_USER_INPUT";
+    ApolloServerErrorCode["OPERATION_RESOLUTION_FAILURE"] = "OPERATION_RESOLUTION_FAILURE";
+    ApolloServerErrorCode["BAD_REQUEST"] = "BAD_REQUEST";
+})(ApolloServerErrorCode || (exports.ApolloServerErrorCode = ApolloServerErrorCode = {}));
+var ApolloServerValidationErrorCode;
+(function (ApolloServerValidationErrorCode) {
+    ApolloServerValidationErrorCode["INTROSPECTION_DISABLED"] = "INTROSPECTION_DISABLED";
+    ApolloServerValidationErrorCode["MAX_RECURSIVE_SELECTIONS_EXCEEDED"] = "MAX_RECURSIVE_SELECTIONS_EXCEEDED";
+})(ApolloServerValidationErrorCode || (exports.ApolloServerValidationErrorCode = ApolloServerValidationErrorCode = {}));
+function unwrapResolverError(error) {
+    if (error instanceof graphql_1.GraphQLError && error.path && error.originalError) {
+        return error.originalError;
+    }
+    return error;
+}
+exports.unwrapResolverError = unwrapResolverError;
+//# sourceMappingURL=index.js.map

node_modules/@apollo/server/dist/cjs/errors/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/errors/index.ts"],"names":[],"mappings":";;;AAAA,qCAAuC;AAEvC,IAAY,qBASX;AATD,WAAY,qBAAqB;IAC/B,wEAA+C,CAAA;IAC/C,sEAA6C,CAAA;IAC7C,gFAAuD,CAAA;IACvD,gFAAuD,CAAA;IACvD,wFAA+D,CAAA;IAC/D,0DAAiC,CAAA;IACjC,sFAA6D,CAAA;IAC7D,oDAA2B,CAAA;AAC7B,CAAC,EATW,qBAAqB,qCAArB,qBAAqB,QAShC;AAED,IAAY,+BAGX;AAHD,WAAY,+BAA+B;IACzC,oFAAiD,CAAA;IACjD,0GAAuE,CAAA;AACzE,CAAC,EAHW,+BAA+B,+CAA/B,+BAA+B,QAG1C;AAWD,SAAgB,mBAAmB,CAAC,KAAc;IAChD,IAAI,KAAK,YAAY,sBAAY,IAAI,KAAK,CAAC,IAAI,IAAI,KAAK,CAAC,aAAa,EAAE,CAAC;QACvE,OAAO,KAAK,CAAC,aAAa,CAAC;IAC7B,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AALD,kDAKC"}

node_modules/@apollo/server/dist/cjs/express4/index.d.ts

@@ -0,0 +1,14 @@
+import type { WithRequired } from '@apollo/utils.withrequired';
+import type express from 'express';
+import type { ApolloServer } from '../index.js';
+import type { BaseContext, ContextFunction } from '../externalTypes/index.js';
+export interface ExpressContextFunctionArgument {
+    req: express.Request;
+    res: express.Response;
+}
+export interface ExpressMiddlewareOptions<TContext extends BaseContext> {
+    context?: ContextFunction<[ExpressContextFunctionArgument], TContext>;
+}
+export declare function expressMiddleware(server: ApolloServer<BaseContext>, options?: ExpressMiddlewareOptions<BaseContext>): express.RequestHandler;
+export declare function expressMiddleware<TContext extends BaseContext>(server: ApolloServer<TContext>, options: WithRequired<ExpressMiddlewareOptions<TContext>, 'context'>): express.RequestHandler;
+//# sourceMappingURL=index.d.ts.map

node_modules/@apollo/server/dist/cjs/express4/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/express4/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC/D,OAAO,KAAK,OAAO,MAAM,SAAS,CAAC;AACnC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,KAAK,EACV,WAAW,EACX,eAAe,EAEhB,MAAM,2BAA2B,CAAC;AAInC,MAAM,WAAW,8BAA8B;IAC7C,GAAG,EAAE,OAAO,CAAC,OAAO,CAAC;IACrB,GAAG,EAAE,OAAO,CAAC,QAAQ,CAAC;CACvB;AAED,MAAM,WAAW,wBAAwB,CAAC,QAAQ,SAAS,WAAW;IACpE,OAAO,CAAC,EAAE,eAAe,CAAC,CAAC,8BAA8B,CAAC,EAAE,QAAQ,CAAC,CAAC;CACvE;AAED,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,YAAY,CAAC,WAAW,CAAC,EACjC,OAAO,CAAC,EAAE,wBAAwB,CAAC,WAAW,CAAC,GAC9C,OAAO,CAAC,cAAc,CAAC;AAC1B,wBAAgB,iBAAiB,CAAC,QAAQ,SAAS,WAAW,EAC5D,MAAM,EAAE,YAAY,CAAC,QAAQ,CAAC,EAC9B,OAAO,EAAE,YAAY,CAAC,wBAAwB,CAAC,QAAQ,CAAC,EAAE,SAAS,CAAC,GACnE,OAAO,CAAC,cAAc,CAAC"}

node_modules/@apollo/server/dist/cjs/express4/index.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expressMiddleware = void 0;
+const url_1 = require("url");
+const HeaderMap_js_1 = require("../utils/HeaderMap.js");
+function expressMiddleware(server, options) {
+    server.assertStarted('expressMiddleware()');
+    const defaultContext = async () => ({});
+    const context = options?.context ?? defaultContext;
+    return (req, res, next) => {
+        if (!req.body) {
+            res.status(500);
+            res.send('`req.body` is not set; this probably means you forgot to set up the ' +
+                '`json` middleware before the Apollo Server middleware.');
+            return;
+        }
+        const headers = new HeaderMap_js_1.HeaderMap();
+        for (const [key, value] of Object.entries(req.headers)) {
+            if (value !== undefined) {
+                headers.set(key, Array.isArray(value) ? value.join(', ') : value);
+            }
+        }
+        const httpGraphQLRequest = {
+            method: req.method.toUpperCase(),
+            headers,
+            search: (0, url_1.parse)(req.url).search ?? '',
+            body: req.body,
+        };
+        server
+            .executeHTTPGraphQLRequest({
+            httpGraphQLRequest,
+            context: () => context({ req, res }),
+        })
+            .then(async (httpGraphQLResponse) => {
+            for (const [key, value] of httpGraphQLResponse.headers) {
+                res.setHeader(key, value);
+            }
+            res.statusCode = httpGraphQLResponse.status || 200;
+            if (httpGraphQLResponse.body.kind === 'complete') {
+                res.send(httpGraphQLResponse.body.string);
+                return;
+            }
+            for await (const chunk of httpGraphQLResponse.body.asyncIterator) {
+                res.write(chunk);
+                if (typeof res.flush === 'function') {
+                    res.flush();
+                }
+            }
+            res.end();
+        })
+            .catch(next);
+    };
+}
+exports.expressMiddleware = expressMiddleware;
+//# sourceMappingURL=index.js.map

node_modules/@apollo/server/dist/cjs/express4/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/express4/index.ts"],"names":[],"mappings":";;;AAQA,6BAAwC;AACxC,wDAAkD;AAmBlD,SAAgB,iBAAiB,CAC/B,MAA8B,EAC9B,OAA4C;IAE5C,MAAM,CAAC,aAAa,CAAC,qBAAqB,CAAC,CAAC;IAK5C,MAAM,cAAc,GAGhB,KAAK,IAAI,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC;IAErB,MAAM,OAAO,GACX,OAAO,EAAE,OAAO,IAAI,cAAc,CAAC;IAErC,OAAO,CAAC,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,EAAE;QACxB,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC;YAKd,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;YAChB,GAAG,CAAC,IAAI,CACN,sEAAsE;gBACpE,wDAAwD,CAC3D,CAAC;YACF,OAAO;QACT,CAAC;QAED,MAAM,OAAO,GAAG,IAAI,wBAAS,EAAE,CAAC;QAChC,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC;YACvD,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;gBAOxB,OAAO,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;YACpE,CAAC;QACH,CAAC;QAED,MAAM,kBAAkB,GAAuB;YAC7C,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,WAAW,EAAE;YAChC,OAAO;YACP,MAAM,EAAE,IAAA,WAAQ,EAAC,GAAG,CAAC,GAAG,CAAC,CAAC,MAAM,IAAI,EAAE;YACtC,IAAI,EAAE,GAAG,CAAC,IAAI;SACf,CAAC;QAEF,MAAM;aACH,yBAAyB,CAAC;YACzB,kBAAkB;YAClB,OAAO,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC;SACrC,CAAC;aACD,IAAI,CAAC,KAAK,EAAE,mBAAmB,EAAE,EAAE;YAClC,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,mBAAmB,CAAC,OAAO,EAAE,CAAC;gBACvD,GAAG,CAAC,SAAS,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;YAC5B,CAAC;YACD,GAAG,CAAC,UAAU,GAAG,mBAAmB,CAAC,MAAM,IAAI,GAAG,CAAC;YAEnD,IAAI,mBAAmB,CAAC,IAAI,CAAC,IAAI,KAAK,UAAU,EAAE,CAAC;gBACjD,GAAG,CAAC,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;gBAC1C,OAAO;YACT,CAAC;YAED,IAAI,KAAK,EAAE,MAAM,KAAK,IAAI,mBAAmB,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC;gBACjE,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;gBAMjB,IAAI,OAAQ,GAAW,CAAC,KAAK,KAAK,UAAU,EAAE,CAAC;oBAC5C,GAAW,CAAC,KAAK,EAAE,CAAC;gBACvB,CAAC;YACH,CAAC;YACD,GAAG,CAAC,GAAG,EAAE,CAAC;QACZ,CAAC,CAAC;aACD,KAAK,CAAC,IAAI,CAAC,CAAC;IACjB,CAAC,CAAC;AACJ,CAAC;AAlFD,8CAkFC"}

node_modules/@apollo/server/dist/cjs/externalTypes/constructor.d.ts

@@ -0,0 +1,74 @@
+import type { Logger } from '@apollo/utils.logger';
+import type { IExecutableSchemaDefinition } from '@graphql-tools/schema';
+import type { DocumentNode, FormattedExecutionResult, GraphQLFieldResolver, GraphQLFormattedError, GraphQLSchema, ParseOptions, ValidationRule } from 'graphql';
+import type { KeyValueCache } from '@apollo/utils.keyvaluecache';
+import type { GatewayInterface } from '@apollo/server-gateway-interface';
+import type { ApolloServerPlugin } from './plugins.js';
+import type { BaseContext } from './index.js';
+import type { GraphQLExperimentalIncrementalExecutionResults } from '../incrementalDeliveryPolyfill.js';
+export type DocumentStore = KeyValueCache<DocumentNode>;
+export interface ApolloConfigInput {
+    key?: string;
+    graphRef?: string;
+    graphId?: string;
+    graphVariant?: string;
+}
+export interface ApolloConfig {
+    key?: string;
+    keyHash?: string;
+    graphRef?: string;
+}
+export interface PersistedQueryOptions {
+    cache?: KeyValueCache<string>;
+    ttl?: number | null;
+}
+export interface CSRFPreventionOptions {
+    requestHeaders?: string[];
+}
+interface ApolloServerOptionsBase<TContext extends BaseContext> {
+    formatError?: (formattedError: GraphQLFormattedError, error: unknown) => GraphQLFormattedError;
+    rootValue?: ((parsedQuery: DocumentNode) => unknown) | unknown;
+    validationRules?: Array<ValidationRule>;
+    fieldResolver?: GraphQLFieldResolver<any, TContext>;
+    cache?: KeyValueCache<string> | 'bounded';
+    includeStacktraceInErrorResponses?: boolean;
+    logger?: Logger;
+    allowBatchedHttpRequests?: boolean;
+    stringifyResult?: (value: FormattedExecutionResult) => string | Promise<string>;
+    introspection?: boolean;
+    maxRecursiveSelections?: boolean | number;
+    hideSchemaDetailsFromClientErrors?: boolean;
+    plugins?: ApolloServerPlugin<TContext>[];
+    persistedQueries?: PersistedQueryOptions | false;
+    stopOnTerminationSignals?: boolean;
+    apollo?: ApolloConfigInput;
+    nodeEnv?: string;
+    documentStore?: DocumentStore | null;
+    dangerouslyDisableValidation?: boolean;
+    csrfPrevention?: CSRFPreventionOptions | boolean;
+    parseOptions?: ParseOptions;
+    status400ForVariableCoercionErrors?: boolean;
+    __testing_incrementalExecutionResults?: GraphQLExperimentalIncrementalExecutionResults;
+}
+export interface ApolloServerOptionsWithGateway<TContext extends BaseContext> extends ApolloServerOptionsBase<TContext> {
+    gateway: GatewayInterface;
+    schema?: undefined;
+    typeDefs?: undefined;
+    resolvers?: undefined;
+}
+export interface ApolloServerOptionsWithSchema<TContext extends BaseContext> extends ApolloServerOptionsBase<TContext> {
+    schema: GraphQLSchema;
+    gateway?: undefined;
+    typeDefs?: undefined;
+    resolvers?: undefined;
+}
+export interface ApolloServerOptionsWithTypeDefs<TContext extends BaseContext> extends ApolloServerOptionsBase<TContext> {
+    typeDefs: IExecutableSchemaDefinition<TContext>['typeDefs'];
+    resolvers?: IExecutableSchemaDefinition<TContext>['resolvers'];
+    gateway?: undefined;
+    schema?: undefined;
+}
+export type ApolloServerOptionsWithStaticSchema<TContext extends BaseContext> = ApolloServerOptionsWithSchema<TContext> | ApolloServerOptionsWithTypeDefs<TContext>;
+export type ApolloServerOptions<TContext extends BaseContext> = ApolloServerOptionsWithGateway<TContext> | ApolloServerOptionsWithStaticSchema<TContext>;
+export {};
+//# sourceMappingURL=constructor.d.ts.map

node_modules/@apollo/server/dist/cjs/externalTypes/constructor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constructor.d.ts","sourceRoot":"","sources":["../../../src/externalTypes/constructor.ts"],"names":[],"mappings":"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"}

node_modules/@apollo/server/dist/cjs/externalTypes/constructor.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=constructor.js.map

node_modules/@apollo/server/dist/cjs/externalTypes/constructor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constructor.js","sourceRoot":"","sources":["../../../src/externalTypes/constructor.ts"],"names":[],"mappings":""}

node_modules/@apollo/server/dist/cjs/externalTypes/context.d.ts

@@ -0,0 +1,4 @@
+export type BaseContext = {};
+export type ContextFunction<TIntegrationSpecificArgs extends any[], TContext extends BaseContext = BaseContext> = (...integrationContext: TIntegrationSpecificArgs) => Promise<TContext>;
+export type ContextThunk<TContext extends BaseContext = BaseContext> = () => Promise<TContext>;
+//# sourceMappingURL=context.d.ts.map

node_modules/@apollo/server/dist/cjs/externalTypes/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../../src/externalTypes/context.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,WAAW,GAAG,EAAE,CAAC;AAI7B,MAAM,MAAM,eAAe,CACzB,wBAAwB,SAAS,GAAG,EAAE,EACtC,QAAQ,SAAS,WAAW,GAAG,WAAW,IACxC,CAAC,GAAG,kBAAkB,EAAE,wBAAwB,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC;AAM3E,MAAM,MAAM,YAAY,CAAC,QAAQ,SAAS,WAAW,GAAG,WAAW,IACjE,MAAM,OAAO,CAAC,QAAQ,CAAC,CAAC"}

node_modules/@apollo/server/dist/cjs/externalTypes/context.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=context.js.map

node_modules/@apollo/server/dist/cjs/externalTypes/context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.js","sourceRoot":"","sources":["../../../src/externalTypes/context.ts"],"names":[],"mappings":""}

node_modules/@apollo/server/dist/cjs/externalTypes/graphql.d.ts

@@ -0,0 +1,32 @@
+import type { FormattedExecutionResult } from 'graphql';
+import type { BaseContext } from './context.js';
+import type { HTTPGraphQLHead, HTTPGraphQLRequest } from './http.js';
+import type { WithRequired } from '@apollo/utils.withrequired';
+import type { GraphQLExperimentalFormattedInitialIncrementalExecutionResult, GraphQLExperimentalFormattedSubsequentIncrementalExecutionResult } from './incrementalDeliveryPolyfill.js';
+export interface GraphQLRequest<TVariables extends VariableValues = VariableValues> {
+    query?: string;
+    operationName?: string;
+    variables?: TVariables;
+    extensions?: Record<string, any>;
+    http?: HTTPGraphQLRequest;
+}
+export type VariableValues = {
+    [name: string]: any;
+};
+export type GraphQLResponseBody<TData = Record<string, unknown>> = {
+    kind: 'single';
+    singleResult: FormattedExecutionResult<TData>;
+} | {
+    kind: 'incremental';
+    initialResult: GraphQLExperimentalFormattedInitialIncrementalExecutionResult;
+    subsequentResults: AsyncIterable<GraphQLExperimentalFormattedSubsequentIncrementalExecutionResult>;
+};
+export type GraphQLInProgressResponse<TData = Record<string, unknown>> = {
+    http: HTTPGraphQLHead;
+    body?: GraphQLResponseBody<TData>;
+};
+export type GraphQLResponse<TData = Record<string, unknown>> = WithRequired<GraphQLInProgressResponse<TData>, 'body'>;
+export interface ExecuteOperationOptions<TContext extends BaseContext> {
+    contextValue?: TContext;
+}
+//# sourceMappingURL=graphql.d.ts.map

node_modules/@apollo/server/dist/cjs/externalTypes/graphql.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphql.d.ts","sourceRoot":"","sources":["../../../src/externalTypes/graphql.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,SAAS,CAAC;AACxD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAChD,OAAO,KAAK,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AACrE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC/D,OAAO,KAAK,EACV,6DAA6D,EAC7D,gEAAgE,EACjE,MAAM,kCAAkC,CAAC;AAE1C,MAAM,WAAW,cAAc,CAC7B,UAAU,SAAS,cAAc,GAAG,cAAc;IAElD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,SAAS,CAAC,EAAE,UAAU,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IACjC,IAAI,CAAC,EAAE,kBAAkB,CAAC;CAC3B;AAED,MAAM,MAAM,cAAc,GAAG;IAAE,CAAC,IAAI,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,CAAC;AAOrD,MAAM,MAAM,mBAAmB,CAAC,KAAK,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,IAC3D;IACE,IAAI,EAAE,QAAQ,CAAC;IACf,YAAY,EAAE,wBAAwB,CAAC,KAAK,CAAC,CAAC;CAC/C,GACD;IACE,IAAI,EAAE,aAAa,CAAC;IACpB,aAAa,EAAE,6DAA6D,CAAC;IAC7E,iBAAiB,EAAE,aAAa,CAAC,gEAAgE,CAAC,CAAC;CACpG,CAAC;AAEN,MAAM,MAAM,yBAAyB,CAAC,KAAK,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI;IACvE,IAAI,EAAE,eAAe,CAAC;IACtB,IAAI,CAAC,EAAE,mBAAmB,CAAC,KAAK,CAAC,CAAC;CACnC,CAAC;AAEF,MAAM,MAAM,eAAe,CAAC,KAAK,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI,YAAY,CACzE,yBAAyB,CAAC,KAAK,CAAC,EAChC,MAAM,CACP,CAAC;AACF,MAAM,WAAW,uBAAuB,CAAC,QAAQ,SAAS,WAAW;IACnE,YAAY,CAAC,EAAE,QAAQ,CAAC;CACzB"}

node_modules/@apollo/server/dist/cjs/externalTypes/graphql.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=graphql.js.map

node_modules/@apollo/server/dist/cjs/externalTypes/graphql.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphql.js","sourceRoot":"","sources":["../../../src/externalTypes/graphql.ts"],"names":[],"mappings":""}

node_modules/@apollo/server/dist/cjs/externalTypes/http.d.ts

@@ -0,0 +1,22 @@
+import type { HeaderMap } from '../utils/HeaderMap.js';
+export interface HTTPGraphQLRequest {
+    method: string;
+    headers: HeaderMap;
+    search: string;
+    body: unknown;
+}
+export interface HTTPGraphQLHead {
+    status?: number;
+    headers: HeaderMap;
+}
+export type HTTPGraphQLResponseBody = {
+    kind: 'complete';
+    string: string;
+} | {
+    kind: 'chunked';
+    asyncIterator: AsyncIterableIterator<string>;
+};
+export type HTTPGraphQLResponse = HTTPGraphQLHead & {
+    body: HTTPGraphQLResponseBody;
+};
+//# sourceMappingURL=http.d.ts.map

node_modules/@apollo/server/dist/cjs/externalTypes/http.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http.d.ts","sourceRoot":"","sources":["../../../src/externalTypes/http.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAEvD,MAAM,WAAW,kBAAkB;IAEjC,MAAM,EAAE,MAAM,CAAC;IAGf,OAAO,EAAE,SAAS,CAAC;IAQnB,MAAM,EAAE,MAAM,CAAC;IAGf,IAAI,EAAE,OAAO,CAAC;CACf;AAED,MAAM,WAAW,eAAe;IAC9B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,SAAS,CAAC;CACpB;AAQD,MAAM,MAAM,uBAAuB,GAC/B;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GACpC;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,aAAa,EAAE,qBAAqB,CAAC,MAAM,CAAC,CAAA;CAAE,CAAC;AAEtE,MAAM,MAAM,mBAAmB,GAAG,eAAe,GAAG;IAClD,IAAI,EAAE,uBAAuB,CAAC;CAC/B,CAAC"}

node_modules/@apollo/server/dist/cjs/externalTypes/http.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=http.js.map

node_modules/@apollo/server/dist/cjs/externalTypes/http.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"http.js","sourceRoot":"","sources":["../../../src/externalTypes/http.ts"],"names":[],"mappings":""}

node_modules/@apollo/server/dist/cjs/externalTypes/incrementalDeliveryPolyfill.d.ts

@@ -0,0 +1,28 @@
+import type { FormattedExecutionResult, GraphQLFormattedError } from 'graphql';
+interface ObjMap<T> {
+    [key: string]: T;
+}
+export interface GraphQLExperimentalFormattedInitialIncrementalExecutionResult<TData = ObjMap<unknown>, TExtensions = ObjMap<unknown>> extends FormattedExecutionResult<TData, TExtensions> {
+    hasNext: boolean;
+    incremental?: ReadonlyArray<GraphQLExperimentalFormattedIncrementalResult<TData, TExtensions>>;
+    extensions?: TExtensions;
+}
+export interface GraphQLExperimentalFormattedSubsequentIncrementalExecutionResult<TData = ObjMap<unknown>, TExtensions = ObjMap<unknown>> {
+    hasNext: boolean;
+    incremental?: ReadonlyArray<GraphQLExperimentalFormattedIncrementalResult<TData, TExtensions>>;
+    extensions?: TExtensions;
+}
+export type GraphQLExperimentalFormattedIncrementalResult<TData = ObjMap<unknown>, TExtensions = ObjMap<unknown>> = GraphQLExperimentalFormattedIncrementalDeferResult<TData, TExtensions> | GraphQLExperimentalFormattedIncrementalStreamResult<TData, TExtensions>;
+export interface GraphQLExperimentalFormattedIncrementalDeferResult<TData = ObjMap<unknown>, TExtensions = ObjMap<unknown>> extends FormattedExecutionResult<TData, TExtensions> {
+    path?: ReadonlyArray<string | number>;
+    label?: string;
+}
+export interface GraphQLExperimentalFormattedIncrementalStreamResult<TData = Array<unknown>, TExtensions = ObjMap<unknown>> {
+    errors?: ReadonlyArray<GraphQLFormattedError>;
+    items?: TData | null;
+    path?: ReadonlyArray<string | number>;
+    label?: string;
+    extensions?: TExtensions;
+}
+export {};
+//# sourceMappingURL=incrementalDeliveryPolyfill.d.ts.map

node_modules/@apollo/server/dist/cjs/externalTypes/incrementalDeliveryPolyfill.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"incrementalDeliveryPolyfill.d.ts","sourceRoot":"","sources":["../../../src/externalTypes/incrementalDeliveryPolyfill.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAS/E,UAAU,MAAM,CAAC,CAAC;IAChB,CAAC,GAAG,EAAE,MAAM,GAAG,CAAC,CAAC;CAClB;AAED,MAAM,WAAW,6DAA6D,CAC5E,KAAK,GAAG,MAAM,CAAC,OAAO,CAAC,EACvB,WAAW,GAAG,MAAM,CAAC,OAAO,CAAC,CAC7B,SAAQ,wBAAwB,CAAC,KAAK,EAAE,WAAW,CAAC;IACpD,OAAO,EAAE,OAAO,CAAC;IACjB,WAAW,CAAC,EAAE,aAAa,CACzB,6CAA6C,CAAC,KAAK,EAAE,WAAW,CAAC,CAClE,CAAC;IACF,UAAU,CAAC,EAAE,WAAW,CAAC;CAC1B;AAED,MAAM,WAAW,gEAAgE,CAC/E,KAAK,GAAG,MAAM,CAAC,OAAO,CAAC,EACvB,WAAW,GAAG,MAAM,CAAC,OAAO,CAAC;IAE7B,OAAO,EAAE,OAAO,CAAC;IACjB,WAAW,CAAC,EAAE,aAAa,CACzB,6CAA6C,CAAC,KAAK,EAAE,WAAW,CAAC,CAClE,CAAC;IACF,UAAU,CAAC,EAAE,WAAW,CAAC;CAC1B;AAED,MAAM,MAAM,6CAA6C,CACvD,KAAK,GAAG,MAAM,CAAC,OAAO,CAAC,EACvB,WAAW,GAAG,MAAM,CAAC,OAAO,CAAC,IAE3B,kDAAkD,CAAC,KAAK,EAAE,WAAW,CAAC,GACtE,mDAAmD,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC;AAE5E,MAAM,WAAW,kDAAkD,CACjE,KAAK,GAAG,MAAM,CAAC,OAAO,CAAC,EACvB,WAAW,GAAG,MAAM,CAAC,OAAO,CAAC,CAC7B,SAAQ,wBAAwB,CAAC,KAAK,EAAE,WAAW,CAAC;IACpD,IAAI,CAAC,EAAE,aAAa,CAAC,MAAM,GAAG,MAAM,CAAC,CAAC;IACtC,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,mDAAmD,CAClE,KAAK,GAAG,KAAK,CAAC,OAAO,CAAC,EACtB,WAAW,GAAG,MAAM,CAAC,OAAO,CAAC;IAE7B,MAAM,CAAC,EAAE,aAAa,CAAC,qBAAqB,CAAC,CAAC;IAC9C,KAAK,CAAC,EAAE,KAAK,GAAG,IAAI,CAAC;IACrB,IAAI,CAAC,EAAE,aAAa,CAAC,MAAM,GAAG,MAAM,CAAC,CAAC;IACtC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,WAAW,CAAC;CAC1B"}

node_modules/@apollo/server/dist/cjs/externalTypes/incrementalDeliveryPolyfill.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=incrementalDeliveryPolyfill.js.map

node_modules/@apollo/server/dist/cjs/externalTypes/incrementalDeliveryPolyfill.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"incrementalDeliveryPolyfill.js","sourceRoot":"","sources":["../../../src/externalTypes/incrementalDeliveryPolyfill.ts"],"names":[],"mappings":""}

node_modules/@apollo/server/dist/cjs/externalTypes/index.d.ts

@@ -0,0 +1,8 @@
+export type { BaseContext, ContextFunction, ContextThunk } from './context.js';
+export type { GraphQLRequest, GraphQLResponse } from './graphql.js';
+export type { HTTPGraphQLRequest, HTTPGraphQLResponse, HTTPGraphQLHead, } from './http.js';
+export type { ApolloServerPlugin, GraphQLFieldResolverParams, GraphQLRequestExecutionListener, GraphQLRequestListener, GraphQLRequestListenerDidResolveField, GraphQLRequestListenerExecutionDidEnd, GraphQLRequestListenerParsingDidEnd, GraphQLRequestListenerValidationDidEnd, GraphQLSchemaContext, GraphQLServerListener, GraphQLServerContext, LandingPage, } from './plugins.js';
+export type { GraphQLRequestContext, GraphQLRequestMetrics, GraphQLRequestContextDidEncounterErrors, GraphQLRequestContextDidResolveOperation, GraphQLRequestContextDidResolveSource, GraphQLRequestContextExecutionDidStart, GraphQLRequestContextParsingDidStart, GraphQLRequestContextResponseForOperation, GraphQLRequestContextValidationDidStart, GraphQLRequestContextWillSendResponse, } from './requestPipeline.js';
+export type { DocumentStore, ApolloConfigInput, ApolloConfig, PersistedQueryOptions, CSRFPreventionOptions, ApolloServerOptionsWithSchema, ApolloServerOptionsWithTypeDefs, ApolloServerOptionsWithStaticSchema, ApolloServerOptionsWithGateway, ApolloServerOptions, } from './constructor.js';
+export type { GraphQLExperimentalFormattedInitialIncrementalExecutionResult, GraphQLExperimentalFormattedSubsequentIncrementalExecutionResult, GraphQLExperimentalFormattedIncrementalResult, GraphQLExperimentalFormattedIncrementalDeferResult, GraphQLExperimentalFormattedIncrementalStreamResult, } from './incrementalDeliveryPolyfill.js';
+//# sourceMappingURL=index.d.ts.map

node_modules/@apollo/server/dist/cjs/externalTypes/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/externalTypes/index.ts"],"names":[],"mappings":"AAMA,YAAY,EAAE,WAAW,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAC/E,YAAY,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AACpE,YAAY,EACV,kBAAkB,EAClB,mBAAmB,EACnB,eAAe,GAChB,MAAM,WAAW,CAAC;AACnB,YAAY,EACV,kBAAkB,EAClB,0BAA0B,EAC1B,+BAA+B,EAC/B,sBAAsB,EACtB,qCAAqC,EACrC,qCAAqC,EACrC,mCAAmC,EACnC,sCAAsC,EACtC,oBAAoB,EACpB,qBAAqB,EACrB,oBAAoB,EACpB,WAAW,GACZ,MAAM,cAAc,CAAC;AACtB,YAAY,EACV,qBAAqB,EACrB,qBAAqB,EACrB,uCAAuC,EACvC,wCAAwC,EACxC,qCAAqC,EACrC,sCAAsC,EACtC,oCAAoC,EACpC,yCAAyC,EACzC,uCAAuC,EACvC,qCAAqC,GACtC,MAAM,sBAAsB,CAAC;AAC9B,YAAY,EACV,aAAa,EACb,iBAAiB,EACjB,YAAY,EACZ,qBAAqB,EACrB,qBAAqB,EACrB,6BAA6B,EAC7B,+BAA+B,EAC/B,mCAAmC,EACnC,8BAA8B,EAC9B,mBAAmB,GACpB,MAAM,kBAAkB,CAAC;AAE1B,YAAY,EACV,6DAA6D,EAC7D,gEAAgE,EAChE,6CAA6C,EAC7C,kDAAkD,EAClD,mDAAmD,GACpD,MAAM,kCAAkC,CAAC"}

node_modules/@apollo/server/dist/cjs/externalTypes/index.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=index.js.map

node_modules/@apollo/server/dist/cjs/externalTypes/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/externalTypes/index.ts"],"names":[],"mappings":""}

node_modules/@apollo/server/dist/cjs/externalTypes/plugins.d.ts

@@ -0,0 +1,74 @@
+import type { KeyValueCache } from '@apollo/utils.keyvaluecache';
+import type { Logger } from '@apollo/utils.logger';
+import type { GraphQLError, GraphQLResolveInfo, GraphQLSchema } from 'graphql';
+import type { ApolloConfig } from './constructor.js';
+import type { BaseContext } from './context.js';
+import type { GraphQLResponse } from './graphql.js';
+import type { GraphQLExperimentalFormattedSubsequentIncrementalExecutionResult } from './incrementalDeliveryPolyfill.js';
+import type { GraphQLRequestContext, GraphQLRequestContextDidEncounterErrors, GraphQLRequestContextDidEncounterSubsequentErrors, GraphQLRequestContextDidResolveOperation, GraphQLRequestContextDidResolveSource, GraphQLRequestContextExecutionDidStart, GraphQLRequestContextParsingDidStart, GraphQLRequestContextResponseForOperation, GraphQLRequestContextValidationDidStart, GraphQLRequestContextWillSendResponse, GraphQLRequestContextWillSendSubsequentPayload } from './requestPipeline.js';
+export interface GraphQLServerContext {
+    readonly logger: Logger;
+    readonly cache: KeyValueCache<string>;
+    schema: GraphQLSchema;
+    apollo: ApolloConfig;
+    startedInBackground: boolean;
+}
+export interface GraphQLSchemaContext {
+    apiSchema: GraphQLSchema;
+    coreSupergraphSdl?: string;
+}
+export interface ApolloServerPlugin<in TContext extends BaseContext = BaseContext> {
+    serverWillStart?(service: GraphQLServerContext): Promise<GraphQLServerListener | void>;
+    requestDidStart?(requestContext: GraphQLRequestContext<TContext>): Promise<GraphQLRequestListener<TContext> | void>;
+    unexpectedErrorProcessingRequest?({ requestContext, error, }: {
+        requestContext: GraphQLRequestContext<TContext>;
+        error: Error;
+    }): Promise<void>;
+    contextCreationDidFail?({ error }: {
+        error: Error;
+    }): Promise<void>;
+    invalidRequestWasReceived?({ error }: {
+        error: Error;
+    }): Promise<void>;
+    startupDidFail?({ error }: {
+        error: Error;
+    }): Promise<void>;
+}
+export interface GraphQLServerListener {
+    schemaDidLoadOrUpdate?(schemaContext: GraphQLSchemaContext): void;
+    drainServer?(): Promise<void>;
+    serverWillStop?(): Promise<void>;
+    renderLandingPage?(): Promise<LandingPage>;
+}
+export interface LandingPage {
+    html: string | (() => Promise<string>);
+}
+export type GraphQLRequestListenerParsingDidEnd = (err?: Error) => Promise<void>;
+export type GraphQLRequestListenerValidationDidEnd = (err?: ReadonlyArray<Error>) => Promise<void>;
+export type GraphQLRequestListenerExecutionDidEnd = (err?: Error) => Promise<void>;
+export type GraphQLRequestListenerDidResolveField = (error: Error | null, result?: any) => void;
+export interface GraphQLRequestListener<TContext extends BaseContext> {
+    didResolveSource?(requestContext: GraphQLRequestContextDidResolveSource<TContext>): Promise<void>;
+    parsingDidStart?(requestContext: GraphQLRequestContextParsingDidStart<TContext>): Promise<GraphQLRequestListenerParsingDidEnd | void>;
+    validationDidStart?(requestContext: GraphQLRequestContextValidationDidStart<TContext>): Promise<GraphQLRequestListenerValidationDidEnd | void>;
+    didResolveOperation?(requestContext: GraphQLRequestContextDidResolveOperation<TContext>): Promise<void>;
+    didEncounterErrors?(requestContext: GraphQLRequestContextDidEncounterErrors<TContext>): Promise<void>;
+    responseForOperation?(requestContext: GraphQLRequestContextResponseForOperation<TContext>): Promise<GraphQLResponse | null>;
+    executionDidStart?(requestContext: GraphQLRequestContextExecutionDidStart<TContext>): Promise<GraphQLRequestExecutionListener<TContext> | void>;
+    willSendResponse?(requestContext: GraphQLRequestContextWillSendResponse<TContext>): Promise<void>;
+    didEncounterSubsequentErrors?(requestContext: GraphQLRequestContextDidEncounterSubsequentErrors<TContext>, errors: ReadonlyArray<GraphQLError>): Promise<void>;
+    willSendSubsequentPayload?(requestContext: GraphQLRequestContextWillSendSubsequentPayload<TContext>, payload: GraphQLExperimentalFormattedSubsequentIncrementalExecutionResult): Promise<void>;
+}
+export type GraphQLFieldResolverParams<TSource, TContext, TArgs = {
+    [argName: string]: any;
+}> = {
+    source: TSource;
+    args: TArgs;
+    contextValue: TContext;
+    info: GraphQLResolveInfo;
+};
+export interface GraphQLRequestExecutionListener<TContext extends BaseContext> {
+    executionDidEnd?: GraphQLRequestListenerExecutionDidEnd;
+    willResolveField?(fieldResolverParams: GraphQLFieldResolverParams<any, TContext>): GraphQLRequestListenerDidResolveField | void;
+}
+//# sourceMappingURL=plugins.d.ts.map

node_modules/@apollo/server/dist/cjs/externalTypes/plugins.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugins.d.ts","sourceRoot":"","sources":["../../../src/externalTypes/plugins.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AACjE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,KAAK,EAAE,YAAY,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAC/E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAChD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AACpD,OAAO,KAAK,EAAE,gEAAgE,EAAE,MAAM,kCAAkC,CAAC;AACzH,OAAO,KAAK,EACV,qBAAqB,EACrB,uCAAuC,EACvC,iDAAiD,EACjD,wCAAwC,EACxC,qCAAqC,EACrC,sCAAsC,EACtC,oCAAoC,EACpC,yCAAyC,EACzC,uCAAuC,EACvC,qCAAqC,EACrC,8CAA8C,EAC/C,MAAM,sBAAsB,CAAC;AAE9B,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAEtC,MAAM,EAAE,aAAa,CAAC;IACtB,MAAM,EAAE,YAAY,CAAC;IACrB,mBAAmB,EAAE,OAAO,CAAC;CAC9B;AAED,MAAM,WAAW,oBAAoB;IACnC,SAAS,EAAE,aAAa,CAAC;IACzB,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,kBAAkB,CACjC,EAAE,CAAC,QAAQ,SAAS,WAAW,GAAG,WAAW;IAG7C,eAAe,CAAC,CACd,OAAO,EAAE,oBAAoB,GAC5B,OAAO,CAAC,qBAAqB,GAAG,IAAI,CAAC,CAAC;IAKzC,eAAe,CAAC,CACd,cAAc,EAAE,qBAAqB,CAAC,QAAQ,CAAC,GAC9C,OAAO,CAAC,sBAAsB,CAAC,QAAQ,CAAC,GAAG,IAAI,CAAC,CAAC;IASpD,gCAAgC,CAAC,CAAC,EAChC,cAAc,EACd,KAAK,GACN,EAAE;QACD,cAAc,EAAE,qBAAqB,CAAC,QAAQ,CAAC,CAAC;QAChD,KAAK,EAAE,KAAK,CAAC;KACd,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAGlB,sBAAsB,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE;QAAE,KAAK,EAAE,KAAK,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAOpE,yBAAyB,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE;QAAE,KAAK,EAAE,KAAK,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAGvE,cAAc,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE;QAAE,KAAK,EAAE,KAAK,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC7D;AAED,MAAM,WAAW,qBAAqB;IAGpC,qBAAqB,CAAC,CAAC,aAAa,EAAE,oBAAoB,GAAG,IAAI,CAAC;IAQlE,WAAW,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAO9B,cAAc,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAQjC,iBAAiB,CAAC,IAAI,OAAO,CAAC,WAAW,CAAC,CAAC;CAC5C;AAGD,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,GAAG,CAAC,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC;CACxC;AAED,MAAM,MAAM,mCAAmC,GAAG,CAChD,GAAG,CAAC,EAAE,KAAK,KACR,OAAO,CAAC,IAAI,CAAC,CAAC;AACnB,MAAM,MAAM,sCAAsC,GAAG,CACnD,GAAG,CAAC,EAAE,aAAa,CAAC,KAAK,CAAC,KACvB,OAAO,CAAC,IAAI,CAAC,CAAC;AACnB,MAAM,MAAM,qCAAqC,GAAG,CAClD,GAAG,CAAC,EAAE,KAAK,KACR,OAAO,CAAC,IAAI,CAAC,CAAC;AACnB,MAAM,MAAM,qCAAqC,GAAG,CAClD,KAAK,EAAE,KAAK,GAAG,IAAI,EACnB,MAAM,CAAC,EAAE,GAAG,KACT,IAAI,CAAC;AAEV,MAAM,WAAW,sBAAsB,CAAC,QAAQ,SAAS,WAAW;IAClE,gBAAgB,CAAC,CACf,cAAc,EAAE,qCAAqC,CAAC,QAAQ,CAAC,GAC9D,OAAO,CAAC,IAAI,CAAC,CAAC;IAEjB,eAAe,CAAC,CACd,cAAc,EAAE,oCAAoC,CAAC,QAAQ,CAAC,GAC7D,OAAO,CAAC,mCAAmC,GAAG,IAAI,CAAC,CAAC;IAEvD,kBAAkB,CAAC,CACjB,cAAc,EAAE,uCAAuC,CAAC,QAAQ,CAAC,GAChE,OAAO,CAAC,sCAAsC,GAAG,IAAI,CAAC,CAAC;IAE1D,mBAAmB,CAAC,CAClB,cAAc,EAAE,wCAAwC,CAAC,QAAQ,CAAC,GACjE,OAAO,CAAC,IAAI,CAAC,CAAC;IAEjB,kBAAkB,CAAC,CACjB,cAAc,EAAE,uCAAuC,CAAC,QAAQ,CAAC,GAChE,OAAO,CAAC,IAAI,CAAC,CAAC;IAOjB,oBAAoB,CAAC,CACnB,cAAc,EAAE,yCAAyC,CAAC,QAAQ,CAAC,GAClE,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC,CAAC;IAInC,iBAAiB,CAAC,CAChB,cAAc,EAAE,sCAAsC,CAAC,QAAQ,CAAC,GAC/D,OAAO,CAAC,+BAA+B,CAAC,QAAQ,CAAC,GAAG,IAAI,CAAC,CAAC;IAI7D,gBAAgB,CAAC,CACf,cAAc,EAAE,qCAAqC,CAAC,QAAQ,CAAC,GAC9D,OAAO,CAAC,IAAI,CAAC,CAAC;IAEjB,4BAA4B,CAAC,CAC3B,cAAc,EAAE,iDAAiD,CAAC,QAAQ,CAAC,EAC3E,MAAM,EAAE,aAAa,CAAC,YAAY,CAAC,GAClC,OAAO,CAAC,IAAI,CAAC,CAAC;IAGjB,yBAAyB,CAAC,CACxB,cAAc,EAAE,8CAA8C,CAAC,QAAQ,CAAC,EACxE,OAAO,EAAE,gEAAgE,GACxE,OAAO,CAAC,IAAI,CAAC,CAAC;CAClB;AAYD,MAAM,MAAM,0BAA0B,CACpC,OAAO,EACP,QAAQ,EACR,KAAK,GAAG;IAAE,CAAC,OAAO,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,IAChC;IACF,MAAM,EAAE,OAAO,CAAC;IAChB,IAAI,EAAE,KAAK,CAAC;IACZ,YAAY,EAAE,QAAQ,CAAC;IACvB,IAAI,EAAE,kBAAkB,CAAC;CAC1B,CAAC;AAEF,MAAM,WAAW,+BAA+B,CAAC,QAAQ,SAAS,WAAW;IAC3E,eAAe,CAAC,EAAE,qCAAqC,CAAC;IAOxD,gBAAgB,CAAC,CACf,mBAAmB,EAAE,0BAA0B,CAAC,GAAG,EAAE,QAAQ,CAAC,GAC7D,qCAAqC,GAAG,IAAI,CAAC;CACjD"}

node_modules/@apollo/server/dist/cjs/externalTypes/plugins.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=plugins.js.map

node_modules/@apollo/server/dist/cjs/externalTypes/plugins.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugins.js","sourceRoot":"","sources":["../../../src/externalTypes/plugins.ts"],"names":[],"mappings":""}

node_modules/@apollo/server/dist/cjs/externalTypes/requestPipeline.d.ts

@@ -0,0 +1,50 @@
+import type { WithRequired } from '@apollo/utils.withrequired';
+import type { Trace } from '@apollo/usage-reporting-protobuf';
+import type { BaseContext } from './context.js';
+import type { GraphQLInProgressResponse, GraphQLRequest, GraphQLResponse } from './graphql.js';
+import type { Logger } from '@apollo/utils.logger';
+import type { KeyValueCache } from '@apollo/utils.keyvaluecache';
+import type { DocumentNode, GraphQLError, GraphQLSchema, OperationDefinitionNode } from 'graphql';
+import type { CachePolicy } from '@apollo/cache-control-types';
+import type { NonFtv1ErrorPath } from '@apollo/server-gateway-interface';
+export interface GraphQLRequestMetrics {
+    captureTraces?: boolean;
+    persistedQueryHit?: boolean;
+    persistedQueryRegister?: boolean;
+    responseCacheHit?: boolean;
+    forbiddenOperation?: boolean;
+    registeredOperation?: boolean;
+    startHrTime?: [number, number];
+    queryPlanTrace?: Trace.QueryPlanNode;
+    nonFtv1ErrorPaths?: NonFtv1ErrorPath[];
+}
+export interface GraphQLRequestContext<TContext extends BaseContext> {
+    readonly logger: Logger;
+    readonly cache: KeyValueCache<string>;
+    readonly request: GraphQLRequest;
+    readonly response: GraphQLInProgressResponse;
+    readonly schema: GraphQLSchema;
+    readonly contextValue: TContext;
+    readonly queryHash?: string;
+    readonly document?: DocumentNode;
+    readonly source?: string;
+    readonly operationName?: string | null;
+    readonly operation?: OperationDefinitionNode;
+    readonly errors?: ReadonlyArray<GraphQLError>;
+    readonly metrics: GraphQLRequestMetrics;
+    readonly overallCachePolicy: CachePolicy;
+    readonly requestIsBatched: boolean;
+}
+export type GraphQLRequestContextDidResolveSource<TContext extends BaseContext> = WithRequired<GraphQLRequestContext<TContext>, 'source' | 'queryHash'>;
+export type GraphQLRequestContextParsingDidStart<TContext extends BaseContext> = GraphQLRequestContextDidResolveSource<TContext>;
+export type GraphQLRequestContextValidationDidStart<TContext extends BaseContext> = GraphQLRequestContextParsingDidStart<TContext> & WithRequired<GraphQLRequestContext<TContext>, 'document'>;
+export type GraphQLRequestContextDidResolveOperation<TContext extends BaseContext> = GraphQLRequestContextValidationDidStart<TContext> & WithRequired<GraphQLRequestContext<TContext>, 'operationName'>;
+export type GraphQLRequestContextDidEncounterErrors<TContext extends BaseContext> = WithRequired<GraphQLRequestContext<TContext>, 'errors'>;
+export type GraphQLRequestContextResponseForOperation<TContext extends BaseContext> = WithRequired<GraphQLRequestContext<TContext>, 'source' | 'document' | 'operation' | 'operationName'>;
+export type GraphQLRequestContextExecutionDidStart<TContext extends BaseContext> = GraphQLRequestContextParsingDidStart<TContext> & WithRequired<GraphQLRequestContext<TContext>, 'document' | 'operation' | 'operationName'>;
+export type GraphQLRequestContextWillSendResponse<TContext extends BaseContext> = GraphQLRequestContextDidResolveSource<TContext> & {
+    readonly response: GraphQLResponse;
+};
+export type GraphQLRequestContextDidEncounterSubsequentErrors<TContext extends BaseContext> = GraphQLRequestContextWillSendResponse<TContext>;
+export type GraphQLRequestContextWillSendSubsequentPayload<TContext extends BaseContext> = GraphQLRequestContextWillSendResponse<TContext>;
+//# sourceMappingURL=requestPipeline.d.ts.map

node_modules/@apollo/server/dist/cjs/externalTypes/requestPipeline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"requestPipeline.d.ts","sourceRoot":"","sources":["../../../src/externalTypes/requestPipeline.ts"],"names":[],"mappings":"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"}

node_modules/@apollo/server/dist/cjs/externalTypes/requestPipeline.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=requestPipeline.js.map

node_modules/@apollo/server/dist/cjs/externalTypes/requestPipeline.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"requestPipeline.js","sourceRoot":"","sources":["../../../src/externalTypes/requestPipeline.ts"],"names":[],"mappings":""}

node_modules/@apollo/server/dist/cjs/generated/packageVersion.d.ts

@@ -0,0 +1,2 @@
+export declare const packageVersion = "4.12.1";
+//# sourceMappingURL=packageVersion.d.ts.map

node_modules/@apollo/server/dist/cjs/generated/packageVersion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"packageVersion.d.ts","sourceRoot":"","sources":["../../../src/generated/packageVersion.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,cAAc,WAAW,CAAC"}

node_modules/@apollo/server/dist/cjs/generated/packageVersion.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.packageVersion = void 0;
+exports.packageVersion = "4.12.1";
+//# sourceMappingURL=packageVersion.js.map

node_modules/@apollo/server/dist/cjs/generated/packageVersion.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"packageVersion.js","sourceRoot":"","sources":["../../../src/generated/packageVersion.ts"],"names":[],"mappings":";;;AAAa,QAAA,cAAc,GAAG,QAAQ,CAAC"}

node_modules/@apollo/server/dist/cjs/httpBatching.d.ts

@@ -0,0 +1,4 @@
+import type { BaseContext, HTTPGraphQLRequest, HTTPGraphQLResponse } from './externalTypes/index.js';
+import type { ApolloServer, ApolloServerInternals, SchemaDerivedData } from './ApolloServer';
+export declare function runPotentiallyBatchedHttpQuery<TContext extends BaseContext>(server: ApolloServer<TContext>, httpGraphQLRequest: HTTPGraphQLRequest, contextValue: TContext, schemaDerivedData: SchemaDerivedData, internals: ApolloServerInternals<TContext>): Promise<HTTPGraphQLResponse>;
+//# sourceMappingURL=httpBatching.d.ts.map

node_modules/@apollo/server/dist/cjs/httpBatching.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"httpBatching.d.ts","sourceRoot":"","sources":["../../src/httpBatching.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,WAAW,EACX,kBAAkB,EAClB,mBAAmB,EACpB,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EACV,YAAY,EACZ,qBAAqB,EACrB,iBAAiB,EAClB,MAAM,gBAAgB,CAAC;AA4DxB,wBAAsB,8BAA8B,CAClD,QAAQ,SAAS,WAAW,EAE5B,MAAM,EAAE,YAAY,CAAC,QAAQ,CAAC,EAC9B,kBAAkB,EAAE,kBAAkB,EACtC,YAAY,EAAE,QAAQ,EACtB,iBAAiB,EAAE,iBAAiB,EACpC,SAAS,EAAE,qBAAqB,CAAC,QAAQ,CAAC,GACzC,OAAO,CAAC,mBAAmB,CAAC,CA2B9B"}

node_modules/@apollo/server/dist/cjs/httpBatching.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runPotentiallyBatchedHttpQuery = void 0;
+const runHttpQuery_js_1 = require("./runHttpQuery.js");
+const internalErrorClasses_js_1 = require("./internalErrorClasses.js");
+async function runBatchedHttpQuery({ server, batchRequest, body, contextValue, schemaDerivedData, internals, }) {
+    if (body.length === 0) {
+        throw new internalErrorClasses_js_1.BadRequestError('No operations found in request.');
+    }
+    const sharedResponseHTTPGraphQLHead = (0, runHttpQuery_js_1.newHTTPGraphQLHead)();
+    const responseBodies = await Promise.all(body.map(async (bodyPiece) => {
+        const singleRequest = {
+            ...batchRequest,
+            body: bodyPiece,
+        };
+        const response = await (0, runHttpQuery_js_1.runHttpQuery)({
+            server,
+            httpRequest: singleRequest,
+            contextValue,
+            schemaDerivedData,
+            internals,
+            sharedResponseHTTPGraphQLHead,
+        });
+        if (response.body.kind === 'chunked') {
+            throw Error('Incremental delivery is not implemented for batch requests');
+        }
+        return response.body.string;
+    }));
+    return {
+        ...sharedResponseHTTPGraphQLHead,
+        body: { kind: 'complete', string: `[${responseBodies.join(',')}]` },
+    };
+}
+async function runPotentiallyBatchedHttpQuery(server, httpGraphQLRequest, contextValue, schemaDerivedData, internals) {
+    if (!(httpGraphQLRequest.method === 'POST' &&
+        Array.isArray(httpGraphQLRequest.body))) {
+        return await (0, runHttpQuery_js_1.runHttpQuery)({
+            server,
+            httpRequest: httpGraphQLRequest,
+            contextValue,
+            schemaDerivedData,
+            internals,
+            sharedResponseHTTPGraphQLHead: null,
+        });
+    }
+    if (internals.allowBatchedHttpRequests) {
+        return await runBatchedHttpQuery({
+            server,
+            batchRequest: httpGraphQLRequest,
+            body: httpGraphQLRequest.body,
+            contextValue,
+            schemaDerivedData,
+            internals,
+        });
+    }
+    throw new internalErrorClasses_js_1.BadRequestError('Operation batching disabled.');
+}
+exports.runPotentiallyBatchedHttpQuery = runPotentiallyBatchedHttpQuery;
+//# sourceMappingURL=httpBatching.js.map

node_modules/@apollo/server/dist/cjs/httpBatching.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"httpBatching.js","sourceRoot":"","sources":["../../src/httpBatching.ts"],"names":[],"mappings":";;;AAUA,uDAAqE;AACrE,uEAA4D;AAE5D,KAAK,UAAU,mBAAmB,CAA+B,EAC/D,MAAM,EACN,YAAY,EACZ,IAAI,EACJ,YAAY,EACZ,iBAAiB,EACjB,SAAS,GAQV;IACC,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACtB,MAAM,IAAI,yCAAe,CAAC,iCAAiC,CAAC,CAAC;IAC/D,CAAC;IAQD,MAAM,6BAA6B,GAAG,IAAA,oCAAkB,GAAE,CAAC;IAC3D,MAAM,cAAc,GAAG,MAAM,OAAO,CAAC,GAAG,CACtC,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,SAAkB,EAAE,EAAE;QACpC,MAAM,aAAa,GAAuB;YACxC,GAAG,YAAY;YACf,IAAI,EAAE,SAAS;SAChB,CAAC;QAEF,MAAM,QAAQ,GAAG,MAAM,IAAA,8BAAY,EAAC;YAClC,MAAM;YACN,WAAW,EAAE,aAAa;YAC1B,YAAY;YACZ,iBAAiB;YACjB,SAAS;YACT,6BAA6B;SAC9B,CAAC,CAAC;QAEH,IAAI,QAAQ,CAAC,IAAI,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;YACrC,MAAM,KAAK,CACT,4DAA4D,CAC7D,CAAC;QACJ,CAAC;QACD,OAAO,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC;IAC9B,CAAC,CAAC,CACH,CAAC;IACF,OAAO;QACL,GAAG,6BAA6B;QAChC,IAAI,EAAE,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,IAAI,cAAc,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE;KACpE,CAAC;AACJ,CAAC;AAEM,KAAK,UAAU,8BAA8B,CAGlD,MAA8B,EAC9B,kBAAsC,EACtC,YAAsB,EACtB,iBAAoC,EACpC,SAA0C;IAE1C,IACE,CAAC,CACC,kBAAkB,CAAC,MAAM,KAAK,MAAM;QACpC,KAAK,CAAC,OAAO,CAAC,kBAAkB,CAAC,IAAI,CAAC,CACvC,EACD,CAAC;QACD,OAAO,MAAM,IAAA,8BAAY,EAAC;YACxB,MAAM;YACN,WAAW,EAAE,kBAAkB;YAC/B,YAAY;YACZ,iBAAiB;YACjB,SAAS;YACT,6BAA6B,EAAE,IAAI;SACpC,CAAC,CAAC;IACL,CAAC;IACD,IAAI,SAAS,CAAC,wBAAwB,EAAE,CAAC;QACvC,OAAO,MAAM,mBAAmB,CAAC;YAC/B,MAAM;YACN,YAAY,EAAE,kBAAkB;YAChC,IAAI,EAAE,kBAAkB,CAAC,IAAiB;YAC1C,YAAY;YACZ,iBAAiB;YACjB,SAAS;SACV,CAAC,CAAC;IACL,CAAC;IACD,MAAM,IAAI,yCAAe,CAAC,8BAA8B,CAAC,CAAC;AAC5D,CAAC;AAnCD,wEAmCC"}

node_modules/@apollo/server/dist/cjs/incrementalDeliveryPolyfill.d.ts

@@ -0,0 +1,33 @@
+import { type ExecutionArgs, type ExecutionResult, type GraphQLError } from 'graphql';
+interface ObjMap<T> {
+    [key: string]: T;
+}
+export interface GraphQLExperimentalInitialIncrementalExecutionResult<TData = ObjMap<unknown>, TExtensions = ObjMap<unknown>> extends ExecutionResult<TData, TExtensions> {
+    hasNext: boolean;
+    incremental?: ReadonlyArray<GraphQLExperimentalIncrementalResult<TData, TExtensions>>;
+    extensions?: TExtensions;
+}
+export interface GraphQLExperimentalSubsequentIncrementalExecutionResult<TData = ObjMap<unknown>, TExtensions = ObjMap<unknown>> {
+    hasNext: boolean;
+    incremental?: ReadonlyArray<GraphQLExperimentalIncrementalResult<TData, TExtensions>>;
+    extensions?: TExtensions;
+}
+type GraphQLExperimentalIncrementalResult<TData = ObjMap<unknown>, TExtensions = ObjMap<unknown>> = GraphQLExperimentalIncrementalDeferResult<TData, TExtensions> | GraphQLExperimentalIncrementalStreamResult<TData, TExtensions>;
+interface GraphQLExperimentalIncrementalDeferResult<TData = ObjMap<unknown>, TExtensions = ObjMap<unknown>> extends ExecutionResult<TData, TExtensions> {
+    path?: ReadonlyArray<string | number>;
+    label?: string;
+}
+interface GraphQLExperimentalIncrementalStreamResult<TData = Array<unknown>, TExtensions = ObjMap<unknown>> {
+    errors?: ReadonlyArray<GraphQLError>;
+    items?: TData | null;
+    path?: ReadonlyArray<string | number>;
+    label?: string;
+    extensions?: TExtensions;
+}
+export interface GraphQLExperimentalIncrementalExecutionResults<TData = ObjMap<unknown>, TExtensions = ObjMap<unknown>> {
+    initialResult: GraphQLExperimentalInitialIncrementalExecutionResult<TData, TExtensions>;
+    subsequentResults: AsyncGenerator<GraphQLExperimentalSubsequentIncrementalExecutionResult<TData, TExtensions>, void, void>;
+}
+export declare function executeIncrementally(args: ExecutionArgs): Promise<ExecutionResult | GraphQLExperimentalIncrementalExecutionResults>;
+export {};
+//# sourceMappingURL=incrementalDeliveryPolyfill.d.ts.map

node_modules/@apollo/server/dist/cjs/incrementalDeliveryPolyfill.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"incrementalDeliveryPolyfill.d.ts","sourceRoot":"","sources":["../../src/incrementalDeliveryPolyfill.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,aAAa,EAClB,KAAK,eAAe,EACpB,KAAK,YAAY,EAClB,MAAM,SAAS,CAAC;AAOjB,UAAU,MAAM,CAAC,CAAC;IAChB,CAAC,GAAG,EAAE,MAAM,GAAG,CAAC,CAAC;CAClB;AACD,MAAM,WAAW,oDAAoD,CACnE,KAAK,GAAG,MAAM,CAAC,OAAO,CAAC,EACvB,WAAW,GAAG,MAAM,CAAC,OAAO,CAAC,CAC7B,SAAQ,eAAe,CAAC,KAAK,EAAE,WAAW,CAAC;IAC3C,OAAO,EAAE,OAAO,CAAC;IACjB,WAAW,CAAC,EAAE,aAAa,CACzB,oCAAoC,CAAC,KAAK,EAAE,WAAW,CAAC,CACzD,CAAC;IACF,UAAU,CAAC,EAAE,WAAW,CAAC;CAC1B;AAED,MAAM,WAAW,uDAAuD,CACtE,KAAK,GAAG,MAAM,CAAC,OAAO,CAAC,EACvB,WAAW,GAAG,MAAM,CAAC,OAAO,CAAC;IAE7B,OAAO,EAAE,OAAO,CAAC;IACjB,WAAW,CAAC,EAAE,aAAa,CACzB,oCAAoC,CAAC,KAAK,EAAE,WAAW,CAAC,CACzD,CAAC;IACF,UAAU,CAAC,EAAE,WAAW,CAAC;CAC1B;AAED,KAAK,oCAAoC,CACvC,KAAK,GAAG,MAAM,CAAC,OAAO,CAAC,EACvB,WAAW,GAAG,MAAM,CAAC,OAAO,CAAC,IAE3B,yCAAyC,CAAC,KAAK,EAAE,WAAW,CAAC,GAC7D,0CAA0C,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC;AAEnE,UAAU,yCAAyC,CACjD,KAAK,GAAG,MAAM,CAAC,OAAO,CAAC,EACvB,WAAW,GAAG,MAAM,CAAC,OAAO,CAAC,CAC7B,SAAQ,eAAe,CAAC,KAAK,EAAE,WAAW,CAAC;IAC3C,IAAI,CAAC,EAAE,aAAa,CAAC,MAAM,GAAG,MAAM,CAAC,CAAC;IACtC,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,UAAU,0CAA0C,CAClD,KAAK,GAAG,KAAK,CAAC,OAAO,CAAC,EACtB,WAAW,GAAG,MAAM,CAAC,OAAO,CAAC;IAE7B,MAAM,CAAC,EAAE,aAAa,CAAC,YAAY,CAAC,CAAC;IACrC,KAAK,CAAC,EAAE,KAAK,GAAG,IAAI,CAAC;IACrB,IAAI,CAAC,EAAE,aAAa,CAAC,MAAM,GAAG,MAAM,CAAC,CAAC;IACtC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,WAAW,CAAC;CAC1B;AAED,MAAM,WAAW,8CAA8C,CAC7D,KAAK,GAAG,MAAM,CAAC,OAAO,CAAC,EACvB,WAAW,GAAG,MAAM,CAAC,OAAO,CAAC;IAE7B,aAAa,EAAE,oDAAoD,CACjE,KAAK,EACL,WAAW,CACZ,CAAC;IACF,iBAAiB,EAAE,cAAc,CAC/B,uDAAuD,CAAC,KAAK,EAAE,WAAW,CAAC,EAC3E,IAAI,EACJ,IAAI,CACL,CAAC;CACH;AA8BD,wBAAsB,oBAAoB,CACxC,IAAI,EAAE,aAAa,GAClB,OAAO,CAAC,eAAe,GAAG,8CAA8C,CAAC,CAM3E"}

node_modules/@apollo/server/dist/cjs/incrementalDeliveryPolyfill.js

@@ -0,0 +1,50 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeIncrementally = void 0;
+const graphql_1 = require("graphql");
+let graphqlExperimentalExecuteIncrementally = undefined;
+async function tryToLoadGraphQL17() {
+    if (graphqlExperimentalExecuteIncrementally !== undefined) {
+        return;
+    }
+    const graphql = await Promise.resolve().then(() => __importStar(require('graphql')));
+    if ('experimentalExecuteIncrementally' in graphql) {
+        graphqlExperimentalExecuteIncrementally = graphql
+            .experimentalExecuteIncrementally;
+    }
+    else {
+        graphqlExperimentalExecuteIncrementally = null;
+    }
+}
+async function executeIncrementally(args) {
+    await tryToLoadGraphQL17();
+    if (graphqlExperimentalExecuteIncrementally) {
+        return graphqlExperimentalExecuteIncrementally(args);
+    }
+    return (0, graphql_1.execute)(args);
+}
+exports.executeIncrementally = executeIncrementally;
+//# sourceMappingURL=incrementalDeliveryPolyfill.js.map

node_modules/@apollo/server/dist/cjs/incrementalDeliveryPolyfill.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"incrementalDeliveryPolyfill.js","sourceRoot":"","sources":["../../src/incrementalDeliveryPolyfill.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,qCAKiB;AA+EjB,IAAI,uCAAuC,GAO3B,SAAS,CAAC;AAE1B,KAAK,UAAU,kBAAkB;IAC/B,IAAI,uCAAuC,KAAK,SAAS,EAAE,CAAC;QAC1D,OAAO;IACT,CAAC;IACD,MAAM,OAAO,GAAG,wDAAa,SAAS,GAAC,CAAC;IACxC,IAAI,kCAAkC,IAAI,OAAO,EAAE,CAAC;QAClD,uCAAuC,GAAI,OAAe;aACvD,gCAAgC,CAAC;IACtC,CAAC;SAAM,CAAC;QACN,uCAAuC,GAAG,IAAI,CAAC;IACjD,CAAC;AACH,CAAC;AAEM,KAAK,UAAU,oBAAoB,CACxC,IAAmB;IAEnB,MAAM,kBAAkB,EAAE,CAAC;IAC3B,IAAI,uCAAuC,EAAE,CAAC;QAC5C,OAAO,uCAAuC,CAAC,IAAI,CAAC,CAAC;IACvD,CAAC;IACD,OAAO,IAAA,iBAAO,EAAC,IAAI,CAAC,CAAC;AACvB,CAAC;AARD,oDAQC"}

node_modules/@apollo/server/dist/cjs/index.d.ts

@@ -0,0 +1,4 @@
+export { ApolloServer } from './ApolloServer.js';
+export { HeaderMap } from './utils/HeaderMap.js';
+export * from './externalTypes/index.js';
+//# sourceMappingURL=index.d.ts.map

node_modules/@apollo/server/dist/cjs/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAEjD,cAAc,0BAA0B,CAAC"}

node_modules/@apollo/server/dist/cjs/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HeaderMap = exports.ApolloServer = void 0;
+var ApolloServer_js_1 = require("./ApolloServer.js");
+Object.defineProperty(exports, "ApolloServer", { enumerable: true, get: function () { return ApolloServer_js_1.ApolloServer; } });
+var HeaderMap_js_1 = require("./utils/HeaderMap.js");
+Object.defineProperty(exports, "HeaderMap", { enumerable: true, get: function () { return HeaderMap_js_1.HeaderMap; } });
+__exportStar(require("./externalTypes/index.js"), exports);
+//# sourceMappingURL=index.js.map

node_modules/@apollo/server/dist/cjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAAA,qDAAiD;AAAxC,+GAAA,YAAY,OAAA;AACrB,qDAAiD;AAAxC,yGAAA,SAAS,OAAA;AAElB,2DAAyC"}

node_modules/@apollo/server/dist/cjs/internalErrorClasses.d.ts

@@ -0,0 +1,28 @@
+import { GraphQLError, type GraphQLErrorOptions } from 'graphql';
+import { ApolloServerErrorCode } from './errors/index.js';
+declare class GraphQLErrorWithCode extends GraphQLError {
+    constructor(message: string, code: ApolloServerErrorCode, options?: GraphQLErrorOptions);
+}
+export declare class SyntaxError extends GraphQLErrorWithCode {
+    constructor(graphqlError: GraphQLError);
+}
+export declare class ValidationError extends GraphQLErrorWithCode {
+    constructor(graphqlError: GraphQLError);
+}
+export declare class PersistedQueryNotFoundError extends GraphQLErrorWithCode {
+    constructor();
+}
+export declare class PersistedQueryNotSupportedError extends GraphQLErrorWithCode {
+    constructor();
+}
+export declare class UserInputError extends GraphQLErrorWithCode {
+    constructor(graphqlError: GraphQLError);
+}
+export declare class OperationResolutionError extends GraphQLErrorWithCode {
+    constructor(graphqlError: GraphQLError);
+}
+export declare class BadRequestError extends GraphQLErrorWithCode {
+    constructor(message: string, options?: GraphQLErrorOptions);
+}
+export {};
+//# sourceMappingURL=internalErrorClasses.d.ts.map

node_modules/@apollo/server/dist/cjs/internalErrorClasses.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internalErrorClasses.d.ts","sourceRoot":"","sources":["../../src/internalErrorClasses.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,KAAK,mBAAmB,EAAE,MAAM,SAAS,CAAC;AACjE,OAAO,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAO1D,cAAM,oBAAqB,SAAQ,YAAY;gBAE3C,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,qBAAqB,EAC3B,OAAO,CAAC,EAAE,mBAAmB;CAQhC;AAED,qBAAa,WAAY,SAAQ,oBAAoB;gBACvC,YAAY,EAAE,YAAY;CAQvC;AAED,qBAAa,eAAgB,SAAQ,oBAAoB;gBAC3C,YAAY,EAAE,YAAY;CAcvC;AAcD,qBAAa,2BAA4B,SAAQ,oBAAoB;;CAQpE;AAED,qBAAa,+BAAgC,SAAQ,oBAAoB;;CAYxE;AAED,qBAAa,cAAe,SAAQ,oBAAoB;gBAC1C,YAAY,EAAE,YAAY;CAOvC;AAED,qBAAa,wBAAyB,SAAQ,oBAAoB;gBACpD,YAAY,EAAE,YAAY;CAcvC;AAED,qBAAa,eAAgB,SAAQ,oBAAoB;gBAC3C,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,mBAAmB;CAQ3D"}

node_modules/@apollo/server/dist/cjs/internalErrorClasses.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BadRequestError = exports.OperationResolutionError = exports.UserInputError = exports.PersistedQueryNotSupportedError = exports.PersistedQueryNotFoundError = exports.ValidationError = exports.SyntaxError = void 0;
+const graphql_1 = require("graphql");
+const index_js_1 = require("./errors/index.js");
+const runHttpQuery_js_1 = require("./runHttpQuery.js");
+const HeaderMap_js_1 = require("./utils/HeaderMap.js");
+class GraphQLErrorWithCode extends graphql_1.GraphQLError {
+    constructor(message, code, options) {
+        super(message, {
+            ...options,
+            extensions: { ...options?.extensions, code },
+        });
+        this.name = this.constructor.name;
+    }
+}
+class SyntaxError extends GraphQLErrorWithCode {
+    constructor(graphqlError) {
+        super(graphqlError.message, index_js_1.ApolloServerErrorCode.GRAPHQL_PARSE_FAILED, {
+            source: graphqlError.source,
+            positions: graphqlError.positions,
+            extensions: { http: (0, runHttpQuery_js_1.newHTTPGraphQLHead)(400), ...graphqlError.extensions },
+            originalError: graphqlError,
+        });
+    }
+}
+exports.SyntaxError = SyntaxError;
+class ValidationError extends GraphQLErrorWithCode {
+    constructor(graphqlError) {
+        super(graphqlError.message, index_js_1.ApolloServerErrorCode.GRAPHQL_VALIDATION_FAILED, {
+            nodes: graphqlError.nodes,
+            extensions: {
+                http: (0, runHttpQuery_js_1.newHTTPGraphQLHead)(400),
+                ...graphqlError.extensions,
+            },
+            originalError: graphqlError.originalError ?? graphqlError,
+        });
+    }
+}
+exports.ValidationError = ValidationError;
+const getPersistedQueryErrorHttp = () => ({
+    status: 200,
+    headers: new HeaderMap_js_1.HeaderMap([
+        ['cache-control', 'private, no-cache, must-revalidate'],
+    ]),
+});
+class PersistedQueryNotFoundError extends GraphQLErrorWithCode {
+    constructor() {
+        super('PersistedQueryNotFound', index_js_1.ApolloServerErrorCode.PERSISTED_QUERY_NOT_FOUND, { extensions: { http: getPersistedQueryErrorHttp() } });
+    }
+}
+exports.PersistedQueryNotFoundError = PersistedQueryNotFoundError;
+class PersistedQueryNotSupportedError extends GraphQLErrorWithCode {
+    constructor() {
+        super('PersistedQueryNotSupported', index_js_1.ApolloServerErrorCode.PERSISTED_QUERY_NOT_SUPPORTED, { extensions: { http: getPersistedQueryErrorHttp() } });
+    }
+}
+exports.PersistedQueryNotSupportedError = PersistedQueryNotSupportedError;
+class UserInputError extends GraphQLErrorWithCode {
+    constructor(graphqlError) {
+        super(graphqlError.message, index_js_1.ApolloServerErrorCode.BAD_USER_INPUT, {
+            nodes: graphqlError.nodes,
+            originalError: graphqlError.originalError ?? graphqlError,
+            extensions: graphqlError.extensions,
+        });
+    }
+}
+exports.UserInputError = UserInputError;
+class OperationResolutionError extends GraphQLErrorWithCode {
+    constructor(graphqlError) {
+        super(graphqlError.message, index_js_1.ApolloServerErrorCode.OPERATION_RESOLUTION_FAILURE, {
+            nodes: graphqlError.nodes,
+            originalError: graphqlError.originalError ?? graphqlError,
+            extensions: {
+                http: (0, runHttpQuery_js_1.newHTTPGraphQLHead)(400),
+                ...graphqlError.extensions,
+            },
+        });
+    }
+}
+exports.OperationResolutionError = OperationResolutionError;
+class BadRequestError extends GraphQLErrorWithCode {
+    constructor(message, options) {
+        super(message, index_js_1.ApolloServerErrorCode.BAD_REQUEST, {
+            ...options,
+            extensions: { http: (0, runHttpQuery_js_1.newHTTPGraphQLHead)(400), ...options?.extensions },
+        });
+    }
+}
+exports.BadRequestError = BadRequestError;
+//# sourceMappingURL=internalErrorClasses.js.map

node_modules/@apollo/server/dist/cjs/internalErrorClasses.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"internalErrorClasses.js","sourceRoot":"","sources":["../../src/internalErrorClasses.ts"],"names":[],"mappings":"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"}

node_modules/@apollo/server/dist/cjs/internalPlugin.d.ts

@@ -0,0 +1,9 @@
+import type { BaseContext, ApolloServerPlugin } from './externalTypes/index.js';
+export interface InternalApolloServerPlugin<TContext extends BaseContext> extends ApolloServerPlugin<TContext> {
+    __internal_plugin_id__: InternalPluginId;
+    __is_disabled_plugin__: boolean;
+}
+export declare function internalPlugin<TContext extends BaseContext>(p: InternalApolloServerPlugin<TContext>): ApolloServerPlugin<TContext>;
+export type InternalPluginId = 'CacheControl' | 'LandingPageDisabled' | 'SchemaReporting' | 'InlineTrace' | 'UsageReporting' | 'DisableSuggestions';
+export declare function pluginIsInternal<TContext extends BaseContext>(plugin: ApolloServerPlugin<TContext>): plugin is InternalApolloServerPlugin<TContext>;
+//# sourceMappingURL=internalPlugin.d.ts.map

node_modules/@apollo/server/dist/cjs/internalPlugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internalPlugin.d.ts","sourceRoot":"","sources":["../../src/internalPlugin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAShF,MAAM,WAAW,0BAA0B,CAAC,QAAQ,SAAS,WAAW,CACtE,SAAQ,kBAAkB,CAAC,QAAQ,CAAC;IAGpC,sBAAsB,EAAE,gBAAgB,CAAC;IACzC,sBAAsB,EAAE,OAAO,CAAC;CACjC;AAMD,wBAAgB,cAAc,CAAC,QAAQ,SAAS,WAAW,EACzD,CAAC,EAAE,0BAA0B,CAAC,QAAQ,CAAC,GACtC,kBAAkB,CAAC,QAAQ,CAAC,CAE9B;AAED,MAAM,MAAM,gBAAgB,GACxB,cAAc,GACd,qBAAqB,GACrB,iBAAiB,GACjB,aAAa,GACb,gBAAgB,GAChB,oBAAoB,CAAC;AAEzB,wBAAgB,gBAAgB,CAAC,QAAQ,SAAS,WAAW,EAC3D,MAAM,EAAE,kBAAkB,CAAC,QAAQ,CAAC,GACnC,MAAM,IAAI,0BAA0B,CAAC,QAAQ,CAAC,CAIhD"}

node_modules/@apollo/server/dist/cjs/internalPlugin.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pluginIsInternal = exports.internalPlugin = void 0;
+function internalPlugin(p) {
+    return p;
+}
+exports.internalPlugin = internalPlugin;
+function pluginIsInternal(plugin) {
+    return '__internal_plugin_id__' in plugin;
+}
+exports.pluginIsInternal = pluginIsInternal;
+//# sourceMappingURL=internalPlugin.js.map

node_modules/@apollo/server/dist/cjs/internalPlugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"internalPlugin.js","sourceRoot":"","sources":["../../src/internalPlugin.ts"],"names":[],"mappings":";;;AAqBA,SAAgB,cAAc,CAC5B,CAAuC;IAEvC,OAAO,CAAC,CAAC;AACX,CAAC;AAJD,wCAIC;AAUD,SAAgB,gBAAgB,CAC9B,MAAoC;IAIpC,OAAO,wBAAwB,IAAI,MAAM,CAAC;AAC5C,CAAC;AAND,4CAMC"}

node_modules/@apollo/server/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

node_modules/@apollo/server/dist/cjs/plugin/cacheControl/index.d.ts

@@ -0,0 +1,9 @@
+import type { ApolloServerPlugin } from '../../externalTypes/index.js';
+import type { CacheHint } from '@apollo/cache-control-types';
+export interface ApolloServerPluginCacheControlOptions {
+    defaultMaxAge?: number;
+    calculateHttpHeaders?: boolean | 'if-cacheable';
+    __testing__cacheHints?: Map<string, CacheHint>;
+}
+export declare function ApolloServerPluginCacheControl(options?: ApolloServerPluginCacheControlOptions): ApolloServerPlugin;
+//# sourceMappingURL=index.d.ts.map

node_modules/@apollo/server/dist/cjs/plugin/cacheControl/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugin/cacheControl/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AAcvE,OAAO,KAAK,EACV,SAAS,EAGV,MAAM,6BAA6B,CAAC;AAYrC,MAAM,WAAW,qCAAqC;IASpD,aAAa,CAAC,EAAE,MAAM,CAAC;IAUvB,oBAAoB,CAAC,EAAE,OAAO,GAAG,cAAc,CAAC;IAEhD,qBAAqB,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;CAChD;AAED,wBAAgB,8BAA8B,CAC5C,OAAO,GAAE,qCAA2D,GACnE,kBAAkB,CAyRpB"}

node_modules/@apollo/server/dist/cjs/plugin/cacheControl/index.js

@@ -0,0 +1,227 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApolloServerPluginCacheControl = void 0;
+const graphql_1 = require("graphql");
+const cachePolicy_js_1 = require("../../cachePolicy.js");
+const internalPlugin_js_1 = require("../../internalPlugin.js");
+const lru_cache_1 = __importDefault(require("lru-cache"));
+function ApolloServerPluginCacheControl(options = Object.create(null)) {
+    let typeAnnotationCache;
+    let fieldAnnotationCache;
+    return (0, internalPlugin_js_1.internalPlugin)({
+        __internal_plugin_id__: 'CacheControl',
+        __is_disabled_plugin__: false,
+        async serverWillStart({ schema }) {
+            typeAnnotationCache = new lru_cache_1.default({
+                max: Object.values(schema.getTypeMap()).filter(graphql_1.isCompositeType)
+                    .length,
+            });
+            fieldAnnotationCache = new lru_cache_1.default({
+                max: Object.values(schema.getTypeMap())
+                    .filter(graphql_1.isObjectType)
+                    .flatMap((t) => Object.values(t.getFields())).length +
+                    Object.values(schema.getTypeMap())
+                        .filter(graphql_1.isInterfaceType)
+                        .flatMap((t) => Object.values(t.getFields())).length,
+            });
+            return undefined;
+        },
+        async requestDidStart(requestContext) {
+            function memoizedCacheAnnotationFromType(t) {
+                const existing = typeAnnotationCache.get(t);
+                if (existing) {
+                    return existing;
+                }
+                const annotation = cacheAnnotationFromType(t);
+                typeAnnotationCache.set(t, annotation);
+                return annotation;
+            }
+            function memoizedCacheAnnotationFromField(field) {
+                const existing = fieldAnnotationCache.get(field);
+                if (existing) {
+                    return existing;
+                }
+                const annotation = cacheAnnotationFromField(field);
+                fieldAnnotationCache.set(field, annotation);
+                return annotation;
+            }
+            const defaultMaxAge = options.defaultMaxAge ?? 0;
+            const calculateHttpHeaders = options.calculateHttpHeaders ?? true;
+            const { __testing__cacheHints } = options;
+            return {
+                async executionDidStart() {
+                    if (isRestricted(requestContext.overallCachePolicy)) {
+                        const fakeFieldPolicy = (0, cachePolicy_js_1.newCachePolicy)();
+                        return {
+                            willResolveField({ info }) {
+                                info.cacheControl = {
+                                    setCacheHint: (dynamicHint) => {
+                                        fakeFieldPolicy.replace(dynamicHint);
+                                    },
+                                    cacheHint: fakeFieldPolicy,
+                                    cacheHintFromType: memoizedCacheAnnotationFromType,
+                                };
+                            },
+                        };
+                    }
+                    return {
+                        willResolveField({ info }) {
+                            const fieldPolicy = (0, cachePolicy_js_1.newCachePolicy)();
+                            let inheritMaxAge = false;
+                            const targetType = (0, graphql_1.getNamedType)(info.returnType);
+                            if ((0, graphql_1.isCompositeType)(targetType)) {
+                                const typeAnnotation = memoizedCacheAnnotationFromType(targetType);
+                                fieldPolicy.replace(typeAnnotation);
+                                inheritMaxAge = !!typeAnnotation.inheritMaxAge;
+                            }
+                            const fieldAnnotation = memoizedCacheAnnotationFromField(info.parentType.getFields()[info.fieldName]);
+                            if (fieldAnnotation.inheritMaxAge &&
+                                fieldPolicy.maxAge === undefined) {
+                                inheritMaxAge = true;
+                                if (fieldAnnotation.scope) {
+                                    fieldPolicy.replace({ scope: fieldAnnotation.scope });
+                                }
+                            }
+                            else {
+                                fieldPolicy.replace(fieldAnnotation);
+                            }
+                            info.cacheControl = {
+                                setCacheHint: (dynamicHint) => {
+                                    fieldPolicy.replace(dynamicHint);
+                                },
+                                cacheHint: fieldPolicy,
+                                cacheHintFromType: memoizedCacheAnnotationFromType,
+                            };
+                            return () => {
+                                if (fieldPolicy.maxAge === undefined &&
+                                    (((0, graphql_1.isCompositeType)(targetType) && !inheritMaxAge) ||
+                                        !info.path.prev)) {
+                                    fieldPolicy.restrict({ maxAge: defaultMaxAge });
+                                }
+                                if (__testing__cacheHints && isRestricted(fieldPolicy)) {
+                                    const path = (0, graphql_1.responsePathAsArray)(info.path).join('.');
+                                    if (__testing__cacheHints.has(path)) {
+                                        throw Error("shouldn't happen: addHint should only be called once per path");
+                                    }
+                                    __testing__cacheHints.set(path, {
+                                        maxAge: fieldPolicy.maxAge,
+                                        scope: fieldPolicy.scope,
+                                    });
+                                }
+                                requestContext.overallCachePolicy.restrict(fieldPolicy);
+                            };
+                        },
+                    };
+                },
+                async willSendResponse(requestContext) {
+                    if (!calculateHttpHeaders) {
+                        return;
+                    }
+                    const { response, overallCachePolicy } = requestContext;
+                    const existingCacheControlHeader = parseExistingCacheControlHeader(response.http.headers.get('cache-control'));
+                    if (existingCacheControlHeader.kind === 'unparsable') {
+                        return;
+                    }
+                    const cachePolicy = (0, cachePolicy_js_1.newCachePolicy)();
+                    cachePolicy.replace(overallCachePolicy);
+                    if (existingCacheControlHeader.kind === 'parsable-and-cacheable') {
+                        cachePolicy.restrict(existingCacheControlHeader.hint);
+                    }
+                    const policyIfCacheable = cachePolicy.policyIfCacheable();
+                    if (policyIfCacheable &&
+                        existingCacheControlHeader.kind !== 'uncacheable' &&
+                        response.body.kind === 'single' &&
+                        !response.body.singleResult.errors) {
+                        response.http.headers.set('cache-control', `max-age=${policyIfCacheable.maxAge}, ${policyIfCacheable.scope.toLowerCase()}`);
+                    }
+                    else if (calculateHttpHeaders !== 'if-cacheable') {
+                        response.http.headers.set('cache-control', CACHE_CONTROL_HEADER_UNCACHEABLE);
+                    }
+                },
+            };
+        },
+    });
+}
+exports.ApolloServerPluginCacheControl = ApolloServerPluginCacheControl;
+const CACHE_CONTROL_HEADER_CACHEABLE_REGEXP = /^max-age=(\d+), (public|private)$/;
+const CACHE_CONTROL_HEADER_UNCACHEABLE = 'no-store';
+function parseExistingCacheControlHeader(header) {
+    if (!header) {
+        return { kind: 'no-header' };
+    }
+    if (header === CACHE_CONTROL_HEADER_UNCACHEABLE) {
+        return { kind: 'uncacheable' };
+    }
+    const match = CACHE_CONTROL_HEADER_CACHEABLE_REGEXP.exec(header);
+    if (!match) {
+        return { kind: 'unparsable' };
+    }
+    return {
+        kind: 'parsable-and-cacheable',
+        hint: {
+            maxAge: +match[1],
+            scope: match[2] === 'public' ? 'PUBLIC' : 'PRIVATE',
+        },
+    };
+}
+function cacheAnnotationFromDirectives(directives) {
+    if (!directives)
+        return undefined;
+    const cacheControlDirective = directives.find((directive) => directive.name.value === 'cacheControl');
+    if (!cacheControlDirective)
+        return undefined;
+    if (!cacheControlDirective.arguments)
+        return undefined;
+    const maxAgeArgument = cacheControlDirective.arguments.find((argument) => argument.name.value === 'maxAge');
+    const scopeArgument = cacheControlDirective.arguments.find((argument) => argument.name.value === 'scope');
+    const inheritMaxAgeArgument = cacheControlDirective.arguments.find((argument) => argument.name.value === 'inheritMaxAge');
+    const scopeString = scopeArgument?.value?.kind === 'EnumValue'
+        ? scopeArgument.value.value
+        : undefined;
+    const scope = scopeString === 'PUBLIC' || scopeString === 'PRIVATE'
+        ? scopeString
+        : undefined;
+    if (inheritMaxAgeArgument?.value?.kind === 'BooleanValue' &&
+        inheritMaxAgeArgument.value.value) {
+        return { inheritMaxAge: true, scope };
+    }
+    return {
+        maxAge: maxAgeArgument?.value?.kind === 'IntValue'
+            ? parseInt(maxAgeArgument.value.value)
+            : undefined,
+        scope,
+    };
+}
+function cacheAnnotationFromType(t) {
+    if (t.astNode) {
+        const hint = cacheAnnotationFromDirectives(t.astNode.directives);
+        if (hint) {
+            return hint;
+        }
+    }
+    if (t.extensionASTNodes) {
+        for (const node of t.extensionASTNodes) {
+            const hint = cacheAnnotationFromDirectives(node.directives);
+            if (hint) {
+                return hint;
+            }
+        }
+    }
+    return {};
+}
+function cacheAnnotationFromField(field) {
+    if (field.astNode) {
+        const hint = cacheAnnotationFromDirectives(field.astNode.directives);
+        if (hint) {
+            return hint;
+        }
+    }
+    return {};
+}
+function isRestricted(hint) {
+    return hint.maxAge !== undefined || hint.scope !== undefined;
+}
+//# sourceMappingURL=index.js.map

node_modules/@apollo/server/dist/cjs/plugin/disableSuggestions/index.d.ts

@@ -0,0 +1,3 @@
+import type { ApolloServerPlugin } from '../../externalTypes/index.js';
+export declare function ApolloServerPluginDisableSuggestions(): ApolloServerPlugin;
+//# sourceMappingURL=index.d.ts.map

node_modules/@apollo/server/dist/cjs/plugin/disableSuggestions/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugin/disableSuggestions/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AAGvE,wBAAgB,oCAAoC,IAAI,kBAAkB,CAmBzE"}

node_modules/@apollo/server/dist/cjs/plugin/disableSuggestions/index.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApolloServerPluginDisableSuggestions = void 0;
+const internalPlugin_js_1 = require("../../internalPlugin.js");
+function ApolloServerPluginDisableSuggestions() {
+    return (0, internalPlugin_js_1.internalPlugin)({
+        __internal_plugin_id__: 'DisableSuggestions',
+        __is_disabled_plugin__: false,
+        async requestDidStart() {
+            return {
+                async validationDidStart() {
+                    return async (validationErrors) => {
+                        validationErrors?.forEach((error) => {
+                            error.message = error.message.replace(/ ?Did you mean(.+?)\?$/, '');
+                        });
+                    };
+                },
+            };
+        },
+    });
+}
+exports.ApolloServerPluginDisableSuggestions = ApolloServerPluginDisableSuggestions;
+//# sourceMappingURL=index.js.map

node_modules/@apollo/server/dist/cjs/plugin/disableSuggestions/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/plugin/disableSuggestions/index.ts"],"names":[],"mappings":";;;AACA,+DAAyD;AAEzD,SAAgB,oCAAoC;IAClD,OAAO,IAAA,kCAAc,EAAC;QACpB,sBAAsB,EAAE,oBAAoB;QAC5C,sBAAsB,EAAE,KAAK;QAC7B,KAAK,CAAC,eAAe;YACnB,OAAO;gBACL,KAAK,CAAC,kBAAkB;oBACtB,OAAO,KAAK,EAAE,gBAAgB,EAAE,EAAE;wBAChC,gBAAgB,EAAE,OAAO,CAAC,CAAC,KAAK,EAAE,EAAE;4BAClC,KAAK,CAAC,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC,OAAO,CACnC,wBAAwB,EACxB,EAAE,CACH,CAAC;wBACJ,CAAC,CAAC,CAAC;oBACL,CAAC,CAAC;gBACJ,CAAC;aACF,CAAC;QACJ,CAAC;KACF,CAAC,CAAC;AACL,CAAC;AAnBD,oFAmBC"}

node_modules/@apollo/server/dist/cjs/plugin/disabled/index.d.ts

@@ -0,0 +1,7 @@
+import type { BaseContext, ApolloServerPlugin } from '../../index.js';
+export declare function ApolloServerPluginCacheControlDisabled(): ApolloServerPlugin<BaseContext>;
+export declare function ApolloServerPluginInlineTraceDisabled(): ApolloServerPlugin<BaseContext>;
+export declare function ApolloServerPluginLandingPageDisabled(): ApolloServerPlugin<BaseContext>;
+export declare function ApolloServerPluginSchemaReportingDisabled(): ApolloServerPlugin<BaseContext>;
+export declare function ApolloServerPluginUsageReportingDisabled(): ApolloServerPlugin<BaseContext>;
+//# sourceMappingURL=index.d.ts.map

node_modules/@apollo/server/dist/cjs/plugin/disabled/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugin/disabled/index.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AActE,wBAAgB,sCAAsC,IAAI,kBAAkB,CAAC,WAAW,CAAC,CAExF;AAED,wBAAgB,qCAAqC,IAAI,kBAAkB,CAAC,WAAW,CAAC,CAEvF;AAED,wBAAgB,qCAAqC,IAAI,kBAAkB,CAAC,WAAW,CAAC,CAEvF;AAED,wBAAgB,yCAAyC,IAAI,kBAAkB,CAAC,WAAW,CAAC,CAE3F;AAED,wBAAgB,wCAAwC,IAAI,kBAAkB,CAAC,WAAW,CAAC,CAE1F"}

node_modules/@apollo/server/dist/cjs/plugin/disabled/index.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApolloServerPluginUsageReportingDisabled = exports.ApolloServerPluginSchemaReportingDisabled = exports.ApolloServerPluginLandingPageDisabled = exports.ApolloServerPluginInlineTraceDisabled = exports.ApolloServerPluginCacheControlDisabled = void 0;
+function disabledPlugin(id) {
+    const plugin = {
+        __internal_plugin_id__: id,
+        __is_disabled_plugin__: true,
+    };
+    return plugin;
+}
+function ApolloServerPluginCacheControlDisabled() {
+    return disabledPlugin('CacheControl');
+}
+exports.ApolloServerPluginCacheControlDisabled = ApolloServerPluginCacheControlDisabled;
+function ApolloServerPluginInlineTraceDisabled() {
+    return disabledPlugin('InlineTrace');
+}
+exports.ApolloServerPluginInlineTraceDisabled = ApolloServerPluginInlineTraceDisabled;
+function ApolloServerPluginLandingPageDisabled() {
+    return disabledPlugin('LandingPageDisabled');
+}
+exports.ApolloServerPluginLandingPageDisabled = ApolloServerPluginLandingPageDisabled;
+function ApolloServerPluginSchemaReportingDisabled() {
+    return disabledPlugin('SchemaReporting');
+}
+exports.ApolloServerPluginSchemaReportingDisabled = ApolloServerPluginSchemaReportingDisabled;
+function ApolloServerPluginUsageReportingDisabled() {
+    return disabledPlugin('UsageReporting');
+}
+exports.ApolloServerPluginUsageReportingDisabled = ApolloServerPluginUsageReportingDisabled;
+//# sourceMappingURL=index.js.map

node_modules/@apollo/server/dist/cjs/plugin/disabled/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/plugin/disabled/index.ts"],"names":[],"mappings":";;;AAcA,SAAS,cAAc,CAAC,EAAoB;IAC1C,MAAM,MAAM,GAA4C;QACtD,sBAAsB,EAAE,EAAE;QAC1B,sBAAsB,EAAE,IAAI;KAC7B,CAAC;IACF,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,SAAgB,sCAAsC;IACpD,OAAO,cAAc,CAAC,cAAc,CAAC,CAAC;AACxC,CAAC;AAFD,wFAEC;AAED,SAAgB,qCAAqC;IACnD,OAAO,cAAc,CAAC,aAAa,CAAC,CAAC;AACvC,CAAC;AAFD,sFAEC;AAED,SAAgB,qCAAqC;IACnD,OAAO,cAAc,CAAC,qBAAqB,CAAC,CAAC;AAC/C,CAAC;AAFD,sFAEC;AAED,SAAgB,yCAAyC;IACvD,OAAO,cAAc,CAAC,iBAAiB,CAAC,CAAC;AAC3C,CAAC;AAFD,8FAEC;AAED,SAAgB,wCAAwC;IACtD,OAAO,cAAc,CAAC,gBAAgB,CAAC,CAAC;AAC1C,CAAC;AAFD,4FAEC"}

node_modules/@apollo/server/dist/cjs/plugin/drainHttpServer/index.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+import type http from 'http';
+import type { ApolloServerPlugin } from '../../externalTypes/index.js';
+export interface ApolloServerPluginDrainHttpServerOptions {
+    httpServer: http.Server;
+    stopGracePeriodMillis?: number;
+}
+export declare function ApolloServerPluginDrainHttpServer(options: ApolloServerPluginDrainHttpServerOptions): ApolloServerPlugin;
+//# sourceMappingURL=index.d.ts.map

node_modules/@apollo/server/dist/cjs/plugin/drainHttpServer/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugin/drainHttpServer/index.ts"],"names":[],"mappings":";AAAA,OAAO,KAAK,IAAI,MAAM,MAAM,CAAC;AAE7B,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AAMvE,MAAM,WAAW,wCAAwC;IAIvD,UAAU,EAAE,IAAI,CAAC,MAAM,CAAC;IAKxB,qBAAqB,CAAC,EAAE,MAAM,CAAC;CAChC;AAQD,wBAAgB,iCAAiC,CAC/C,OAAO,EAAE,wCAAwC,GAChD,kBAAkB,CA2BpB"}

node_modules/@apollo/server/dist/cjs/plugin/drainHttpServer/index.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApolloServerPluginDrainHttpServer = void 0;
+const node_abort_controller_1 = require("node-abort-controller");
+const stoppable_js_1 = require("./stoppable.js");
+function ApolloServerPluginDrainHttpServer(options) {
+    const stopper = new stoppable_js_1.Stopper(options.httpServer);
+    return {
+        async serverWillStart() {
+            return {
+                async drainServer() {
+                    const hardDestroyAbortController = new node_abort_controller_1.AbortController();
+                    const stopGracePeriodMillis = options.stopGracePeriodMillis ?? 10000;
+                    let timeout;
+                    if (stopGracePeriodMillis < Infinity) {
+                        timeout = setTimeout(() => hardDestroyAbortController.abort(), stopGracePeriodMillis);
+                    }
+                    await stopper.stop(hardDestroyAbortController.signal);
+                    if (timeout) {
+                        clearTimeout(timeout);
+                    }
+                },
+            };
+        },
+    };
+}
+exports.ApolloServerPluginDrainHttpServer = ApolloServerPluginDrainHttpServer;
+//# sourceMappingURL=index.js.map

node_modules/@apollo/server/dist/cjs/plugin/drainHttpServer/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/plugin/drainHttpServer/index.ts"],"names":[],"mappings":";;;AACA,iEAAwD;AAExD,iDAAyC;AAuBzC,SAAgB,iCAAiC,CAC/C,OAAiD;IAEjD,MAAM,OAAO,GAAG,IAAI,sBAAO,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;IAChD,OAAO;QACL,KAAK,CAAC,eAAe;YACnB,OAAO;gBACL,KAAK,CAAC,WAAW;oBAKf,MAAM,0BAA0B,GAAG,IAAI,uCAAe,EAAE,CAAC;oBACzD,MAAM,qBAAqB,GAAG,OAAO,CAAC,qBAAqB,IAAI,KAAM,CAAC;oBACtE,IAAI,OAAmC,CAAC;oBACxC,IAAI,qBAAqB,GAAG,QAAQ,EAAE,CAAC;wBACrC,OAAO,GAAG,UAAU,CAClB,GAAG,EAAE,CAAC,0BAA0B,CAAC,KAAK,EAAE,EACxC,qBAAqB,CACtB,CAAC;oBACJ,CAAC;oBACD,MAAM,OAAO,CAAC,IAAI,CAAC,0BAA0B,CAAC,MAAM,CAAC,CAAC;oBACtD,IAAI,OAAO,EAAE,CAAC;wBACZ,YAAY,CAAC,OAAO,CAAC,CAAC;oBACxB,CAAC;gBACH,CAAC;aACF,CAAC;QACJ,CAAC;KACF,CAAC;AACJ,CAAC;AA7BD,8EA6BC"}

node_modules/@apollo/server/dist/cjs/plugin/drainHttpServer/stoppable.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import type http from 'http';
+import https from 'https';
+import type { AbortSignal } from 'node-abort-controller';
+export declare class Stopper {
+    private server;
+    private requestCountPerSocket;
+    private stopped;
+    constructor(server: http.Server | https.Server);
+    stop(hardDestroyAbortSignal?: AbortSignal): Promise<boolean>;
+}
+//# sourceMappingURL=stoppable.d.ts.map

node_modules/@apollo/server/dist/cjs/plugin/drainHttpServer/stoppable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stoppable.d.ts","sourceRoot":"","sources":["../../../../src/plugin/drainHttpServer/stoppable.ts"],"names":[],"mappings":";;AA4BA,OAAO,KAAK,IAAI,MAAM,MAAM,CAAC;AAC7B,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAEzD,qBAAa,OAAO;IAIN,OAAO,CAAC,MAAM;IAH1B,OAAO,CAAC,qBAAqB,CAA6B;IAC1D,OAAO,CAAC,OAAO,CAAS;gBAEJ,MAAM,EAAE,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC,MAAM;IA+BhD,IAAI,CAAC,sBAAsB,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC;CAyCnE"}