sst 3.0.0 → 3.0.1-10

package/constructs/Cron.d.ts

@@ -1,164 +0,0 @@
-import { Construct } from "constructs";
-import * as events from "aws-cdk-lib/aws-events";
-import * as eventsTargets from "aws-cdk-lib/aws-events-targets";
-import { SSTConstruct } from "./Construct.js";
-import { Function as Func, FunctionInlineDefinition, FunctionDefinition } from "./Function.js";
-import { Permissions } from "./util/permission.js";
-export interface CronJobProps {
-    /**
-     * The function that will be executed when the job runs.
-     *
-     * @example
-     * ```js
-     *   new Cron(stack, "Cron", {
-     *     job: {
-     *       function: "src/lambda.main",
-     *     },
-     *   });
-     * ```
-     */
-    function: FunctionDefinition;
-    cdk?: {
-        /**
-         * Override the default settings this construct uses internally to create the events rule.
-         */
-        target?: eventsTargets.LambdaFunctionProps;
-    };
-}
-export interface CronProps {
-    /**
-     * The definition of the function to be executed.
-     *
-     * @example
-     * ```js
-     * new Cron(stack, "Cron", {
-     *   job : "src/lambda.main",
-     *   schedule: "rate(5 minutes)",
-     * })
-     * ```
-     */
-    job: FunctionInlineDefinition | CronJobProps;
-    /**
-     * The schedule for the cron job.
-     *
-     * The string format takes a [rate expression](https://docs.aws.amazon.com/lambda/latest/dg/services-cloudwatchevents-expressions.html).
-     *
-     * ```txt
-     * rate(1 minute)
-     * rate(5 minutes)
-     * rate(1 hour)
-     * rate(5 hours)
-     * rate(1 day)
-     * rate(5 days)
-     * ```
-     * Or as a [cron expression](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-create-rule-schedule.html#eb-cron-expressions).
-     *
-     * ```txt
-     * cron(15 10 * * ? *)    // 10:15 AM (UTC) every day.
-     * ```
-     *
-     * @example
-     * ```js
-     * new Cron(stack, "Cron", {
-     *   job: "src/lambda.main",
-     *   schedule: "rate(5 minutes)",
-     * });
-     * ```
-     * ```js
-     * new Cron(stack, "Cron", {
-     *   job: "src/lambda.main",
-     *   schedule: "cron(15 10 * * ? *)",
-     * });
-     * ```
-     */
-    schedule?: `rate(${string})` | `cron(${string})`;
-    /**
-     * Indicates whether the cron job is enabled.
-     * @default true
-     * @example
-     * ```js
-     * new Cron(stack, "Cron", {
-     *   job: "src/lambda.main",
-     *   schedule: "rate(5 minutes)",
-     *   enabled: app.mode === "dev",
-     * })
-     * ```
-     */
-    enabled?: boolean;
-    cdk?: {
-        /**
-         * Allows you to override default id for this construct.
-         */
-        id?: string;
-        /**
-         * Override the default settings this construct uses internally to create the events rule.
-         */
-        rule?: events.RuleProps;
-    };
-}
-/**
- * The `Cron` construct is a higher level CDK construct that makes it easy to create a cron job.
- *
- * @example
- *
- * ```js
- * import { Cron } from "sst/constructs";
- *
- * new Cron(stack, "Cron", {
- *   schedule: "rate(1 minute)",
- *   job: "src/lambda.main",
- * });
- * ```
- */
-export declare class Cron extends Construct implements SSTConstruct {
-    readonly id: string;
-    readonly cdk: {
-        /**
-         * The internally created CDK EventBridge Rule instance.
-         */
-        rule: events.Rule;
-    };
-    /**
-     * The internally created Function instance that'll be run on schedule.
-     */
-    readonly jobFunction: Func;
-    private props;
-    constructor(scope: Construct, id: string, props: CronProps);
-    /**
-     * Binds the given list of resources to the cron job.
-     *
-     * @example
-     *
-     * ```js
-     * cron.bind([STRIPE_KEY, bucket]);
-     * ```
-     *
-     */
-    bind(constructs: SSTConstruct[]): void;
-    /**
-     * Attaches the given list of permissions to the cron job. This allows the function to access other AWS resources.
-     *
-     * @example
-     *
-     * ```js
-     * cron.attachPermissions(["s3"]);
-     * ```
-     *
-     */
-    attachPermissions(permissions: Permissions): void;
-    getConstructMetadata(): {
-        type: "Cron";
-        data: {
-            schedule: string | undefined;
-            ruleName: string;
-            job: {
-                node: string;
-                stack: string;
-            } | undefined;
-        };
-    };
-    /** @internal */
-    getFunctionBinding(): undefined;
-    private createEventsRule;
-    private createRuleTarget;
-}

package/constructs/Cron.js

@@ -1,114 +0,0 @@
-import { Construct } from "constructs";
-import * as events from "aws-cdk-lib/aws-events";
-import * as eventsTargets from "aws-cdk-lib/aws-events-targets";
-import { getFunctionRef } from "./Construct.js";
-import { Function as Func, } from "./Function.js";
-/////////////////////
-// Construct
-/////////////////////
-/**
- * The `Cron` construct is a higher level CDK construct that makes it easy to create a cron job.
- *
- * @example
- *
- * ```js
- * import { Cron } from "sst/constructs";
- *
- * new Cron(stack, "Cron", {
- *   schedule: "rate(1 minute)",
- *   job: "src/lambda.main",
- * });
- * ```
- */
-export class Cron extends Construct {
-    id;
-    cdk;
-    /**
-     * The internally created Function instance that'll be run on schedule.
-     */
-    jobFunction;
-    props;
-    constructor(scope, id, props) {
-        super(scope, props.cdk?.id || id);
-        this.id = id;
-        this.props = props;
-        this.cdk = {};
-        this.createEventsRule();
-        this.jobFunction = this.createRuleTarget();
-    }
-    /**
-     * Binds the given list of resources to the cron job.
-     *
-     * @example
-     *
-     * ```js
-     * cron.bind([STRIPE_KEY, bucket]);
-     * ```
-     *
-     */
-    bind(constructs) {
-        this.jobFunction.bind(constructs);
-    }
-    /**
-     * Attaches the given list of permissions to the cron job. This allows the function to access other AWS resources.
-     *
-     * @example
-     *
-     * ```js
-     * cron.attachPermissions(["s3"]);
-     * ```
-     *
-     */
-    attachPermissions(permissions) {
-        this.jobFunction.attachPermissions(permissions);
-    }
-    getConstructMetadata() {
-        const cfnRule = this.cdk.rule.node.defaultChild;
-        return {
-            type: "Cron",
-            data: {
-                schedule: cfnRule.scheduleExpression,
-                ruleName: this.cdk.rule.ruleName,
-                job: getFunctionRef(this.jobFunction),
-            },
-        };
-    }
-    /** @internal */
-    getFunctionBinding() {
-        return undefined;
-    }
-    createEventsRule() {
-        const { cdk, schedule, enabled } = this.props;
-        const id = this.node.id;
-        // Configure Schedule
-        if (!schedule && !cdk?.rule?.schedule) {
-            throw new Error(`No schedule defined for the "${id}" Cron`);
-        }
-        this.cdk.rule = new events.Rule(this, "Rule", {
-            schedule: schedule && events.Schedule.expression(schedule),
-            enabled: enabled === false ? false : true,
-            ...cdk?.rule,
-        });
-    }
-    createRuleTarget() {
-        const { job } = this.props;
-        const id = this.node.id;
-        if (!job) {
-            throw new Error(`No job defined for the "${id}" Cron`);
-        }
-        // normalize job
-        let jobFunction, jobProps;
-        if (job.function) {
-            jobFunction = job.function;
-            jobProps = job.cdk?.target;
-        }
-        else {
-            jobFunction = job;
-            jobProps = {};
-        }
-        // create function
-        const fn = Func.fromDefinition(this, `Job_${this.node.id}`, jobFunction);
-        this.cdk.rule.addTarget(new eventsTargets.LambdaFunction(fn, jobProps));
-        return fn;
-    }
-}

package/constructs/Distribution.d.ts

@@ -1,143 +0,0 @@
-import { Construct, IConstruct } from "constructs";
-import { CustomResource } from "aws-cdk-lib/core";
-import { IHostedZone } from "aws-cdk-lib/aws-route53";
-import { DistributionProps as CdkDistributionProps, IDistribution } from "aws-cdk-lib/aws-cloudfront";
-import { ICertificate } from "aws-cdk-lib/aws-certificatemanager";
-/**
- * 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 DistributionDomainProps {
-    /**
-     * 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 DistributionProps {
-    /**
-     * 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
-     * customDomain: "domain.com",
-     * ```
-     *
-     * ```js
-     * customDomain: {
-     *   domainName: "domain.com",
-     *   domainAlias: "www.domain.com",
-     *   hostedZone: "domain.com"
-     * },
-     * ```
-     */
-    customDomain?: string | DistributionDomainProps;
-    /**
-     * The SSR function is deployed to Lambda in a single region. Alternatively, you can enable this option to deploy to Lambda@Edge.
-     * @default false
-     */
-    /**
-     * While deploying, SST waits for the CloudFront cache invalidation process to finish. This ensures that the new content will be served once the deploy command finishes. However, this process can sometimes take more than 5 mins. For non-prod environments it might make sense to pass in `false`. That'll skip waiting for the cache to invalidate and speed up the deploy process.
-     * @default false
-     */
-    waitForInvalidation?: boolean;
-    scopeOverride?: IConstruct;
-    cdk: {
-        distribution: CdkDistributionProps | IDistribution;
-    };
-}
-export declare class Distribution extends Construct {
-    private scope;
-    private props;
-    private distribution;
-    private hostedZone?;
-    private certificate?;
-    constructor(scope: Construct, id: string, props: DistributionProps);
-    /**
-     * The CloudFront URL of the website.
-     */
-    get url(): string;
-    /**
-     * If the custom domain is enabled, this is the URL of the website with the
-     * custom domain.
-     */
-    get customDomainUrl(): string | undefined;
-    /**
-     * The internally created CDK resources.
-     */
-    get cdk(): {
-        distribution: IDistribution;
-        hostedZone: IHostedZone | undefined;
-        certificate: ICertificate | undefined;
-    };
-    createInvalidation(buildId?: string): CustomResource;
-    private validateCloudFrontDistributionSettings;
-    private validateCustomDomainSettings;
-    private lookupHostedZone;
-    private createCertificate;
-    private createDistribution;
-    private buildDistributionDomainNames;
-    private createRoute53Records;
-}

package/constructs/Distribution.js

@@ -1,260 +0,0 @@
-import { Construct } from "constructs";
-import { CustomResource } from "aws-cdk-lib/core";
-import { Effect, Policy, PolicyStatement } from "aws-cdk-lib/aws-iam";
-import { HostedZone, ARecord, AaaaRecord, RecordTarget, } from "aws-cdk-lib/aws-route53";
-import { Distribution as CdkDistribution, } from "aws-cdk-lib/aws-cloudfront";
-import { CloudFrontTarget } from "aws-cdk-lib/aws-route53-targets";
-import { Stack } from "./Stack.js";
-import { isCDKConstruct } from "./Construct.js";
-import { HttpsRedirect } from "./cdk/website-redirect.js";
-import { DnsValidatedCertificate } from "./cdk/dns-validated-certificate.js";
-export class Distribution extends Construct {
-    scope;
-    props;
-    distribution;
-    hostedZone;
-    certificate;
-    constructor(scope, id, props) {
-        super(scope, id);
-        // Override scope
-        // note: this is intended to be used internally by SST to make constructs
-        //       backwards compatible when the hirechical structure of the constructs
-        //       changes. When the hirerchical structure changes, the child AWS
-        //       resources' logical ID will change. And CloudFormation will recreate
-        //       them.
-        this.scope = props.scopeOverride || this;
-        this.props = props;
-        const isImportedCloudFrontDistribution = (distribution) => {
-            return distribution !== undefined && isCDKConstruct(distribution);
-        };
-        // cdk.distribution is an imported construct
-        if (isImportedCloudFrontDistribution(props.cdk?.distribution)) {
-            this.distribution = props.cdk?.distribution;
-            return;
-        }
-        this.validateCustomDomainSettings();
-        this.validateCloudFrontDistributionSettings();
-        this.hostedZone = this.lookupHostedZone();
-        this.certificate = this.createCertificate();
-        this.distribution = this.createDistribution();
-        this.createRoute53Records();
-    }
-    /**
-     * The CloudFront URL of the website.
-     */
-    get url() {
-        return `https://${this.distribution.distributionDomainName}`;
-    }
-    /**
-     * If the custom domain is enabled, this is the URL of the website with the
-     * custom domain.
-     */
-    get customDomainUrl() {
-        const { customDomain } = this.props;
-        if (!customDomain)
-            return;
-        if (typeof customDomain === "string") {
-            return `https://${customDomain}`;
-        }
-        else {
-            return `https://${customDomain.domainName}`;
-        }
-    }
-    /**
-     * The internally created CDK resources.
-     */
-    get cdk() {
-        return {
-            distribution: this.distribution,
-            hostedZone: this.hostedZone,
-            certificate: this.certificate,
-        };
-    }
-    createInvalidation(buildId) {
-        const stack = Stack.of(this);
-        const policy = new Policy(this.scope, "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.scope, "CloudFrontInvalidator", {
-            serviceToken: stack.customResourceHandler.functionArn,
-            resourceType: "Custom::CloudFrontInvalidator",
-            properties: {
-                buildId: buildId || Date.now().toString(),
-                distributionId: this.distribution.distributionId,
-                paths: ["/*"],
-                waitForInvalidation: this.props.waitForInvalidation,
-            },
-        });
-        resource.node.addDependency(policy);
-        return resource;
-    }
-    validateCloudFrontDistributionSettings() {
-        const { cdk } = this.props;
-        if (!cdk?.distribution)
-            return;
-        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.`);
-        }
-    }
-    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.scope, "HostedZone", {
-                domainName: customDomain,
-            });
-        }
-        else if (customDomain.cdk?.hostedZone) {
-            hostedZone = customDomain.cdk.hostedZone;
-        }
-        else if (typeof customDomain.hostedZone === "string") {
-            hostedZone = HostedZone.fromLookup(this.scope, "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.scope, "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.scope, "Certificate", {
-                    domainName: customDomain,
-                    hostedZone: this.hostedZone,
-                    region: "us-east-1",
-                });
-            }
-            else if (customDomain.cdk?.certificate) {
-                acmCertificate = customDomain.cdk.certificate;
-            }
-            else {
-                acmCertificate = new DnsValidatedCertificate(this.scope, "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;
-    }
-    createDistribution() {
-        const { cdk } = this.props;
-        return new CdkDistribution(this.scope, "Distribution", {
-            ...cdk?.distribution,
-            domainNames: this.buildDistributionDomainNames(),
-            certificate: this.certificate,
-        });
-    }
-    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;
-    }
-    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.scope, "AliasRecord", recordProps);
-        new AaaaRecord(this.scope, "AliasRecordAAAA", recordProps);
-        // Create Alias redirect record
-        if (domainAlias) {
-            new HttpsRedirect(this.scope, "Redirect", {
-                zone: this.hostedZone,
-                recordNames: [domainAlias],
-                targetDomain: recordName,
-            });
-        }
-    }
-}