@zeltjs/adapter-lambda 0.0.1 → 0.4.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 9wick / Kohei Kido
+
+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/dist/index.d.ts

@@ -0,0 +1,341 @@
+import { EnvConfig, HttpApp, ReadyResult } from "@zeltjs/core";
+import { Writable } from "node:stream";
+
+//#region src/lambda-env.config.d.ts
+declare class LambdaEnvConfig extends EnvConfig {
+  get(key: string): string | undefined;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@types+aws-lambda@8.10.150/node_modules/@types/aws-lambda/common/api-gateway.d.ts
+// Default authorizer type, prefer using a specific type with the "...WithAuthorizer..." variant types.
+// Note that this doesn't have to be a context from a custom lambda outhorizer, AWS also has a cognito
+// authorizer type and could add more, so the property won't always be a string.
+type APIGatewayEventDefaultAuthorizerContext = undefined | null | {
+  [name: string]: any;
+};
+// The requestContext property of both request authorizer and proxy integration events.
+interface APIGatewayEventRequestContextWithAuthorizer<TAuthorizerContext> {
+  accountId: string;
+  apiId: string; // This one is a bit confusing: it is not actually present in authorizer calls
+  // and proxy calls without an authorizer. We model this by allowing undefined in the type,
+  // since it ends up the same and avoids breaking users that are testing the property.
+  // This lets us allow parameterizing the authorizer for proxy events that know what authorizer
+  // context values they have.
+  authorizer: TAuthorizerContext;
+  connectedAt?: number | undefined;
+  connectionId?: string | undefined;
+  domainName?: string | undefined;
+  domainPrefix?: string | undefined;
+  eventType?: string | undefined;
+  extendedRequestId?: string | undefined;
+  protocol: string;
+  httpMethod: string;
+  identity: APIGatewayEventIdentity;
+  messageDirection?: string | undefined;
+  messageId?: string | null | undefined;
+  path: string;
+  stage: string;
+  requestId: string;
+  requestTime?: string | undefined;
+  requestTimeEpoch: number;
+  resourceId: string;
+  resourcePath: string;
+  routeKey?: string | undefined;
+}
+interface APIGatewayEventClientCertificate {
+  clientCertPem: string;
+  serialNumber: string;
+  subjectDN: string;
+  issuerDN: string;
+  validity: {
+    notAfter: string;
+    notBefore: string;
+  };
+}
+interface APIGatewayEventIdentity {
+  accessKey: string | null;
+  accountId: string | null;
+  apiKey: string | null;
+  apiKeyId: string | null;
+  caller: string | null;
+  clientCert: APIGatewayEventClientCertificate | null;
+  cognitoAuthenticationProvider: string | null;
+  cognitoAuthenticationType: string | null;
+  cognitoIdentityId: string | null;
+  cognitoIdentityPoolId: string | null;
+  principalOrgId: string | null;
+  sourceIp: string;
+  user: string | null;
+  userAgent: string | null;
+  userArn: string | null;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@types+aws-lambda@8.10.150/node_modules/@types/aws-lambda/handler.d.ts
+/**
+ * {@link Handler} context parameter.
+ * See {@link https://docs.aws.amazon.com/lambda/latest/dg/nodejs-prog-model-context.html AWS documentation}.
+ */
+interface Context {
+  callbackWaitsForEmptyEventLoop: boolean;
+  functionName: string;
+  functionVersion: string;
+  invokedFunctionArn: string;
+  memoryLimitInMB: string;
+  awsRequestId: string;
+  logGroupName: string;
+  logStreamName: string;
+  identity?: CognitoIdentity | undefined;
+  clientContext?: ClientContext | undefined;
+  getRemainingTimeInMillis(): number; // Functions for compatibility with earlier Node.js Runtime v0.10.42
+  // No longer documented, so they are deprecated, but they still work
+  // as of the 12.x runtime, so they are not removed from the types.
+  /** @deprecated Use handler callback or promise result */
+  done(error?: Error, result?: any): void;
+  /** @deprecated Use handler callback with first argument or reject a promise result */
+  fail(error: Error | string): void;
+  /** @deprecated Use handler callback with second argument or resolve a promise result */
+  succeed(messageOrObject: any): void; // Unclear what behavior this is supposed to have, I couldn't find any still extant reference,
+  // and it behaves like the above, ignoring the object parameter.
+  /** @deprecated Use handler callback or promise result */
+  succeed(message: string, object: any): void;
+}
+interface CognitoIdentity {
+  cognitoIdentityId: string;
+  cognitoIdentityPoolId: string;
+}
+interface ClientContext {
+  client: ClientContextClient;
+  Custom?: any;
+  env: ClientContextEnv;
+}
+interface ClientContextClient {
+  installationId: string;
+  appTitle: string;
+  appVersionName: string;
+  appVersionCode: string;
+  appPackageName: string;
+}
+interface ClientContextEnv {
+  platformVersion: string;
+  platform: string;
+  make: string;
+  model: string;
+  locale: string;
+}
+/**
+ * Interface for using response streaming from AWS Lambda.
+ * To indicate to the runtime that Lambda should stream your function’s responses, you must wrap your function handler with the `awslambda.streamifyResponse()` decorator.
+ *
+ * The `streamifyResponse` decorator accepts the following additional parameter, `responseStream`, besides the default node handler parameters, `event`, and `context`.
+ * The new `responseStream` object provides a stream object that your function can write data to. Data written to this stream is sent immediately to the client. You can optionally set the Content-Type header of the response to pass additional metadata to your client about the contents of the stream.
+ *
+ * {@link https://aws.amazon.com/blogs/compute/introducing-aws-lambda-response-streaming/ AWS blog post}
+ * {@link https://docs.aws.amazon.com/lambda/latest/dg/config-rs-write-functions.html AWS documentation}
+ *
+ * @example <caption>Writing to the response stream</caption>
+ * import 'aws-lambda';
+ *
+ * export const handler = awslambda.streamifyResponse(
+ *   async (event, responseStream, context) => {
+ *       responseStream.setContentType("text/plain");
+ *       responseStream.write("Hello, world!");
+ *       responseStream.end();
+ *   }
+ * );
+ *
+ * @example <caption>Using pipeline</caption>
+ * import 'aws-lambda';
+ * import { Readable } from 'stream';
+ * import { pipeline } from 'stream/promises';
+ * import zlib from 'zlib';
+ *
+ * export const handler = awslambda.streamifyResponse(
+ *   async (event, responseStream, context) => {
+ *     // As an example, convert event to a readable stream.
+ *     const requestStream = Readable.from(Buffer.from(JSON.stringify(event)));
+ *
+ *     await pipeline(requestStream, zlib.createGzip(), responseStream);
+ *   }
+ * );
+ */
+type StreamifyHandler<TEvent = any, TResult = any> = (event: TEvent, responseStream: awslambda.HttpResponseStream, context: Context) => TResult | Promise<TResult>;
+declare global {
+  namespace awslambda {
+    class HttpResponseStream extends Writable {
+      static from(writable: Writable, metadata: Record<string, unknown>): HttpResponseStream;
+      setContentType: (contentType: string) => void;
+    }
+    /**
+     * Decorator for using response streaming from AWS Lambda.
+     * To indicate to the runtime that Lambda should stream your function’s responses, you must wrap your function handler with the `awslambda.streamifyResponse()` decorator.
+     *
+     * The `streamifyResponse` decorator accepts the following additional parameter, `responseStream`, besides the default node handler parameters, `event`, and `context`.
+     * The new `responseStream` object provides a stream object that your function can write data to. Data written to this stream is sent immediately to the client. You can optionally set the Content-Type header of the response to pass additional metadata to your client about the contents of the stream.
+     *
+     * {@link https://aws.amazon.com/blogs/compute/introducing-aws-lambda-response-streaming/ AWS blog post}
+     * {@link https://docs.aws.amazon.com/lambda/latest/dg/config-rs-write-functions.html AWS documentation}
+     *
+     * @example <caption>Writing to the response stream</caption>
+     * import 'aws-lambda';
+     *
+     * export const handler = awslambda.streamifyResponse(
+     *   async (event, responseStream, context) => {
+     *       responseStream.setContentType("text/plain");
+     *       responseStream.write("Hello, world!");
+     *       responseStream.end();
+     *   }
+     * );
+     *
+     * @example <caption>Using pipeline</caption>
+     * import 'aws-lambda';
+     * import { Readable } from 'stream';
+     * import { pipeline } from 'stream/promises';
+     * import zlib from 'zlib';
+     *
+     * export const handler = awslambda.streamifyResponse(
+     *   async (event, responseStream, context) => {
+     *     // As an example, convert event to a readable stream.
+     *     const requestStream = Readable.from(Buffer.from(JSON.stringify(event)));
+     *
+     *     await pipeline(requestStream, zlib.createGzip(), responseStream);
+     *   }
+     * );
+     */
+    function streamifyResponse<TEvent = any, TResult = void>(handler: StreamifyHandler<TEvent, TResult>): StreamifyHandler<TEvent, TResult>;
+  }
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@types+aws-lambda@8.10.150/node_modules/@types/aws-lambda/trigger/api-gateway-proxy.d.ts
+/**
+ * Works with Lambda Proxy Integration for Rest API or HTTP API integration Payload Format version 1.0
+ * @see - https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-lambda.html
+ */
+type APIGatewayProxyEvent = APIGatewayProxyEventBase<APIGatewayEventDefaultAuthorizerContext>;
+interface APIGatewayProxyEventHeaders {
+  [name: string]: string | undefined;
+}
+interface APIGatewayProxyEventMultiValueHeaders {
+  [name: string]: string[] | undefined;
+}
+interface APIGatewayProxyEventPathParameters {
+  [name: string]: string | undefined;
+}
+interface APIGatewayProxyEventQueryStringParameters {
+  [name: string]: string | undefined;
+}
+interface APIGatewayProxyEventMultiValueQueryStringParameters {
+  [name: string]: string[] | undefined;
+}
+interface APIGatewayProxyEventStageVariables {
+  [name: string]: string | undefined;
+}
+interface APIGatewayProxyEventBase<TAuthorizerContext> {
+  body: string | null;
+  headers: APIGatewayProxyEventHeaders;
+  multiValueHeaders: APIGatewayProxyEventMultiValueHeaders;
+  httpMethod: string;
+  isBase64Encoded: boolean;
+  path: string;
+  pathParameters: APIGatewayProxyEventPathParameters | null;
+  queryStringParameters: APIGatewayProxyEventQueryStringParameters | null;
+  multiValueQueryStringParameters: APIGatewayProxyEventMultiValueQueryStringParameters | null;
+  stageVariables: APIGatewayProxyEventStageVariables | null;
+  requestContext: APIGatewayEventRequestContextWithAuthorizer<TAuthorizerContext>;
+  resource: string;
+}
+/**
+ * Works with Lambda Proxy Integration for Rest API or HTTP API integration Payload Format version 1.0
+ * @see - https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-lambda.html
+ */
+interface APIGatewayProxyResult {
+  statusCode: number;
+  headers?: {
+    [header: string]: boolean | number | string;
+  } | undefined;
+  multiValueHeaders?: {
+    [header: string]: Array<boolean | number | string>;
+  } | undefined;
+  body: string;
+  isBase64Encoded?: boolean | undefined;
+}
+/**
+ * Works with HTTP API integration Payload Format version 2.0
+ * @see - https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-lambda.html
+ */
+interface APIGatewayEventRequestContextV2 {
+  accountId: string;
+  apiId: string;
+  authentication?: {
+    clientCert: APIGatewayEventClientCertificate;
+  };
+  domainName: string;
+  domainPrefix: string;
+  http: {
+    method: string;
+    path: string;
+    protocol: string;
+    sourceIp: string;
+    userAgent: string;
+  };
+  requestId: string;
+  routeKey: string;
+  stage: string;
+  time: string;
+  timeEpoch: number;
+}
+/**
+ * Proxy Event with adaptable requestContext for different authorizer scenarios
+ */
+interface APIGatewayProxyEventV2WithRequestContext<TRequestContext> {
+  version: string;
+  routeKey: string;
+  rawPath: string;
+  rawQueryString: string;
+  cookies?: string[];
+  headers: APIGatewayProxyEventHeaders;
+  queryStringParameters?: APIGatewayProxyEventQueryStringParameters;
+  requestContext: TRequestContext;
+  body?: string;
+  pathParameters?: APIGatewayProxyEventPathParameters;
+  isBase64Encoded: boolean;
+  stageVariables?: APIGatewayProxyEventStageVariables;
+}
+/**
+ * Default Proxy event with no Authorizer
+ */
+type APIGatewayProxyEventV2 = APIGatewayProxyEventV2WithRequestContext<APIGatewayEventRequestContextV2>;
+/**
+ * Works with HTTP API integration Payload Format version 2.0
+ * @see - https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-lambda.html
+ */
+type APIGatewayProxyResultV2<T = never> = APIGatewayProxyStructuredResultV2 | string | T;
+/**
+ * Interface for structured response with `statusCode` and`headers`
+ * Works with HTTP API integration Payload Format version 2.0
+ * @see - https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-lambda.html
+ */
+interface APIGatewayProxyStructuredResultV2 {
+  statusCode?: number | undefined;
+  headers?: {
+    [header: string]: boolean | number | string;
+  } | undefined;
+  body?: string | undefined;
+  isBase64Encoded?: boolean | undefined;
+  cookies?: string[] | undefined;
+}
+//#endregion
+//#region src/on-lambda.d.ts
+type LambdaAppOptions = {
+  readonly warmup?: boolean;
+};
+type LambdaHandlerV2 = (event: APIGatewayProxyEventV2, context: Context) => Promise<APIGatewayProxyResultV2>;
+type LambdaHandlerV1 = (event: APIGatewayProxyEvent, context: Context) => Promise<APIGatewayProxyResult>;
+type LambdaApp = ReadyResult & {
+  readonly handler: LambdaHandlerV2;
+  readonly handlerV1: LambdaHandlerV1;
+  readonly shutdown: () => Promise<void>;
+};
+declare const onLambda: (app: HttpApp, options?: LambdaAppOptions) => Promise<LambdaApp>;
+//#endregion
+export { type LambdaApp, type LambdaAppOptions, LambdaEnvConfig, type LambdaHandlerV1, type LambdaHandlerV2, onLambda };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":["APIGatewayAuthorizerResultContext","name","APIGatewayEventDefaultAuthorizerContext","APIGatewayEventRequestContext","APIGatewayEventRequestContextWithAuthorizer","TAuthorizerContext","APIGatewayEventIdentity","accountId","apiId","authorizer","connectedAt","connectionId","domainName","domainPrefix","eventType","extendedRequestId","protocol","httpMethod","identity","messageDirection","messageId","path","stage","requestId","requestTime","requestTimeEpoch","resourceId","resourcePath","routeKey","APIGatewayEventClientCertificate","clientCertPem","serialNumber","subjectDN","issuerDN","validity","notAfter","notBefore","accessKey","apiKey","apiKeyId","caller","clientCert","cognitoAuthenticationProvider","cognitoAuthenticationType","cognitoIdentityId","cognitoIdentityPoolId","principalOrgId","sourceIp","user","userAgent","userArn","Writable","Handler","TEvent","TResult","Context","Callback","Promise","event","context","callback","CognitoIdentity","ClientContext","Error","callbackWaitsForEmptyEventLoop","functionName","functionVersion","invokedFunctionArn","memoryLimitInMB","awsRequestId","logGroupName","logStreamName","identity","clientContext","getRemainingTimeInMillis","done","error","result","fail","succeed","messageOrObject","message","object","cognitoIdentityId","cognitoIdentityPoolId","ClientContextClient","ClientContextEnv","client","Custom","env","installationId","appTitle","appVersionName","appVersionCode","appPackageName","platformVersion","platform","make","model","locale","StreamifyHandler","awslambda","HttpResponseStream","responseStream","_0","Record","global","from","writable","metadata","setContentType","contentType","streamifyResponse","handler","sideEffect","APIGatewayEventClientCertificate","APIGatewayEventDefaultAuthorizerContext","APIGatewayEventRequestContextWithAuthorizer","Callback","CognitoIdentity","Handler","APIGatewayProxyHandler","APIGatewayProxyEvent","APIGatewayProxyResult","APIGatewayProxyCallback","APIGatewayProxyHandlerV2","T","APIGatewayProxyEventV2","APIGatewayProxyResultV2","APIGatewayProxyWebsocketHandlerV2","APIGatewayProxyWebsocketEventV2","APIGatewayProxyHandlerV2WithJWTAuthorizer","APIGatewayProxyEventV2WithJWTAuthorizer","APIGatewayProxyHandlerV2WithLambdaAuthorizer","TAuthorizerContext","APIGatewayProxyEventV2WithLambdaAuthorizer","APIGatewayProxyHandlerV2WithIAMAuthorizer","APIGatewayProxyEventV2WithIAMAuthorizer","APIGatewayProxyCallbackV2","APIGatewayProxyEventBase","APIGatewayProxyWithLambdaAuthorizerHandler","APIGatewayProxyWithLambdaAuthorizerEvent","APIGatewayProxyWithCognitoAuthorizerHandler","APIGatewayProxyWithCognitoAuthorizerEvent","APIGatewayEventLambdaAuthorizerContext","APIGatewayProxyWithLambdaAuthorizerEventRequestContext","P","principalId","integrationLatency","APIGatewayProxyCognitoAuthorizer","claims","name","APIGatewayProxyEventHeaders","APIGatewayProxyEventMultiValueHeaders","APIGatewayProxyEventPathParameters","APIGatewayProxyEventQueryStringParameters","APIGatewayProxyEventMultiValueQueryStringParameters","APIGatewayProxyEventStageVariables","body","headers","multiValueHeaders","httpMethod","isBase64Encoded","path","pathParameters","queryStringParameters","multiValueQueryStringParameters","stageVariables","requestContext","resource","Array","statusCode","header","APIGatewayEventRequestContextV2","accountId","apiId","authentication","clientCert","domainName","domainPrefix","http","method","protocol","sourceIp","userAgent","requestId","routeKey","stage","time","timeEpoch","APIGatewayEventWebsocketRequestContextV2","messageId","eventType","extendedRequestId","requestTime","messageDirection","connectedAt","requestTimeEpoch","connectionId","APIGatewayProxyEventV2WithRequestContext","TRequestContext","version","rawPath","rawQueryString","cookies","APIGatewayProxyWebsocketEventV2WithRequestContext","APIGatewayEventRequestContextLambdaAuthorizer","lambda","APIGatewayEventRequestContextJWTAuthorizer","jwt","scopes","APIGatewayEventRequestContextIAMAuthorizer","iam","accessKey","callerId","cognitoIdentity","principalOrgId","userArn","userId","APIGatewayEventRequestContextV2WithAuthorizer","TAuthorizer","authorizer","APIGatewayProxyStructuredResultV2","ProxyHandler","ProxyCallback","APIGatewayEvent","ProxyResult"],"sources":["../src/lambda-env.config.ts","../../../node_modules/.pnpm/@types+aws-lambda@8.10.150/node_modules/@types/aws-lambda/common/api-gateway.d.ts","../../../node_modules/.pnpm/@types+aws-lambda@8.10.150/node_modules/@types/aws-lambda/handler.d.ts","../../../node_modules/.pnpm/@types+aws-lambda@8.10.150/node_modules/@types/aws-lambda/trigger/api-gateway-proxy.d.ts","../src/on-lambda.ts"],"x_google_ignoreList":[1,2,3],"mappings":"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"}

package/dist/index.js

@@ -0,0 +1,112 @@
+import { Config, EnvConfig } from "@zeltjs/core";
+//#region src/lambda-env.config.ts
+var LambdaEnvConfig = @Config class extends EnvConfig {
+	get(key) {
+		return process.env[key];
+	}
+};
+//#endregion
+//#region src/on-lambda.ts
+const buildHeadersFromRecord = (headersRecord) => {
+	const headers = new Headers();
+	if (headersRecord) {
+		for (const [key, value] of Object.entries(headersRecord)) if (value) headers.set(key, value);
+	}
+	return headers;
+};
+const buildBodyFromEvent = (body, isBase64Encoded) => {
+	if (!body) return null;
+	if (isBase64Encoded) {
+		const buffer = Buffer.from(body, "base64");
+		return new Blob([buffer]);
+	}
+	return body;
+};
+const buildRequestBody = (method, body) => {
+	return method !== "GET" && method !== "HEAD" ? body : null;
+};
+const buildRequestFromEventV2 = (event) => {
+	const headers = buildHeadersFromRecord(event.headers);
+	const url = `${headers.get("x-forwarded-proto") ?? "https"}://${event.requestContext.domainName}${event.rawPath}${event.rawQueryString ? `?${event.rawQueryString}` : ""}`;
+	const method = event.requestContext.http.method;
+	const requestBody = buildRequestBody(method, buildBodyFromEvent(event.body, event.isBase64Encoded));
+	return new Request(url, {
+		method,
+		headers,
+		body: requestBody
+	});
+};
+const buildQueryStringFromParams = (queryParams) => {
+	if (!queryParams) return "";
+	const params = {};
+	for (const [key, value] of Object.entries(queryParams)) if (value !== void 0) params[key] = value;
+	return `?${new URLSearchParams(params).toString()}`;
+};
+const buildRequestFromEventV1 = (event) => {
+	const headers = buildHeadersFromRecord(event.headers);
+	const url = `${headers.get("x-forwarded-proto") ?? "https"}://${headers.get("host") ?? "localhost"}${event.path}${buildQueryStringFromParams(event.queryStringParameters)}`;
+	const method = event.httpMethod;
+	const requestBody = buildRequestBody(method, buildBodyFromEvent(event.body, event.isBase64Encoded));
+	return new Request(url, {
+		method,
+		headers,
+		body: requestBody
+	});
+};
+const buildResultFromResponseV2 = async (response) => {
+	const headers = {};
+	response.headers.forEach((value, key) => {
+		headers[key] = value;
+	});
+	const contentType = response.headers.get("content-type") ?? "";
+	const isBinary = contentType.startsWith("image/") || contentType.startsWith("audio/") || contentType.startsWith("video/") || contentType === "application/octet-stream";
+	const body = isBinary ? Buffer.from(await response.arrayBuffer()).toString("base64") : await response.text();
+	return {
+		statusCode: response.status,
+		headers,
+		body,
+		isBase64Encoded: isBinary
+	};
+};
+const buildResultFromResponseV1 = async (response) => {
+	const headers = {};
+	response.headers.forEach((value, key) => {
+		headers[key] = value;
+	});
+	const contentType = response.headers.get("content-type") ?? "";
+	const isBinary = contentType.startsWith("image/") || contentType.startsWith("audio/") || contentType.startsWith("video/") || contentType === "application/octet-stream";
+	const body = isBinary ? Buffer.from(await response.arrayBuffer()).toString("base64") : await response.text();
+	return {
+		statusCode: response.status,
+		headers,
+		body,
+		isBase64Encoded: isBinary
+	};
+};
+const createHandlerV2 = (appFetch) => {
+	return async (event, _context) => {
+		return buildResultFromResponseV2(await appFetch(buildRequestFromEventV2(event)));
+	};
+};
+const createHandlerV1 = (appFetch) => {
+	return async (event, _context) => {
+		return buildResultFromResponseV1(await appFetch(buildRequestFromEventV1(event)));
+	};
+};
+const onLambda = async (app, options = {}) => {
+	app.addFallbackConfig(LambdaEnvConfig);
+	const readyOptions = { warmup: options.warmup ?? false };
+	const resolver = await app.ready(readyOptions);
+	const handler = createHandlerV2(app.fetch);
+	const handlerV1 = createHandlerV1(app.fetch);
+	return {
+		...resolver,
+		handler,
+		handlerV1,
+		shutdown: app.shutdown
+	};
+};
+//#endregion
+export { LambdaEnvConfig, onLambda };
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../src/lambda-env.config.ts","../src/on-lambda.ts"],"sourcesContent":["import { Config, EnvConfig } from '@zeltjs/core';\n\n@Config\nexport class LambdaEnvConfig extends EnvConfig {\n  override get(key: string): string | undefined {\n    return process.env[key];\n  }\n}\n","import type { HttpApp, ReadyOptions, ReadyResult } from '@zeltjs/core';\nimport type {\n  APIGatewayProxyEvent,\n  APIGatewayProxyEventV2,\n  APIGatewayProxyResult,\n  APIGatewayProxyResultV2,\n  Context,\n} from 'aws-lambda';\n\nimport { LambdaEnvConfig } from './lambda-env.config';\n\nexport type LambdaAppOptions = {\n  readonly warmup?: boolean;\n};\n\nexport type LambdaHandlerV2 = (\n  event: APIGatewayProxyEventV2,\n  context: Context,\n) => Promise<APIGatewayProxyResultV2>;\n\nexport type LambdaHandlerV1 = (\n  event: APIGatewayProxyEvent,\n  context: Context,\n) => Promise<APIGatewayProxyResult>;\n\nexport type LambdaApp = ReadyResult & {\n  readonly handler: LambdaHandlerV2;\n  readonly handlerV1: LambdaHandlerV1;\n  readonly shutdown: () => Promise<void>;\n};\n\nconst buildHeadersFromRecord = (\n  headersRecord: Record<string, string | undefined> | undefined,\n): Headers => {\n  const headers = new Headers();\n  if (headersRecord) {\n    for (const [key, value] of Object.entries(headersRecord)) {\n      if (value) headers.set(key, value);\n    }\n  }\n  return headers;\n};\n\nconst buildBodyFromEvent = (\n  body: string | null | undefined,\n  isBase64Encoded: boolean,\n): BodyInit | null => {\n  if (!body) return null;\n  if (isBase64Encoded) {\n    const buffer = Buffer.from(body, 'base64');\n    return new Blob([buffer]);\n  }\n  return body;\n};\n\nconst buildRequestBody = (method: string, body: BodyInit | null): BodyInit | null => {\n  return method !== 'GET' && method !== 'HEAD' ? body : null;\n};\n\nconst buildRequestFromEventV2 = (event: APIGatewayProxyEventV2): Request => {\n  const headers = buildHeadersFromRecord(event.headers);\n\n  const protocol = headers.get('x-forwarded-proto') ?? 'https';\n  const host = event.requestContext.domainName;\n  const path = event.rawPath;\n  const queryString = event.rawQueryString ? `?${event.rawQueryString}` : '';\n  const url = `${protocol}://${host}${path}${queryString}`;\n\n  const method = event.requestContext.http.method;\n  const body = buildBodyFromEvent(event.body, event.isBase64Encoded);\n  const requestBody = buildRequestBody(method, body);\n\n  return new Request(url, {\n    method,\n    headers,\n    body: requestBody,\n  });\n};\n\nconst buildQueryStringFromParams = (\n  queryParams: Record<string, string | undefined> | null | undefined,\n): string => {\n  if (!queryParams) return '';\n  const params: Record<string, string> = {};\n  for (const [key, value] of Object.entries(queryParams)) {\n    if (value !== undefined) {\n      params[key] = value;\n    }\n  }\n  return `?${new URLSearchParams(params).toString()}`;\n};\n\nconst buildRequestFromEventV1 = (event: APIGatewayProxyEvent): Request => {\n  const headers = buildHeadersFromRecord(event.headers);\n\n  const protocol = headers.get('x-forwarded-proto') ?? 'https';\n  const host = headers.get('host') ?? 'localhost';\n  const path = event.path;\n\n  const queryString = buildQueryStringFromParams(event.queryStringParameters);\n  const url = `${protocol}://${host}${path}${queryString}`;\n\n  const method = event.httpMethod;\n  const body = buildBodyFromEvent(event.body, event.isBase64Encoded);\n  const requestBody = buildRequestBody(method, body);\n\n  return new Request(url, {\n    method,\n    headers,\n    body: requestBody,\n  });\n};\n\nconst buildResultFromResponseV2 = async (response: Response): Promise<APIGatewayProxyResultV2> => {\n  const headers: Record<string, string> = {};\n  response.headers.forEach((value, key) => {\n    headers[key] = value;\n  });\n\n  const contentType = response.headers.get('content-type') ?? '';\n  const isBinary =\n    contentType.startsWith('image/') ||\n    contentType.startsWith('audio/') ||\n    contentType.startsWith('video/') ||\n    contentType === 'application/octet-stream';\n\n  const body = isBinary\n    ? Buffer.from(await response.arrayBuffer()).toString('base64')\n    : await response.text();\n\n  return {\n    statusCode: response.status,\n    headers,\n    body,\n    isBase64Encoded: isBinary,\n  };\n};\n\nconst buildResultFromResponseV1 = async (response: Response): Promise<APIGatewayProxyResult> => {\n  const headers: Record<string, string> = {};\n  response.headers.forEach((value, key) => {\n    headers[key] = value;\n  });\n\n  const contentType = response.headers.get('content-type') ?? '';\n  const isBinary =\n    contentType.startsWith('image/') ||\n    contentType.startsWith('audio/') ||\n    contentType.startsWith('video/') ||\n    contentType === 'application/octet-stream';\n\n  const body = isBinary\n    ? Buffer.from(await response.arrayBuffer()).toString('base64')\n    : await response.text();\n\n  return {\n    statusCode: response.status,\n    headers,\n    body,\n    isBase64Encoded: isBinary,\n  };\n};\n\nconst createHandlerV2 = (appFetch: (request: Request) => Promise<Response>): LambdaHandlerV2 => {\n  return async (\n    event: APIGatewayProxyEventV2,\n    _context: Context,\n  ): Promise<APIGatewayProxyResultV2> => {\n    const request = buildRequestFromEventV2(event);\n    const response = await appFetch(request);\n    return buildResultFromResponseV2(response);\n  };\n};\n\nconst createHandlerV1 = (appFetch: (request: Request) => Promise<Response>): LambdaHandlerV1 => {\n  return async (event: APIGatewayProxyEvent, _context: Context): Promise<APIGatewayProxyResult> => {\n    const request = buildRequestFromEventV1(event);\n    const response = await appFetch(request);\n    return buildResultFromResponseV1(response);\n  };\n};\n\nexport const onLambda = async (\n  app: HttpApp,\n  options: LambdaAppOptions = {},\n): Promise<LambdaApp> => {\n  app.addFallbackConfig(LambdaEnvConfig);\n\n  const readyOptions: ReadyOptions = { warmup: options.warmup ?? false };\n  const resolver = await app.ready(readyOptions);\n\n  const handler = createHandlerV2(app.fetch);\n  const handlerV1 = createHandlerV1(app.fetch);\n\n  return {\n    ...resolver,\n    handler,\n    handlerV1,\n    shutdown: app.shutdown,\n  };\n};\n"],"mappings":"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"}

package/package.json

@@ -1,10 +1,38 @@
 {
   "name": "@zeltjs/adapter-lambda",
-  "version": "0.0.1",
-  "description": "OIDC trusted publishing setup package for @zeltjs/adapter-lambda",
-  "keywords": [
-    "oidc",
-    "trusted-publishing",
-    "setup"
-  ]
-}
+  "version": "0.4.0",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/zeltjs/zelt.git",
+    "directory": "packages/adapter-lambda"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@zeltjs/core": "0.4.0"
+  },
+  "devDependencies": {
+    "@types/aws-lambda": "8.10.150",
+    "@types/node": "22.19.17"
+  },
+  "volta": {
+    "extends": "../../package.json"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "test": "vitest run",
+    "typecheck": "tsc -b"
+  }
+}

package/README.md

@@ -1,45 +0,0 @@
-# @zeltjs/adapter-lambda
-
-## ⚠️ IMPORTANT NOTICE ⚠️
-
-**This package is created solely for the purpose of setting up OIDC (OpenID Connect) trusted publishing with npm.**
-
-This is **NOT** a functional package and contains **NO** code or functionality beyond the OIDC setup configuration.
-
-## Purpose
-
-This package exists to:
-1. Configure OIDC trusted publishing for the package name `@zeltjs/adapter-lambda`
-2. Enable secure, token-less publishing from CI/CD workflows
-3. Establish provenance for packages published under this name
-
-## What is OIDC Trusted Publishing?
-
-OIDC trusted publishing allows package maintainers to publish packages directly from their CI/CD workflows without needing to manage npm access tokens. Instead, it uses OpenID Connect to establish trust between the CI/CD provider (like GitHub Actions) and npm.
-
-## Setup Instructions
-
-To properly configure OIDC trusted publishing for this package:
-
-1. Go to [npmjs.com](https://www.npmjs.com/) and navigate to your package settings
-2. Configure the trusted publisher (e.g., GitHub Actions)
-3. Specify the repository and workflow that should be allowed to publish
-4. Use the configured workflow to publish your actual package
-
-## DO NOT USE THIS PACKAGE
-
-This package is a placeholder for OIDC configuration only. It:
-- Contains no executable code
-- Provides no functionality
-- Should not be installed as a dependency
-- Exists only for administrative purposes
-
-## More Information
-
-For more details about npm's trusted publishing feature, see:
-- [npm Trusted Publishing Documentation](https://docs.npmjs.com/generating-provenance-statements)
-- [GitHub Actions OIDC Documentation](https://docs.github.com/en/actions/deployment/security-hardening-your-deployments/about-security-hardening-with-openid-connect)
-
----
-
-**Maintained for OIDC setup purposes only**