apollo-server-lambda/dist/ApolloServer.js

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.ApolloServer = exports.FileUploadRequest = void 0;
const apollo_server_core_1 = require("apollo-server-core");
const graphql_playground_html_1 = require("@apollographql/graphql-playground-html");
const apollo_server_env_1 = require("apollo-server-env");
const stream_1 = require("stream");
function eventHttpMethod(event) {
    return 'httpMethod' in event
        ? event.httpMethod
        : event.requestContext.http.method;
}
function eventPath(event) {
    return 'path' in event ? event.path : event.rawPath;
}
class FileUploadRequest extends stream_1.Readable {
}
exports.FileUploadRequest = FileUploadRequest;
function maybeCallbackify(asyncHandler) {
    return (event, context, callback) => {
        if (callback) {
            context.callbackWaitsForEmptyEventLoop = false;
            asyncHandler(event, context).then((r) => callback(null, r), (e) => callback(e));
            return;
        }
        else {
            return asyncHandler(event, context);
        }
    };
}
class ApolloServer extends apollo_server_core_1.ApolloServerBase {
    serverlessFramework() {
        return true;
    }
    supportsUploads() {
        return true;
    }
    createGraphQLServerOptions(event, context) {
        return super.graphQLServerOptions({ event, context });
    }
    createHandler({ cors, onHealthCheck } = {
        cors: undefined,
        onHealthCheck: undefined,
    }) {
        const corsHeaders = new apollo_server_env_1.Headers();
        if (cors) {
            if (cors.methods) {
                if (typeof cors.methods === 'string') {
                    corsHeaders.set('access-control-allow-methods', cors.methods);
                }
                else if (Array.isArray(cors.methods)) {
                    corsHeaders.set('access-control-allow-methods', cors.methods.join(','));
                }
            }
            if (cors.allowedHeaders) {
                if (typeof cors.allowedHeaders === 'string') {
                    corsHeaders.set('access-control-allow-headers', cors.allowedHeaders);
                }
                else if (Array.isArray(cors.allowedHeaders)) {
                    corsHeaders.set('access-control-allow-headers', cors.allowedHeaders.join(','));
                }
            }
            if (cors.exposedHeaders) {
                if (typeof cors.exposedHeaders === 'string') {
                    corsHeaders.set('access-control-expose-headers', cors.exposedHeaders);
                }
                else if (Array.isArray(cors.exposedHeaders)) {
                    corsHeaders.set('access-control-expose-headers', cors.exposedHeaders.join(','));
                }
            }
            if (cors.credentials) {
                corsHeaders.set('access-control-allow-credentials', 'true');
            }
            if (typeof cors.maxAge === 'number') {
                corsHeaders.set('access-control-max-age', cors.maxAge.toString());
            }
        }
        return maybeCallbackify((event, context) => __awaiter(this, void 0, void 0, function* () {
            const eventHeaders = new apollo_server_env_1.Headers(event.headers);
            const requestCorsHeaders = new apollo_server_env_1.Headers(corsHeaders);
            if (cors && cors.origin) {
                const requestOrigin = eventHeaders.get('origin');
                if (typeof cors.origin === 'string') {
                    requestCorsHeaders.set('access-control-allow-origin', cors.origin);
                }
                else if (requestOrigin &&
                    (typeof cors.origin === 'boolean' ||
                        (Array.isArray(cors.origin) &&
                            requestOrigin &&
                            cors.origin.includes(requestOrigin)))) {
                    requestCorsHeaders.set('access-control-allow-origin', requestOrigin);
                }
                const requestAccessControlRequestHeaders = eventHeaders.get('access-control-request-headers');
                if (!cors.allowedHeaders && requestAccessControlRequestHeaders) {
                    requestCorsHeaders.set('access-control-allow-headers', requestAccessControlRequestHeaders);
                }
            }
            const requestCorsHeadersObject = Array.from(requestCorsHeaders).reduce((headersObject, [key, value]) => {
                headersObject[key] = value;
                return headersObject;
            }, {});
            if (eventHttpMethod(event) === 'OPTIONS') {
                return {
                    body: '',
                    statusCode: 204,
                    headers: Object.assign({}, requestCorsHeadersObject),
                };
            }
            if (eventPath(event).endsWith('/.well-known/apollo/server-health')) {
                if (onHealthCheck) {
                    try {
                        yield onHealthCheck(event);
                    }
                    catch (_) {
                        return {
                            body: JSON.stringify({ status: 'fail' }),
                            statusCode: 503,
                            headers: Object.assign({ 'Content-Type': 'application/json' }, requestCorsHeadersObject),
                        };
                    }
                }
                return {
                    body: JSON.stringify({ status: 'pass' }),
                    statusCode: 200,
                    headers: Object.assign({ 'Content-Type': 'application/json' }, requestCorsHeadersObject),
                };
            }
            if (this.playgroundOptions && eventHttpMethod(event) === 'GET') {
                const acceptHeader = event.headers['Accept'] || event.headers['accept'];
                if (acceptHeader && acceptHeader.includes('text/html')) {
                    const path = eventPath(event) || '/';
                    const playgroundRenderPageOptions = Object.assign({ endpoint: path }, this.playgroundOptions);
                    return {
                        body: graphql_playground_html_1.renderPlaygroundPage(playgroundRenderPageOptions),
                        statusCode: 200,
                        headers: Object.assign({ 'Content-Type': 'text/html' }, requestCorsHeadersObject),
                    };
                }
            }
            const response = new stream_1.Writable();
            const contentType = (event.headers['content-type'] ||
                event.headers['Content-Type'] ||
                '').toLowerCase();
            const isMultipart = contentType.startsWith('multipart/form-data');
            let bodyFromFileUploads;
            if (isMultipart && typeof apollo_server_core_1.processFileUploads === 'function') {
                const request = new FileUploadRequest();
                request.push(Buffer.from(event.body, event.isBase64Encoded ? 'base64' : 'ascii'));
                request.push(null);
                request.headers = event.headers;
                try {
                    bodyFromFileUploads = yield apollo_server_core_1.processFileUploads(request, response, this.uploadsConfig || {});
                }
                catch (error) {
                    throw apollo_server_core_1.formatApolloErrors([error], {
                        formatter: this.requestOptions.formatError,
                        debug: this.requestOptions.debug,
                    });
                }
            }
            try {
                let { body, isBase64Encoded } = event;
                let query;
                if (body && isBase64Encoded && !isMultipart) {
                    body = Buffer.from(body, 'base64').toString();
                }
                if (eventHttpMethod(event) === 'POST' && !body) {
                    return {
                        body: 'POST body missing.',
                        statusCode: 500,
                    };
                }
                if (bodyFromFileUploads) {
                    query = bodyFromFileUploads;
                }
                else if (body && eventHttpMethod(event) === 'POST' && isMultipart) {
                    query = body;
                }
                else if (body && eventHttpMethod(event) === 'POST') {
                    query = JSON.parse(body);
                }
                else {
                    query = event.queryStringParameters || {};
                }
                try {
                    const { graphqlResponse, responseInit } = yield apollo_server_core_1.runHttpQuery([event, context], {
                        method: eventHttpMethod(event),
                        options: () => __awaiter(this, void 0, void 0, function* () {
                            return this.createGraphQLServerOptions(event, context);
                        }),
                        query,
                        request: {
                            url: eventPath(event),
                            method: eventHttpMethod(event),
                            headers: eventHeaders,
                        },
                    });
                    return {
                        body: graphqlResponse,
                        statusCode: 200,
                        headers: Object.assign(Object.assign({}, responseInit.headers), requestCorsHeadersObject),
                    };
                }
                catch (error) {
                    if (error.name !== 'HttpQueryError')
                        throw error;
                    const httpQueryError = error;
                    return {
                        body: httpQueryError.message,
                        statusCode: httpQueryError.statusCode,
                        headers: Object.assign(Object.assign({}, httpQueryError.headers), requestCorsHeadersObject),
                    };
                }
            }
            finally {
                response.end();
            }
        }));
    }
}
exports.ApolloServer = ApolloServer;
//# sourceMappingURL=ApolloServer.js.map