sst 2.29.0 → 2.30.1

package/runtime/handlers.js

@@ -13,6 +13,7 @@ import { useJavaHandler } from "./handlers/java.js";
 import { usePythonHandler } from "./handlers/python.js";
 import { useRustHandler } from "./handlers/rust.js";
 import { lazy } from "../util/lazy.js";
+import { Semaphore } from "../util/semaphore.js";
 export const useRuntimeHandlers = lazy(() => {
     const handlers = [
         useNodeHandler(),
@@ -104,9 +105,12 @@ export const useRuntimeHandlers = lazy(() => {
             const promise = task();
             pendingBuilds.set(functionID, promise);
             Logger.debug("Building function", functionID);
-            const r = await promise;
-            pendingBuilds.delete(functionID);
-            return r;
+            try {
+                return await promise;
+            }
+            finally {
+                pendingBuilds.delete(functionID);
+            }
         },
     };
     return result;
@@ -114,6 +118,7 @@ export const useRuntimeHandlers = lazy(() => {
 export const useFunctionBuilder = lazy(() => {
     const artifacts = new Map();
     const handlers = useRuntimeHandlers();
+    const semaphore = new Semaphore(4);
     const result = {
         artifact: (functionID) => {
             if (artifacts.has(functionID))
@@ -121,13 +126,19 @@ export const useFunctionBuilder = lazy(() => {
             return result.build(functionID);
         },
         build: async (functionID) => {
-            const result = await handlers.build(functionID, "start");
-            if (!result)
-                return;
-            if (result.type === "error")
-                return;
-            artifacts.set(functionID, result);
-            return artifacts.get(functionID);
+            const unlock = await semaphore.lock();
+            try {
+                const result = await handlers.build(functionID, "start");
+                if (!result)
+                    return;
+                if (result.type === "error")
+                    return;
+                artifacts.set(functionID, result);
+                return artifacts.get(functionID);
+            }
+            finally {
+                unlock();
+            }
         },
     };
     const watcher = useWatcher();

package/stacks/build.js

@@ -14,7 +14,13 @@ export async function load(input, shallow) {
     const root = await findAbove(input, "package.json");
     if (!root)
         throw new VisibleError("Could not find a package.json file");
-    const outfile = path.join(parsed.dir, `.${parsed.name}.${Date.now()}.mjs`);
+    // Create the output file in the current working directory. This is because
+    // the sst cli command might not always run from where `sst.config.ts` is. When
+    // running from another workspace (ie. running `sst bind` in frontend workspace),
+    // the "sst" package imported from within the output file might resolve to a
+    // different "sst" package than the one resolved by the sst cli command. This
+    // will cause issues like "Project not initialized".
+    const outfile = path.join(process.cwd(), `.${parsed.name}.${Date.now()}.mjs`);
     const pkg = JSON.parse(await fs.readFile(path.join(root, "package.json")).then((x) => x.toString()));
     try {
         // Logger.debug("running esbuild on", input);

package/stacks/synth.js

@@ -5,68 +5,76 @@ import * as contextproviders from "sst-aws-cdk/lib/context-providers/index.js";
 import path from "path";
 import { VisibleError } from "../error.js";
 import fs from "fs/promises";
+import { Semaphore } from "../util/semaphore.js";
+const sem = new Semaphore(1);
 export async function synth(opts) {
     Logger.debug("Synthesizing stacks...");
     const { App } = await import("../constructs/App.js");
     const cxapi = await import("@aws-cdk/cx-api");
     const { Configuration } = await import("sst-aws-cdk/lib/settings.js");
     const project = useProject();
-    const identity = await useSTSIdentity();
-    opts = {
-        ...opts,
-        buildDir: opts.buildDir || path.join(project.paths.out, "dist"),
-    };
-    await fs.rm(opts.buildDir, { recursive: true, force: true });
-    await fs.mkdir(opts.buildDir, { recursive: true });
-    /*
-    console.log(JSON.stringify(cfg.context));
-    const executable = new CloudExecutable({
-      sdkProvider: await useAWSProvider(),
-      configuration: cfg,
-      synthesizer: async () => app.synth() as any
-    });
-    const { assembly } = await executable.synthesize(true);
-    */
-    const cfg = new Configuration();
-    await cfg.load();
-    let previous = new Set();
-    while (true) {
-        const app = new App({
-            account: identity.Account,
-            stage: project.config.stage,
-            name: project.config.name,
-            region: project.config.region,
-            mode: opts.mode,
-            debugIncreaseTimeout: opts.increaseTimeout,
-            debugScriptVersion: opts.scriptVersion,
-            isActiveStack: opts.isActiveStack,
-        }, {
-            outdir: opts.buildDir,
-            context: {
-                ...cfg.context.all,
-                [cxapi.PATH_METADATA_ENABLE_CONTEXT]: project.config.cdk?.pathMetadata ?? false,
-            },
-        });
-        await opts.fn(app);
-        await app.finish();
-        const assembly = app.synth();
-        Logger.debug(assembly.manifest.missing);
-        const { missing } = assembly.manifest;
-        const provider = await useAWSProvider();
-        if (missing && missing.length) {
-            const next = missing.map((x) => x.key);
-            if (next.length === previous.size && next.every((x) => previous.has(x)))
-                throw new VisibleError(formatErrorMessage(next.join("")));
-            Logger.debug("Looking up context for:", next, "Previous:", previous);
-            previous = new Set(next);
-            await contextproviders.provideContextValues(missing, cfg.context, provider);
-            if (cfg.context.keys.length) {
-                await cfg.saveContext();
+    const cwd = process.cwd();
+    process.chdir(project.paths.root);
+    const unlock = await sem.lock();
+    try {
+        return await synthInRoot();
+    }
+    catch (e) {
+        throw e;
+    }
+    finally {
+        unlock();
+        process.chdir(cwd);
+    }
+    async function synthInRoot() {
+        const identity = await useSTSIdentity();
+        opts = {
+            ...opts,
+            buildDir: opts.buildDir || path.join(project.paths.out, "dist"),
+        };
+        await fs.rm(opts.buildDir, { recursive: true, force: true });
+        await fs.mkdir(opts.buildDir, { recursive: true });
+        const cfg = new Configuration();
+        await cfg.load();
+        let previous = new Set();
+        while (true) {
+            const app = new App({
+                account: identity.Account,
+                stage: project.config.stage,
+                name: project.config.name,
+                region: project.config.region,
+                mode: opts.mode,
+                debugIncreaseTimeout: opts.increaseTimeout,
+                debugScriptVersion: opts.scriptVersion,
+                isActiveStack: opts.isActiveStack,
+            }, {
+                outdir: opts.buildDir,
+                context: {
+                    ...cfg.context.all,
+                    [cxapi.PATH_METADATA_ENABLE_CONTEXT]: project.config.cdk?.pathMetadata ?? false,
+                },
+            });
+            await opts.fn(app);
+            await app.finish();
+            const assembly = app.synth();
+            Logger.debug(assembly.manifest.missing);
+            const { missing } = assembly.manifest;
+            const provider = await useAWSProvider();
+            if (missing && missing.length) {
+                const next = missing.map((x) => x.key);
+                if (next.length === previous.size && next.every((x) => previous.has(x)))
+                    throw new VisibleError(formatErrorMessage(next.join("")));
+                Logger.debug("Looking up context for:", next, "Previous:", previous);
+                previous = new Set(next);
+                await contextproviders.provideContextValues(missing, cfg.context, provider);
+                if (cfg.context.keys.length) {
+                    await cfg.saveContext();
+                }
+                continue;
             }
-            continue;
+            Logger.debug("Finished synthesizing");
+            return assembly;
         }
-        Logger.debug("Finished synthesizing");
-        return assembly;
     }
 }
 function formatErrorMessage(message) {

package/util/semaphore.d.ts

@@ -0,0 +1,7 @@
+export declare class Semaphore {
+    private queue;
+    private locked;
+    private maxLocks;
+    constructor(maxLocks?: number);
+    lock(): Promise<() => void>;
+}

package/util/semaphore.js

@@ -0,0 +1,27 @@
+export class Semaphore {
+    queue = [];
+    locked = 0;
+    maxLocks;
+    constructor(maxLocks = 1) {
+        this.maxLocks = maxLocks;
+    }
+    lock() {
+        return new Promise((resolve) => {
+            const unlock = () => {
+                this.locked--;
+                const next = this.queue.shift();
+                if (next) {
+                    this.locked++;
+                    next(unlock);
+                }
+            };
+            if (this.locked < this.maxLocks) {
+                this.locked++;
+                resolve(unlock);
+            }
+            else {
+                this.queue.push(unlock);
+            }
+        });
+    }
+}