@h4ad/serverless-adapter 2.2.0 → 2.3.0

package/README.md

@@ -63,6 +63,10 @@ import { DefaultHandler } from '@h4ad/serverless-adapter/lib/handlers/default';
 import { PromiseResolver } from '@h4ad/serverless-adapter/lib/resolvers/promise';
 import app from './app';
 
+// if you create your app asynchronously
+// check the docs about the LazyFramework.
+// ServerlessAdapter.new(null)
+// .setFramework(new LazyFramework(new ExpressFramework(), async () => createAsyncApp()))
 export const handler = ServerlessAdapter.new(app)
   .setFramework(new ExpressFramework())
   .setHandler(new DefaultHandler())
@@ -119,6 +123,9 @@ Currently, we support these frameworks:
 - [Fastify](https://www.fastify.io/) by using ([FastifyFramework](src/frameworks/fastify/fastify.framework.ts))
 - [Hapi](https://hapi.dev/) by using ([HapiFramework](src/frameworks/hapi/hapi.framework.ts))
 - [Koa](https://koajs.com/) by using ([KoaFramework](src/frameworks/koa/koa.framework.ts))
+- Async Initialization by using ([LazyFramework](src/frameworks/lazy/lazy.framework.ts))
+  - Use this framework to provide a way to create the instance of your app asynchronously.
+  - With him, you can create an instance of Express or Fastify asynchronously, [see the docs](src/frameworks/lazy/lazy.framework.ts).
 
 We support these event sources:
 

package/lib/frameworks/lazy/index.js

@@ -0,0 +1 @@
+"use strict";

package/lib/frameworks/lazy/lazy.framework.d.ts

@@ -0,0 +1,51 @@
+/// <reference types="node" />
+import { IncomingMessage, ServerResponse } from 'http';
+import { FrameworkContract } from '../../contracts';
+import { ILogger } from '../../core';
+/**
+ * The framework that asynchronously instantiates your application and forwards the request to the framework as quickly as possible.
+ *
+ * @example```typescript
+ * import express from 'express';
+ * import { ServerlessAdapter } from '@h4ad/serverless-adapter';
+ * import { ExpressFramework } from '@h4ad/serverless-adapter/lib/frameworks/express';
+ * import { LazyFramework } from '@h4ad/serverless-adapter/lib/frameworks/lazy';
+ *
+ * const expressFramework = new ExpressFramework();
+ * const factory = async () => {
+ *   const app = express();
+ *
+ *   // do some asynchronous stuffs like create the database;
+ *   await new Promise(resolve => setTimeout(resolve, 100);
+ *
+ *   return app;
+ * };
+ * const framework = new LazyFramework(expressFramework, factory);
+ *
+ * export const handler = ServerlessAdapter.new(null)
+ *   .setFramework(framework)
+ *   // set other configurations and then build
+ *   .build();
+ * ```
+ */
+export declare class LazyFramework<TApp> implements FrameworkContract<null> {
+    protected readonly framework: FrameworkContract<TApp>;
+    protected readonly factory: () => Promise<TApp>;
+    protected readonly logger: ILogger;
+    /**
+     * Default Constructor
+     */
+    constructor(framework: FrameworkContract<TApp>, factory: () => Promise<TApp>, logger?: ILogger);
+    /**
+     * The cached version of the app
+     */
+    protected cachedApp?: TApp;
+    /**
+     * The delayed factory to create an instance of the app
+     */
+    protected readonly delayedFactory: Promise<void>;
+    /**
+     * @inheritDoc
+     */
+    sendRequest(app: null, request: IncomingMessage, response: ServerResponse): void;
+}

package/lib/frameworks/lazy/lazy.framework.js

@@ -0,0 +1,70 @@
+"use strict";
+//#region Imports
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LazyFramework = void 0;
+const core_1 = require("../../core");
+//#endregion
+/**
+ * The framework that asynchronously instantiates your application and forwards the request to the framework as quickly as possible.
+ *
+ * @example```typescript
+ * import express from 'express';
+ * import { ServerlessAdapter } from '@h4ad/serverless-adapter';
+ * import { ExpressFramework } from '@h4ad/serverless-adapter/lib/frameworks/express';
+ * import { LazyFramework } from '@h4ad/serverless-adapter/lib/frameworks/lazy';
+ *
+ * const expressFramework = new ExpressFramework();
+ * const factory = async () => {
+ *   const app = express();
+ *
+ *   // do some asynchronous stuffs like create the database;
+ *   await new Promise(resolve => setTimeout(resolve, 100);
+ *
+ *   return app;
+ * };
+ * const framework = new LazyFramework(expressFramework, factory);
+ *
+ * export const handler = ServerlessAdapter.new(null)
+ *   .setFramework(framework)
+ *   // set other configurations and then build
+ *   .build();
+ * ```
+ */
+class LazyFramework {
+    //#region Constructor
+    /**
+     * Default Constructor
+     */
+    constructor(framework, factory, logger = (0, core_1.createDefaultLogger)()) {
+        this.framework = framework;
+        this.factory = factory;
+        this.logger = logger;
+        this.delayedFactory = Promise.resolve()
+            .then(() => factory())
+            .then(app => {
+            this.cachedApp = app;
+        })
+            .catch((error) => {
+            // deal with the error only when receive some request
+            // to be able to return some message to user
+            this.logger.error('SERVERLESS_ADAPTER:LAZY_FRAMEWORK: An error occours during the creation of your app.');
+            this.logger.error(error);
+        });
+    }
+    //#endregion
+    //#region Public Methods
+    /**
+     * @inheritDoc
+     */
+    sendRequest(app, request, response) {
+        if (this.cachedApp)
+            return this.framework.sendRequest(this.cachedApp, request, response);
+        this.delayedFactory.then(() => {
+            if (!this.cachedApp) {
+                return response.emit('error', new Error('SERVERLESS_ADAPTER:LAZY_FRAMEWORK: The instance of the app returned by the factory is not valid, see the logs to learn more.'));
+            }
+            return this.framework.sendRequest(this.cachedApp, request, response);
+        });
+    }
+}
+exports.LazyFramework = LazyFramework;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@h4ad/serverless-adapter",
-  "version": "2.2.0",
+  "version": "2.3.0",
   "description": "This library enables you to utilize any Cloud or Event Source to respond to web and API requests using your existing Node.js application framework.",
   "main": "./lib/index.js",
   "files": [