sst 3.0.0 → 3.0.1-10

package/stacks/deploy.js

@@ -1,240 +0,0 @@
-import { useBus } from "../bus.js";
-import { useProject } from "../project.js";
-import { useAWSClient, useAWSProvider } from "../credentials.js";
-import { Logger } from "../logger.js";
-import { filterOutputs, isFailed, monitor, } from "./monitor.js";
-import { VisibleError } from "../error.js";
-export async function publishAssets(stacks) {
-    Logger.debug("Publishing assets");
-    const provider = await useAWSProvider();
-    const { publishDeployAssets } = await import("../cdk/deployments-wrapper.js");
-    const results = {};
-    for (const stack of stacks) {
-        const result = await publishDeployAssets(provider, {
-            stack: stack,
-            quiet: false,
-            deploymentMethod: {
-                method: "direct",
-            },
-        });
-        results[stack.stackName] = result;
-    }
-    return results;
-}
-export async function deployMany(stacks) {
-    if (stacks.length === 0) {
-        throw new VisibleError("No stacks to deploy");
-    }
-    Logger.debug("Deploying stacks", stacks.map((s) => s.stackName));
-    const { CloudFormationStackArtifact } = await import("aws-cdk-lib/cx-api");
-    await useAWSProvider();
-    const bus = useBus();
-    const complete = new Set();
-    const todo = new Set(stacks.map((s) => s.id));
-    const results = {};
-    return new Promise((resolve) => {
-        async function trigger() {
-            for (const stack of stacks) {
-                if (!todo.has(stack.id))
-                    continue;
-                Logger.debug("Checking if", stack.id, "is ready to deploy");
-                if (stack.dependencies.some((dep) => dep instanceof CloudFormationStackArtifact &&
-                    !complete.has(dep.id) &&
-                    stacks.some((s) => s.id === dep.id)))
-                    continue;
-                deploy(stack).then((result) => {
-                    results[stack.id] = result;
-                    complete.add(stack.id);
-                    if (isFailed(result.status))
-                        stacks.forEach((s) => {
-                            if (todo.delete(s.stackName)) {
-                                complete.add(s.stackName);
-                                results[s.id] = {
-                                    status: "DEPENDENCY_FAILED",
-                                    outputs: {},
-                                    errors: {},
-                                };
-                                bus.publish("stack.status", {
-                                    stackID: s.id,
-                                    status: "DEPENDENCY_FAILED",
-                                });
-                            }
-                        });
-                    if (complete.size === stacks.length) {
-                        resolve(results);
-                    }
-                    trigger();
-                });
-                todo.delete(stack.id);
-            }
-        }
-        trigger();
-    });
-}
-export async function deploy(stack) {
-    const bus = useBus();
-    const { cdk } = useProject().config;
-    Logger.debug("Deploying stack", stack.id);
-    const provider = await useAWSProvider();
-    const { Deployments } = await import("../cdk/deployments.js");
-    const deployment = new Deployments({ sdkProvider: provider });
-    const stackTags = Object.entries(stack.tags ?? {}).map(([Key, Value]) => ({
-        Key,
-        Value,
-    }));
-    try {
-        await addInUseExports(stack);
-        bus.publish("stack.status", {
-            stackID: stack.stackName,
-            status: "PUBLISH_ASSETS_IN_PROGRESS",
-        });
-        const result = await deployment.deployStack({
-            stack: stack,
-            quiet: true,
-            tags: stackTags,
-            deploymentMethod: {
-                method: "direct",
-            },
-            toolkitStackName: cdk?.toolkitStackName,
-        });
-        if (result?.noOp) {
-            bus.publish("stack.status", {
-                stackID: stack.stackName,
-                status: "SKIPPED",
-            });
-            return {
-                errors: {},
-                outputs: filterOutputs(result.outputs),
-                status: "SKIPPED",
-            };
-        }
-        bus.publish("stack.updated", {
-            stackID: stack.stackName,
-        });
-        return monitor(stack.stackName);
-    }
-    catch (ex) {
-        Logger.debug("Failed to deploy stack", stack.id, ex);
-        if (ex.message === "No updates are to be performed.") {
-            return monitor(stack.stackName);
-        }
-        bus.publish("stack.status", {
-            stackID: stack.stackName,
-            status: "UPDATE_FAILED",
-        });
-        return {
-            errors: {
-                stack: ex.message,
-            },
-            outputs: {},
-            status: "UPDATE_FAILED",
-        };
-    }
-}
-async function addInUseExports(stack) {
-    // Get old outputs
-    const oldOutputs = await getCloudFormationStackOutputs(stack);
-    if (!oldOutputs)
-        return;
-    // Get new exports
-    // note: that we only want to handle outputs exported by CDK.
-    // ie.
-    // "Outputs": {
-    //   "ExportsOutputRefauthUserPoolA78B038B8D9965B5": {
-    //     "Value": {
-    //       "Ref": "authUserPoolA78B038B"
-    //     },
-    //     "Export": {
-    //       "Name": "frank-acme-auth:ExportsOutputRefauthUserPoolA78B038B8D9965B5"
-    //     }
-    //   },
-    const newTemplate = JSON.parse(await getLocalTemplate(stack));
-    const newOutputs = newTemplate.Outputs || {};
-    const newExportNames = Object.keys(newOutputs)
-        .filter((outputKey) => outputKey.startsWith("ExportsOutput"))
-        .filter((outputKey) => newOutputs[outputKey].Export)
-        .map((outputKey) => newOutputs[outputKey].Export.Name);
-    // Add missing exports
-    // ie.
-    // Outputs [{
-    //   OutputKey: (String)
-    //   OutputValue: (String)
-    //   Description: (String)
-    //   ExportName: (String)
-    // }]
-    let isDirty = false;
-    await Promise.all(oldOutputs
-        .filter((output) => output.OutputKey?.startsWith("ExportsOutput"))
-        .filter((output) => output.ExportName)
-        // filter exports not in the new template (ie. CloudFormation will be removing)
-        .filter((output) => !newExportNames.includes(output.ExportName))
-        // filter the exports still in-use by other stacks
-        .map(async (output) => {
-        const imports = await listImports(output.ExportName);
-        // update template
-        if (imports.length > 0) {
-            Logger.debug(`deploy stack: addInUseExports: export ${output.ExportName} used in ${imports.join(", ")}`);
-            newTemplate.Outputs = newTemplate.Outputs || {};
-            newTemplate.Outputs[output.OutputKey] = {
-                Description: `Output added by SST b/c exported value still used in ${imports.join(", ")}`,
-                Value: output.OutputValue,
-                Export: {
-                    Name: output.ExportName,
-                },
-            };
-            isDirty = true;
-        }
-    }));
-    // Save new template
-    if (isDirty) {
-        await saveLocalTemplate(stack, JSON.stringify(newTemplate, null, 2));
-    }
-}
-async function getCloudFormationStackOutputs(stack) {
-    const { CloudFormationClient, DescribeStacksCommand } = await import("@aws-sdk/client-cloudformation");
-    const client = useAWSClient(CloudFormationClient);
-    try {
-        const { Stacks: stacks } = await client.send(new DescribeStacksCommand({
-            StackName: stack.id,
-        }));
-        if (!stacks || stacks.length === 0)
-            return;
-        return stacks[0].Outputs || [];
-    }
-    catch (e) {
-        if (e.name === "ValidationError" &&
-            e.message.includes("Stack with id") &&
-            e.message.includes("does not exist")) {
-            return;
-        }
-        else {
-            throw e;
-        }
-    }
-}
-async function listImports(exportName) {
-    const { CloudFormationClient, ListImportsCommand } = await import("@aws-sdk/client-cloudformation");
-    const client = useAWSClient(CloudFormationClient);
-    try {
-        const ret = await client.send(new ListImportsCommand({
-            ExportName: exportName,
-        }));
-        return ret.Imports || [];
-    }
-    catch (e) {
-        if (e.name === "ValidationError" &&
-            e.message.includes("is not imported by any stack")) {
-            return [];
-        }
-        throw e;
-    }
-}
-async function getLocalTemplate(stack) {
-    const fs = await import("fs/promises");
-    const fileContent = await fs.readFile(stack.templateFullPath);
-    return fileContent.toString();
-}
-async function saveLocalTemplate(stack, content) {
-    const fs = await import("fs/promises");
-    await fs.writeFile(stack.templateFullPath, content);
-}

package/stacks/diff.d.ts

@@ -1,8 +0,0 @@
-import type { CloudFormationStackArtifact } from "aws-cdk-lib/cx-api";
-export declare function diff(stack: CloudFormationStackArtifact, oldTemplate: any): Promise<{
-    count: number;
-    diff?: undefined;
-} | {
-    count: number;
-    diff: string;
-}>;

package/stacks/diff.js

@@ -1,62 +0,0 @@
-export async function diff(stack, oldTemplate) {
-    const { diffTemplate, formatDifferences, TemplateDiff } = await import("@aws-cdk/cloudformation-diff");
-    // Generate diff
-    const diff = diffTemplate(oldTemplate, stack.template);
-    if (diff.isEmpty) {
-        return { count: 0 };
-    }
-    // Only display resource and output changes
-    // @ts-ignore
-    diff.iamChanges = { hasChanges: false };
-    // @ts-ignore
-    diff.securityGroupChanges = { hasChanges: false };
-    // @ts-ignore
-    diff.awsTemplateFormatVersion = false;
-    // @ts-ignore
-    diff.transform = false;
-    // @ts-ignore
-    diff.description = false;
-    // @ts-ignore
-    diff.parameters = { differenceCount: 0 };
-    // @ts-ignore
-    diff.metadata = { differenceCount: 0 };
-    // @ts-ignore
-    diff.mappings = { differenceCount: 0 };
-    // @ts-ignore
-    diff.conditions = { differenceCount: 0 };
-    // @ts-ignore
-    diff.unknown = { differenceCount: 0 };
-    // Filter out SST internal diffs
-    // @ts-ignore
-    delete diff.outputs.diffs?.["SSTMetadata"];
-    // Format diff
-    const output = [];
-    const stream = {
-        write(chunk) {
-            output.push(`   ${chunk}`);
-        },
-    };
-    const pathMap = await buildLogicalToPathMap(stack);
-    formatDifferences(stream, diff, pathMap);
-    // Remove trailing newline
-    while (true) {
-        if (output[output.length - 1]?.match(/^\s*$/)) {
-            output.pop();
-        }
-        else {
-            break;
-        }
-    }
-    return {
-        count: diff.outputs.differenceCount + diff.resources.differenceCount,
-        diff: output.join(""),
-    };
-}
-async function buildLogicalToPathMap(stack) {
-    const { ArtifactMetadataEntryType } = await import("@aws-cdk/cloud-assembly-schema");
-    const map = {};
-    for (const md of stack.findMetadataByType(ArtifactMetadataEntryType.LOGICAL_ID)) {
-        map[md.data] = md.path;
-    }
-    return map;
-}

package/stacks/index.d.ts

@@ -1,10 +0,0 @@
-export * from "./app-metadata.js";
-export * from "./assembly.js";
-export * from "./build.js";
-export * from "./deploy.js";
-export * from "./diff.js";
-export * from "./metadata.js";
-export * from "./synth.js";
-export * from "./monitor.js";
-export * from "./remove.js";
-export * as Stacks from "./index.js";

package/stacks/index.js

@@ -1,10 +0,0 @@
-export * from "./app-metadata.js";
-export * from "./assembly.js";
-export * from "./build.js";
-export * from "./deploy.js";
-export * from "./diff.js";
-export * from "./metadata.js";
-export * from "./synth.js";
-export * from "./monitor.js";
-export * from "./remove.js";
-export * as Stacks from "./index.js";

package/stacks/metadata.d.ts

@@ -1,11 +0,0 @@
-import type { Metadata } from "../constructs/Metadata.js";
-declare module "../bus.js" {
-    interface Events {
-        "stacks.metadata": Awaited<ReturnType<typeof metadata>>;
-        "stacks.metadata.updated": {};
-        "stacks.metadata.deleted": {};
-    }
-}
-export declare function metadataForStack(stack: String): Promise<Metadata[] | undefined>;
-export declare function metadata(): Promise<Record<string, Metadata[]>>;
-export declare const useMetadataCache: () => Promise<Record<string, Metadata[]>>;

package/stacks/metadata.js

@@ -1,83 +0,0 @@
-import { useBootstrap } from "../bootstrap.js";
-import { useAWSCredentials, } from "../credentials.js";
-import { S3Client, GetObjectCommand, ListObjectsV2Command, } from "@aws-sdk/client-s3";
-import { useCache } from "../cache.js";
-import { useBus } from "../bus.js";
-import { Logger } from "../logger.js";
-import { useProject } from "../project.js";
-import { lazy } from "../util/lazy.js";
-export async function metadataForStack(stack) {
-    const project = useProject();
-    const [credentials, bootstrap] = await Promise.all([
-        useAWSCredentials(),
-        useBootstrap(),
-    ]);
-    const s3 = new S3Client({
-        region: project.config.region,
-        credentials: credentials,
-    });
-    try {
-        const result = await s3.send(new GetObjectCommand({
-            Key: `stackMetadata/app.${project.config.name}/stage.${project.config.stage}/stack.${stack}.json`,
-            Bucket: bootstrap.bucket,
-        }));
-        const body = await result.Body.transformToString();
-        return JSON.parse(body);
-    }
-    catch (e) {
-        Logger.debug(`Fetching metadata for stack ${stack} failed`, e);
-        return;
-    }
-}
-export async function metadata() {
-    Logger.debug("Fetching all metadata");
-    const project = useProject();
-    const [credentials, bootstrap] = await Promise.all([
-        useAWSCredentials(),
-        useBootstrap(),
-    ]);
-    const s3 = new S3Client({
-        region: project.config.region,
-        credentials: credentials,
-    });
-    const key = `stackMetadata/app.${project.config.name}/stage.${project.config.stage}/`;
-    const list = await s3.send(new ListObjectsV2Command({
-        Prefix: key,
-        Bucket: bootstrap.bucket,
-    }));
-    const result = Object.fromEntries(await Promise.all(list.Contents?.map(async (obj) => {
-        const stackID = obj.Key?.split("/").pop();
-        const result = await s3.send(new GetObjectCommand({
-            Key: obj.Key,
-            Bucket: bootstrap.bucket,
-        }));
-        const body = await result.Body.transformToString();
-        return [stackID, JSON.parse(body)];
-    }) || []));
-    Logger.debug("Fetched metadata from", list.KeyCount, "stacks");
-    return result;
-}
-export const useMetadataCache = lazy(async () => {
-    const bus = useBus();
-    const cache = await useCache();
-    bus.subscribe("stacks.metadata.updated", async () => {
-        const data = await metadata();
-        await cache.write(`metadata.json`, JSON.stringify(data));
-        bus.publish("stacks.metadata", data);
-    });
-    bus.subscribe("stacks.metadata.deleted", async () => {
-        const data = await metadata();
-        await cache.write(`metadata.json`, JSON.stringify(data));
-        bus.publish("stacks.metadata", data);
-    });
-    while (true) {
-        try {
-            const data = await metadata();
-            bus.publish("stacks.metadata", data);
-            return data;
-        }
-        catch {
-            await new Promise((resolve) => setTimeout(resolve, 1000));
-        }
-    }
-});

package/stacks/monitor.d.ts

@@ -1,32 +0,0 @@
-import { DescribeStackResourcesOutput, StackEvent } from "@aws-sdk/client-cloudformation";
-declare module "../bus.js" {
-    interface Events {
-        "stack.updated": {
-            stackID: string;
-        };
-        "stack.status": {
-            stackID: string;
-            status: (typeof STATUSES)[number];
-        };
-        "stack.resources": {
-            stackID: string;
-            resources: DescribeStackResourcesOutput["StackResources"];
-        };
-        "stack.event": {
-            stackID: string;
-            event: StackEvent;
-        };
-    }
-}
-export declare const STATUSES: readonly ["CREATE_IN_PROGRESS", "DELETE_IN_PROGRESS", "REVIEW_IN_PROGRESS", "ROLLBACK_IN_PROGRESS", "UPDATE_COMPLETE_CLEANUP_IN_PROGRESS", "UPDATE_IN_PROGRESS", "UPDATE_ROLLBACK_COMPLETE_CLEANUP_IN_PROGRESS", "UPDATE_ROLLBACK_IN_PROGRESS", "PUBLISH_ASSETS_IN_PROGRESS", "CREATE_COMPLETE", "UPDATE_COMPLETE", "DELETE_COMPLETE", "SKIPPED", "CREATE_FAILED", "DELETE_FAILED", "ROLLBACK_FAILED", "ROLLBACK_COMPLETE", "UPDATE_FAILED", "UPDATE_ROLLBACK_COMPLETE", "UPDATE_ROLLBACK_FAILED", "DEPENDENCY_FAILED"];
-export declare function isFinal(input: string): boolean;
-export declare function isFailed(input: string): boolean;
-export declare function isSuccess(input: string): boolean;
-export declare function isPending(input: string): boolean;
-export declare function monitor(stack: string): Promise<{
-    status: string;
-    outputs: Record<string, string>;
-    errors: Record<string, string>;
-}>;
-export declare function filterOutputs(input: Record<string, string>): Record<string, string>;
-export type StackDeploymentResult = Awaited<ReturnType<typeof monitor>>;

package/stacks/monitor.js

@@ -1,151 +0,0 @@
-import { CloudFormationClient, DescribeStackResourcesCommand, DescribeStacksCommand, DescribeStackEventsCommand, } from "@aws-sdk/client-cloudformation";
-import { useBus } from "../bus.js";
-import { useAWSClient } from "../credentials.js";
-import { Logger } from "../logger.js";
-const STATUSES_PENDING = [
-    "CREATE_IN_PROGRESS",
-    "DELETE_IN_PROGRESS",
-    "REVIEW_IN_PROGRESS",
-    "ROLLBACK_IN_PROGRESS",
-    "UPDATE_COMPLETE_CLEANUP_IN_PROGRESS",
-    "UPDATE_IN_PROGRESS",
-    "UPDATE_ROLLBACK_COMPLETE_CLEANUP_IN_PROGRESS",
-    "UPDATE_ROLLBACK_IN_PROGRESS",
-    "PUBLISH_ASSETS_IN_PROGRESS",
-];
-const STATUSES_SUCCESS = [
-    "CREATE_COMPLETE",
-    "UPDATE_COMPLETE",
-    "DELETE_COMPLETE",
-    "SKIPPED",
-];
-const STATUSES_FAILED = [
-    "CREATE_FAILED",
-    "DELETE_FAILED",
-    "ROLLBACK_FAILED",
-    "ROLLBACK_COMPLETE",
-    "UPDATE_FAILED",
-    "UPDATE_ROLLBACK_COMPLETE",
-    "UPDATE_ROLLBACK_FAILED",
-    "DEPENDENCY_FAILED",
-];
-export const STATUSES = [
-    ...STATUSES_PENDING,
-    ...STATUSES_SUCCESS,
-    ...STATUSES_FAILED,
-];
-export function isFinal(input) {
-    return (STATUSES_SUCCESS.includes(input) ||
-        STATUSES_FAILED.includes(input));
-}
-export function isFailed(input) {
-    return STATUSES_FAILED.includes(input);
-}
-export function isSuccess(input) {
-    return STATUSES_SUCCESS.includes(input);
-}
-export function isPending(input) {
-    return STATUSES_PENDING.includes(input);
-}
-export async function monitor(stack) {
-    const [cfn, bus] = await Promise.all([
-        useAWSClient(CloudFormationClient),
-        useBus(),
-    ]);
-    let lastStatus;
-    const errors = {};
-    let lastEvent;
-    while (true) {
-        try {
-            const [describe, resources, events] = await Promise.all([
-                cfn.send(new DescribeStacksCommand({
-                    StackName: stack,
-                })),
-                cfn.send(new DescribeStackResourcesCommand({
-                    StackName: stack,
-                })),
-                cfn.send(new DescribeStackEventsCommand({
-                    StackName: stack,
-                })),
-            ]);
-            Logger.debug("Stack description", describe);
-            if (lastEvent) {
-                const eventsReversed = [...(events.StackEvents ?? [])].reverse();
-                for (const event of eventsReversed) {
-                    if (!event.Timestamp)
-                        continue;
-                    if (event.Timestamp.getTime() > lastEvent.getTime()) {
-                        bus.publish("stack.event", {
-                            event: event,
-                            stackID: stack,
-                        });
-                        if (event.ResourceStatusReason) {
-                            if (event.ResourceStatusReason.includes("Resource creation cancelled") ||
-                                event.ResourceStatusReason.includes("Resource update cancelled") ||
-                                event.ResourceStatusReason.includes("Resource creation Initiated") ||
-                                // ie. The following resource(s) failed to update: [MyResource10A5921D].
-                                event.ResourceStatusReason.startsWith("The following resource(s) failed to"))
-                                continue;
-                            errors[event.LogicalResourceId] = event.ResourceStatusReason;
-                        }
-                    }
-                }
-                Logger.debug("Last event set to", lastEvent);
-            }
-            lastEvent = events.StackEvents?.at(0)?.Timestamp;
-            bus.publish("stack.resources", {
-                stackID: stack,
-                resources: resources.StackResources,
-            });
-            for (const resource of resources.StackResources || []) {
-                if (resource.ResourceStatusReason?.includes("Resource creation cancelled") ||
-                    resource.ResourceStatusReason?.includes("Resource update cancelled") ||
-                    resource.ResourceStatusReason?.includes("Resource creation Initiated") ||
-                    // ie. The following resource(s) failed to update: [MyResource10A5921D].
-                    resource.ResourceStatusReason?.startsWith("The following resource(s) failed to"))
-                    continue;
-                if (resource.ResourceStatusReason)
-                    errors[resource.LogicalResourceId] = resource.ResourceStatusReason;
-            }
-            const [first] = describe.Stacks || [];
-            if (first) {
-                if (lastStatus !== first.StackStatus && first.StackStatus) {
-                    lastStatus = first.StackStatus;
-                    bus.publish("stack.status", {
-                        stackID: stack,
-                        status: first.StackStatus,
-                    });
-                    Logger.debug(first);
-                    if (isFinal(first.StackStatus)) {
-                        return {
-                            status: first.StackStatus,
-                            outputs: pipe(first.Outputs || [], map((o) => [o.OutputKey, o.OutputValue]), Object.fromEntries, filterOutputs),
-                            errors: isFailed(first.StackStatus) ? errors : {},
-                        };
-                    }
-                }
-            }
-        }
-        catch (ex) {
-            if (ex.message.includes("does not exist")) {
-                bus.publish("stack.status", {
-                    stackID: stack,
-                    status: "DELETE_COMPLETE",
-                });
-                return {
-                    status: "DELETE_COMPLETE",
-                    outputs: {},
-                    errors: {},
-                };
-            }
-            throw ex;
-        }
-        await new Promise((resolve) => setTimeout(resolve, 1000));
-    }
-}
-import { map, omitBy, pipe } from "remeda";
-export function filterOutputs(input) {
-    return pipe(input, omitBy((_, key) => {
-        return key.startsWith("Export") || key === "SSTMetadata";
-    }));
-}

package/stacks/remove.d.ts

@@ -1,8 +0,0 @@
-import type { CloudFormationStackArtifact } from "aws-cdk-lib/cx-api";
-import { StackDeploymentResult } from "./monitor.js";
-export declare function removeMany(stacks: CloudFormationStackArtifact[]): Promise<Record<string, {
-    status: string;
-    outputs: Record<string, string>;
-    errors: Record<string, string>;
-}>>;
-export declare function remove(stack: CloudFormationStackArtifact): Promise<StackDeploymentResult>;