sst 2.1.16 → 2.1.18

package/constructs/RemixSite.js

@@ -1,18 +1,12 @@
 import fs from "fs";
 import url from "url";
 import path from "path";
-import * as esbuild from "esbuild";
 import { createRequire } from "module";
 const require = createRequire(import.meta.url);
-import { Duration as CdkDuration, RemovalPolicy } from "aws-cdk-lib";
-import * as logs from "aws-cdk-lib/aws-logs";
-import * as lambda from "aws-cdk-lib/aws-lambda";
-import { Logger } from "../logger.js";
+import { Architecture } from "aws-cdk-lib/aws-lambda";
 import { SsrSite } from "./SsrSite.js";
-import { useProject } from "../project.js";
+import { Function } from "./Function.js";
 import { EdgeFunction } from "./EdgeFunction.js";
-import { toCdkSize } from "./util/size.js";
-import { toCdkDuration } from "./util/duration.js";
 const __dirname = url.fileURLToPath(new URL(".", import.meta.url));
 /**
  * The `RemixSite` construct is a higher level CDK construct that makes it easy to create a Remix app.
@@ -60,7 +54,7 @@ export class RemixSite extends SsrSite {
             clientBuildVersionedSubDir: "build",
         };
     }
-    createServerLambdaBundle(wrapperFile, external) {
+    createServerLambdaBundle(wrapperFile) {
         // Create a Lambda@Edge handler for the Remix server bundle.
         //
         // Note: Remix does perform their own internal ESBuild process, but it
@@ -77,84 +71,61 @@ export class RemixSite extends SsrSite {
         // appropriate Lambda@Edge handler. We will utilise an internal asset
         // template to create this wrapper within the "core server build" output
         // directory.
-        Logger.debug(`Creating Lambda@Edge handler for server`);
-        // Resolve the path to create the server lambda handler at.
-        const serverPath = path.join(this.props.path, "build/server.js");
-        // Write the server lambda
-        const templatePath = path.resolve(__dirname, `../support/remix-site-function/${wrapperFile}`);
-        fs.copyFileSync(templatePath, serverPath);
-        Logger.debug(`Bundling server`);
-        // Create a directory that we will use to create the bundled version
-        // of the "core server build" along with our custom Lamba server handler.
-        const outputPath = path.resolve(path.join(useProject().paths.artifacts, `RemixSiteFunction-${this.node.id}-${this.node.addr}`));
+        // Copy the server lambda handler
+        const handler = path.join(this.props.path, "build", "server.js");
+        fs.copyFileSync(path.resolve(__dirname, `../support/remix-site-function/${wrapperFile}`), handler);
         // Copy the Remix polyfil to the server build directory
-        const polyfillSource = path.resolve(__dirname, "../support/remix-site-function/polyfill.js");
+        //
+        // Note: We need to ensure that the polyfills are injected above other code that
+        // will depend on them. Importing them within the top of the lambda code
+        // doesn't appear to guarantee this, we therefore leverage ESBUild's
+        // `inject` option to ensure that the polyfills are injected at the top of
+        // the bundle.
         const polyfillDest = path.join(this.props.path, "build/polyfill.js");
-        fs.copyFileSync(polyfillSource, polyfillDest);
-        const result = esbuild.buildSync({
-            entryPoints: [serverPath],
-            bundle: true,
-            target: "node16",
-            platform: "node",
-            external,
-            outfile: path.join(outputPath, "server.js"),
-            // We need to ensure that the polyfills are injected above other code that
-            // will depend on them. Importing them within the top of the lambda code
-            // doesn't appear to guarantee this, we therefore leverage ESBUild's
-            // `inject` option to ensure that the polyfills are injected at the top of
-            // the bundle.
-            inject: [polyfillDest],
-        });
-        if (result.errors.length > 0) {
-            result.errors.forEach((error) => console.error(error));
-            throw new Error(`There was a problem bundling the server.`);
-        }
-        return outputPath;
+        fs.copyFileSync(path.resolve(__dirname, "../support/remix-site-function/polyfill.js"), polyfillDest);
+        return {
+            handler: path.join(this.props.path, "build", "server.handler"),
+            esbuild: { inject: [polyfillDest] },
+        };
     }
     createFunctionForRegional() {
-        const { runtime: runtimeRaw, timeout, memorySize, environment, cdk, } = this.props;
-        const runtime = this.normalizeRuntime(runtimeRaw);
-        const bundlePath = this.createServerLambdaBundle("regional-server.js", runtime === "nodejs18.x" ? [] : ["aws-sdk"]);
-        return new lambda.Function(this, `ServerFunction`, {
-            description: "Server handler for Remix",
-            handler: "server.handler",
-            currentVersionOptions: {
-                removalPolicy: RemovalPolicy.DESTROY,
+        const { runtime, timeout, memorySize, permissions, environment, bind, cdk, } = this.props;
+        const { handler, esbuild } = this.createServerLambdaBundle("regional-server.js");
+        const fn = new Function(this, `ServerFunction`, {
+            description: "Server handler",
+            handler,
+            logRetention: "three_days",
+            runtime,
+            memorySize,
+            timeout,
+            nodejs: {
+                format: "cjs",
+                install: ["sharp"],
+                esbuild,
             },
-            logRetention: logs.RetentionDays.THREE_DAYS,
-            code: lambda.Code.fromAsset(bundlePath),
-            runtime: runtime === "nodejs14.x"
-                ? lambda.Runtime.NODEJS_14_X
-                : runtime === "nodejs16.x"
-                    ? lambda.Runtime.NODEJS_16_X
-                    : lambda.Runtime.NODEJS_18_X,
-            memorySize: typeof memorySize === "string"
-                ? toCdkSize(memorySize).toMebibytes()
-                : memorySize,
-            timeout: typeof timeout === "string"
-                ? toCdkDuration(timeout)
-                : CdkDuration.seconds(timeout),
+            bind,
             environment,
+            permissions,
             ...cdk?.server,
+            architecture: cdk?.server?.architecture === Architecture.ARM_64 ? "arm_64" : "x86_64",
         });
+        fn._doNotAllowOthersToBind = true;
+        return fn;
     }
     createFunctionForEdge() {
-        const { runtime: runtimeRaw, timeout, memorySize, permissions, environment, } = this.props;
-        const runtime = this.normalizeRuntime(runtimeRaw);
-        const bundlePath = this.createServerLambdaBundle("edge-server.js", runtime === "nodejs18.x" ? [] : ["aws-sdk"]);
+        const { runtime, timeout, memorySize, bind, permissions, environment } = this.props;
+        const { handler, esbuild } = this.createServerLambdaBundle("edge-server.js");
         return new EdgeFunction(this, `Server`, {
             scopeOverride: this,
-            format: "cjs",
-            bundlePath,
-            handler: "server.handler",
+            handler,
             runtime,
             timeout,
             memorySize,
-            permissions,
+            bind,
             environment,
+            permissions,
+            format: "cjs",
+            esbuild,
         });
     }
-    normalizeRuntime(runtime) {
-        return runtime || "nodejs18.x";
-    }
 }

package/constructs/SolidStartSite.js

@@ -1,10 +1,7 @@
-import fs from "fs";
 import path from "path";
-import { buildSync } from "esbuild";
 import { Architecture } from "aws-cdk-lib/aws-lambda";
 import { SsrSite } from "./SsrSite.js";
 import { Function } from "./Function.js";
-import { useProject } from "../project.js";
 import { EdgeFunction } from "./EdgeFunction.js";
 /**
  * The `SolidStartSite` construct is a higher level CDK construct that makes it easy to create a SolidStart app.
@@ -26,13 +23,11 @@ export class SolidStartSite extends SsrSite {
         };
     }
     createFunctionForRegional() {
-        const { runtime, timeout, memorySize, environment, cdk } = this.props;
-        // Bundle code
-        const handler = path.join(this.props.path, "dist", "server", "index.handler");
+        const { runtime, timeout, memorySize, bind, permissions, environment, cdk, } = this.props;
         // Create function
         const fn = new Function(this, `ServerFunction`, {
             description: "Server handler",
-            handler,
+            handler: path.join(this.props.path, "dist", "server", "index.handler"),
             logRetention: "three_days",
             runtime,
             memorySize,
@@ -40,52 +35,24 @@ export class SolidStartSite extends SsrSite {
             nodejs: {
                 format: "esm",
             },
+            bind,
             environment,
+            permissions,
             ...cdk?.server,
             architecture: cdk?.server?.architecture === Architecture.ARM_64 ? "arm_64" : "x86_64",
         });
-        fn._disableBind = true;
+        fn._doNotAllowOthersToBind = true;
         return fn;
     }
     createFunctionForEdge() {
-        const { runtime, timeout, memorySize, permissions, environment } = this.props;
-        // Create a directory that we will use to create the bundled version
-        // of the "core server build" along with our custom Lamba server handler.
-        const outputPath = path.resolve(path.join(useProject().paths.artifacts, `SolidStartSiteFunction-${this.node.id}-${this.node.addr}`));
-        // Bundle code
-        const result = buildSync({
-            entryPoints: [
-                path.join(this.props.path, this.buildConfig.serverBuildOutputFile),
-            ],
-            target: "esnext",
-            format: "esm",
-            platform: "node",
-            metafile: true,
-            bundle: true,
-            write: true,
-            allowOverwrite: true,
-            outfile: path.join(outputPath, "server.mjs"),
-            banner: {
-                js: [
-                    `import { createRequire as topLevelCreateRequire } from 'module';`,
-                    `const require = topLevelCreateRequire(import.meta.url);`,
-                ].join(""),
-            },
-        });
-        if (result.errors.length > 0) {
-            result.errors.forEach((error) => console.error(error));
-            throw new Error(`There was a problem bundling the function code for the ${this.id} SolidStartSite.`);
-        }
-        // Create package.json
-        fs.writeFileSync(path.join(outputPath, "package.json"), `{"type":"module"}`);
-        // Create function
+        const { runtime, timeout, memorySize, bind, permissions, environment } = this.props;
         return new EdgeFunction(this, `Server`, {
             scopeOverride: this,
-            bundlePath: outputPath,
-            handler: "server.handler",
+            handler: path.join(this.props.path, "dist", "server", "index.handler"),
             runtime,
             timeout,
             memorySize,
+            bind,
             permissions,
             environment,
             format: "esm",

package/constructs/SsrFunction.d.ts

@@ -1,23 +1,26 @@
 import { Construct } from "constructs";
-import * as lambda from "aws-cdk-lib/aws-lambda";
+import { FunctionOptions, Function as CdkFunction } from "aws-cdk-lib/aws-lambda";
+import { SSTConstruct } from "./Construct.js";
 import { Permissions } from "./util/permission.js";
 import { Size } from "./util/size.js";
 import { Duration } from "./util/duration.js";
-import { FunctionOptions } from "aws-cdk-lib/aws-lambda";
 export interface SsrFunctionProps extends Omit<FunctionOptions, "memorySize" | "timeout" | "runtime"> {
-    bundlePath: string;
+    bundle: string;
     handler: string;
     runtime?: "nodejs14.x" | "nodejs16.x" | "nodejs18.x";
     timeout: number | Duration;
     memorySize: number | Size;
     permissions?: Permissions;
+    environment?: Record<string, string>;
+    bind?: SSTConstruct[];
 }
 export declare class SsrFunction extends Construct {
-    function: lambda.Function;
+    function: CdkFunction;
     private props;
     constructor(scope: Construct, id: string, props: SsrFunctionProps);
     attachPermissions(permissions: Permissions): void;
+    private createCodeAsset;
     private createFunction;
-    private createLambdaCodeReplacer;
-    private getLambdaContentReplaceValues;
+    private createCodeReplacer;
+    private bind;
 }

package/constructs/SsrFunction.js

@@ -3,12 +3,13 @@ import path from "path";
 import spawn from "cross-spawn";
 import { Construct } from "constructs";
 import { Effect, Policy, PolicyStatement } from "aws-cdk-lib/aws-iam";
-import * as logs from "aws-cdk-lib/aws-logs";
-import * as lambda from "aws-cdk-lib/aws-lambda";
-import * as s3Assets from "aws-cdk-lib/aws-s3-assets";
+import { RetentionDays } from "aws-cdk-lib/aws-logs";
+import { Architecture, Runtime, Code, Function as CdkFunction, } from "aws-cdk-lib/aws-lambda";
+import { Asset } from "aws-cdk-lib/aws-s3-assets";
 import { Duration as CdkDuration, CustomResource } from "aws-cdk-lib";
-import { Stack } from "./Stack.js";
 import { useProject } from "../project.js";
+import { Stack } from "./Stack.js";
+import { bindEnvironment, bindPermissions, getReferencedSecrets, } from "./util/functionBinding.js";
 import { attachPermissionsToRole } from "./util/permission.js";
 import { toCdkSize } from "./util/size.js";
 import { toCdkDuration } from "./util/duration.js";
@@ -21,48 +22,52 @@ export class SsrFunction extends Construct {
     props;
     constructor(scope, id, props) {
         super(scope, id);
-        this.props = props;
-        const { permissions } = props;
-        this.function = this.createFunction();
-        this.attachPermissions(permissions || []);
+        this.props = {
+            ...props,
+            environment: props.environment || {},
+            permissions: props.permissions || [],
+        };
+        const asset = this.createCodeAsset();
+        const assetReplacer = this.createCodeReplacer(asset);
+        this.function = this.createFunction(asset);
+        this.attachPermissions(props.permissions || []);
+        this.bind(props.bind || []);
+        this.function.node.addDependency(assetReplacer);
     }
     attachPermissions(permissions) {
         attachPermissionsToRole(this.function.role, permissions);
     }
-    createFunction() {
-        const { runtime, timeout, memorySize, handler, bundlePath } = this.props;
-        // Note: cannot point the bundlePath to the `.open-next/server-function`
+    createCodeAsset() {
+        const { bundle } = this.props;
+        // Note: cannot point the bundle to the `.open-next/server-function`
         //       b/c the folder contains node_modules. And pnpm node_modules
         //       contains symlinks. CDK cannot zip symlinks correctly.
         //       https://github.com/aws/aws-cdk/issues/9251
         //       We will zip the folder ourselves.
-        const zipOutDir = path.resolve(useProject().paths.artifacts, `Site-${this.node.id}-${this.node.addr}`);
+        const outputPath = path.resolve(useProject().paths.artifacts, `SsrFunction-${this.node.id}-${this.node.addr}`);
         const script = path.resolve(__dirname, "../support/ssr-site-function-archiver.mjs");
-        const result = spawn.sync("node", [
-            script,
-            path.join(bundlePath),
-            path.join(zipOutDir, "server-function.zip"),
-        ], { stdio: "inherit" });
+        const result = spawn.sync("node", [script, path.join(bundle), path.join(outputPath, "server-function.zip")], { stdio: "inherit" });
         if (result.status !== 0) {
             throw new Error(`There was a problem generating the assets package.`);
         }
         // Create asset
-        const asset = new s3Assets.Asset(this, "Asset", {
-            path: path.join(zipOutDir, "server-function.zip"),
+        return new Asset(this, "Asset", {
+            path: path.join(outputPath, "server-function.zip"),
         });
-        // Deploy after the code is updated
-        const replacer = this.createLambdaCodeReplacer(asset);
-        const fn = new lambda.Function(this, `ServerFunction`, {
+    }
+    createFunction(asset) {
+        const { runtime, timeout, memorySize, handler } = this.props;
+        return new CdkFunction(this, `ServerFunction`, {
             ...this.props,
             handler,
-            logRetention: logs.RetentionDays.THREE_DAYS,
-            code: lambda.Code.fromBucket(asset.bucket, asset.s3ObjectKey),
+            logRetention: RetentionDays.THREE_DAYS,
+            code: Code.fromBucket(asset.bucket, asset.s3ObjectKey),
             runtime: runtime === "nodejs14.x"
-                ? lambda.Runtime.NODEJS_14_X
+                ? Runtime.NODEJS_14_X
                 : runtime === "nodejs16.x"
-                    ? lambda.Runtime.NODEJS_16_X
-                    : lambda.Runtime.NODEJS_18_X,
-            architecture: lambda.Architecture.ARM_64,
+                    ? Runtime.NODEJS_16_X
+                    : Runtime.NODEJS_18_X,
+            architecture: Architecture.ARM_64,
             memorySize: typeof memorySize === "string"
                 ? toCdkSize(memorySize).toMebibytes()
                 : memorySize,
@@ -70,10 +75,9 @@ export class SsrFunction extends Construct {
                 ? toCdkDuration(timeout)
                 : CdkDuration.seconds(timeout),
         });
-        fn.node.addDependency(replacer);
-        return fn;
     }
-    createLambdaCodeReplacer(asset) {
+    createCodeReplacer(asset) {
+        const { environment } = this.props;
         // Note: Source code for the Lambda functions have "{{ ENV_KEY }}" in them.
         //       They need to be replaced with real values before the Lambda
         //       functions get deployed.
@@ -94,30 +98,37 @@ export class SsrFunction extends Construct {
             properties: {
                 bucket: asset.s3BucketName,
                 key: asset.s3ObjectKey,
-                replacements: this.getLambdaContentReplaceValues(),
+                replacements: Object.entries(environment).map(([key, value]) => ({
+                    files: "**/*.*js",
+                    search: `{{ ${key} }}`,
+                    replace: value,
+                })),
             },
         });
         resource.node.addDependency(policy);
         return resource;
     }
-    getLambdaContentReplaceValues() {
-        const replaceValues = [];
-        Object.entries(this.props.environment || {}).forEach(([key, value]) => {
-            const token = `{{ ${key} }}`;
-            replaceValues.push({
-                files: "**/*.js",
-                search: token,
-                replace: value,
-            }, {
-                files: "**/*.cjs",
-                search: token,
-                replace: value,
-            }, {
-                files: "**/*.mjs",
-                search: token,
-                replace: value,
-            });
+    bind(constructs) {
+        const app = this.node.root;
+        this.function.addEnvironment("SST_APP", app.name);
+        this.function.addEnvironment("SST_STAGE", app.stage);
+        this.function.addEnvironment("SST_SSM_PREFIX", useProject().config.ssmPrefix);
+        // Get referenced secrets
+        const referencedSecrets = [];
+        constructs.forEach((c) => referencedSecrets.push(...getReferencedSecrets(c)));
+        [...constructs, ...referencedSecrets].forEach((c) => {
+            // Bind environment
+            const env = bindEnvironment(c);
+            Object.entries(env).forEach(([key, value]) => this.function.addEnvironment(key, value));
+            // Bind permissions
+            const permissions = bindPermissions(c);
+            Object.entries(permissions).forEach(([action, resources]) => this.attachPermissions([
+                new PolicyStatement({
+                    actions: [action],
+                    effect: Effect.ALLOW,
+                    resources,
+                }),
+            ]));
         });
-        return replaceValues;
     }
 }

package/constructs/SsrSite.d.ts

@@ -179,10 +179,12 @@ export interface SsrSiteProps {
  */
 export declare class SsrSite extends Construct implements SSTConstruct {
     readonly id: string;
-    protected props: Omit<SsrSiteProps, "path"> & {
-        path: string;
-        timeout: number | Duration;
-        memorySize: number | Size;
+    protected props: SsrSiteProps & {
+        path: Exclude<SsrSiteProps["path"], undefined>;
+        runtime: Exclude<SsrSiteProps["runtime"], undefined>;
+        timeout: Exclude<SsrSiteProps["timeout"], undefined>;
+        memorySize: Exclude<SsrSiteProps["memorySize"], undefined>;
+        waitForInvalidation: Exclude<SsrSiteProps["waitForInvalidation"], undefined>;
     };
     private doNotDeploy;
     protected buildConfig: SsrBuildConfig;

package/constructs/SsrSite.js

@@ -398,11 +398,7 @@ export class SsrSite extends Construct {
         return {};
     }
     createFunctionPermissionsForRegional() {
-        const { permissions } = this.props;
         this.bucket.grantReadWrite(this.serverLambdaForRegional.role);
-        if (permissions) {
-            attachPermissionsToRole(this.serverLambdaForRegional.role, permissions);
-        }
     }
     createFunctionPermissionsForEdge() {
         this.bucket.grantReadWrite(this.serverLambdaForEdge.role);

package/constructs/Stack.js

@@ -175,7 +175,8 @@ export class Stack extends cdk.Stack {
             const output = typeof value === "string"
                 ? new cdk.CfnOutput(this, `SSTStackOutput${key}`, { value })
                 : new cdk.CfnOutput(this, `SSTStackOutput${key}`, value);
-            output.overrideLogicalId(key);
+            // CloudFormation only allows alphanumeric characters in the output name.
+            output.overrideLogicalId(key.replace(/[^A-Za-z0-9]/g, ""));
         });
     }
     createCustomResourceHandler() {

package/constructs/future/Auth.d.ts

@@ -0,0 +1,79 @@
+import { Construct } from "constructs";
+import { Api, ApiProps } from "../Api.js";
+import { FunctionDefinition } from "../Function.js";
+import { SSTConstruct } from "../Construct.js";
+import { FunctionBindingProps } from "../util/functionBinding.js";
+export interface AuthProps {
+    /**
+     * The function that will handle authentication
+     */
+    authenticator: FunctionDefinition;
+    customDomain?: ApiProps["customDomain"];
+    cdk?: {
+        /**
+         * Allows you to override default id for this construct.
+         */
+        id?: string;
+    };
+}
+export interface ApiAttachmentProps {
+    /**
+     * The API to attach auth routes to
+     *
+     * @example
+     * ```js
+     * const api = new Api(stack, "Api", {});
+     * const auth = new Auth(stack, "Auth", {
+     *   authenticator: "functions/authenticator.handler"
+     * })
+     * auth.attach(stack, {
+     *   api
+     * })
+     * ```
+     */
+    api: Api;
+    /**
+     * Optionally specify the prefix to mount authentication routes
+     *
+     * @default "/auth"
+     *
+     * @example
+     * ```js
+     * const api = new Api(stack, "Api", {});
+     * const auth = new Auth(stack, "Auth", {
+     *   authenticator: "functions/authenticator.handler"
+     * })
+     * auth.attach(stack, {
+     *   api,
+     *   prefix: "/custom/prefix"
+     * })
+     * ```
+     */
+    prefix?: string;
+}
+/**
+ * SST Auth is a lightweight authentication solution for your applications. With a simple set of configuration you can deploy a function attached to your API that can handle various authentication flows.  *
+ * @example
+ * ```
+ * import { Auth } from "@serverless-stack/resources"
+ *
+ * new Auth(stack, "auth", {
+ *   authenticator: "functions/authenticator.handler"
+ * })
+ */
+export declare class Auth extends Construct implements SSTConstruct {
+    readonly id: string;
+    private readonly authenticator;
+    private api;
+    private publicKey;
+    private privateKey;
+    constructor(scope: Construct, id: string, props: AuthProps);
+    get url(): string;
+    /** @internal */
+    getConstructMetadata(): {
+        type: "Auth";
+        data: {};
+    };
+    /** @internal */
+    getFunctionBinding(): FunctionBindingProps;
+}