sst 3.0.0 → 3.0.1-10

package/bootstrap.js

@@ -1,318 +0,0 @@
-import url from "url";
-import path from "path";
-import { bold, dim } from "colorette";
-import { spawn } from "child_process";
-import { DescribeStacksCommand, CloudFormationClient, } from "@aws-sdk/client-cloudformation";
-import { App, DefaultStackSynthesizer, Duration, CfnOutput, Tags, Stack, RemovalPolicy, } from "aws-cdk-lib/core";
-import { Function, Runtime, Code } from "aws-cdk-lib/aws-lambda";
-import { ManagedPolicy, PermissionsBoundary, PolicyStatement, } from "aws-cdk-lib/aws-iam";
-import { Rule } from "aws-cdk-lib/aws-events";
-import { LambdaFunction } from "aws-cdk-lib/aws-events-targets";
-import { BlockPublicAccess, Bucket, BucketEncryption, } from "aws-cdk-lib/aws-s3";
-import { useProject } from "./project.js";
-import { createSpinner } from "./cli/spinner.js";
-import { useAWSClient, useAWSCredentials, useSTSIdentity, } from "./credentials.js";
-import { VisibleError } from "./error.js";
-import { Logger } from "./logger.js";
-import { Stacks } from "./stacks/index.js";
-import { lazy } from "./util/lazy.js";
-const CDK_STACK_NAME = "CDKToolkit";
-const SST_STACK_NAME = "SSTBootstrap";
-const OUTPUT_VERSION = "Version";
-const OUTPUT_BUCKET = "BucketName";
-const LATEST_VERSION = "7.2";
-const __dirname = url.fileURLToPath(new URL(".", import.meta.url));
-export const useBootstrap = lazy(async () => {
-    Logger.debug("Initializing bootstrap context");
-    let [cdkStatus, sstStatus] = await Promise.all([
-        loadCDKStatus(),
-        loadSSTStatus(),
-    ]);
-    Logger.debug("Loaded bootstrap status");
-    const needToBootstrapCDK = cdkStatus.status !== "ready";
-    const needToBootstrapSST = sstStatus.status !== "ready";
-    if (needToBootstrapCDK || needToBootstrapSST) {
-        const spinner = createSpinner(cdkStatus.status === "bootstrap" || sstStatus.status === "bootstrap"
-            ? "Deploying bootstrap stack, this only needs to happen once"
-            : "Updating bootstrap stack").start();
-        if (needToBootstrapCDK) {
-            await bootstrapCDK();
-            // fetch bootstrap status
-            cdkStatus = await loadCDKStatus();
-            if (cdkStatus.status !== "ready")
-                throw new VisibleError("Failed to load bootstrap stack status");
-        }
-        if (needToBootstrapSST) {
-            await bootstrapSST(cdkStatus.bucket);
-            // fetch bootstrap status
-            sstStatus = await loadSSTStatus();
-            if (sstStatus.status !== "ready")
-                throw new VisibleError("Failed to load bootstrap stack status");
-        }
-        spinner.succeed();
-    }
-    Logger.debug("Bootstrap context initialized", sstStatus);
-    return sstStatus;
-});
-async function loadCDKStatus() {
-    const { cdk } = useProject().config;
-    const client = useAWSClient(CloudFormationClient);
-    const stackName = cdk?.toolkitStackName || CDK_STACK_NAME;
-    try {
-        const { Stacks: stacks } = await client.send(new DescribeStacksCommand({ StackName: stackName }));
-        // Check CDK bootstrap stack exists
-        if (!stacks || stacks.length === 0)
-            return { status: "bootstrap" };
-        // Check CDK bootstrap stack deployed successfully
-        if (![
-            "CREATE_COMPLETE",
-            "UPDATE_COMPLETE",
-            "UPDATE_ROLLBACK_COMPLETE",
-        ].includes(stacks[0].StackStatus)) {
-            return { status: "bootstrap" };
-        }
-        // Check CDK bootstrap stack is up to date
-        // note: there is no a programmatical way to get the minimal required version
-        //       of CDK bootstrap stack. We are going to hardcode it to 14 for now,
-        //       which is the latest version as of CDK v2.62.2
-        let version;
-        let bucket;
-        const output = stacks[0].Outputs?.forEach((o) => {
-            if (o.OutputKey === "BootstrapVersion") {
-                version = parseInt(o.OutputValue);
-            }
-            else if (o.OutputKey === "BucketName") {
-                bucket = o.OutputValue;
-            }
-        });
-        if (!version || version < 14 || !bucket) {
-            return { status: "update" };
-        }
-        return { status: "ready", version, bucket };
-    }
-    catch (e) {
-        if (e.name === "ValidationError" &&
-            e.message === `Stack with id ${stackName} does not exist`) {
-            return { status: "bootstrap" };
-        }
-        else {
-            throw e;
-        }
-    }
-}
-async function loadSSTStatus() {
-    // Get bootstrap CloudFormation stack
-    const { bootstrap } = useProject().config;
-    const cf = useAWSClient(CloudFormationClient);
-    const stackName = bootstrap?.stackName || SST_STACK_NAME;
-    let result;
-    try {
-        result = await cf.send(new DescribeStacksCommand({
-            StackName: stackName,
-        }));
-    }
-    catch (e) {
-        if (e.Code === "ValidationError" &&
-            e.message === `Stack with id ${stackName} does not exist`) {
-            return { status: "bootstrap" };
-        }
-        throw e;
-    }
-    // Parse stack outputs
-    let version;
-    let bucket;
-    (result.Stacks[0].Outputs || []).forEach((o) => {
-        if (o.OutputKey === OUTPUT_VERSION) {
-            version = o.OutputValue;
-        }
-        else if (o.OutputKey === OUTPUT_BUCKET) {
-            bucket = o.OutputValue;
-        }
-    });
-    if (!version || !bucket) {
-        return { status: "bootstrap" };
-    }
-    // Need to update bootstrap stack:
-    // 1. If current MAJOR version < latest MAJOR version
-    // 2. If current MAJOR version > latest MAJOR version (has breaking change)
-    // 3. If current MAJOR version == latest MAJOR version,
-    //    but current MINOR version < latest MINOR version
-    const latestParts = LATEST_VERSION.split(".");
-    const latestMajor = parseInt(latestParts[0]);
-    const latestMinor = parseInt(latestParts[1] || "0");
-    const currentParts = version.split(".");
-    const currentMajor = parseInt(currentParts[0]);
-    const currentMinor = parseInt(currentParts[1] || "0");
-    if (currentMajor < latestMajor ||
-        currentMajor > latestMajor ||
-        currentMinor < latestMinor) {
-        return { status: "update" };
-    }
-    return { status: "ready", version, bucket };
-}
-export async function bootstrapSST(cdkBucket) {
-    const { region, bootstrap, cdk } = useProject().config;
-    // Create bootstrap stack
-    const app = new App();
-    const stackName = bootstrap?.stackName || SST_STACK_NAME;
-    const stack = new Stack(app, stackName, {
-        env: {
-            region,
-        },
-        synthesizer: new DefaultStackSynthesizer({
-            qualifier: cdk?.qualifier,
-            bootstrapStackVersionSsmParameter: cdk?.bootstrapStackVersionSsmParameter,
-            fileAssetsBucketName: cdk?.fileAssetsBucketName,
-            deployRoleArn: cdk?.deployRoleArn,
-            fileAssetPublishingRoleArn: cdk?.fileAssetPublishingRoleArn,
-            imageAssetPublishingRoleArn: cdk?.imageAssetPublishingRoleArn,
-            imageAssetsRepositoryName: cdk?.imageAssetsRepositoryName,
-            cloudFormationExecutionRole: cdk?.cloudFormationExecutionRole,
-            lookupRoleArn: cdk?.lookupRoleArn,
-        }),
-    });
-    // Add tags to stack
-    for (const [key, value] of Object.entries(bootstrap?.tags || {})) {
-        Tags.of(app).add(key, value);
-    }
-    // Create S3 bucket to store stacks metadata
-    const bucket = bootstrap?.useCdkBucket
-        ? {
-            bucketName: cdkBucket,
-            bucketArn: `arn:${stack.partition}:s3:::${cdkBucket}`,
-        }
-        : 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")),
-        handler: "index.handler",
-        runtime: region?.startsWith("us-gov-")
-            ? Runtime.NODEJS_16_X
-            : Runtime.NODEJS_18_X,
-        environment: {
-            BUCKET_NAME: bucket.bucketName,
-        },
-        initialPolicy: [
-            new PolicyStatement({
-                actions: ["cloudformation:DescribeStacks"],
-                resources: ["*"],
-            }),
-            new PolicyStatement({
-                actions: ["s3:PutObject", "s3:DeleteObject"],
-                resources: [bucket.bucketArn + "/*"],
-            }),
-            new PolicyStatement({
-                actions: ["iot:Publish"],
-                resources: [
-                    `arn:${stack.partition}:iot:${stack.region}:${stack.account}:topic//sst/*`,
-                ],
-            }),
-        ],
-    });
-    const rule = new Rule(stack, "MetadataRule", {
-        eventPattern: {
-            source: ["aws.cloudformation"],
-            detailType: ["CloudFormation Stack Status Change"],
-            detail: {
-                "status-details": {
-                    status: [
-                        "CREATE_COMPLETE",
-                        "UPDATE_COMPLETE",
-                        "UPDATE_ROLLBACK_COMPLETE",
-                        "ROLLBACK_COMPLETE",
-                        "DELETE_COMPLETE",
-                    ],
-                },
-            },
-        },
-    });
-    rule.addTarget(new LambdaFunction(fn));
-    // Create permissions boundary
-    if (cdk?.customPermissionsBoundary) {
-        const boundaryPolicy = ManagedPolicy.fromManagedPolicyName(stack, "PermissionBoundaryPolicy", cdk.customPermissionsBoundary);
-        PermissionsBoundary.of(stack).apply(boundaryPolicy);
-    }
-    // Create stack outputs to store bootstrap stack info
-    new CfnOutput(stack, OUTPUT_VERSION, { value: LATEST_VERSION });
-    new CfnOutput(stack, OUTPUT_BUCKET, { value: bucket.bucketName });
-    // Deploy bootstrap stack
-    const asm = app.synth();
-    const result = await Stacks.deploy(asm.stacks[0]);
-    if (Stacks.isFailed(result.status)) {
-        throw new VisibleError(`Failed to deploy bootstrap stack:\n${JSON.stringify(result.errors, null, 4)}`);
-    }
-}
-async function bootstrapCDK() {
-    const identity = await useSTSIdentity();
-    const credentials = await useAWSCredentials();
-    const { region, profile, cdk } = useProject().config;
-    await new Promise((resolve, reject) => {
-        const proc = spawn([
-            "npx",
-            "cdk",
-            "bootstrap",
-            `aws://${identity.Account}/${region}`,
-            "--no-version-reporting",
-            ...(cdk?.publicAccessBlockConfiguration === false
-                ? ["--public-access-block-configuration", "false"]
-                : cdk?.publicAccessBlockConfiguration === true
-                    ? ["--public-access-block-configuration", "false"]
-                    : []),
-            ...(cdk?.toolkitStackName
-                ? ["--toolkit-stack-name", cdk.toolkitStackName]
-                : []),
-            ...(cdk?.qualifier ? ["--qualifier", cdk.qualifier] : []),
-            ...(cdk?.fileAssetsBucketName
-                ? ["--toolkit-bucket-name", cdk.fileAssetsBucketName]
-                : []),
-            ...(cdk?.customPermissionsBoundary
-                ? ["--custom-permissions-boundary", cdk.customPermissionsBoundary]
-                : []),
-        ].join(" "), {
-            env: {
-                ...process.env,
-                AWS_ACCESS_KEY_ID: credentials.accessKeyId,
-                AWS_SECRET_ACCESS_KEY: credentials.secretAccessKey,
-                AWS_SESSION_TOKEN: credentials.sessionToken,
-                AWS_REGION: region,
-                AWS_PROFILE: profile,
-                JSII_SILENCE_WARNING_DEPRECATED_NODE_VERSION: "1",
-            },
-            stdio: "pipe",
-            shell: true,
-        });
-        let stderr = "";
-        proc.stdout.on("data", (data) => {
-            Logger.debug(data.toString());
-        });
-        proc.stderr.on("data", (data) => {
-            Logger.debug(data.toString());
-            stderr += data;
-        });
-        proc.on("exit", (code) => {
-            Logger.debug("CDK bootstrap exited with code " + code);
-            if (code === 0) {
-                resolve();
-            }
-            else {
-                console.log(bold(dim(stderr)));
-                reject(new VisibleError(`Failed to bootstrap`));
-            }
-        });
-    });
-}

package/bus.d.ts

@@ -1,20 +0,0 @@
-export interface Events {
-}
-export type EventTypes = keyof Events;
-export type EventPayload<Type extends EventTypes = EventTypes> = {
-    type: Type;
-    sourceID: string;
-    properties: Events[Type];
-};
-type Subscription = {
-    type: EventTypes;
-    cb: (payload: any) => void;
-};
-export declare const useBus: () => {
-    sourceID: string;
-    publish<Type extends keyof Events>(type: Type, properties: Events[Type]): void;
-    unsubscribe(sub: Subscription): void;
-    subscribe<Type_1 extends keyof Events>(type: Type_1, cb: (payload: EventPayload<Type_1>) => void): Subscription;
-    forward<T extends (keyof Events)[]>(..._types: T): <Type_2 extends T[number]>(type: Type_2, cb: (payload: EventPayload<Type_2>) => void) => Subscription;
-};
-export {};

package/bus.js

@@ -1,52 +0,0 @@
-import crypto from "crypto";
-import { Logger } from "./logger.js";
-import { lazy } from "./util/lazy.js";
-const DO_NOT_LOG = new Set(["stacks.metadata"]);
-export const useBus = lazy(() => {
-    const subscriptions = {};
-    function subscribers(type) {
-        let arr = subscriptions[type];
-        if (!arr) {
-            arr = [];
-            subscriptions[type] = arr;
-        }
-        return arr;
-    }
-    const sourceID = crypto.randomBytes(16).toString("hex");
-    const result = {
-        sourceID,
-        publish(type, properties) {
-            const payload = {
-                type,
-                properties,
-                sourceID,
-            };
-            if (!DO_NOT_LOG.has(type)) {
-                Logger.debug(`Publishing event ${JSON.stringify(payload)}`);
-            }
-            for (const sub of subscribers(type))
-                sub.cb(payload);
-        },
-        unsubscribe(sub) {
-            const arr = subscribers(sub.type);
-            const index = arr.indexOf(sub);
-            if (index < 0)
-                return;
-            arr.splice(index, 1);
-        },
-        subscribe(type, cb) {
-            const sub = {
-                type,
-                cb,
-            };
-            subscribers(type).push(sub);
-            return sub;
-        },
-        forward(..._types) {
-            return (type, cb) => {
-                return this.subscribe(type, cb);
-            };
-        },
-    };
-    return result;
-});

package/cache.d.ts

@@ -1,4 +0,0 @@
-export declare const useCache: () => Promise<{
-    write: (key: string, data: string) => Promise<void>;
-    read: (key: string) => Promise<string | null>;
-}>;

package/cache.js

@@ -1,31 +0,0 @@
-import path from "path";
-import fs from "fs/promises";
-import { useProject } from "./project.js";
-import { Logger } from "./logger.js";
-import { lazy } from "./util/lazy.js";
-export const useCache = lazy(async () => {
-    const project = useProject();
-    const cache = path.join(project.paths.out, "cache");
-    await fs.mkdir(cache, {
-        recursive: true,
-    });
-    async function write(key, data) {
-        const full = path.join(cache, key);
-        Logger.debug("Writing cache", full, data.length, "bytes");
-        await fs.writeFile(full, data);
-    }
-    async function read(key) {
-        const full = path.join(cache, key);
-        try {
-            const data = await fs.readFile(full);
-            return data.toString();
-        }
-        catch {
-            return null;
-        }
-    }
-    return {
-        write,
-        read,
-    };
-});

package/cdk/deploy-stack.d.ts

@@ -1,223 +0,0 @@
-import * as cxapi from "@aws-cdk/cx-api";
-import { Tag } from "sst-aws-cdk/lib/cdk-toolkit.js";
-import { AssetManifestBuilder } from "sst-aws-cdk/lib/util/asset-manifest-builder.js";
-import { ISDK, SdkProvider } from "sst-aws-cdk/lib/api/aws-auth/index.js";
-import { HotswapMode } from "sst-aws-cdk/lib/api/hotswap/common.js";
-import { ToolkitInfo } from "sst-aws-cdk/lib/api/toolkit-info.js";
-import { ResourcesToImport } from "sst-aws-cdk/lib/api/util/cloudformation.js";
-import { StackActivityProgress } from "sst-aws-cdk/lib/api/util/cloudformation/stack-activity-monitor.js";
-type TemplateBodyParameter = {
-    TemplateBody?: string;
-    TemplateURL?: string;
-};
-export interface DeployStackResult {
-    readonly noOp: boolean;
-    readonly outputs: {
-        [name: string]: string;
-    };
-    readonly stackArn: string;
-}
-export interface DeployStackOptions {
-    /**
-     * The stack to be deployed
-     */
-    readonly stack: cxapi.CloudFormationStackArtifact;
-    /**
-     * Skip monitoring
-     */
-    readonly noMonitor?: boolean;
-    /**
-     * The environment to deploy this stack in
-     *
-     * The environment on the stack artifact may be unresolved, this one
-     * must be resolved.
-     */
-    readonly resolvedEnvironment: cxapi.Environment;
-    /**
-     * The SDK to use for deploying the stack
-     *
-     * Should have been initialized with the correct role with which
-     * stack operations should be performed.
-     */
-    readonly sdk: ISDK;
-    /**
-     * SDK provider (seeded with default credentials)
-     *
-     * Will exclusively be used to assume publishing credentials (which must
-     * start out from current credentials regardless of whether we've assumed an
-     * action role to touch the stack or not).
-     *
-     * Used for the following purposes:
-     *
-     * - Publish legacy assets.
-     * - Upload large CloudFormation templates to the staging bucket.
-     */
-    readonly sdkProvider: SdkProvider;
-    /**
-     * Information about the bootstrap stack found in the target environment
-     */
-    readonly toolkitInfo: ToolkitInfo;
-    /**
-     * Role to pass to CloudFormation to execute the change set
-     *
-     * @default - Role specified on stack, otherwise current
-     */
-    readonly roleArn?: string;
-    /**
-     * Notification ARNs to pass to CloudFormation to notify when the change set has completed
-     *
-     * @default - No notifications
-     */
-    readonly notificationArns?: string[];
-    /**
-     * Name to deploy the stack under
-     *
-     * @default - Name from assembly
-     */
-    readonly deployName?: string;
-    /**
-     * Quiet or verbose deployment
-     *
-     * @default false
-     */
-    readonly quiet?: boolean;
-    /**
-     * List of asset IDs which shouldn't be built
-     *
-     * @default - Build all assets
-     */
-    readonly reuseAssets?: string[];
-    /**
-     * Tags to pass to CloudFormation to add to stack
-     *
-     * @default - No tags
-     */
-    readonly tags?: Tag[];
-    /**
-     * What deployment method to use
-     *
-     * @default - Change set with defaults
-     */
-    readonly deploymentMethod?: DeploymentMethod;
-    /**
-     * The collection of extra parameters
-     * (in addition to those used for assets)
-     * to pass to the deployed template.
-     * Note that parameters with `undefined` or empty values will be ignored,
-     * and not passed to the template.
-     *
-     * @default - no additional parameters will be passed to the template
-     */
-    readonly parameters?: {
-        [name: string]: string | undefined;
-    };
-    /**
-     * Use previous values for unspecified parameters
-     *
-     * If not set, all parameters must be specified for every deployment.
-     *
-     * @default false
-     */
-    readonly usePreviousParameters?: boolean;
-    /**
-     * Display mode for stack deployment progress.
-     *
-     * @default StackActivityProgress.Bar stack events will be displayed for
-     *   the resource currently being deployed.
-     */
-    readonly progress?: StackActivityProgress;
-    /**
-     * Deploy even if the deployed template is identical to the one we are about to deploy.
-     * @default false
-     */
-    readonly force?: boolean;
-    /**
-     * Whether we are on a CI system
-     *
-     * @default false
-     */
-    readonly ci?: boolean;
-    /**
-     * Rollback failed deployments
-     *
-     * @default true
-     */
-    readonly rollback?: boolean;
-    readonly hotswap?: HotswapMode;
-    /**
-     * The extra string to append to the User-Agent header when performing AWS SDK calls.
-     *
-     * @default - nothing extra is appended to the User-Agent header
-     */
-    readonly extraUserAgent?: string;
-    /**
-     * If set, change set of type IMPORT will be created, and resourcesToImport
-     * passed to it.
-     */
-    readonly resourcesToImport?: ResourcesToImport;
-    /**
-     * If present, use this given template instead of the stored one
-     *
-     * @default - Use the stored template
-     */
-    readonly overrideTemplate?: any;
-    /**
-     * Whether to build/publish assets in parallel
-     *
-     * @default true To remain backward compatible.
-     */
-    readonly assetParallelism?: boolean;
-}
-export type DeploymentMethod = DirectDeploymentMethod | ChangeSetDeploymentMethod;
-export interface DirectDeploymentMethod {
-    readonly method: "direct";
-}
-export interface ChangeSetDeploymentMethod {
-    readonly method: "change-set";
-    /**
-     * Whether to execute the changeset or leave it in review.
-     *
-     * @default true
-     */
-    readonly execute?: boolean;
-    /**
-     * Optional name to use for the CloudFormation change set.
-     * If not provided, a name will be generated automatically.
-     */
-    readonly changeSetName?: string;
-}
-export declare function deployStack(options: DeployStackOptions): Promise<DeployStackResult | undefined>;
-/**
- * Prepares the body parameter for +CreateChangeSet+.
- *
- * If the template is small enough to be inlined into the API call, just return
- * it immediately.
- *
- * Otherwise, add it to the asset manifest to get uploaded to the staging
- * bucket and return its coordinates. If there is no staging bucket, an error
- * is thrown.
- *
- * @param stack     the synthesized stack that provides the CloudFormation template
- * @param toolkitInfo information about the toolkit stack
- */
-export declare function makeBodyParameter(stack: cxapi.CloudFormationStackArtifact, resolvedEnvironment: cxapi.Environment, assetManifest: AssetManifestBuilder, toolkitInfo: ToolkitInfo, sdk: ISDK, overrideTemplate?: any): Promise<TemplateBodyParameter>;
-/**
- * Prepare a body parameter for CFN, performing the upload
- *
- * Return it as-is if it is small enough to pass in the API call,
- * upload to S3 and return the coordinates if it is not.
- */
-export declare function makeBodyParameterAndUpload(stack: cxapi.CloudFormationStackArtifact, resolvedEnvironment: cxapi.Environment, toolkitInfo: ToolkitInfo, sdkProvider: SdkProvider, sdk: ISDK, overrideTemplate?: any): Promise<TemplateBodyParameter>;
-export interface DestroyStackOptions {
-    /**
-     * The stack to be destroyed
-     */
-    stack: cxapi.CloudFormationStackArtifact;
-    sdk: ISDK;
-    roleArn?: string;
-    deployName?: string;
-    quiet?: boolean;
-    ci?: boolean;
-}
-export declare function destroyStack(options: DestroyStackOptions): Promise<void>;
-export {};