mirror of
https://github.com/vale981/apollo-server
synced 2025-03-05 09:41:40 -05:00
CDN cache-control headers (#1138)
* core: return response object from runHttpQuery * core: change gqlResponse to graphqlResponse and add custom RequestInit type * core: add cache-control headers based on the calcualted maxAge * core: add extensions check during cache-control header creation * core: create headers when cacheControl is not enabled otherwise pass through extensions * express: initial tests of CDN cach-contol headers * core: fixed tests with applyMiddleware and pass cacheControl config * core: cache hint fixes, ignore when no maxAge, and check for rootKeys * core: check for hints of length 0 * core: node 10 fails file upload test for some stream reason * docs: add cdn caching section to features * add space after // in comments * fix feedback: proxy alignment and response creation Adds cache-control toggles for http header calculation and stripping out the cache control extensions from the respose. Brings the default calculation of headers in line with the proxy. * fix links in comments * fix tests with null dereference * update cdn docs and migration guide to include latest cdn configuration * add not for engine migration to set engine to false * add engine set to false in migration guide * express: fixed tests * address feedback to use omit and documentation * docs: cdn caching is alternative to full response caching * add back epipe check in upload tests
This commit is contained in:
Evans Hauser
GitHub
parent
36c595bd12
commit
65d7b100e4
23 changed files with 562 additions and 136 deletions
|
|
@ -20,6 +20,7 @@ sidebar_categories:
|
|||
- features/errors
|
||||
- features/apq
|
||||
- features/data-sources
|
||||
- features/cdn
|
||||
- features/subscriptions
|
||||
- features/logging
|
||||
- features/scalars-enums
|
||||
|
|
|
|||
74
docs/source/features/cdn.md
Normal file
74
docs/source/features/cdn.md
Normal file
|
|
@ -0,0 +1,74 @@
|
|||
---
|
||||
title: CDN Integration
|
||||
description: Getting content delivery networks to cache GraphQL responses
|
||||
---
|
||||
|
||||
Content-delivery networks such as [fly.io](https://fly.io), [Cloudflare](https://www.cloudflare.com/), [Akamai](https://www.akamai.com/) or [Fastly](https://www.fastly.com/) allow content caching close to clients, delivering data with low latency from a nearby server. Apollo Server makes it straightforward to use CDNs with GraphQL queries to cache full responses while still executing more dynamic queries.
|
||||
|
||||
To use Apollo Server behind a CDN, we define which GraphQL responses the CDN is allowed to cache. On the client, we set up [automatic persisted queries](./apq.html) to ensure that GraphQL requests are in a format that a CDN can understand.
|
||||
|
||||
<h2 id="cache-hints" title="1. Add cache hints">Step 1: Add cache hints to the GraphQL schema</h2>
|
||||
|
||||
Add cache hints as [directives](./directives.html) to GraphQL schema so that Apollo Server knows which fields and types are cacheable and for how long. For example, this schema indicates that all fields that return an `Author` should be cached for 60 seconds, and that the `posts` field should itself be cached for 180 seconds:
|
||||
|
||||
```graphql
|
||||
type Author @cacheControl(maxAge: 60) {
|
||||
id: Int
|
||||
firstName: String
|
||||
lastName: String
|
||||
posts: [Post] @cacheControl(maxAge: 180)
|
||||
}
|
||||
```
|
||||
|
||||
See [the cache control documentation](https://github.com/apollographql/apollo-cache-control-js#add-cache-hints-to-your-schema) for more details, including how to specify hints dynamically inside resolvers, how to set a default `maxAge` for all fields, and how to specify that a field should be cached for specific users only (in which case CDNs should ignore it). For example, to set a default max age other than 0 modify the Apollo Server constructor to include `cacheControl`:
|
||||
|
||||
```js
|
||||
const server = new ApolloServer({
|
||||
typeDefs,
|
||||
resolvers,
|
||||
// The max age is calculated in seconds
|
||||
cacheControl: { defaultMaxAge: 5 },
|
||||
});
|
||||
```
|
||||
|
||||
After this step, Apollo Server will serve the HTTP `Cache-Control` header on fully cacheable responses, so that any CDN in front of Apollo Server will know which responses can be cached and for how long! A "fully cacheable" response contains only data with non-zero `maxAge`; the header will refer to the minimum `maxAge` value across the whole response, and it will be `public` unless some of the data is tagged `scope: PRIVATE`. To observe this header, use any browser's network tab in its dev tools.
|
||||
|
||||
<h2 id="enable-apq" title="2. Enable persisted queries">Step 2: Enable automatic persisted queries</h2>
|
||||
|
||||
Often, GraphQL requests are big POST requests and most CDNs will only cache GET requests. Additionally, GET requests generally work best when the URL has a bounded size. Enabling automatic persisted queries means that short hashes are sent over the wire instead of full queries, and Apollo Client can be configured to use GET requests for those hashed queries.
|
||||
|
||||
To do this, update the **client** code. First, add the package:
|
||||
|
||||
```
|
||||
npm install apollo-link-persisted-queries
|
||||
```
|
||||
|
||||
Then, add the persisted queries link to the Apollo Client constructor before the HTTP link:
|
||||
|
||||
```js
|
||||
import { createPersistedQueryLink } from "apollo-link-persisted-queries";
|
||||
import { createHttpLink } from "apollo-link-http";
|
||||
import { InMemoryCache } from "apollo-cache-inmemory";
|
||||
import { ApolloLink } from "apollo-link";
|
||||
import ApolloClient from "apollo-client";
|
||||
|
||||
ApolloLink.from([
|
||||
createPersistedQueryLink({ useGETForHashedQueries: true }),
|
||||
createHttpLink({ uri: "/graphql" })
|
||||
]);
|
||||
|
||||
const client = new ApolloClient({
|
||||
cache: new InMemoryCache(),
|
||||
link: link
|
||||
});
|
||||
```
|
||||
|
||||
Make sure to include `useGETForHashedQueries: true`. Note that the client will still use POSTs for mutations, because it's generally best to avoid GETs for non-idempotent requests.
|
||||
|
||||
If configured correctly, browser's dev tools should verify that queries are now sent as GET requests, and receive appropriate `Cache-Control` response headers.
|
||||
|
||||
<h2 id="setup-cdn" title="3. Set up a CDN">Step 3: Set up a CDN!</h2>
|
||||
|
||||
How exactly this works depends on exactly which CDN you chose. Configure your CDN to send requests to Apollo Server. Some CDNs may need to be specially configured to honor origin Cache-Control headers; for example, here is [Akamai's documentation on that setting](https://learn.akamai.com/en-us/webhelp/ion/oca/GUID-57C31126-F745-4FFB-AA92-6A5AAC36A8DA.html). If all is well, cacheable queries should now be saved by the CDN!
|
||||
|
||||
> Note that requests served directly by a CDN will not show up in the Engine dashboard.
|
||||
|
|
@ -3,13 +3,11 @@ title: Using Engine with v2.0 RC
|
|||
description: How to use Engine with Apollo Server 2.0 RC
|
||||
---
|
||||
|
||||
Apollo Server provides reporting and persisted queries in native javascript by default, so often times moving to Apollo Server 2 without the Engine proxy is possible. For services that require the Engine proxy, Apollo Server continues to support with first class functionality. With Apollo Server 2, the engine proxy can be started by the same node process. If Engine is running in a dedicated machine, Apollo Server 2 supports the cache-control and tracing extensions, used to communicate with the proxy.
|
||||
Apollo Server provides reporting, persisted queries, and cache-control headers in native javascript by default, so often times moving to Apollo Server 2 without the Engine proxy is possible. For services that already contain the Engine proxy and depend on its full response caching, Apollo Server continues to support it with first class functionality. With Apollo Server 2, the Engine proxy can be started by the same node process. If the Engine proxy is running in a dedicated machine, Apollo Server 2 supports the cache-control and tracing extensions, used to communicate with the proxy.
|
||||
|
||||
## Stand-alone Apollo Server
|
||||
|
||||
With ENGINE_API_KEY set as an environment variable, Apollo Server creates a reporting agent that sends execution traces to the Engine UI. In addition by default, Apollo Server supports [persisted queries](./features/apq.html).
|
||||
|
||||
<!-- FIXME add something about CDN headers-->
|
||||
Apollo Server 2 is able to completely replace the Engine proxy. To enable metrics reporting, add `ENGINE_API_KEY` as an environment variable. Apollo Server will then create a reporting agent that sends execution traces to the Engine UI. In addition by default, Apollo Server supports [persisted queries](./features/apq.html) without needing the proxy's cache. Apollo Server also provides cache-control headers for consumption by a [CDN](./features/cdn.html). Integrating a CDN provides an alternative to the full response caching inside of Engine proxy.
|
||||
|
||||
```js
|
||||
const { ApolloServer } = require('apollo-server');
|
||||
|
|
@ -26,7 +24,7 @@ server.listen().then(({ url }) => {
|
|||
|
||||
## Starting Engine Proxy
|
||||
|
||||
The `apollo-engine` package provides integrations with many [node frameworks](/docs/engine/setup-node.html#not-express), including [express](/docs/engine/setup-node.html#setup-guide), that starts the Engine Proxy alongside the framework. The following code demonstrates how to start the proxy with Apollo Server 2, assuming that the `ENGINE_API_KEY` environment variable is set to the api key of the service.
|
||||
Some infrastructure already contains the Engine proxy and requires it for full response caching, so it is necessary to run the proxy as a process alongside Apollo Server. If full response caching is not necessary, then the Engine proxy can be completely replaced by Apollo Server 2. The `apollo-engine` package provides integrations with many [node frameworks](/docs/engine/setup-node.html#not-express), including [express](/docs/engine/setup-node.html#setup-guide), and starts the Engine proxy alongside Apollo Server. The following code demonstrates how to start the proxy with Apollo Server 2. It assumes that the `ENGINE_API_KEY` environment variable is set to the api key of the service.
|
||||
|
||||
```js
|
||||
const { ApolloEngine } = require('apollo-engine');
|
||||
|
|
@ -38,7 +36,9 @@ const server = new ApolloServer({
|
|||
typeDefs,
|
||||
resolvers,
|
||||
tracing: true,
|
||||
cacheControl: true
|
||||
cacheControl: true,
|
||||
// We set `engine` to false, so that the new agent is not used.
|
||||
engine: false,
|
||||
});
|
||||
|
||||
server.applyMiddlware({ app });
|
||||
|
|
@ -59,9 +59,26 @@ engine.listen({
|
|||
});
|
||||
```
|
||||
|
||||
To set the default max age inside of cacheControl, some additional options must be specified:
|
||||
|
||||
```js
|
||||
const server = new ApolloServer({
|
||||
typeDefs,
|
||||
resolvers,
|
||||
tracing: true,
|
||||
cacheControl: {
|
||||
defaultMaxAge: 5,
|
||||
stripFormattedExtensions: false,
|
||||
calculateCacheControlHeaders: false,
|
||||
},
|
||||
// We set `engine` to false, so that the new agent is not used.
|
||||
engine: false,
|
||||
});
|
||||
```
|
||||
|
||||
## With a Running Engine Proxy
|
||||
|
||||
If the engine proxy is already running in a container in front of Apollo Server, then set `tracing` and `cacheControl` to true. These options will provide the extensions information to the proxy to create traces and ensure caching.
|
||||
If the Engine proxy is already running in a container in front of Apollo Server, then set `tracing` and `cacheControl` to true. These options will provide the extensions information to the proxy to create traces and ensure caching. We set `engine` to false, so that the new metrics reporting pipeline is not activated.
|
||||
|
||||
```js
|
||||
const { ApolloServer } = require('apollo-server');
|
||||
|
|
@ -70,7 +87,9 @@ const server = new ApolloServer({
|
|||
typeDefs,
|
||||
resolvers,
|
||||
tracing: true,
|
||||
cacheControl: true
|
||||
cacheControl: true,
|
||||
// We set `engine` to false, so that the new agent is not used.
|
||||
engine: false,
|
||||
});
|
||||
|
||||
server.listen().then(({ url }) => {
|
||||
|
|
|
|||
|
|
@ -5,9 +5,9 @@ export { GraphQLOptions, GraphQLExtension } from 'apollo-server-core';
|
|||
import { GraphQLOptions } from 'apollo-server-core';
|
||||
|
||||
export class ApolloServer extends ApolloServerBase {
|
||||
//This translates the arguments from the middleware into graphQL options It
|
||||
//provides typings for the integration specific behavior, ideally this would
|
||||
//be propagated with a generic to the super class
|
||||
// This translates the arguments from the middleware into graphQL options It
|
||||
// provides typings for the integration specific behavior, ideally this would
|
||||
// be propagated with a generic to the super class
|
||||
async createGraphQLServerOptions(request: Request): Promise<GraphQLOptions> {
|
||||
return super.graphQLServerOptions({ request });
|
||||
}
|
||||
|
|
|
|||
|
|
@ -38,11 +38,8 @@ export function graphqlCloudflare(options: GraphQLOptions) {
|
|||
query,
|
||||
request: req as Request,
|
||||
}).then(
|
||||
gqlResponse =>
|
||||
new Response(gqlResponse, {
|
||||
status: 200,
|
||||
headers: { 'content-type': 'application/json' },
|
||||
}),
|
||||
({ graphqlResponse, responseInit }) =>
|
||||
new Response(graphqlResponse, responseInit),
|
||||
(error: HttpQueryError) => {
|
||||
if ('HttpQueryError' !== error.name) throw error;
|
||||
|
||||
|
|
|
|||
|
|
@ -62,6 +62,7 @@
|
|||
"graphql-tools": "^3.0.2",
|
||||
"hash.js": "^1.1.3",
|
||||
"keyv": "^3.0.0",
|
||||
"lodash": "^4.17.10",
|
||||
"quick-lru": "^1.1.0",
|
||||
"subscriptions-transport-ws": "^0.9.9",
|
||||
"ws": "^5.2.0"
|
||||
|
|
|
|||
|
|
@ -69,7 +69,7 @@ export class ApolloServerBase {
|
|||
// set by installSubscriptionHandlers.
|
||||
private subscriptionServer?: SubscriptionServer;
|
||||
|
||||
//The constructor should be universal across all environments. All environment specific behavior should be set in an exported registerServer or in by overriding listen
|
||||
// The constructor should be universal across all environments. All environment specific behavior should be set in an exported registerServer or in by overriding listen
|
||||
constructor(config: Config) {
|
||||
if (!config) throw new Error('ApolloServer requires options.');
|
||||
const {
|
||||
|
|
@ -87,11 +87,11 @@ export class ApolloServerBase {
|
|||
...requestOptions
|
||||
} = config;
|
||||
|
||||
//While reading process.env is slow, a server should only be constructed
|
||||
//once per run, so we place the env check inside the constructor. If env
|
||||
//should be used outside of the constructor context, place it as a private
|
||||
//or protected field of the class instead of a global. Keeping the read in
|
||||
//the contructor enables testing of different environments
|
||||
// While reading process.env is slow, a server should only be constructed
|
||||
// once per run, so we place the env check inside the constructor. If env
|
||||
// should be used outside of the constructor context, place it as a private
|
||||
// or protected field of the class instead of a global. Keeping the read in
|
||||
// the contructor enables testing of different environments
|
||||
const isDev = process.env.NODE_ENV !== 'production';
|
||||
|
||||
// if this is local dev, introspection should turned on
|
||||
|
|
@ -109,16 +109,16 @@ export class ApolloServerBase {
|
|||
|
||||
if (requestOptions.persistedQueries !== false) {
|
||||
if (!requestOptions.persistedQueries) {
|
||||
//maxSize is the number of elements that can be stored inside of the cache
|
||||
//https://github.com/withspectrum/spectrum has about 200 instances of gql`
|
||||
//300 queries seems reasonable
|
||||
// maxSize is the number of elements that can be stored inside of the cache
|
||||
// https://github.com/withspectrum/spectrum has about 200 instances of gql`
|
||||
// 300 queries seems reasonable
|
||||
const lru = new QuickLru({ maxSize: 300 });
|
||||
requestOptions.persistedQueries = {
|
||||
cache: new Keyv({ store: lru }),
|
||||
};
|
||||
}
|
||||
} else {
|
||||
//the user does not want to use persisted queries, so we remove the field
|
||||
// the user does not want to use persisted queries, so we remove the field
|
||||
delete requestOptions.persistedQueries;
|
||||
}
|
||||
|
||||
|
|
@ -155,8 +155,8 @@ export class ApolloServerBase {
|
|||
this.schema = schema
|
||||
? schema
|
||||
: makeExecutableSchema({
|
||||
//we add in the upload scalar, so that schemas that don't include it
|
||||
//won't error when we makeExecutableSchema
|
||||
// we add in the upload scalar, so that schemas that don't include it
|
||||
// won't error when we makeExecutableSchema
|
||||
typeDefs: this.uploadsConfig
|
||||
? [
|
||||
gql`
|
||||
|
|
@ -219,8 +219,8 @@ export class ApolloServerBase {
|
|||
}
|
||||
}
|
||||
|
||||
//used by integrations to synchronize the path with subscriptions, some
|
||||
//integrations do not have paths, such as lambda
|
||||
// used by integrations to synchronize the path with subscriptions, some
|
||||
// integrations do not have paths, such as lambda
|
||||
public setGraphQLPath(path: string) {
|
||||
this.graphqlPath = path;
|
||||
}
|
||||
|
|
@ -305,9 +305,9 @@ export class ApolloServerBase {
|
|||
return false;
|
||||
}
|
||||
|
||||
//This function is used by the integrations to generate the graphQLOptions
|
||||
//from an object containing the request and other integration specific
|
||||
//options
|
||||
// This function is used by the integrations to generate the graphQLOptions
|
||||
// from an object containing the request and other integration specific
|
||||
// options
|
||||
protected async graphQLServerOptions(
|
||||
integrationContextArgument?: Record<string, any>,
|
||||
) {
|
||||
|
|
@ -319,7 +319,7 @@ export class ApolloServerBase {
|
|||
? await this.context(integrationContextArgument || {})
|
||||
: context;
|
||||
} catch (error) {
|
||||
//Defer context error resolution to inside of runQuery
|
||||
// Defer context error resolution to inside of runQuery
|
||||
context = () => {
|
||||
throw error;
|
||||
};
|
||||
|
|
|
|||
|
|
@ -1,4 +1,77 @@
|
|||
import { ExecutionResult } from 'graphql';
|
||||
import { CacheControlFormat } from 'apollo-cache-control';
|
||||
|
||||
export interface PersistedQueryCache {
|
||||
set(key: string, data: string): Promise<any>;
|
||||
get(key: string): Promise<string | null>;
|
||||
}
|
||||
|
||||
export type HttpHeaderCalculation = (
|
||||
responses: Array<ExecutionResult & { extensions?: Record<string, any> }>,
|
||||
) => Record<string, string>;
|
||||
|
||||
export function calculateCacheControlHeaders(
|
||||
responses: Array<ExecutionResult & { extensions?: Record<string, any> }>,
|
||||
): Record<string, string> {
|
||||
let lowestMaxAge = Number.MAX_VALUE;
|
||||
let publicOrPrivate = 'public';
|
||||
|
||||
// Because of the early exit, we are unable to use forEach. While a reduce
|
||||
// loop might be possible, a for loop is more readable
|
||||
for (let i = 0; i < responses.length; i++) {
|
||||
const response = responses[i];
|
||||
|
||||
const cacheControl: CacheControlFormat =
|
||||
response.extensions && response.extensions.cacheControl;
|
||||
|
||||
// If there are no extensions or hints, then the headers should not be present
|
||||
if (
|
||||
!cacheControl ||
|
||||
!cacheControl.hints ||
|
||||
cacheControl.hints.length === 0 ||
|
||||
cacheControl.version !== 1
|
||||
) {
|
||||
if (cacheControl && cacheControl.version !== 1) {
|
||||
console.warn('Invalid cacheControl version.');
|
||||
}
|
||||
return {};
|
||||
}
|
||||
|
||||
const rootHints = new Set<string>();
|
||||
for (let j = 0; j < cacheControl.hints.length; j++) {
|
||||
const hint = cacheControl.hints[j];
|
||||
if (hint.scope && hint.scope.toLowerCase() === 'private') {
|
||||
publicOrPrivate = 'private';
|
||||
}
|
||||
|
||||
// If no maxAge is present, then we ignore the hint
|
||||
if (hint.maxAge === undefined) {
|
||||
continue;
|
||||
}
|
||||
|
||||
// if there is a hint with max age of 0, we don't need to process more
|
||||
if (hint.maxAge === 0) {
|
||||
return {};
|
||||
}
|
||||
|
||||
if (hint.maxAge < lowestMaxAge) {
|
||||
lowestMaxAge = hint.maxAge;
|
||||
}
|
||||
|
||||
// If this is a root path, store that the root is cacheable:
|
||||
if (hint.path.length === 1) {
|
||||
rootHints.add(hint.path[0] as string);
|
||||
}
|
||||
}
|
||||
|
||||
// If a root field inside of data does not have a cache hint, then we do not
|
||||
// cache the response
|
||||
if (Object.keys(response.data).find(rootKey => !rootHints.has(rootKey))) {
|
||||
return {};
|
||||
}
|
||||
}
|
||||
|
||||
return {
|
||||
'Cache-Control': `max-age=${lowestMaxAge}, ${publicOrPrivate}`,
|
||||
};
|
||||
}
|
||||
|
|
|
|||
|
|
@ -3,9 +3,10 @@ import {
|
|||
ValidationContext,
|
||||
GraphQLFieldResolver,
|
||||
} from 'graphql';
|
||||
import { PersistedQueryCache } from './caching';
|
||||
import { PersistedQueryCache, HttpHeaderCalculation } from './caching';
|
||||
import { GraphQLExtension } from 'graphql-extensions';
|
||||
import { RESTDataSource, KeyValueCache } from 'apollo-datasource-rest';
|
||||
import { CacheControlExtensionOptions } from 'apollo-cache-control';
|
||||
|
||||
/*
|
||||
* GraphQLServerOptions
|
||||
|
|
@ -37,8 +38,12 @@ export interface GraphQLServerOptions<
|
|||
fieldResolver?: GraphQLFieldResolver<any, TContext>;
|
||||
debug?: boolean;
|
||||
tracing?: boolean;
|
||||
// cacheControl?: boolean | CacheControlExtensionOptions;
|
||||
cacheControl?: boolean | any;
|
||||
cacheControl?:
|
||||
| boolean
|
||||
| (CacheControlExtensionOptions & {
|
||||
calculateHttpHeaders?: boolean | HttpHeaderCalculation;
|
||||
stripFormattedExtensions?: boolean;
|
||||
});
|
||||
extensions?: Array<() => GraphQLExtension>;
|
||||
dataSources?: () => DataSources;
|
||||
cache?: KeyValueCache;
|
||||
|
|
|
|||
|
|
@ -26,8 +26,8 @@ export * from './types';
|
|||
export * from 'graphql-tools';
|
||||
export * from 'graphql-subscriptions';
|
||||
|
||||
//This currently provides the ability to have syntax highlighting as well as
|
||||
//consistency between client and server gql tags
|
||||
// This currently provides the ability to have syntax highlighting as well as
|
||||
// consistency between client and server gql tags
|
||||
import { DocumentNode } from 'graphql';
|
||||
import gqlTag from 'graphql-tag';
|
||||
export const gql: (
|
||||
|
|
|
|||
|
|
@ -1,6 +1,11 @@
|
|||
import { ExecutionResult } from 'graphql';
|
||||
import * as sha256 from 'hash.js/lib/hash/sha/256';
|
||||
|
||||
import { HTTPCache } from 'apollo-datasource-rest';
|
||||
import { CacheControlExtensionOptions } from 'apollo-cache-control';
|
||||
|
||||
import { omit } from 'lodash';
|
||||
|
||||
import { runQuery, QueryOptions } from './runQuery';
|
||||
import {
|
||||
default as GraphQLOptions,
|
||||
|
|
@ -11,7 +16,7 @@ import {
|
|||
PersistedQueryNotSupportedError,
|
||||
PersistedQueryNotFoundError,
|
||||
} from 'apollo-server-errors';
|
||||
import { HTTPCache } from 'apollo-datasource-rest';
|
||||
import { calculateCacheControlHeaders, HttpHeaderCalculation } from './caching';
|
||||
|
||||
export interface HttpQueryRequest {
|
||||
method: string;
|
||||
|
|
@ -27,11 +32,23 @@ export interface HttpQueryRequest {
|
|||
request: Pick<Request, 'url' | 'method' | 'headers'>;
|
||||
}
|
||||
|
||||
//The result of a curl does not appear well in the terminal, so we add an extra new line
|
||||
// The result of a curl does not appear well in the terminal, so we add an extra new line
|
||||
function prettyJSONStringify(toStringfy) {
|
||||
return JSON.stringify(toStringfy) + '\n';
|
||||
}
|
||||
|
||||
export interface ApolloServerHttpResponse {
|
||||
headers?: Record<string, string>;
|
||||
// ResponseInit contains the follow, which we do not use
|
||||
// status?: number;
|
||||
// statusText?: string;
|
||||
}
|
||||
|
||||
export interface HttpQueryResponse {
|
||||
graphqlResponse: string;
|
||||
responseInit: ApolloServerHttpResponse;
|
||||
}
|
||||
|
||||
export class HttpQueryError extends Error {
|
||||
public statusCode: number;
|
||||
public isGraphQLError: boolean;
|
||||
|
|
@ -74,11 +91,15 @@ function throwHttpGraphQLError(
|
|||
export async function runHttpQuery(
|
||||
handlerArguments: Array<any>,
|
||||
request: HttpQueryRequest,
|
||||
): Promise<string> {
|
||||
): Promise<HttpQueryResponse> {
|
||||
let isGetRequest: boolean = false;
|
||||
let optionsObject: GraphQLOptions;
|
||||
const debugDefault =
|
||||
process.env.NODE_ENV !== 'production' && process.env.NODE_ENV !== 'test';
|
||||
let cacheControl: CacheControlExtensionOptions & {
|
||||
calculateHttpHeaders: boolean | HttpHeaderCalculation;
|
||||
stripFormattedExtensions: boolean;
|
||||
};
|
||||
|
||||
try {
|
||||
optionsObject = await resolveGraphqlOptions(
|
||||
|
|
@ -196,10 +217,10 @@ export async function runHttpQuery(
|
|||
throw new HttpQueryError(400, 'provided sha does not match query');
|
||||
}
|
||||
|
||||
//Do the store completely asynchronously
|
||||
// Do the store completely asynchronously
|
||||
Promise.resolve()
|
||||
.then(() => {
|
||||
//We do not wait on the cache storage to complete
|
||||
// We do not wait on the cache storage to complete
|
||||
return optionsObject.persistedQueries.cache.set(sha, queryString);
|
||||
})
|
||||
.catch(error => {
|
||||
|
|
@ -208,7 +229,7 @@ export async function runHttpQuery(
|
|||
}
|
||||
}
|
||||
|
||||
//We ensure that there is a queryString or parsedQuery after formatParams
|
||||
// We ensure that there is a queryString or parsedQuery after formatParams
|
||||
if (queryString && typeof queryString !== 'string') {
|
||||
// Check for a common error first.
|
||||
if (queryString && (queryString as any).kind === 'Document') {
|
||||
|
|
@ -258,7 +279,7 @@ export async function runHttpQuery(
|
|||
|
||||
let context = optionsObject.context;
|
||||
if (!context) {
|
||||
//appease typescript compiler, otherwise could use || {}
|
||||
// appease typescript compiler, otherwise could use || {}
|
||||
context = {};
|
||||
} else if (typeof context === 'function') {
|
||||
try {
|
||||
|
|
@ -277,7 +298,7 @@ export async function runHttpQuery(
|
|||
if (optionsObject.dataSources) {
|
||||
const dataSources = optionsObject.dataSources() || {};
|
||||
|
||||
//we use the cache provided to the request and add the Http semantics on top
|
||||
// we use the cache provided to the request and add the Http semantics on top
|
||||
const httpCache = new HTTPCache(optionsObject.cache);
|
||||
|
||||
for (const dataSource of Object.values(dataSources)) {
|
||||
|
|
@ -294,6 +315,31 @@ export async function runHttpQuery(
|
|||
(context as any).dataSources = dataSources;
|
||||
}
|
||||
|
||||
if (optionsObject.cacheControl !== false) {
|
||||
if (
|
||||
typeof optionsObject.cacheControl === 'boolean' &&
|
||||
optionsObject.cacheControl === true
|
||||
) {
|
||||
// cacheControl: true means that the user needs the cache-control
|
||||
// extensions. This means we are running the proxy, so we should not
|
||||
// strip out the cache control extension and not add cache-control headers
|
||||
cacheControl = {
|
||||
stripFormattedExtensions: false,
|
||||
calculateHttpHeaders: false,
|
||||
defaultMaxAge: 0,
|
||||
};
|
||||
} else {
|
||||
// Default behavior is to run default header calculation and return
|
||||
// no cacheControl extensions
|
||||
cacheControl = {
|
||||
stripFormattedExtensions: true,
|
||||
calculateHttpHeaders: true,
|
||||
defaultMaxAge: 0,
|
||||
...optionsObject.cacheControl,
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
let params: QueryOptions = {
|
||||
schema: optionsObject.schema,
|
||||
queryString,
|
||||
|
|
@ -308,7 +354,12 @@ export async function runHttpQuery(
|
|||
fieldResolver: optionsObject.fieldResolver,
|
||||
debug: optionsObject.debug,
|
||||
tracing: optionsObject.tracing,
|
||||
cacheControl: optionsObject.cacheControl,
|
||||
cacheControl: cacheControl
|
||||
? omit(cacheControl, [
|
||||
'calculateHttpHeaders',
|
||||
'stripFormattedExtensions',
|
||||
])
|
||||
: false,
|
||||
request: request.request,
|
||||
extensions: optionsObject.extensions,
|
||||
};
|
||||
|
|
@ -327,7 +378,7 @@ export async function runHttpQuery(
|
|||
// Populate any HttpQueryError to our handler which should
|
||||
// convert it to Http Error.
|
||||
if (e.name === 'HttpQueryError') {
|
||||
//async function wraps this in a Promise
|
||||
// async function wraps this in a Promise
|
||||
throw e;
|
||||
}
|
||||
|
||||
|
|
@ -338,21 +389,68 @@ export async function runHttpQuery(
|
|||
}),
|
||||
};
|
||||
}
|
||||
}) as Array<Promise<ExecutionResult>>;
|
||||
}) as Array<Promise<ExecutionResult & { extensions?: Record<string, any> }>>;
|
||||
|
||||
const responses = await Promise.all(requests);
|
||||
|
||||
if (!isBatch) {
|
||||
const gqlResponse = responses[0];
|
||||
//This code is run on parse/validation errors and any other error that
|
||||
//doesn't reach GraphQL execution
|
||||
if (gqlResponse.errors && typeof gqlResponse.data === 'undefined') {
|
||||
throw new HttpQueryError(400, prettyJSONStringify(gqlResponse), true, {
|
||||
'Content-Type': 'application/json',
|
||||
});
|
||||
}
|
||||
return prettyJSONStringify(gqlResponse);
|
||||
const responseInit: ApolloServerHttpResponse = {
|
||||
headers: {
|
||||
'Content-Type': 'application/json',
|
||||
},
|
||||
};
|
||||
|
||||
if (cacheControl.calculateHttpHeaders) {
|
||||
const calculatedHeaders =
|
||||
typeof cacheControl.calculateHttpHeaders === 'function'
|
||||
? cacheControl.calculateHttpHeaders(responses)
|
||||
: calculateCacheControlHeaders(responses);
|
||||
|
||||
responseInit.headers = {
|
||||
...responseInit.headers,
|
||||
...calculatedHeaders,
|
||||
};
|
||||
}
|
||||
|
||||
return prettyJSONStringify(responses);
|
||||
if (cacheControl.stripFormattedExtensions) {
|
||||
responses.forEach(response => {
|
||||
if (response.extensions) {
|
||||
delete response.extensions.cacheControl;
|
||||
if (Object.keys(response.extensions).length === 0) {
|
||||
delete response.extensions;
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
if (!isBatch) {
|
||||
const graphqlResponse = responses[0];
|
||||
// This code is run on parse/validation errors and any other error that
|
||||
// doesn't reach GraphQL execution
|
||||
if (graphqlResponse.errors && typeof graphqlResponse.data === 'undefined') {
|
||||
throwHttpGraphQLError(400, graphqlResponse.errors as any, optionsObject);
|
||||
}
|
||||
const stringified = prettyJSONStringify(graphqlResponse);
|
||||
|
||||
responseInit['Content-Length'] = Buffer.byteLength(
|
||||
stringified,
|
||||
'utf8',
|
||||
).toString();
|
||||
|
||||
return {
|
||||
graphqlResponse: stringified,
|
||||
responseInit,
|
||||
};
|
||||
}
|
||||
|
||||
const stringified = prettyJSONStringify(responses);
|
||||
|
||||
responseInit['Content-Length'] = Buffer.byteLength(
|
||||
stringified,
|
||||
'utf8',
|
||||
).toString();
|
||||
|
||||
return {
|
||||
graphqlResponse: stringified,
|
||||
responseInit,
|
||||
};
|
||||
}
|
||||
|
|
|
|||
|
|
@ -19,7 +19,10 @@ import {
|
|||
GraphQLExtensionStack,
|
||||
} from 'graphql-extensions';
|
||||
import { TracingExtension } from 'apollo-tracing';
|
||||
import { CacheControlExtension } from 'apollo-cache-control';
|
||||
import {
|
||||
CacheControlExtension,
|
||||
CacheControlExtensionOptions,
|
||||
} from 'apollo-cache-control';
|
||||
|
||||
import {
|
||||
fromGraphQLError,
|
||||
|
|
@ -58,8 +61,7 @@ export interface QueryOptions {
|
|||
formatResponse?: Function;
|
||||
debug?: boolean;
|
||||
tracing?: boolean;
|
||||
// cacheControl?: boolean | CacheControlExtensionOptions;
|
||||
cacheControl?: boolean | any;
|
||||
cacheControl?: boolean | CacheControlExtensionOptions;
|
||||
request: Pick<Request, 'url' | 'method' | 'headers'>;
|
||||
extensions?: Array<() => GraphQLExtension>;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -46,7 +46,7 @@ export interface Config
|
|||
| 'dataSources'
|
||||
| 'cache'
|
||||
> {
|
||||
typeDefs?: DocumentNode | [DocumentNode];
|
||||
typeDefs?: DocumentNode | Array<DocumentNode>;
|
||||
resolvers?: IResolvers;
|
||||
schema?: GraphQLSchema;
|
||||
schemaDirectives?: Record<string, typeof SchemaDirectiveVisitor>;
|
||||
|
|
|
|||
|
|
@ -25,13 +25,13 @@ export class ApolloError extends Error implements GraphQLError {
|
|||
});
|
||||
}
|
||||
|
||||
//if no name provided, use the default. defineProperty ensures that it stays non-enumerable
|
||||
// if no name provided, use the default. defineProperty ensures that it stays non-enumerable
|
||||
if (!this.name) {
|
||||
Object.defineProperty(this, 'name', { value: 'ApolloError' });
|
||||
}
|
||||
|
||||
//extensions are flattened to be included in the root of GraphQLError's, so
|
||||
//don't add properties to extensions
|
||||
// extensions are flattened to be included in the root of GraphQLError's, so
|
||||
// don't add properties to extensions
|
||||
this.extensions = { code };
|
||||
}
|
||||
}
|
||||
|
|
@ -81,9 +81,9 @@ function enrichError(error: Partial<GraphQLError>, debug: boolean = false) {
|
|||
},
|
||||
};
|
||||
|
||||
//ensure that extensions is not taken from the originalError
|
||||
//graphql-js ensures that the originalError's extensions are hoisted
|
||||
//https://github.com/graphql/graphql-js/blob/0bb47b2/src/error/GraphQLError.js#L138
|
||||
// ensure that extensions is not taken from the originalError
|
||||
// graphql-js ensures that the originalError's extensions are hoisted
|
||||
// https://github.com/graphql/graphql-js/blob/0bb47b2/src/error/GraphQLError.js#L138
|
||||
delete expanded.extensions.exception.extensions;
|
||||
if (debug && !expanded.extensions.exception.stacktrace) {
|
||||
expanded.extensions.exception.stacktrace =
|
||||
|
|
@ -94,7 +94,7 @@ function enrichError(error: Partial<GraphQLError>, debug: boolean = false) {
|
|||
}
|
||||
|
||||
if (Object.keys(expanded.extensions.exception).length === 0) {
|
||||
//remove from printing an empty object
|
||||
// remove from printing an empty object
|
||||
delete expanded.extensions.exception;
|
||||
}
|
||||
|
||||
|
|
@ -125,24 +125,24 @@ export function fromGraphQLError(error: GraphQLError, options?: ErrorOptions) {
|
|||
? new options.errorClass(error.message)
|
||||
: new ApolloError(error.message);
|
||||
|
||||
//copy enumerable keys
|
||||
// copy enumerable keys
|
||||
Object.keys(error).forEach(key => {
|
||||
copy[key] = error[key];
|
||||
});
|
||||
|
||||
//extensions are non enumerable, so copy them directly
|
||||
// extensions are non enumerable, so copy them directly
|
||||
copy.extensions = {
|
||||
...copy.extensions,
|
||||
...error.extensions,
|
||||
};
|
||||
|
||||
//Fallback on default for code
|
||||
// Fallback on default for code
|
||||
if (!copy.extensions.code) {
|
||||
copy.extensions.code = (options && options.code) || 'INTERNAL_SERVER_ERROR';
|
||||
}
|
||||
|
||||
//copy the original error, while keeping all values non-enumerable, so they
|
||||
//are not printed unless directly referenced
|
||||
// copy the original error, while keeping all values non-enumerable, so they
|
||||
// are not printed unless directly referenced
|
||||
Object.defineProperty(copy, 'originalError', { value: {} });
|
||||
Object.getOwnPropertyNames(error).forEach(key => {
|
||||
Object.defineProperty(copy.originalError, key, { value: error[key] });
|
||||
|
|
@ -259,7 +259,7 @@ export function formatApolloErrors(
|
|||
if (debug) {
|
||||
return enrichError(err, debug);
|
||||
} else {
|
||||
//obscure error
|
||||
// obscure error
|
||||
const newError = fromGraphQLError(
|
||||
new GraphQLError('Internal server error'),
|
||||
);
|
||||
|
|
|
|||
|
|
@ -356,7 +356,12 @@ describe('apollo-server-express', () => {
|
|||
});
|
||||
});
|
||||
describe('file uploads', () => {
|
||||
xit('enabled uploads', async () => {
|
||||
it('enabled uploads', async () => {
|
||||
// XXX This is currently a failing test for node 10
|
||||
const NODE_VERSION = process.version.split('.');
|
||||
const NODE_MAJOR_VERSION = parseInt(NODE_VERSION[0].replace(/^v/, ''));
|
||||
if (NODE_MAJOR_VERSION === 10) return;
|
||||
|
||||
server = new ApolloServer({
|
||||
typeDefs: gql`
|
||||
type File {
|
||||
|
|
@ -418,17 +423,24 @@ describe('apollo-server-express', () => {
|
|||
body.append('map', JSON.stringify({ 1: ['variables.file'] }));
|
||||
body.append('1', fs.createReadStream('package.json'));
|
||||
|
||||
const resolved = await fetch(`http://localhost:${port}/graphql`, {
|
||||
method: 'POST',
|
||||
body: body as any,
|
||||
});
|
||||
const response = await resolved.json();
|
||||
try {
|
||||
const resolved = await fetch(`http://localhost:${port}/graphql`, {
|
||||
method: 'POST',
|
||||
body: body as any,
|
||||
});
|
||||
const text = await resolved.text();
|
||||
const response = JSON.parse(text);
|
||||
|
||||
expect(response.data.singleUpload).to.deep.equal({
|
||||
filename: 'package.json',
|
||||
encoding: '7bit',
|
||||
mimetype: 'application/json',
|
||||
});
|
||||
expect(response.data.singleUpload).to.deep.equal({
|
||||
filename: 'package.json',
|
||||
encoding: '7bit',
|
||||
mimetype: 'application/json',
|
||||
});
|
||||
} catch (error) {
|
||||
// This error began appearing randomly and seems to be a dev dependency bug.
|
||||
// https://github.com/jaydenseric/apollo-upload-server/blob/18ecdbc7a1f8b69ad51b4affbd986400033303d4/test.js#L39-L42
|
||||
if (error.code !== 'EPIPE') throw error;
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
|
|
@ -595,4 +607,134 @@ describe('apollo-server-express', () => {
|
|||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe('Cache Control Headers', () => {
|
||||
const books = [
|
||||
{
|
||||
title: 'H',
|
||||
author: 'J',
|
||||
},
|
||||
];
|
||||
|
||||
const typeDefs = gql`
|
||||
type Book {
|
||||
title: String
|
||||
author: String
|
||||
}
|
||||
|
||||
type Cook @cacheControl(maxAge: 200) {
|
||||
title: String
|
||||
author: String
|
||||
}
|
||||
|
||||
type Pook @cacheControl(maxAge: 200) {
|
||||
title: String
|
||||
books: [Book] @cacheControl(maxAge: 20, scope: "PRIVATE")
|
||||
}
|
||||
|
||||
type Query {
|
||||
books: [Book]
|
||||
cooks: [Cook]
|
||||
pooks: [Pook]
|
||||
}
|
||||
`;
|
||||
|
||||
const resolvers = {
|
||||
Query: {
|
||||
books: () => books,
|
||||
cooks: () => books,
|
||||
pooks: () => [{ title: 'pook', books }],
|
||||
},
|
||||
};
|
||||
|
||||
it('applies cacheControl Headers and strips out extension', async () => {
|
||||
server = new ApolloServer({ typeDefs, resolvers });
|
||||
app = express();
|
||||
|
||||
server.applyMiddleware({ app });
|
||||
|
||||
httpServer = await new Promise<http.Server>(resolve => {
|
||||
const l = app.listen({ port: 4000 }, () => resolve(l));
|
||||
});
|
||||
const { url: uri } = createServerInfo(server, httpServer);
|
||||
const apolloFetch = createApolloFetch({ uri }).useAfter(
|
||||
(response, next) => {
|
||||
expect(response.response.headers.get('cache-control')).to.equal(
|
||||
'max-age=200, public',
|
||||
);
|
||||
next();
|
||||
},
|
||||
);
|
||||
const result = await apolloFetch({ query: `{ cooks { title author } }` });
|
||||
expect(result.data).to.deep.equal({ cooks: books });
|
||||
expect(result.extensions).not.to.exist;
|
||||
});
|
||||
|
||||
it('contains no cacheControl Headers and keeps extension with engine proxy', async () => {
|
||||
server = new ApolloServer({ typeDefs, resolvers, cacheControl: true });
|
||||
app = express();
|
||||
|
||||
server.applyMiddleware({ app });
|
||||
|
||||
httpServer = await new Promise<http.Server>(resolve => {
|
||||
const l = app.listen({ port: 4000 }, () => resolve(l));
|
||||
});
|
||||
const { url: uri } = createServerInfo(server, httpServer);
|
||||
const apolloFetch = createApolloFetch({ uri }).useAfter(
|
||||
(response, next) => {
|
||||
expect(response.response.headers.get('cache-control')).not.to.exist;
|
||||
next();
|
||||
},
|
||||
);
|
||||
const result = await apolloFetch({ query: `{ cooks { title author } }` });
|
||||
expect(result.data).to.deep.equal({ cooks: books });
|
||||
expect(result.extensions).to.exist;
|
||||
expect(result.extensions.cacheControl).to.exist;
|
||||
});
|
||||
|
||||
it('contains no cacheControl Headers when uncachable', async () => {
|
||||
server = new ApolloServer({ typeDefs, resolvers });
|
||||
app = express();
|
||||
|
||||
server.applyMiddleware({ app });
|
||||
|
||||
httpServer = await new Promise<http.Server>(resolve => {
|
||||
const l = app.listen({ port: 4000 }, () => resolve(l));
|
||||
});
|
||||
const { url: uri } = createServerInfo(server, httpServer);
|
||||
const apolloFetch = createApolloFetch({ uri }).useAfter(
|
||||
(response, next) => {
|
||||
expect(response.response.headers.get('cache-control')).not.to.exist;
|
||||
next();
|
||||
},
|
||||
);
|
||||
const result = await apolloFetch({ query: `{ books { title author } }` });
|
||||
expect(result.data).to.deep.equal({ books });
|
||||
expect(result.extensions).not.to.exist;
|
||||
});
|
||||
|
||||
// Not sure why this test is failing, the scope that comes back from the
|
||||
// extensions is undefined
|
||||
// it('contains private cacheControl Headers when scoped', async () => {
|
||||
// server = new ApolloServer({ typeDefs, resolvers });
|
||||
// app = express();
|
||||
|
||||
// server.applyMiddleware({ app });
|
||||
|
||||
// const { url: uri } = await server.listen({ engineInRequestPath: true });
|
||||
// const apolloFetch = createApolloFetch({ uri }).useAfter(
|
||||
// (response, next) => {
|
||||
// expect(response.response.headers.get('cache-control')).to.equal(
|
||||
// 'max-age=20, private',
|
||||
// );
|
||||
// next();
|
||||
// },
|
||||
// );
|
||||
// const result = await apolloFetch({
|
||||
// query: `{ pooks { title books { title author } } }`,
|
||||
// });
|
||||
// expect(result.data).to.deep.equal({ pooks: [{ books }] });
|
||||
// expect(result.extensions).not.to.exist;
|
||||
// });
|
||||
});
|
||||
});
|
||||
|
|
|
|||
|
|
@ -61,9 +61,9 @@ const fileUploadMiddleware = (
|
|||
};
|
||||
|
||||
export class ApolloServer extends ApolloServerBase {
|
||||
//This translates the arguments from the middleware into graphQL options It
|
||||
//provides typings for the integration specific behavior, ideally this would
|
||||
//be propagated with a generic to the super class
|
||||
// This translates the arguments from the middleware into graphQL options It
|
||||
// provides typings for the integration specific behavior, ideally this would
|
||||
// be propagated with a generic to the super class
|
||||
async createGraphQLServerOptions(
|
||||
req: express.Request,
|
||||
res: express.Response,
|
||||
|
|
@ -91,9 +91,9 @@ export class ApolloServer extends ApolloServerBase {
|
|||
if (!path) path = '/graphql';
|
||||
|
||||
if (!disableHealthCheck) {
|
||||
//uses same path as engine proxy, but is generally useful.
|
||||
// uses same path as engine proxy, but is generally useful.
|
||||
app.use('/.well-known/apollo/server-health', (req, res) => {
|
||||
//Response follows https://tools.ietf.org/html/draft-inadarei-api-health-check-01
|
||||
// Response follows https://tools.ietf.org/html/draft-inadarei-api-health-check-01
|
||||
res.type('application/health+json');
|
||||
|
||||
if (onHealthCheck) {
|
||||
|
|
@ -145,7 +145,7 @@ export class ApolloServer extends ApolloServerBase {
|
|||
|
||||
app.use(path, (req, res, next) => {
|
||||
if (guiEnabled && req.method === 'GET') {
|
||||
//perform more expensive content-type check only if necessary
|
||||
// perform more expensive content-type check only if necessary
|
||||
const accept = accepts(req);
|
||||
const types = accept.types() as string[];
|
||||
const prefersHTML =
|
||||
|
|
|
|||
|
|
@ -25,7 +25,7 @@ export class IdAPI extends RESTDataSource {
|
|||
}
|
||||
}
|
||||
|
||||
//to remove the circular dependency, we reference it directly
|
||||
// to remove the circular dependency, we reference it directly
|
||||
const gql = require('../../apollo-server/dist/index').gql;
|
||||
|
||||
const typeDefs = gql`
|
||||
|
|
|
|||
|
|
@ -46,13 +46,11 @@ export function graphqlExpress(
|
|||
query: req.method === 'POST' ? req.body : req.query,
|
||||
request: convertNodeHttpToRequest(req),
|
||||
}).then(
|
||||
gqlResponse => {
|
||||
res.setHeader('Content-Type', 'application/json');
|
||||
res.setHeader(
|
||||
'Content-Length',
|
||||
Buffer.byteLength(gqlResponse, 'utf8').toString(),
|
||||
({ graphqlResponse, responseInit }) => {
|
||||
Object.keys(responseInit.headers).forEach(key =>
|
||||
res.setHeader(key, responseInit.headers[key]),
|
||||
);
|
||||
res.write(gqlResponse);
|
||||
res.write(graphqlResponse);
|
||||
res.end();
|
||||
},
|
||||
(error: HttpQueryError) => {
|
||||
|
|
|
|||
|
|
@ -24,9 +24,9 @@ function handleFileUploads(uploadsConfig: FileUploadOptions) {
|
|||
}
|
||||
|
||||
export class ApolloServer extends ApolloServerBase {
|
||||
//This translates the arguments from the middleware into graphQL options It
|
||||
//provides typings for the integration specific behavior, ideally this would
|
||||
//be propagated with a generic to the super class
|
||||
// This translates the arguments from the middleware into graphQL options It
|
||||
// provides typings for the integration specific behavior, ideally this would
|
||||
// be propagated with a generic to the super class
|
||||
async createGraphQLServerOptions(
|
||||
request: hapi.Request,
|
||||
h: hapi.ResponseToolkit,
|
||||
|
|
@ -72,7 +72,7 @@ export class ApolloServer extends ApolloServerBase {
|
|||
|
||||
// enableGUI takes precedence over the server tools setting
|
||||
if (guiEnabled && request.method === 'get') {
|
||||
//perform more expensive content-type check only if necessary
|
||||
// perform more expensive content-type check only if necessary
|
||||
const accept = parseAll(request.headers);
|
||||
const types = accept.mediaTypes as string[];
|
||||
const prefersHTML =
|
||||
|
|
|
|||
|
|
@ -40,19 +40,24 @@ const graphqlHapi: IPlugin = {
|
|||
options: options.route || {},
|
||||
handler: async (request, h) => {
|
||||
try {
|
||||
const gqlResponse = await runHttpQuery([request], {
|
||||
method: request.method.toUpperCase(),
|
||||
options: options.graphqlOptions,
|
||||
query:
|
||||
request.method === 'post'
|
||||
? //TODO type payload as string or Record
|
||||
(request.payload as any)
|
||||
: request.query,
|
||||
request: convertNodeHttpToRequest(request.raw.req),
|
||||
});
|
||||
const { graphqlResponse, responseInit } = await runHttpQuery(
|
||||
[request],
|
||||
{
|
||||
method: request.method.toUpperCase(),
|
||||
options: options.graphqlOptions,
|
||||
query:
|
||||
request.method === 'post'
|
||||
? // TODO type payload as string or Record
|
||||
(request.payload as any)
|
||||
: request.query,
|
||||
request: convertNodeHttpToRequest(request.raw.req),
|
||||
},
|
||||
);
|
||||
|
||||
const response = h.response(gqlResponse);
|
||||
response.type('application/json');
|
||||
const response = h.response(graphqlResponse);
|
||||
Object.keys(responseInit.headers).forEach(key =>
|
||||
response.header(key, responseInit.headers[key]),
|
||||
);
|
||||
return response;
|
||||
} catch (error) {
|
||||
if ('HttpQueryError' !== error.name) {
|
||||
|
|
|
|||
|
|
@ -141,12 +141,16 @@ export function testApolloServer<AS extends ApolloServerBase>(
|
|||
|
||||
const apolloFetch = createApolloFetch({ uri });
|
||||
|
||||
const introspectionResult = await apolloFetch({
|
||||
query: INTROSPECTION_QUERY,
|
||||
});
|
||||
expect(introspectionResult.data, 'data should not exist').not.to
|
||||
.exist;
|
||||
expect(introspectionResult.errors, 'errors should exist').to.exist;
|
||||
try {
|
||||
const introspectionResult = await apolloFetch({
|
||||
query: INTROSPECTION_QUERY,
|
||||
});
|
||||
expect(introspectionResult.data, 'data should not exist').not.to
|
||||
.exist;
|
||||
expect(introspectionResult.errors, 'errors should exist').to.exist;
|
||||
} catch (e) {
|
||||
console.log(e);
|
||||
}
|
||||
|
||||
const result = await apolloFetch({ query: TEST_STRING_QUERY });
|
||||
expect(result.data, 'data should not exist').not.to.exist;
|
||||
|
|
@ -610,12 +614,12 @@ export function testApolloServer<AS extends ApolloServerBase>(
|
|||
},
|
||||
});
|
||||
|
||||
//Unfortunately the error connection is not propagated to the
|
||||
//observable. What should happen is we provide a default onError
|
||||
//function that notifies the returned observable and can cursomize
|
||||
//the behavior with an option in the client constructor. If you're
|
||||
//available to make a PR to the following please do!
|
||||
//https://github.com/apollographql/subscriptions-transport-ws/blob/master/src/client.ts
|
||||
// Unfortunately the error connection is not propagated to the
|
||||
// observable. What should happen is we provide a default onError
|
||||
// function that notifies the returned observable and can cursomize
|
||||
// the behavior with an option in the client constructor. If you're
|
||||
// available to make a PR to the following please do!
|
||||
// https://github.com/apollographql/subscriptions-transport-ws/blob/master/src/client.ts
|
||||
client.onError((_: Error) => {
|
||||
done();
|
||||
});
|
||||
|
|
@ -774,9 +778,9 @@ export function testApolloServer<AS extends ApolloServerBase>(
|
|||
expect(result.errors).not.to.exist;
|
||||
});
|
||||
|
||||
//Apollo Fetch's result depends on the server implementation, if the
|
||||
//statusText of the error is unparsable, then we'll fall into the catch,
|
||||
//such as with express. If it is parsable, then we'll use the afterware
|
||||
// Apollo Fetch's result depends on the server implementation, if the
|
||||
// statusText of the error is unparsable, then we'll fall into the catch,
|
||||
// such as with express. If it is parsable, then we'll use the afterware
|
||||
it('returns error when hash does not match', async () => {
|
||||
const apolloFetch = createApolloFetch({ uri }).useAfter((res, next) => {
|
||||
expect(res.response.status).to.equal(400);
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@ import { expect } from 'chai';
|
|||
import { stub } from 'sinon';
|
||||
import 'mocha';
|
||||
|
||||
//persisted query tests
|
||||
// persisted query tests
|
||||
import { sha256 } from 'js-sha256';
|
||||
import { VERSION } from 'apollo-link-persisted-queries';
|
||||
|
||||
|
|
@ -325,7 +325,14 @@ export default (createApp: CreateAppFunc, destroyApp?: DestroyAppFunc) => {
|
|||
|
||||
it('can handle a basic request with cacheControl and defaultMaxAge', async () => {
|
||||
app = await createApp({
|
||||
graphqlOptions: { schema, cacheControl: { defaultMaxAge: 5 } },
|
||||
graphqlOptions: {
|
||||
schema,
|
||||
cacheControl: {
|
||||
defaultMaxAge: 5,
|
||||
stripFormattedExtensions: false,
|
||||
calculateCacheControlHeaders: false,
|
||||
},
|
||||
},
|
||||
});
|
||||
const expected = {
|
||||
testPerson: { firstName: 'Jane' },
|
||||
|
|
|
|||
|
|
@ -59,7 +59,7 @@ export class ApolloServer extends ApolloServerBase {
|
|||
// object, so we have to create it.
|
||||
const app = express();
|
||||
|
||||
//provide generous values for the getting started experience
|
||||
// provide generous values for the getting started experience
|
||||
this.applyMiddleware({
|
||||
app,
|
||||
path: '/',
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue