sst 2.22.10 → 2.23.0

package/bootstrap.js

@@ -157,22 +157,27 @@ export async function bootstrapSST() {
         Tags.of(app).add(key, value);
     }
     // Create S3 bucket to store stacks metadata
-    const bucket = new Bucket(stack, region, {
-        encryption: BucketEncryption.S3_MANAGED,
-        removalPolicy: RemovalPolicy.DESTROY,
-        autoDeleteObjects: true,
-        enforceSSL: true,
-        lifecycleRules: [
-            {
-                id: "Remove partial uploads after 3 days",
-                enabled: true,
-                abortIncompleteMultipartUploadAfter: Duration.days(3),
-            },
-        ],
-        blockPublicAccess: cdk?.publicAccessBlockConfiguration !== false
-            ? BlockPublicAccess.BLOCK_ALL
-            : undefined,
-    });
+    const bucket = bootstrap?.useExistingBucket
+        ? {
+            bucketName: bootstrap.useExistingBucket,
+            bucketArn: `arn:${stack.partition}:s3:::${bootstrap.useExistingBucket}`,
+        }
+        : new Bucket(stack, region, {
+            encryption: BucketEncryption.S3_MANAGED,
+            removalPolicy: RemovalPolicy.DESTROY,
+            autoDeleteObjects: true,
+            enforceSSL: true,
+            lifecycleRules: [
+                {
+                    id: "Remove partial uploads after 3 days",
+                    enabled: true,
+                    abortIncompleteMultipartUploadAfter: Duration.days(3),
+                },
+            ],
+            blockPublicAccess: cdk?.publicAccessBlockConfiguration !== false
+                ? BlockPublicAccess.BLOCK_ALL
+                : undefined,
+        });
     // Create Function and subscribe to CloudFormation events
     const fn = new Function(stack, "MetadataHandler", {
         code: Code.fromAsset(path.resolve(__dirname, "support/bootstrap-metadata-function")),

package/cli/commands/bind.d.ts

@@ -12,8 +12,6 @@ export declare const bind: (program: Program) => import("yargs").Argv<{
     role: string | undefined;
 } & {
     future: boolean | undefined;
-} & {
-    site: boolean | undefined;
 } & {
     script: boolean | undefined;
 } & {

package/cli/commands/bind.js

@@ -6,10 +6,6 @@ class MetadataOutdatedError extends Error {
 }
 export const bind = (program) => program
     .command(["bind <command..>", "env <command..>"], "Bind your app's resources to a command", (yargs) => yargs
-    .option("site", {
-    type: "boolean",
-    describe: "Run in site mode",
-})
     .option("script", {
     type: "boolean",
     describe: "Run in script mode",
@@ -18,103 +14,110 @@ export const bind = (program) => program
     .example(`sst bind vitest run`, "Bind resources to your tests")
     .example(`sst bind next dev`, "Bind resources to your site")
     .example(`sst bind --script next build`, "Bind resources to your site before deployment"), async (args) => {
+    const { Token } = await import("aws-cdk-lib");
     const { spawn } = await import("child_process");
     const kill = await import("tree-kill");
     const { useProject } = await import("../../project.js");
+    const { Stacks } = await import("../../stacks/index.js");
     const { useBus } = await import("../../bus.js");
     const { useIOT } = await import("../../iot.js");
     const { Colors } = await import("../colors.js");
     const { Logger } = await import("../../logger.js");
+    const [{ useServices }, { useSites: useSsrSites }, { useSites: useStaticSites }, { useSites: useSlsNextjsSites }, { Parameter }, { getEnvironmentKey },] = await Promise.all([
+        import("../../constructs/Service.js"),
+        import("../../constructs/SsrSite.js"),
+        import("../../constructs/StaticSite.js"),
+        import("../../constructs/deprecated/NextjsSite.js"),
+        import("../../constructs/Config.js"),
+        import("../../constructs/util/functionBinding.js"),
+    ]);
+    // Handle deprecated "env" command
     if (args._[0] === "env") {
         Colors.line(Colors.warning(`Warning: ${Colors.bold(`sst env`)} has been renamed to ${Colors.bold(`sst bind`)}`));
     }
+    // Handle missing command
+    const command = args.command?.join(" ");
+    if (!command) {
+        throw new VisibleError("Command is required, e.g. sst bind npm run script");
+    }
     await useIOT();
     const bus = useBus();
     const project = useProject();
-    const command = args.command?.join(" ");
-    const isSite = await isRunningInSite();
-    const mode = args.site ? "site" : args.script ? "script" : "auto";
     let p;
     let timer;
     let siteConfigCache;
-    // Handle missing command
-    if (!command) {
-        throw new VisibleError(`Command is required, e.g. sst bind ${isSite ? "next dev" : "vitest run"}`);
+    await buildApp();
+    const ssrSite = isInSsrSite();
+    const staticSite = isInStaticSite();
+    const service = isInService();
+    // Run the script
+    if (args.script || (!ssrSite && !staticSite && !service)) {
+        return await runScript();
+    }
+    // Run the app
+    try {
+        await runSite("init");
     }
-    // Bind script
-    if (args.script || (!isSite && !args.site)) {
-        Logger.debug("Running in script mode.");
-        return await bindScript();
+    catch (e) {
+        if (!(e instanceof MetadataOutdatedError) &&
+            !(e instanceof MetadataNotFoundError)) {
+            return;
+        }
+        Colors.line(Colors.warning(e instanceof MetadataOutdatedError
+            ? "Warning: This was deployed with an old version of SST. Run `sst dev` or `sst deploy` to update."
+            : "Warning: The site has not been deployed. Some resources might not be available."));
+        return await runSiteUndeployed();
     }
-    // Bind site
-    await bindSite("init");
-    bus.subscribe("stacks.metadata.updated", () => bindSite("metadata_updated"));
-    bus.subscribe("stacks.metadata.deleted", () => bindSite("metadata_updated"));
+    bus.subscribe("stacks.metadata.updated", () => runSite("metadata_updated"));
+    bus.subscribe("stacks.metadata.deleted", () => runSite("metadata_updated"));
     bus.subscribe("config.secret.updated", (payload) => {
         const secretName = payload.properties.name;
-        if (!(siteConfigCache?.secrets || []).includes(secretName))
+        if (!siteConfigCache.secrets.includes(secretName))
             return;
         Colors.line(`\n`, `SST secrets have been updated. Restarting \`${command}\`...`);
-        bindSite("secrets_updated");
+        runSite("secrets_updated");
     });
-    async function isRunningInSite() {
-        const { existsAsync } = await import("../../util/fs.js");
-        const { readFile } = await import("fs/promises");
-        const SITE_CONFIGS = [
-            { file: "next.config", multiExtension: true },
-            { file: "astro.config", multiExtension: true },
-            { file: "remix.config", multiExtension: true },
-            { file: "svelte.config", multiExtension: true },
-            { file: "gatsby-config", multiExtension: true },
-            { file: "angular.json" },
-            { file: "ember-cli-build.js" },
-            {
-                file: "vite.config",
-                multiExtension: true,
-                match: /solid-start|plugin-vue|plugin-react|@preact\/preset-vite/,
-            },
-            { file: "package.json", match: /react-scripts/ },
-            { file: "index.html" }, // plain HTML
-        ];
-        const results = await Promise.all(SITE_CONFIGS.map((site) => {
-            const files = site.multiExtension
-                ? [".js", ".cjs", ".mjs", ".ts"].map((ext) => `${site.file}${ext}`)
-                : [site.file];
-            return files.map(async (file) => {
-                const exists = await existsAsync(file);
-                if (!exists)
-                    return false;
-                if (site.match) {
-                    const content = await readFile(file);
-                    return content.toString().match(site.match);
-                }
-                return true;
-            });
-        }).flat());
-        return results.some(Boolean);
+    async function buildApp() {
+        const [_metafile, sstConfig] = await Stacks.load(project.paths.config);
+        const cwd = process.cwd();
+        process.chdir(project.paths.root);
+        await Stacks.synth({
+            fn: sstConfig.stacks,
+            mode: "remove",
+        });
+        process.chdir(cwd);
     }
-    async function bindSite(reason) {
-        // Get metadata
-        let siteMetadata;
-        try {
-            siteMetadata = await getSiteMetadata();
-        }
-        catch (e) {
-            // unhandled error
-            if (!(e instanceof MetadataOutdatedError) &&
-                !(e instanceof MetadataNotFoundError)) {
-                throw e;
-            }
-            // ignore error if previously failed to fetch metadata
-            if (reason !== "init")
-                return;
-            // run in script mode
-            Colors.line(Colors.warning(e instanceof MetadataOutdatedError
-                ? "Warning: This was deployed with an old version of SST. Run `sst dev` or `sst deploy` to update."
-                : "Warning: The site has not been deployed. Some resources might not be available."));
-            return await bindScript();
-        }
-        const siteConfig = await parseSiteMetadata(siteMetadata);
+    function isInSsrSite() {
+        const cwd = process.cwd();
+        return useSsrSites().all.find(({ props }) => {
+            console.log(path.resolve(project.paths.root, props.path));
+            return path.resolve(project.paths.root, props.path) === cwd;
+        });
+    }
+    function isInStaticSite() {
+        const cwd = process.cwd();
+        return (useStaticSites().all.find(({ props }) => {
+            console.log(path.resolve(project.paths.root, props.path));
+            return path.resolve(project.paths.root, props.path) === cwd;
+        }) ||
+            useSlsNextjsSites().all.find(({ props }) => {
+                console.log(path.resolve(project.paths.root, props.path));
+                return path.resolve(project.paths.root, props.path) === cwd;
+            }));
+    }
+    function isInService() {
+        const cwd = process.cwd();
+        return useServices().all.find(({ props }) => {
+            console.log(path.resolve(project.paths.root, props.path));
+            return path.resolve(project.paths.root, props.path) === cwd;
+        });
+    }
+    async function runSite(reason) {
+        const siteConfig = ssrSite
+            ? await getSsrSiteMetadata()
+            : staticSite
+                ? await getStaticSiteMetadata()
+                : await getServiceMetadata();
         // Handle rebind due to metadata updated
         if (reason === "metadata_updated") {
             if (areEnvsSame(siteConfig.envs, siteConfigCache?.envs || {}))
@@ -132,54 +135,123 @@ export const bind = (program) => program
             ...credentials,
         });
     }
-    async function bindScript() {
+    async function runSiteUndeployed() {
+        // Note: when the site is undeployed:
+        // - bind all resources
+        // - bind resources that are constant (ie. Config.Parameter)
+        // - set environment variables that are constant
+        const constructEnvs = {};
+        Object.entries((ssrSite || staticSite || service)?.props.environment || {})
+            .filter(([key, value]) => !Token.isUnresolved(value))
+            .forEach(([key, value]) => (constructEnvs[key] = value));
+        ((ssrSite || service)?.props.bind || []).forEach((b) => {
+            if (b instanceof Parameter && !Token.isUnresolved(b.value)) {
+                constructEnvs[getEnvironmentKey(b, "name")] = b.value;
+            }
+        });
         const { Config } = await import("../../config.js");
         await runCommand({
+            ...constructEnvs,
             ...(await Config.env()),
             ...(await getLocalIamCredentials()),
         });
     }
-    async function getSiteMetadata() {
-        const { metadata } = await import("../../stacks/metadata.js");
-        const metadataData = await metadata();
-        const data = Object.values(metadataData)
-            .flat()
+    async function runScript() {
+        const { Config } = await import("../../config.js");
+        await runCommand({
+            ...(await Config.env()),
+            ...(await getLocalIamCredentials()),
+        });
+    }
+    async function getSsrSiteMetadata() {
+        const [{ metadataForStack }, { LambdaClient, GetFunctionCommand }, { useAWSClient },] = await Promise.all([
+            import("../../stacks/metadata.js"),
+            import("@aws-sdk/client-lambda"),
+            import("../../credentials.js"),
+        ]);
+        const metadataData = await metadataForStack(ssrSite.stack);
+        const metadata = metadataData
             .filter((c) => [
-            "StaticSite",
             "NextjsSite",
             "AstroSite",
             "RemixSite",
             "SolidStartSite",
             "SvelteKitSite",
-            "SlsNextjsSite",
         ].includes(c.type))
             .find((c) => {
-            // Handle metadata prior to SST v2.3.0 doesn't have path
-            const isSsr = c.type !== "StaticSite" && c.type !== "SlsNextjsSite";
-            if (!c.data.path ||
-                (isSsr && !c.data.server) ||
-                (!isSsr && !c.data.environment)) {
+            // metadata prior to SST v2.3.0 doesn't have path
+            if (!c.data.path || !c.data.server) {
                 throw new MetadataOutdatedError();
             }
             return (path.resolve(project.paths.root, c.data.path) === process.cwd());
         });
-        if (!data) {
+        if (!metadata)
             throw new MetadataNotFoundError();
-        }
-        return data;
+        // Parse metadata
+        const lambda = useAWSClient(LambdaClient);
+        const { Configuration: functionConfig } = await lambda.send(new GetFunctionCommand({
+            FunctionName: metadata.data.server,
+        }));
+        return {
+            role: functionConfig?.Role,
+            envs: functionConfig?.Environment?.Variables || {},
+            secrets: metadata.data.secrets,
+        };
     }
-    async function parseSiteMetadata(metadata) {
-        const { LambdaClient, GetFunctionCommand } = await import("@aws-sdk/client-lambda");
-        const { useAWSClient } = await import("../../credentials.js");
-        const isBindSupported = metadata.type !== "StaticSite" && metadata.type !== "SlsNextjsSite";
-        // Handle StaticSite
-        if (!isBindSupported) {
-            return { envs: metadata.data.environment };
+    async function getStaticSiteMetadata() {
+        const { metadataForStack } = await import("../../stacks/metadata.js");
+        const metadataData = await metadataForStack(staticSite.stack);
+        const metadata = metadataData
+            .filter((c) => ["StaticSite", "SlsNextjsSite"].includes(c.type))
+            .find((c) => {
+            // metadata prior to SST v2.3.0 doesn't have path
+            if (!c.data.path || !c.data.environment) {
+                throw new MetadataOutdatedError();
+            }
+            return (path.resolve(project.paths.root, c.data.path) === process.cwd());
+        });
+        if (!metadata)
+            throw new MetadataNotFoundError();
+        return {
+            envs: metadata.data.environment,
+            role: undefined,
+            secrets: [],
+        };
+    }
+    async function getServiceMetadata() {
+        const [{ metadataForStack }, { LambdaClient, GetFunctionCommand }, { ECSClient, DescribeTaskDefinitionCommand }, { useAWSClient },] = await Promise.all([
+            import("../../stacks/metadata.js"),
+            import("@aws-sdk/client-lambda"),
+            import("@aws-sdk/client-ecs"),
+            import("../../credentials.js"),
+        ]);
+        // Get metadata
+        const metadataData = await metadataForStack(service.stack);
+        const metadata = metadataData
+            .filter((c) => ["Service"].includes(c.type))
+            .find((c) => {
+            return (path.resolve(project.paths.root, c.data.path) === process.cwd());
+        });
+        if (!metadata)
+            throw new MetadataNotFoundError();
+        // Parse metadata for "sst deploy"
+        if (metadata.data.mode === "deployed") {
+            const ecs = useAWSClient(ECSClient);
+            const task = await ecs.send(new DescribeTaskDefinitionCommand({
+                taskDefinition: metadata.data.task,
+            }));
+            const envs = {};
+            (task?.taskDefinition?.containerDefinitions[0].environment || []).forEach(({ name, value }) => (envs[name] = value));
+            return {
+                role: task?.taskDefinition?.taskRoleArn,
+                envs,
+                secrets: metadata.data.secrets,
+            };
         }
-        // Get function details
+        // Parse metadata for "sst dev"
         const lambda = useAWSClient(LambdaClient);
         const { Configuration: functionConfig } = await lambda.send(new GetFunctionCommand({
-            FunctionName: metadata.data.server,
+            FunctionName: metadata.data.devFunction,
         }));
         return {
             role: functionConfig?.Role,
@@ -196,7 +268,7 @@ export const bind = (program) => program
         clearTimeout(timer);
         timer = setTimeout(() => {
             Colors.line(`\n`, `Your AWS session is about to expire. Creating a new session and restarting \`${command}\`...`);
-            bindSite("iam_expired");
+            runSite("iam_expired");
         }, expireAt - Date.now());
         return {
             AWS_ACCESS_KEY_ID: credentials.AccessKeyId,

package/cli/ui/deploy.js

@@ -6,13 +6,29 @@ import Spinner from "ink-spinner";
 import { Colors } from "../colors.js";
 import { useProject } from "../../project.js";
 export const DeploymentUI = (props) => {
+    const [statuses, setStatuses] = useState({});
     const [resources, setResources] = useState({});
     useEffect(() => {
         Colors.gap();
         const bus = useBus();
+        const status = bus.subscribe("stack.status", (payload) => {
+            const { stackID, status } = payload.properties;
+            setStatuses((previous) => {
+                if (status !== "PUBLISH_ASSETS_IN_PROGRESS") {
+                    if (previous[stackID]) {
+                        Colors.line(Colors.warning(Colors.prefix), Colors.dim(stackNameToId(stackID)), Colors.dim("PUBLISH_ASSETS_COMPLETE"), "");
+                    }
+                    const { [stackID]: _, ...next } = previous;
+                    return next;
+                }
+                return {
+                    ...previous,
+                    [stackID]: status,
+                };
+            });
+        });
         const event = bus.subscribe("stack.event", (payload) => {
             const { event } = payload.properties;
-            // if (event.ResourceType === "AWS::CloudFormation::Stack") return;
             setResources((previous) => {
                 if (Stacks.isFinal(event.ResourceStatus)) {
                     const readable = logicalIdToCdkPath(props.assembly, event.StackName, event.LogicalResourceId);
@@ -34,6 +50,7 @@ export const DeploymentUI = (props) => {
         });
         return () => {
             bus.unsubscribe(event);
+            bus.unsubscribe(status);
         };
     }, []);
     function color(status) {
@@ -44,8 +61,19 @@ export const DeploymentUI = (props) => {
         return "yellow";
     }
     return (React.createElement(Box, { flexDirection: "column" },
-        Object.entries(resources)
+        Object.entries(statuses)
             .slice(0, process.stdout.rows - 2)
+            .map(([stack, status], index) => {
+            return (React.createElement(Box, { key: index },
+                React.createElement(Text, null,
+                    React.createElement(Spinner, null),
+                    "  ",
+                    stackNameToId(stack),
+                    " "),
+                React.createElement(Text, { color: color(status) }, status)));
+        }),
+        Object.entries(resources)
+            .slice(0, Math.max(0, process.stdout.rows - Object.entries(statuses).length - 2))
             .map(([_, evt], index) => {
             const readable = logicalIdToCdkPath(props.assembly, evt.StackName, evt.LogicalResourceId);
             return (React.createElement(Box, { key: index },
@@ -58,7 +86,8 @@ export const DeploymentUI = (props) => {
                     " "),
                 React.createElement(Text, { color: color(evt.ResourceStatus || "") }, evt.ResourceStatus)));
         }),
-        Object.entries(resources).length === 0 && (React.createElement(Box, null,
+        Object.entries(resources).length === 0 &&
+            Object.entries(statuses).length === 0 && (React.createElement(Box, null,
             React.createElement(Text, null,
                 React.createElement(Spinner, null),
                 "  ",

package/constructs/AstroSite.d.ts

@@ -34,4 +34,5 @@ export declare class AstroSite extends SsrSite {
         };
         type: "AstroSite";
     };
+    protected supportsStreaming(): boolean;
 }

package/constructs/AstroSite.js

@@ -72,4 +72,7 @@ export class AstroSite extends SsrSite {
             ...this.getConstructMetadataBase(),
         };
     }
+    supportsStreaming() {
+        return true;
+    }
 }

package/constructs/BaseSite.d.ts

@@ -1,81 +1,10 @@
-import { IHostedZone } from "aws-cdk-lib/aws-route53";
 import { ErrorResponse, DistributionProps, BehaviorOptions, IOrigin } from "aws-cdk-lib/aws-cloudfront";
-import { ICertificate } from "aws-cdk-lib/aws-certificatemanager";
 export interface BaseSiteFileOptions {
     exclude: string | string[];
     include: string | string[];
     cacheControl: string;
     contentType?: string;
 }
-/**
- * The customDomain for this website. SST supports domains that are hosted either on [Route 53](https://aws.amazon.com/route53/) or externally.
- *
- * Note that you can also migrate externally hosted domains to Route 53 by [following this guide](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/MigratingDNS.html).
- *
- * @example
- * ```js
- * new StaticSite(this, "Site", {
- *   path: "path/to/src",
- *   customDomain: "domain.com",
- * });
- * ```
- *
- * @example
- * ```js
- * new StaticSite(this, "Site", {
- *   path: "path/to/src",
- *   customDomain: {
- *     domainName: "domain.com",
- *     domainAlias: "www.domain.com",
- *     hostedZone: "domain.com",
- *   }
- * });
- * ```
- */
-export interface BaseSiteDomainProps {
-    /**
-     * The domain to be assigned to the website URL (ie. domain.com).
-     *
-     * Supports domains that are hosted either on [Route 53](https://aws.amazon.com/route53/) or externally.
-     */
-    domainName: string;
-    /**
-     * An alternative domain to be assigned to the website URL. Visitors to the alias will be redirected to the main domain. (ie. `www.domain.com`).
-     *
-     * Use this to create a `www.` version of your domain and redirect visitors to the root domain.
-     * @default no alias configured
-     */
-    domainAlias?: string;
-    /**
-     * The hosted zone in Route 53 that contains the domain. By default, SST will look for a hosted zone matching the domainName that's passed in.
-     *
-     * Set this option if SST cannot find the hosted zone in Route 53.
-     * @default same as the `domainName`
-     */
-    hostedZone?: string;
-    /**
-     * Specify additional names that should route to the Cloudfront Distribution. Note, certificates for these names will not be automatically generated so the `certificate` option must be specified.
-     * @default `[]`
-     */
-    alternateNames?: string[];
-    /**
-     * Set this option if the domain is not hosted on Amazon Route 53.
-     * @default `false`
-     */
-    isExternalDomain?: boolean;
-    cdk?: {
-        /**
-         * Import the underlying Route 53 hosted zone.
-         */
-        hostedZone?: IHostedZone;
-        /**
-         * Import the certificate for the domain. By default, SST will create a certificate with the domain name. The certificate will be created in the `us-east-1`(N. Virginia) region as required by AWS CloudFront.
-         *
-         * Set this option if you have an existing certificate in the `us-east-1` region in AWS Certificate Manager you want to use.
-         */
-        certificate?: ICertificate;
-    };
-}
 export interface BaseSiteEnvironmentOutputsInfo {
     path: string;
     stack: string;