sst 2.18.4 → 2.19.1

package/constructs/Function.js

@@ -12,17 +12,20 @@ import * as functionUrlCors from "./util/functionUrlCors.js";
 import url from "url";
 import { useDeferredTasks } from "./deferred_task.js";
 import { useProject } from "../project.js";
+import { VisibleError } from "../error.js";
 import { useRuntimeHandlers } from "../runtime/handlers.js";
 import { createAppContext } from "./context.js";
 import { useWarning } from "./util/warning.js";
-import { Architecture, AssetCode, Code, Function as CDKFunction, FunctionUrlAuthType, LayerVersion, Runtime as CDKRuntime, Tracing, } from "aws-cdk-lib/aws-lambda";
+import { Architecture, AssetCode, Code, Function as CDKFunction, FunctionUrlAuthType, Handler as CDKHandler, LayerVersion, Runtime as CDKRuntime, Tracing, } from "aws-cdk-lib/aws-lambda";
 import { RetentionDays } from "aws-cdk-lib/aws-logs";
 import { Token, Size as CDKSize, Duration as CDKDuration, } from "aws-cdk-lib/core";
 import { Effect, PolicyStatement } from "aws-cdk-lib/aws-iam";
 import { StringParameter } from "aws-cdk-lib/aws-ssm";
+import { Platform } from "aws-cdk-lib/aws-ecr-assets";
 import { useBootstrap } from "../bootstrap.js";
 const __dirname = url.fileURLToPath(new URL(".", import.meta.url));
 const supportedRuntimes = {
+    container: CDKRuntime.FROM_IMAGE,
     rust: CDKRuntime.PROVIDED_AL2,
     nodejs: CDKRuntime.NODEJS,
     "nodejs4.3": CDKRuntime.NODEJS_4_3,
@@ -96,7 +99,7 @@ export class Function extends CDKFunction {
                 return Architecture.ARM_64;
             if (props.architecture === "x86_64")
                 return Architecture.X86_64;
-            return undefined;
+            return Architecture.X86_64;
         })();
         const memorySize = Function.normalizeMemorySize(props.memorySize);
         const diskSize = Function.normalizeDiskSize(props.diskSize);
@@ -147,17 +150,30 @@ export class Function extends CDKFunction {
             }
             super(scope, id, {
                 ...props,
+                ...(props.runtime === "container"
+                    ? {
+                        code: Code.fromAssetImage(path.resolve(__dirname, "../support/bridge"), {
+                            ...(architecture?.dockerPlatform
+                                ? { platform: Platform.custom(architecture.dockerPlatform) }
+                                : {}),
+                        }),
+                        handler: CDKHandler.FROM_IMAGE,
+                        runtime: CDKRuntime.FROM_IMAGE,
+                        layers: undefined,
+                    }
+                    : {
+                        runtime: CDKRuntime.NODEJS_16_X,
+                        code: Code.fromAsset(path.resolve(__dirname, "../support/bridge")),
+                        handler: "bridge.handler",
+                        layers: [],
+                    }),
                 architecture,
-                code: Code.fromAsset(path.resolve(__dirname, "../support/bridge")),
-                handler: "bridge.handler",
                 functionName,
-                runtime: CDKRuntime.NODEJS_16_X,
                 memorySize,
                 ephemeralStorageSize: diskSize,
                 timeout,
                 tracing,
                 environment: props.environment,
-                layers: [],
                 logRetention,
                 logRetentionRetryOptions: logRetention && { maxRetries: 100 },
                 retryAttempts: 0,
@@ -186,17 +202,30 @@ export class Function extends CDKFunction {
         else {
             super(scope, id, {
                 ...props,
+                ...(props.runtime === "container"
+                    ? {
+                        code: Code.fromAssetImage(props.handler, {
+                            ...(architecture?.dockerPlatform
+                                ? { platform: Platform.custom(architecture.dockerPlatform) }
+                                : {}),
+                        }),
+                        handler: CDKHandler.FROM_IMAGE,
+                        runtime: CDKRuntime.FROM_IMAGE,
+                        layers: undefined,
+                    }
+                    : {
+                        code: Code.fromInline("export function placeholder() {}"),
+                        handler: "index.placeholder",
+                        runtime: CDKRuntime.NODEJS_16_X,
+                        layers: Function.buildLayers(scope, id, props),
+                    }),
                 architecture,
-                code: Code.fromInline("export function placeholder() {}"),
-                handler: "index.placeholder",
                 functionName,
-                runtime: CDKRuntime.NODEJS_16_X,
                 memorySize,
                 ephemeralStorageSize: diskSize,
                 timeout,
                 tracing,
                 environment: props.environment,
-                layers: Function.buildLayers(scope, id, props),
                 logRetention,
                 logRetentionRetryOptions: logRetention && { maxRetries: 100 },
             });
@@ -204,11 +233,14 @@ export class Function extends CDKFunction {
                 // Build function
                 const result = await useRuntimeHandlers().build(this.node.addr, "deploy");
                 if (result.type === "error") {
-                    throw new Error([
+                    throw new VisibleError([
                         `Failed to build function "${props.handler}"`,
                         ...result.errors,
                     ].join("\n"));
                 }
+                // No need to update code if runtime is container
+                if (props.runtime === "container")
+                    return;
                 // Update code
                 const cfnFunction = this.node.defaultChild;
                 const code = AssetCode.fromAsset(result.out);

package/constructs/SsrSite.js

@@ -877,9 +877,7 @@ function handler(event) {
     generateBuildId() {
         // We will generate a hash based on the contents of the "public" folder
         // which will be used to indicate if we need to invalidate our CloudFront
-        // cache. As the browser build files are always uniquely hash in their
-        // filenames according to their content we can ignore the browser build
-        // files.
+        // cache.
         // The below options are needed to support following symlinks when building zip files:
         // - nodir: This will prevent symlinks themselves from being copied into the zip.
         // - follow: This will follow symlinks and copy the files within.
@@ -887,7 +885,6 @@ function handler(event) {
             dot: true,
             nodir: true,
             follow: true,
-            ignore: [`${this.buildConfig.clientBuildVersionedSubDir}/**`],
             cwd: path.resolve(this.props.path, this.buildConfig.clientBuildOutputDir),
         };
         const files = glob.sync("**", globOptions);

package/package.json

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

package/project.d.ts

@@ -29,6 +29,7 @@ export interface ConfigOptions {
         imageAssetPublishingRoleArn?: string;
         cloudFormationExecutionRole?: string;
         lookupRoleArn?: string;
+        pathMetadata?: boolean;
     };
 }
 declare const DEFAULTS: {

package/runtime/handlers/container.d.ts

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

package/runtime/handlers/container.js

@@ -0,0 +1,124 @@
+import { useRuntimeHandlers } from "../handlers.js";
+import { useRuntimeWorkers } from "../workers.js";
+import { Context } from "../../context/context.js";
+import { VisibleError } from "../../error.js";
+import { spawn } from "child_process";
+import { useRuntimeServerConfig } from "../server.js";
+import { isChild } from "../../util/fs.js";
+import { execAsync } from "../../util/process.js";
+export const useContainerHandler = Context.memo(async () => {
+    const workers = await useRuntimeWorkers();
+    const server = await useRuntimeServerConfig();
+    const handlers = useRuntimeHandlers();
+    const containers = new Map();
+    const sources = new Map();
+    handlers.register({
+        shouldBuild: (input) => {
+            const parent = sources.get(input.functionID);
+            if (!parent)
+                return false;
+            return isChild(parent, input.file);
+        },
+        canHandle: (input) => input.startsWith("container"),
+        startWorker: async (input) => {
+            const name = `sst-workerID-${input.workerID}-${Date.now()}`;
+            const proc = spawn("docker", [
+                "run",
+                "--rm",
+                "--network=host",
+                `--name=${name}`,
+                ...Object.entries({
+                    ...input.environment,
+                    IS_LOCAL: "true",
+                    AWS_LAMBDA_RUNTIME_API: `host.docker.internal:${server.port}/${input.workerID}`,
+                })
+                    .map(([key, value]) => ["-e", `${key}=${value}`])
+                    .flat(),
+                `sst-dev:${input.functionID}`,
+            ], {
+                env: {
+                    ...process.env,
+                },
+                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());
+            });
+            containers.set(input.workerID, name);
+        },
+        stopWorker: async (workerID) => {
+            const name = containers.get(workerID);
+            if (name) {
+                try {
+                    // note:
+                    // - calling `docker kill` kills the docker process much faster than `docker stop`
+                    // - process.kill() does not work on docker processes
+                    await execAsync(`docker kill ${name}`, {
+                        env: {
+                            ...process.env,
+                        },
+                    });
+                }
+                catch (ex) {
+                    console.error(ex);
+                    throw new VisibleError(`Could not stop docker container ${name}`);
+                }
+                containers.delete(workerID);
+            }
+        },
+        build: async (input) => {
+            const project = input.props.handler;
+            sources.set(input.functionID, project);
+            if (input.mode === "start") {
+                try {
+                    const result = await execAsync(`docker build -t sst-dev:${input.functionID} .`, {
+                        cwd: project,
+                        env: {
+                            ...process.env,
+                        },
+                    });
+                }
+                catch (ex) {
+                    return {
+                        type: "error",
+                        errors: [String(ex)],
+                    };
+                }
+            }
+            if (input.mode === "deploy") {
+                try {
+                    const platform = input.props.architecture === "arm_64"
+                        ? "linux/arm64"
+                        : "linux/amd64";
+                    await execAsync([
+                        `docker build`,
+                        `-t sst-build:${input.functionID}`,
+                        `--platform ${platform}`,
+                        `.`,
+                    ].join(" "), {
+                        cwd: project,
+                        env: {
+                            ...process.env,
+                        },
+                    });
+                }
+                catch (ex) {
+                    return {
+                        type: "error",
+                        errors: [String(ex)],
+                    };
+                }
+            }
+            return {
+                type: "success",
+                handler: "not required for container",
+            };
+        },
+    });
+});

package/runtime/handlers.d.ts

@@ -1,6 +1,9 @@
 import { FunctionProps } from "../constructs/Function.js";
 declare module "../bus.js" {
     interface Events {
+        "function.build.started": {
+            functionID: string;
+        };
         "function.build.success": {
             functionID: string;
         };
@@ -19,6 +22,7 @@ interface BuildInput {
 interface StartWorkerInput {
     url: string;
     workerID: string;
+    functionID: string;
     environment: Record<string, string>;
     out: string;
     handler: string;

package/runtime/handlers.js

@@ -34,6 +34,7 @@ export const useRuntimeHandlers = Context.memo(() => {
                 const out = path.join(project.paths.artifacts, functionID);
                 await fs.rm(out, { recursive: true, force: true });
                 await fs.mkdir(out, { recursive: true });
+                bus.publish("function.build.started", { functionID });
                 if (func.hooks?.beforeBuild)
                     await func.hooks.beforeBuild(func, out);
                 const built = await handler.build({

package/runtime/workers.js

@@ -43,6 +43,7 @@ export const useRuntimeWorkers = Context.memo(async () => {
         await handler.startWorker({
             ...build,
             workerID: evt.properties.workerID,
+            functionID: evt.properties.functionID,
             environment: evt.properties.env,
             url: `${server.url}/${evt.properties.workerID}/${server.API_VERSION}`,
             runtime: props.runtime,