@travetto/web-aws-lambda 6.0.0-rc.2

package/README.md

@@ -0,0 +1,46 @@
+<!-- This file was generated by @travetto/doc and should not be modified directly -->
+<!-- Please modify https://github.com/travetto/travetto/tree/main/module/web-aws-lambda/DOC.tsx and execute "npx trv doc" to rebuild -->
+# Web AWS Lambda
+
+## Web APIs entry point support for AWS Lambdas.
+
+**Install: @travetto/web-aws-lambda**
+```bash
+npm install @travetto/web-aws-lambda
+
+# or
+
+yarn add @travetto/web-aws-lambda
+```
+
+This module provides an adapter between [Web API](https://github.com/travetto/travetto/tree/main/module/web#readme "Declarative api for Web Applications with support for the dependency injection.") and [AWS Lambda](https://aws.amazon.com/lambda/).  The event-driven invocation model for [Web API](https://github.com/travetto/travetto/tree/main/module/web#readme "Declarative api for Web Applications with support for the dependency injection.") aligns cleanly with [AWS Lambda](https://aws.amazon.com/lambda/)'s model for event-driven operation.  
+
+**NOTE:** The only caveat to consider, is that while the framework supports streams for responses, [AWS Lambda](https://aws.amazon.com/lambda/) does not. Any streaming result will be read and converted into a [Buffer](https://nodejs.org/api/buffer.html) before being sent back.
+
+## CLI - Packaging Lambdas
+
+**Terminal: Invoking a Package Build**
+```bash
+$ trv pack:lambda -h
+
+Usage: pack:lambda [options]
+
+Options:
+  -b, --build-dir <string>             Workspace for building (default: "/tmp/<temp-folder>")
+  --clean, --no-clean                  Clean workspace (default: true)
+  -o, --output <string>                Output location (default: "<module>.zip")
+  -es, --main-scripts                  Create entry scripts (default: false)
+  -f, --main-name <string>             Main name for build artifact
+  -e, --entry-point <string>           Entry point (default: "@travetto/web-aws-lambda/support/entry.handler.ts")
+  --minify, --no-minify                Minify output (default: true)
+  -sm, --sourcemap                     Bundle source maps (default: false)
+  -is, --include-sources               Include source with source maps (default: false)
+  -x, --eject-file <string>            Eject commands to file
+  -r, --rollup-configuration <string>  Rollup configuration file (default: "@travetto/pack/support/rollup/build.ts")
+  --env-file <string>                  Env Flag File Name (default: ".env")
+  --manifest-file <string>             Manifest File Name (default: "manifest.json")
+  -wr, --include-workspace-resources   Include workspace resources (default: false)
+  -np, --npm-package <string>          External NPM Packages (default: [])
+  -m, --module <module>                Module to run for
+  -h, --help                           display help for command
+```

package/__index__.ts

@@ -0,0 +1,2 @@
+export * from './src/handler.ts';
+export * from './src/util.ts';

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@travetto/web-aws-lambda",
+  "version": "6.0.0-rc.2",
+  "description": "Web APIs entry point support for AWS Lambdas.",
+  "keywords": [
+    "web",
+    "aws-lambda",
+    "travetto",
+    "typescript"
+  ],
+  "homepage": "https://travetto.io",
+  "license": "MIT",
+  "author": {
+    "email": "travetto.framework@gmail.com",
+    "name": "Travetto Framework"
+  },
+  "files": [
+    "__index__.ts",
+    "src",
+    "support"
+  ],
+  "main": "__index__.ts",
+  "repository": {
+    "url": "git+https://github.com/travetto/travetto.git",
+    "directory": "module/web-aws-lambda"
+  },
+  "dependencies": {
+    "@travetto/web": "^6.0.0-rc.2",
+    "@types/aws-lambda": "^8.10.149"
+  },
+  "peerDependencies": {
+    "@travetto/cli": "^6.0.0-rc.2",
+    "@travetto/pack": "^6.0.0-rc.2",
+    "@travetto/test": "^6.0.0-rc.2"
+  },
+  "peerDependenciesMeta": {
+    "@travetto/test": {
+      "optional": true
+    },
+    "@travetto/pack": {
+      "optional": true
+    },
+    "@travetto/cli": {
+      "optional": true
+    }
+  },
+  "travetto": {
+    "displayName": "Web AWS Lambda"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/handler.ts

@@ -0,0 +1,38 @@
+import type lambda from 'aws-lambda';
+
+import { Runtime, ConsoleManager } from '@travetto/runtime';
+import { DependencyRegistry, Inject, Injectable } from '@travetto/di';
+import { RootRegistry } from '@travetto/registry';
+import { ConfigurationService } from '@travetto/config';
+import { StandardWebRouter } from '@travetto/web';
+
+import { AwsLambdaWebUtil } from './util.ts';
+
+@Injectable()
+export class AwsLambdaWebHandler {
+
+  static inst: AwsLambdaWebHandler;
+
+  static entryPoint(): (event: lambda.APIGatewayProxyEvent, context: lambda.Context) => Promise<lambda.APIGatewayProxyResult> {
+    ConsoleManager.debug(Runtime.debug);
+
+    return async (event, context) => {
+      if (!this.inst) {
+        await RootRegistry.init();
+        await DependencyRegistry.getInstance(ConfigurationService).then(v => v.initBanner());
+        this.inst = await DependencyRegistry.getInstance(AwsLambdaWebHandler);
+      }
+      return this.inst.handle(event, context);
+    };
+  }
+
+  @Inject()
+  router: StandardWebRouter;
+
+  async handle(event: lambda.APIGatewayProxyEvent, context: lambda.Context): Promise<lambda.APIGatewayProxyResult> {
+    context.callbackWaitsForEmptyEventLoop = false;
+    const request = AwsLambdaWebUtil.toWebRequest(event);
+    const response = await this.router.dispatch({ request });
+    return AwsLambdaWebUtil.toLambdaResult(response, event.isBase64Encoded);
+  }
+}

package/src/util.ts

@@ -0,0 +1,59 @@
+import { APIGatewayProxyEvent, APIGatewayProxyResult } from 'aws-lambda';
+
+import { castTo } from '@travetto/runtime';
+import { WebBodyUtil, WebCommonUtil, WebRequest, WebResponse } from '@travetto/web';
+
+export class AwsLambdaWebUtil {
+
+  /**
+   * Create a request from an api gateway event
+   */
+  static toWebRequest(event: APIGatewayProxyEvent): WebRequest {
+    // Build request
+    const body = event.body ? Buffer.from(event.body, event.isBase64Encoded ? 'base64' : 'utf8') : undefined;
+
+    return new WebRequest({
+      context: {
+        connection: {
+          httpProtocol: 'http',
+          ip: event.requestContext.identity?.sourceIp,
+        },
+        httpMethod: castTo(event.httpMethod.toUpperCase()),
+        httpQuery: castTo(event.queryStringParameters!),
+        path: event.path,
+      },
+      headers: { ...event.headers, ...event.multiValueHeaders },
+      body: WebBodyUtil.markRaw(body)
+    });
+  }
+
+  /**
+   * Create an API Gateway result from a web response
+   */
+  static async toLambdaResult(response: WebResponse, base64Encoded: boolean = false): Promise<APIGatewayProxyResult> {
+    const binaryResponse = new WebResponse({
+      context: response.context,
+      ...WebBodyUtil.toBinaryMessage(response)
+    });
+    const output = binaryResponse.body ? await WebBodyUtil.toBuffer(binaryResponse.body!) : Buffer.alloc(0);
+    const isBase64Encoded = !!output.length && base64Encoded;
+    const headers: Record<string, string> = {};
+    const multiValueHeaders: Record<string, string[]> = {};
+
+    binaryResponse.headers.forEach((v, k) => {
+      if (Array.isArray(v)) {
+        multiValueHeaders[k] = v;
+      } else {
+        headers[k] = v;
+      }
+    });
+
+    return {
+      statusCode: WebCommonUtil.getStatusCode(binaryResponse),
+      isBase64Encoded,
+      body: output.toString(isBase64Encoded ? 'base64' : 'utf8'),
+      headers,
+      multiValueHeaders,
+    };
+  }
+}

package/support/cli.pack_lambda.ts

@@ -0,0 +1,29 @@
+import { CliCommand, CliUtil } from '@travetto/cli';
+import { PackOperation } from '@travetto/pack/support/bin/operation.ts';
+import { BasePackCommand, PackOperationShape } from '@travetto/pack/support/pack.base.ts';
+
+/**
+ * Standard lambda support for pack
+ */
+@CliCommand({ with: { module: true } })
+export class PackLambdaCommand extends BasePackCommand {
+
+  preMain(): void {
+    this.entryPoint ??= '@travetto/web-aws-lambda/support/entry.handler.ts';
+    this.output ??= CliUtil.getSimpleModuleName('<module>.zip', this.module);
+    this.mainScripts = false;
+  }
+
+  preHelp(): void {
+    this.output = undefined!;
+    this.entryPoint = undefined!;
+    this.preMain();
+  }
+
+  getOperations(): PackOperationShape<this>[] {
+    return [
+      ...super.getOperations(),
+      PackOperation.compress
+    ];
+  }
+}

package/support/entry.handler.ts

@@ -0,0 +1,3 @@
+// @trv-no-transform
+import { AwsLambdaWebHandler } from '../src/handler.ts';
+export const handler = AwsLambdaWebHandler.entryPoint();

package/support/test/dispatcher.ts

@@ -0,0 +1,81 @@
+import { APIGatewayProxyEvent, Context } from 'aws-lambda';
+
+import { Inject, Injectable } from '@travetto/di';
+import { WebDispatcher, WebFilterContext, WebRequest, WebResponse } from '@travetto/web';
+import { AppError, asFull, castTo } from '@travetto/runtime';
+
+import { WebTestDispatchUtil } from '@travetto/web/support/test/dispatch-util.ts';
+
+import { AwsLambdaWebHandler } from '../../src/handler.ts';
+
+/**
+ * Create an api gateway event given a web request
+ */
+function toLambdaEvent(request: WebRequest): APIGatewayProxyEvent {
+  const body = request.body;
+  const headers: Record<string, string> = {};
+  const multiValueHeaders: Record<string, string[]> = {};
+  const queryStringParameters: Record<string, string> = {};
+  const multiValueQueryStringParameters: Record<string, string[]> = {};
+
+  if (!(body === undefined || body === null || Buffer.isBuffer(body))) {
+    throw new AppError('Unsupported request type, only buffer bodies supported');
+  }
+
+  request.headers.forEach((v, k) => {
+    headers[k] = Array.isArray(v) ? v.join('; ') : v;
+    multiValueHeaders[k] = request.headers.getList(k) ?? [];
+  });
+
+  Object.entries(request.context.httpQuery ?? {}).forEach(([k, v]) => {
+    if (Array.isArray(v)) {
+      multiValueQueryStringParameters[k] = v;
+    } else {
+      queryStringParameters[k] = v?.toString() ?? '';
+    }
+  });
+
+  return {
+    resource: '/{proxy+}',
+    pathParameters: {},
+    stageVariables: {},
+    path: request.context.path,
+    httpMethod: request.context.httpMethod ?? 'POST',
+    queryStringParameters,
+    multiValueQueryStringParameters,
+    headers,
+    multiValueHeaders,
+    isBase64Encoded: true,
+    body: body?.toString('base64')!,
+    requestContext: castTo({
+      identity: castTo({ sourceIp: '127.0.0.1' }),
+    }),
+  };
+}
+
+/**
+ * AWS Lambda support for invoking directly
+ */
+@Injectable()
+export class LocalAwsLambdaWebDispatcher implements WebDispatcher {
+
+  @Inject()
+  app: AwsLambdaWebHandler;
+
+  async dispatch({ request }: WebFilterContext): Promise<WebResponse> {
+    const event = toLambdaEvent(await WebTestDispatchUtil.applyRequestBody(request));
+
+    const response = await this.app.handle(event, asFull<Context>({}));
+
+    return WebTestDispatchUtil.finalizeResponseBody(
+      new WebResponse<unknown>({
+        body: Buffer.from(response.body, response.isBase64Encoded ? 'base64' : 'utf8'),
+        headers: { ...response.headers ?? {}, ...response.multiValueHeaders ?? {} },
+        context: {
+          httpStatusCode: response.statusCode
+        }
+      }),
+      true
+    );
+  }
+}