sst 1.16.0 → 2.0.0-rc.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 SST
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/{dist/app.d.ts → app.d.ts}

@@ -1,8 +1,8 @@
 export interface Project {
     name: string;
+    region: string;
     stage?: string;
     profile?: string;
-    region?: string;
     main?: string;
     ssmPrefix?: string;
 }
@@ -14,16 +14,23 @@ declare const DEFAULTS: {
 declare type ProjectWithDefaults = Project & Required<{
     [key in keyof typeof DEFAULTS]: Exclude<Project[key], undefined>;
 }> & {
+    version: string;
     paths: {
         root: string;
         out: string;
+        artifacts: string;
     };
 };
+export declare const ProjectContext: {
+    use(): ProjectWithDefaults;
+    provide(value: ProjectWithDefaults): void;
+};
 export declare function useProject(): ProjectWithDefaults;
 interface GlobalOptions {
     profile?: string;
     stage?: string;
     root?: string;
+    region?: string;
 }
 export declare function initProject(globals: GlobalOptions): Promise<void>;
 export {};

package/app.js

@@ -0,0 +1,122 @@
+import fs from "fs/promises";
+import fsSync from "fs";
+import path from "path";
+import url from "url";
+import os from "os";
+import { Logger } from "./logger.js";
+import { Context } from "./context/context.js";
+import { VisibleError } from "./error.js";
+import { blue } from "colorette";
+import { dynamicImport } from "./util/module.js";
+import dotenv from "dotenv";
+const DEFAULTS = {
+    main: "stacks/index.ts",
+    stage: undefined,
+    ssmPrefix: undefined,
+};
+export const ProjectContext = Context.create();
+export function useProject() {
+    return ProjectContext.use();
+}
+const CONFIG_EXTENSIONS = [".config.cjs", ".config.mjs", ".config.js", ".json"];
+export async function initProject(globals) {
+    const root = globals.root || (await findRoot());
+    const out = path.join(root, ".sst");
+    await fs.mkdir(out, {
+        recursive: true,
+    });
+    async function load() {
+        const base = await (async function () {
+            for (const ext of CONFIG_EXTENSIONS) {
+                const file = path.join(root, "sst" + ext);
+                try {
+                    await fs.access(file);
+                }
+                catch {
+                    continue;
+                }
+                if (file.endsWith("js")) {
+                    const fn = await dynamicImport(file);
+                    return await fn.default(globals);
+                }
+                if (file.endsWith(".json")) {
+                    const data = await fs.readFile(file);
+                    return Object.assign(DEFAULTS, JSON.parse(data.toString("utf8")));
+                }
+            }
+            throw new VisibleError("Could not found a configuration file", "Make sure one of the following exists", "  - sst.config.cjs", "  - sst.config.mjs", "  - sst.config.js", "  - sst.json");
+        })();
+        return {
+            ...DEFAULTS,
+            ...base,
+            stage: base.stage ||
+                globals.stage ||
+                (await usePersonalStage(out)) ||
+                (await promptPersonalStage(out)),
+            profile: base.profile || globals.profile,
+            region: base.region || globals.region,
+        };
+    }
+    const project = await load();
+    project.ssmPrefix =
+        project.ssmPrefix || `/sst/${project.name}/${project.stage}/`;
+    project.paths = {
+        root,
+        out,
+        artifacts: path.join(out, "artifacts"),
+    };
+    try {
+        const packageJson = JSON.parse(await fs
+            .readFile(url.fileURLToPath(new URL("./package.json", import.meta.url)))
+            .then((x) => x.toString()));
+        project.version = packageJson.version;
+    }
+    catch {
+        project.version = "unknown";
+    }
+    ProjectContext.provide(project);
+    dotenv.config({
+        path: path.join(project.paths.root, `.env.${project.stage}`),
+    });
+    Logger.debug("Config loaded", project);
+}
+async function usePersonalStage(out) {
+    try {
+        const result = await fs.readFile(path.join(out, "stage"));
+        return result.toString("utf8").trim();
+    }
+    catch {
+        return;
+    }
+}
+async function promptPersonalStage(out) {
+    const readline = await import("readline");
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        const suggested = os.userInfo().username;
+        rl.question(`Please enter a name you’d like to use for your personal stage. Or hit enter to use ${blue(suggested)}: `, async (input) => {
+            rl.close();
+            const result = input || suggested;
+            await fs.writeFile(path.join(out, "stage"), result);
+            resolve(result);
+        });
+    });
+}
+async function findRoot() {
+    async function find(dir) {
+        if (dir === "/")
+            throw new VisibleError("Could not found a configuration file", "Make sure one of the following exists", ...CONFIG_EXTENSIONS.map((ext) => `  - sst${ext}`));
+        for (const ext of CONFIG_EXTENSIONS) {
+            const configPath = path.join(dir, `sst${ext}`);
+            if (fsSync.existsSync(configPath)) {
+                return dir;
+            }
+        }
+        return await find(path.join(dir, ".."));
+    }
+    const result = await find(process.cwd());
+    return result;
+}

package/{dist/bootstrap.d.ts → bootstrap.d.ts}

@@ -1,3 +1,4 @@
+export declare const LATEST_VERSION = "3";
 export declare const useBootstrap: () => Promise<{
     version: string | undefined;
     bucket: string | undefined;

package/bootstrap.js

@@ -0,0 +1,79 @@
+import { GetParametersCommand, SSMClient } from "@aws-sdk/client-ssm";
+import { Tags, Stack, RemovalPolicy, App } from "aws-cdk-lib";
+import { BlockPublicAccess, Bucket, BucketEncryption, } from "aws-cdk-lib/aws-s3";
+import { ParameterTier, StringParameter } from "aws-cdk-lib/aws-ssm";
+import { useProject } from "./app.js";
+import { createSpinner } from "./cli/spinner.js";
+import { Context } from "./context/context.js";
+import { useAWSClient } from "./credentials.js";
+import { VisibleError } from "./error.js";
+import { Logger } from "./logger.js";
+import { Stacks } from "./stacks/index.js";
+const SSM_NAME_VERSION = `/sst/bootstrap/version`;
+const SSM_NAME_STACK_NAME = `/sst/bootstrap/stack-name`;
+const SSM_NAME_BUCKET_NAME = `/sst/bootstrap/bucket-name`;
+export const LATEST_VERSION = "3";
+export const useBootstrap = Context.memo(async () => {
+    Logger.debug("Initializing bootstrap context");
+    const ret = await ssm();
+    if (!ret.version ||
+        !ret.bucket ||
+        !ret.stack ||
+        ret.version !== LATEST_VERSION) {
+        const project = useProject();
+        const spinner = createSpinner("Deploying bootstrap stack, this only needs to happen once").start();
+        const app = new App();
+        const stack = new Stack(app, "SSTBootstrap", {
+            env: {
+                region: project.region,
+            },
+        });
+        const tags = {};
+        for (const [key, value] of Object.entries(tags)) {
+            Tags.of(app).add(key, value);
+        }
+        const bucket = new Bucket(stack, project.region, {
+            encryption: BucketEncryption.S3_MANAGED,
+            removalPolicy: RemovalPolicy.DESTROY,
+            autoDeleteObjects: true,
+            blockPublicAccess: BlockPublicAccess.BLOCK_ALL,
+        });
+        new StringParameter(stack, SSM_NAME_VERSION, {
+            parameterName: SSM_NAME_VERSION,
+            stringValue: LATEST_VERSION,
+            tier: ParameterTier.STANDARD,
+        });
+        new StringParameter(stack, SSM_NAME_STACK_NAME, {
+            parameterName: SSM_NAME_STACK_NAME,
+            stringValue: stack.stackName,
+            tier: ParameterTier.STANDARD,
+        });
+        new StringParameter(stack, SSM_NAME_BUCKET_NAME, {
+            parameterName: SSM_NAME_BUCKET_NAME,
+            stringValue: bucket.bucketName,
+            tier: ParameterTier.STANDARD,
+        });
+        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)}`);
+        }
+        spinner.succeed();
+        return ssm();
+    }
+    Logger.debug("Loaded bootstrap info: ", JSON.stringify(ret));
+    return ret;
+});
+async function ssm() {
+    const ssm = useAWSClient(SSMClient);
+    const result = await ssm.send(new GetParametersCommand({
+        Names: [SSM_NAME_VERSION, SSM_NAME_STACK_NAME, SSM_NAME_BUCKET_NAME],
+    }));
+    return {
+        version: result.Parameters.find((p) => p.Name === SSM_NAME_VERSION)?.Value,
+        bucket: result.Parameters.find((p) => p.Name === SSM_NAME_BUCKET_NAME)
+            ?.Value,
+        stack: result.Parameters.find((p) => p.Name === SSM_NAME_STACK_NAME)
+            ?.Value,
+    };
+}

package/{dist/cdk → cdk}/cloudformation-deployments.d.ts

@@ -5,7 +5,7 @@ import { ISDK } from "aws-cdk/lib/api/aws-auth/sdk.js";
 import { SdkProvider } from "aws-cdk/lib/api/aws-auth/sdk-provider.js";
 import { DeployStackResult, DeploymentMethod } from "./deploy-stack.js";
 import { Template, ResourcesToImport, ResourceIdentifierSummaries } from "aws-cdk/lib/api/util/cloudformation.js";
-import { StackActivityProgress } from "aws-cdk/lib/api/util/cloudformation/stack-activity-monitor";
+import { StackActivityProgress } from "aws-cdk/lib/api/util/cloudformation/stack-activity-monitor.js";
 /**
  * SDK obtained by assuming the lookup role
  * for a given environment

package/{dist/cdk → cdk}/cloudformation-deployments.js

@@ -76,6 +76,7 @@ export async function prepareSdkWithLookupRoleFor(sdkProvider, stack) {
  * stack artifact.
  */
 export class CloudFormationDeployments {
+    sdkProvider;
     constructor(props) {
         this.sdkProvider = props.sdkProvider;
     }

package/{dist/cdk → cdk}/deploy-stack.js

@@ -1,6 +1,5 @@
 import * as cxapi from "@aws-cdk/cx-api";
-import chalk from "chalk";
-import * as fs from "fs-extra";
+import fs from "fs/promises";
 import * as uuid from "uuid";
 import { addMetadataAssetsToManifest } from "aws-cdk/lib/assets.js";
 import { debug, error, print } from "aws-cdk/lib/logging.js";
@@ -10,9 +9,9 @@ import { publishAssets } from "aws-cdk/lib/util/asset-publishing.js";
 import { contentHash } from "aws-cdk/lib/util/content-hash.js";
 import { CfnEvaluationException } from "aws-cdk/lib/api/evaluate-cloudformation-template.js";
 import { tryHotswapDeployment } from "aws-cdk/lib/api/hotswap-deployments.js";
-import { ICON } from "aws-cdk/lib/api/hotswap/common.js";
 import { changeSetHasNoChanges, CloudFormationStack, TemplateParameters, waitForChangeSet, waitForStackDeploy, waitForStackDelete, } from "aws-cdk/lib/api/util/cloudformation.js";
 import { StackActivityMonitor, } from "aws-cdk/lib/api/util/cloudformation/stack-activity-monitor.js";
+import { blue } from "colorette";
 const LARGE_TEMPLATE_SIZE_KB = 50;
 export async function deployStack(options) {
     const stackArtifact = options.stack;
@@ -48,7 +47,6 @@ export async function deployStack(options) {
         // if we can skip deployment and we are performing a hotswap, let the user know
         // that no hotswap deployment happened
         if (options.hotswap) {
-            print(`\n ${ICON} %s\n`, chalk.bold("hotswap deployment skipped - no changes were detected (use --force to override)"));
         }
         return {
             noOp: true,
@@ -89,6 +87,16 @@ export async function deployStack(options) {
  * This class shares state and functionality between the different full deployment modes
  */
 class FullCloudFormationDeployment {
+    options;
+    cloudFormationStack;
+    stackArtifact;
+    stackParams;
+    bodyParameter;
+    cfn;
+    stackName;
+    update;
+    verb;
+    uuid;
     constructor(options, cloudFormationStack, stackArtifact, stackParams, bodyParameter) {
         this.options = options;
         this.cloudFormationStack = cloudFormationStack;
@@ -153,7 +161,6 @@ class FullCloudFormationDeployment {
     async createChangeSet(changeSetName, willExecute) {
         await this.cleanupOldChangeset(changeSetName);
         debug(`Attempting to create ChangeSet with name ${changeSetName} to ${this.verb} stack ${this.stackName}`);
-        print("%s: creating CloudFormation changeset...", chalk.bold(this.stackName));
         const changeSet = await this.cfn
             .createChangeSet({
             StackName: this.stackName,
@@ -344,7 +351,7 @@ async function makeBodyParameter(stack, resolvedEnvironment, assetManifest, tool
     if (!toolkitInfo.found) {
         error(`The template for stack "${stack.displayName}" is ${Math.round(templateJson.length / 1024)}KiB. ` +
             `Templates larger than ${LARGE_TEMPLATE_SIZE_KB}KiB must be uploaded to S3.\n` +
-            "Run the following command in order to setup an S3 bucket in this environment, and then re-deploy:\n\n", chalk.blue(`\t$ cdk bootstrap ${resolvedEnvironment.name}\n`));
+            "Run the following command in order to setup an S3 bucket in this environment, and then re-deploy:\n\n", blue(`\t$ cdk bootstrap ${resolvedEnvironment.name}\n`));
         throw new Error('Template too large to deploy ("cdk bootstrap" is required)');
     }
     const templateHash = contentHash(templateJson);

package/{dist/cli → cli}/commands/bind.d.ts

@@ -1,9 +1,11 @@
 /// <reference types="yargs" />
-import { Program } from "../program.js";
+import type { Program } from "../program.js";
 export declare const bind: (program: Program) => import("yargs").Argv<{
     stage: string | undefined;
 } & {
     profile: string | undefined;
+} & {
+    region: string | undefined;
 } & {
     command: string;
 }>;

package/{dist/cli → cli}/commands/bind.js

@@ -1,12 +1,14 @@
-import { Config } from "../../config.js";
-import { spawnSync } from "child_process";
-import { useAWSCredentials } from "../../credentials.js";
+import { useProject } from "../../app.js";
 export const bind = (program) => program.command("bind <command>", "Binds blah", (yargs) => yargs.positional("command", {
     type: "string",
     describe: "Command to bind to",
     demandOption: true,
 }), async (args) => {
+    const { Config } = await import("../../config.js");
+    const { spawnSync, spawn } = await import("child_process");
+    const { useAWSCredentials } = await import("../../credentials.js");
     const env = await Config.env();
+    const project = useProject();
     const credentials = await useAWSCredentials();
     const result = spawnSync(args.command, {
         env: {
@@ -14,9 +16,11 @@ export const bind = (program) => program.command("bind <command>", "Binds blah",
             AWS_ACCESS_KEY_ID: credentials.accessKeyId,
             AWS_SECRET_ACCESS_KEY: credentials.secretAccessKey,
             AWS_SESSION_TOKEN: credentials.sessionToken,
+            AWS_REGION: project.region,
+            PATH: process.env.PATH,
         },
         stdio: "inherit",
-        shell: true,
+        shell: process.env.SHELL || true,
     });
     process.exitCode = result.status || undefined;
 });

package/{dist/cli → cli}/commands/build.d.ts

@@ -4,6 +4,8 @@ export declare const build: (program: Program) => import("yargs").Argv<{
     stage: string | undefined;
 } & {
     profile: string | undefined;
+} & {
+    region: string | undefined;
 } & {
     from: string | undefined;
 }>;

package/cli/commands/build.js

@@ -0,0 +1,12 @@
+import { createSpinner } from "../spinner.js";
+export const build = (program) => program.command("build", "Build stacks code", yargs => yargs.option("from", { type: "string" }), async () => {
+    const { Stacks } = await import("../../stacks/index.js");
+    const spinner = createSpinner("Building stacks").start();
+    const fn = await Stacks.build();
+    await Stacks.synth({
+        fn,
+        mode: "deploy"
+    });
+    spinner.succeed();
+    process.exit(0);
+});

package/cli/commands/console.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="yargs" />
+import { Program } from "../program.js";
+export declare const consoleCommand: (program: Program) => Promise<import("yargs").Argv<{
+    stage: string | undefined;
+} & {
+    profile: string | undefined;
+} & {
+    region: string | undefined;
+}>>;

package/cli/commands/console.js

@@ -0,0 +1,15 @@
+import { blue } from "colorette";
+import { useRuntimeServer } from "../../runtime/server.js";
+import { useLocalServer } from "../local/server.js";
+export const consoleCommand = async (program) => program.command("console", "Start the sst console", (yargs) => yargs, async () => {
+    await Promise.all([
+        useRuntimeServer(),
+        useLocalServer({
+            key: "",
+            cert: "",
+            live: false,
+            port: 13557,
+        }),
+    ]);
+    console.log(`Console started: ${blue(`https://console.sst.dev`)}`);
+});

package/{dist/cli → cli}/commands/deploy.d.ts

@@ -1,9 +1,15 @@
 /// <reference types="yargs" />
-import { Program } from "../program.js";
+import type { Program } from "../program.js";
 export declare const deploy: (program: Program) => import("yargs").Argv<{
     stage: string | undefined;
 } & {
     profile: string | undefined;
+} & {
+    region: string | undefined;
 } & {
     from: string | undefined;
+} & {
+    fullscreen: boolean;
+} & {
+    filter: string | undefined;
 }>;

package/cli/commands/deploy.js

@@ -0,0 +1,48 @@
+import { printDeploymentResults } from "../ui/deploy.js";
+export const deploy = (program) => program.command("deploy [filter]", "Work on your SST app locally", (yargs) => yargs
+    .option("from", { type: "string" })
+    .option("fullscreen", {
+    type: "boolean",
+    describe: "Disable full screen UI",
+    default: true,
+})
+    .positional("filter", { type: "string" }), async (args) => {
+    const React = await import("react");
+    const { CloudAssembly } = await import("aws-cdk-lib/cx-api");
+    const { blue, bold } = await import("colorette");
+    const { useProject } = await import("../../app.js");
+    const { Stacks } = await import("../../stacks/index.js");
+    const { render } = await import("ink");
+    const { DeploymentUI } = await import("../ui/deploy.js");
+    const assembly = await (async function () {
+        if (args.from) {
+            const result = new CloudAssembly(args.from);
+            return result;
+        }
+        const fn = await Stacks.build();
+        return await Stacks.synth({
+            fn,
+            mode: "deploy",
+        });
+    })();
+    const project = useProject();
+    const target = assembly.stacks.filter((s) => !args.filter ||
+        s.stackName.toLowerCase().includes(args.filter.toLowerCase()));
+    if (!target.length) {
+        console.log(`No stacks found matching ${blue(args.filter)}`);
+        process.exit(1);
+        return;
+    }
+    console.log(`Deploying ${bold(target.length + " stacks")} for stage ${blue(project.stage)}...`);
+    let component = undefined;
+    if (args.fullscreen) {
+        process.stdout.write("\x1b[?1049h");
+        component = render(React.createElement(DeploymentUI, { stacks: assembly.stacks.map((s) => s.stackName) }));
+    }
+    const results = await Stacks.deployMany(target);
+    if (component)
+        component.unmount();
+    process.stdout.write("\x1b[?1049l");
+    printDeploymentResults(results);
+    process.exit(0);
+});

package/cli/commands/dev.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="yargs" />
+import type { Program } from "../program.js";
+export declare const dev: (program: Program) => import("yargs").Argv<{
+    stage: string | undefined;
+} & {
+    profile: string | undefined;
+} & {
+    region: string | undefined;
+} & {
+    fullscreen: boolean;
+}>;