🎨 refactor: add ofn register with tests and docs

Signed-off-by: Haili Zhang <[email protected]>

Author: webup

docs/generated/api.json

@@ -1500,6 +1500,36 @@
           ],
           "extendsTokenRanges": []
         },
+        {
+          "kind": "Variable",
+          "canonicalReference": "@openfunction/functions-framework!openfunction:var",
+          "docComment": "/**\n * Register a function that responds to OpenFunction.\n *\n * @param functionName - the name of the function\n *\n * @param handler - the function to invoke when handling OpenFunction\n *\n * @public\n */\n",
+          "excerptTokens": [
+            {
+              "kind": "Content",
+              "text": "openfunction: "
+            },
+            {
+              "kind": "Content",
+              "text": "(functionName: string, handler: "
+            },
+            {
+              "kind": "Reference",
+              "text": "OpenFunction",
+              "canonicalReference": "@openfunction/functions-framework!OpenFunction:interface"
+            },
+            {
+              "kind": "Content",
+              "text": ") => void"
+            }
+          ],
+          "releaseTag": "Public",
+          "name": "openfunction",
+          "variableTypeTokenRange": {
+            "startIndex": 1,
+            "endIndex": 4
+          }
+        },
         {
           "kind": "Interface",
           "canonicalReference": "@openfunction/functions-framework!OpenFunctionBinding:interface",

docs/generated/api.md

@@ -113,6 +113,9 @@ export interface OpenFunction {
     (ctx: OpenFunctionRuntime, data: {}): any;
 }
 
+// @public
+export const openfunction: (functionName: string, handler: OpenFunction) => void;
+
 // @public
 export interface OpenFunctionBinding {
     [key: string]: OpenFunctionComponent;

src/function_registry.ts

@@ -12,7 +12,12 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-import {HttpFunction, CloudEventFunction, HandlerFunction} from './functions';
+import {
+  HttpFunction,
+  CloudEventFunction,
+  HandlerFunction,
+  OpenFunction,
+} from './functions';
 import {SignatureType} from './types';
 
 interface RegisteredFunction<T> {
@@ -94,3 +99,16 @@ export const cloudEvent = <T = unknown>(
 ): void => {
   register(functionName, 'cloudevent', handler);
 };
+
+/**
+ * Register a function that responds to OpenFunction.
+ * @param functionName - the name of the function
+ * @param handler - the function to invoke when handling OpenFunction
+ * @public
+ */
+export const openfunction = (
+  functionName: string,
+  handler: OpenFunction
+): void => {
+  register(functionName, 'openfunction', handler);
+};

src/index.ts

@@ -20,7 +20,7 @@ export * from './functions';
 /**
  * @public
  */
-export {http, cloudEvent} from './function_registry';
+export {http, cloudEvent, openfunction} from './function_registry';
 
 /**
  * @public

test/function_registry.ts

@@ -31,6 +31,14 @@ describe('function_registry', () => {
     assert.deepStrictEqual((userFunction as () => string)(), 'CE_PASS');
   });
 
+  it('can register OpenFunction functions', () => {
+    FunctionRegistry.openfunction('OpenFunction', () => 'OFN_PASS');
+    const {userFunction, signatureType} =
+      FunctionRegistry.getRegisteredFunction('OpenFunction')!;
+    assert.deepStrictEqual('openfunction', signatureType);
+    assert.deepStrictEqual((userFunction as () => string)(), 'OFN_PASS');
+  });
+
   it('throws an error if you try to register a function with an invalid URL', () => {
     // Valid function names
     const validFunctions = ['httpFunction', 'ceFunction', 'test-func'];

test/function_wrappers.ts

@@ -1,7 +1,10 @@
 import * as assert from 'assert';
 import * as sinon from 'sinon';
 import {Request, Response} from 'express';
-import {Context, CloudEvent} from '../src/functions';
+
+import {OpenFunctionContext} from '../src/openfunction/function_context';
+
+import {Context, CloudEvent, OpenFunctionRuntime} from '../src/functions';
 import {wrapUserFunction} from '../src/function_wrappers';
 
 describe('wrapUserFunction', () => {
@@ -17,6 +20,12 @@ describe('wrapUserFunction', () => {
     },
   };
 
+  const OPENFUNCTION_CONTEXT: OpenFunctionContext = {
+    name: 'test-context',
+    version: '1.0.0',
+    runtime: 'Knative',
+  };
+
   const createRequest = (body: object) =>
     ({
       body,
@@ -105,4 +114,21 @@ describe('wrapUserFunction', () => {
     );
     func(request, response, () => {});
   });
+
+  it('correctly wraps an OpenFunctionn function', done => {
+    const request = createRequest(CLOUD_EVENT);
+    const response = createResponse();
+    const func = wrapUserFunction(
+      async (context: OpenFunctionRuntime, data: {}) => {
+        assert.deepStrictEqual(data, CLOUD_EVENT);
+        assert.deepStrictEqual(context.req?.body, CLOUD_EVENT);
+        // await to make sure wrapper handles async code
+        await new Promise(resolve => setTimeout(resolve, 20));
+        done();
+      },
+      'openfunction',
+      OPENFUNCTION_CONTEXT
+    );
+    func(request, Object.assign(response, {end: () => {}}), () => {});
+  });
 });