sst 3.0.0 → 3.0.1-10

package/project.js

@@ -1,188 +0,0 @@
-import fs from "fs/promises";
-import fsSync from "fs";
-import path from "path";
-import url from "url";
-import os from "os";
-import { Logger } from "./logger.js";
-import { VisibleError } from "./error.js";
-import { blue } from "colorette";
-import dotenv from "dotenv";
-import { load } from "./stacks/build.js";
-const DEFAULTS = {
-    stage: undefined,
-    ssmPrefix: undefined,
-};
-let project;
-export function useProject() {
-    if (!project)
-        throw new Error("Project not initialized");
-    return project;
-}
-const CONFIG_EXTENSIONS = [
-    ".config.ts",
-    ".config.mts",
-    ".config.cts",
-    ".config.cjs",
-    ".config.mjs",
-    ".config.js",
-];
-export async function initProject(globals) {
-    // Logger.debug("initing project");
-    const root = globals.root || (await findRoot());
-    const out = path.join(root, ".sst");
-    await fs.mkdir(out, {
-        recursive: true,
-    });
-    // Logger.debug("made out dir");
-    let file;
-    const [metafile, sstConfig] = await (async function () {
-        for (const ext of CONFIG_EXTENSIONS) {
-            file = path.join(root, "sst" + ext);
-            if (!fsSync.existsSync(file))
-                continue;
-            // Logger.debug("found sst config");
-            const [metafile, config] = await load(file, true);
-            // Logger.debug("loaded sst config");
-            return [metafile, config];
-        }
-        throw new VisibleError("Could not found a configuration file", "Make sure one of the following exists", ...CONFIG_EXTENSIONS.map((x) => `  - sst${x}`));
-    })();
-    const config = await Promise.resolve(sstConfig.config(globals));
-    const stage = process.env.SST_STAGE ||
-        globals.stage ||
-        config.stage ||
-        (await usePersonalStage(out)) ||
-        (await promptPersonalStage(out));
-    // Set stage to SST_STAGE so that if SST spawned processes are aware
-    // of the stage. ie.
-    // `sst deploy --stage prod`: `prod` stage passed in via CLI
-    // -> spawns `open-next build`
-    // -> spawns `sst bind`: `prod` stage read from SST_STAGE
-    process.env.SST_STAGE = stage;
-    const [version, cdkVersion, constructsVersion] = await (async () => {
-        try {
-            const packageJson = JSON.parse(await fs
-                .readFile(url.fileURLToPath(new URL("./package.json", import.meta.url)))
-                .then((x) => x.toString()));
-            return [
-                packageJson.version,
-                packageJson.dependencies["aws-cdk-lib"],
-                packageJson.dependencies["constructs"],
-            ];
-        }
-        catch {
-            return ["unknown", "unknown"];
-        }
-    })();
-    project = {
-        version,
-        cdkVersion,
-        constructsVersion,
-        config: {
-            ...config,
-            stage,
-            profile: process.env.AWS_ACCESS_KEY_ID && process.env.AWS_SECRET_ACCESS_KEY
-                ? undefined
-                : globals.profile || config.profile,
-            region: globals.region || config.region,
-            role: globals.role || config.role,
-            ssmPrefix: config.ssmPrefix || `/sst/${config.name}/${stage}/`,
-            bootstrap: config.bootstrap,
-            cdk: config.cdk,
-        },
-        stacks: sstConfig.stacks,
-        metafile,
-        paths: {
-            config: file,
-            root,
-            out,
-            artifacts: path.join(out, "artifacts"),
-        },
-    };
-    // Cleanup old config files
-    (async function () {
-        const files = await fs.readdir(project.paths.root);
-        for (const file of files) {
-            if (file.startsWith(".sst.config")) {
-                // Do not remove recently generated config files. This allows for multiple
-                // SST processes to run concurrently.
-                const timeGenerated = (file.match(/\b\d{13}\b/g) ?? []).at(0);
-                if (timeGenerated && Date.now() - parseInt(timeGenerated, 10) < 30000) {
-                    continue;
-                }
-                await fs.unlink(path.join(project.paths.root, file));
-                Logger.debug(`Removed old config file ${file}`);
-            }
-        }
-    })();
-    // Load .env files
-    [
-        path.join(project.paths.root, `.env`),
-        path.join(project.paths.root, `.env.local`),
-        path.join(project.paths.root, `.env.${project.config.stage}`),
-        path.join(project.paths.root, `.env.${project.config.stage}.local`),
-    ].forEach((path) => dotenv.config({ path, override: true }));
-    Logger.debug("Config loaded", project);
-}
-async function usePersonalStage(out) {
-    try {
-        const result = await fs.readFile(path.join(out, "stage"));
-        return result.toString("utf8").trim();
-    }
-    catch {
-        return;
-    }
-}
-async function promptPersonalStage(out, isRetry) {
-    const readline = await import("readline");
-    const rl = readline.createInterface({
-        input: process.stdin,
-        output: process.stdout,
-    });
-    const stage = await new Promise((resolve) => {
-        const suggested = sanitizeStageName(os.userInfo().username) || "local";
-        const instruction = !isRetry
-            ? `Please enter a name you’d like to use for your personal stage.`
-            : `Please enter a name that starts with a letter, followed by letters, numbers, or hyphens.`;
-        rl.question(`${instruction} Or hit enter to use ${blue(suggested)}: `, async (input) => {
-            rl.close();
-            const result = input === "" ? suggested : input;
-            resolve(result);
-        });
-    });
-    // Validate stage name
-    if (isValidStageName(stage)) {
-        await fs.writeFile(path.join(out, "stage"), stage);
-        return stage;
-    }
-    return await promptPersonalStage(out, true);
-}
-async function findRoot() {
-    async function find(dir) {
-        if (dir === "/")
-            throw new VisibleError("Could not found a configuration file", "Make sure one of the following exists", ...CONFIG_EXTENSIONS.map((ext) => `  - sst${ext}`));
-        for (const ext of CONFIG_EXTENSIONS) {
-            const configPath = path.join(dir, `sst${ext}`);
-            if (fsSync.existsSync(configPath)) {
-                return dir;
-            }
-        }
-        return await find(path.join(dir, ".."));
-    }
-    const result = await find(process.cwd());
-    return result;
-}
-function sanitizeStageName(stage) {
-    return (stage
-        .replace(/[^A-Za-z0-9-]/g, "-")
-        .replace(/--+/g, "-")
-        .replace(/^[^A-Za-z]/, "")
-        .replace(/-$/, "") || "local");
-}
-function isValidStageName(stage) {
-    return Boolean(stage.match(/^[A-Za-z][A-Za-z0-9-]*$/));
-}
-export const exportedForTesting = {
-    sanitizeStageName,
-    isValidStageName,
-};

package/runtime/handlers/container.d.ts

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

package/runtime/handlers/container.js

@@ -1,263 +0,0 @@
-import http from "http";
-import { spawn } from "child_process";
-import { useRuntimeWorkers } from "../workers.js";
-import { useRuntimeServerConfig } from "../server.js";
-import { VisibleError } from "../../error.js";
-import { isChild } from "../../util/fs.js";
-import { execAsync } from "../../util/process.js";
-import { useFunctions } from "../../constructs/Function.js";
-export const useContainerHandler = () => {
-    const containers = new Map();
-    const sources = new Map();
-    async function dockerRun(input, opts, onExit) {
-        const workers = await useRuntimeWorkers();
-        const name = `sst-workerID-${input.workerID}-${Date.now()}`;
-        const proc = spawn("docker", [
-            "run",
-            "--rm",
-            "--network=host",
-            `--name=${name}`,
-            ...Object.entries({
-                ...input.environment,
-                ...opts.envs,
-                IS_LOCAL: "true",
-            })
-                .map(([key, value]) => ["-e", `${key}=${value}`])
-                .flat(),
-            ...(opts.entrypoint !== undefined
-                ? ["--entrypoint", opts.entrypoint]
-                : []),
-            `sst-dev:${input.functionID}`,
-            ...(opts.cmd ?? []),
-        ], {
-            env: {
-                ...process.env,
-            },
-            cwd: input.out,
-        });
-        proc.on("exit", (code) => {
-            onExit(code);
-        });
-        proc.stdout.on("data", (data) => {
-            workers.stdout(input.workerID, data.toString());
-        });
-        proc.stderr.on("data", (data) => {
-            workers.stdout(input.workerID, data.toString());
-        });
-        containers.set(input.workerID, name);
-    }
-    async function startLambdaWorker(input) {
-        const server = await useRuntimeServerConfig();
-        const workers = await useRuntimeWorkers();
-        const fn = useFunctions().fromID(input.functionID);
-        dockerRun(input, {
-            cmd: fn?.container?.cmd,
-            envs: {
-                AWS_LAMBDA_RUNTIME_API: `host.docker.internal:${server.port}/${input.workerID}`,
-            },
-        }, () => {
-            workers.exited(input.workerID);
-        });
-    }
-    async function startJobWorker(input) {
-        const workers = await useRuntimeWorkers();
-        // Job container is special:
-        // 1. Not capable of receiving the `event` payload
-        //    - on `sst deploy`, the CodeBuild job is started with `SST_PAYLOAD` env var
-        //    - on `sst dev`, set `SST_DEBUG_JOB` env var here
-        // 2. Worker exits at the end of the run.
-        // Fetch request
-        const result = await init();
-        const awsRequestId = result.headers["lambda-runtime-aws-request-id"];
-        const fn = useFunctions().fromID(input.functionID);
-        try {
-            await dockerRun(input, {
-                entrypoint: "",
-                cmd: fn?.container?.cmd,
-                envs: {
-                    SST_PAYLOAD: result.body,
-                },
-            }, async (code) => {
-                code === 0 ? await success() : await error();
-                workers.exited(input.workerID);
-            });
-        }
-        catch (ex) {
-            await initError(ex);
-            workers.exited(input.workerID);
-        }
-        async function init() {
-            return await fetch({
-                path: `/runtime/invocation/next`,
-                method: "GET",
-                headers: {},
-            });
-        }
-        async function initError(ex) {
-            return await fetch({
-                path: `/runtime/init/error`,
-                method: "POST",
-                headers: {
-                    "Content-Type": "application/json",
-                },
-                body: JSON.stringify({
-                    errorType: "Error",
-                    errorMessage: ex.message,
-                    trace: ex.stack?.split("\n"),
-                }),
-            });
-        }
-        async function success() {
-            while (true) {
-                try {
-                    await fetch({
-                        path: `/runtime/invocation/${awsRequestId}/response`,
-                        method: "POST",
-                        headers: {
-                            "Content-Type": "application/json",
-                        },
-                        body: JSON.stringify("Job completed successfully"),
-                    });
-                    break;
-                }
-                catch (ex) {
-                    console.error(ex);
-                    await new Promise((resolve) => setTimeout(resolve, 500));
-                }
-            }
-        }
-        async function error() {
-            return await fetch({
-                path: `/runtime/invocation/${awsRequestId}/error`,
-                method: "POST",
-                headers: {
-                    "Content-Type": "application/json",
-                },
-                body: JSON.stringify({
-                    errorType: "Error",
-                    errorMessage: "Failed to run job",
-                    trace: [],
-                }),
-            });
-        }
-        function fetch(req) {
-            return new Promise((resolve, reject) => {
-                const request = http.request(input.url + req.path, {
-                    headers: req.headers,
-                    method: req.method,
-                }, (res) => {
-                    let body = "";
-                    res.setEncoding("utf8");
-                    res.on("data", (chunk) => {
-                        body += chunk.toString();
-                    });
-                    res.on("end", () => {
-                        resolve({
-                            statusCode: res.statusCode,
-                            headers: res.headers,
-                            body,
-                        });
-                    });
-                });
-                request.on("error", reject);
-                if (req.body)
-                    request.write(req.body);
-                request.end();
-            });
-        }
-    }
-    return {
-        shouldBuild: (input) => {
-            const parent = sources.get(input.functionID);
-            if (!parent)
-                return false;
-            return isChild(parent, input.file);
-        },
-        canHandle: (input) => input.startsWith("container"),
-        startWorker: async (input) => {
-            input.environment.SST_DEBUG_JOB
-                ? await startJobWorker(input)
-                : await startLambdaWorker(input);
-        },
-        stopWorker: async (workerID) => {
-            const name = containers.get(workerID);
-            if (name) {
-                try {
-                    // note:
-                    // - calling `docker kill` kills the docker process much faster than `docker stop`
-                    // - process.kill() does not work on docker processes
-                    await execAsync(`docker kill ${name}`, {
-                        env: {
-                            ...process.env,
-                        },
-                    });
-                }
-                catch (ex) {
-                    console.error(ex);
-                    throw new VisibleError(`Could not stop docker container ${name}`);
-                }
-                containers.delete(workerID);
-            }
-        },
-        build: async (input) => {
-            const project = input.props.handler;
-            sources.set(input.functionID, project);
-            if (input.mode === "start") {
-                try {
-                    const result = await execAsync([
-                        `docker build`,
-                        `-t sst-dev:${input.functionID}`,
-                        ...(input.props.container?.file
-                            ? [`-f ${input.props.container.file}`]
-                            : []),
-                        ...Object.entries(input.props.container?.buildArgs || {}).map(([k, v]) => `--build-arg ${k}=${v}`),
-                        `.`,
-                    ].join(" "), {
-                        cwd: project,
-                        env: {
-                            ...process.env,
-                        },
-                    });
-                }
-                catch (ex) {
-                    return {
-                        type: "error",
-                        errors: [String(ex)],
-                    };
-                }
-            }
-            if (input.mode === "deploy") {
-                try {
-                    const platform = input.props.architecture === "arm_64"
-                        ? "linux/arm64"
-                        : "linux/amd64";
-                    await execAsync([
-                        `docker build`,
-                        `-t sst-build:${input.functionID}`,
-                        ...(input.props.container?.file
-                            ? [`-f ${input.props.container.file}`]
-                            : []),
-                        ...Object.entries(input.props.container?.buildArgs || {}).map(([k, v]) => `--build-arg ${k}=${v}`),
-                        `--platform ${platform}`,
-                        `.`,
-                    ].join(" "), {
-                        cwd: project,
-                        env: {
-                            ...process.env,
-                        },
-                    });
-                }
-                catch (ex) {
-                    return {
-                        type: "error",
-                        errors: [String(ex)],
-                    };
-                }
-            }
-            return {
-                type: "success",
-                handler: "not required for container",
-            };
-        },
-    };
-};

package/runtime/handlers/dotnet.d.ts

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

package/runtime/handlers/dotnet.js

@@ -1,115 +0,0 @@
-import { useRuntimeWorkers } from "../workers.js";
-import { spawn } from "child_process";
-import { useRuntimeServerConfig } from "../server.js";
-import { findBelow, isChild } from "../../util/fs.js";
-import { useProject } from "../../project.js";
-import { execAsync } from "../../util/process.js";
-import url from "url";
-const FRAMEWORK_MAP = {
-    "dotnetcore1.0": "netcoreapp3.1",
-    "dotnetcore2.0": "netcoreapp3.1",
-    "dotnetcore2.1": "netcoreapp3.1",
-    "dotnetcore3.1": "netcoreapp3.1",
-    dotnet6: "net6.0",
-};
-const BOOTSTRAP_MAP = {
-    "dotnetcore1.0": "dotnet31-bootstrap",
-    "dotnetcore2.0": "dotnet31-bootstrap",
-    "dotnetcore2.1": "dotnet31-bootstrap",
-    "dotnetcore3.1": "dotnet31-bootstrap",
-    dotnet6: "dotnet6-bootstrap",
-};
-export const useDotnetHandler = () => {
-    const processes = new Map();
-    const sources = new Map();
-    const handlerName = process.platform === "win32" ? `handler.exe` : `handler`;
-    return {
-        shouldBuild: (input) => {
-            if (!input.file.endsWith(".cs") && !input.file.endsWith(".fs"))
-                return false;
-            const parent = sources.get(input.functionID);
-            if (!parent)
-                return false;
-            return isChild(parent, input.file);
-        },
-        canHandle: (input) => input.startsWith("dotnet"),
-        startWorker: async (input) => {
-            const workers = await useRuntimeWorkers();
-            const server = await useRuntimeServerConfig();
-            const name = input.handler.split(":")[0];
-            const proc = spawn(`dotnet`, [
-                `exec`,
-                url.fileURLToPath(new URL(`../../support/${BOOTSTRAP_MAP[input.runtime]}/release/dotnet-bootstrap.dll`, import.meta.url)),
-                name + ".dll",
-                input.handler,
-            ], {
-                env: {
-                    ...process.env,
-                    ...input.environment,
-                    IS_LOCAL: "true",
-                    AWS_LAMBDA_RUNTIME_API: `localhost:${server.port}/${input.workerID}`,
-                    AWS_LAMBDA_DOTNET_DEBUG_RUN_ONCE: "true",
-                },
-                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 name = input.props.handler.split(":")[0];
-            const srcPath = await findBelow(project.paths.root, `${name}.csproj`);
-            sources.set(input.functionID, srcPath);
-            try {
-                await execAsync([
-                    "dotnet",
-                    "publish",
-                    "--output",
-                    '"' + input.out + '"',
-                    "--configuration",
-                    "Release",
-                    "--framework",
-                    FRAMEWORK_MAP[input.props.runtime],
-                    "/p:GenerateRuntimeConfigurationFiles=true",
-                    "/clp:ForceConsoleColor",
-                    // warnings are not reported for repeated builds by default and this flag
-                    // does a clean before build. It takes a little longer to run, but the
-                    // warnings are consistently printed on each build.
-                    //"/target:Rebuild",
-                    "--self-contained",
-                    "false",
-                    // do not print "Build Engine version"
-                    "-nologo",
-                ].join(" "), 
-                // only print errors
-                {
-                    cwd: srcPath,
-                });
-                return {
-                    type: "success",
-                    handler: input.props.handler,
-                    runtime: input.props.runtime,
-                };
-            }
-            catch (ex) {
-                return {
-                    type: "error",
-                    errors: [ex.stderr],
-                };
-            }
-        },
-    };
-};

package/runtime/handlers/go.d.ts

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