Merge pull request #9 from apollo-server-integrations/initial-implementation

Initial implementation for Azure Functions

Author: aaronpowell

package-lock.json

@@ -29,16 +29,21 @@
     "spell-check": "cspell lint '**' --no-progress || (echo 'Add any real words to cspell-dict.txt.'; exit 1)",
     "test": "jest",
     "test:ci": "jest --coverage --ci --maxWorkers=2 --reporters=default --reporters=jest-junit",
-    "watch": "tsc --build --watch"
+    "watch": "tsc --build --watch",
+    "start": "npm-run-all watch start:host",
+    "start:host": "cd src/sample && func start --cors *"
   },
   "devDependencies": {
+    "@apollo/server-integration-testsuite": "^4.1.1",
     "@changesets/changelog-github": "0.4.7",
     "@changesets/cli": "2.25.1",
     "@types/jest": "29.2.0",
     "@types/node": "14.18.33",
+    "azure-functions-core-tools": "^4.0.4895",
     "cspell": "6.13.1",
     "jest": "29.2.2",
     "jest-junit": "14.0.1",
+    "npm-run-all": "^4.1.5",
     "prettier": "2.7.1",
     "ts-jest": "29.0.3",
     "ts-node": "10.9.1",
@@ -47,5 +52,11 @@
   "volta": {
     "node": "16.18.0",
     "npm": "8.19.2"
+  },
+  "dependencies": {
+    "@apollo/server": "^4.1.1",
+    "@azure/functions": "^3.2.0",
+    "graphql": "^16.6.0",
+    "graphql-tag": "^2.12.6"
   }
 }

package.json

@@ -0,0 +1,47 @@
+import { ApolloServer, ApolloServerOptions, BaseContext } from '@apollo/server';
+import { startServerAndCreateHandler } from '..';
+import {
+  CreateServerForIntegrationTestsOptions,
+  defineIntegrationTestSuite,
+} from '@apollo/server-integration-testsuite';
+import { createServer } from 'http';
+import type { AzureFunction } from '@azure/functions';
+import { createMockServer, urlForHttpServer } from './mockServer';
+
+describe('Azure Functions', () => {
+  defineIntegrationTestSuite(
+    async function (
+      serverOptions: ApolloServerOptions<BaseContext>,
+      testOptions?: CreateServerForIntegrationTestsOptions,
+    ) {
+      const httpServer = createServer();
+      const server = new ApolloServer({
+        ...serverOptions,
+      });
+
+      const handler: AzureFunction = testOptions
+        ? startServerAndCreateHandler(server, testOptions)
+        : startServerAndCreateHandler(server);
+
+      await new Promise<void>((resolve) => {
+        httpServer.listen({ port: 0 }, resolve);
+      });
+
+      httpServer.addListener('request', createMockServer(handler));
+
+      return {
+        server,
+        url: urlForHttpServer(httpServer),
+        async extraCleanup() {
+          await new Promise<void>((resolve) => {
+            httpServer.close(() => resolve());
+          });
+        },
+      };
+    },
+    {
+      serverIsStartedInBackground: true,
+      noIncrementalDelivery: true,
+    },
+  );
+});

src/__tests__/helloWorld.test.ts

@@ -0,0 +1,119 @@
+import type {
+  AzureFunction,
+  Context,
+  HttpMethod,
+  HttpRequest,
+  HttpRequestHeaders,
+  HttpRequestQuery,
+  Logger,
+} from '@azure/functions';
+import type {
+  IncomingHttpHeaders,
+  IncomingMessage,
+  Server,
+  ServerResponse,
+} from 'http';
+import type { AddressInfo } from 'net';
+
+export function urlForHttpServer(httpServer: Server): string {
+  const { address, port } = httpServer.address() as AddressInfo;
+
+  // Convert IPs which mean "any address" (IPv4 or IPv6) into localhost
+  // corresponding loopback ip. Note that the url field we're setting is
+  // primarily for consumption by our test suite. If this heuristic is wrong for
+  // your use case, explicitly specify a frontend host (in the `host` option
+  // when listening).
+  const hostname = address === '' || address === '::' ? 'localhost' : address;
+
+  return `http://${hostname}:${port}`;
+}
+
+export const createMockServer = (handler: AzureFunction) => {
+  return (req: IncomingMessage, res: ServerResponse) => {
+    let body = '';
+    req.on('data', (chunk) => (body += chunk));
+
+    req.on('end', async () => {
+      const azReq: HttpRequest = {
+        method: (req.method as HttpMethod) || null,
+        url: new URL(req.url || '', 'http://localhost').toString(),
+        headers: processHeaders(req.headers),
+        body,
+        query: processQuery(req.url),
+        params: {},
+        user: null,
+        parseFormBody: () => {
+          throw new Error('Not implemented');
+        },
+      };
+
+      const context: Context = {
+        invocationId: 'mock',
+        executionContext: {
+          invocationId: 'mock',
+          functionName: 'mock',
+          functionDirectory: 'mock',
+          retryContext: null,
+        },
+        bindings: {},
+        bindingData: {
+          invocationId: 'mock',
+        },
+        log: createConsoleLogger(),
+        bindingDefinitions: [],
+        traceContext: {
+          traceparent: '',
+          tracestate: '',
+          attributes: {},
+        },
+        done: () => {},
+      };
+
+      const azRes = await handler(context, azReq);
+
+      res.statusCode = azRes.status || 200;
+      Object.entries(azRes.headers ?? {}).forEach(([key, value]) => {
+        res.setHeader(key, value!.toString());
+      });
+      res.write(azRes.body);
+      res.end();
+    });
+  };
+};
+
+const processQuery: (url: string | undefined) => HttpRequestQuery = (url) => {
+  if (!url) {
+    return {};
+  }
+
+  const uri = new URL(url, 'http://localhost');
+
+  const query: HttpRequestQuery = {};
+  for (const [key, value] of uri.searchParams.entries()) {
+    if (query[key] !== undefined) {
+      query[key] = `${query[key]},${value}`;
+    } else {
+      query[key] = value;
+    }
+  }
+  return query;
+};
+
+const processHeaders: (headers: IncomingHttpHeaders) => HttpRequestHeaders = (
+  headers,
+) => {
+  const result: HttpRequestHeaders = {};
+  for (const [key, value] of Object.entries(headers)) {
+    result[key] = Array.isArray(value) ? value.join(',') : value ?? '';
+  }
+  return result;
+};
+
+const createConsoleLogger = () => {
+  const logger = console.log as Logger;
+  logger.error = console.error;
+  logger.warn = console.warn;
+  logger.info = console.info;
+  logger.verbose = console.log;
+  return logger;
+};

src/__tests__/index.test.ts

@@ -1,3 +1,108 @@
-export function helloWorld() {
-  return 'Hello World!';
+import type {
+  AzureFunction,
+  Context,
+  HttpRequest,
+  HttpRequestHeaders,
+} from '@azure/functions';
+import {
+  ApolloServer,
+  BaseContext,
+  ContextFunction,
+  HeaderMap,
+  HTTPGraphQLRequest,
+} from '@apollo/server';
+import type { WithRequired } from '@apollo/utils.withrequired';
+
+export interface AzureFunctionsContextFunctionArgument {
+  context: Context;
+}
+
+export interface AzureFunctionsMiddlewareOptions<TContext extends BaseContext> {
+  context?: ContextFunction<[AzureFunctionsContextFunctionArgument], TContext>;
+}
+
+const defaultContext: ContextFunction<
+  [AzureFunctionsContextFunctionArgument],
+  any
+> = async () => ({});
+
+export function startServerAndCreateHandler(
+  server: ApolloServer<BaseContext>,
+  options?: AzureFunctionsMiddlewareOptions<BaseContext>,
+): AzureFunction;
+export function startServerAndCreateHandler<TContext extends BaseContext>(
+  server: ApolloServer<TContext>,
+  options: WithRequired<AzureFunctionsMiddlewareOptions<TContext>, 'context'>,
+): AzureFunction;
+export function startServerAndCreateHandler<TContext extends BaseContext>(
+  server: ApolloServer<TContext>,
+  options?: AzureFunctionsMiddlewareOptions<TContext>,
+): AzureFunction {
+  server.startInBackgroundHandlingStartupErrorsByLoggingAndFailingAllRequests();
+  return async (context: Context, req: HttpRequest) => {
+    const contextFunction = options?.context ?? defaultContext;
+    try {
+      const normalizedRequest = normalizeRequest(req);
+
+      const { body, headers, status } = await server.executeHTTPGraphQLRequest({
+        httpGraphQLRequest: normalizedRequest,
+        context: () => contextFunction({ context }),
+      });
+
+      if (body.kind === 'chunked') {
+        throw Error('Incremental delivery not implemented');
+      }
+
+      return {
+        status: status || 200,
+        headers: {
+          ...Object.fromEntries(headers),
+          'content-length': Buffer.byteLength(body.string).toString(),
+        },
+        body: body.string,
+      };
+    } catch (e) {
+      context.log.error('Failure processing GraphQL request', e);
+      return {
+        status: 400,
+        body: (e as Error).message,
+      };
+    }
+  };
+}
+
+function normalizeRequest(req: HttpRequest): HTTPGraphQLRequest {
+  if (!req.method) {
+    throw new Error('No method');
+  }
+
+  return {
+    method: req.method,
+    headers: normalizeHeaders(req.headers),
+    search: new URL(req.url).search,
+    body: parseBody(req.body, req.headers['content-type']),
+  };
+}
+
+function parseBody(
+  body: string | null | undefined,
+  contentType: string | undefined,
+): object | string {
+  if (body) {
+    if (contentType === 'application/json' && typeof body === 'string') {
+      return JSON.parse(body);
+    }
+    if (contentType === 'text/plain') {
+      return body;
+    }
+  }
+  return '';
+}
+
+function normalizeHeaders(headers: HttpRequestHeaders): HeaderMap {
+  const headerMap = new HeaderMap();
+  for (const [key, value] of Object.entries(headers)) {
+    headerMap.set(key, value ?? '');
+  }
+  return headerMap;
 }

src/__tests__/mockServer.ts

@@ -0,0 +1,18 @@
+{
+    "bindings": [
+      {
+        "authLevel": "function",
+        "type": "httpTrigger",
+        "direction": "in",
+        "name": "req",
+        "methods": ["get", "post"]
+      },
+      {
+        "type": "http",
+        "direction": "out",
+        "name": "$return"
+      }
+    ],
+    "scriptFile": "../../../dist/sample/graphql/index.js"
+  }
+  

src/index.ts

@@ -0,0 +1,24 @@
+import { ApolloServer } from '@apollo/server';
+import { startServerAndCreateHandler } from '../..';
+
+// 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',
+  },
+};
+
+// Set up Apollo Server
+const server = new ApolloServer({
+  typeDefs,
+  resolvers,
+});
+
+export default startServerAndCreateHandler(server);

src/sample/graphql/function.json

@@ -0,0 +1,15 @@
+{
+    "version": "2.0",
+    "logging": {
+      "applicationInsights": {
+        "samplingSettings": {
+          "isEnabled": true,
+          "excludedTypes": "Request"
+        }
+      }
+    },
+    "extensionBundle": {
+      "id": "Microsoft.Azure.Functions.ExtensionBundle",
+      "version": "[3.*, 4.0.0)"
+    }
+  }