sst 1.16.0 → 2.0.0-rc.0

package/src/cli/ui/deploy.tsx

@@ -1,139 +0,0 @@
-import React, { useState, useEffect, useLayoutEffect } from "react";
-import type { StackResource } from "@aws-sdk/client-cloudformation";
-import { Box, Text } from "ink";
-import { useBus } from "../../bus.js";
-import { Stacks } from "../../stacks/index.js";
-import inkSpinner from "ink-spinner";
-import { useProject } from "../../app.js";
-
-// @ts-ignore
-const { default: Spinner } = inkSpinner;
-
-const FullScreen: React.FC = (props) => {
-  const [size, setSize] = useState({
-    columns: process.stdout.columns,
-    rows: process.stdout.rows,
-  });
-
-  useEffect(() => {
-    function onResize() {
-      setSize({
-        columns: process.stdout.columns,
-        rows: process.stdout.rows,
-      });
-    }
-
-    process.stdout.on("resize", onResize);
-    return () => {
-      process.stdout.off("resize", onResize);
-    };
-  }, []);
-
-  return (
-    <Box width={size.columns} height={size.rows} flexDirection="column">
-      {props.children}
-    </Box>
-  );
-};
-
-interface Props {
-  stacks: string[];
-}
-export const DeploymentUI = (props: Props) => {
-  const [stacks, setStacks] = useState<Record<string, string>>(
-    Object.fromEntries(props.stacks.map((s) => [s, ""]))
-  );
-
-  const [resources, setResources] = useState<Record<string, StackResource[]>>(
-    {}
-  );
-
-  useEffect(() => {
-    const bus = useBus();
-
-    const update = bus.subscribe("stack.updated", (payload) => {
-      setStacks((prev) => ({
-        ...prev,
-        [payload.properties.stackID]: "",
-      }));
-    });
-
-    const status = bus.subscribe("stack.status", (payload) => {
-      setStacks((prev) => ({
-        ...prev,
-        [payload.properties.stackID]: payload.properties.status,
-      }));
-    });
-
-    const resourcesSub = bus.subscribe("stack.resources", (payload) => {
-      setResources((previous) => {
-        const existing = previous[payload.properties.stackID] || [];
-        const filtered = (payload.properties.resources || []).filter((r) => {
-          if (existing.some((p) => p.LogicalResourceId === r.LogicalResourceId))
-            return true;
-          if (!Stacks.isFinal(r.ResourceStatus as any)) return true;
-          return false;
-        });
-        return {
-          ...previous,
-          [payload.properties.stackID]: filtered,
-        };
-      });
-    });
-
-    return () => {
-      bus.unsubscribe(resourcesSub);
-      bus.unsubscribe(update);
-      bus.unsubscribe(status);
-    };
-  }, []);
-
-  function color(status: string) {
-    if (Stacks.isFailed(status)) return "red";
-    if (Stacks.isSuccess(status)) return "green";
-    return "yellow";
-  }
-
-  return (
-    <FullScreen>
-      <Text>
-        Deploying <Text color="bold">{props.stacks.length}</Text> stacks for
-        stage <Text color="blue">{useProject().stage}</Text>
-      </Text>
-      {Object.entries(stacks).map(([stackID, status]) => {
-        return (
-          <React.Fragment key={stackID}>
-            <Text>
-              {!Stacks.isFinal(status) && <Spinner />}
-              {Stacks.isSuccess(status) && <Text color={color(status)}>✔</Text>}
-              {Stacks.isFailed(status) && <Text color={color(status)}>✖</Text>}
-              <Text>{" " + stackID}</Text>
-              {status && <Text color={color(status)}> {status}</Text>}
-            </Text>
-            {resources[stackID]?.map((resource) => (
-              <Box key={resource.LogicalResourceId}>
-                <Text>
-                  {"  "}
-                  {!Stacks.isFinal(resource.ResourceStatus || "") && (
-                    <Spinner />
-                  )}
-                  {Stacks.isSuccess(resource.ResourceStatus || "") && (
-                    <Text color="green">✔</Text>
-                  )}
-                  {Stacks.isFailed(resource.ResourceStatus || "") && (
-                    <Text color="red">✖</Text>
-                  )}{" "}
-                  {resource.ResourceType} {resource.LogicalResourceId}{" "}
-                  {resource.ResourceStatusReason}
-                </Text>
-                <Text color={color(resource.ResourceStatus || "")}>
-                  {resource.ResourceStatus}
-                </Text>
-              </Box>
-            ))}
-          </React.Fragment>
-        );
-      })}
-    </FullScreen>
-  );
-};

package/src/config.ts

@@ -1,226 +0,0 @@
-import {
-  DeleteParameterCommand,
-  GetParameterCommand,
-  GetParametersByPathCommand,
-  PutParameterCommand,
-  SSMClient,
-} from "@aws-sdk/client-ssm";
-import {
-  GetFunctionConfigurationCommand,
-  LambdaClient,
-  UpdateFunctionConfigurationCommand,
-} from "@aws-sdk/client-lambda";
-import { pipe, map } from "remeda";
-import { useProject } from "./app.js";
-import { useAWSClient } from "./credentials.js";
-import { useFunctions } from "./stacks/metadata.js";
-
-interface Secret {
-  value?: string;
-  fallback?: string;
-}
-
-export namespace Config {
-  export async function parameters() {
-    const result: (ReturnType<typeof parse> & { value: string })[] = [];
-
-    for await (const p of scan(PREFIX.STAGE)) {
-      const parsed = parse(p.Name!);
-      if (parsed.type === "secrets") continue;
-      result.push({
-        ...parsed,
-        value: p.Value!,
-      });
-    }
-
-    return result;
-  }
-
-  export function envFor(input: {
-    type: string;
-    id: string;
-    prop: string;
-    fallback?: boolean;
-  }) {
-    return `SST_${input.type}_${input.prop}_${input.id}`;
-  }
-
-  export function pathFor(input: {
-    type: string;
-    id: string;
-    prop: string;
-    fallback?: boolean;
-  }) {
-    return `${input.fallback ? PREFIX.FALLBACK : PREFIX.STAGE}${
-      input.type
-    }/${normalizeID(input.id)}/${input.prop}`;
-  }
-
-  export function normalizeID(input: string) {
-    return input.replace(/-/g, "_");
-  }
-
-  export async function secrets() {
-    const result: Record<string, Secret> = {};
-
-    for await (const p of scan(PREFIX.STAGE + "Secret")) {
-      const parsed = parse(p.Name!);
-      if (!result[parsed.id]) result[parsed.id] = {};
-      result[parsed.id].value = p.Value;
-    }
-
-    for await (const p of scan(PREFIX.FALLBACK + "Secret")) {
-      const parsed = parse(p.Name!);
-      if (!result[parsed.id]) result[parsed.id] = {};
-      result[parsed.id].fallback = p.Value;
-    }
-
-    return result;
-  }
-
-  export async function env() {
-    const project = useProject();
-
-    const parameters = await Config.parameters();
-
-    const env = {
-      SST_APP: project.name,
-      SST_STAGE: project.stage,
-      ...pipe(
-        parameters,
-        map((p) => [`SST_${p.type}_${p.prop}_${p.id}`, p.value]),
-        Object.fromEntries
-      ),
-    };
-
-    return env as typeof env & Record<string, string | undefined>;
-  }
-
-  export async function setSecret(input: {
-    key: string;
-    value: string;
-    fallback?: boolean;
-  }) {
-    const ssm = useAWSClient(SSMClient);
-    const result = await ssm.send(
-      new PutParameterCommand({
-        Name: pathFor({
-          id: input.key,
-          type: "Secret",
-          prop: "value",
-          fallback: true,
-        }),
-        Value: input.value,
-        Type: "SecureString",
-        Overwrite: true,
-      })
-    );
-  }
-
-  export async function getSecret(input: { key: string; fallback?: boolean }) {
-    const ssm = useAWSClient(SSMClient);
-    const result = await ssm.send(
-      new GetParameterCommand({
-        Name: pathFor({
-          id: input.key,
-          prop: "value",
-          type: "Secret",
-          fallback: input.fallback,
-        }),
-        WithDecryption: true,
-      })
-    );
-    return result.Parameter?.Value;
-  }
-
-  export async function removeSecret(input: {
-    key: string;
-    fallback?: boolean;
-  }) {
-    const ssm = useAWSClient(SSMClient);
-    await ssm.send(
-      new DeleteParameterCommand({
-        Name: pathFor({
-          id: input.key,
-          type: "Secret",
-          prop: "value",
-          fallback: input.fallback,
-        }),
-      })
-    );
-  }
-
-  export async function restart(key: string) {
-    const lambda = useAWSClient(LambdaClient);
-    const functions = await useFunctions();
-    const filtered = Object.values(functions).filter((f) =>
-      f.data.secrets.includes(key)
-    );
-
-    await Promise.all(
-      filtered.map(async (f) => {
-        const config = await lambda.send(
-          new GetFunctionConfigurationCommand({
-            FunctionName: f.data.arn,
-          })
-        );
-
-        await lambda.send(
-          new UpdateFunctionConfigurationCommand({
-            FunctionName: f.data.arn,
-            Environment: {
-              Variables: {
-                ...(config.Environment?.Variables || {}),
-                [SECRET_UPDATED_AT_ENV]: Date.now().toString(),
-              },
-            },
-          })
-        );
-      })
-    );
-    return filtered.length;
-  }
-}
-
-async function* scan(prefix: string) {
-  const ssm = useAWSClient(SSMClient);
-  let token: string | undefined;
-
-  while (true) {
-    const results = await ssm.send(
-      new GetParametersByPathCommand({
-        Path: prefix,
-        WithDecryption: true,
-        Recursive: true,
-        NextToken: token,
-      })
-    );
-    yield* results.Parameters || [];
-
-    if (!results.NextToken) break;
-    token = results.NextToken;
-  }
-}
-
-const FALLBACK_STAGE = ".fallback";
-const SECRET_UPDATED_AT_ENV = "SST_ADMIN_SECRET_UPDATED_AT";
-
-const PREFIX = {
-  get STAGE() {
-    const project = useProject();
-    return `/sst/${project.name}/${project.stage}/`;
-  },
-  get FALLBACK() {
-    const project = useProject();
-    return `/sst/${project.name}/${FALLBACK_STAGE}/`;
-  },
-};
-
-function parse(ssmName: string) {
-  const parts = ssmName.split("/");
-  return {
-    type: parts[4],
-    id: parts[5],
-    prop: parts.slice(6),
-  };
-}