sst 2.0.0-rc.2 → 2.0.0-rc.21

package/project.d.ts

@@ -0,0 +1,44 @@
+import { Metafile } from "esbuild";
+import { App } from "./constructs/App.js";
+export interface SSTConfig {
+    config: (globals: GlobalOptions) => Promise<ConfigOptions> | ConfigOptions;
+    stacks: (app: App) => Promise<void> | void;
+}
+export interface ConfigOptions {
+    name: string;
+    region?: string;
+    stage?: string;
+    profile?: string;
+    ssmPrefix?: string;
+}
+declare const DEFAULTS: {
+    readonly stage: undefined;
+    readonly ssmPrefix: undefined;
+};
+interface Project {
+    config: ConfigOptions & Required<{
+        [key in keyof typeof DEFAULTS]: Exclude<ConfigOptions[key], undefined>;
+    }>;
+    version: string;
+    paths: {
+        root: string;
+        config: string;
+        out: string;
+        artifacts: string;
+    };
+    metafile: Metafile;
+    stacks: SSTConfig["stacks"];
+}
+export declare const ProjectContext: {
+    use(): Project;
+    provide(value: Project): void;
+};
+export declare function useProject(): Project;
+interface GlobalOptions {
+    profile?: string;
+    stage?: string;
+    root?: string;
+    region?: string;
+}
+export declare function initProject(globals: GlobalOptions): Promise<void>;
+export {};

package/{app.js → project.js}

@@ -7,10 +7,9 @@ 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 { Stacks } from "./stacks/index.js";
 const DEFAULTS = {
-    main: "stacks/index.ts",
     stage: undefined,
     ssmPrefix: undefined,
 };
@@ -18,65 +17,71 @@ export const ProjectContext = Context.create();
 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")));
-                }
+    let file;
+    const [metafile, sstConfig] = await (async function () {
+        for (const ext of CONFIG_EXTENSIONS) {
+            file = path.join(root, "sst" + ext);
+            try {
+                await fs.access(file);
             }
-            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"),
+            catch {
+                continue;
+            }
+            const [metafile, config] = await Stacks.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 = config.stage ||
+        globals.stage ||
+        (await usePersonalStage(out)) ||
+        (await promptPersonalStage(out));
+    const project = {
+        version: 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;
+            }
+            catch {
+                return "unknown";
+            }
+        })(),
+        config: {
+            ...config,
+            stage,
+            profile: config.profile || globals.profile,
+            region: config.region || globals.region,
+            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}`),
     });
     Logger.debug("Config loaded", project);
 }

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 = {

package/runtime/handlers/java.js

@@ -8,7 +8,7 @@ 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(() => {

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";
@@ -93,9 +93,7 @@ export const useNodeHandler = Context.memo(() => {
                 entryPoints: [file],
                 platform: "node",
                 external: [
-                    ...(nodejs.format === "esm" || input.props.runtime === "nodejs18.x"
-                        ? []
-                        : ["aws-sdk"]),
+                    ...(isESM || input.props.runtime === "nodejs18.x" ? [] : ["aws-sdk"]),
                     ...(nodejs.install || []),
                     ...(external || []),
                 ],
@@ -159,7 +157,10 @@ export const useNodeHandler = Context.memo(() => {
                 }
                 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");
+                    try {
+                        await fs.symlink(path.resolve(dir), path.resolve(path.join(input.out, "node_modules")), "dir");
+                    }
+                    catch { }
                 }
             }
             cache[input.functionID] = result;

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 = [];
@@ -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/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/workers.js

@@ -21,6 +21,10 @@ 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)

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");
 }