sst 2.25.6 → 2.26.1

package/bootstrap.js

@@ -11,18 +11,18 @@ import { LambdaFunction } from "aws-cdk-lib/aws-events-targets";
 import { BlockPublicAccess, Bucket, BucketEncryption, } from "aws-cdk-lib/aws-s3";
 import { useProject } from "./project.js";
 import { createSpinner } from "./cli/spinner.js";
-import { Context } from "./context/context.js";
 import { useAWSClient, useAWSCredentials, useSTSIdentity, } from "./credentials.js";
 import { VisibleError } from "./error.js";
 import { Logger } from "./logger.js";
 import { Stacks } from "./stacks/index.js";
+import { lazy } from "./util/lazy.js";
 const CDK_STACK_NAME = "CDKToolkit";
 const SST_STACK_NAME = "SSTBootstrap";
 const OUTPUT_VERSION = "Version";
 const OUTPUT_BUCKET = "BucketName";
 const LATEST_VERSION = "7.2";
 const __dirname = url.fileURLToPath(new URL(".", import.meta.url));
-export const useBootstrap = Context.memo(async () => {
+export const useBootstrap = lazy(async () => {
     Logger.debug("Initializing bootstrap context");
     let [cdkStatus, sstStatus] = await Promise.all([
         loadCDKStatus(),
@@ -53,7 +53,7 @@ export const useBootstrap = Context.memo(async () => {
     }
     Logger.debug("Bootstrap context initialized", sstStatus);
     return sstStatus;
-}, "Bootstrap");
+});
 async function loadCDKStatus() {
     const { cdk } = useProject().config;
     const client = useAWSClient(CloudFormationClient);

package/bus.js

@@ -1,8 +1,8 @@
 import crypto from "crypto";
-import { Context } from "./context/context.js";
 import { Logger } from "./logger.js";
+import { lazy } from "./util/lazy.js";
 const DO_NOT_LOG = new Set(["stacks.metadata"]);
-export const useBus = Context.memo(() => {
+export const useBus = lazy(() => {
     const subscriptions = {};
     function subscribers(type) {
         let arr = subscriptions[type];

package/cache.js

@@ -2,8 +2,8 @@ import path from "path";
 import fs from "fs/promises";
 import { useProject } from "./project.js";
 import { Logger } from "./logger.js";
-import { Context } from "./context/context.js";
-export const useCache = Context.memo(async () => {
+import { lazy } from "./util/lazy.js";
+export const useCache = lazy(async () => {
     const project = useProject();
     const cache = path.join(project.paths.out, "cache");
     await fs.mkdir(cache, {

package/cdk/deployments-wrapper.js

@@ -9,7 +9,7 @@ import { publishAssets } from "sst-aws-cdk/lib/util/asset-publishing.js";
 import { AssetManifestBuilder } from "sst-aws-cdk/lib/util/asset-manifest-builder.js";
 import { Deployments, } from "./deployments.js";
 import { makeBodyParameter } from "./deploy-stack.js";
-import { Context } from "../context/context.js";
+import { lazy } from "../util/lazy.js";
 export async function publishDeployAssets(sdkProvider, options) {
     const { deployment, toolkitInfo, stackSdk, resolvedEnvironment, cloudFormationRoleArn, } = await useDeployment().get(sdkProvider, options);
     // TODO
@@ -60,7 +60,7 @@ export async function publishDeployAssets(sdkProvider, options) {
         assetParallelism: options.assetParallelism,
     });
 }
-const useDeployment = Context.memo(() => {
+const useDeployment = lazy(() => {
     const state = new Map();
     return {
         async get(sdkProvider, options) {

package/cli/commands/dev.js

@@ -1,3 +1,4 @@
+import { lazy } from "../../util/lazy.js";
 export const dev = (program) => program.command(["dev", "start"], "Work on your app locally", (yargs) => yargs.option("increase-timeout", {
     type: "boolean",
     description: "Increase function timeout",
@@ -29,7 +30,7 @@ export const dev = (program) => program.command(["dev", "start"], "Work on your
     const { useKyselyTypeGenerator } = await import("./plugins/kysely.js");
     const { useRDSWarmer } = await import("./plugins/warmer.js");
     const { useProject } = await import("../../project.js");
-    const { useMetadata } = await import("../../stacks/metadata.js");
+    const { useMetadataCache } = await import("../../stacks/metadata.js");
     const { useIOT } = await import("../../iot.js");
     const { clear } = await import("../terminal.js");
     const { getCiInfo } = await import("../ci-info.js");
@@ -38,7 +39,7 @@ export const dev = (program) => program.command(["dev", "start"], "Work on your
             console.log(yellow(`Warning: ${bold(`sst start`)} has been renamed to ${bold(`sst dev`)}`));
         }
         const project = useProject();
-        const useFunctionLogger = Context.memo(async () => {
+        const useFunctionLogger = lazy(async () => {
             const bus = useBus();
             const colors = ["#01cdfe", "#ff71ce", "#05ffa1", "#b967ff"];
             let index = 0;
@@ -138,7 +139,7 @@ export const dev = (program) => program.command(["dev", "start"], "Work on your
                 }, 100);
             });
         });
-        const useStackBuilder = Context.memo(async () => {
+        const useStackBuilder = lazy(async () => {
             const watcher = useWatcher();
             const scriptVersion = Date.now().toString();
             let lastDeployed;
@@ -277,7 +278,7 @@ export const dev = (program) => program.command(["dev", "start"], "Work on your
             });
             await build();
         });
-        const useDisconnector = Context.memo(async () => {
+        const useDisconnector = lazy(async () => {
             const bus = useBus();
             const iot = await useIOT();
             bus.subscribe("cli.dev", async (evt) => {
@@ -338,7 +339,7 @@ export const dev = (program) => program.command(["dev", "start"], "Work on your
             useIOTBridge(),
             useRuntimeServer(),
             usePothosBuilder(),
-            useMetadata(),
+            useMetadataCache(),
             useKyselyTypeGenerator(),
             useRDSWarmer(),
             useFunctionLogger(),

package/cli/commands/plugins/kysely.js

@@ -3,11 +3,11 @@ import { DataApiDialect } from "kysely-data-api";
 import { RDSData } from "@aws-sdk/client-rds-data";
 import * as fs from "fs/promises";
 import { PostgresDialect, MysqlDialect, Serializer, Transformer, } from "kysely-codegen";
-import { Context } from "../../../context/context.js";
 import { useBus } from "../../../bus.js";
 import { Logger } from "../../../logger.js";
 import { useAWSClient } from "../../../credentials.js";
-export const useKyselyTypeGenerator = Context.memo(async () => {
+import { lazy } from "../../../util/lazy.js";
+export const useKyselyTypeGenerator = lazy(async () => {
     let databases = [];
     const bus = useBus();
     const logger = Logger.debug.bind(null, "[kysely-codegen]");

package/cli/commands/plugins/pothos.js

@@ -1,5 +1,4 @@
 import { useBus } from "../../../bus.js";
-import { Context } from "../../../context/context.js";
 import { Pothos } from "../../../pothos.js";
 import fs from "fs/promises";
 import { exec } from "child_process";
@@ -7,7 +6,8 @@ import { promisify } from "util";
 const execAsync = promisify(exec);
 import path from "path";
 import { Colors } from "../../colors.js";
-export const usePothosBuilder = Context.memo(() => {
+import { lazy } from "../../../util/lazy.js";
+export const usePothosBuilder = lazy(() => {
     let routes = [];
     const bus = useBus();
     async function build(route) {

package/cli/commands/plugins/warmer.js

@@ -1,8 +1,8 @@
 import { useBus } from "../../../bus.js";
-import { Context } from "../../../context/context.js";
 import { RDSDataClient, ExecuteStatementCommand, } from "@aws-sdk/client-rds-data";
 import { useAWSClient } from "../../../credentials.js";
-export const useRDSWarmer = Context.memo(async () => {
+import { lazy } from "../../../util/lazy.js";
+export const useRDSWarmer = lazy(async () => {
     let interval;
     const bus = useBus();
     const client = useAWSClient(RDSDataClient);

package/cli/local/server.js

@@ -12,9 +12,8 @@ import { sync } from "cross-spawn";
 import { useProject } from "../../project.js";
 import { useBus } from "../../bus.js";
 import getPort from "get-port";
-import { Context } from "../../context/context.js";
-export const useLocalServerConfig = Context.memo(async () => {
-    const project = useProject();
+import { lazy } from "../../util/lazy.js";
+export const useLocalServerConfig = lazy(async () => {
     const port = await getPort({
         port: 13557,
     });
@@ -104,28 +103,29 @@ export async function useLocalServer(opts) {
     const wss = new WebSocketServer({ noServer: true });
     const wss2 = new WebSocketServer({ noServer: true });
     const sockets = new Set();
-    let buffer = [
-        {
-            type: "cli.dev",
-            properties: {
-                stage: project.config.stage,
-                app: project.config.name,
-            },
-        },
-    ];
-    function publish(type, properties) {
-        const msg = {
-            type,
-            properties,
-        };
-        buffer.push(msg);
-        const json = JSON.stringify(msg);
+    let invocations = [];
+    function publish(invocation) {
+        invocations.push(invocation);
+        const json = JSON.stringify({
+            type: "invocation",
+            properties: [invocation],
+        });
         [...sockets.values()].map((s) => s.send(json));
     }
     wss2.on("connection", (socket, req) => {
         sockets.add(socket);
-        for (const msg of buffer) {
-            socket.send(JSON.stringify(msg));
+        socket.send(JSON.stringify({
+            type: "cli.dev",
+            properties: {
+                app: project.config.name,
+                stage: project.config.stage,
+            },
+        }));
+        for (const invocation of invocations) {
+            socket.send(JSON.stringify({
+                type: "invocation",
+                properties: [invocation],
+            }));
         }
         socket.on("close", () => {
             sockets.delete(socket);
@@ -133,7 +133,11 @@ export async function useLocalServer(opts) {
         socket.on("message", (data) => {
             const parsed = JSON.parse(data.toString());
             if (parsed.type === "log.cleared") {
-                buffer = buffer.filter((msg) => msg.properties?.functionID !== parsed.properties?.functionID);
+                if (parsed.properties.source === "all") {
+                    invocations = [];
+                    return;
+                }
+                invocations = invocations.filter((item) => item.source === parsed.properties.source);
             }
         });
     });
@@ -207,7 +211,15 @@ export async function useLocalServer(opts) {
         });
     }
     bus.subscribe("function.invoked", async (evt) => {
-        publish("function.invoked", evt.properties);
+        publish({
+            start: Date.now(),
+            cold: false,
+            input: evt.properties.event,
+            id: evt.properties.requestID,
+            errors: [],
+            logs: [],
+            source: evt.properties.functionID,
+        });
         updateFunction(evt.properties.functionID, (draft) => {
             if (draft.invocations.length >= 25)
                 draft.invocations.pop();
@@ -222,7 +234,15 @@ export async function useLocalServer(opts) {
         });
     });
     bus.subscribe("worker.stdout", (evt) => {
-        publish("worker.stdout", evt.properties);
+        const invocation = invocations.findLast((i) => i.source === evt.properties.functionID);
+        if (invocation) {
+            invocation.logs.push({
+                id: Math.random().toString(),
+                message: evt.properties.message,
+                timestamp: Date.now(),
+            });
+            publish(invocation);
+        }
         updateFunction(evt.properties.functionID, (draft) => {
             const entry = draft.invocations.find((i) => i.id === evt.properties.requestID);
             if (!entry)
@@ -234,7 +254,18 @@ export async function useLocalServer(opts) {
         });
     });
     bus.subscribe("function.success", (evt) => {
-        publish("function.success", evt.properties);
+        const invocation = invocations.findLast((i) => i.source === evt.properties.functionID);
+        if (invocation) {
+            invocation.end = Date.now();
+            invocation.report = {
+                duration: invocation.end - invocation.start,
+                size: 0,
+                xray: "",
+                memory: 0,
+            };
+            invocation.output = evt.properties.body;
+            publish(invocation);
+        }
         updateFunction(evt.properties.functionID, (draft) => {
             const invocation = draft.invocations.find((x) => x.id === evt.properties.requestID);
             if (!invocation)
@@ -247,7 +278,25 @@ export async function useLocalServer(opts) {
         });
     });
     bus.subscribe("function.error", (evt) => {
-        publish("function.error", evt.properties);
+        const invocation = invocations.findLast((i) => i.source === evt.properties.functionID);
+        if (invocation) {
+            invocation.errors.push({
+                id: invocation.id,
+                error: evt.properties.errorType,
+                message: evt.properties.errorMessage,
+                stack: evt.properties.trace.map((t) => ({
+                    raw: t,
+                })),
+            });
+            invocation.end = Date.now();
+            invocation.report = {
+                duration: invocation.end - invocation.start,
+                size: 0,
+                xray: "",
+                memory: 0,
+            };
+            publish(invocation);
+        }
         updateFunction(evt.properties.functionID, (draft) => {
             const invocation = draft.invocations.find((x) => x.id === evt.properties.requestID);
             if (!invocation)

package/cli/spinner.js

@@ -1,7 +1,7 @@
-import { Context } from "../context/context.js";
 import ora from "ora";
 import { Colors } from "./colors.js";
-export const useSpinners = Context.memo(() => {
+import { lazy } from "../util/lazy.js";
+export const useSpinners = lazy(() => {
     const spinners = [];
     return spinners;
 });

package/constructs/App.js

@@ -7,7 +7,7 @@ import { bindParameters, bindType } from "./util/functionBinding.js";
 import { stack } from "./FunctionalStack.js";
 import { Auth } from "./Auth.js";
 import { useDeferredTasks } from "./deferred_task.js";
-import { AppContext } from "./context.js";
+import { provideApp } from "./context.js";
 import { useProject } from "../project.js";
 import { VisibleError } from "../error.js";
 import { Logger } from "../logger.js";
@@ -66,7 +66,7 @@ export class App extends CDKApp {
      */
     constructor(deployProps, props = {}) {
         super(props);
-        AppContext.provide(this);
+        provideApp(this);
         this.appPath = process.cwd();
         this.mode = deployProps.mode;
         this.local = this.mode === "dev";
@@ -221,10 +221,11 @@ export class App extends CDKApp {
                                 stage: this.stage,
                                 bootstrap: bootstrap.bucket,
                                 bucket: sourcemaps[0].bucket.bucketName,
-                                functions: sourcemaps.map((s) => [s.arn, s.key]),
+                                functions: sourcemaps.map((s) => [s.func.functionArn, s.key]),
                             },
                         });
                         resource.node.addDependency(policy);
+                        sourcemaps.forEach((s) => s.func.node.addDependency(resource));
                     }
                 }
                 // Set removal policy

package/constructs/Function.d.ts

@@ -673,14 +673,14 @@ export declare class Function extends CDKFunction implements SSTConstruct {
 export declare const useFunctions: () => {
     sourcemaps: {
         add(stack: string, source: {
-            arn: string;
             bucket: IBucket;
             key: string;
+            func: Function;
         }): void;
         forStack(stack: string): {
-            arn: string;
             bucket: IBucket;
             key: string;
+            func: Function;
         }[];
     };
     fromID(id: string): FunctionProps | undefined;

package/constructs/Function.js

@@ -259,7 +259,7 @@ export class Function extends CDKFunction {
                     useFunctions().sourcemaps.add(stack.stackName, {
                         bucket: asset.bucket,
                         key: asset.s3ObjectKey,
-                        arn: this.functionArn,
+                        func: this,
                     });
                 }
                 // Update code

package/constructs/context.d.ts

@@ -1,8 +1,3 @@
 import { App } from "./App.js";
-export declare const AppContext: {
-    use(): App;
-    reset(): void;
-    provide(value: App): void;
-};
-export declare const useApp: () => App;
-export declare function createAppContext<C>(cb: () => C): () => C;
+export declare function provideApp(app: App): void;
+export declare const createAppContext: <C>(cb: () => C) => () => C;

package/constructs/context.js

@@ -1,9 +1,27 @@
-import { Context } from "../context/context.js";
-export const AppContext = Context.create();
-export const useApp = AppContext.use;
-export function createAppContext(cb) {
-    return Context.memo(() => {
-        AppContext.use();
-        return cb();
-    });
+const AppContext = (() => {
+    let app;
+    const children = new Map();
+    return {
+        set(input) {
+            children.clear();
+            app = input;
+        },
+        get current() {
+            return app;
+        },
+        createAppContext(cb) {
+            return () => {
+                const exists = children.get(cb);
+                if (exists)
+                    return exists;
+                const val = cb();
+                children.set(cb, val);
+                return val;
+            };
+        },
+    };
+})();
+export function provideApp(app) {
+    AppContext.set(app);
 }
+export const createAppContext = AppContext.createAppContext;

package/context/context2.d.ts

@@ -0,0 +1,16 @@
+export declare class ContextNotFoundError extends Error {
+    name: string;
+    constructor(name: string);
+}
+export type Context<T> = ReturnType<typeof create<T>>;
+export declare function create<T>(name: string): {
+    name: string;
+    with<R>(value: T, cb: () => R): R;
+    use(): T;
+    version(): string;
+};
+export declare function memo<T>(cb: () => T): () => T;
+export declare const Context: {
+    create: typeof create;
+    memo: typeof memo;
+};

package/context/context2.js

@@ -0,0 +1,108 @@
+import { AsyncLocalStorage } from "async_hooks";
+export class ContextNotFoundError extends Error {
+    name;
+    constructor(name) {
+        super(`${name} context was not provided. It is possible you have multiple versions of SST installed.`);
+        this.name = name;
+    }
+}
+let count = 0;
+export function create(name) {
+    const storage = new AsyncLocalStorage();
+    const children = [];
+    // notify all memos to reset
+    function reset() {
+        for (const child of children) {
+            child();
+        }
+    }
+    const ctx = {
+        name,
+        with(value, cb) {
+            const version = (++count).toString();
+            return storage.run({ value, version }, () => {
+                return runWithCleanup(cb, () => reset());
+            });
+        },
+        use() {
+            const memo = ContextMemo.getStore();
+            // use is being called within a memo, so track dependency
+            if (memo) {
+                memo.deps.push(ctx);
+                children.push(memo.reset);
+            }
+            const result = storage.getStore();
+            if (result === undefined)
+                throw new ContextNotFoundError(name);
+            return result.value;
+        },
+        version() {
+            const result = storage.getStore();
+            if (result === undefined)
+                throw new ContextNotFoundError(name);
+            return result.version;
+        },
+    };
+    return ctx;
+}
+const ContextMemo = new AsyncLocalStorage();
+export function memo(cb) {
+    const deps = [];
+    const cache = new Map();
+    const children = [];
+    let tracked = false;
+    function key() {
+        return deps.map((dep) => dep.version()).join(",");
+    }
+    function reset() {
+        cache.delete(key());
+        for (const child of children) {
+            child();
+        }
+    }
+    function save(value) {
+        cache.set(key(), value);
+    }
+    return () => {
+        const child = ContextMemo.getStore();
+        if (child) {
+            child.deps.push({ version: () => key() });
+            children.push(child.reset);
+        }
+        // Memo never run so build up dependency list
+        if (!tracked) {
+            return ContextMemo.run({ deps, reset }, () => {
+                return runWithCleanup(cb, (result) => {
+                    tracked = true;
+                    save(result);
+                });
+            });
+        }
+        const cached = cache.get(key());
+        if (cached) {
+            return cached;
+        }
+        const result = cb();
+        save(result);
+        return result;
+    };
+}
+function runWithCleanup(cb, cleanup) {
+    const result = cb();
+    if (result &&
+        typeof result === "object" &&
+        "then" in result &&
+        typeof result.then === "function") {
+        return result.then((value) => {
+            // cleanup
+            cleanup(result);
+            return value;
+        });
+    }
+    cleanup(result);
+    return result;
+}
+export const Context = {
+    create,
+    memo,
+};

package/context/handler.js

@@ -1,5 +1,5 @@
-import { Context } from "./context.js";
-const RequestContext = Context.create("RequestContext");
+import { create } from "./context2.js";
+const RequestContext = create("RequestContext");
 export function useContextType() {
     const ctx = RequestContext.use();
     return ctx.type;
@@ -16,7 +16,6 @@ export function useLambdaContext() {
 }
 export function Handler(type, cb) {
     return function handler(event, context) {
-        RequestContext.provide({ type, event: event, context });
-        return cb(event, context);
+        return RequestContext.with({ type, event: event, context }, () => cb(event, context));
     };
 }

package/credentials.d.ts

@@ -1,16 +1,9 @@
-import { Client } from "@aws-sdk/smithy-client";
-import { RegionInputConfig } from "@aws-sdk/config-resolver";
-import { RetryInputConfig } from "@aws-sdk/middleware-retry";
-import { AwsAuthInputConfig } from "@aws-sdk/middleware-signing";
 import { SdkProvider } from "sst-aws-cdk/lib/api/aws-auth/sdk-provider.js";
-type Config = RegionInputConfig & RetryInputConfig & AwsAuthInputConfig & HostHeaderConditionConfig;
-export declare const useAWSCredentialsProvider: () => import("@aws-sdk/types").AwsCredentialIdentityProvider;
-export declare const useAWSCredentials: () => Promise<import("@aws-sdk/types").AwsCredentialIdentity>;
+export declare const useAWSCredentialsProvider: () => import("@smithy/types").AwsCredentialIdentityProvider;
+export declare const useAWSCredentials: () => Promise<import("@smithy/types").AwsCredentialIdentity>;
 export declare const useSTSIdentity: () => Promise<import("@aws-sdk/client-sts").GetCallerIdentityCommandOutput>;
-export declare function useAWSClient<C extends Client<any, any, any, any>>(client: new (config: Config) => C, force?: boolean): C;
-import { HostHeaderConditionConfig } from "aws-sdk/clients/elbv2.js";
+export declare function useAWSClient<C extends any>(client: new (config: any) => C, force?: boolean): C;
 /**
  * Do not use this. It is only used for AWS CDK compatibility.
  */
 export declare const useAWSProvider: () => Promise<SdkProvider>;
-export {};

package/credentials.js

@@ -1,10 +1,9 @@
-import { Context } from "./context/context.js";
 import { fromNodeProviderChain } from "@aws-sdk/credential-providers";
 import { GetCallerIdentityCommand, STSClient } from "@aws-sdk/client-sts";
 import { Logger } from "./logger.js";
 import { SdkProvider } from "sst-aws-cdk/lib/api/aws-auth/sdk-provider.js";
 import { StandardRetryStrategy } from "@aws-sdk/middleware-retry";
-export const useAWSCredentialsProvider = Context.memo(() => {
+export const useAWSCredentialsProvider = lazy(() => {
     const project = useProject();
     Logger.debug("Using AWS profile", project.config.profile);
     const provider = fromNodeProviderChain({
@@ -39,13 +38,13 @@ export const useAWSCredentials = () => {
     const provider = useAWSCredentialsProvider();
     return provider();
 };
-export const useSTSIdentity = Context.memo(async () => {
+export const useSTSIdentity = lazy(async () => {
     const sts = useAWSClient(STSClient);
     const identity = await sts.send(new GetCallerIdentityCommand({}));
     Logger.debug("Using identity", "Account:", identity.Account, "User:", identity.UserId);
     return identity;
 });
-const useClientCache = Context.memo(() => new Map());
+const useClientCache = lazy(() => new Map());
 export function useAWSClient(client, force = false) {
     const cache = useClientCache();
     const existing = cache.get(client.name);
@@ -108,11 +107,12 @@ import stupid from "aws-sdk/lib/maintenance_mode_message.js";
 stupid.suppress = true;
 import aws from "aws-sdk";
 import { useProject } from "./project.js";
+import { lazy } from "./util/lazy.js";
 const CredentialProviderChain = aws.CredentialProviderChain;
 /**
  * Do not use this. It is only used for AWS CDK compatibility.
  */
-export const useAWSProvider = Context.memo(async () => {
+export const useAWSProvider = lazy(async () => {
     Logger.debug("Loading v2 AWS SDK");
     const project = useProject();
     const creds = await useAWSCredentials();