@midwayjs/faas 3.3.6-beta.1 → 3.3.6-beta.2

package/dist/framework.d.ts

@@ -1,6 +1,8 @@
-import { FaaSContext, IFaaSConfigurationOptions, IMidwayFaaSApplication } from './interface';
-import { BaseFramework, FunctionMiddleware, IMidwayBootstrapOptions, MidwayEnvironmentService, MidwayFrameworkType, MidwayMiddlewareService, RouterInfo } from '@midwayjs/core';
+/// <reference types="node" />
+import { FaaSContext, IFaaSConfigurationOptions, IMidwayFaaSApplication, InvokeOptions } from './interface';
+import { BaseFramework, ContextMiddlewareManager, FunctionMiddleware, IMidwayBootstrapOptions, MidwayEnvironmentService, MidwayFrameworkType, MidwayMiddlewareService, RouterInfo } from '@midwayjs/core';
 import { LoggerOptions } from '@midwayjs/logger';
+import * as http from 'http';
 export declare class MidwayFaaSFramework extends BaseFramework<IMidwayFaaSApplication, FaaSContext, IFaaSConfigurationOptions> {
     protected defaultHandlerMethod: string;
     protected funMappingStore: Map<string, RouterInfo>;
@@ -10,6 +12,10 @@ export declare class MidwayFaaSFramework extends BaseFramework<IMidwayFaaSApplic
     private isReplaceLogger;
     private developmentRun;
     private serverlessRoutes;
+    private server;
+    private respond;
+    private applicationAdapter;
+    protected eventMiddlewareManager: ContextMiddlewareManager<FaaSContext, unknown, unknown>;
     environmentService: MidwayEnvironmentService;
     middlewareService: MidwayMiddlewareService<FaaSContext, any>;
     configure(options: IFaaSConfigurationOptions): any;
@@ -17,17 +23,19 @@ export declare class MidwayFaaSFramework extends BaseFramework<IMidwayFaaSApplic
     applicationInitialize(options: IMidwayBootstrapOptions): Promise<void>;
     run(): Promise<void>;
     getFrameworkType(): MidwayFrameworkType;
-    handleInvokeWrapper(handlerMapping: string): (...args: any[]) => Promise<any>;
+    handleInvokeWrapper(handlerMapping: string, options?: InvokeOptions): (...args: any[]) => Promise<any>;
     /**
      * @deprecated
      * @param middlewareId
      */
     generateMiddleware(middlewareId: string): Promise<FunctionMiddleware<FaaSContext, any>>;
-    getContext(context: any): any;
+    getContext(context?: any): any;
     private invokeHandler;
     protected getFunctionHandler(ctx: any, args: any, target: any, method: any): string;
     createLogger(name: string, option?: LoggerOptions): import("@midwayjs/core").ILogger;
     getFrameworkName(): string;
+    getServer(): http.Server;
+    protected createHttpContext(req: any, res: any): Promise<unknown>;
 }
 export declare const createModuleServerlessFramework: (globalOption: Omit<IMidwayBootstrapOptions, 'applicationContext'> & IFaaSConfigurationOptions) => Promise<MidwayFaaSFramework>;
 //# sourceMappingURL=framework.d.ts.map

package/dist/framework.js

@@ -10,10 +10,13 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createModuleServerlessFramework = exports.MidwayFaaSFramework = void 0;
+const interface_1 = require("./interface");
 const core_1 = require("@midwayjs/core");
 const decorator_1 = require("@midwayjs/decorator");
 const simple_lock_1 = require("@midwayjs/simple-lock");
 const logger_1 = require("@midwayjs/logger");
+const serverless_http_parser_1 = require("@midwayjs/serverless-http-parser");
+const http = require("http");
 const LOCK_KEY = '_faas_starter_start_key';
 let MidwayFaaSFramework = class MidwayFaaSFramework extends core_1.BaseFramework {
     constructor() {
@@ -24,6 +27,7 @@ let MidwayFaaSFramework = class MidwayFaaSFramework extends core_1.BaseFramework
         this.isReplaceLogger = process.env['MIDWAY_SERVERLESS_REPLACE_LOGGER'] === 'true';
         this.developmentRun = false;
         this.serverlessRoutes = [];
+        this.eventMiddlewareManager = this.createMiddlewareManager();
     }
     configure(options) {
         var _a;
@@ -40,13 +44,14 @@ let MidwayFaaSFramework = class MidwayFaaSFramework extends core_1.BaseFramework
         return !this.developmentRun;
     }
     async applicationInitialize(options) {
-        var _a;
+        var _a, _b;
         if (!this.logger) {
             this.logger = options.logger || logger_1.loggers.getLogger('appLogger');
         }
+        this.applicationAdapter = this.configurationOptions.applicationAdapter;
         this.app =
-            ((_a = this.configurationOptions.applicationAdapter) === null || _a === void 0 ? void 0 : _a.getApplication()) ||
-                {};
+            ((_a = this.applicationAdapter) === null || _a === void 0 ? void 0 : _a.getApplication()) ||
+                new serverless_http_parser_1.Application();
         this.defineApplicationProperties({
             /**
              * return init context value such as aliyun fc
@@ -69,14 +74,18 @@ let MidwayFaaSFramework = class MidwayFaaSFramework extends core_1.BaseFramework
                 var _a;
                 return (_a = this.configurationOptions.applicationAdapter) === null || _a === void 0 ? void 0 : _a.getFunctionServiceName();
             },
+            useEventMiddleware: () => { },
         });
         // hack use method
         this.app.originUse = this.app.use;
         this.app.use = this.app.useMiddleware;
+        if ((_b = this.configurationOptions.applicationAdapter) === null || _b === void 0 ? void 0 : _b.runAppHook) {
+            this.configurationOptions.applicationAdapter.runAppHook(this.app);
+        }
     }
     async run() {
         return this.lock.sureOnce(async () => {
-            var _a;
+            var _a, _b;
             // set app keys
             this.app['keys'] = (_a = this.configService.getConfiguration('keys')) !== null && _a !== void 0 ? _a : '';
             // store all http function entry
@@ -93,22 +102,42 @@ let MidwayFaaSFramework = class MidwayFaaSFramework extends core_1.BaseFramework
                     });
                 }
             }
+            this.respond = this.app.callback();
+            if (this.environmentService.isDevelopmentEnvironment()) {
+                const faasConfig = (_b = this.configService.getConfiguration('faas')) !== null && _b !== void 0 ? _b : {};
+                this.server = await new Promise(resolve => {
+                    const server = http.createServer((req, res) => {
+                        const url = new URL(req.url, `http://${req.headers.host}`);
+                        // create event and invoke
+                        this.handleInvokeWrapper(url.pathname)(req, res, {});
+                    });
+                    if (faasConfig['port']) {
+                        server.listen(faasConfig['port']);
+                    }
+                    resolve(server);
+                });
+            }
         }, LOCK_KEY);
     }
     getFrameworkType() {
         return core_1.MidwayFrameworkType.FAAS;
     }
-    handleInvokeWrapper(handlerMapping) {
+    handleInvokeWrapper(handlerMapping, options) {
         let funOptions = this.funMappingStore.get(handlerMapping);
         return async (...args) => {
+            var _a, _b;
             if (args.length === 0) {
                 throw new Error('first parameter must be function context');
             }
-            const context = this.getContext(args.shift());
-            const isHttpFunction = !!(context.headers && context.get);
+            const event = args[0];
+            const isLegacyMode = !options;
+            const isHttpFunction = (options === null || options === void 0 ? void 0 : options.triggerType) === interface_1.TRIGGER_TYPE_ENUM.HTTP ||
+                event.constructor.name === 'IncomingMessage' ||
+                event.constructor.name === 'EventEmitter' ||
+                !!(event.headers && event.get);
             if (!funOptions && isHttpFunction) {
                 for (const item of this.serverlessRoutes) {
-                    if (item.matchPattern.test(context.path)) {
+                    if (item.matchPattern.test(event.path)) {
                         funOptions = item.funcInfo;
                         break;
                     }
@@ -117,6 +146,19 @@ let MidwayFaaSFramework = class MidwayFaaSFramework extends core_1.BaseFramework
             if (!funOptions) {
                 throw new Error(`function handler = ${handlerMapping} not found`);
             }
+            let context;
+            if (isLegacyMode) {
+                context = this.getContext(args.shift());
+            }
+            else if (isHttpFunction) {
+                const newReq = ((_a = this.applicationAdapter) === null || _a === void 0 ? void 0 : _a.runRequestHook(...args)) ||
+                    new serverless_http_parser_1.HTTPRequest(args[0], args[1]);
+                const newRes = new serverless_http_parser_1.HTTPResponse();
+                context = this.getContext(await this.createHttpContext(newReq, newRes));
+            }
+            else {
+                context = this.getContext(await ((_b = this.applicationAdapter) === null || _b === void 0 ? void 0 : _b.runEventHook(...args)));
+            }
             const globalMiddlewareFn = await this.applyMiddleware();
             const middlewareManager = new core_1.ContextMiddlewareManager();
             middlewareManager.insertLast(globalMiddlewareFn);
@@ -139,7 +181,58 @@ let MidwayFaaSFramework = class MidwayFaaSFramework extends core_1.BaseFramework
                 return await fn(ctx, next);
             });
             const composeMiddleware = await this.middlewareService.compose(middlewareManager, this.app);
-            return await composeMiddleware(context);
+            const result = await composeMiddleware(context);
+            if (isLegacyMode) {
+                return result;
+            }
+            else if (isHttpFunction) {
+                if (!context.response._explicitStatus) {
+                    if (context.body === null || context.body === 'undefined') {
+                        context.body = '';
+                        context.type = 'text';
+                        context.status = 204;
+                    }
+                }
+                let encoded = false;
+                let data = context.body;
+                if (typeof data === 'string') {
+                    if (!context.type) {
+                        context.type = 'text/plain';
+                    }
+                    context.body = data;
+                }
+                else if (Buffer.isBuffer(data)) {
+                    encoded = true;
+                    if (!context.type) {
+                        context.type = 'application/octet-stream';
+                    }
+                    // data is reserved as buffer
+                    context.body = data.toString('base64');
+                }
+                else if (typeof data === 'object') {
+                    if (!context.type) {
+                        context.type = 'application/json';
+                    }
+                    // set data to string
+                    context.body = data = JSON.stringify(data);
+                }
+                else {
+                    if (!context.type) {
+                        context.type = 'text/plain';
+                    }
+                    // set data to string
+                    context.body = data = data + '';
+                }
+                return {
+                    isBase64Encoded: encoded,
+                    statusCode: context.status,
+                    headers: context.res.headers,
+                    body: context.body,
+                };
+            }
+            else {
+                return result;
+            }
         };
     }
     /**
@@ -150,7 +243,7 @@ let MidwayFaaSFramework = class MidwayFaaSFramework extends core_1.BaseFramework
         const mwIns = await this.getApplicationContext().getAsync(middlewareId);
         return mwIns.resolve();
     }
-    getContext(context) {
+    getContext(context = {}) {
         if (!context.env) {
             context.env = this.environmentService.getCurrentEnvironment();
         }
@@ -218,6 +311,14 @@ let MidwayFaaSFramework = class MidwayFaaSFramework extends core_1.BaseFramework
     getFrameworkName() {
         return 'midway:faas';
     }
+    getServer() {
+        return this.server;
+    }
+    async createHttpContext(req, res) {
+        return new Promise(resolve => {
+            this.respond(req, res, resolve);
+        });
+    }
 };
 __decorate([
     (0, decorator_1.Inject)(),

package/dist/interface.d.ts

@@ -1,12 +1,16 @@
 import { MidwayRequestContainer, IMidwayApplication, IConfigurationOptions, IMidwayContext, NextFunction as BaseNextFunction } from '@midwayjs/core';
 import { FaaSHTTPContext } from '@midwayjs/faas-typings';
 import { ILogger } from '@midwayjs/logger';
+import { Application as ServerlessHttpApplication } from '@midwayjs/serverless-http-parser';
 export interface FaaSContext extends IMidwayContext<FaaSHTTPContext> {
     logger: ILogger;
     env: string;
     requestContext: MidwayRequestContainer;
     originContext: any;
 }
+/**
+ * @deprecated
+ */
 export declare type FaaSMiddleware = ((context: FaaSContext, next: () => Promise<any>) => any) | string;
 export declare type IMidwayFaaSApplication = IMidwayApplication<FaaSContext, {
     getInitializeContext(): any;
@@ -24,7 +28,8 @@ export declare type IMidwayFaaSApplication = IMidwayApplication<FaaSContext, {
      * Get function service name in serverless environment
      */
     getFunctionServiceName(): string;
-}>;
+    useEventMiddleware(): void;
+}> & ServerlessHttpApplication;
 export interface Application extends IMidwayFaaSApplication {
 }
 export interface Context extends FaaSContext {
@@ -37,9 +42,22 @@ export interface IFaaSConfigurationOptions extends IConfigurationOptions {
         getApplication(): IMidwayFaaSApplication;
         getFunctionName(): string;
         getFunctionServiceName(): string;
+        runAppHook?(app: IMidwayFaaSApplication): void;
+        runEventHook?(...args: any[]): any | void;
+        runRequestHook?(...args: any[]): any | void;
     };
 }
+/**
+ * @deprecated
+ */
 export interface IWebMiddleware {
     resolve(): FaaSMiddleware;
 }
+export declare enum TRIGGER_TYPE_ENUM {
+    HTTP = "http",
+    Event = "event"
+}
+export interface InvokeOptions {
+    triggerType: TRIGGER_TYPE_ENUM;
+}
 //# sourceMappingURL=interface.d.ts.map

package/dist/interface.js

@@ -1,3 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.TRIGGER_TYPE_ENUM = void 0;
+var TRIGGER_TYPE_ENUM;
+(function (TRIGGER_TYPE_ENUM) {
+    TRIGGER_TYPE_ENUM["HTTP"] = "http";
+    TRIGGER_TYPE_ENUM["Event"] = "event";
+})(TRIGGER_TYPE_ENUM = exports.TRIGGER_TYPE_ENUM || (exports.TRIGGER_TYPE_ENUM = {}));
 //# sourceMappingURL=interface.js.map

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "@midwayjs/faas",
-  "version": "3.3.6-beta.1",
+  "version": "3.3.6-beta.2",
   "main": "dist/index",
   "typings": "index.d.ts",
   "dependencies": {
     "@midwayjs/core": "^3.3.5",
     "@midwayjs/faas-typings": "^3.3.5",
     "@midwayjs/logger": "^2.15.0",
-    "@midwayjs/simple-lock": "^1.1.4"
+    "@midwayjs/simple-lock": "^1.1.4",
+    "@midwayjs/serverless-http-parser": "^3.3.5"
   },
   "devDependencies": {
     "@midwayjs/decorator": "^3.3.4",