@intelligems/sst 2.49.3 → 2.49.6-ig.2

package/cli/commands/dev.js

@@ -92,9 +92,10 @@ export const dev = (program) => program.command(["dev", "start"], "Work on your
                     return;
                 if (info.enableLiveDev === false)
                     return;
+                const buildType = evt.properties.monoBundle ? "(mono-bundle)" : "(individual)";
                 Colors.line(info.runtime === "container"
-                    ? Colors.dim(Colors.prefix, "Built", info.handler, "container")
-                    : Colors.dim(Colors.prefix, "Built", info.handler));
+                    ? Colors.dim(Colors.prefix, "Built", info.handler, "container", buildType)
+                    : Colors.dim(Colors.prefix, "Built", info.handler, buildType));
             });
             bus.subscribe("function.build.failed", async (evt) => {
                 const info = useFunctions().fromID(evt.properties.functionID);

package/constructs/Function.d.ts

@@ -24,6 +24,7 @@ declare const supportedRuntimes: {
     "python3.10": CDKRuntime;
     "python3.11": CDKRuntime;
     "python3.12": CDKRuntime;
+    "python3.13": CDKRuntime;
     "dotnetcore3.1": CDKRuntime;
     dotnet6: CDKRuntime;
     dotnet8: CDKRuntime;
@@ -798,7 +799,7 @@ export declare class Function extends CDKFunction implements SSTConstruct {
         type: "Function";
         data: {
             arn: string;
-            runtime: "container" | "rust" | "nodejs16.x" | "nodejs18.x" | "nodejs20.x" | "nodejs22.x" | "python3.7" | "python3.8" | "python3.9" | "python3.10" | "python3.11" | "python3.12" | "dotnetcore3.1" | "dotnet6" | "dotnet8" | "java8" | "java11" | "java17" | "java21" | "go1.x" | "go" | undefined;
+            runtime: "container" | "rust" | "nodejs16.x" | "nodejs18.x" | "nodejs20.x" | "nodejs22.x" | "python3.7" | "python3.8" | "python3.9" | "python3.10" | "python3.11" | "python3.12" | "python3.13" | "dotnetcore3.1" | "dotnet6" | "dotnet8" | "java8" | "java11" | "java17" | "java21" | "go1.x" | "go" | undefined;
             handler: string | undefined;
             missingSourcemap: boolean | undefined;
             localId: string;

package/constructs/Function.js

@@ -43,6 +43,7 @@ const supportedRuntimes = {
     "python3.10": CDKRuntime.PYTHON_3_10,
     "python3.11": CDKRuntime.PYTHON_3_11,
     "python3.12": CDKRuntime.PYTHON_3_12,
+    "python3.13": CDKRuntime.PYTHON_3_13,
     "dotnetcore3.1": CDKRuntime.DOTNET_CORE_3_1,
     dotnet6: CDKRuntime.DOTNET_6,
     dotnet8: CDKRuntime.DOTNET_8,
@@ -216,18 +217,18 @@ export class Function extends CDKFunction {
                     ? {
                         code: Code.fromInline("export function placeholder() {}"),
                         handler: "index.placeholder",
-                        runtime: CDKRuntime.NODEJS_20_X,
+                        runtime: CDKRuntime.NODEJS_22_X,
                         layers: undefined,
                     }
                     : props.code ? {
                         code: props.code,
                         handler: "index.handler",
-                        runtime: CDKRuntime.NODEJS_20_X,
+                        runtime: CDKRuntime.NODEJS_22_X,
                         layers: Function.buildLayers(scope, id, props),
                     } : {
                         code: Code.fromInline("export function placeholder() {}"),
                         handler: "index.placeholder",
-                        runtime: CDKRuntime.NODEJS_20_X,
+                        runtime: CDKRuntime.NODEJS_22_X,
                         layers: Function.buildLayers(scope, id, props),
                     }),
                 architecture,

package/credentials.js

@@ -1,4 +1,5 @@
 import path from "path";
+import { fileURLToPath, pathToFileURL } from "url";
 import { fromNodeProviderChain } from "@aws-sdk/credential-providers";
 import { GetCallerIdentityCommand, STSClient } from "@aws-sdk/client-sts";
 import { Logger } from "./logger.js";
@@ -121,9 +122,9 @@ export function useAWSClient(client, force = false) {
 }
 export const useAWSProvider = lazy(async () => {
     const cdkToolkitUrl = await import.meta.resolve("@aws-cdk/toolkit-lib");
-    const cdkToolkitPath = new URL(cdkToolkitUrl).pathname;
-    const { SdkProvider } = await import(path.resolve(cdkToolkitPath, "..", "api", "aws-auth", "sdk-provider.js"));
-    const { IoHelper } = await import(path.resolve(cdkToolkitPath, "..", "api", "io", "private", "io-helper.js"));
+    const cdkToolkitPath = fileURLToPath(cdkToolkitUrl);
+    const { SdkProvider } = await import(pathToFileURL(path.resolve(cdkToolkitPath, "..", "api", "aws-auth", "sdk-provider.js")).href);
+    const { IoHelper } = await import(pathToFileURL(path.resolve(cdkToolkitPath, "..", "api", "io", "private", "io-helper.js")).href);
     const project = useProject();
     return new SdkProvider(useAWSCredentialsProvider(), project.config.region, {
         ioHelper: IoHelper.fromActionAwareIoHost({

package/iot.js

@@ -1,6 +1,8 @@
 import { IoTClient, DescribeEndpointCommand } from "@aws-sdk/client-iot";
 import { useAWSClient, useAWSCredentials } from "./credentials.js";
 import { VisibleError } from "./error.js";
+import { lazy } from "./util/lazy.js";
+import { Logger } from "./logger.js";
 export const useIOTEndpoint = lazy(async () => {
     const iot = useAWSClient(IoTClient);
     Logger.debug("Getting IoT endpoint");
@@ -15,10 +17,8 @@ export const useIOTEndpoint = lazy(async () => {
 import iot from "aws-iot-device-sdk";
 import { useBus } from "./bus.js";
 import { useProject } from "./project.js";
-import { Logger } from "./logger.js";
 import { useBootstrap } from "./bootstrap.js";
 import { PutObjectCommand, S3Client } from "@aws-sdk/client-s3";
-import { lazy } from "./util/lazy.js";
 export const useIOT = lazy(async () => {
     const bus = useBus();
     const endpoint = await useIOTEndpoint();

package/package.json

@@ -1,7 +1,7 @@
 {
   "sideEffects": false,
   "name": "@intelligems/sst",
-  "version": "2.49.3",
+  "version": "2.49.6-ig.2",
   "bin": {
     "sst": "cli/sst.js"
   },

package/package.json.bak

@@ -5,7 +5,7 @@
   },
   "sideEffects": false,
   "name": "@intelligems/sst",
-  "version": "2.49.3",
+  "version": "2.49.6-ig.2",
   "bin": {
     "sst": "cli/sst.js"
   },

package/runtime/handlers/node.js

@@ -61,6 +61,38 @@ export const useNodeHandler = () => {
             await worker?.terminate();
         },
         build: async (input) => {
+            // Check for dev mode mono-bundle: if .mono-build/index.mjs exists, skip individual builds
+            const monoBundleDir = path.join(project.paths.root, ".mono-build");
+            const monoBundlePath = path.join(monoBundleDir, "index.mjs");
+            const monoBundleExists = fsSync.existsSync(monoBundlePath);
+            console.log(`[MONO-BUNDLE] mode=${input.mode}, exists=${monoBundleExists}, handler=${input.props.handler}`);
+            if (input.mode === "start" && monoBundleExists) {
+                console.log(`[MONO-BUNDLE] Using mono-bundle for: ${input.props.handler}`);
+                Logger.debug("Using mono-bundle for dev mode:", monoBundlePath);
+                // Symlink node_modules to mono-bundle dir for external dependencies
+                // Use the same approach as individual builds: find nearest package.json above the handler
+                // handler-functions.ts lives in web/node-backend/src/, so start from there
+                const handlerFunctionsDir = path.join(project.paths.root, "web/node-backend/src");
+                const root = await findAbove(handlerFunctionsDir, "package.json");
+                if (root) {
+                    const sourceNodeModules = path.join(root, "node_modules");
+                    const monoBundleNodeModules = path.join(monoBundleDir, "node_modules");
+                    try {
+                        // Remove existing node_modules in mono-build (might be stale from deploy build)
+                        await fs.rm(monoBundleNodeModules, { recursive: true, force: true });
+                        await fs.symlink(path.resolve(sourceNodeModules), monoBundleNodeModules, "dir");
+                        Logger.debug("Symlinked node_modules for mono-bundle from:", sourceNodeModules);
+                    }
+                    catch (err) {
+                        Logger.debug("Failed to symlink node_modules for mono-bundle:", err);
+                    }
+                }
+                return {
+                    type: "success",
+                    handler: "index.handler",
+                    out: monoBundleDir,
+                };
+            }
             const parsed = path.parse(input.props.handler);
             const file = [
                 ".ts",

package/runtime/handlers.d.ts

@@ -6,6 +6,7 @@ declare module "../bus.js" {
         };
         "function.build.success": {
             functionID: string;
+            monoBundle?: boolean;
         };
         "function.build.failed": {
             functionID: string;
@@ -41,6 +42,7 @@ export interface RuntimeHandler {
         type: "success";
         handler: string;
         sourcemap?: string;
+        out?: string;
     } | {
         type: "error";
         errors: string[];
@@ -57,10 +59,10 @@ export declare const useRuntimeHandlers: () => {
         type: "error";
         errors: string[];
     } | {
-        out: string;
-        sourcemap: string | undefined;
         type: "success";
         handler: string;
+        out: string;
+        sourcemap: string | undefined;
     }>;
 };
 interface Artifact {

package/runtime/handlers.js

@@ -48,6 +48,26 @@ export const useRuntimeHandlers = lazy(() => {
                     };
                 const handler = result.for(func.runtime);
                 const out = path.join(project.paths.artifacts, functionID);
+                // Check for mono-bundle mode by doing a preliminary build call
+                // In mono-bundle mode, handler returns its own out path immediately without building
+                const monoBundleCheck = await handler.build({
+                    functionID,
+                    out,
+                    mode,
+                    props: func,
+                });
+                // If mono-bundle detected (handler returned custom out), skip all artifact work
+                if (monoBundleCheck.type === "success" && monoBundleCheck.out) {
+                    bus.publish("function.build.started", { functionID });
+                    bus.publish("function.build.success", { functionID, monoBundle: true });
+                    return {
+                        type: "success",
+                        handler: monoBundleCheck.handler,
+                        out: monoBundleCheck.out,
+                        sourcemap: monoBundleCheck.sourcemap,
+                    };
+                }
+                // Non-mono-bundle: follow original flow
                 await fs.rm(out, { recursive: true, force: true });
                 await fs.mkdir(out, { recursive: true });
                 bus.publish("function.build.started", { functionID });

package/stacks/deploy.js

@@ -1,4 +1,5 @@
 import path from "path";
+import { fileURLToPath, pathToFileURL } from "url";
 import { useBus } from "../bus.js";
 import { useProject } from "../project.js";
 import { useAWSClient, useAWSProvider } from "../credentials.js";
@@ -7,6 +8,7 @@ import { filterOutputs, isFailed, monitor, } from "./monitor.js";
 import { VisibleError } from "../error.js";
 export async function publishAssets(stacks) {
     Logger.debug("Publishing assets");
+    const { cdk } = useProject().config;
     const results = {};
     for (const stackArtifact of stacks) {
         const cfnStack = await getCloudFormationStack(stackArtifact);
@@ -15,7 +17,7 @@ export async function publishAssets(stacks) {
         await buildAndPublishAssets(deployment, stackArtifact);
         results[stackArtifact.stackName] = {
             isUpdate: cfnStack && cfnStack.StackStatus !== "REVIEW_IN_PROGRESS",
-            params: await buildCloudFormationStackParams(deployment, stackArtifact),
+            params: await buildCloudFormationStackParams(deployment, stackArtifact, cdk),
         };
     }
     return results;
@@ -87,7 +89,7 @@ export async function deploy(stack) {
             cfnStack?.StackStatus === "ROLLBACK_FAILED") {
             await deleteCloudFormationStack(stack.stackName);
         }
-        const stackParams = await buildCloudFormationStackParams(deployment, stack);
+        const stackParams = await buildCloudFormationStackParams(deployment, stack, cdk);
         try {
             cfnStack && cfnStack.StackStatus !== "REVIEW_IN_PROGRESS"
                 ? await updateCloudFormationStack(stackParams)
@@ -192,9 +194,9 @@ async function addInUseExports(stackArtifact, cfnStack) {
 }
 async function createCdkDeployments() {
     const cdkToolkitUrl = await import.meta.resolve("@aws-cdk/toolkit-lib");
-    const cdkToolkitPath = new URL(cdkToolkitUrl).pathname;
-    const { Deployments } = await import(path.resolve(cdkToolkitPath, "..", "api", "deployments", "deployments.js"));
-    const { IoHelper } = await import(path.resolve(cdkToolkitPath, "..", "api", "io", "private", "io-helper.js"));
+    const cdkToolkitPath = fileURLToPath(cdkToolkitUrl);
+    const { Deployments } = await import(pathToFileURL(path.resolve(cdkToolkitPath, "..", "api", "deployments", "deployments.js")).href);
+    const { IoHelper } = await import(pathToFileURL(path.resolve(cdkToolkitPath, "..", "api", "io", "private", "io-helper.js")).href);
     const provider = await useAWSProvider();
     await useAWSProvider();
     const ioHelper = IoHelper.fromActionAwareIoHost({
@@ -227,17 +229,19 @@ async function buildAndPublishAssets(deployment, stackArtifact) {
         }
     }
 }
-async function buildCloudFormationStackParams(deployment, stack) {
-    const resolvedEnv = await deployment.resolveEnvironment(stack);
+async function buildCloudFormationStackParams(deployment, stack, cdkOptions) {
+    const env = await deployment.envs.accessStackForMutableStackOperations(stack);
+    const executionRoleArn = cdkOptions?.cloudFormationExecutionRole ?? await env.replacePlaceholders(stack.cloudFormationExecutionRoleArn);
     const s3Url = stack
-        .stackTemplateAssetObjectUrl.replace("${AWS::AccountId}", resolvedEnv.account)
+        .stackTemplateAssetObjectUrl.replace("${AWS::AccountId}", env.resolvedEnvironment.account)
         .match(/s3:\/\/([^/]+)\/(.*)$/);
     const templateUrl = s3Url
-        ? `https://s3.${resolvedEnv.region}.amazonaws.com/${s3Url[1]}/${s3Url[2]}`
+        ? `https://s3.${env.resolvedEnvironment.region}.amazonaws.com/${s3Url[1]}/${s3Url[2]}`
         : stack.stackTemplateAssetObjectUrl;
     return {
         StackName: stack.stackName,
         TemplateURL: templateUrl,
+        RoleARN: executionRoleArn,
         //TemplateBody: bodyParameter.TemplateBody,
         //Parameters: stackParams.apiParameters,
         Parameters: [],
@@ -257,7 +261,7 @@ async function getCloudFormationStack(stack) {
     const client = useAWSClient(CloudFormationClient);
     try {
         const { Stacks: stacks } = await client.send(new DescribeStacksCommand({
-            StackName: stack.id,
+            StackName: stack.stackName,
         }));
         if (!stacks || stacks.length === 0)
             return;

package/stacks/synth.js

@@ -2,6 +2,7 @@ import { Logger } from "../logger.js";
 import { useProject } from "../project.js";
 import { useAWSProvider, useSTSIdentity } from "../credentials.js";
 import path from "path";
+import { fileURLToPath, pathToFileURL } from "url";
 import { VisibleError } from "../error.js";
 import { Semaphore } from "../util/semaphore.js";
 import { Configuration } from "../util/user-configuration.js";
@@ -11,10 +12,10 @@ export async function synth(opts) {
     const { App } = await import("../constructs/App.js");
     const cxapi = await import("@aws-cdk/cx-api");
     const cdkToolkitUrl = await import.meta.resolve("@aws-cdk/toolkit-lib");
-    const cdkToolkitPath = new URL(cdkToolkitUrl).pathname;
-    const { IoHelper } = await import(path.resolve(cdkToolkitPath, "..", "api", "io", "private", "io-helper.js"));
-    const { PluginHost } = await import(path.resolve(cdkToolkitPath, "..", "api", "plugin", "plugin.js"));
-    const { provideContextValues } = await import(path.resolve(cdkToolkitPath, "..", "context-providers", "index.js"));
+    const cdkToolkitPath = fileURLToPath(cdkToolkitUrl);
+    const { IoHelper } = await import(pathToFileURL(path.resolve(cdkToolkitPath, "..", "api", "io", "private", "io-helper.js")).href);
+    const { PluginHost } = await import(pathToFileURL(path.resolve(cdkToolkitPath, "..", "api", "plugin", "plugin.js")).href);
+    const { provideContextValues } = await import(pathToFileURL(path.resolve(cdkToolkitPath, "..", "context-providers", "index.js")).href);
     const project = useProject();
     const cwd = process.cwd();
     process.chdir(project.paths.root);

package/support/nodejs-runtime/index.mjs

@@ -7,10 +7,22 @@ import fs from "fs";
 import http from "http";
 import url from "url";
 var input = workerData;
-var parsed = path.parse(input.handler);
-var file = [".js", ".jsx", ".mjs", ".cjs"].map((ext) => path.join(input.out, parsed.dir, parsed.name + ext)).find((file2) => {
-  return fs.existsSync(file2);
-});
+var monoBundlePath = path.join(input.out, "index.mjs");
+var useMonoBundle = input.handler === "index.handler" && fs.existsSync(monoBundlePath);
+var file;
+var handlerName;
+if (useMonoBundle) {
+  file = monoBundlePath;
+  handlerName = "handler";
+} else {
+  const parsed = path.parse(input.handler);
+  const foundFile = [".js", ".jsx", ".mjs", ".cjs"].map((ext) => path.join(input.out, parsed.dir, parsed.name + ext)).find((f) => fs.existsSync(f));
+  if (!foundFile) {
+    throw new Error(`Could not find handler file for "${input.handler}"`);
+  }
+  file = foundFile;
+  handlerName = parsed.ext.substring(1);
+}
 var fn;
 function fetch(req) {
   return new Promise((resolve, reject) => {
@@ -44,11 +56,10 @@ function fetch(req) {
 try {
   const { href } = url.pathToFileURL(file);
   const mod = await import(href);
-  const handler = parsed.ext.substring(1);
-  fn = mod[handler];
+  fn = mod[handlerName];
   if (!fn) {
     throw new Error(
-      `Function "${handler}" not found in "${input.handler}". Found ${Object.keys(mod).join(", ")}`
+      useMonoBundle ? `Mono-bundle handler "${handlerName}" not found in "${file}". Found: ${Object.keys(mod).join(", ")}` : `Function "${handlerName}" not found in "${input.handler}". Found: ${Object.keys(mod).join(", ")}`
     );
   }
 } catch (ex) {

package/util/user-configuration.js

@@ -1,16 +1,28 @@
-// @ts-nocheck
 import * as os from "os";
 import * as fs_path from "path";
 import * as fs from "fs";
+import { fileURLToPath, pathToFileURL } from "url";
 export const PROJECT_CONFIG = "cdk.json";
 export const USER_DEFAULTS = "~/.cdk.json";
 const CONTEXT_KEY = "context";
-const cdkToolkitUrl = await import.meta.resolve("@aws-cdk/toolkit-lib");
-const cdkToolkitPath = new URL(cdkToolkitUrl).pathname;
-const { ToolkitError } = await import(cdkToolkitPath);
-const { Context, PROJECT_CONTEXT } = await import(fs_path.resolve(cdkToolkitPath, "..", "api", "context.js"));
-const { Settings } = await import(fs_path.resolve(cdkToolkitPath, "..", "api", "settings.js"));
-const { Tags } = await import(fs_path.resolve(cdkToolkitPath, "..", "api", "tags", "index.js"));
+let cdkToolkitPath = "";
+let cdkToolkitUrl = "";
+try {
+    cdkToolkitUrl = await import.meta.resolve("@aws-cdk/toolkit-lib");
+    cdkToolkitPath = fileURLToPath(cdkToolkitUrl);
+}
+catch (e) {
+    // Fallback for test environment where import.meta.resolve is not available
+    const module = await import("module");
+    const require = module.createRequire(import.meta.url);
+    cdkToolkitPath = require.resolve("@aws-cdk/toolkit-lib");
+    cdkToolkitUrl = pathToFileURL(cdkToolkitPath).href;
+}
+const { ToolkitError } = await import(cdkToolkitUrl);
+const { Context, PROJECT_CONTEXT } = await import(pathToFileURL(fs_path.resolve(cdkToolkitPath, "..", "api", "context.js")).href);
+const { Settings } = await import(pathToFileURL(fs_path.resolve(cdkToolkitPath, "..", "api", "settings.js"))
+    .href);
+const { Tags } = await import(pathToFileURL(fs_path.resolve(cdkToolkitPath, "..", "api", "tags", "index.js")).href);
 export var Command;
 (function (Command) {
     Command["LS"] = "ls";