Scaffold out new transport mechanisms

v3/src/execution/__tests__/execution.test.ts

@@ -399,7 +399,7 @@ describe("processGraphqlRequest", () => {
       context
     });
 
-    expect(data.modifiesContext).toBe("Context modified!");
+    expect(data && data.modifiesContext).toBe("Context modified!");
     expect(context).toHaveProperty("modified");
   });
 });

v3/src/execution/index.ts

@@ -1,35 +1,29 @@
 export {
-  processGraphQLRequest,
   GraphQLRequestContext,
   GraphQLRequestPipelineConfig,
 } from 'apollo-server-core/dist/requestPipeline';
-import {
-  GraphQLRequest,
-  GraphQLResponse,
-  VariableValues,
-} from 'apollo-server-types';
+import { VariableValues } from 'apollo-server-types';
 import {
   DocumentNode,
   parse,
   GraphQLError,
   GraphQLSchema,
   validate,
   execute,
-  ExecutionResult,
   separateOperations,
 } from 'graphql';
-export { GraphQLRequest, GraphQLResponse };
+import { GraphQLRequest, GraphQLResponse } from "../types/";
 
 // TODO(AS3) I'm not sure if this is execution.  Perhaps, a top-level export.
 export { GraphQLSchemaModule } from 'apollo-graphql';
 
 export { Context, ContextFunction } from 'apollo-server-core';
 
-/** Options for {@link processGraphQLRequest} */
-interface ProcessRequestInput<TContext extends Record<string, any>> {
+/** Options for {@link processGraphqlRequest} */
+interface ProcessRequestInput<TRequestContext extends Record<string, any>> {
   request: GraphQLRequest;
   schema: GraphQLSchema;
-  context?: TContext;
+  context?: TRequestContext;
 }
 
 /**
@@ -47,13 +41,12 @@ interface ProcessRequestInput<TContext extends Record<string, any>> {
  *   3. Data without errors if execution was successful without errors
  */
 export async function processGraphqlRequest<
-  TData = Record<string, any>,
   TContext extends Record<string, any> = Record<string, any>
 >({
   request,
   schema,
   context,
-}: ProcessRequestInput<TContext>): Promise<ExecutionResult<TData>> {
+}: ProcessRequestInput<TContext>): Promise<GraphQLResponse> {
   const { query, operationName, variables } = request;
 
   if (!query) {
@@ -79,7 +72,7 @@ export async function processGraphqlRequest<
     return { errors: documentValidationErrors };
   }
 
-  return await executeGraphqlRequest<TData>({
+  return await executeGraphqlRequest({
     schema,
     document: parseResult.document,
     operationName,
@@ -175,14 +168,14 @@ interface ExecutionInput<
  *
  * @see https://github.com/graphql/graphql-spec/blob/master/spec/Section%207%20--%20Response.md#response-format
  */
-export async function executeGraphqlRequest<TData = Record<string, any>>({
+export async function executeGraphqlRequest({
   schema,
   document,
   operationName,
   variables,
   context,
-}: ExecutionInput): Promise<ExecutionResult<TData>> {
-  return await execute<TData>({
+}: ExecutionInput): Promise<GraphQLResponse> {
+  return await execute<Record<string, any>>({
     schema,
     document,
     operationName,

v3/src/index.ts

@@ -3,23 +3,12 @@ import { GraphQLSchema } from 'graphql/type/schema';
 import { DocumentNode } from 'graphql/language/ast';
 import { InMemoryLRUCache } from './caching';
 import { approximateObjectSize } from './utilities';
-import {
-  GraphQLRequest,
-  GraphQLResponse,
-  processGraphQLRequest,
-  GraphQLRequestContext,
-  GraphQLRequestPipelineConfig,
-} from './execution';
 
 // These should not be imported from here.
 import { Config as BaseConfig } from 'apollo-server-core';
 import { buildServiceDefinition } from '@apollographql/apollo-tools';
 
 export { default as gql } from 'graphql-tag';
-import {
-  Context,
-  ContextFunction,
-} from './execution';
 
 // A subset of the base configuration.
 type Config = Pick<BaseConfig,
@@ -48,7 +37,6 @@ type SchemaDerivedData = {
 export class ApolloServer {
   // public requestOptions: Partial<GraphQLOptions<any>> = Object.create(null);
 
-  private userContext?: Context | ContextFunction;
   // TODO(AS3) Reconsider these for Apollo Graph Manager
   // private engineReportingAgent?: import('apollo-engine-reporting').EngineReportingAgent;
   // private engineServiceId?: string;
@@ -64,9 +52,6 @@ export class ApolloServer {
   constructor(private readonly config: Config) {
     if (!config) throw new Error('ApolloServer requires options.');
 
-    // TODO(AS3) Rename content variables to be more clear, like `userContext`.
-    this.userContext = this.config.context;
-
     // Plugins will be instantiated if they aren't already, and this.plugins
     // is populated accordingly.
     this.ensurePluginInstantiation(this.config.plugins);
@@ -269,68 +254,4 @@ export class ApolloServer {
       sizeCalculator: approximateObjectSize,
     });
   }
-
-  public async executeOperation<
-    R extends GraphQLRequest,
-    S extends GraphQLResponse = GraphQLResponse
-  >(
-    request: R,
-    responseInit: S = Object.create(null),
-  ) {
-
-    const { schema, documentStore } = await this.schemaDerivedData;
-
-    // TODO(AS3) The transport will provide context.
-    const integrationContextArgument = Object.create(null);
-
-    let context: Context;
-
-    try {
-      context =
-        typeof this.userContext === 'function'
-          ? await this.userContext(integrationContextArgument || Object.create(null))
-          : this.userContext || Object.create(null);
-    } catch (error) {
-      // Defer context error resolution to inside of runQuery
-      context = () => {
-        throw error;
-      };
-    }
-
-    // TODO(AS3) This context argument is maybe quite wrong, check it.
-    const options: GraphQLRequestPipelineConfig<typeof context> = {
-      schema,
-      plugins: this.plugins,
-      documentStore,
-      // Allow overrides from options. Be explicit about a couple of them to
-      // avoid a bad side effect of the otherwise useful noUnusedLocals option
-      // (https://github.com/Microsoft/TypeScript/issues/21673).
-      // TODO(AS3)
-      // persistedQueries: this.requestOptions
-      //   .persistedQueries as PersistedQueryOptions,
-      // TODO(AS3)
-      // fieldResolver: this.requestOptions.fieldResolver as GraphQLFieldResolver<
-      //   any,
-      //   any
-      // >,
-      // TODO(AS3)
-      // parseOptions: this.parseOptions,
-      // TODO(AS3): AGM
-      // reporting: !!this.engineReportingAgent,
-      // ...this.requestOptions,
-    };
-
-    // TODO(AS3) This is not where the global cache should be created.
-    // Especially since this is per request.
-    const cache = new InMemoryLRUCache();
-
-    const requestCtx: GraphQLRequestContext = {
-      request,
-      context,
-      cache,
-      response: responseInit,
-    };
-
-    return processGraphQLRequest(options, requestCtx);
-  }
 }

v3/src/transports/http/__tests__/handler.test.ts

@@ -0,0 +1,131 @@
+import { gql } from "apollo-server-core";
+import { buildSchemaFromSDL } from "apollo-graphql";
+import { httpHandler, responseAsInternalServerError } from "../handler";
+import { ServerResponse, RequestListener } from "http";
+import { PassThrough, Readable } from "stream";
+const testModule = {
+  typeDefs: gql`
+    type Book {
+      title: String
+      author: String
+    }
+
+    type Query {
+      books: [Book]
+    }
+  `,
+  resolvers: {
+    Query: {
+      books: () => [
+        {
+          title: "Harry Potter and the Chamber of Secrets",
+          author: "J.K. Rowling",
+        },
+        {
+          title: "Jurassic Park",
+          author: "Michael Crichton",
+        },
+      ],
+    },
+  },
+};
+
+type IMockedResponse = Pick<
+      ServerResponse,
+      | "setHeader"
+      | "writeHead"
+      | "statusCode"
+      | "statusMessage"
+      | "write"
+      | "end"
+    >
+
+// type IMockedRequest = Pick<IncomingMessage, "method">;
+// type IMockedRequestListener = (req: IMockedRequest) => void;
+
+function mockedResponse(): IMockedResponse {
+  return {
+    writeHead: jest.fn(),
+    write: jest.fn(),
+    end: jest.fn(),
+    setHeader: jest.fn(),
+    statusCode: 0,
+    statusMessage: "DEFAULT_VALUE",
+  };
+}
+
+const validQuery= "query { books { author } }";
+const schema = buildSchemaFromSDL([testModule]);
+
+describe("httpHandler", () => {
+  describe("construction", () => {
+    it("returns a RequestListener when invoked with a schema", () => {
+      expect(httpHandler(schema)).toBeInstanceOf(Function);
+    });
+
+    it("throws when invoked without a schema", () => {
+      expect(() => {
+        // @ts-ignore
+        httpHandler();
+      }).toThrowErrorMatchingInlineSnapshot(`"Must pass a schema."`);
+    });
+  });
+
+  describe("RequestListener", () => {
+    let handler: RequestListener;
+    let res: IMockedResponse;
+
+    beforeEach(() => {
+      handler = httpHandler(schema);
+      res = mockedResponse();
+    });
+
+    // TODO(AS3) Skipped, but need to enable.
+    it.skip("throws when called with no request", () => {
+      expect(() => {
+        // @ts-ignore
+        handler();
+      }).toThrowError();
+    });
+
+    // TODO(AS3) Move this to testing `jsonBodyParse` and finish it by
+    // proving that it's actually failing as it should be.
+    // (I'm pretty sure it's failing for the wrong reasons.)
+    it.skip("fails with an internal server error on corrupted body streams",
+      async () => {
+        const pass = new PassThrough();
+        const readable = new Readable();
+        // readable._read = function () {};
+
+        const req = Object.assign({
+          method: 'POST',
+          headers: {},
+        }, readable);
+
+        pass.write(JSON.stringify({ query: validQuery }));
+
+        // @ts-ignore
+        await handler(req, res);
+
+        expect(res.writeHead).toBeCalledWith(500, "Error parsing body");
+      }
+    );
+
+    // Legacy
+    it.todo("returns a 500 if the body of the request is missing");
+    it.todo(
+      "returns a 400 if the 'query' is missing when the 'GET' method is used",
+    );
+  });
+});
+
+describe("responseAsInternalServerError", () => {
+  it("can call the writeHead message with the correct code and message", () => {
+    const res = mockedResponse();
+    // @ts-ignore
+    responseAsInternalServerError(res, "Catastrophic.");
+    expect(res.writeHead).toBeCalledTimes(1);
+    expect(res.writeHead).toBeCalledWith(500, "Catastrophic.");
+    expect(res.end).not.toBeCalled();
+  })
+});