sst 2.22.5 → 2.22.7

package/constructs/Function.js

@@ -172,6 +172,7 @@ export class Function extends CDKFunction {
             this.addEnvironment("SST_FUNCTION_ID", this.node.addr);
             useDeferredTasks().add(async () => {
                 const bootstrap = await useBootstrap();
+                const bootstrapBucketArn = `arn:${Stack.of(this).partition}:s3:::${bootstrap.bucket}`;
                 this.attachPermissions([
                     new PolicyStatement({
                         actions: ["iot:*"],
@@ -181,9 +182,7 @@ export class Function extends CDKFunction {
                     new PolicyStatement({
                         actions: ["s3:*"],
                         effect: Effect.ALLOW,
-                        resources: [
-                            `arn:${Stack.of(this).partition}:s3:::${bootstrap.bucket}`,
-                        ],
+                        resources: [bootstrapBucketArn, `${bootstrapBucketArn}/*`],
                     }),
                 ]);
             });

package/constructs/NextjsSite.js

@@ -260,6 +260,7 @@ export class NextjsSite extends SsrSite {
                 "rsc",
                 "next-router-prefetch",
                 "next-router-state-tree",
+                "next-url",
             ]);
         const serverBehavior = this.buildDefaultBehaviorForRegional(cachePolicy);
         return new Distribution(this, "Distribution", {

package/constructs/SsrFunction.js

@@ -79,7 +79,7 @@ export class SsrFunction extends Construct {
         attachPermissionsToRole(this.function.role, permissions);
     }
     createFunction(assetBucket, assetKey) {
-        const { runtime, timeout, memorySize, handler, logRetention } = this.props;
+        const { architecture, runtime, timeout, memorySize, handler, logRetention, } = this.props;
         return new CdkFunction(this, `ServerFunction`, {
             ...this.props,
             handler: handler.split(path.sep).join(path.posix.sep),
@@ -90,7 +90,7 @@ export class SsrFunction extends Construct {
                 : runtime === "nodejs16.x"
                     ? Runtime.NODEJS_16_X
                     : Runtime.NODEJS_18_X,
-            architecture: Architecture.ARM_64,
+            architecture: architecture || Architecture.ARM_64,
             memorySize: typeof memorySize === "string"
                 ? toCdkSize(memorySize).toMebibytes()
                 : memorySize,

package/constructs/Table.js

@@ -356,25 +356,17 @@ export class Table extends Construct {
         else {
             consumerFunction = consumer;
         }
-        eventSourceProps = {
-            startingPosition: lambda.StartingPosition.LATEST,
-            ...(eventSourceProps || {}),
-        };
         // create function
         const fn = Fn.fromDefinition(scope, `Consumer_${this.node.id}_${consumerName}`, consumerFunction, this.props.defaults?.function, `The "defaults.function" cannot be applied if an instance of a Function construct is passed in. Make sure to define all the consumers using FunctionProps, so the Table construct can apply the "defaults.function" to them.`);
         this.functions[consumerName] = fn;
         // create event source
-        const eventSource = new lambdaEventSources.DynamoEventSource(this.cdk.table, eventSourceProps);
-        fn.addEventSource(eventSource);
-        // set filter pattern
-        if (filters && filters.length > 0) {
-            const cfnEventSource = fn.node.children.find((c) => c instanceof lambda.EventSourceMapping)?.node.defaultChild;
-            cfnEventSource.addPropertyOverride("FilterCriteria", {
-                Filters: filters.map((filter) => ({
-                    Pattern: JSON.stringify(filter),
-                })),
-            });
-        }
+        fn.addEventSource(new lambdaEventSources.DynamoEventSource(this.cdk.table, {
+            startingPosition: lambda.StartingPosition.LATEST,
+            filters: filters?.map((filter) => ({
+                pattern: JSON.stringify(filter),
+            })),
+            ...(eventSourceProps || {}),
+        }));
         // attach permissions
         this.permissionsAttachedForAllConsumers.forEach((permissions) => {
             fn.attachPermissions(permissions);

package/credentials.d.ts

@@ -1,4 +1,3 @@
-import "@aws-sdk/types";
 import { Client } from "@aws-sdk/smithy-client";
 import { RegionInputConfig } from "@aws-sdk/config-resolver";
 import { RetryInputConfig } from "@aws-sdk/middleware-retry";

package/credentials.js

@@ -1,4 +1,3 @@
-import "@aws-sdk/types";
 import { Context } from "./context/context.js";
 import { fromNodeProviderChain } from "@aws-sdk/credential-providers";
 import { GetCallerIdentityCommand, STSClient } from "@aws-sdk/client-sts";

package/package.json

@@ -1,7 +1,7 @@
 {
   "sideEffects": false,
   "name": "sst",
-  "version": "2.22.5",
+  "version": "2.22.7",
   "bin": {
     "sst": "cli/sst.js"
   },

package/runtime/handlers/node.js

@@ -1,3 +1,4 @@
+import os from "os";
 import path from "path";
 import fs from "fs/promises";
 import { exec } from "child_process";
@@ -9,14 +10,15 @@ import { Worker } from "worker_threads";
 import { useRuntimeHandlers } from "../handlers.js";
 import { useRuntimeWorkers } from "../workers.js";
 import { Context } from "../../context/context.js";
-import { VisibleError } from "../../error.js";
 import { Colors } from "../../cli/colors.js";
+import { Logger } from "../../logger.js";
+import { findAbove } from "../../util/fs.js";
 export const useNodeHandler = Context.memo(async () => {
     const workers = await useRuntimeWorkers();
     const handlers = useRuntimeHandlers();
-    const cache = {};
+    const rebuildCache = {};
     process.on("exit", () => {
-        for (const { ctx } of Object.values(cache)) {
+        for (const { ctx } of Object.values(rebuildCache)) {
             ctx.dispose();
         }
     });
@@ -24,14 +26,14 @@ export const useNodeHandler = Context.memo(async () => {
     const threads = new Map();
     handlers.register({
         shouldBuild: (input) => {
-            const result = cache[input.functionID];
-            if (!result)
+            const cache = rebuildCache[input.functionID];
+            if (!cache)
                 return false;
             const relative = path
                 .relative(project.paths.root, input.file)
                 .split(path.sep)
                 .join(path.posix.sep);
-            return Boolean(result.last.metafile?.inputs[relative]);
+            return Boolean(cache.result.metafile?.inputs[relative]);
         },
         canHandle: (input) => input.startsWith("nodejs"),
         startWorker: async (input) => {
@@ -62,7 +64,6 @@ export const useNodeHandler = Context.memo(async () => {
             await worker?.terminate();
         },
         build: async (input) => {
-            const exists = cache[input.functionID];
             const parsed = path.parse(input.props.handler);
             const file = [
                 ".ts",
@@ -94,11 +95,29 @@ export const useNodeHandler = Context.memo(async () => {
                 .relative(input.out, target.replace(extension, parsed.ext))
                 .split(path.sep)
                 .join(path.posix.sep);
+            if (input.mode === "start") {
+                const root = await findAbove(parsed.dir, "package.json");
+                if (!root) {
+                    return {
+                        type: "error",
+                        errors: [
+                            `Could not find package.json for handler "${input.props.handler}"`,
+                        ],
+                    };
+                }
+                const dir = path.join(root, "node_modules");
+                try {
+                    await fs.symlink(path.resolve(dir), path.resolve(path.join(input.out, "node_modules")), "dir");
+                }
+                catch { }
+            }
+            // Rebuilt using existing esbuild context
+            const exists = rebuildCache[input.functionID];
             if (exists) {
                 const result = await exists.ctx.rebuild();
-                cache[input.functionID] = {
+                rebuildCache[input.functionID] = {
                     ctx: exists.ctx,
-                    last: result,
+                    result,
                 };
                 return {
                     type: "success",
@@ -171,18 +190,16 @@ export const useNodeHandler = Context.memo(async () => {
                     .forEach(({ path }) => {
                     warnings.push(`You are importing from "${path}" in "${inputPath}". Did you mean to import from "sst/node"?`);
                 }));
-                async function find(dir, target) {
-                    if (dir === "/")
-                        throw new VisibleError("Could not find a package.json file");
-                    if (await fs
-                        .access(path.join(dir, target))
-                        .then(() => true)
-                        .catch(() => false))
-                        return dir;
-                    return find(path.join(dir, ".."), target);
-                }
                 if (input.mode === "deploy" && installPackages) {
-                    const src = await find(parsed.dir, "package.json");
+                    const src = await findAbove(parsed.dir, "package.json");
+                    if (!src) {
+                        return {
+                            type: "error",
+                            errors: [
+                                `Could not find package.json for handler "${input.props.handler}"`,
+                            ],
+                        };
+                    }
                     const json = JSON.parse(await fs
                         .readFile(path.join(src, "package.json"))
                         .then((x) => x.toString()));
@@ -204,17 +221,11 @@ export const useNodeHandler = Context.memo(async () => {
                         });
                     });
                 }
+                // Cache esbuild result and context for rebuild
                 if (input.mode === "start") {
-                    const dir = path.join(await find(parsed.dir, "package.json"), "node_modules");
-                    try {
-                        await fs.symlink(path.resolve(dir), path.resolve(path.join(input.out, "node_modules")), "dir");
-                    }
-                    catch { }
+                    rebuildCache[input.functionID] = { ctx, result };
                 }
-                cache[input.functionID] = {
-                    ctx,
-                    last: result,
-                };
+                logMemoryUsage(input.functionID, input.props.handler);
                 return {
                     type: "success",
                     handler,
@@ -240,3 +251,18 @@ export const useNodeHandler = Context.memo(async () => {
         },
     });
 });
+function logMemoryUsage(functionID, handler) {
+    const printInMB = (bytes) => `${Math.round(bytes / 1024 / 1024)} MB`;
+    const used = process.memoryUsage();
+    for (const key in used) {
+        // @ts-ignore
+        used[key] = printInMB(used[key]);
+    }
+    Logger.debug({
+        functionID,
+        handler,
+        freeMemory: printInMB(os.freemem()),
+        totalMemory: printInMB(os.totalmem()),
+        ...used,
+    });
+}