sst 2.22.11 → 2.23.1

package/constructs/StaticSite.js

@@ -7,26 +7,20 @@ import { Construct } from "constructs";
 import { Token, Duration, RemovalPolicy, CustomResource, } from "aws-cdk-lib/core";
 import { BlockPublicAccess, Bucket, } from "aws-cdk-lib/aws-s3";
 import { Asset } from "aws-cdk-lib/aws-s3-assets";
-import { Effect, Policy, PolicyStatement } from "aws-cdk-lib/aws-iam";
 import { Code, Function, Runtime } from "aws-cdk-lib/aws-lambda";
-import { HostedZone, ARecord, AaaaRecord, RecordTarget, } from "aws-cdk-lib/aws-route53";
-import { CloudFrontTarget } from "aws-cdk-lib/aws-route53-targets";
-import { Distribution, Function as CfFunction, FunctionCode as CfFunctionCode, FunctionEventType as CfFunctionEventType, ViewerProtocolPolicy, } from "aws-cdk-lib/aws-cloudfront";
+import { Function as CfFunction, FunctionCode as CfFunctionCode, FunctionEventType as CfFunctionEventType, ViewerProtocolPolicy, } from "aws-cdk-lib/aws-cloudfront";
 import { S3Origin } from "aws-cdk-lib/aws-cloudfront-origins";
 import { AwsCliLayer } from "aws-cdk-lib/lambda-layer-awscli";
 import { Stack } from "./Stack.js";
+import { Distribution } from "./Distribution.js";
 import { getBuildCmdEnvironment, buildErrorResponsesFor404ErrorPage, buildErrorResponsesForRedirectToIndex, } from "./BaseSite.js";
 import { useDeferredTasks } from "./deferred_task.js";
-import { HttpsRedirect } from "./cdk/website-redirect.js";
-import { DnsValidatedCertificate } from "./cdk/dns-validated-certificate.js";
 import { isCDKConstruct } from "./Construct.js";
 import { getParameterPath, } from "./util/functionBinding.js";
 import { gray } from "colorette";
 import { useProject } from "../project.js";
+import { createAppContext } from "./context.js";
 const __dirname = path.dirname(url.fileURLToPath(import.meta.url));
-/////////////////////
-// Construct
-/////////////////////
 /**
  * The `StaticSite` construct is a higher level CDK construct that makes it easy to create a static website.
  *
@@ -48,8 +42,6 @@ export class StaticSite extends Construct {
     doNotDeploy;
     bucket;
     distribution;
-    hostedZone;
-    certificate;
     constructor(scope, id, props) {
         super(scope, props?.cdk?.id || id);
         const app = scope.node.root;
@@ -62,22 +54,15 @@ export class StaticSite extends Construct {
         };
         this.doNotDeploy =
             !stack.isActive || (app.mode === "dev" && !this.props.dev?.deploy);
-        this.validateCustomDomainSettings();
         this.generateViteTypes();
+        useSites().add(stack.stackName, id, this.props);
         if (this.doNotDeploy) {
             // @ts-ignore
             this.bucket = this.distribution = null;
             return;
         }
-        // Create Bucket
         this.bucket = this.createS3Bucket();
-        // Create Custom Domain
-        this.hostedZone = this.lookupHostedZone();
-        this.certificate = this.createCertificate();
-        // Create CloudFront
         this.distribution = this.createCfDistribution();
-        // Connect Custom Domain to CloudFront Distribution
-        this.createRoute53Records();
         useDeferredTasks().add(async () => {
             // Build app
             this.buildApp();
@@ -88,7 +73,7 @@ export class StaticSite extends Construct {
             const s3deployCR = this.createS3Deployment(cliLayer, assets, filenamesAsset);
             this.distribution.node.addDependency(s3deployCR);
             // Invalidate CloudFront
-            this.createCloudFrontInvalidation(assets);
+            this.distribution.createInvalidation(this.generateInvalidationId(assets));
         });
     }
     /**
@@ -97,7 +82,7 @@ export class StaticSite extends Construct {
     get url() {
         if (this.doNotDeploy)
             return this.props.dev?.url;
-        return `https://${this.distribution.distributionDomainName}`;
+        return this.distribution.url;
     }
     /**
      * If the custom domain is enabled, this is the URL of the website with the custom domain.
@@ -123,9 +108,9 @@ export class StaticSite extends Construct {
             return;
         return {
             bucket: this.bucket,
-            distribution: this.distribution,
-            hostedZone: this.hostedZone,
-            certificate: this.certificate,
+            distribution: this.distribution.cdk.distribution,
+            hostedZone: this.distribution.cdk.hostedZone,
+            certificate: this.distribution.cdk.certificate,
         };
     }
     getConstructMetadata() {
@@ -383,92 +368,34 @@ interface ImportMeta {
     // CloudFront Distribution
     /////////////////////
     createCfDistribution() {
-        const { cdk, errorPage } = this.props;
-        const isImportedCloudFrontDistribution = (distribution) => {
-            return distribution !== undefined && isCDKConstruct(distribution);
-        };
-        // cdk.distribution is an imported construct
-        if (isImportedCloudFrontDistribution(cdk?.distribution)) {
-            return cdk?.distribution;
-        }
-        // Validate input
-        if (cdk?.distribution?.certificate) {
-            throw new Error(`Do not configure the "cfDistribution.certificate". Use the "customDomain" to configure the domain certificate.`);
-        }
-        if (cdk?.distribution?.domainNames) {
-            throw new Error(`Do not configure the "cfDistribution.domainNames". Use the "customDomain" to configure the domain name.`);
-        }
-        if (errorPage && cdk?.distribution?.errorResponses) {
-            throw new Error(`Cannot configure the "cfDistribution.errorResponses" when "errorPage" is passed in. Use one or the other to configure the behavior for error pages.`);
-        }
-        // Create CloudFront distribution
+        const { errorPage, customDomain, cdk } = this.props;
         const indexPage = this.props.indexPage || "index.html";
-        return new Distribution(this, "Distribution", {
-            // these values can be overwritten by cfDistributionProps
-            defaultRootObject: indexPage,
-            errorResponses: !errorPage || errorPage === "redirect_to_index_page"
-                ? buildErrorResponsesForRedirectToIndex(indexPage)
-                : buildErrorResponsesFor404ErrorPage(errorPage),
-            ...cdk?.distribution,
-            // these values can NOT be overwritten by cfDistributionProps
-            domainNames: this.buildDistributionDomainNames(),
-            certificate: this.certificate,
-            defaultBehavior: this.buildDistributionBehavior(),
+        return new Distribution(this, "CDN", {
+            scopeOverride: this,
+            customDomain,
+            cdk: {
+                distribution: cdk?.distribution && isCDKConstruct(cdk.distribution)
+                    ? cdk.distribution
+                    : {
+                        // these values can be overwritten by cfDistributionProps
+                        defaultRootObject: indexPage,
+                        errorResponses: !errorPage || errorPage === "redirect_to_index_page"
+                            ? buildErrorResponsesForRedirectToIndex(indexPage)
+                            : buildErrorResponsesFor404ErrorPage(errorPage),
+                        ...cdk?.distribution,
+                        // these values can NOT be overwritten by cfDistributionProps
+                        defaultBehavior: this.buildDistributionBehavior(),
+                    },
+            },
         });
     }
-    createCloudFrontInvalidation(assets) {
+    generateInvalidationId(assets) {
         const stack = Stack.of(this);
         // Need the AssetHash field so the CR gets updated on each deploy
-        const assetsHash = crypto
+        return crypto
             .createHash("md5")
             .update(assets.map(({ assetHash }) => assetHash).join(""))
             .digest("hex");
-        const policy = new Policy(this, "CloudFrontInvalidatorPolicy", {
-            statements: [
-                new PolicyStatement({
-                    effect: Effect.ALLOW,
-                    actions: [
-                        "cloudfront:GetInvalidation",
-                        "cloudfront:CreateInvalidation",
-                    ],
-                    resources: [
-                        `arn:${stack.partition}:cloudfront::${stack.account}:distribution/${this.distribution.distributionId}`,
-                    ],
-                }),
-            ],
-        });
-        stack.customResourceHandler.role?.attachInlinePolicy(policy);
-        const resource = new CustomResource(this, "CloudFrontInvalidator", {
-            serviceToken: stack.customResourceHandler.functionArn,
-            resourceType: "Custom::CloudFrontInvalidator",
-            properties: {
-                assetsHash,
-                distributionId: this.distribution.distributionId,
-                paths: ["/*"],
-                waitForInvalidation: this.props.waitForInvalidation,
-            },
-        });
-        resource.node.addDependency(policy);
-        return resource;
-    }
-    buildDistributionDomainNames() {
-        const { customDomain } = this.props;
-        const domainNames = [];
-        if (!customDomain) {
-            // no domain
-        }
-        else if (typeof customDomain === "string") {
-            domainNames.push(customDomain);
-        }
-        else {
-            domainNames.push(customDomain.domainName);
-            if (customDomain.alternateNames) {
-                if (!customDomain.cdk?.certificate)
-                    throw new Error("Certificates for alternate domains cannot be automatically created. Please specify certificate to use");
-                domainNames.push(...customDomain.alternateNames);
-            }
-        }
-        return domainNames;
     }
     buildDistributionBehavior() {
         const { cdk } = this.props;
@@ -507,128 +434,6 @@ function handler(event) {
         };
     }
     /////////////////////
-    // Custom Domain
-    /////////////////////
-    validateCustomDomainSettings() {
-        const { customDomain } = this.props;
-        if (!customDomain) {
-            return;
-        }
-        if (typeof customDomain === "string") {
-            return;
-        }
-        if (customDomain.isExternalDomain === true) {
-            if (!customDomain.cdk?.certificate) {
-                throw new Error(`A valid certificate is required when "isExternalDomain" is set to "true".`);
-            }
-            if (customDomain.domainAlias) {
-                throw new Error(`Domain alias is only supported for domains hosted on Amazon Route 53. Do not set the "customDomain.domainAlias" when "isExternalDomain" is enabled.`);
-            }
-            if (customDomain.hostedZone) {
-                throw new Error(`Hosted zones can only be configured for domains hosted on Amazon Route 53. Do not set the "customDomain.hostedZone" when "isExternalDomain" is enabled.`);
-            }
-        }
-    }
-    lookupHostedZone() {
-        const { customDomain } = this.props;
-        // Skip if customDomain is not configured
-        if (!customDomain) {
-            return;
-        }
-        let hostedZone;
-        if (typeof customDomain === "string") {
-            hostedZone = HostedZone.fromLookup(this, "HostedZone", {
-                domainName: customDomain,
-            });
-        }
-        else if (customDomain.cdk?.hostedZone) {
-            hostedZone = customDomain.cdk.hostedZone;
-        }
-        else if (typeof customDomain.hostedZone === "string") {
-            hostedZone = HostedZone.fromLookup(this, "HostedZone", {
-                domainName: customDomain.hostedZone,
-            });
-        }
-        else if (typeof customDomain.domainName === "string") {
-            // Skip if domain is not a Route53 domain
-            if (customDomain.isExternalDomain === true) {
-                return;
-            }
-            hostedZone = HostedZone.fromLookup(this, "HostedZone", {
-                domainName: customDomain.domainName,
-            });
-        }
-        else {
-            hostedZone = customDomain.hostedZone;
-        }
-        return hostedZone;
-    }
-    createCertificate() {
-        const { customDomain } = this.props;
-        if (!customDomain) {
-            return;
-        }
-        let acmCertificate;
-        // HostedZone is set for Route 53 domains
-        if (this.hostedZone) {
-            if (typeof customDomain === "string") {
-                acmCertificate = new DnsValidatedCertificate(this, "Certificate", {
-                    domainName: customDomain,
-                    hostedZone: this.hostedZone,
-                    region: "us-east-1",
-                });
-            }
-            else if (customDomain.cdk?.certificate) {
-                acmCertificate = customDomain.cdk.certificate;
-            }
-            else {
-                acmCertificate = new DnsValidatedCertificate(this, "Certificate", {
-                    domainName: customDomain.domainName,
-                    hostedZone: this.hostedZone,
-                    region: "us-east-1",
-                });
-            }
-        }
-        // HostedZone is NOT set for non-Route 53 domains
-        else {
-            if (typeof customDomain !== "string") {
-                acmCertificate = customDomain.cdk?.certificate;
-            }
-        }
-        return acmCertificate;
-    }
-    createRoute53Records() {
-        const { customDomain } = this.props;
-        if (!customDomain || !this.hostedZone) {
-            return;
-        }
-        let recordName;
-        let domainAlias;
-        if (typeof customDomain === "string") {
-            recordName = customDomain;
-        }
-        else {
-            recordName = customDomain.domainName;
-            domainAlias = customDomain.domainAlias;
-        }
-        // Create DNS record
-        const recordProps = {
-            recordName,
-            zone: this.hostedZone,
-            target: RecordTarget.fromAlias(new CloudFrontTarget(this.distribution)),
-        };
-        new ARecord(this, "AliasRecord", recordProps);
-        new AaaaRecord(this, "AliasRecordAAAA", recordProps);
-        // Create Alias redirect record
-        if (domainAlias) {
-            new HttpsRedirect(this, "Redirect", {
-                zone: this.hostedZone,
-                recordNames: [domainAlias],
-                targetDomain: recordName,
-            });
-        }
-    }
-    /////////////////////
     // Helper Functions
     /////////////////////
     getS3ContentReplaceValues() {
@@ -650,3 +455,14 @@ function handler(event) {
         return replaceValues;
     }
 }
+export const useSites = createAppContext(() => {
+    const sites = [];
+    return {
+        add(stack, name, props) {
+            sites.push({ stack, name, props });
+        },
+        get all() {
+            return sites;
+        },
+    };
+});

package/constructs/deprecated/NextjsSite.d.ts

@@ -5,10 +5,11 @@ import * as route53 from "aws-cdk-lib/aws-route53";
 import * as cloudfront from "aws-cdk-lib/aws-cloudfront";
 import * as acm from "aws-cdk-lib/aws-certificatemanager";
 import { SSTConstruct } from "../Construct.js";
-import { BaseSiteDomainProps, BaseSiteCdkDistributionProps } from "../BaseSite.js";
+import { DistributionDomainProps } from "../Distribution.js";
+import { BaseSiteCdkDistributionProps } from "../BaseSite.js";
 import { Permissions } from "../util/permission.js";
 import { FunctionBindingProps } from "../util/functionBinding.js";
-export interface NextjsDomainProps extends BaseSiteDomainProps {
+export interface NextjsDomainProps extends DistributionDomainProps {
 }
 export interface NextjsCdkDistributionProps extends BaseSiteCdkDistributionProps {
 }
@@ -298,3 +299,11 @@ export declare class NextjsSite extends Construct implements SSTConstruct {
     private getLambdaContentReplaceValues;
     private normalizeRuntime;
 }
+export declare const useSites: () => {
+    add(stack: string, name: string, props: NextjsSiteProps): void;
+    readonly all: {
+        stack: string;
+        name: string;
+        props: NextjsSiteProps;
+    }[];
+};

package/constructs/deprecated/NextjsSite.js

@@ -28,6 +28,7 @@ import { getParameterPath, } from "../util/functionBinding.js";
 import * as crossRegionHelper from "./cross-region-helper.js";
 import { gray, red } from "colorette";
 import { useProject } from "../../project.js";
+import { createAppContext } from "../context.js";
 const __dirname = url.fileURLToPath(new URL(".", import.meta.url));
 /////////////////////
 // Construct
@@ -129,6 +130,7 @@ export class NextjsSite extends Construct {
         this.props = props;
         this.cdk = {};
         this.awsCliLayer = new AwsCliLayer(this, "AwsCliLayer");
+        useSites().add(stack.stackName, id, this.props);
         // Build app
         if (this.isPlaceholder) {
             this.buildOutDir = null;
@@ -1060,3 +1062,14 @@ export class NextjsSite extends Construct {
         return lambda.Runtime.NODEJS_16_X;
     }
 }
+export const useSites = createAppContext(() => {
+    const sites = [];
+    return {
+        add(stack, name, props) {
+            sites.push({ stack, name, props });
+        },
+        get all() {
+            return sites;
+        },
+    };
+});

package/constructs/index.d.ts

@@ -12,6 +12,7 @@ export * from "./Table.js";
 export * from "./Topic.js";
 export * from "./Bucket.js";
 export * from "./Script.js";
+export * from "./Service.js";
 export * from "./EventBus.js";
 export * from "./Function.js";
 export * from "./AppSyncApi.js";

package/constructs/index.js

@@ -12,6 +12,7 @@ export * from "./Table.js";
 export * from "./Topic.js";
 export * from "./Bucket.js";
 export * from "./Script.js";
+export * from "./Service.js";
 export * from "./EventBus.js";
 export * from "./Function.js";
 export * from "./AppSyncApi.js";

package/node/event-bus/index.d.ts

@@ -31,10 +31,13 @@ type EventPayload<E extends Event> = {
     type: E["type"];
     properties: E["shape"]["properties"];
     metadata: undefined extends E["shape"]["metadata"] ? E["shape"]["metadataFn"] : E["shape"]["metadata"];
+    attempts: number;
 };
 export declare function EventHandler<Events extends Event>(_events: Events | Events[], cb: (evt: {
     [K in Events["type"]]: EventPayload<Extract<Events, {
         type: K;
     }>>;
-}[Events["type"]]) => Promise<void>): (event: EventBridgeEvent<string, any>) => Promise<void>;
+}[Events["type"]]) => Promise<void>): (event: EventBridgeEvent<string, any> & {
+    attempts?: number;
+}) => Promise<void>;
 export {};

package/node/event-bus/index.js

@@ -51,6 +51,7 @@ export function EventHandler(_events, cb) {
             type: event["detail-type"],
             properties: event.detail.properties,
             metadata: event.detail.metadata,
+            attempts: event.attempts ?? 0,
         });
     };
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "sideEffects": false,
   "name": "sst",
-  "version": "2.22.11",
+  "version": "2.23.1",
   "bin": {
     "sst": "cli/sst.js"
   },
@@ -32,6 +32,7 @@
     "@aws-cdk/cloudformation-diff": "2.84.0",
     "@aws-cdk/cx-api": "2.84.0",
     "@aws-sdk/client-cloudformation": "^3.279.0",
+    "@aws-sdk/client-ecs": "^3.279.0",
     "@aws-sdk/client-eventbridge": "^3.342.0",
     "@aws-sdk/client-iam": "^3.279.0",
     "@aws-sdk/client-iot": "^3.279.0",

package/project.d.ts

@@ -16,6 +16,7 @@ export interface ConfigOptions {
         disableParameterizedStackNameCheck?: boolean;
     };
     bootstrap?: {
+        useCdkBucket?: boolean;
         stackName?: string;
         tags?: Record<string, string>;
     };