@opennextjs/aws 3.1.4

package/dist/cache/incremental/types.d.ts

@@ -0,0 +1,34 @@
+import { Meta } from "../next-types";
+export type S3CachedFile = {
+    type: "redirect";
+    props?: Object;
+    meta?: Meta;
+} | {
+    type: "page";
+    html: string;
+    json: Object;
+    meta?: Meta;
+} | {
+    type: "app";
+    html: string;
+    rsc: string;
+    meta?: Meta;
+} | {
+    type: "route";
+    body: string;
+    meta?: Meta;
+};
+export type S3FetchCache = Object;
+export type WithLastModified<T> = {
+    lastModified?: number;
+    value?: T;
+};
+export type CacheValue<IsFetch extends boolean> = (IsFetch extends true ? S3FetchCache : S3CachedFile) & {
+    revalidate?: number | false;
+};
+export type IncrementalCache = {
+    get<IsFetch extends boolean = false>(key: string, isFetch?: IsFetch): Promise<WithLastModified<CacheValue<IsFetch>>>;
+    set<IsFetch extends boolean = false>(key: string, value: CacheValue<IsFetch>, isFetch?: IsFetch): Promise<void>;
+    delete(key: string): Promise<void>;
+    name: string;
+};

package/dist/cache/incremental/types.js

@@ -0,0 +1 @@
+export {};

package/dist/cache/next-types.d.ts

@@ -0,0 +1,62 @@
+/// <reference types="node" />
+interface CachedFetchValue {
+    kind: "FETCH";
+    data: {
+        headers: {
+            [k: string]: string;
+        };
+        body: string;
+        url: string;
+        status?: number;
+        tags?: string[];
+    };
+    revalidate: number;
+}
+interface CachedRedirectValue {
+    kind: "REDIRECT";
+    props: Object;
+}
+interface CachedRouteValue {
+    kind: "ROUTE";
+    body: Buffer;
+    status: number;
+    headers: Record<string, undefined | string | string[]>;
+}
+interface CachedImageValue {
+    kind: "IMAGE";
+    etag: string;
+    buffer: Buffer;
+    extension: string;
+    isMiss?: boolean;
+    isStale?: boolean;
+}
+interface IncrementalCachedPageValue {
+    kind: "PAGE";
+    html: string;
+    pageData: Object;
+    status?: number;
+    headers?: Record<string, undefined | string>;
+}
+type IncrementalCacheValue = CachedRedirectValue | IncrementalCachedPageValue | CachedImageValue | CachedFetchValue | CachedRouteValue;
+export interface CacheHandlerContext {
+    fs?: never;
+    dev?: boolean;
+    flushToDisk?: boolean;
+    serverDistDir?: string;
+    maxMemoryCacheSize?: number;
+    _appDir: boolean;
+    _requestHeaders: never;
+    fetchCacheKeyPrefix?: string;
+}
+export interface CacheHandlerValue {
+    lastModified?: number;
+    age?: number;
+    cacheState?: string;
+    value: IncrementalCacheValue | null;
+}
+export type Extension = "cache" | "fetch";
+export interface Meta {
+    status?: number;
+    headers?: Record<string, undefined | string | string[]>;
+}
+export {};

package/dist/cache/next-types.js

@@ -0,0 +1 @@
+export {};

package/dist/cache/tag/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const MAX_DYNAMO_BATCH_WRITE_ITEM_COUNT = 25;
+export declare const getDynamoBatchWriteCommandConcurrency: () => number;

package/dist/cache/tag/constants.js

@@ -0,0 +1,17 @@
+export const MAX_DYNAMO_BATCH_WRITE_ITEM_COUNT = 25;
+/**
+ * Sending to dynamo X commands at a time, using about X * 25 write units per batch to not overwhelm DDB
+ * and give production plenty of room to work with. With DDB Response times, you can expect about 10 batches per second.
+ */
+const DEFAULT_DYNAMO_BATCH_WRITE_COMMAND_CONCURRENCY = 4;
+export const getDynamoBatchWriteCommandConcurrency = () => {
+    const dynamoBatchWriteCommandConcurrencyFromEnv = process.env.DYNAMO_BATCH_WRITE_COMMAND_CONCURRENCY;
+    const parsedDynamoBatchWriteCommandConcurrencyFromEnv = dynamoBatchWriteCommandConcurrencyFromEnv
+        ? parseInt(dynamoBatchWriteCommandConcurrencyFromEnv)
+        : undefined;
+    if (parsedDynamoBatchWriteCommandConcurrencyFromEnv &&
+        !isNaN(parsedDynamoBatchWriteCommandConcurrencyFromEnv)) {
+        return parsedDynamoBatchWriteCommandConcurrencyFromEnv;
+    }
+    return DEFAULT_DYNAMO_BATCH_WRITE_COMMAND_CONCURRENCY;
+};

package/dist/cache/tag/dynamodb-lite.d.ts

@@ -0,0 +1,3 @@
+import { TagCache } from "./types";
+declare const tagCache: TagCache;
+export default tagCache;

package/dist/cache/tag/dynamodb-lite.js

@@ -0,0 +1,174 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+import { AwsClient } from "aws4fetch";
+import path from "path";
+import { RecoverableError } from "../../utils/error";
+import { customFetchClient } from "../../utils/fetch";
+import { debug, error } from "../../adapters/logger";
+import { chunk, parseNumberFromEnv } from "../../adapters/util";
+import { getDynamoBatchWriteCommandConcurrency, MAX_DYNAMO_BATCH_WRITE_ITEM_COUNT, } from "./constants";
+let awsClient = null;
+const getAwsClient = () => {
+    const { CACHE_BUCKET_REGION } = process.env;
+    if (awsClient) {
+        return awsClient;
+    }
+    else {
+        awsClient = new AwsClient({
+            accessKeyId: process.env.AWS_ACCESS_KEY_ID,
+            secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
+            sessionToken: process.env.AWS_SESSION_TOKEN,
+            region: CACHE_BUCKET_REGION,
+            retries: parseNumberFromEnv(process.env.AWS_SDK_S3_MAX_ATTEMPTS),
+        });
+        return awsClient;
+    }
+};
+const awsFetch = (body, type = "query") => {
+    const { CACHE_BUCKET_REGION } = process.env;
+    const client = getAwsClient();
+    return customFetchClient(client)(`https://dynamodb.${CACHE_BUCKET_REGION}.amazonaws.com`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/x-amz-json-1.0",
+            "X-Amz-Target": `DynamoDB_20120810.${type === "query" ? "Query" : "BatchWriteItem"}`,
+        },
+        body,
+    });
+};
+function buildDynamoKey(key) {
+    const { NEXT_BUILD_ID } = process.env;
+    // FIXME: We should probably use something else than path.join here
+    // this could transform some fetch cache key into a valid path
+    return path.posix.join(NEXT_BUILD_ID ?? "", key);
+}
+function buildDynamoObject(path, tags, revalidatedAt) {
+    return {
+        path: { S: buildDynamoKey(path) },
+        tag: { S: buildDynamoKey(tags) },
+        revalidatedAt: { N: `${revalidatedAt ?? Date.now()}` },
+    };
+}
+const tagCache = {
+    async getByPath(path) {
+        try {
+            if (globalThis.disableDynamoDBCache)
+                return [];
+            const { CACHE_DYNAMO_TABLE, NEXT_BUILD_ID } = process.env;
+            const result = await awsFetch(JSON.stringify({
+                TableName: CACHE_DYNAMO_TABLE,
+                IndexName: "revalidate",
+                KeyConditionExpression: "#key = :key",
+                ExpressionAttributeNames: {
+                    "#key": "path",
+                },
+                ExpressionAttributeValues: {
+                    ":key": { S: buildDynamoKey(path) },
+                },
+            }));
+            if (result.status !== 200) {
+                throw new RecoverableError(`Failed to get tags by path: ${result.status}`);
+            }
+            const { Items } = (await result.json());
+            const tags = Items?.map((item) => item.tag.S ?? "") ?? [];
+            debug("tags for path", path, tags);
+            // We need to remove the buildId from the path
+            return tags.map((tag) => tag.replace(`${NEXT_BUILD_ID}/`, ""));
+        }
+        catch (e) {
+            error("Failed to get tags by path", e);
+            return [];
+        }
+    },
+    async getByTag(tag) {
+        try {
+            if (globalThis.disableDynamoDBCache)
+                return [];
+            const { CACHE_DYNAMO_TABLE, NEXT_BUILD_ID } = process.env;
+            const result = await awsFetch(JSON.stringify({
+                TableName: CACHE_DYNAMO_TABLE,
+                KeyConditionExpression: "#tag = :tag",
+                ExpressionAttributeNames: {
+                    "#tag": "tag",
+                },
+                ExpressionAttributeValues: {
+                    ":tag": { S: buildDynamoKey(tag) },
+                },
+            }));
+            if (result.status !== 200) {
+                throw new RecoverableError(`Failed to get by tag: ${result.status}`);
+            }
+            const { Items } = (await result.json());
+            return (
+            // We need to remove the buildId from the path
+            Items?.map(({ path: { S: key } }) => key?.replace(`${NEXT_BUILD_ID}/`, "") ?? "") ?? []);
+        }
+        catch (e) {
+            error("Failed to get by tag", e);
+            return [];
+        }
+    },
+    async getLastModified(key, lastModified) {
+        try {
+            if (globalThis.disableDynamoDBCache)
+                return lastModified ?? Date.now();
+            const { CACHE_DYNAMO_TABLE } = process.env;
+            const result = await awsFetch(JSON.stringify({
+                TableName: CACHE_DYNAMO_TABLE,
+                IndexName: "revalidate",
+                KeyConditionExpression: "#key = :key AND #revalidatedAt > :lastModified",
+                ExpressionAttributeNames: {
+                    "#key": "path",
+                    "#revalidatedAt": "revalidatedAt",
+                },
+                ExpressionAttributeValues: {
+                    ":key": { S: buildDynamoKey(key) },
+                    ":lastModified": { N: String(lastModified ?? 0) },
+                },
+            }));
+            if (result.status !== 200) {
+                throw new RecoverableError(`Failed to get last modified: ${result.status}`);
+            }
+            const revalidatedTags = (await result.json()).Items ?? [];
+            debug("revalidatedTags", revalidatedTags);
+            // If we have revalidated tags we return -1 to force revalidation
+            return revalidatedTags.length > 0 ? -1 : lastModified ?? Date.now();
+        }
+        catch (e) {
+            error("Failed to get revalidated tags", e);
+            return lastModified ?? Date.now();
+        }
+    },
+    async writeTags(tags) {
+        try {
+            const { CACHE_DYNAMO_TABLE } = process.env;
+            if (globalThis.disableDynamoDBCache)
+                return;
+            const dataChunks = chunk(tags, MAX_DYNAMO_BATCH_WRITE_ITEM_COUNT).map((Items) => ({
+                RequestItems: {
+                    [CACHE_DYNAMO_TABLE ?? ""]: Items.map((Item) => ({
+                        PutRequest: {
+                            Item: {
+                                ...buildDynamoObject(Item.path, Item.tag, Item.revalidatedAt),
+                            },
+                        },
+                    })),
+                },
+            }));
+            const toInsert = chunk(dataChunks, getDynamoBatchWriteCommandConcurrency());
+            for (const paramsChunk of toInsert) {
+                await Promise.all(paramsChunk.map(async (params) => {
+                    const response = await awsFetch(JSON.stringify(params), "batchWrite");
+                    if (response.status !== 200) {
+                        throw new RecoverableError(`Failed to batch write dynamo item: ${response.status}`);
+                    }
+                    return response;
+                }));
+            }
+        }
+        catch (e) {
+            error("Failed to batch write dynamo item", e);
+        }
+    },
+    name: "dynamoDb",
+};
+export default tagCache;

package/dist/cache/tag/dynamodb.d.ts

@@ -0,0 +1,3 @@
+import { TagCache } from "./types";
+declare const tagCache: TagCache;
+export default tagCache;

package/dist/cache/tag/dynamodb.js

@@ -0,0 +1,129 @@
+import { BatchWriteItemCommand, DynamoDBClient, QueryCommand, } from "@aws-sdk/client-dynamodb";
+import path from "path";
+import { awsLogger, debug, error } from "../../adapters/logger";
+import { chunk, parseNumberFromEnv } from "../../adapters/util";
+import { getDynamoBatchWriteCommandConcurrency, MAX_DYNAMO_BATCH_WRITE_ITEM_COUNT, } from "./constants";
+const { CACHE_BUCKET_REGION, CACHE_DYNAMO_TABLE, NEXT_BUILD_ID } = process.env;
+function parseDynamoClientConfigFromEnv() {
+    return {
+        region: CACHE_BUCKET_REGION,
+        logger: awsLogger,
+        maxAttempts: parseNumberFromEnv(process.env.AWS_SDK_DYNAMODB_MAX_ATTEMPTS),
+    };
+}
+const dynamoClient = new DynamoDBClient(parseDynamoClientConfigFromEnv());
+function buildDynamoKey(key) {
+    // FIXME: We should probably use something else than path.join here
+    // this could transform some fetch cache key into a valid path
+    return path.posix.join(NEXT_BUILD_ID ?? "", key);
+}
+function buildDynamoObject(path, tags, revalidatedAt) {
+    return {
+        path: { S: buildDynamoKey(path) },
+        tag: { S: buildDynamoKey(tags) },
+        revalidatedAt: { N: `${revalidatedAt ?? Date.now()}` },
+    };
+}
+const tagCache = {
+    async getByPath(path) {
+        try {
+            if (globalThis.disableDynamoDBCache)
+                return [];
+            const result = await dynamoClient.send(new QueryCommand({
+                TableName: CACHE_DYNAMO_TABLE,
+                IndexName: "revalidate",
+                KeyConditionExpression: "#key = :key",
+                ExpressionAttributeNames: {
+                    "#key": "path",
+                },
+                ExpressionAttributeValues: {
+                    ":key": { S: buildDynamoKey(path) },
+                },
+            }));
+            const tags = result.Items?.map((item) => item.tag.S ?? "") ?? [];
+            debug("tags for path", path, tags);
+            // We need to remove the buildId from the path
+            return tags.map((tag) => tag.replace(`${NEXT_BUILD_ID}/`, ""));
+        }
+        catch (e) {
+            error("Failed to get tags by path", e);
+            return [];
+        }
+    },
+    async getByTag(tag) {
+        try {
+            if (globalThis.disableDynamoDBCache)
+                return [];
+            const { Items } = await dynamoClient.send(new QueryCommand({
+                TableName: CACHE_DYNAMO_TABLE,
+                KeyConditionExpression: "#tag = :tag",
+                ExpressionAttributeNames: {
+                    "#tag": "tag",
+                },
+                ExpressionAttributeValues: {
+                    ":tag": { S: buildDynamoKey(tag) },
+                },
+            }));
+            return (
+            // We need to remove the buildId from the path
+            Items?.map(({ path: { S: key } }) => key?.replace(`${NEXT_BUILD_ID}/`, "") ?? "") ?? []);
+        }
+        catch (e) {
+            error("Failed to get by tag", e);
+            return [];
+        }
+    },
+    async getLastModified(key, lastModified) {
+        try {
+            if (globalThis.disableDynamoDBCache)
+                return lastModified ?? Date.now();
+            const result = await dynamoClient.send(new QueryCommand({
+                TableName: CACHE_DYNAMO_TABLE,
+                IndexName: "revalidate",
+                KeyConditionExpression: "#key = :key AND #revalidatedAt > :lastModified",
+                ExpressionAttributeNames: {
+                    "#key": "path",
+                    "#revalidatedAt": "revalidatedAt",
+                },
+                ExpressionAttributeValues: {
+                    ":key": { S: buildDynamoKey(key) },
+                    ":lastModified": { N: String(lastModified ?? 0) },
+                },
+            }));
+            const revalidatedTags = result.Items ?? [];
+            debug("revalidatedTags", revalidatedTags);
+            // If we have revalidated tags we return -1 to force revalidation
+            return revalidatedTags.length > 0 ? -1 : lastModified ?? Date.now();
+        }
+        catch (e) {
+            error("Failed to get revalidated tags", e);
+            return lastModified ?? Date.now();
+        }
+    },
+    async writeTags(tags) {
+        try {
+            if (globalThis.disableDynamoDBCache)
+                return;
+            const dataChunks = chunk(tags, MAX_DYNAMO_BATCH_WRITE_ITEM_COUNT).map((Items) => ({
+                RequestItems: {
+                    [CACHE_DYNAMO_TABLE ?? ""]: Items.map((Item) => ({
+                        PutRequest: {
+                            Item: {
+                                ...buildDynamoObject(Item.path, Item.tag, Item.revalidatedAt),
+                            },
+                        },
+                    })),
+                },
+            }));
+            const toInsert = chunk(dataChunks, getDynamoBatchWriteCommandConcurrency());
+            for (const paramsChunk of toInsert) {
+                await Promise.all(paramsChunk.map(async (params) => dynamoClient.send(new BatchWriteItemCommand(params))));
+            }
+        }
+        catch (e) {
+            error("Failed to batch write dynamo item", e);
+        }
+    },
+    name: "dynamoDb",
+};
+export default tagCache;

package/dist/cache/tag/types.d.ts

@@ -0,0 +1,11 @@
+export type TagCache = {
+    getByTag(tag: string): Promise<string[]>;
+    getByPath(path: string): Promise<string[]>;
+    getLastModified(path: string, lastModified?: number): Promise<number>;
+    writeTags(tags: {
+        tag: string;
+        path: string;
+        revalidatedAt?: number;
+    }[]): Promise<void>;
+    name: string;
+};

package/dist/cache/tag/types.js

@@ -0,0 +1 @@
+export {};

package/dist/converters/aws-apigw-v1.d.ts

@@ -0,0 +1,3 @@
+import type { Converter, InternalEvent, InternalResult } from "../types/open-next";
+declare const _default: Converter<InternalEvent, InternalResult>;
+export default _default;

package/dist/converters/aws-apigw-v1.js

@@ -0,0 +1,89 @@
+import { fromReadableStream } from "../utils/stream";
+import { debug } from "../adapters/logger";
+import { removeUndefinedFromQuery } from "./utils";
+function normalizeAPIGatewayProxyEventHeaders(event) {
+    event.multiValueHeaders;
+    const headers = {};
+    for (const [key, values] of Object.entries(event.multiValueHeaders || {})) {
+        if (values) {
+            headers[key.toLowerCase()] = values.join(",");
+        }
+    }
+    for (const [key, value] of Object.entries(event.headers || {})) {
+        if (value) {
+            headers[key.toLowerCase()] = value;
+        }
+    }
+    return headers;
+}
+function normalizeAPIGatewayProxyEventQueryParams(event) {
+    // Note that the same query string values are returned in both
+    // "multiValueQueryStringParameters" and "queryStringParameters".
+    // We only need to use one of them.
+    // For example:
+    //   "?name=foo" appears in the event object as
+    //   {
+    //     ...
+    //     queryStringParameters: { name: 'foo' },
+    //     multiValueQueryStringParameters: { name: [ 'foo' ] },
+    //     ...
+    //   }
+    const params = new URLSearchParams();
+    for (const [key, value] of Object.entries(event.multiValueQueryStringParameters || {})) {
+        if (value !== undefined) {
+            for (const v of value) {
+                params.append(key, v);
+            }
+        }
+    }
+    const value = params.toString();
+    return value ? `?${value}` : "";
+}
+async function convertFromAPIGatewayProxyEvent(event) {
+    const { path, body, httpMethod, requestContext, isBase64Encoded } = event;
+    return {
+        type: "core",
+        method: httpMethod,
+        rawPath: path,
+        url: path + normalizeAPIGatewayProxyEventQueryParams(event),
+        body: Buffer.from(body ?? "", isBase64Encoded ? "base64" : "utf8"),
+        headers: normalizeAPIGatewayProxyEventHeaders(event),
+        remoteAddress: requestContext.identity.sourceIp,
+        query: removeUndefinedFromQuery(event.multiValueQueryStringParameters ?? {}),
+        cookies: event.multiValueHeaders?.cookie?.reduce((acc, cur) => {
+            const [key, value] = cur.split("=");
+            return { ...acc, [key]: value };
+        }, {}) ?? {},
+    };
+}
+async function convertToApiGatewayProxyResult(result) {
+    const headers = {};
+    const multiValueHeaders = {};
+    Object.entries(result.headers).forEach(([key, value]) => {
+        if (Array.isArray(value)) {
+            multiValueHeaders[key] = value;
+        }
+        else {
+            if (value === null) {
+                headers[key] = "";
+                return;
+            }
+            headers[key] = value;
+        }
+    });
+    const body = await fromReadableStream(result.body, result.isBase64Encoded);
+    const response = {
+        statusCode: result.statusCode,
+        headers,
+        body,
+        isBase64Encoded: result.isBase64Encoded,
+        multiValueHeaders,
+    };
+    debug(response);
+    return response;
+}
+export default {
+    convertFrom: convertFromAPIGatewayProxyEvent,
+    convertTo: convertToApiGatewayProxyResult,
+    name: "aws-apigw-v1",
+};

package/dist/converters/aws-apigw-v2.d.ts

@@ -0,0 +1,3 @@
+import type { Converter, InternalEvent, InternalResult } from "../types/open-next";
+declare const _default: Converter<InternalEvent, InternalResult>;
+export default _default;

package/dist/converters/aws-apigw-v2.js

@@ -0,0 +1,99 @@
+import { parseCookies } from "../http/util";
+import { fromReadableStream } from "../utils/stream";
+import { debug } from "../adapters/logger";
+import { convertToQuery } from "../core/routing/util";
+import { removeUndefinedFromQuery } from "./utils";
+// Not sure which one is reallly needed as this is not documented anywhere but server actions redirect are not working without this, it causes a 500 error from cloudfront itself with a 'x-amzErrortype: InternalFailure' header
+const CloudFrontBlacklistedHeaders = [
+    "connection",
+    "expect",
+    "keep-alive",
+    "proxy-authenticate",
+    "proxy-authorization",
+    "proxy-connection",
+    "trailer",
+    "upgrade",
+    "x-accel-buffering",
+    "x-accel-charset",
+    "x-accel-limit-rate",
+    "x-accel-redirect",
+    /x-amz-cf-(.*)/,
+    /x-amzn-(.*)/,
+    /x-edge-(.*)/,
+    "x-cache",
+    "x-forwarded-proto",
+    "x-real-ip",
+    "set-cookie",
+    "age",
+    "via",
+];
+function normalizeAPIGatewayProxyEventV2Body(event) {
+    const { body, isBase64Encoded } = event;
+    if (Buffer.isBuffer(body)) {
+        return body;
+    }
+    else if (typeof body === "string") {
+        return Buffer.from(body, isBase64Encoded ? "base64" : "utf8");
+    }
+    else if (typeof body === "object") {
+        return Buffer.from(JSON.stringify(body));
+    }
+    else {
+        return Buffer.from("", "utf8");
+    }
+}
+function normalizeAPIGatewayProxyEventV2Headers(event) {
+    const { headers: rawHeaders, cookies } = event;
+    const headers = {};
+    if (Array.isArray(cookies)) {
+        headers["cookie"] = cookies.join("; ");
+    }
+    for (const [key, value] of Object.entries(rawHeaders || {})) {
+        headers[key.toLowerCase()] = value;
+    }
+    return headers;
+}
+async function convertFromAPIGatewayProxyEventV2(event) {
+    const { rawPath, rawQueryString, requestContext } = event;
+    return {
+        type: "core",
+        method: requestContext.http.method,
+        rawPath,
+        url: rawPath + (rawQueryString ? `?${rawQueryString}` : ""),
+        body: normalizeAPIGatewayProxyEventV2Body(event),
+        headers: normalizeAPIGatewayProxyEventV2Headers(event),
+        remoteAddress: requestContext.http.sourceIp,
+        query: removeUndefinedFromQuery(convertToQuery(rawQueryString)),
+        cookies: event.cookies?.reduce((acc, cur) => {
+            const [key, value] = cur.split("=");
+            return { ...acc, [key]: value };
+        }, {}) ?? {},
+    };
+}
+async function convertToApiGatewayProxyResultV2(result) {
+    const headers = {};
+    Object.entries(result.headers)
+        .filter(([key]) => !CloudFrontBlacklistedHeaders.some((header) => typeof header === "string" ? header === key : header.test(key)))
+        .forEach(([key, value]) => {
+        if (value === null || value === undefined) {
+            headers[key] = "";
+            return;
+        }
+        headers[key] = Array.isArray(value) ? value.join(", ") : `${value}`;
+    });
+    const body = await fromReadableStream(result.body, result.isBase64Encoded);
+    const response = {
+        statusCode: result.statusCode,
+        headers,
+        cookies: parseCookies(result.headers["set-cookie"]),
+        body,
+        isBase64Encoded: result.isBase64Encoded,
+    };
+    debug(response);
+    return response;
+}
+export default {
+    convertFrom: convertFromAPIGatewayProxyEventV2,
+    convertTo: convertToApiGatewayProxyResultV2,
+    name: "aws-apigw-v2",
+};

package/dist/converters/aws-cloudfront.d.ts

@@ -0,0 +1,3 @@
+import type { Converter, InternalEvent, InternalResult } from "../types/open-next";
+declare const _default: Converter<InternalEvent, InternalResult>;
+export default _default;