sst 2.0.0-rc.9 → 2.0.0

package/{app.js → project.js}

@@ -7,76 +7,83 @@ import { Logger } from "./logger.js";
 import { Context } from "./context/context.js";
 import { VisibleError } from "./error.js";
 import { blue } from "colorette";
-import { dynamicImport } from "./util/module.js";
 import dotenv from "dotenv";
+import { load } from "./stacks/build.js";
 const DEFAULTS = {
-    main: "stacks/index.ts",
     stage: undefined,
     ssmPrefix: undefined,
 };
-export const ProjectContext = Context.create();
+export const ProjectContext = Context.create("Project");
 export function useProject() {
     return ProjectContext.use();
 }
-const CONFIG_EXTENSIONS = [".config.cjs", ".config.mjs", ".config.js", ".json"];
+const CONFIG_EXTENSIONS = [
+    ".config.ts",
+    ".config.mts",
+    ".config.cts",
+    ".config.cjs",
+    ".config.mjs",
+    ".config.js",
+];
 export async function initProject(globals) {
     const root = globals.root || (await findRoot());
     const out = path.join(root, ".sst");
     await fs.mkdir(out, {
         recursive: true,
     });
-    async function load() {
-        const base = await (async function () {
-            for (const ext of CONFIG_EXTENSIONS) {
-                const file = path.join(root, "sst" + ext);
-                try {
-                    await fs.access(file);
-                }
-                catch {
-                    continue;
-                }
-                if (file.endsWith("js")) {
-                    const fn = await dynamicImport(file);
-                    return await fn.default(globals);
-                }
-                if (file.endsWith(".json")) {
-                    const data = await fs.readFile(file);
-                    return Object.assign(DEFAULTS, JSON.parse(data.toString("utf8")));
-                }
-            }
-            throw new VisibleError("Could not found a configuration file", "Make sure one of the following exists", "  - sst.config.cjs", "  - sst.config.mjs", "  - sst.config.js", "  - sst.json");
-        })();
-        return {
-            ...DEFAULTS,
-            ...base,
-            stage: base.stage ||
-                globals.stage ||
-                (await usePersonalStage(out)) ||
-                (await promptPersonalStage(out)),
-            profile: base.profile || globals.profile,
-            region: base.region || globals.region,
-        };
-    }
-    const project = await load();
-    project.ssmPrefix =
-        project.ssmPrefix || `/sst/${project.name}/${project.stage}/`;
-    project.paths = {
-        root,
-        out,
-        artifacts: path.join(out, "artifacts"),
+    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;
+            const [metafile, config] = await load(file);
+            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 = globals.stage ||
+        config.stage ||
+        (await usePersonalStage(out)) ||
+        (await promptPersonalStage(out));
+    const [version, cdkVersion] = 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"]];
+        }
+        catch {
+            return ["unknown", "unknown"];
+        }
+    })();
+    const project = {
+        version,
+        cdkVersion,
+        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}/`,
+        },
+        stacks: sstConfig.stacks,
+        metafile,
+        paths: {
+            config: file,
+            root,
+            out,
+            artifacts: path.join(out, "artifacts"),
+        },
     };
-    try {
-        const packageJson = JSON.parse(await fs
-            .readFile(url.fileURLToPath(new URL("./package.json", import.meta.url)))
-            .then((x) => x.toString()));
-        project.version = packageJson.version;
-    }
-    catch {
-        project.version = "unknown";
-    }
     ProjectContext.provide(project);
     dotenv.config({
-        path: path.join(project.paths.root, `.env.${project.stage}`),
+        path: path.join(project.paths.root, `.env.${project.config.stage}`),
+        override: true,
     });
     Logger.debug("Config loaded", project);
 }

package/runtime/handlers/dotnet.d.ts

@@ -1 +1 @@
-export declare const useDotnetHandler: () => void;
+export declare const useDotnetHandler: () => Promise<void>;

package/runtime/handlers/dotnet.js

@@ -4,7 +4,7 @@ import { Context } from "../../context/context.js";
 import { spawn } from "child_process";
 import { useRuntimeServerConfig } from "../server.js";
 import { findBelow, isChild } from "../../util/fs.js";
-import { useProject } from "../../app.js";
+import { useProject } from "../../project.js";
 import { execAsync } from "../../util/process.js";
 import url from "url";
 const FRAMEWORK_MAP = {
@@ -21,10 +21,10 @@ const BOOTSTRAP_MAP = {
     "dotnetcore3.1": "dotnet31-bootstrap",
     dotnet6: "dotnet6-bootstrap",
 };
-export const useDotnetHandler = Context.memo(() => {
-    const workers = useRuntimeWorkers();
+export const useDotnetHandler = Context.memo(async () => {
+    const workers = await useRuntimeWorkers();
+    const server = await useRuntimeServerConfig();
     const handlers = useRuntimeHandlers();
-    const server = useRuntimeServerConfig();
     const processes = new Map();
     const sources = new Map();
     const handlerName = process.platform === "win32" ? `handler.exe` : `handler`;

package/runtime/handlers/go.d.ts

@@ -1 +1 @@
-export declare const useGoHandler: () => void;
+export declare const useGoHandler: () => Promise<void>;

package/runtime/handlers/go.js

@@ -9,10 +9,10 @@ import { promisify } from "util";
 import { useRuntimeServerConfig } from "../server.js";
 import { isChild } from "../../util/fs.js";
 const execAsync = promisify(exec);
-export const useGoHandler = Context.memo(() => {
-    const workers = useRuntimeWorkers();
+export const useGoHandler = Context.memo(async () => {
+    const workers = await useRuntimeWorkers();
+    const server = await useRuntimeServerConfig();
     const handlers = useRuntimeHandlers();
-    const server = useRuntimeServerConfig();
     const processes = new Map();
     const sources = new Map();
     const handlerName = process.platform === "win32" ? `handler.exe` : `handler`;

package/runtime/handlers/java.d.ts

@@ -1 +1 @@
-export declare const useJavaHandler: () => void;
+export declare const useJavaHandler: () => Promise<void>;

package/runtime/handlers/java.js

@@ -8,13 +8,13 @@ import zipLocal from "zip-local";
 import { spawn } from "child_process";
 import { useRuntimeServerConfig } from "../server.js";
 import { existsAsync, findBelow, isChild } from "../../util/fs.js";
-import { useProject } from "../../app.js";
+import { useProject } from "../../project.js";
 import { execAsync } from "../../util/process.js";
 import url from "url";
-export const useJavaHandler = Context.memo(() => {
-    const workers = useRuntimeWorkers();
+export const useJavaHandler = Context.memo(async () => {
+    const workers = await useRuntimeWorkers();
+    const server = await useRuntimeServerConfig();
     const handlers = useRuntimeHandlers();
-    const server = useRuntimeServerConfig();
     const processes = new Map();
     const sources = new Map();
     const handlerName = process.platform === "win32" ? `handler.exe` : `handler`;

package/runtime/handlers/node.d.ts

@@ -1 +1 @@
-export declare const useNodeHandler: () => void;
+export declare const useNodeHandler: () => Promise<void>;

package/runtime/handlers/node.js

@@ -2,7 +2,7 @@ import path from "path";
 import fs from "fs/promises";
 import { exec } from "child_process";
 import fsSync from "fs";
-import { useProject } from "../../app.js";
+import { useProject } from "../../project.js";
 import esbuild from "esbuild";
 import url from "url";
 import { Worker } from "worker_threads";
@@ -10,8 +10,9 @@ import { useRuntimeHandlers } from "../handlers.js";
 import { useRuntimeWorkers } from "../workers.js";
 import { Context } from "../../context/context.js";
 import { VisibleError } from "../../error.js";
-export const useNodeHandler = Context.memo(() => {
-    const workers = useRuntimeWorkers();
+import { Colors } from "../../cli/colors.js";
+export const useNodeHandler = Context.memo(async () => {
+    const workers = await useRuntimeWorkers();
     const handlers = useRuntimeHandlers();
     const cache = {};
     const project = useProject();
@@ -79,7 +80,10 @@ export const useNodeHandler = Context.memo(() => {
             const target = path.join(input.out, !relative.startsWith("..") && !path.isAbsolute(relative)
                 ? relative
                 : "", parsed.name + extension);
-            const handler = path.relative(input.out, target.replace(extension, parsed.ext));
+            const handler = path
+                .relative(input.out, target.replace(extension, parsed.ext))
+                .split(path.sep)
+                .join(path.posix.sep);
             if (exists?.rebuild) {
                 const result = await exists.rebuild();
                 cache[input.functionID] = result;
@@ -99,6 +103,7 @@ export const useNodeHandler = Context.memo(() => {
                 ],
                 keepNames: true,
                 bundle: true,
+                logLevel: "silent",
                 metafile: true,
                 ...(isESM
                     ? {
@@ -127,44 +132,60 @@ export const useNodeHandler = Context.memo(() => {
                 minify: nodejs.minify,
                 ...override,
             };
-            const result = await esbuild.build(options);
-            // Install node_modules
-            if (options.external?.length) {
-                async function find(dir, target) {
-                    if (dir === "/")
-                        throw new VisibleError("Could not find a package.json file");
-                    if (await fs
-                        .access(path.join(dir, target))
-                        .then(() => true)
-                        .catch(() => false))
-                        return dir;
-                    return find(path.join(dir, ".."), target);
-                }
-                if (input.mode === "deploy" && nodejs.install) {
-                    const src = await find(parsed.dir, "package.json");
-                    const json = JSON.parse(await fs
-                        .readFile(path.join(src, "package.json"))
-                        .then((x) => x.toString()));
-                    fs.writeFile(path.join(input.out, "package.json"), JSON.stringify({
-                        dependencies: Object.fromEntries(nodejs.install?.map((x) => [x, json.dependencies?.[x] || "*"])),
-                    }));
-                    await new Promise((resolve) => {
-                        const process = exec("npm install", {
-                            cwd: input.out,
+            try {
+                const result = await esbuild.build(options);
+                // Install node_modules
+                if (options.external?.length) {
+                    async function find(dir, target) {
+                        if (dir === "/")
+                            throw new VisibleError("Could not find a package.json file");
+                        if (await fs
+                            .access(path.join(dir, target))
+                            .then(() => true)
+                            .catch(() => false))
+                            return dir;
+                        return find(path.join(dir, ".."), target);
+                    }
+                    if (input.mode === "deploy" && nodejs.install) {
+                        const src = await find(parsed.dir, "package.json");
+                        const json = JSON.parse(await fs
+                            .readFile(path.join(src, "package.json"))
+                            .then((x) => x.toString()));
+                        fs.writeFile(path.join(input.out, "package.json"), JSON.stringify({
+                            dependencies: Object.fromEntries(nodejs.install?.map((x) => [x, json.dependencies?.[x] || "*"])),
+                        }));
+                        await new Promise((resolve) => {
+                            const process = exec("npm install", {
+                                cwd: input.out,
+                            });
+                            process.on("exit", () => resolve());
                         });
-                        process.on("exit", () => resolve());
-                    });
-                }
-                if (input.mode === "start") {
-                    const dir = path.join(await find(parsed.dir, "package.json"), "node_modules");
-                    await fs.symlink(path.resolve(dir), path.resolve(path.join(input.out, "node_modules")), "dir");
+                    }
+                    if (input.mode === "start") {
+                        const dir = path.join(await find(parsed.dir, "package.json"), "node_modules");
+                        try {
+                            await fs.symlink(path.resolve(dir), path.resolve(path.join(input.out, "node_modules")), "dir");
+                        }
+                        catch { }
+                    }
                 }
+                cache[input.functionID] = result;
+                return {
+                    type: "success",
+                    handler,
+                };
+            }
+            catch (ex) {
+                const result = ex;
+                return {
+                    type: "error",
+                    errors: result.errors.flatMap((x) => [
+                        Colors.bold(x.text),
+                        x.location?.file || "",
+                        Colors.dim(x.location?.line, "│", x.location?.lineText),
+                    ]),
+                };
             }
-            cache[input.functionID] = result;
-            return {
-                type: "success",
-                handler,
-            };
         },
     });
 });

package/runtime/handlers/python.d.ts

@@ -1 +1 @@
-export declare const usePythonHandler: () => void;
+export declare const usePythonHandler: () => Promise<void>;

package/runtime/handlers/python.js

@@ -18,10 +18,10 @@ const RUNTIME_MAP = {
     "python3.8": Runtime.PYTHON_3_8,
     "python3.9": Runtime.PYTHON_3_9,
 };
-export const usePythonHandler = Context.memo(() => {
-    const workers = useRuntimeWorkers();
+export const usePythonHandler = Context.memo(async () => {
+    const workers = await useRuntimeWorkers();
+    const server = await useRuntimeServerConfig();
     const handlers = useRuntimeHandlers();
-    const server = useRuntimeServerConfig();
     const processes = new Map();
     const sources = new Map();
     handlers.register({

package/runtime/handlers.js

@@ -4,7 +4,7 @@ import path from "path";
 import fs from "fs/promises";
 import { useWatcher } from "../watcher.js";
 import { useBus } from "../bus.js";
-import { useProject } from "../app.js";
+import { useProject } from "../project.js";
 import { useFunctions } from "../constructs/Function.js";
 export const useRuntimeHandlers = Context.memo(() => {
     const handlers = [];
@@ -19,7 +19,7 @@ export const useRuntimeHandlers = Context.memo(() => {
         for: (runtime) => {
             const result = handlers.find((x) => x.canHandle(runtime));
             if (!result)
-                throw new Error(`No handler found for runtime ${runtime}`);
+                throw new Error(`${runtime} runtime is unsupported`);
             return result;
         },
         async build(functionID, mode) {
@@ -101,17 +101,20 @@ export const useFunctionBuilder = Context.memo(() => {
     };
     const watcher = useWatcher();
     watcher.subscribe("file.changed", async (evt) => {
-        const functions = useFunctions();
-        for (const [functionID, props] of Object.entries(functions.all)) {
-            const handler = handlers.for(props.runtime);
-            if (!handler?.shouldBuild({
-                functionID,
-                file: evt.properties.file,
-            }))
-                continue;
-            await result.build(functionID);
-            Logger.debug("Rebuilt function", functionID);
+        try {
+            const functions = useFunctions();
+            for (const [functionID, props] of Object.entries(functions.all)) {
+                const handler = handlers.for(props.runtime);
+                if (!handler?.shouldBuild({
+                    functionID,
+                    file: evt.properties.file,
+                }))
+                    continue;
+                await result.build(functionID);
+                Logger.debug("Rebuilt function", functionID);
+            }
         }
+        catch { }
     });
     return result;
 });

package/runtime/iot.js

@@ -11,4 +11,7 @@ export const useIOTBridge = Context.memo(async () => {
     bus.subscribe("function.error", async (evt) => {
         iot.publish(topic, "function.error", evt.properties);
     });
+    bus.subscribe("function.ack", async (evt) => {
+        iot.publish(topic, "function.ack", evt.properties);
+    });
 });

package/runtime/runtime.d.ts

@@ -1,6 +1,10 @@
 import "../bus.js";
 declare module "../bus.js" {
     interface Events {
+        "function.ack": {
+            workerID: string;
+            functionID: string;
+        };
         "function.invoked": {
             workerID: string;
             functionID: string;

package/runtime/server.d.ts

@@ -1,6 +1,6 @@
-export declare const useRuntimeServerConfig: () => {
+export declare const useRuntimeServerConfig: () => Promise<{
     API_VERSION: string;
-    url: string;
     port: number;
-};
+    url: string;
+}>;
 export declare const useRuntimeServer: () => Promise<void>;

package/runtime/server.js

@@ -4,18 +4,22 @@ import { useBus } from "../bus.js";
 import { Logger } from "../logger.js";
 import { useRuntimeWorkers } from "./workers.js";
 import https from "https";
-export const useRuntimeServerConfig = Context.memo(() => {
+import getPort from "get-port";
+export const useRuntimeServerConfig = Context.memo(async () => {
+    const port = await getPort({
+        port: 12557,
+    });
     return {
         API_VERSION: "2018-06-01",
-        url: "http://localhost:12557",
-        port: 12557,
+        port,
+        url: `http://localhost:${port}`,
     };
 });
 export const useRuntimeServer = Context.memo(async () => {
     const bus = useBus();
     const app = express();
-    const workers = useRuntimeWorkers();
-    const cfg = useRuntimeServerConfig();
+    const workers = await useRuntimeWorkers();
+    const cfg = await useRuntimeServerConfig();
     const workersWaiting = new Map();
     const invocationsQueued = new Map();
     function next(workerID) {
@@ -54,6 +58,8 @@ export const useRuntimeServer = Context.memo(async () => {
     }), async (req, res) => {
         const worker = workers.fromID(req.params.workerID);
         bus.publish("function.error", {
+            requestID: workers.getCurrentRequestID(worker.workerID),
+            workerID: worker.workerID,
             functionID: worker.functionID,
             ...req.body,
         });

package/runtime/workers.d.ts

@@ -24,13 +24,15 @@ interface Worker {
     workerID: string;
     functionID: string;
 }
-export declare const useRuntimeWorkers: () => {
+export declare const useRuntimeWorkers: () => Promise<{
     fromID(workerID: string): Worker;
+    getCurrentRequestID(workerID: string): string | undefined;
+    setCurrentRequestID(workerID: string, requestID: string): void;
     stdout(workerID: string, message: string): void;
     exited(workerID: string): void;
     subscribe: <Type extends "worker.started" | "worker.stopped" | "worker.exited" | "worker.stdout">(type: Type, cb: (payload: import("../bus.js").EventPayload<Type>) => void) => {
         type: keyof import("../bus.js").Events;
         cb: (payload: any) => void;
     };
-};
+}>;
 export {};

package/runtime/workers.js

@@ -3,12 +3,12 @@ import { useBus } from "../bus.js";
 import { useFunctionBuilder, useRuntimeHandlers } from "./handlers.js";
 import { useRuntimeServerConfig } from "./server.js";
 import { useFunctions } from "../constructs/Function.js";
-export const useRuntimeWorkers = Context.memo(() => {
+export const useRuntimeWorkers = Context.memo(async () => {
     const workers = new Map();
     const bus = useBus();
     const handlers = useRuntimeHandlers();
     const builder = useFunctionBuilder();
-    const server = useRuntimeServerConfig();
+    const server = await useRuntimeServerConfig();
     handlers.subscribe("function.build.success", async (evt) => {
         for (const [_, worker] of workers) {
             if (worker.functionID === evt.properties.functionID) {
@@ -21,8 +21,11 @@ export const useRuntimeWorkers = Context.memo(() => {
     });
     const lastRequestId = new Map();
     bus.subscribe("function.invoked", async (evt) => {
+        bus.publish("function.ack", {
+            functionID: evt.properties.functionID,
+            workerID: evt.properties.workerID,
+        });
         let worker = workers.get(evt.properties.workerID);
-        lastRequestId.set(evt.properties.workerID, evt.properties.context.awsRequestId);
         if (worker)
             return;
         const props = useFunctions().fromID(evt.properties.functionID);
@@ -32,6 +35,7 @@ export const useRuntimeWorkers = Context.memo(() => {
         const build = await builder.artifact(evt.properties.functionID);
         if (!build)
             return;
+        lastRequestId.set(evt.properties.workerID, evt.properties.requestID);
         await handler.startWorker({
             ...build,
             workerID: evt.properties.workerID,
@@ -51,6 +55,12 @@ export const useRuntimeWorkers = Context.memo(() => {
         fromID(workerID) {
             return workers.get(workerID);
         },
+        getCurrentRequestID(workerID) {
+            return lastRequestId.get(workerID);
+        },
+        setCurrentRequestID(workerID, requestID) {
+            lastRequestId.set(workerID, requestID);
+        },
         stdout(workerID, message) {
             const worker = workers.get(workerID);
             bus.publish("worker.stdout", {

package/site-env.js

@@ -1,7 +1,7 @@
 export * as SiteEnv from "./site-env.js";
 import fs from "fs";
 import path from "path";
-import { useProject } from "./app.js";
+import { useProject } from "./project.js";
 function keysFile() {
     return path.join(useProject().paths.out, "site-environment-keys.jsonl");
 }
@@ -37,6 +37,7 @@ export async function writeValues(input) {
     await fs.promises.writeFile(file, JSON.stringify(input));
 }
 export function append(input) {
+    input.path = path.resolve(useProject().paths.root, input.path);
     fs.appendFileSync(keysFile(), JSON.stringify(input) + "\n");
 }
 export function reset() {