Apply formatting fixes

Author: garethgeorge

docs/generated/api.json

@@ -59,7 +59,7 @@ export interface EventFunctionWithCallback {
 }
 
 // @public
-export type HandlerFunction<T = unknown> = HttpFunction | EventFunction | EventFunctionWithCallback | CloudEventFunction<T> | CloudEventFunctionWithCallback<T>;
+export type HandlerFunction<T = unknown, U = unknown> = HttpFunction | EventFunction | EventFunctionWithCallback | CloudEventFunction<T> | CloudEventFunctionWithCallback<T> | TypedHandlerFunction<T, U>;
 
 // @public
 export const http: (functionName: string, handler: HttpFunction) => void;
@@ -70,6 +70,35 @@ export interface HttpFunction {
     (req: Request_2, res: Response_2): any;
 }
 
+// @public
+export interface InvocationFormat<T, U> {
+    // (undocumented)
+    deserializeRequest(request: InvocationRequest): T | Promise<T>;
+    // (undocumented)
+    serializeResponse(responseWriter: InvocationResponse, response: U): void | Promise<void>;
+}
+
+// @public
+export interface InvocationRequest {
+    body(): string | Buffer;
+    header(header: string): string | undefined;
+}
+
+// @public
+export interface InvocationResponse {
+    end(data: string | Buffer): void;
+    setHeader(key: string, value: string): void;
+    write(data: string | Buffer): void;
+}
+
+// @public
+export class JsonInvocationFormat<T, U> implements InvocationFormat<T, U> {
+    // (undocumented)
+    deserializeRequest(request: InvocationRequest): T;
+    // (undocumented)
+    serializeResponse(responseWriter: InvocationResponse, response: U): void;
+}
+
 // @public
 export type LegacyCloudFunctionsContext = CloudFunctionsContext | Data;
 
@@ -91,6 +120,17 @@ export { Request_2 as Request }
 
 export { Response_2 as Response }
 
+// @public
+export const typed: <T, U>(functionName: string, handler: TypedHandlerFunction<T, U> | ((req: T) => U | Promise<U>)) => void;
+
+// @public
+export interface TypedHandlerFunction<T = unknown, U = unknown> {
+    // (undocumented)
+    format: InvocationFormat<T, U>;
+    // (undocumented)
+    handler: (req: T) => U | Promise<U>;
+}
+
 // (No @packageDocumentation comment for this package)
 
 ```

docs/generated/api.md

@@ -17,7 +17,6 @@ import {
   CloudEventFunction,
   HandlerFunction,
   TypedHandlerFunction,
-  InvocationFormat,
   JsonInvocationFormat,
 } from './functions';
 import {SignatureType} from './types';
@@ -102,10 +101,9 @@ export const cloudEvent = <T = unknown>(
   register(functionName, 'cloudevent', handler);
 };
 
-
 /**
  * Register a function that handles strongly typed invocations.
- * @param functionName - the name of the function 
+ * @param functionName - the name of the function
  * @param handler - the function to trigger.
  */
 export const typed = <T, U>(
@@ -116,7 +114,7 @@ export const typed = <T, U>(
     handler = {
       handler,
       format: new JsonInvocationFormat<T, U>(),
-    }
+    };
   }
   register(functionName, 'typed', handler);
-};
+};

src/function_registry.ts

@@ -28,7 +28,7 @@ import {
   HandlerFunction,
   TypedHandlerFunction,
   InvocationRequest,
-  InvocationResponse
+  InvocationResponse,
 } from './functions';
 import {CloudEvent} from './functions';
 import {SignatureType} from './types';
@@ -110,7 +110,7 @@ const wrapHttpFunction = (execute: HttpFunction): RequestHandler => {
         console.error(`Exception from a finished function: ${err}`);
       } else {
         res.locals.functionExecutionFinished = true;
-        sendCrashResponse({ err, res });
+        sendCrashResponse({err, res});
       }
     };
 
@@ -211,19 +211,19 @@ const wrapTypedFunction = (
 ): RequestHandler => {
   class InvocationRequestImpl implements InvocationRequest {
     constructor(private req: Request) {}
-    
+
     body(): string | Buffer {
       return this.req.body;
     }
-    
+
     header(header: string): string | undefined {
       return this.req.header(header);
     }
   }
 
   class InvocationResponseImpl implements InvocationResponse {
-    constructor(private res: Response) { }
-    
+    constructor(private res: Response) {}
+
     setHeader(key: string, value: string): void {
       this.res.set(key, value);
     }
@@ -235,29 +235,38 @@ const wrapTypedFunction = (
     }
   }
 
-  const typedHandlerWrapper: HttpFunction = async (req: Request, res: Response) => {
-    let reqTyped: any;
+  const typedHandlerWrapper: HttpFunction = async (
+    req: Request,
+    res: Response
+  ) => {
+    let reqTyped: unknown;
     try {
-      reqTyped = typedFunction.format.deserializeRequest(new InvocationRequestImpl(req));
+      reqTyped = typedFunction.format.deserializeRequest(
+        new InvocationRequestImpl(req)
+      );
     } catch (err) {
       console.log(err);
       sendCrashResponse({
-        err, res,
-        statusOverride: 400 // 400 Bad Request
+        err,
+        res,
+        statusOverride: 400, // 400 Bad Request
       });
       return;
     }
 
-    let resTyped: any = typedFunction.handler(reqTyped);
+    let resTyped: unknown = typedFunction.handler(reqTyped);
     if (resTyped instanceof Promise) {
       resTyped = await resTyped;
     }
 
-    typedFunction.format.serializeResponse(new InvocationResponseImpl(res), resTyped);
-  }
+    typedFunction.format.serializeResponse(
+      new InvocationResponseImpl(res),
+      resTyped
+    );
+  };
 
   return wrapHttpFunction(typedHandlerWrapper);
-}
+};
 
 /**
  * Wraps a user function with the provided signature type in an express

src/function_wrappers.ts

@@ -149,7 +149,7 @@ export interface CloudFunctionsContext {
 export type Context = CloudFunctionsContext | CloudEvent<unknown>;
 
 /**
- * Invocation request interface describes the properties of an invocation.
+ * InvocationRequest represents the properties of an invocation over HTTP.
  */
 export interface InvocationRequest {
   /** Returns the request body as either a string or a Buffer if the body is binary. */
@@ -197,14 +197,17 @@ export interface InvocationFormat<T, U> {
  */
 export class JsonInvocationFormat<T, U> implements InvocationFormat<T, U> {
   deserializeRequest(request: InvocationRequest): T {
-    let body = request.body();
+    const body = request.body();
     if (typeof body !== 'string') {
-      throw new Error("Unsupported Content-Type, expected application/json");
+      throw new Error('Unsupported Content-Type, expected application/json');
     }
     try {
       return JSON.parse(body);
     } catch (e) {
-      throw new Error("Failed to parse malformatted JSON in request: " + (e as SyntaxError).message)
+      throw new Error(
+        'Failed to parse malformatted JSON in request: ' +
+          (e as SyntaxError).message
+      );
     }
   }
 

src/functions.ts

@@ -28,7 +28,7 @@ export function sendCrashResponse({
   callback,
   silent = false,
   statusHeader = 'crash',
-  statusOverride = 500
+  statusOverride = 500,
 }: {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   err: Error | any;

src/logger.ts

@@ -86,14 +86,18 @@ export function getServer(
 
   // Apply middleware
   if (functionSignatureType === 'typed') {
-    app.use(bodyParser.text({
-      limit: requestLimit,
-      type: '*/json',
-    }))
-    app.use(bodyParser.text({
-      limit: requestLimit,
-      type: 'text/*',
-    }))
+    app.use(
+      bodyParser.text({
+        limit: requestLimit,
+        type: '*/json',
+      })
+    );
+    app.use(
+      bodyParser.text({
+        limit: requestLimit,
+        type: 'text/*',
+      })
+    );
   } else {
     app.use(bodyParser.json(cloudEventsBodySavingOptions));
     app.use(bodyParser.json(defaultBodySavingOptions));

src/server.ts

@@ -1,16 +1,12 @@
 import * as assert from 'assert';
-import * as sinon from 'sinon';
 import {Request, Response} from 'express';
 import {
   Context,
   CloudEvent,
   JsonInvocationFormat,
   TypedHandlerFunction,
-  InvocationRequest,
-  InvocationResponse,
 } from '../src/functions';
 import {wrapUserFunction} from '../src/function_wrappers';
-import {send} from 'process';
 import EventEmitter = require('events');
 
 describe('wrapUserFunction', () => {
@@ -40,7 +36,7 @@ describe('wrapUserFunction', () => {
 
   class ResponseMock extends EventEmitter {
     public headers: {[key: string]: string} = {};
-    public statusCode: number = 200;
+    public statusCode = 200;
     public body: string | undefined;
     public locals = {
       functionExecutionFinished: false,
@@ -151,8 +147,10 @@ describe('wrapUserFunction', () => {
   });
 
   describe('wraps a Typed JSON function', () => {
-
-    const synchronousJsonFunction: TypedHandlerFunction<EchoMessage, EchoMessage> = {
+    const synchronousJsonFunction: TypedHandlerFunction<
+      EchoMessage,
+      EchoMessage
+    > = {
       format: new JsonInvocationFormat<EchoMessage, EchoMessage>(),
       handler: (req: EchoMessage): EchoMessage => {
         return {
@@ -235,7 +233,7 @@ describe('wrapUserFunction', () => {
 
       const typedFn: TypedHandlerFunction<EchoMessage, EchoMessage> = {
         format: new JsonInvocationFormat<EchoMessage, EchoMessage>(),
-        handler: (req: EchoMessage): Promise<EchoMessage> => {
+        handler: (): Promise<EchoMessage> => {
           return new Promise((_, reject) => {
             setImmediate(() => reject(new Error('an error')));
           });

test/function_wrappers.ts

@@ -32,23 +32,31 @@ describe('Typed Function', () => {
   }
 
   before(() => {
-    functions.typed<NameConcatRequest, NameConcatResponse>('nameConcatFunc', req => {
-      callCount += 1;
-      return {
-        combined: req.first + req.last
-      };
-    });
+    functions.typed<NameConcatRequest, NameConcatResponse>(
+      'nameConcatFunc',
+      req => {
+        callCount += 1;
+        return {
+          combined: req.first + req.last,
+        };
+      }
+    );
 
     // Async function is expected to test asynchronous codepaths for echo handling.
-    functions.typed<NameConcatRequest, NameConcatResponse>('nameConcatFuncAsync', req => {
-      callCount += 1;
-      return new Promise(accept => setImmediate(() => accept({combined: req.first + req.last})));
-    });
+    functions.typed<NameConcatRequest, NameConcatResponse>(
+      'nameConcatFuncAsync',
+      req => {
+        callCount += 1;
+        return new Promise(accept =>
+          setImmediate(() => accept({combined: req.first + req.last}))
+        );
+      }
+    );
 
     // Error prone function tests simply throwing an error a synchronous function
     functions.typed<NameConcatRequest, NameConcatResponse>(
       'errorProneTypedFunc',
-      req => {
+      () => {
         callCount += 1;
         throw new Error('synchronous error');
       }
@@ -57,7 +65,7 @@ describe('Typed Function', () => {
     // Error prone async function throws an asynchronous error
     functions.typed<NameConcatRequest, NameConcatResponse>(
       'errorProneAsyncTypedFunc',
-      req => {
+      () => {
         callCount += 1;
         return new Promise((_, reject) =>
           setImmediate(() => reject(new Error('async error')))
@@ -79,9 +87,9 @@ describe('Typed Function', () => {
   const testData = [
     {
       func: 'nameConcatFunc',
-      name: 'basic POST request to \'/\'/',
-      requestBody: { first: 'Jane', last: 'Doe' },
-      expectedBody: { combined: 'JaneDoe' },
+      name: "basic POST request to '/'/",
+      requestBody: {first: 'Jane', last: 'Doe'},
+      expectedBody: {combined: 'JaneDoe'},
       expectedStatus: 200,
       expectedCallCount: 1,
     },
@@ -98,16 +106,16 @@ describe('Typed Function', () => {
       func: 'nameConcatFunc',
       name: 'POST /foo PATH',
       path: '/foo',
-      requestBody: { first: 'Jane', last: 'Doe' },
-      expectedBody: { combined: 'JaneDoe' },
+      requestBody: {first: 'Jane', last: 'Doe'},
+      expectedBody: {combined: 'JaneDoe'},
       expectedStatus: 200,
       expectedCallCount: 1,
     },
     {
       func: 'nameConcatFuncAsync',
-      name: 'async basic POST request to \'/\'',
-      requestBody: { first: 'Jane', last: 'Doe' },
-      expectedBody: { combined: 'JaneDoe' },
+      name: "async basic POST request to '/'",
+      requestBody: {first: 'Jane', last: 'Doe'},
+      expectedBody: {combined: 'JaneDoe'},
       expectedStatus: 200,
       expectedCallCount: 1,
     },
@@ -125,10 +133,10 @@ describe('Typed Function', () => {
     },
   ];
 
-  it('does not support \'GET\' HTTP verb', async () => {
+  it("does not support 'GET' HTTP verb", async () => {
     const st = supertest(getTestServer('nameConcatFunc'));
     await st.get('/').expect(404);
-  })
+  });
 
   testData.forEach(test => {
     it(test.name, async () => {