sst 3.0.0 → 3.0.1-10

package/runtime/handlers/go.js

@@ -1,126 +0,0 @@
-import path from "path";
-import fs from "fs/promises";
-import os from "os";
-import { useRuntimeWorkers } from "../workers.js";
-import { VisibleError } from "../../error.js";
-import { spawn } from "child_process";
-import { useRuntimeServerConfig } from "../server.js";
-import { isChild } from "../../util/fs.js";
-import { execAsync } from "../../util/process.js";
-export const useGoHandler = () => {
-    const processes = new Map();
-    const sources = new Map();
-    const handlerName = process.platform === "win32" ? `bootstrap.exe` : `bootstrap`;
-    return {
-        shouldBuild: (input) => {
-            const parent = sources.get(input.functionID);
-            if (!parent)
-                return false;
-            return isChild(parent, input.file);
-        },
-        canHandle: (input) => input.startsWith("go"),
-        startWorker: async (input) => {
-            const workers = await useRuntimeWorkers();
-            const server = await useRuntimeServerConfig();
-            const proc = spawn(path.join(input.out, handlerName), {
-                env: {
-                    ...process.env,
-                    ...input.environment,
-                    IS_LOCAL: "true",
-                    AWS_LAMBDA_RUNTIME_API: `localhost:${server.port}/${input.workerID}`,
-                },
-                cwd: input.out,
-            });
-            proc.on("exit", () => workers.exited(input.workerID));
-            proc.stdout.on("data", (data) => {
-                workers.stdout(input.workerID, data.toString());
-            });
-            proc.stderr.on("data", (data) => {
-                workers.stdout(input.workerID, data.toString());
-            });
-            processes.set(input.workerID, proc);
-        },
-        stopWorker: async (workerID) => {
-            const proc = processes.get(workerID);
-            if (proc) {
-                proc.kill();
-                processes.delete(workerID);
-            }
-        },
-        build: async (input) => {
-            const parsed = path.parse(input.props.handler);
-            const project = await find(parsed.dir, "go.mod");
-            sources.set(input.functionID, project);
-            const src = path.relative(project, input.props.handler);
-            const ldFlags = input.props.go?.ldFlags || ["-s", "-w"];
-            const buildTags = input.props.go?.buildTags || [];
-            if (input.mode === "start") {
-                try {
-                    const target = path.join(input.out, handlerName);
-                    const srcPath = os.platform() === "win32" ? src.replaceAll("\\", "\\\\") : src;
-                    const result = await execAsync([
-                        "go",
-                        "build",
-                        ...(ldFlags.length ? [`-ldflags "${ldFlags.join(" ")}"`] : []),
-                        ...(buildTags.length ? [`-tags ${buildTags.join(" ")}`] : []),
-                        `-o "${target}"`,
-                        `./${srcPath}`,
-                    ].join(" "), {
-                        cwd: project,
-                        env: {
-                            ...process.env,
-                        },
-                    });
-                }
-                catch (ex) {
-                    return {
-                        type: "error",
-                        errors: [String(ex)],
-                    };
-                }
-            }
-            if (input.mode === "deploy") {
-                try {
-                    const target = path.join(input.out, "bootstrap");
-                    const srcPath = os.platform() === "win32" ? src.replaceAll("\\", "\\\\") : src;
-                    await execAsync([
-                        "go",
-                        "build",
-                        ...(ldFlags.length ? [`-ldflags "${ldFlags.join(" ")}"`] : []),
-                        ...(buildTags.length ? [`-tags ${buildTags.join(" ")}`] : []),
-                        `-o "${target}"`,
-                        `./${srcPath}`,
-                    ].join(" "), {
-                        cwd: project,
-                        env: {
-                            ...process.env,
-                            CGO_ENABLED: input.props.go?.cgoEnabled ? "1" : "0",
-                            GOARCH: input.props.architecture === "arm_64" ? "arm64" : "amd64",
-                            GOOS: "linux",
-                        },
-                    });
-                }
-                catch (ex) {
-                    return {
-                        type: "error",
-                        errors: [String(ex)],
-                    };
-                }
-            }
-            return {
-                type: "success",
-                handler: "bootstrap",
-            };
-        },
-    };
-};
-async function find(dir, target) {
-    if (dir === "/")
-        throw new VisibleError(`Could not find a ${target} file`);
-    if (await fs
-        .access(path.join(dir, target))
-        .then(() => true)
-        .catch(() => false))
-        return dir;
-    return find(path.join(dir, ".."), target);
-}

package/runtime/handlers/java.d.ts

@@ -1,2 +0,0 @@
-import { RuntimeHandler } from "../handlers.js";
-export declare const useJavaHandler: () => RuntimeHandler;

package/runtime/handlers/java.js

@@ -1,103 +0,0 @@
-import path from "path";
-import fs from "fs/promises";
-import os from "os";
-import { useRuntimeWorkers } from "../workers.js";
-import { spawn } from "child_process";
-import { useRuntimeServerConfig } from "../server.js";
-import { existsAsync, findBelow, isChild } from "../../util/fs.js";
-import { useProject } from "../../project.js";
-import { execAsync } from "../../util/process.js";
-import url from "url";
-import AdmZip from "adm-zip";
-export const useJavaHandler = () => {
-    const processes = new Map();
-    const sources = new Map();
-    const runningBuilds = new Map();
-    return {
-        shouldBuild: (input) => {
-            if (!input.file.endsWith(".java"))
-                return false;
-            const parent = sources.get(input.functionID);
-            if (!parent)
-                return false;
-            return isChild(parent, input.file);
-        },
-        canHandle: (input) => input.startsWith("java"),
-        startWorker: async (input) => {
-            const workers = await useRuntimeWorkers();
-            const server = await useRuntimeServerConfig();
-            const proc = spawn(`java`, [
-                `-cp`,
-                [
-                    url.fileURLToPath(new URL("../../support/java-runtime/release/*", import.meta.url)),
-                ].join(os.platform() === "win32" ? ";" : ":"),
-                "com.amazonaws.services.lambda.runtime.api.client.AWSLambda",
-                input.handler,
-            ], {
-                env: {
-                    ...process.env,
-                    ...input.environment,
-                    IS_LOCAL: "true",
-                    AWS_LAMBDA_RUNTIME_API: `localhost:${server.port}/${input.workerID}`,
-                },
-                cwd: input.out,
-            });
-            proc.on("exit", () => workers.exited(input.workerID));
-            proc.stdout.on("data", (data) => {
-                workers.stdout(input.workerID, data.toString());
-            });
-            proc.stderr.on("data", (data) => {
-                workers.stdout(input.workerID, data.toString());
-            });
-            processes.set(input.workerID, proc);
-        },
-        stopWorker: async (workerID) => {
-            const proc = processes.get(workerID);
-            if (proc) {
-                proc.kill();
-                processes.delete(workerID);
-            }
-        },
-        build: async (input) => {
-            const project = useProject();
-            const srcPath = await findBelow(project.paths.root, "build.gradle");
-            const buildBinary = await getGradleBinary(srcPath);
-            const buildTask = input.props.java?.buildTask || "build";
-            const outputDir = input.props.java?.buildOutputDir || "distributions";
-            sources.set(input.functionID, srcPath);
-            try {
-                // Build
-                // Note: run gradle build once per directory. Otherwise they'll interfere
-                // with one another
-                const buildPromise = runningBuilds.get(buildBinary) ??
-                    execAsync(`${buildBinary} ${buildTask} -Dorg.gradle.logging.level=${process.env.DEBUG ? "debug" : "lifecycle"}`, {
-                        cwd: srcPath,
-                    });
-                runningBuilds.set(buildBinary, buildPromise);
-                await buildPromise;
-                runningBuilds.delete(buildBinary);
-                // unzip
-                const buildOutput = path.join(srcPath, "build", outputDir);
-                const zip = (await fs.readdir(buildOutput)).find((f) => f.endsWith(".zip"));
-                const zipper = new AdmZip(path.join(buildOutput, zip));
-                zipper.extractAllTo(input.out, false, false);
-                return {
-                    type: "success",
-                    handler: input.props.handler,
-                };
-            }
-            catch (ex) {
-                return {
-                    type: "error",
-                    errors: [ex.stderr],
-                };
-            }
-        },
-    };
-};
-async function getGradleBinary(srcPath) {
-    // Use a gradle wrapper if provided in the folder, otherwise fall back
-    // to system "gradle"
-    const gradleWrapperPath = path.resolve(path.join(srcPath, "gradlew"));
-    return (await existsAsync(gradleWrapperPath)) ? gradleWrapperPath : "gradle";
-}

package/runtime/handlers/node.d.ts

@@ -1,2 +0,0 @@
-import { RuntimeHandler } from "../handlers.js";
-export declare const useNodeHandler: () => RuntimeHandler;

package/runtime/handlers/node.js

@@ -1,269 +0,0 @@
-import os from "os";
-import path from "path";
-import fs from "fs/promises";
-import { exec } from "child_process";
-import fsSync from "fs";
-import { useProject } from "../../project.js";
-import esbuild from "esbuild";
-import url from "url";
-import { Worker } from "worker_threads";
-import { useRuntimeWorkers } from "../workers.js";
-import { Colors } from "../../cli/colors.js";
-import { Logger } from "../../logger.js";
-import { findAbove } from "../../util/fs.js";
-export const useNodeHandler = () => {
-    const rebuildCache = {};
-    process.on("exit", () => {
-        for (const { ctx } of Object.values(rebuildCache)) {
-            ctx.dispose();
-        }
-    });
-    const project = useProject();
-    const threads = new Map();
-    return {
-        shouldBuild: (input) => {
-            const cache = rebuildCache[input.functionID];
-            if (!cache)
-                return false;
-            const relative = path
-                .relative(project.paths.root, input.file)
-                .split(path.sep)
-                .join(path.posix.sep);
-            return Boolean(cache.result.metafile?.inputs[relative]);
-        },
-        canHandle: (input) => input.startsWith("nodejs"),
-        startWorker: async (input) => {
-            const workers = await useRuntimeWorkers();
-            new Promise(async () => {
-                const worker = new Worker(url.fileURLToPath(new URL("../../support/nodejs-runtime/index.mjs", import.meta.url)), {
-                    env: {
-                        ...input.environment,
-                        IS_LOCAL: "true",
-                    },
-                    execArgv: ["--enable-source-maps"],
-                    workerData: input,
-                    stderr: true,
-                    stdin: true,
-                    stdout: true,
-                });
-                worker.stdout.on("data", (data) => {
-                    workers.stdout(input.workerID, data.toString());
-                });
-                worker.stderr.on("data", (data) => {
-                    workers.stdout(input.workerID, data.toString());
-                });
-                worker.on("exit", () => workers.exited(input.workerID));
-                threads.set(input.workerID, worker);
-            });
-        },
-        stopWorker: async (workerID) => {
-            const worker = threads.get(workerID);
-            await worker?.terminate();
-        },
-        build: async (input) => {
-            const parsed = path.parse(input.props.handler);
-            const file = [
-                ".ts",
-                ".tsx",
-                ".mts",
-                ".cts",
-                ".js",
-                ".jsx",
-                ".mjs",
-                ".cjs",
-            ]
-                .map((ext) => path.join(parsed.dir, parsed.name + ext))
-                .find((file) => {
-                return fsSync.existsSync(file);
-            });
-            if (!file)
-                return {
-                    type: "error",
-                    errors: [`Could not find file for handler "${input.props.handler}"`],
-                };
-            const nodejs = input.props.nodejs || {};
-            const isESM = (nodejs.format || "esm") === "esm";
-            const relative = path.relative(project.paths.root, path.resolve(parsed.dir));
-            const extension = isESM ? ".mjs" : ".cjs";
-            const target = path.join(input.out, !relative.startsWith("..") && !path.isAbsolute(input.props.handler)
-                ? relative
-                : "", parsed.name + extension);
-            const handler = path
-                .relative(input.out, target.replace(extension, parsed.ext))
-                .split(path.sep)
-                .join(path.posix.sep);
-            if (input.mode === "start") {
-                const root = await findAbove(parsed.dir, "package.json");
-                if (!root) {
-                    return {
-                        type: "error",
-                        errors: [
-                            `Could not find package.json for handler "${input.props.handler}"`,
-                        ],
-                    };
-                }
-                const dir = path.join(root, "node_modules");
-                try {
-                    await fs.symlink(path.resolve(dir), path.resolve(path.join(input.out, "node_modules")), "dir");
-                }
-                catch { }
-            }
-            // Rebuilt using existing esbuild context
-            let ctx = rebuildCache[input.functionID]?.ctx;
-            const forceExternal = [
-                "sharp",
-                "pg-native",
-                ...(isESM || input.props.runtime === "nodejs18.x" ? [] : ["aws-sdk"]),
-            ];
-            const { external, ...override } = nodejs.esbuild || {};
-            if (!ctx) {
-                const options = {
-                    entryPoints: [file],
-                    platform: "node",
-                    external: [
-                        ...forceExternal,
-                        ...(nodejs.install || []),
-                        ...(external || []),
-                    ],
-                    loader: nodejs.loader,
-                    keepNames: true,
-                    bundle: true,
-                    logLevel: "silent",
-                    metafile: true,
-                    ...(isESM
-                        ? {
-                            format: "esm",
-                            target: "esnext",
-                            mainFields: ["module", "main"],
-                            banner: {
-                                js: [
-                                    `import { createRequire as topLevelCreateRequire } from 'module';`,
-                                    `const require = topLevelCreateRequire(import.meta.url);`,
-                                    `import { fileURLToPath as topLevelFileUrlToPath, URL as topLevelURL } from "url"`,
-                                    `const __dirname = topLevelFileUrlToPath(new topLevelURL(".", import.meta.url))`,
-                                    nodejs.banner || "",
-                                ].join("\n"),
-                            },
-                        }
-                        : {
-                            format: "cjs",
-                            target: "node14",
-                            banner: nodejs.banner
-                                ? {
-                                    js: nodejs.banner,
-                                }
-                                : undefined,
-                        }),
-                    outfile: target,
-                    // always generate sourcemaps in local
-                    // never generate sourcemaps if explicitly false
-                    // otherwise generate sourcemaps
-                    sourcemap: input.mode === "start"
-                        ? "linked"
-                        : nodejs.sourcemap === false
-                            ? false
-                            : true,
-                    minify: nodejs.minify,
-                    ...override,
-                };
-                ctx = await esbuild.context(options);
-            }
-            try {
-                const result = await ctx.rebuild();
-                // Install node_modules
-                const installPackages = [
-                    ...(nodejs.install || []),
-                    ...forceExternal
-                        .filter((pkg) => pkg !== "aws-sdk")
-                        .filter((pkg) => !external?.includes(pkg))
-                        .filter((pkg) => Object.values(result.metafile?.inputs || {}).some(({ imports }) => imports.some(({ path }) => path === pkg))),
-                ];
-                // TODO bubble up the warnings
-                const warnings = [];
-                Object.entries(result.metafile?.inputs || {}).forEach(([inputPath, { imports }]) => imports
-                    .filter(({ path }) => path.includes("sst/constructs"))
-                    .forEach(({ path }) => {
-                    warnings.push(`You are importing from "${path}" in "${inputPath}". Did you mean to import from "sst/node"?`);
-                }));
-                if (input.mode === "deploy" && installPackages) {
-                    const src = await findAbove(parsed.dir, "package.json");
-                    if (!src) {
-                        return {
-                            type: "error",
-                            errors: [
-                                `Could not find package.json for handler "${input.props.handler}"`,
-                            ],
-                        };
-                    }
-                    const json = JSON.parse(await fs
-                        .readFile(path.join(src, "package.json"))
-                        .then((x) => x.toString()));
-                    await fs.writeFile(path.join(input.out, "package.json"), JSON.stringify({
-                        dependencies: Object.fromEntries(installPackages.map((x) => [x, json.dependencies?.[x] || "*"])),
-                    }));
-                    const cmd = ["npm install"];
-                    if (installPackages.includes("sharp")) {
-                        cmd.push("--platform=linux", input.props.architecture === "arm_64"
-                            ? "--arch=arm64"
-                            : "--arch=x64");
-                    }
-                    await new Promise((resolve, reject) => {
-                        exec(cmd.join(" "), { cwd: input.out }, (error) => {
-                            if (error) {
-                                reject(error);
-                            }
-                            resolve();
-                        });
-                    });
-                }
-                // Cache esbuild result and context for rebuild
-                if (input.mode === "start") {
-                    rebuildCache[input.functionID] = { ctx, result };
-                }
-                if (input.mode === "deploy") {
-                    ctx.dispose();
-                }
-                logMemoryUsage(input.functionID, input.props.handler);
-                return {
-                    type: "success",
-                    handler,
-                    sourcemap: !nodejs.sourcemap
-                        ? Object.keys(result.metafile?.outputs || {}).find((item) => item.endsWith(".map"))
-                        : undefined,
-                };
-            }
-            catch (ex) {
-                const result = ex;
-                if ("errors" in result) {
-                    return {
-                        type: "error",
-                        errors: result.errors.flatMap((x) => [
-                            Colors.bold(x.text),
-                            x.location?.file || "",
-                            Colors.dim(x.location?.line, "│", x.location?.lineText),
-                        ]),
-                    };
-                }
-                return {
-                    type: "error",
-                    errors: [ex.toString()],
-                };
-            }
-        },
-    };
-};
-function logMemoryUsage(functionID, handler) {
-    const printInMB = (bytes) => `${Math.round(bytes / 1024 / 1024)} MB`;
-    const used = process.memoryUsage();
-    for (const key in used) {
-        // @ts-ignore
-        used[key] = printInMB(used[key]);
-    }
-    Logger.debug({
-        functionID,
-        handler,
-        freeMemory: printInMB(os.freemem()),
-        totalMemory: printInMB(os.totalmem()),
-        ...used,
-    });
-}

package/runtime/handlers/python.d.ts

@@ -1,2 +0,0 @@
-import { RuntimeHandler } from "../handlers.js";
-export declare const usePythonHandler: () => RuntimeHandler;

package/runtime/handlers/python.js

@@ -1,141 +0,0 @@
-import path from "path";
-import { useRuntimeWorkers } from "../workers.js";
-import { spawn } from "child_process";
-import { useRuntimeServerConfig } from "../server.js";
-import { findAbove, isChild } from "../../util/fs.js";
-import { Runtime } from "aws-cdk-lib/aws-lambda";
-import { bundle } from "./pythonBundling.js";
-import os from "os";
-import url from "url";
-const RUNTIME_MAP = {
-    "python2.7": Runtime.PYTHON_2_7,
-    "python3.6": Runtime.PYTHON_3_6,
-    "python3.7": Runtime.PYTHON_3_7,
-    "python3.8": Runtime.PYTHON_3_8,
-    "python3.9": Runtime.PYTHON_3_9,
-    "python3.10": Runtime.PYTHON_3_10,
-    "python3.11": Runtime.PYTHON_3_11,
-};
-export const usePythonHandler = () => {
-    const processes = new Map();
-    const sources = new Map();
-    async function findSrc(input) {
-        const hints = ["requirements.txt", "Pipfile", "poetry.lock"];
-        for (const hint of hints) {
-            const result = await findAbove(input, hint);
-            if (result)
-                return result;
-        }
-    }
-    return {
-        shouldBuild: (input) => {
-            const parent = sources.get(input.functionID);
-            if (!parent)
-                return false;
-            return isChild(parent, input.file);
-        },
-        canHandle: (input) => input.startsWith("python"),
-        startWorker: async (input) => {
-            const workers = await useRuntimeWorkers();
-            const server = await useRuntimeServerConfig();
-            const src = await findSrc(input.handler);
-            if (!src)
-                throw new Error(`Could not find src for ${input.handler}`);
-            const parsed = path.parse(path.relative(src, input.handler));
-            const target = [...parsed.dir.split(path.sep), parsed.name].join(".");
-            const proc = spawn(os.platform() === "win32" ? "python.exe" : "python3", [
-                "-u",
-                url.fileURLToPath(new URL("../../support/python-runtime/runtime.py", import.meta.url)),
-                target,
-                src,
-                parsed.ext.substring(1),
-            ], {
-                env: {
-                    ...process.env,
-                    ...input.environment,
-                    IS_LOCAL: "true",
-                    AWS_LAMBDA_FUNCTION_MEMORY_SIZE: "1024",
-                    AWS_LAMBDA_RUNTIME_API: `localhost:${server.port}/${input.workerID}`,
-                },
-                shell: true,
-                cwd: src,
-            });
-            proc.on("exit", () => workers.exited(input.workerID));
-            proc.stdout.on("data", (data) => {
-                workers.stdout(input.workerID, data.toString());
-            });
-            proc.stderr.on("data", (data) => {
-                workers.stdout(input.workerID, data.toString());
-            });
-            processes.set(input.workerID, proc);
-        },
-        stopWorker: async (workerID) => {
-            const proc = processes.get(workerID);
-            if (proc) {
-                proc.kill();
-                processes.delete(workerID);
-            }
-        },
-        build: async (input) => {
-            if (input.mode === "start")
-                return {
-                    type: "success",
-                    handler: input.props.handler,
-                };
-            const src = await findSrc(input.props.handler);
-            if (!src)
-                return {
-                    type: "error",
-                    errors: [`Could not find src for ${input.props.handler}`],
-                };
-            bundle({
-                installCommands: input.props.python?.installCommands,
-                entry: src,
-                runtime: RUNTIME_MAP[input.props.runtime],
-                architecture: input.props.architecture,
-                outputPathSuffix: ".",
-                out: input.out,
-            });
-            /*
-            await fs.cp(src, input.out, {
-              recursive: true,
-              filter: (src) => !src.includes(".sst"),
-            });
-      
-            if (await existsAsync(path.join(src, "Pipfile"))) {
-              await execAsync("pipenv requirements > requirements.txt", {
-                cwd: input.out,
-              });
-            }
-            if (await existsAsync(path.join(src, "poetry.lock"))) {
-              await execAsync(
-                "poetry export --with-credentials --format requirements.txt --output requirements.txt",
-                {
-                  cwd: input.out,
-                }
-              );
-            }
-            if (await existsAsync(path.join(src, "requirements.txt"))) {
-              await execAsync("pip install -r requirements.txt", {
-                cwd: input.out,
-              });
-            }
-      
-            if (input.props.python?.installCommands) {
-              for (const cmd of input.props.python.installCommands) {
-                await execAsync(cmd, {
-                  cwd: input.out,
-                });
-              }
-            }
-            */
-            return {
-                type: "success",
-                handler: path
-                    .relative(src, path.resolve(input.props.handler))
-                    .split(path.sep)
-                    .join(path.posix.sep),
-            };
-        },
-    };
-};