@opennextjs/aws 3.1.4

package/dist/index.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+import { build } from "./build.js";
+const command = process.argv[2];
+if (command !== "build")
+    printHelp();
+const args = parseArgs();
+if (Object.keys(args).includes("--help"))
+    printHelp();
+await build(args["--config-path"], args["--node-externals"]);
+function parseArgs() {
+    return process.argv.slice(2).reduce((acc, key, ind, self) => {
+        if (key.startsWith("--")) {
+            if (self[ind + 1] && self[ind + 1].startsWith("-")) {
+                acc[key] = undefined;
+            }
+            else if (self[ind + 1]) {
+                acc[key] = self[ind + 1];
+            }
+            else if (!self[ind + 1]) {
+                acc[key] = undefined;
+            }
+        }
+        return acc;
+    }, {});
+}
+function printHelp() {
+    console.log("Unknown command");
+    console.log("");
+    console.log("Usage:");
+    console.log("  npx open-next build");
+    console.log("You can use a custom config path here");
+    console.log("  npx open-next build --config-path ./path/to/open-next.config.ts");
+    console.log("You can configure externals for the esbuild compilation of the open-next.config.ts file");
+    console.log("  npx open-next build --node-externals aws-sdk,sharp,sqlite3");
+    console.log("");
+    process.exit(1);
+}

package/dist/logger.d.ts

@@ -0,0 +1,12 @@
+type LEVEL = "info" | "debug";
+declare const _default: {
+    setLevel: (level: LEVEL) => LEVEL;
+    debug: (...args: any[]) => void;
+    info: {
+        (...data: any[]): void;
+        (message?: any, ...optionalParams: any[]): void;
+    };
+    warn: (...args: any[]) => void;
+    error: (...args: any[]) => void;
+};
+export default _default;

package/dist/logger.js

@@ -0,0 +1,13 @@
+import chalk from "chalk";
+let logLevel = "info";
+export default {
+    setLevel: (level) => (logLevel = level),
+    debug: (...args) => {
+        if (logLevel !== "debug")
+            return;
+        console.log(chalk.magenta("DEBUG"), ...args);
+    },
+    info: console.log,
+    warn: (...args) => console.warn(chalk.yellow("WARN"), ...args),
+    error: (...args) => console.error(chalk.red("ERROR"), ...args),
+};

package/dist/minimize-js.d.ts

@@ -0,0 +1 @@
+export declare function minifyAll(dir: any, opts: any): Promise<void>;

package/dist/minimize-js.js

@@ -0,0 +1,101 @@
+// Copied and modified from node-minify-all-js by Adones Pitogo
+// https://github.com/adonespitogo/node-minify-all-js/blob/master/index.js
+// @ts-nocheck
+import fs from "node:fs/promises";
+import path from "node:path";
+import minify from "@node-minify/core";
+import terser from "@node-minify/terser";
+var failed_files = [];
+var total_files = 0;
+var options = {};
+const promiseSeries = async (tasks, initial) => {
+    if (!Array.isArray(tasks)) {
+        return Promise.reject(new TypeError("promise.series only accepts an array of functions"));
+    }
+    return tasks.reduce((current, next) => {
+        return current.then(next);
+    }, Promise.resolve(initial));
+};
+const minifyJS = async (file) => {
+    total_files++;
+    try {
+        await minify({
+            compressor: terser,
+            input: file,
+            output: file,
+            options: {
+                module: options.module,
+                mangle: options.mangle,
+                compress: { reduce_vars: false },
+            },
+        });
+    }
+    catch (e) {
+        failed_files.push(file);
+    }
+    //process.stdout.write(".");
+};
+const minifyJSON = async (file) => {
+    try {
+        if (options.compress_json || options.packagejson) {
+            total_files++;
+            var is_package_json = file.indexOf("package.json") > -1;
+            var data = await fs.readFile(file, "utf8");
+            var json = JSON.parse(data);
+            var new_json = {};
+            if (options.packagejson && is_package_json) {
+                var { name, version, bin, main, binary, engines } = json;
+                new_json = { name, version };
+                if (bin)
+                    new_json.bin = bin;
+                if (binary)
+                    new_json.binary = binary;
+                if (main)
+                    new_json.main = main;
+                if (engines)
+                    new_json.engines = engines;
+            }
+            else {
+                new_json = json;
+            }
+            await fs.writeFile(file, JSON.stringify(new_json));
+        }
+    }
+    catch (e) { }
+    //process.stdout.write(".");
+};
+const walk = async (currentDirPath) => {
+    var js_files = [];
+    var json_files = [];
+    var dirs = [];
+    var current_dirs = await fs.readdir(currentDirPath);
+    for (const name of current_dirs) {
+        var filePath = path.join(currentDirPath, name);
+        var stat = await fs.stat(filePath);
+        var is_bin = /\.bin$/;
+        if (stat.isFile()) {
+            if (filePath.substr(-5) === ".json")
+                json_files.push(filePath);
+            else if (filePath.substr(-3) === ".js" || options.all_js)
+                js_files.push(filePath);
+        }
+        else if (stat.isDirectory() && !is_bin.test(filePath)) {
+            dirs.push(filePath);
+        }
+    }
+    var js_promise = Promise.all(js_files.map((f) => minifyJS(f)));
+    var json_promise = Promise.all(json_files.map((f) => minifyJSON(f)));
+    await Promise.all([js_promise, json_promise]);
+    await promiseSeries(dirs.map((dir) => () => walk(dir)));
+};
+export async function minifyAll(dir, opts) {
+    Object.assign(options, opts || {});
+    //console.log("minify-all-js options:\n", JSON.stringify(options, null, 2));
+    await walk(dir);
+    //process.stdout.write(".\n");
+    //console.log("Total found files: " + total_files);
+    if (failed_files.length) {
+        console.log(`\n\nFailed to minify files:`);
+        failed_files.forEach((f) => console.log("\t" + f));
+    }
+}

package/dist/overrides/imageLoader/host.d.ts

@@ -0,0 +1,3 @@
+import { ImageLoader } from "../../types/open-next";
+declare const hostLoader: ImageLoader;
+export default hostLoader;

package/dist/overrides/imageLoader/host.js

@@ -0,0 +1,29 @@
+import { Readable } from "node:stream";
+import { FatalError } from "../../utils/error";
+const hostLoader = {
+    name: "host",
+    load: async (key) => {
+        const host = process.env.HOST;
+        if (!host) {
+            throw new FatalError("Host must be defined!");
+        }
+        const url = `https://${host}${key}`;
+        const response = await fetch(url);
+        if (!response.ok) {
+            throw new FatalError(`Failed to fetch image from ${url}`);
+        }
+        if (!response.body) {
+            throw new FatalError("No body in response");
+        }
+        const body = Readable.fromWeb(response.body);
+        const contentType = response.headers.get("content-type") ?? "image/jpeg";
+        const cacheControl = response.headers.get("cache-control") ??
+            "private, max-age=0, must-revalidate";
+        return {
+            body,
+            contentType,
+            cacheControl,
+        };
+    },
+};
+export default hostLoader;

package/dist/overrides/imageLoader/s3.d.ts

@@ -0,0 +1,3 @@
+import { ImageLoader } from "../../types/open-next";
+declare const s3Loader: ImageLoader;
+export default s3Loader;

package/dist/overrides/imageLoader/s3.js

@@ -0,0 +1,33 @@
+import { GetObjectCommand, S3Client } from "@aws-sdk/client-s3";
+import { FatalError } from "../../utils/error";
+import { awsLogger } from "../../adapters/logger";
+const { BUCKET_NAME, BUCKET_KEY_PREFIX } = process.env;
+function ensureBucketExists() {
+    if (!BUCKET_NAME) {
+        throw new Error("Bucket name must be defined!");
+    }
+}
+const s3Loader = {
+    name: "s3",
+    load: async (key) => {
+        const s3Client = new S3Client({ logger: awsLogger });
+        ensureBucketExists();
+        const keyPrefix = BUCKET_KEY_PREFIX?.replace(/^\/|\/$/g, "");
+        const response = await s3Client.send(new GetObjectCommand({
+            Bucket: BUCKET_NAME,
+            Key: keyPrefix
+                ? keyPrefix + "/" + key.replace(/^\//, "")
+                : key.replace(/^\//, ""),
+        }));
+        const body = response.Body;
+        if (!body) {
+            throw new FatalError("No body in S3 response");
+        }
+        return {
+            body: body,
+            contentType: response.ContentType,
+            cacheControl: response.CacheControl,
+        };
+    },
+};
+export default s3Loader;

package/dist/plugins/edge.d.ts

@@ -0,0 +1,15 @@
+import { Plugin } from "esbuild";
+import { MiddlewareInfo } from "../types/next-types.js";
+export interface IPluginSettings {
+    nextDir: string;
+    edgeFunctionHandlerPath?: string;
+    middlewareInfo: MiddlewareInfo;
+    isInCloudfare?: boolean;
+}
+/**
+ * @param opts.nextDir - The path to the .next directory
+ * @param opts.edgeFunctionHandlerPath - The path to the edgeFunctionHandler.js file that we'll use to bundle the routing
+ * @param opts.entryFiles - The entry files that we'll inject into the edgeFunctionHandler.js file
+ * @returns
+ */
+export declare function openNextEdgePlugins({ nextDir, edgeFunctionHandlerPath, middlewareInfo, isInCloudfare, }: IPluginSettings): Plugin;

package/dist/plugins/edge.js

@@ -0,0 +1,157 @@
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { loadAppPathsManifestKeys, loadBuildId, loadConfig, loadConfigHeaders, loadHtmlPages, loadMiddlewareManifest, loadPrerenderManifest, loadRoutesManifest, } from "../adapters/config/util.js";
+/**
+ * @param opts.nextDir - The path to the .next directory
+ * @param opts.edgeFunctionHandlerPath - The path to the edgeFunctionHandler.js file that we'll use to bundle the routing
+ * @param opts.entryFiles - The entry files that we'll inject into the edgeFunctionHandler.js file
+ * @returns
+ */
+export function openNextEdgePlugins({ nextDir, edgeFunctionHandlerPath, middlewareInfo, isInCloudfare, }) {
+    const entryFiles = middlewareInfo.files.map((file) => path.join(nextDir, file));
+    const routes = [
+        {
+            name: middlewareInfo.name || "/",
+            page: middlewareInfo.page,
+            regex: middlewareInfo.matchers.map((m) => m.regexp),
+        },
+    ];
+    const wasmFiles = middlewareInfo.wasm ?? [];
+    return {
+        name: "opennext-edge",
+        setup(build) {
+            if (edgeFunctionHandlerPath) {
+                // If we bundle the routing, we need to resolve the middleware
+                build.onResolve({ filter: /\.\/middleware.mjs/g }, () => {
+                    return {
+                        path: edgeFunctionHandlerPath,
+                    };
+                });
+            }
+            build.onResolve({ filter: /\.(mjs|wasm)$/g }, (args) => {
+                return {
+                    external: true,
+                };
+            });
+            //Copied from https://github.com/cloudflare/next-on-pages/blob/7a18efb5cab4d86c8e3e222fc94ea88ac05baffd/packages/next-on-pages/src/buildApplication/processVercelFunctions/build.ts#L86-L112
+            build.onResolve({ filter: /^node:/ }, ({ kind, path }) => {
+                // this plugin converts `require("node:*")` calls, those are the only ones that
+                // need updating (esm imports to "node:*" are totally valid), so here we tag with the
+                // node-buffer namespace only imports that are require calls
+                return kind === "require-call"
+                    ? { path, namespace: "node-built-in-modules" }
+                    : undefined;
+            });
+            // we convert the imports we tagged with the node-built-in-modules namespace so that instead of `require("node:*")`
+            // they import from `export * from "node:*";`
+            build.onLoad({ filter: /.*/, namespace: "node-built-in-modules" }, ({ path }) => {
+                return {
+                    contents: `export * from '${path}'`,
+                    loader: "js",
+                };
+            });
+            // We inject the entry files into the edgeFunctionHandler
+            build.onLoad({ filter: /\/edgeFunctionHandler.js/g }, async (args) => {
+                let contents = readFileSync(args.path, "utf-8");
+                contents = `
+globalThis._ENTRIES = {};
+globalThis.self = globalThis;
+globalThis._ROUTES = ${JSON.stringify(routes)};
+
+${isInCloudfare
+                    ? ``
+                    : `
+import {readFileSync} from "node:fs";
+import path from "node:path";
+function addDuplexToInit(init) {
+  return typeof init === 'undefined' ||
+    (typeof init === 'object' && init.duplex === undefined)
+    ? { duplex: 'half', ...init }
+    : init
+}
+// We need to override Request to add duplex to the init, it seems Next expects it to work like this
+class OverrideRequest extends Request {
+  constructor(input, init) {
+    super(input, addDuplexToInit(init))
+  }
+}
+globalThis.Request = OverrideRequest;
+
+// If we're not in cloudflare, we polyfill crypto
+// https://github.com/vercel/edge-runtime/blob/main/packages/primitives/src/primitives/crypto.js
+import { webcrypto } from 'node:crypto'
+if(!globalThis.crypto){
+  globalThis.crypto = new webcrypto.Crypto()
+}
+if(!globalThis.CryptoKey){
+  globalThis.CryptoKey = webcrypto.CryptoKey
+}
+function SubtleCrypto() {
+  if (!(this instanceof SubtleCrypto)) return new SubtleCrypto()
+  throw TypeError('Illegal constructor')
+}
+if(!globalThis.SubtleCrypto) {
+  globalThis.SubtleCrypto = SubtleCrypto
+}
+if(!globalThis.Crypto) {
+  globalThis.Crypto = webcrypto.Crypto
+}
+// We also need to polyfill URLPattern
+if (!globalThis.URLPattern) { 
+  await import("urlpattern-polyfill");
+}
+`}
+${wasmFiles
+                    .map((file) => isInCloudfare
+                    ? `import ${file.name} from './wasm/${file.name}.wasm';`
+                    : `const ${file.name} = readFileSync(path.join(__dirname,'/wasm/${file.name}.wasm'));`)
+                    .join("\n")}
+${entryFiles?.map((file) => `require("${file}");`).join("\n")}
+${contents}        
+        `;
+                return {
+                    contents,
+                };
+            });
+            build.onLoad({ filter: /adapters\/config\/index/g }, async () => {
+                const NextConfig = loadConfig(nextDir);
+                const BuildId = loadBuildId(nextDir);
+                const HtmlPages = loadHtmlPages(nextDir);
+                const RoutesManifest = loadRoutesManifest(nextDir);
+                const ConfigHeaders = loadConfigHeaders(nextDir);
+                const PrerenderManifest = loadPrerenderManifest(nextDir);
+                const AppPathsManifestKeys = loadAppPathsManifestKeys(nextDir);
+                const MiddlewareManifest = loadMiddlewareManifest(nextDir);
+                const contents = `
+  import path from "path";
+  
+  import { debug } from "../logger";
+  
+  if(!globalThis.__dirname) {
+    globalThis.__dirname = ""
+  }
+  
+  export const NEXT_DIR = path.join(__dirname, ".next");
+  export const OPEN_NEXT_DIR = path.join(__dirname, ".open-next");
+  
+  debug({ NEXT_DIR, OPEN_NEXT_DIR });
+  
+  export const NextConfig = ${JSON.stringify(NextConfig)};
+  export const BuildId = ${JSON.stringify(BuildId)};
+  export const HtmlPages = ${JSON.stringify(HtmlPages)};
+  export const RoutesManifest = ${JSON.stringify(RoutesManifest)};
+  export const ConfigHeaders = ${JSON.stringify(ConfigHeaders)};
+  export const PrerenderManifest = ${JSON.stringify(PrerenderManifest)};
+  export const AppPathsManifestKeys = ${JSON.stringify(AppPathsManifestKeys)};
+  export const MiddlewareManifest = ${JSON.stringify(MiddlewareManifest)};
+
+  process.env.NEXT_BUILD_ID = BuildId;
+  
+          `;
+                return {
+                    contents,
+                };
+            });
+        },
+    };
+}

package/dist/plugins/replacement.d.ts

@@ -0,0 +1,42 @@
+import { Plugin } from "esbuild";
+export interface IPluginSettings {
+    target: RegExp;
+    replacements?: string[];
+    deletes?: string[];
+    name?: string;
+}
+/**
+ *
+ * openNextPlugin({
+ *   target: /plugins\/default\.js/g,
+ *   replacements: [require.resolve("./plugins/default.js")],
+ *   deletes: ["id1"],
+ * })
+ *
+ * To inject arbritary code by using (import at top of file):
+ *
+ * //#import
+ *
+ * import data from 'data'
+ * const datum = data.datum
+ *
+ * //#endImport
+ *
+ * To replace code:
+ *
+ * //#override id1
+ *
+ * export function overrideMe() {
+ *    // I will replace the "id1" block in the target file
+ * }
+ *
+ * //#endOverride
+ *
+ *
+ * @param opts.target - the target file to replace
+ * @param opts.replacements - list of files used to replace the imports/overrides in the target
+ *                          - the path is absolute
+ * @param opts.deletes - list of ids to delete from the target
+ * @returns
+ */
+export declare function openNextReplacementPlugin({ target, replacements, deletes, name, }: IPluginSettings): Plugin;

package/dist/plugins/replacement.js

@@ -0,0 +1,74 @@
+import { readFile } from "node:fs/promises";
+import chalk from "chalk";
+import logger from "../logger.js";
+const overridePattern = /\/\/#override (\w+)\n([\s\S]*?)\n\/\/#endOverride/gm;
+const importPattern = /\/\/#import([\s\S]*?)\n\/\/#endImport/gm;
+/**
+ *
+ * openNextPlugin({
+ *   target: /plugins\/default\.js/g,
+ *   replacements: [require.resolve("./plugins/default.js")],
+ *   deletes: ["id1"],
+ * })
+ *
+ * To inject arbritary code by using (import at top of file):
+ *
+ * //#import
+ *
+ * import data from 'data'
+ * const datum = data.datum
+ *
+ * //#endImport
+ *
+ * To replace code:
+ *
+ * //#override id1
+ *
+ * export function overrideMe() {
+ *    // I will replace the "id1" block in the target file
+ * }
+ *
+ * //#endOverride
+ *
+ *
+ * @param opts.target - the target file to replace
+ * @param opts.replacements - list of files used to replace the imports/overrides in the target
+ *                          - the path is absolute
+ * @param opts.deletes - list of ids to delete from the target
+ * @returns
+ */
+export function openNextReplacementPlugin({ target, replacements, deletes, name, }) {
+    return {
+        name: name ?? "opennext",
+        setup(build) {
+            build.onLoad({ filter: target }, async (args) => {
+                let contents = await readFile(args.path, "utf-8");
+                await Promise.all([
+                    ...(deletes ?? []).map(async (id) => {
+                        const pattern = new RegExp(`\/\/#override (${id})\n([\\s\\S]*?)\/\/#endOverride`);
+                        logger.debug(chalk.blue(`Open-next replacement plugin ${name}`), ` -- Deleting override for ${id}`);
+                        contents = contents.replace(pattern, "");
+                    }),
+                    ...(replacements ?? []).map(async (fp) => {
+                        const p = fp;
+                        const replacementFile = await readFile(p, "utf-8");
+                        const matches = replacementFile.matchAll(overridePattern);
+                        const importMatch = replacementFile.match(importPattern);
+                        const addedImport = importMatch ? importMatch[0] : "";
+                        contents = `${addedImport}\n${contents}`;
+                        for (const match of matches) {
+                            const replacement = match[2];
+                            const id = match[1];
+                            const pattern = new RegExp(`\/\/#override (${id})\n([\\s\\S]*?)\/\/#endOverride`, "g");
+                            logger.debug(chalk.blue(`Open-next replacement plugin ${name}`), `-- Applying override for ${id} from ${fp}`);
+                            contents = contents.replace(pattern, replacement);
+                        }
+                    }),
+                ]);
+                return {
+                    contents,
+                };
+            });
+        },
+    };
+}

package/dist/plugins/resolve.d.ts

@@ -0,0 +1,18 @@
+import { Plugin } from "esbuild";
+import type { DefaultOverrideOptions, ImageLoader, IncludedImageLoader, LazyLoadedOverride, OverrideOptions } from "../types/open-next";
+export interface IPluginSettings {
+    overrides?: {
+        wrapper?: DefaultOverrideOptions<any, any>["wrapper"];
+        converter?: DefaultOverrideOptions<any, any>["converter"];
+        tagCache?: OverrideOptions["tagCache"];
+        queue?: OverrideOptions["queue"];
+        incrementalCache?: OverrideOptions["incrementalCache"];
+        imageLoader?: LazyLoadedOverride<ImageLoader> | IncludedImageLoader;
+    };
+    fnName?: string;
+}
+/**
+ * @param opts.overrides - The name of the overrides to use
+ * @returns
+ */
+export declare function openNextResolvePlugin({ overrides, fnName, }: IPluginSettings): Plugin;

package/dist/plugins/resolve.js

@@ -0,0 +1,45 @@
+import { readFileSync } from "node:fs";
+import logger from "../logger.js";
+function getOverrideOrDefault(override, defaultOverride) {
+    if (typeof override === "string") {
+        return override;
+    }
+    return defaultOverride;
+}
+/**
+ * @param opts.overrides - The name of the overrides to use
+ * @returns
+ */
+export function openNextResolvePlugin({ overrides, fnName, }) {
+    return {
+        name: "opennext-resolve",
+        setup(build) {
+            logger.debug(`OpenNext Resolve plugin for ${fnName}`);
+            build.onLoad({ filter: /core(\/|\\)resolve\.js/g }, async (args) => {
+                let contents = readFileSync(args.path, "utf-8");
+                //TODO: refactor this. Every override should be at the same place so we can generate this dynamically
+                if (overrides?.wrapper) {
+                    contents = contents.replace("../wrappers/aws-lambda.js", `../wrappers/${getOverrideOrDefault(overrides.wrapper, "aws-lambda")}.js`);
+                }
+                if (overrides?.converter) {
+                    contents = contents.replace("../converters/aws-apigw-v2.js", `../converters/${getOverrideOrDefault(overrides.converter, "dummy")}.js`);
+                }
+                if (overrides?.tagCache) {
+                    contents = contents.replace("../cache/tag/dynamodb.js", `../cache/tag/${getOverrideOrDefault(overrides.tagCache, "dynamodb-lite")}.js`);
+                }
+                if (overrides?.queue) {
+                    contents = contents.replace("../queue/sqs.js", `../queue/${getOverrideOrDefault(overrides.queue, "sqs-lite")}.js`);
+                }
+                if (overrides?.incrementalCache) {
+                    contents = contents.replace("../cache/incremental/s3.js", `../cache/incremental/${getOverrideOrDefault(overrides.incrementalCache, "s3-lite")}.js`);
+                }
+                if (overrides?.imageLoader) {
+                    contents = contents.replace("../overrides/imageLoader/s3.js", `../overrides/imageLoader/${getOverrideOrDefault(overrides.imageLoader, "s3")}.js`);
+                }
+                return {
+                    contents,
+                };
+            });
+        },
+    };
+}

package/dist/queue/sqs-lite.d.ts

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

package/dist/queue/sqs-lite.js

@@ -0,0 +1,52 @@
+import { AwsClient } from "aws4fetch";
+import { RecoverableError } from "../utils/error";
+import { customFetchClient } from "../utils/fetch";
+import { error } from "../adapters/logger";
+let awsClient = null;
+const getAwsClient = () => {
+    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: process.env.REVALIDATION_QUEUE_REGION,
+        });
+        return awsClient;
+    }
+};
+const awsFetch = (body) => {
+    const { REVALIDATION_QUEUE_REGION } = process.env;
+    const client = getAwsClient();
+    return customFetchClient(client)(`https://sqs.${REVALIDATION_QUEUE_REGION ?? "us-east-1"}.amazonaws.com`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/x-amz-json-1.0",
+            "X-Amz-Target": "AmazonSQS.SendMessage",
+        },
+        body,
+    });
+};
+const queue = {
+    send: async ({ MessageBody, MessageDeduplicationId, MessageGroupId }) => {
+        try {
+            const { REVALIDATION_QUEUE_URL } = process.env;
+            const result = await awsFetch(JSON.stringify({
+                QueueUrl: REVALIDATION_QUEUE_URL,
+                MessageBody: JSON.stringify(MessageBody),
+                MessageDeduplicationId,
+                MessageGroupId,
+            }));
+            if (result.status !== 200) {
+                throw new RecoverableError(`Failed to send message: ${result.status}`);
+            }
+        }
+        catch (e) {
+            error(e);
+        }
+    },
+    name: "sqs",
+};
+export default queue;

package/dist/queue/sqs.d.ts

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