@temporary-name/standard-server-aws-lambda 1.9.3-alpha.03e17aa3340f4b261a549bf9e3fe948b084e2309

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Stainless
+
+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,3 @@
+## `@temporary-name/standard-server-aws-lambda`
+
+[AWS Lambda](https://aws.amazon.com/lambda/) server adapter for oRPC.

package/dist/index.d.mts

@@ -0,0 +1,66 @@
+import Stream, { Readable } from 'node:stream';
+import { StandardBody, StandardHeaders, StandardLazyRequest, StandardResponse } from '@temporary-name/standard-server';
+import { ToNodeHttpBodyOptions } from '@temporary-name/standard-server-node';
+export { ToEventStreamOptions, toAbortSignal, toEventStream } from '@temporary-name/standard-server-node';
+import { ToEventIteratorOptions as ToEventIteratorOptions$1 } from '@temporary-name/standard-server-fetch';
+
+interface ToEventIteratorOptions extends ToEventIteratorOptions$1 {
+}
+declare function toEventIterator(body: string | undefined, options?: ToEventIteratorOptions): AsyncIteratorObject<unknown | void, unknown | void, void> & AsyncGenerator<unknown | void, unknown | void, void>;
+
+interface APIGatewayProxyEventHeaders {
+    [name: string]: string | undefined;
+}
+interface APIGatewayProxyEventPathParameters {
+    [name: string]: string | undefined;
+}
+interface APIGatewayProxyEventQueryStringParameters {
+    [name: string]: string | undefined;
+}
+interface APIGatewayProxyEventStageVariables {
+    [name: string]: string | undefined;
+}
+interface APIGatewayProxyEventV2 {
+    version: string;
+    routeKey: string;
+    rawPath: string;
+    rawQueryString: string;
+    cookies?: string[];
+    headers: APIGatewayProxyEventHeaders;
+    queryStringParameters?: APIGatewayProxyEventQueryStringParameters;
+    requestContext: {
+        domainName: string;
+        http: {
+            method: string;
+            path: string;
+            protocol: string;
+        };
+    };
+    body?: string;
+    pathParameters?: APIGatewayProxyEventPathParameters;
+    isBase64Encoded: boolean;
+    stageVariables?: APIGatewayProxyEventStageVariables;
+}
+
+interface ToStandardBodyOptions extends ToEventIteratorOptions {
+}
+declare function toStandardBody(event: APIGatewayProxyEventV2, options?: ToStandardBodyOptions): Promise<StandardBody>;
+interface ToLambdaBodyOptions extends ToNodeHttpBodyOptions {
+}
+declare function toLambdaBody(standardBody: StandardBody, standardHeaders: StandardHeaders, options?: ToLambdaBodyOptions): [body: undefined | string | Readable, headers: StandardHeaders];
+
+declare function toStandardHeaders(headers: APIGatewayProxyEventHeaders, cookies: string[] | undefined): StandardHeaders;
+declare function toLambdaHeaders(standard: StandardHeaders): [headers: APIGatewayProxyEventHeaders, setCookies: string[]];
+
+declare function toStandardLazyRequest(event: APIGatewayProxyEventV2, responseStream: Stream.Writable): StandardLazyRequest;
+
+interface SendStandardResponseOptions extends ToLambdaBodyOptions {
+}
+declare function sendStandardResponse(responseStream: Stream.Writable, standardResponse: StandardResponse, options?: SendStandardResponseOptions): Promise<void>;
+
+declare function toStandardUrl(event: APIGatewayProxyEventV2): URL;
+
+type ResponseStream = Stream.Writable;
+
+export { sendStandardResponse, toEventIterator, toLambdaBody, toLambdaHeaders, toStandardBody, toStandardHeaders, toStandardLazyRequest, toStandardUrl };
+export type { APIGatewayProxyEventHeaders, APIGatewayProxyEventPathParameters, APIGatewayProxyEventQueryStringParameters, APIGatewayProxyEventStageVariables, APIGatewayProxyEventV2, ResponseStream, SendStandardResponseOptions, ToEventIteratorOptions, ToLambdaBodyOptions, ToStandardBodyOptions };

package/dist/index.d.ts

@@ -0,0 +1,66 @@
+import Stream, { Readable } from 'node:stream';
+import { StandardBody, StandardHeaders, StandardLazyRequest, StandardResponse } from '@temporary-name/standard-server';
+import { ToNodeHttpBodyOptions } from '@temporary-name/standard-server-node';
+export { ToEventStreamOptions, toAbortSignal, toEventStream } from '@temporary-name/standard-server-node';
+import { ToEventIteratorOptions as ToEventIteratorOptions$1 } from '@temporary-name/standard-server-fetch';
+
+interface ToEventIteratorOptions extends ToEventIteratorOptions$1 {
+}
+declare function toEventIterator(body: string | undefined, options?: ToEventIteratorOptions): AsyncIteratorObject<unknown | void, unknown | void, void> & AsyncGenerator<unknown | void, unknown | void, void>;
+
+interface APIGatewayProxyEventHeaders {
+    [name: string]: string | undefined;
+}
+interface APIGatewayProxyEventPathParameters {
+    [name: string]: string | undefined;
+}
+interface APIGatewayProxyEventQueryStringParameters {
+    [name: string]: string | undefined;
+}
+interface APIGatewayProxyEventStageVariables {
+    [name: string]: string | undefined;
+}
+interface APIGatewayProxyEventV2 {
+    version: string;
+    routeKey: string;
+    rawPath: string;
+    rawQueryString: string;
+    cookies?: string[];
+    headers: APIGatewayProxyEventHeaders;
+    queryStringParameters?: APIGatewayProxyEventQueryStringParameters;
+    requestContext: {
+        domainName: string;
+        http: {
+            method: string;
+            path: string;
+            protocol: string;
+        };
+    };
+    body?: string;
+    pathParameters?: APIGatewayProxyEventPathParameters;
+    isBase64Encoded: boolean;
+    stageVariables?: APIGatewayProxyEventStageVariables;
+}
+
+interface ToStandardBodyOptions extends ToEventIteratorOptions {
+}
+declare function toStandardBody(event: APIGatewayProxyEventV2, options?: ToStandardBodyOptions): Promise<StandardBody>;
+interface ToLambdaBodyOptions extends ToNodeHttpBodyOptions {
+}
+declare function toLambdaBody(standardBody: StandardBody, standardHeaders: StandardHeaders, options?: ToLambdaBodyOptions): [body: undefined | string | Readable, headers: StandardHeaders];
+
+declare function toStandardHeaders(headers: APIGatewayProxyEventHeaders, cookies: string[] | undefined): StandardHeaders;
+declare function toLambdaHeaders(standard: StandardHeaders): [headers: APIGatewayProxyEventHeaders, setCookies: string[]];
+
+declare function toStandardLazyRequest(event: APIGatewayProxyEventV2, responseStream: Stream.Writable): StandardLazyRequest;
+
+interface SendStandardResponseOptions extends ToLambdaBodyOptions {
+}
+declare function sendStandardResponse(responseStream: Stream.Writable, standardResponse: StandardResponse, options?: SendStandardResponseOptions): Promise<void>;
+
+declare function toStandardUrl(event: APIGatewayProxyEventV2): URL;
+
+type ResponseStream = Stream.Writable;
+
+export { sendStandardResponse, toEventIterator, toLambdaBody, toLambdaHeaders, toStandardBody, toStandardHeaders, toStandardLazyRequest, toStandardUrl };
+export type { APIGatewayProxyEventHeaders, APIGatewayProxyEventPathParameters, APIGatewayProxyEventQueryStringParameters, APIGatewayProxyEventStageVariables, APIGatewayProxyEventV2, ResponseStream, SendStandardResponseOptions, ToEventIteratorOptions, ToLambdaBodyOptions, ToStandardBodyOptions };

package/dist/index.mjs

@@ -0,0 +1,131 @@
+import { runWithSpan, parseEmptyableJSON, toArray, once } from '@temporary-name/shared';
+import { getFilenameFromContentDisposition, flattenHeader } from '@temporary-name/standard-server';
+import { toNodeHttpBody, toAbortSignal } from '@temporary-name/standard-server-node';
+export { toAbortSignal, toEventStream } from '@temporary-name/standard-server-node';
+import { Buffer } from 'node:buffer';
+import { toEventIterator as toEventIterator$1 } from '@temporary-name/standard-server-fetch';
+
+function toEventIterator(body, options = {}) {
+  const stream = body ? new Blob([body]).stream() : null;
+  return toEventIterator$1(stream, options);
+}
+
+function toStandardBody(event, options = {}) {
+  return runWithSpan({ name: "parse_standard_body", signal: options.signal }, async () => {
+    const contentType = event.headers["content-type"];
+    const contentDisposition = event.headers["content-disposition"];
+    if (typeof contentDisposition === "string") {
+      const fileName = getFilenameFromContentDisposition(contentDisposition) ?? "blob";
+      return _parseAsFile(event.body, event.isBase64Encoded, fileName, contentType ?? "");
+    }
+    if (!contentType || contentType.startsWith("application/json")) {
+      const text = _parseAsString(event.body, event.isBase64Encoded);
+      return parseEmptyableJSON(text);
+    }
+    if (contentType.startsWith("multipart/form-data")) {
+      return _parseAsFormData(event.body, event.isBase64Encoded, contentType);
+    }
+    if (contentType.startsWith("application/x-www-form-urlencoded")) {
+      return new URLSearchParams(_parseAsString(event.body, event.isBase64Encoded));
+    }
+    if (contentType.startsWith("text/event-stream")) {
+      return toEventIterator(_parseAsString(event.body, event.isBase64Encoded), options);
+    }
+    if (contentType.startsWith("text/plain")) {
+      return _parseAsString(event.body, event.isBase64Encoded);
+    }
+    return _parseAsFile(event.body, event.isBase64Encoded, "blob", contentType);
+  });
+}
+function toLambdaBody(standardBody, standardHeaders, options = {}) {
+  standardHeaders = { ...standardHeaders };
+  const body = toNodeHttpBody(standardBody, standardHeaders, options);
+  return [body, standardHeaders];
+}
+function _parseAsFile(body, isBase64Encoded, fileName, contentType) {
+  return new File(
+    body === void 0 ? [] : [isBase64Encoded ? Buffer.from(body, "base64") : body],
+    fileName,
+    { type: contentType }
+  );
+}
+function _parseAsString(body, isBase64Encoded) {
+  return isBase64Encoded && body !== void 0 ? Buffer.from(body, "base64").toString() : body;
+}
+function _parseAsFormData(body, isBase64Encoded, contentType) {
+  const blobPart = isBase64Encoded && body !== void 0 ? Buffer.from(body, "base64") : body;
+  const response = new Response(blobPart, {
+    headers: {
+      "content-type": contentType
+    }
+  });
+  return response.formData();
+}
+
+function toStandardHeaders(headers, cookies) {
+  return {
+    ...headers,
+    "set-cookie": cookies
+  };
+}
+function toLambdaHeaders(standard) {
+  const headers = {};
+  const setCookies = [];
+  for (const key in standard) {
+    const value = standard[key];
+    if (value === void 0) {
+      continue;
+    }
+    if (key === "set-cookie") {
+      setCookies.push(...toArray(value));
+    } else {
+      headers[key] = flattenHeader(value);
+    }
+  }
+  return [headers, setCookies];
+}
+
+function toStandardUrl(event) {
+  return new URL(`https://${event.requestContext.domainName}${event.rawPath}?${event.rawQueryString}`);
+}
+
+function toStandardLazyRequest(event, responseStream) {
+  const signal = toAbortSignal(responseStream);
+  return {
+    url: toStandardUrl(event),
+    method: event.requestContext.http.method,
+    headers: toStandardHeaders(event.headers, event.cookies),
+    signal,
+    body: once(() => toStandardBody(event, { signal }))
+  };
+}
+
+function sendStandardResponse(responseStream, standardResponse, options = {}) {
+  return new Promise((resolve, reject) => {
+    responseStream.once("error", reject);
+    responseStream.once("close", resolve);
+    const [body, standardHeaders] = toLambdaBody(standardResponse.body, standardResponse.headers, options);
+    const [headers, setCookies] = toLambdaHeaders(standardHeaders);
+    globalThis.awslambda.HttpResponseStream.from(responseStream, {
+      statusCode: standardResponse.status,
+      headers,
+      cookies: setCookies
+    });
+    if (body === void 0) {
+      responseStream.end();
+    } else if (typeof body === "string") {
+      responseStream.write(body);
+      responseStream.end();
+    } else {
+      responseStream.once("close", () => {
+        if (!body.closed) {
+          body.destroy(responseStream.errored ?? void 0);
+        }
+      });
+      body.once("error", (error) => responseStream.destroy(error));
+      body.pipe(responseStream);
+    }
+  });
+}
+
+export { sendStandardResponse, toEventIterator, toLambdaBody, toLambdaHeaders, toStandardBody, toStandardHeaders, toStandardLazyRequest, toStandardUrl };

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@temporary-name/standard-server-aws-lambda",
+  "type": "module",
+  "version": "1.9.3-alpha.03e17aa3340f4b261a549bf9e3fe948b084e2309",
+  "license": "MIT",
+  "homepage": "https://www.stainless.com/",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/stainless-api/krusty.git",
+    "directory": "packages/standard-server-aws-lambda"
+  },
+  "keywords": [
+    "krusty"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@temporary-name/shared": "1.9.3-alpha.03e17aa3340f4b261a549bf9e3fe948b084e2309",
+    "@temporary-name/standard-server": "1.9.3-alpha.03e17aa3340f4b261a549bf9e3fe948b084e2309",
+    "@temporary-name/standard-server-fetch": "1.9.3-alpha.03e17aa3340f4b261a549bf9e3fe948b084e2309",
+    "@temporary-name/standard-server-node": "1.9.3-alpha.03e17aa3340f4b261a549bf9e3fe948b084e2309"
+  },
+  "devDependencies": {
+    "@types/aws-lambda": "^8.10.153",
+    "@types/node": "^22.15.30"
+  },
+  "scripts": {
+    "build": "unbuild",
+    "build:watch": "pnpm run build --watch",
+    "type:check": "tsc -b"
+  }
+}