hono-adapter-aws-lambda 0.2.7

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 NamesMT <https://github.com/namesmt>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,65 @@
+# hono-adapter-aws-lambda ![TypeScript heart icon](https://img.shields.io/badge/♡-%23007ACC.svg?logo=typescript&logoColor=white)
+
+[![npm version][npm-version-src]][npm-version-href]
+[![npm downloads][npm-downloads-src]][npm-downloads-href]
+[![Codecov][codecov-src]][codecov-href]
+[![Bundlejs][bundlejs-src]][bundlejs-href]
+[![jsDocs.io][jsDocs-src]][jsDocs-href]
+
+**hono-adapter-aws-lambda** is a fork of [hono](https://hono.dev/)'s `aws-lambda` adapter, experimenting and adding some extra features
+
+## Features & Roadmap
+- [x] add router support for trigger events.
+  - > I.e, support for S3, SQS, etc. triggers, which would also support a simpler cross-function call interface.
+  - ~~Support is added with a few notices~~
+    - ~~Must use `getTriggerPath()` when defining a trigger route~~
+    - ~~Must use `fixTriggerRoute()` to support basePath / grouping~~
+  - A refactor of the trigger routing support have been released, it now supports multiple routes on the same eventSource, uses a factory pattern, and decoupled the trigger context (middlewares, env bindings) from our main Hono app, see [#10](https://github.com/NamesMT/hono-adapter-aws-lambda/issues/10) for more information.
+
+## Usage
+### Install package:
+```sh
+# pnpm (recommended)
+pnpm install hono-adapter-aws-lambda
+```
+
+### Import:
+```ts
+// ESM
+import { handle, streamHandle } from 'hono-adapter-aws-lambda'
+```
+
+### Examples:
+Fast example of accepting an S3 trigger event
+```ts
+import type { S3Event } from 'aws-lambda' // You need to install `@types/aws-lambda`
+import { createTriggerFactory, handle, streamHandle } from 'hono-adapter-aws-lambda'
+
+interface Bindings {
+  event: { Records: Array<{ eventName: string }> }
+}
+const app = new Hono<{ Bindings: Bindings }>()
+const triggerFactory = createTriggerFactory(app)
+
+triggerFactory.on('aws:s3', '$!', c => c.text((c.env.event as S3Event).Records[0].eventName))
+```
+
+See some more examples in the test file: [test/index.test.ts](test/index.test.ts)
+
+## License
+[MIT](./LICENSE) License © 2024 [NamesMT](https://github.com/NamesMT)
+
+<!-- Badges -->
+
+[npm-version-src]: https://img.shields.io/npm/v/hono-adapter-aws-lambda?labelColor=18181B&color=F0DB4F
+[npm-version-href]: https://npmjs.com/package/hono-adapter-aws-lambda
+[npm-downloads-src]: https://img.shields.io/npm/dm/hono-adapter-aws-lambda?labelColor=18181B&color=F0DB4F
+[npm-downloads-href]: https://npmjs.com/package/hono-adapter-aws-lambda
+[codecov-src]: https://img.shields.io/codecov/c/gh/namesmt/hono-adapter-aws-lambda/main?labelColor=18181B&color=F0DB4F
+[codecov-href]: https://codecov.io/gh/namesmt/hono-adapter-aws-lambda
+[license-src]: https://img.shields.io/github/license/namesmt/hono-adapter-aws-lambda.svg?labelColor=18181B&color=F0DB4F
+[license-href]: https://github.com/namesmt/hono-adapter-aws-lambda/blob/main/LICENSE
+[bundlejs-src]: https://img.shields.io/bundlejs/size/hono-adapter-aws-lambda?labelColor=18181B&color=F0DB4F
+[bundlejs-href]: https://bundlejs.com/?q=hono-adapter-aws-lambda
+[jsDocs-src]: https://img.shields.io/badge/Check_out-jsDocs.io---?labelColor=18181B&color=F0DB4F
+[jsDocs-href]: https://www.jsdocs.io/package/hono-adapter-aws-lambda

package/dist/index.d.mts

@@ -0,0 +1,35 @@
+import { Env, Schema, Hono } from 'hono';
+import { LambdaEvent, LambdaTriggerEvent } from '@namesmt/utils-lambda';
+export { LambdaEvent, LambdaRequestEvent, LambdaTriggerEvent } from '@namesmt/utils-lambda';
+import { Handler, APIGatewayProxyResult, APIGatewayProxyStructuredResultV2 } from 'aws-lambda';
+export { Context as LambdaContext } from 'aws-lambda';
+import * as hono_types from 'hono/types';
+import { H } from 'hono/types';
+
+type LambdaHandler<TEvent = any, TResult = any> = Handler<TEvent, TResult>;
+type LambdaHandlerResult = APIGatewayProxyResult | APIGatewayProxyStructuredResultV2;
+
+declare function streamHandle<E extends Env = Env, S extends Schema = {}, BasePath extends string = '/'>(app: Hono<E, S, BasePath>): LambdaHandler<LambdaEvent>;
+/**
+ * Accepts events from API Gateway/ELB(`APIGatewayProxyEvent`) and directly through Function Url(`APIGatewayProxyEventV2`)
+ */
+declare function handle<E extends Env = Env, S extends Schema = {}, BasePath extends string = '/'>(app: Hono<E, S, BasePath>): LambdaHandler<LambdaEvent, LambdaHandlerResult>;
+
+declare class TriggerFactory<IE extends Env, HE extends Env> {
+    private simpleRouter;
+    honoApp: Hono<HE>;
+    internalApp: Hono<IE, hono_types.BlankSchema, "/">;
+    constructor(app: Hono<HE>);
+    on: (eventSource: string, id: string, ...handlers: H<IE>[]) => this;
+}
+type ExtractHonoEnv<A extends Hono> = A extends Hono<infer E> ? E : never;
+declare function createTriggerFactory<E extends Env, A extends Hono<any, any, '/'>>(app: A): TriggerFactory<E extends unknown ? {
+    Bindings: {
+        event: LambdaTriggerEvent;
+    };
+    Variables: Record<string, unknown>;
+} : E, ExtractHonoEnv<A>>;
+declare const triggerPathUUID: string;
+declare function getTriggerPath(path: string): string;
+
+export { type LambdaHandler, type LambdaHandlerResult, TriggerFactory, createTriggerFactory, getTriggerPath, handle, streamHandle, triggerPathUUID };

package/dist/index.mjs

@@ -0,0 +1,385 @@
+import crypto from 'node:crypto';
+import { Readable } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+import { decodeBase64, encodeBase64 } from 'hono/utils/encode';
+import { Hono } from 'hono';
+import { mergePath } from 'hono/utils/url';
+
+class RequestEventProcessor {
+  createRequest(event) {
+    const queryString = this.getQueryString(event);
+    const domainName = event.requestContext && "domainName" in event.requestContext ? event.requestContext.domainName : event.headers?.host ?? event.multiValueHeaders?.host?.[0];
+    const path = this.getPath(event);
+    const urlPath = `https://${domainName}${path}`;
+    const url = queryString ? `${urlPath}?${queryString}` : urlPath;
+    const headers = this.getHeaders(event);
+    const method = this.getMethod(event);
+    const requestInit = {
+      headers,
+      method
+    };
+    if (event.body) {
+      requestInit.body = event.isBase64Encoded ? decodeBase64(event.body) : event.body;
+    }
+    return new Request(url, requestInit);
+  }
+  async createResult(event, res) {
+    const contentType = res.headers.get("content-type");
+    let isBase64Encoded = !!(contentType && isContentTypeBinary(contentType));
+    if (!isBase64Encoded) {
+      const contentEncoding = res.headers.get("content-encoding");
+      isBase64Encoded = isContentEncodingBinary(contentEncoding);
+    }
+    const body = isBase64Encoded ? encodeBase64(await res.arrayBuffer()) : await res.text();
+    const result = {
+      body,
+      headers: {},
+      multiValueHeaders: void 0,
+      statusCode: res.status,
+      isBase64Encoded
+    };
+    if ("multiValueHeaders" in event) {
+      result.multiValueHeaders = {};
+    }
+    this.setCookies(event, res, result);
+    res.headers.forEach((value, key) => {
+      result.headers[key] = value;
+      if ("multiValueHeaders" in event) {
+        result.multiValueHeaders[key] = [value];
+      }
+    });
+    return result;
+  }
+  setCookies(event, res, result) {
+    if (res.headers.has("set-cookie")) {
+      const cookies = res.headers.getSetCookie ? res.headers.getSetCookie() : Array.from(res.headers.entries()).filter(([k]) => k === "set-cookie").map(([, v]) => v);
+      if (Array.isArray(cookies)) {
+        this.setCookiesToResult(event, result, cookies);
+        res.headers.delete("set-cookie");
+      }
+    }
+  }
+}
+class EventV2Processor extends RequestEventProcessor {
+  getPath(event) {
+    return event.rawPath;
+  }
+  getMethod(event) {
+    return event.requestContext.http.method;
+  }
+  getQueryString(event) {
+    return event.rawQueryString;
+  }
+  getCookies(event, headers) {
+    if (Array.isArray(event.cookies)) {
+      headers.set("Cookie", event.cookies.join("; "));
+    }
+  }
+  setCookiesToResult(_, result, cookies) {
+    result.cookies = cookies;
+  }
+  getHeaders(event) {
+    const headers = new Headers();
+    this.getCookies(event, headers);
+    if (event.headers) {
+      for (const [k, v] of Object.entries(event.headers)) {
+        if (v) {
+          headers.set(k, v);
+        }
+      }
+    }
+    return headers;
+  }
+}
+const v2Processor = new EventV2Processor();
+class EventV1Processor extends RequestEventProcessor {
+  getPath(event) {
+    return event.path;
+  }
+  getMethod(event) {
+    return event.httpMethod;
+  }
+  getQueryString(event) {
+    return Object.entries(event.queryStringParameters || {}).filter(([, value]) => value).map(([key, value]) => `${key}=${value}`).join("&");
+  }
+  getCookies(event, headers) {
+  }
+  getHeaders(event) {
+    const headers = new Headers();
+    this.getCookies(event, headers);
+    if (event.headers) {
+      for (const [k, v] of Object.entries(event.headers)) {
+        if (v) {
+          headers.set(k, v);
+        }
+      }
+    }
+    if (event.multiValueHeaders) {
+      for (const [k, values] of Object.entries(event.multiValueHeaders)) {
+        if (values) {
+          const foundK = headers.get(k);
+          values.forEach((v) => (!foundK || !foundK.includes(v)) && headers.append(k, v));
+        }
+      }
+    }
+    return headers;
+  }
+  setCookiesToResult(_, result, cookies) {
+    result.multiValueHeaders = {
+      "set-cookie": cookies
+    };
+  }
+}
+const v1Processor = new EventV1Processor();
+class ALBProcessor extends RequestEventProcessor {
+  getHeaders(event) {
+    const headers = new Headers();
+    if (event.multiValueHeaders) {
+      for (const [key, values] of Object.entries(event.multiValueHeaders)) {
+        if (values && Array.isArray(values)) {
+          headers.set(key, values.join("; "));
+        }
+      }
+    } else {
+      for (const [key, value] of Object.entries(event.headers ?? {})) {
+        if (value) {
+          headers.set(key, value);
+        }
+      }
+    }
+    return headers;
+  }
+  getPath(event) {
+    return event.path;
+  }
+  getMethod(event) {
+    return event.httpMethod;
+  }
+  getQueryString(event) {
+    if (event.multiValueQueryStringParameters) {
+      return Object.entries(event.multiValueQueryStringParameters || {}).filter(([, value]) => value).map(([key, value]) => `${key}=${value?.join(`&${key}=`)}`).join("&");
+    } else {
+      return Object.entries(event.queryStringParameters || {}).filter(([, value]) => value).map(([key, value]) => `${key}=${value}`).join("&");
+    }
+  }
+  getCookies(event, headers) {
+    let cookie;
+    if (event.multiValueHeaders) {
+      cookie = event.multiValueHeaders.cookie?.join("; ");
+    } else {
+      cookie = event.headers ? event.headers.cookie : void 0;
+    }
+    if (cookie) {
+      headers.append("Cookie", cookie);
+    }
+  }
+  setCookiesToResult(event, result, cookies) {
+    if (event.multiValueHeaders && result.multiValueHeaders) {
+      result.multiValueHeaders["set-cookie"] = cookies;
+    } else {
+      result.headers["set-cookie"] = cookies.join(", ");
+    }
+  }
+}
+const albProcessor = new ALBProcessor();
+function isProxyEventALB(event) {
+  return Object.hasOwn(event, "requestContext") && Object.hasOwn(event.requestContext, "elb");
+}
+function isProxyEventV2(event) {
+  return Object.hasOwn(event, "rawPath");
+}
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+const METHOD = "TRIGGER";
+class TriggerFactory {
+  constructor(app) {
+    __publicField(this, "simpleRouter", {});
+    __publicField(this, "honoApp");
+    __publicField(this, "internalApp", new Hono());
+    __publicField(this, "on", (eventSource, id, ...handlers) => {
+      let thisEventSource = this.simpleRouter[eventSource];
+      if (!thisEventSource) {
+        this.simpleRouter[eventSource] = thisEventSource = {};
+        this.honoApp.on(METHOD, getTriggerPath(eventSource), async (c) => {
+          if (thisEventSource["$!"]) {
+            return this.internalApp.fetch(makeLocalRequest(METHOD, `/${eventSource}/$!`));
+          }
+          const resObj = {};
+          for (const route in thisEventSource) {
+            if (route[0] === "$")
+              continue;
+            const res = await this.internalApp.fetch(makeLocalRequest(METHOD, `/${eventSource}/${route}`));
+            resObj[route] = /^application\/json/.test(res.headers.get("content-type") || "") ? await res.json() : await res.text();
+          }
+          if (thisEventSource["$="]) {
+            return this.internalApp.fetch(makeLocalRequest(METHOD, `/${eventSource}/$=`));
+          }
+          return c.json(resObj);
+        });
+      }
+      if (thisEventSource[id])
+        throw new Error(`Route ID "${id}" already exists for event source "${eventSource}"`);
+      this.internalApp.on(METHOD, `/${eventSource}/${id}`, ...handlers);
+      thisEventSource[id] = true;
+      return this;
+    });
+    this.honoApp = app;
+  }
+}
+function createTriggerFactory(app) {
+  return new TriggerFactory(app);
+}
+class TriggerEventProcessor {
+  createRequest(event) {
+    const path = getTriggerPath(getEventSource(event));
+    return makeLocalRequest(METHOD, path);
+  }
+  async createResult(event, res) {
+    const contentType = res.headers.get("content-type");
+    let isBase64Encoded = !!(contentType && isContentTypeBinary(contentType));
+    if (!isBase64Encoded) {
+      const contentEncoding = res.headers.get("content-encoding");
+      isBase64Encoded = isContentEncodingBinary(contentEncoding);
+    }
+    const body = isBase64Encoded ? encodeBase64(await res.arrayBuffer()) : await res.text();
+    const result = {
+      body,
+      headers: {},
+      statusCode: res.status,
+      isBase64Encoded
+    };
+    res.headers.forEach((value, key) => {
+      result.headers[key] = value;
+    });
+    return result;
+  }
+}
+const triggerProcessor = new TriggerEventProcessor();
+const triggerPathUUID = `${process.env.SECRET_SALT}-${Date.now()}-${globalThis.crypto.randomUUID()}`;
+function getTriggerPath(path) {
+  return mergePath(triggerPathUUID, path);
+}
+function getEventSource(event) {
+  const eventSource = event?.eventSource || event?.Name || event?.Records?.[0]?.eventSource || event?.Records?.[0]?.EventSource || event?.source || event?.triggerSource;
+  if (!eventSource)
+    throw new Error("Invalid `event`: not LambdaTriggerEvent");
+  return eventSource;
+}
+function isTriggerEvent(event) {
+  try {
+    return Boolean(getEventSource(event));
+  } catch {
+    return false;
+  }
+}
+function makeLocalRequest(method, path) {
+  return new Request(`http://127.0.0.1${path}`, { method });
+}
+
+function isContentTypeBinary(contentType) {
+  return !/^(?:text\/(?:plain|html|css|javascript|csv).*|application\/(?:.*json|.*xml).*|image\/svg\+xml.*)$/.test(
+    contentType
+  );
+}
+function isContentEncodingBinary(contentEncoding) {
+  if (contentEncoding === null) {
+    return false;
+  }
+  return /^(?:gzip|deflate|compress|br)/.test(contentEncoding);
+}
+function getProcessor(event) {
+  if (isTriggerEvent(event))
+    return triggerProcessor;
+  if (isProxyEventALB(event))
+    return albProcessor;
+  if (isProxyEventV2(event))
+    return v2Processor;
+  return v1Processor;
+}
+
+globalThis.crypto ?? (globalThis.crypto = crypto);
+async function writableWriteReadable(writer, reader) {
+  let readResult = await reader.read();
+  while (!readResult.done) {
+    writer.write(readResult.value);
+    readResult = await reader.read();
+  }
+  writer.end();
+}
+function stringToReadable(str) {
+  return Readable.from(Buffer.from(str));
+}
+function resultToStreamMetadata(result) {
+  return {
+    statusCode: result.statusCode,
+    headers: result.headers,
+    cookies: result.cookies
+  };
+}
+function responseToStreamMetadata(res) {
+  const headers = {};
+  const cookies = [];
+  res.headers.forEach((value, name) => {
+    if (name === "set-cookie")
+      cookies.push(value);
+    else
+      headers[name] = value;
+  });
+  return {
+    statusCode: res.status,
+    headers,
+    cookies
+  };
+}
+function streamHandle(app) {
+  return awslambda.streamifyResponse(
+    async (event, responseStream, context) => {
+      const processor = getProcessor(event);
+      try {
+        const req = processor.createRequest(event);
+        const res = await app.fetch(req, {
+          event,
+          context
+        });
+        if (res.headers.get("$HAAL-returnBody")) {
+          const result = await res.json();
+          responseStream = awslambda.HttpResponseStream.from(responseStream, resultToStreamMetadata(result));
+          const bodyStream = stringToReadable(result.body || "");
+          await pipeline(bodyStream, responseStream);
+        } else {
+          responseStream = awslambda.HttpResponseStream.from(responseStream, responseToStreamMetadata(res));
+          if (res.body) {
+            await writableWriteReadable(responseStream, res.body.getReader());
+          } else {
+            responseStream.write("");
+          }
+        }
+      } catch (error) {
+        console.error("Error processing request:", error);
+        responseStream.write("Internal Server Error");
+      } finally {
+        responseStream.end();
+      }
+    }
+  );
+}
+function handle(app) {
+  return async (event, lambdaContext) => {
+    const processor = getProcessor(event);
+    const req = processor.createRequest(event);
+    const res = await app.fetch(req, {
+      event,
+      lambdaContext
+    });
+    if (res.headers.get("$HAAL-returnBody"))
+      return await res.json();
+    return processor.createResult(event, res);
+  };
+}
+
+export { TriggerFactory, createTriggerFactory, getTriggerPath, handle, streamHandle, triggerPathUUID };

package/package.json

@@ -0,0 +1,88 @@
+{
+  "name": "hono-adapter-aws-lambda",
+  "type": "module",
+  "version": "0.2.7",
+  "packageManager": "pnpm@9.5.0",
+  "description": "",
+  "author": "NamesMT <dangquoctrung123@gmail.com>",
+  "license": "MIT",
+  "funding": "https://github.com/sponsors/namesmt",
+  "homepage": "https://github.com/namesmt/hono-adapter-aws-lambda#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/namesmt/hono-adapter-aws-lambda.git"
+  },
+  "bugs": "https://github.com/namesmt/hono-adapter-aws-lambda/issues",
+  "keywords": [
+    "hono",
+    "adapter",
+    "aws",
+    "lambda"
+  ],
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
+    }
+  },
+  "source": "./src/index.ts",
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=18.20.3"
+  },
+  "scripts": {
+    "start": "NODE_ENV=dev tsx src/index.ts",
+    "watch": "NODE_ENV=dev tsx watch src/index.ts",
+    "stub": "unbuild --stub",
+    "dev": "pnpm run watch",
+    "play": "pnpm run stub && pnpm run --filter playground dev",
+    "play:useBuild": "pnpm run build && pnpm run --filter playground dev",
+    "lint": "eslint .",
+    "test": "vitest",
+    "test:types": "tsc --noEmit --skipLibCheck",
+    "check": "pnpm lint && pnpm test:types && vitest run --coverage",
+    "build": "unbuild",
+    "release": "pnpm dlx changelogen@latest --release --push --publish",
+    "prepare": "simple-git-hooks",
+    "prepublishOnly": "pnpm run build"
+  },
+  "dependencies": {
+    "@namesmt/utils-lambda": "^0.0.2",
+    "@types/aws-lambda": "^8.10.141",
+    "consola": "^3.2.3",
+    "hono": "^4.5.0",
+    "std-env": "^3.7.0"
+  },
+  "devDependencies": {
+    "@antfu/eslint-config": "^2.23.0",
+    "@types/node": "^20.14.11",
+    "@unocss/eslint-plugin": "^0.61.5",
+    "@vitest/coverage-v8": "^2.0.3",
+    "eslint": "^9.7.0",
+    "klona": "^2.0.6",
+    "lint-staged": "^15.2.7",
+    "simple-git-hooks": "^2.11.1",
+    "tsx": "^4.16.2",
+    "typescript": "^5.5.3",
+    "unbuild": "^2.0.0",
+    "vitest": "^2.0.3"
+  },
+  "pnpm": {
+    "overrides": {
+      "hasown": "npm:@nolyfill/hasown@^1",
+      "is-core-module": "npm:@nolyfill/is-core-module@^1"
+    }
+  },
+  "simple-git-hooks": {
+    "pre-commit": "pnpm lint-staged"
+  },
+  "lint-staged": {
+    "*": "eslint --fix"
+  }
+}