sst 2.0.18 → 2.0.19

package/constructs/Function.d.ts

@@ -10,6 +10,7 @@ import { Duration } from "./util/duration.js";
 import { Permissions } from "./util/permission.js";
 import * as functionUrlCors from "./util/functionUrlCors.js";
 declare const supportedRuntimes: {
+    rust: cdk.aws_lambda.Runtime;
     nodejs: cdk.aws_lambda.Runtime;
     "nodejs4.3": cdk.aws_lambda.Runtime;
     "nodejs6.10": cdk.aws_lambda.Runtime;

package/constructs/Function.js

@@ -21,6 +21,7 @@ import { useRuntimeHandlers } from "../runtime/handlers.js";
 import { createAppContext } from "./context.js";
 const __dirname = url.fileURLToPath(new URL(".", import.meta.url));
 const supportedRuntimes = {
+    rust: lambda.Runtime.PROVIDED_AL2,
     nodejs: lambda.Runtime.NODEJS,
     "nodejs4.3": lambda.Runtime.NODEJS_4_3,
     "nodejs6.10": lambda.Runtime.NODEJS_6_10,

package/constructs/WebSocketApi.d.ts

@@ -354,6 +354,7 @@ export declare class WebSocketApi extends Construct implements SSTConstruct {
     };
     private createWebSocketApi;
     private createWebSocketStage;
+    private createCloudWatchRole;
     private addAuthorizer;
     private addRoute;
     private buildRouteAuth;

package/constructs/WebSocketApi.js

@@ -1,8 +1,10 @@
 import { Construct } from "constructs";
+import { CustomResource } from "aws-cdk-lib";
 import * as iam from "aws-cdk-lib/aws-iam";
 import * as apig from "@aws-cdk/aws-apigatewayv2-alpha";
 import * as apigAuthorizers from "@aws-cdk/aws-apigatewayv2-authorizers-alpha";
 import * as apigIntegrations from "@aws-cdk/aws-apigatewayv2-integrations-alpha";
+import { Effect, Policy, PolicyStatement } from "aws-cdk-lib/aws-iam";
 import { Stack } from "./Stack.js";
 import { getFunctionRef, isCDKConstruct } from "./Construct.js";
 import { Function as Fn, } from "./Function.js";
@@ -258,7 +260,10 @@ export class WebSocketApi extends Construct {
                 };
                 this._customDomainUrl = `wss://${customDomainData.url}`;
             }
+            // Create CloudWatch Role
+            const customResource = this.createCloudWatchRole();
             // Create stage
+            // note: create the CloudWatch role before creating the Api
             this.cdk.webSocketStage = new apig.WebSocketStage(this, "Stage", {
                 webSocketApi: this.cdk.webSocketApi,
                 stageName: this.node.root.stage,
@@ -266,10 +271,43 @@ export class WebSocketApi extends Construct {
                 domainMapping,
                 ...webSocketStageProps,
             });
+            this.cdk.webSocketStage.node.addDependency(customResource);
             // Configure Access Log
             this.cdk.accessLogGroup = apigV2AccessLog.buildAccessLogData(this, accessLog, this.cdk.webSocketStage, true);
         }
     }
+    createCloudWatchRole() {
+        const stack = Stack.of(this);
+        const roleName = "apigateway-cloudwatch-logs-role";
+        const roleArn = `arn:${stack.partition}:iam::${stack.account}:role/${roleName}`;
+        const policy = new Policy(this, "APIGatewayCloudWatchRolePolicy", {
+            statements: [
+                new PolicyStatement({
+                    effect: Effect.ALLOW,
+                    actions: ["apigateway:GET", "apigateway:PATCH"],
+                    resources: [
+                        `arn:${stack.partition}:apigateway:${stack.region}::/account`,
+                    ],
+                }),
+                new PolicyStatement({
+                    effect: Effect.ALLOW,
+                    actions: ["iam:CreateRole", "iam:PassRole", "iam:AttachRolePolicy"],
+                    resources: [roleArn],
+                }),
+            ],
+        });
+        stack.customResourceHandler.role?.attachInlinePolicy(policy);
+        const resource = new CustomResource(this, "APIGatewayCloudWatchRole", {
+            serviceToken: stack.customResourceHandler.functionArn,
+            resourceType: "Custom::APIGatewayCloudWatchRole",
+            properties: {
+                roleName,
+                roleArn,
+            },
+        });
+        resource.node.addDependency(policy);
+        return resource;
+    }
     addAuthorizer() {
         const { authorizer } = this.props;
         if (!authorizer || authorizer === "none") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sst",
-  "version": "2.0.18",
+  "version": "2.0.19",
   "bin": {
     "sst": "cli/sst.js"
   },
@@ -29,8 +29,10 @@
     "@aws-cdk/cloudformation-diff": "2.62.2",
     "@aws-cdk/cx-api": "2.62.2",
     "@aws-cdk/region-info": "2.62.2",
+    "@aws-sdk/client-api-gateway": "3.208.0",
     "@aws-sdk/client-cloudformation": "3.208.0",
     "@aws-sdk/client-cloudfront": "3.208.0",
+    "@aws-sdk/client-iam": "3.208.0",
     "@aws-sdk/client-iot": "3.208.0",
     "@aws-sdk/client-iot-data-plane": "3.208.0",
     "@aws-sdk/client-lambda": "3.208.0",

package/runtime/handlers/rust.d.ts

@@ -0,0 +1 @@
+export declare const useRustHandler: () => Promise<void>;

package/runtime/handlers/rust.js

@@ -0,0 +1,96 @@
+import path from "path";
+import fs from "fs/promises";
+import { useRuntimeHandlers } from "../handlers.js";
+import { useRuntimeWorkers } from "../workers.js";
+import { Context } from "../../context/context.js";
+import { VisibleError } from "../../error.js";
+import { exec, spawn } from "child_process";
+import { promisify } from "util";
+import { useRuntimeServerConfig } from "../server.js";
+import { findAbove, isChild } from "../../util/fs.js";
+const execAsync = promisify(exec);
+export const useRustHandler = Context.memo(async () => {
+    const workers = await useRuntimeWorkers();
+    const server = await useRuntimeServerConfig();
+    const handlers = useRuntimeHandlers();
+    const processes = new Map();
+    const sources = new Map();
+    const handlerName = process.platform === "win32" ? `handler.exe` : `handler`;
+    handlers.register({
+        shouldBuild: (input) => {
+            if (!input.file.endsWith(".rs"))
+                return false;
+            const parent = sources.get(input.functionID);
+            if (!parent)
+                return false;
+            const result = isChild(parent, input.file);
+            return result;
+        },
+        canHandle: (input) => input.startsWith("rust"),
+        startWorker: async (input) => {
+            const proc = spawn(path.join(input.out, handlerName), {
+                env: {
+                    ...process.env,
+                    ...input.environment,
+                    IS_LOCAL: "true",
+                    RUST_BACKTRACE: "1",
+                    AWS_LAMBDA_RUNTIME_API: `http://localhost:${server.port}/${input.workerID}`,
+                    AWS_LAMBDA_FUNCTION_MEMORY_SIZE: "1024",
+                },
+                cwd: input.out,
+            });
+            proc.on("exit", () => workers.exited(input.workerID));
+            proc.stdout.on("data", (data) => {
+                workers.stdout(input.workerID, data.toString());
+            });
+            proc.stderr.on("data", (data) => {
+                workers.stdout(input.workerID, data.toString());
+            });
+            processes.set(input.workerID, proc);
+        },
+        stopWorker: async (workerID) => {
+            const proc = processes.get(workerID);
+            if (proc) {
+                proc.kill();
+                processes.delete(workerID);
+            }
+        },
+        build: async (input) => {
+            const parsed = path.parse(input.props.handler);
+            const project = await findAbove(parsed.dir, "Cargo.toml");
+            sources.set(input.functionID, project);
+            if (input.mode === "start") {
+                try {
+                    await execAsync(`cargo build --bin ${parsed.name}`, {
+                        cwd: project,
+                        env: {
+                            ...process.env,
+                        },
+                    });
+                    await fs.cp(path.join(project, `target/debug`, parsed.name), path.join(input.out, "handler"));
+                }
+                catch (ex) {
+                    throw new VisibleError("Failed to build");
+                }
+            }
+            if (input.mode === "deploy") {
+                try {
+                    await execAsync(`cargo lambda build --release --bin ${parsed.name}`, {
+                        cwd: project,
+                        env: {
+                            ...process.env,
+                        },
+                    });
+                    await fs.cp(path.join(project, `target/lambda/`, parsed.name, "bootstrap"), path.join(input.out, "bootstrap"));
+                }
+                catch (ex) {
+                    throw new VisibleError("Failed to build");
+                }
+            }
+            return {
+                type: "success",
+                handler: "handler",
+            };
+        },
+    });
+});

package/runtime/server.js

@@ -74,15 +74,22 @@ export const useRuntimeServer = Context.memo(async () => {
             "Lambda-Runtime-Deadline-Ms": payload.deadline,
             "Lambda-Runtime-Invoked-Function-Arn": payload.context.invokedFunctionArn,
             "Lambda-Runtime-Client-Context": JSON.stringify(payload.context.clientContext || {}),
-            "Lambda-Runtime-Cognito-Identity": JSON.stringify(payload.context.identity || {}),
+            ...(payload.context.identity
+                ? {
+                    "Lambda-Runtime-Cognito-Identity": JSON.stringify(payload.context.identity),
+                }
+                : {}),
         });
         res.json(payload.event);
     });
     app.post(`/:workerID/${cfg.API_VERSION}/runtime/invocation/:awsRequestId/response`, express.json({
         strict: false,
-        type: ["application/json", "application/*+json"],
+        type() {
+            return true;
+        },
         limit: "10mb",
     }), (req, res) => {
+        console.log(JSON.stringify(req.body, null, 4));
         Logger.debug("Worker", req.params.workerID, "got response", req.body);
         const worker = workers.fromID(req.params.workerID);
         bus.publish("function.success", {