sst 2.0.28 → 2.0.30

package/constructs/NextjsSite.js

@@ -10,6 +10,7 @@ import { SsrFunction } from "./SsrFunction.js";
 import { EdgeFunction } from "./EdgeFunction.js";
 import { SsrSite } from "./SsrSite.js";
 import { toCdkSize } from "./util/size.js";
+import { PolicyStatement } from "aws-cdk-lib/aws-iam";
 const __dirname = url.fileURLToPath(new URL(".", import.meta.url));
 /**
  * The `NextjsSite` construct is a higher level CDK construct that makes it easy to create a Next.js app.
@@ -72,6 +73,12 @@ export class NextjsSite extends SsrSite {
             environment: {
                 BUCKET_NAME: this.cdk.bucket.bucketName,
             },
+            initialPolicy: [
+                new PolicyStatement({
+                    actions: ["s3:GetObject"],
+                    resources: [this.cdk.bucket.arnForObjects("*")],
+                }),
+            ],
         });
     }
     createMiddlewareEdgeFunctionForRegional() {

package/constructs/RDS.js

@@ -263,7 +263,7 @@ export class RDS extends Construct {
         // - when running resources tests, __dirname is `resources/src`
         // For now we will do `__dirname/../dist` to make both cases work.
         const fn = new Fn(this, "MigrationFunction", {
-            handler: path.resolve(path.join(__dirname, "../support/rds-migrator/index.handler")),
+            handler: path.resolve(path.join(__dirname, "../../support/rds-migrator/index.handler")),
             runtime: "nodejs16.x",
             timeout: 900,
             memorySize: 1024,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sst",
-  "version": "2.0.28",
+  "version": "2.0.30",
   "bin": {
     "sst": "cli/sst.js"
   },

package/runtime/handlers/python.js

@@ -91,22 +91,30 @@ export const usePythonHandler = Context.memo(async () => {
                     type: "error",
                     errors: [`Could not find src for ${input.props.handler}`],
                 };
+            await fs.cp(src, input.out, {
+                recursive: true,
+                filter: (src) => !src.includes(".sst"),
+            });
             if (await existsAsync(path.join(src, "Pipfile"))) {
-                await execAsync("pipenv requirements > requirements.txt");
+                await execAsync("pipenv requirements > requirements.txt", {
+                    cwd: input.out,
+                });
             }
             if (await existsAsync(path.join(src, "poetry.lock"))) {
-                await execAsync("poetry export --with-credentials --format requirements.txt --output requirements.txt");
+                await execAsync("poetry export --with-credentials --format requirements.txt --output requirements.txt", {
+                    cwd: input.out,
+                });
             }
             if (await existsAsync(path.join(src, "requirements.txt"))) {
-                await execAsync("pip install -r requirements.txt");
+                await execAsync("pip install -r requirements.txt", {
+                    cwd: input.out,
+                });
             }
-            await fs.cp(src, input.out, {
-                recursive: true,
-                filter: (src) => !src.includes(".sst"),
-            });
             if (input.props.python?.installCommands) {
                 for (const cmd of input.props.python.installCommands) {
-                    await execAsync(cmd);
+                    await execAsync(cmd, {
+                        cwd: input.out,
+                    });
                 }
             }
             const result = {

package/runtime/handlers/rust.js

@@ -58,6 +58,11 @@ export const useRustHandler = Context.memo(async () => {
         build: async (input) => {
             const parsed = path.parse(input.props.handler);
             const project = await findAbove(parsed.dir, "Cargo.toml");
+            if (!project)
+                return {
+                    type: "error",
+                    errors: ["Could not find a Cargo.toml file"],
+                };
             sources.set(input.functionID, project);
             if (input.mode === "start") {
                 try {

package/sst.mjs

@@ -181,7 +181,7 @@ import fs2 from "fs/promises";
 import path2 from "path";
 async function findAbove(dir, target) {
   if (dir === "/")
-    throw new VisibleError(`Could not find a ${target} file`);
+    return void 0;
   if (await existsAsync(path2.join(dir, target)))
     return dir;
   return findAbove(path2.resolve(path2.join(dir, "..")), target);
@@ -235,6 +235,8 @@ import path3 from "path";
 async function load(input) {
   const parsed = path3.parse(input);
   const root = await findAbove(input, "package.json");
+  if (!root)
+    throw new VisibleError("Could not find a package.json file");
   const outfile = path3.join(parsed.dir, `.${parsed.name}.${Date.now()}.mjs`);
   const pkg = JSON.parse(
     await fs3.readFile(path3.join(root, "package.json")).then((x) => x.toString())
@@ -5132,6 +5134,11 @@ var init_rust = __esm({
         build: async (input) => {
           const parsed = path12.parse(input.props.handler);
           const project = await findAbove(parsed.dir, "Cargo.toml");
+          if (!project)
+            return {
+              type: "error",
+              errors: ["Could not find a Cargo.toml file"]
+            };
           sources.set(input.functionID, project);
           if (input.mode === "start") {
             try {
@@ -5283,24 +5290,33 @@ var init_python = __esm({
               type: "error",
               errors: [`Could not find src for ${input.props.handler}`]
             };
+          await fs13.cp(src, input.out, {
+            recursive: true,
+            filter: (src2) => !src2.includes(".sst")
+          });
           if (await existsAsync(path13.join(src, "Pipfile"))) {
-            await execAsync4("pipenv requirements > requirements.txt");
+            await execAsync4("pipenv requirements > requirements.txt", {
+              cwd: input.out
+            });
           }
           if (await existsAsync(path13.join(src, "poetry.lock"))) {
             await execAsync4(
-              "poetry export --with-credentials --format requirements.txt --output requirements.txt"
+              "poetry export --with-credentials --format requirements.txt --output requirements.txt",
+              {
+                cwd: input.out
+              }
             );
           }
           if (await existsAsync(path13.join(src, "requirements.txt"))) {
-            await execAsync4("pip install -r requirements.txt");
+            await execAsync4("pip install -r requirements.txt", {
+              cwd: input.out
+            });
           }
-          await fs13.cp(src, input.out, {
-            recursive: true,
-            filter: (src2) => !src2.includes(".sst")
-          });
           if (input.props.python?.installCommands) {
             for (const cmd of input.props.python.installCommands) {
-              await execAsync4(cmd);
+              await execAsync4(cmd, {
+                cwd: input.out
+              });
             }
           }
           const result = {

package/stacks/build.js

@@ -7,6 +7,8 @@ import { VisibleError } from "../error.js";
 export async function load(input) {
     const parsed = path.parse(input);
     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`);
     const pkg = JSON.parse(await fs.readFile(path.join(root, "package.json")).then((x) => x.toString()));
     try {

package/util/fs.d.ts

@@ -1,4 +1,4 @@
-export declare function findAbove(dir: string, target: string): Promise<string>;
+export declare function findAbove(dir: string, target: string): Promise<string | undefined>;
 export declare function findBelow(dir: string, target: string): Promise<string>;
 export declare function isChild(parent: string, child: string): boolean;
 export declare function existsAsync(input: string): Promise<boolean>;

package/util/fs.js

@@ -3,7 +3,7 @@ import fs from "fs/promises";
 import path from "path";
 export async function findAbove(dir, target) {
     if (dir === "/")
-        throw new VisibleError(`Could not find a ${target} file`);
+        return undefined;
     if (await existsAsync(path.join(dir, target)))
         return dir;
     return findAbove(path.resolve(path.join(dir, "..")), target);