@h4ad/serverless-adapter 2.1.0 → 2.3.1

package/README.md

@@ -6,6 +6,7 @@
   <a href="#install">Install</a>&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;&nbsp;
   <a href="#usage">Usage</a>&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;&nbsp;
   <a href="#support">Support</a>&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;&nbsp;
+  <a href="#examples">Examples</a>&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;&nbsp;
   <a href="#architecture">Architecture</a>&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;&nbsp;
   <a href="#credits">Credits</a>
 </p>
@@ -62,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())
@@ -118,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:
 
@@ -140,7 +148,8 @@ We support these event sources:
     using ([SQSAdapter](./src/adapters/aws/sqs.adapter.ts))
 - Huawei
   - [Http Function](https://support.huaweicloud.com/intl/en-us/usermanual-functiongraph/functiongraph_01_1442.html): Look [this section](#huawei-http-function) about Huawei support for Http Function.
-  - [Event Function](https://support.huaweicloud.com/intl/en-us/usermanual-functiongraph/functiongraph_01_1441.html): Work in progress.
+  - [Event Function](https://support.huaweicloud.com/intl/en-us/usermanual-functiongraph/functiongraph_01_1441.html): 
+    - [Api Gateway](https://support.huaweicloud.com/intl/en-us/devg-functiongraph/functiongraph_02_0102.html#functiongraph_02_0102__li5178638110137) by using ([HuaweiApiGatewayAdapter](src/adapters/huawei/huawei-api-gateway.adapter.ts)).
 - Azure
   - [The support is coming soon.](https://github.com/H4ad/serverless-adapter/issues/3)
 - Firebase
@@ -161,7 +170,7 @@ We support these handlers:
 
 ## Huawei
 
-In Huawei, currently we only added support to FunctionGraphV2 with Http Function type.
+In Huawei, we added support to FunctionGraphV2 with Http Function and Event Function.
 
 The difference between Http Function and Event Function is that in Http Function you must expose port 8000 and Huawei will proxy Api Gateway requests to your application.
 So, on implementation, this library will create an http server to listen on port 8000 and forward the request to your framework.
@@ -216,7 +225,35 @@ In the end, the structure of the zip file you upload looks like this:
 
 ### Huawei Event Function
 
-Work in progress.
+With Http Function you need to use [HttpHuaweiHandler](src/handlers/huawei/http-huawei.handler.ts), 
+but with Event Function you should use [DefaultHandler](src/handlers/default/default.handler.ts).
+
+So, to add support to Api Gateway you do the following:
+
+```ts
+import { ServerlessAdapter } from '@h4ad/serverless-adapter';
+import { HuaweiApiGatewayAdapter } from '@h4ad/serverless-adapter/lib/adapters/huawei';
+import { ExpressFramework } from '@h4ad/serverless-adapter/lib/frameworks/express';
+import { DefaultHandler } from '@h4ad/serverless-adapter/lib/handlers/default';
+import { CallbackResolver } from '@h4ad/serverless-adapter/lib/resolvers/callback';
+import app from './app';
+
+export const handler = ServerlessAdapter.new(app)
+  .setFramework(new ExpressFramework())
+  .setHandler(new DefaultHandler())
+  .setResolver(new CallbackResolver())
+  .addAdapter(new HuaweiApiGatewayAdapter())
+  .build();
+```
+
+#### One important thing
+
+You must use the callback resolver because I couldn't get it to work with the PromiseResolver.
+Maybe it's a bug in the library or something specific in Huawei, if you have a tip please create an issue.
+
+# Examples
+
+You can see some examples of how to use this library [here](https://github.com/H4ad/serverless-adapter-examples).
 
 # Architecture
 

package/lib/@types/huawei/huawei-api-gateway-event.d.ts

@@ -0,0 +1,19 @@
+import { BothValueHeaders } from '../index';
+export interface HuaweiApiGatewayEvent {
+    body: string;
+    headers: BothValueHeaders;
+    httpMethod: string;
+    isBase64Encoded: boolean;
+    path: string;
+    pathParameters: HuaweiRequestPathParameters;
+    queryStringParameters: HuaweiRequestQueryStringParameters;
+    requestContext: HuaweiRequestContext;
+    [key: string]: any;
+}
+export declare type HuaweiRequestPathParameters = Record<string, string>;
+export declare type HuaweiRequestQueryStringParameters = Record<string, string | string[]>;
+export interface HuaweiRequestContext {
+    apiId: string;
+    requestId: string;
+    stage: string;
+}

package/lib/@types/huawei/huawei-api-gateway-event.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/@types/huawei/huawei-api-gateway-response.d.ts

@@ -0,0 +1,7 @@
+import { MultiValueHeaders } from '../headers';
+export interface HuaweiApiGatewayResponse {
+    isBase64Encoded: boolean;
+    statusCode: number;
+    headers: MultiValueHeaders;
+    body: string;
+}

package/lib/@types/huawei/huawei-api-gateway-response.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/@types/huawei/huawei-context.d.ts

@@ -0,0 +1,31 @@
+export declare type GetRequestIDSecondsReturn = string;
+export declare type GetRemainingTimeInMilliSecondsReturn = number;
+export declare type GetAccessKeyReturn = string;
+export declare type GetSecretKeyReturn = string;
+export declare type GetUserDataKeyParameter = string;
+export declare type GetUserDataReturn = any;
+export declare type GetFunctionNameReturn = string;
+export declare type GetRunningTimeInSecondsReturn = number;
+export declare type GetVersionReturn = string;
+export declare type GetMemorySizeReturn = number;
+export declare type GetCPUNumberReturn = number;
+export declare type GetProjectIdReturn = number;
+export declare type GetPackageReturn = string;
+export declare type GetLoggerReturn = {
+    info(message: string): void;
+};
+export interface HuaweiContext {
+    getRequestID(): GetRequestIDSecondsReturn;
+    getRemainingTimeInMilliSeconds(): GetRemainingTimeInMilliSecondsReturn;
+    getAccessKey(): GetAccessKeyReturn;
+    getSecretKey(): GetSecretKeyReturn;
+    getUserData(key: GetUserDataKeyParameter): GetUserDataReturn;
+    getFunctionName(): GetFunctionNameReturn;
+    getRunningTimeInSeconds(): GetRunningTimeInSecondsReturn;
+    getVersion(): GetVersionReturn;
+    getMemorySize(): GetMemorySizeReturn;
+    getCPUNumber(): GetCPUNumberReturn;
+    getProjectID(): GetProjectIdReturn;
+    getPackage(): GetPackageReturn;
+    getLogger(): GetLoggerReturn;
+}

package/lib/@types/huawei/huawei-context.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/@types/huawei/index.d.ts

@@ -0,0 +1,3 @@
+export * from './huawei-context';
+export * from './huawei-api-gateway-event';
+export * from './huawei-api-gateway-response';

package/lib/@types/huawei/index.js

@@ -0,0 +1,15 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./huawei-context"), exports);
+__exportStar(require("./huawei-api-gateway-event"), exports);
+__exportStar(require("./huawei-api-gateway-response"), exports);

package/lib/adapters/aws/api-gateway-v2.adapter.js

@@ -73,10 +73,10 @@ class ApiGatewayV2Adapter {
         const transferEncodingHeader = headers['transfer-encoding'];
         const hasTransferEncodingChunked = transferEncodingHeader && transferEncodingHeader.includes('chunked');
         if (hasTransferEncodingChunked) {
-            throw new Error('chunked encoding in headers is not supported by API Gateway V1');
+            throw new Error('chunked encoding in headers is not supported by API Gateway V2');
         }
         if (response === null || response === void 0 ? void 0 : response.chunkedEncoding) {
-            throw new Error('chunked encoding in response is not supported by API Gateway V1');
+            throw new Error('chunked encoding in response is not supported by API Gateway V2');
         }
         const cookies = multiValueHeaders['set-cookie'];
         if (headers)

package/lib/adapters/huawei/huawei-api-gateway.adapter.d.ts

@@ -0,0 +1,59 @@
+import { HuaweiApiGatewayEvent, HuaweiContext } from '../../@types/huawei';
+import { HuaweiApiGatewayResponse } from '../../@types/huawei/huawei-api-gateway-response';
+import { AdapterContract, AdapterRequest, GetResponseAdapterProps, OnErrorProps } from '../../contracts';
+/**
+ * The options to customize the {@link HuaweiApiGatewayAdapter}
+ */
+export interface HuaweiApiGatewayOptions {
+    /**
+     * Strip base path for custom domains
+     *
+     * @default ''
+     */
+    stripBasePath?: string;
+}
+/**
+ * The adapter to handle requests from Huawei Api Gateway
+ *
+ * @example```typescript
+ * const stripBasePath = '/any/custom/base/path'; // default ''
+ * const adapter = new ApiGatewayAdapter({ stripBasePath });
+ * ```
+ *
+ * {@link https://support.huaweicloud.com/intl/en-us/devg-functiongraph/functiongraph_02_0102.html#functiongraph_02_0102__li5178638110137 Event Reference}
+ */
+export declare class HuaweiApiGatewayAdapter implements AdapterContract<HuaweiApiGatewayEvent, HuaweiContext, HuaweiApiGatewayResponse> {
+    protected readonly options?: HuaweiApiGatewayOptions | undefined;
+    /**
+     * Default constructor
+     *
+     * @param options The options to customize the {@link HuaweiApiGatewayAdapter}
+     */
+    constructor(options?: HuaweiApiGatewayOptions | undefined);
+    /**
+     * @inheritDoc
+     */
+    getAdapterName(): string;
+    /**
+     * @inheritDoc
+     */
+    canHandle(event: unknown): event is HuaweiApiGatewayEvent;
+    /**
+     * @inheritDoc
+     */
+    getRequest(event: HuaweiApiGatewayEvent): AdapterRequest;
+    /**
+     * @inheritDoc
+     */
+    getResponse({ headers: responseHeaders, body, isBase64Encoded, statusCode, }: GetResponseAdapterProps<HuaweiApiGatewayEvent>): HuaweiApiGatewayResponse;
+    /**
+     * @inheritDoc
+     */
+    onErrorWhileForwarding({ error, delegatedResolver, respondWithErrors, event, log, }: OnErrorProps<HuaweiApiGatewayEvent, HuaweiApiGatewayResponse>): void;
+    /**
+     * Get path from event with query strings
+     *
+     * @param event The event sent by serverless
+     */
+    protected getPathFromEvent(event: HuaweiApiGatewayEvent): string;
+}

package/lib/adapters/huawei/huawei-api-gateway.adapter.js

@@ -0,0 +1,113 @@
+"use strict";
+//#region Imports
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HuaweiApiGatewayAdapter = void 0;
+const core_1 = require("../../core");
+/**
+ * The adapter to handle requests from Huawei Api Gateway
+ *
+ * @example```typescript
+ * const stripBasePath = '/any/custom/base/path'; // default ''
+ * const adapter = new ApiGatewayAdapter({ stripBasePath });
+ * ```
+ *
+ * {@link https://support.huaweicloud.com/intl/en-us/devg-functiongraph/functiongraph_02_0102.html#functiongraph_02_0102__li5178638110137 Event Reference}
+ */
+class HuaweiApiGatewayAdapter {
+    //#region Constructor
+    /**
+     * Default constructor
+     *
+     * @param options The options to customize the {@link HuaweiApiGatewayAdapter}
+     */
+    constructor(options) {
+        this.options = options;
+    }
+    //#endregion
+    //#region Public Methods
+    /**
+     * @inheritDoc
+     */
+    getAdapterName() {
+        return HuaweiApiGatewayAdapter.name;
+    }
+    /**
+     * @inheritDoc
+     */
+    canHandle(event) {
+        const apiGatewayEvent = event;
+        return !!(apiGatewayEvent &&
+            apiGatewayEvent.httpMethod &&
+            apiGatewayEvent.requestContext &&
+            apiGatewayEvent.requestContext.apiId &&
+            apiGatewayEvent.requestContext.stage &&
+            apiGatewayEvent.requestContext.requestId &&
+            // to avoid conflict with api gateway v1 of aws
+            !('multiValueQueryStringParameters' in apiGatewayEvent));
+    }
+    /**
+     * @inheritDoc
+     */
+    getRequest(event) {
+        const method = event.httpMethod;
+        const path = this.getPathFromEvent(event);
+        const headers = (0, core_1.getFlattenedHeadersMap)(event.headers, ',', true);
+        let body;
+        if (event.body) {
+            const [bufferBody, contentLength] = (0, core_1.getEventBodyAsBuffer)(event.body, event.isBase64Encoded);
+            body = bufferBody;
+            headers['content-length'] = String(contentLength);
+        }
+        const remoteAddress = headers['x-real-ip'];
+        return {
+            method,
+            headers,
+            body,
+            remoteAddress,
+            path,
+        };
+    }
+    /**
+     * @inheritDoc
+     */
+    getResponse({ headers: responseHeaders, body, isBase64Encoded, statusCode, }) {
+        const headers = (0, core_1.getMultiValueHeadersMap)(responseHeaders);
+        return {
+            statusCode,
+            body,
+            headers,
+            isBase64Encoded,
+        };
+    }
+    /**
+     * @inheritDoc
+     */
+    onErrorWhileForwarding({ error, delegatedResolver, respondWithErrors, event, log, }) {
+        const body = respondWithErrors ? error.stack : '';
+        const errorResponse = this.getResponse({
+            event,
+            statusCode: 500,
+            body: body || '',
+            headers: {},
+            isBase64Encoded: false,
+            log,
+        });
+        delegatedResolver.succeed(errorResponse);
+    }
+    //#endregion
+    //#region Protected Methods
+    /**
+     * Get path from event with query strings
+     *
+     * @param event The event sent by serverless
+     */
+    getPathFromEvent(event) {
+        var _a;
+        const stripBasePath = (0, core_1.getDefaultIfUndefined)((_a = this.options) === null || _a === void 0 ? void 0 : _a.stripBasePath, '');
+        const replaceRegex = new RegExp(`^${stripBasePath}`);
+        const path = event.path.replace(replaceRegex, '');
+        const queryParams = event.queryStringParameters;
+        return (0, core_1.getPathWithQueryStringParams)(path, queryParams);
+    }
+}
+exports.HuaweiApiGatewayAdapter = HuaweiApiGatewayAdapter;

package/lib/adapters/huawei/index.d.ts

@@ -0,0 +1 @@
+export * from './huawei-api-gateway.adapter';

package/lib/adapters/huawei/index.js

@@ -0,0 +1,13 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./huawei-api-gateway.adapter"), exports);

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

@@ -0,0 +1 @@
+export * from './lazy.framework';

package/lib/frameworks/lazy/index.js

@@ -0,0 +1,13 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./lazy.framework"), exports);

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/lib/resolvers/dummy/index.d.ts

@@ -0,0 +1 @@
+export * from './dummy.resolver';

package/lib/resolvers/dummy/index.js

@@ -0,0 +1,13 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./dummy.resolver"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@h4ad/serverless-adapter",
-  "version": "2.1.0",
+  "version": "2.3.1",
   "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": [
@@ -90,6 +90,7 @@
     "@types/koa": ">= 2.11.2",
     "express": ">= 4.15.4",
     "fastify": ">= 3.0.0",
+    "fastify-3": "npm:fastify@3.29.0",
     "koa": ">= 2.5.1"
   },
   "peerDependenciesMeta": {
@@ -113,6 +114,9 @@
     },
     "@types/koa": {
       "optional": true
+    },
+    "fastify-3": {
+      "optional": true
     }
   },
   "config": {