sst 2.0.0-rc.11 → 2.0.0-rc.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sst",
-  "version": "2.0.0-rc.11",
+  "version": "2.0.0-rc.13",
   "bin": {
     "sst": "cli/sst.js"
   },
@@ -17,6 +17,7 @@
     "./constructs": "./constructs/index.js",
     "./context": "./context/index.js",
     "./node/*": "./node/*/index.js",
+    ".": "./index.js",
     "./*": "./*"
   },
   "homepage": "https://sst.dev",
@@ -68,8 +69,8 @@
     "immer": "9",
     "ink": "^3.2.0",
     "ink-spinner": "^4.0.3",
-    "kysely": "^0.22.0",
-    "kysely-codegen": "^0.8.0",
+    "kysely": "^0.23.3",
+    "kysely-codegen": "^0.9.0",
     "kysely-data-api": "^0.1.4",
     "openid-client": "^5.1.8",
     "ora": "^6.1.2",

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,74 @@ 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",
+    ".json",
+];
 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;
+            }
+            if (file.endsWith("js") || file.endsWith("ts")) {
+                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", "  - sst.config.cjs", "  - sst.config.mjs", "  - sst.config.js", "  - sst.config.ts", "  - sst.json");
+    })();
+    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";

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 = [];

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