feat: enable plugin mechanism for async func

src/main.ts

@@ -26,6 +26,7 @@ import {
   OpenFunctionContext,
   ContextUtils,
 } from './openfunction/function_context';
+import {getPlugins} from './plugin';
 
 /**
  * Main entrypoint for the functions framework that loads the user's function
@@ -50,13 +51,16 @@ export const main = async () => {
       process.exit(1);
     }
     const {userFunction, signatureType} = loadedFunction;
-
+    if (options.plugin) {
+      options.plugin = await getPlugins(options.sourceLocation, options.plugin);
+    }
     if (ContextUtils.IsAsyncRuntime(options.context as OpenFunctionContext)) {
       options.context!.port = options.port;
 
       const server = getAysncServer(
         userFunction! as OpenFunction,
-        options.context!
+        options.context!,
+        options.plugin
       );
       await server.start();
     } else {

src/openfunction/async_server.ts

@@ -5,6 +5,7 @@ import {OpenFunction} from '../functions';
 
 import {OpenFunctionContext, ContextUtils} from './function_context';
 import {OpenFunctionRuntime} from './function_runtime';
+import {PluginContext, PluginContextRuntime} from '../plugin_context';
 
 export type AsyncFunctionServer = DaprServer;
 
@@ -17,13 +18,38 @@ export type AsyncFunctionServer = DaprServer;
  */
 export default function (
   userFunction: OpenFunction,
-  context: OpenFunctionContext
+  context: OpenFunctionContext,
+  pluginContext?: PluginContext
 ): AsyncFunctionServer {
   const app = new DaprServer('localhost', context.port);
   const ctx = OpenFunctionRuntime.ProxyContext(context);
 
   const wrapper = async (data: object) => {
+    const runtime: PluginContextRuntime | undefined = pluginContext
+      ? {
+          pluginContext: pluginContext,
+          data: data,
+          context: ctx,
+        }
+      : undefined;
+
+    if (runtime) {
+      runtime.context = ctx;
+      runtime.data = data;
+      for (let i = 0; i < runtime.pluginContext.prePluginFuncs!.length; i++) {
+        await runtime.pluginContext.prePluginFuncs![i](pluginContext);
+        data = runtime.data;
+      }
+    }
     await userFunction(ctx, data);
+    if (runtime) {
+      runtime.context = ctx;
+      runtime.data = data;
+      for (let i = 0; i < runtime.pluginContext.postPluginFuncs!.length; i++) {
+        await runtime.pluginContext.postPluginFuncs![i](pluginContext);
+        data = runtime.data;
+      }
+    }
   };
 
   // Initialize the server with the user's function.

src/options.ts

@@ -19,6 +19,7 @@ import * as minimist from 'minimist';
 
 import {SignatureType, isValidSignatureType} from './types';
 import {OpenFunctionContext} from './openfunction/function_context';
+import {PluginContext} from './plugin_context';
 
 const debug = Debug('common:options');
 
@@ -53,6 +54,10 @@ export interface FrameworkOptions {
    * The context to use for the function when serving.
    */
   context?: OpenFunctionContext;
+  /**
+   * The context to use for the function when serving.
+   */
+  plugin?: PluginContext;
   /**
    * Whether or not the --help CLI flag was provided.
    */
@@ -134,7 +139,23 @@ const FunctionContextOption = new ConfigurableOption(
     }
   }
 );
+const PluginContextOption = new ConfigurableOption(
+  'plugin',
+  'PLUGIN_CONTEXT',
+  undefined,
+  x => {
+    // Try to parse plugin string
+    debug('ℹ️ Plugin loaded: %s', x);
 
+    try {
+      const context = JSON.parse(x);
+      return context as PluginContext;
+    } catch (e) {
+      debug('Failed to parse plugin: %s', e);
+      return undefined;
+    }
+  }
+);
 export const helpText = `Example usage:
   functions-framework --target=helloWorld --port=8080
 Documentation:
@@ -158,6 +179,7 @@ export const parseOptions = (
       SignatureOption.cliOption,
       SourceLocationOption.cliOption,
       FunctionContextOption.cliOption,
+      PluginContextOption.cliOption,
     ],
   });
   return {
@@ -166,6 +188,7 @@ export const parseOptions = (
     sourceLocation: SourceLocationOption.parse(argv, envVars),
     signatureType: SignatureOption.parse(argv, envVars),
     context: FunctionContextOption.parse(argv, envVars),
+    plugin: PluginContextOption.parse(argv, envVars),
     printHelp: cliArgs[2] === '-h' || cliArgs[2] === '--help',
   };
 };

src/plugin.ts

@@ -0,0 +1,64 @@
+import * as path from 'path';
+import * as fs from 'fs';
+import {PluginContext} from './plugin_context';
+
+export async function loadPlugins(
+  codeLocation: string
+): Promise<Map<string, Function>> {
+  const funcMap: Map<string, Function> = new Map();
+  const param = path.resolve(`${codeLocation}/plugins`);
+  const plugin_files: Array<string> = [];
+  const files = fs.readdirSync(param);
+  files.forEach(f => {
+    if (f.endsWith('.js')) {
+      plugin_files.push(path.join(param, f));
+    }
+  });
+  console.log(plugin_files);
+  plugin_files.forEach(f => {
+    const pluginModule = require(f);
+    Object.keys(pluginModule).forEach(key => {
+      funcMap.set(key, pluginModule[key]);
+    });
+  });
+  return funcMap;
+}
+
+export async function getPlugins(
+  codeLocation: string,
+  pluginContext: PluginContext
+): Promise<PluginContext> {
+  const funcMapResult: Map<string, Function> = new Map();
+  const funcMap = await loadPlugins(codeLocation);
+  pluginContext.pluginMap = funcMap;
+  pluginContext.prePluginFuncs = [];
+  pluginContext.postPluginFuncs = [];
+  pluginContext.prePlugins.forEach(p => {
+    const func = funcMap.get(p);
+    if (func) {
+      funcMapResult.set(p, func);
+      pluginContext.prePluginFuncs!.push(func);
+    } else {
+      console.error('----------------error----------------');
+      console.error(
+        `pre-plugin-function[${p}] is not found  \nDid you specify the correct target plugin-function to execute?`
+      );
+      console.error('-------------------------------------');
+    }
+  });
+  pluginContext.postPlugins.forEach(p => {
+    const func = funcMap.get(p);
+    if (func) {
+      funcMapResult.set(p, func);
+      pluginContext.postPluginFuncs!.push(func);
+    } else {
+      console.error('----------------error----------------');
+      console.error(
+        `post-plugin-function[${p}] is not found  \nDid you specify the correct target plugin-function to execute?`
+      );
+      console.error('-------------------------------------');
+    }
+  });
+
+  return pluginContext;
+}

src/plugin_context.ts

@@ -0,0 +1,46 @@
+import {OpenFunctionRuntime} from './functions';
+/**
+ * The OpenFunction's plugin  context.
+ * @public
+ */
+export interface PluginContext {
+  /**
+   * The name of the pre plugins.
+   */
+  prePlugins: Array<string>;
+  /**
+   * The name of the pre plugins.
+   */
+  postPlugins: Array<string>;
+  /**
+   * The func of the pre plugins.
+   */
+  prePluginFuncs?: Array<Function>;
+  /**
+   * The func of the pre plugins.
+   */
+  postPluginFuncs?: Array<Function>;
+  /**
+   * The refect between name func.
+   */
+  pluginMap?: Map<string, Function>;
+}
+
+/**
+ * The OpenFunction's plugin  context runtime.
+ * @public
+ */
+export interface PluginContextRuntime {
+  /**
+   * The refect between name func.
+   */
+  pluginContext: PluginContext;
+  /**
+   * OpenFunctionRuntime.
+   */
+  context?: OpenFunctionRuntime;
+  /**
+   * data.
+   */
+  data?: object;
+}