cdktn-cli 0.0.1 → 0.21.0

package/src/bin/cmds/ui/components/bottom-bars/override.tsx

@@ -0,0 +1,68 @@
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+
+import React from "react";
+import SelectInput from "ink-select-input";
+import { Box, Text } from "ink";
+
+type Props = {
+  stackName: string;
+  onOverride: () => void;
+  onReject: () => void;
+};
+
+type Option = { label: string; description: string };
+type TransformedOption = Option & { value: string };
+const options: Record<string, Option> = {
+  override: {
+    label: "Override",
+    description: `Overrides the soft failed policy check`,
+  },
+  reject: {
+    label: "Reject",
+    description: `Does not override the failed policy check, and stops the operation`,
+  },
+};
+export function OverrideBottomBar({ stackName, onOverride, onReject }: Props) {
+  const selectOptions: TransformedOption[] = Object.keys(options).map(
+    (key) => ({
+      ...options[key],
+      value: key,
+    }),
+  );
+  const [highlighted, setHighlighted] = React.useState(selectOptions[0].value);
+  const handleHighlight = (item: { value: string }) => {
+    setHighlighted(item.value);
+  };
+  const handleSelect = (item: { value: string }) => {
+    switch (item.value) {
+      case "override":
+        onOverride();
+        break;
+      case "reject":
+        onReject();
+        break;
+    }
+  };
+
+  return (
+    <Box flexDirection="column">
+      <Box>
+        <Text>Please review the above failures for </Text>
+        <Text bold>{stackName}</Text>
+      </Box>
+      <Box>
+        <SelectInput
+          items={selectOptions}
+          onSelect={handleSelect}
+          onHighlight={handleHighlight}
+        />
+        <Box paddingLeft={2}>
+          <Text>{options[highlighted].description}</Text>
+        </Box>
+      </Box>
+    </Box>
+  );
+}

package/src/bin/cmds/ui/components/bottom-bars/status.tsx

@@ -0,0 +1,183 @@
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+
+import React from "react";
+import { Text, Box } from "ink";
+import Spinner from "ink-spinner";
+import { Status } from "../../hooks/cdktf-project";
+import { WatchState, CdktfStack } from "@cdktn/cli-core";
+
+type Props = {
+  status: Status;
+  errorMessage?: string;
+  children?: any;
+  actionName: "deploying" | "destroying";
+};
+
+export function StatusBottomBar({
+  status,
+  children,
+}: Omit<Props, "actionName">) {
+  switch (status.type) {
+    case "done": {
+      if (children) {
+        return children;
+      }
+      return <></>;
+    }
+
+    // This is handled on the outside of this component
+    case "waiting for approval of stack":
+      return <></>;
+
+    case "starting":
+      return (
+        <Box>
+          <Box marginRight={2}>
+            <Text>
+              <Spinner type="dots" />
+            </Text>
+          </Box>
+          <Box>
+            <Text bold>Starting</Text>
+          </Box>
+        </Box>
+      );
+
+    case "synthesizing":
+      return (
+        <Box>
+          <Box marginRight={2}>
+            <Text>
+              <Spinner type="dots" />
+            </Text>
+          </Box>
+          <Box>
+            <Text bold>Synthesizing</Text>
+          </Box>
+        </Box>
+      );
+
+    case "running":
+      return (
+        <Box>
+          <Box marginRight={2}>
+            <Text>
+              <Spinner type="dots" />
+            </Text>
+          </Box>
+          <Box>
+            <Text bold>Processing</Text>
+          </Box>
+        </Box>
+      );
+  }
+}
+
+export function localizeStacks(num: number) {
+  if (num === 1) {
+    return "1 Stack";
+  }
+  return `${num} Stacks`;
+}
+
+function Execution({
+  inProgress,
+  finished,
+  pending,
+  actionName,
+}: Pick<Props, "actionName"> & {
+  inProgress: CdktfStack[];
+  finished: CdktfStack[];
+  pending: CdktfStack[];
+}) {
+  return (
+    <Box marginTop={1}>
+      <Box marginRight={5}>
+        <Text>
+          {localizeStacks(inProgress.length)} {actionName}
+        </Text>
+      </Box>
+      <Box marginRight={5}>
+        <Text>{localizeStacks(finished.length)} done</Text>
+      </Box>
+      <Box>
+        <Text>{localizeStacks(pending.length)} waiting</Text>
+      </Box>
+    </Box>
+  );
+}
+
+export function ExecutionStatusBottomBar({
+  status,
+  children,
+  actionName,
+}: Props) {
+  if (status?.type !== "running") {
+    return <StatusBottomBar status={status}>{children}</StatusBottomBar>;
+  }
+
+  return (
+    <Execution
+      inProgress={status.inProgress}
+      finished={status.finished}
+      pending={status.pending}
+      actionName={actionName}
+    />
+  );
+}
+
+export function WatchStatusBottomBar({
+  currentState,
+}: {
+  currentState: WatchState;
+}): React.ReactElement {
+  switch (currentState.type) {
+    case "waiting": {
+      return (
+        <Box marginTop={1}>
+          <Spinner />
+          <Box marginLeft={1}>
+            <Text>Waiting for changes...</Text>
+          </Box>
+        </Box>
+      );
+    }
+    case "stopped": {
+      return (
+        <Box marginTop={1}>
+          <Text>Watch was stopped</Text>
+        </Box>
+      );
+    }
+
+    case "running": {
+      if (
+        currentState.inProgress.length +
+          currentState.finished.length +
+          currentState.pending.length ===
+        0
+      ) {
+        return (
+          <Box marginTop={1}>
+            <Spinner />
+            <Box marginLeft={1}>
+              <Text>Synthesizing...</Text>
+            </Box>
+          </Box>
+        );
+      }
+
+      return (
+        <Execution
+          inProgress={currentState.inProgress}
+          finished={currentState.finished}
+          pending={currentState.pending}
+          actionName="deploying"
+        />
+      );
+    }
+  }
+}

package/src/bin/cmds/ui/components/outputs.tsx

@@ -0,0 +1,103 @@
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+
+import React from "react";
+import { Text, Box } from "ink";
+import {
+  NestedTerraformOutputs,
+  TerraformOutput,
+  isTerraformOutput,
+} from "@cdktn/cli-core";
+
+export interface OutputsConfig {
+  outputs: NestedTerraformOutputs;
+}
+function sanitize(value: any) {
+  if (typeof value === "object") {
+    return JSON.stringify(value, null, 2);
+  }
+
+  return value;
+}
+
+function Output({ name, value }: { name: string; value: TerraformOutput }) {
+  return (
+    <Box key={name}>
+      <Text>
+        {name} = {value.sensitive ? "<sensitive>" : sanitize(value.value)}
+      </Text>
+    </Box>
+  );
+}
+
+// Puts the top-level outputs before the nested outputs
+const compareOutputs =
+  (value: NestedTerraformOutputs) =>
+  ([k1]: [string, any], [k2]: [string, any]): number => {
+    if (isTerraformOutput(value[k1]) && isTerraformOutput(value[k2])) {
+      return k1.localeCompare(k2);
+    }
+
+    if (isTerraformOutput(value[k1])) {
+      return -1;
+    }
+
+    if (isTerraformOutput(value[k2])) {
+      return 1;
+    }
+    return k1.localeCompare(k2);
+  };
+
+function NestedOutput({
+  name,
+  value,
+  indentationLevel = 0,
+}: {
+  name: string;
+  value: NestedTerraformOutputs;
+  indentationLevel?: number;
+}) {
+  // This is a safe-guard against infinite recursion
+  if (indentationLevel > 500) {
+    return <></>;
+  }
+  if (isTerraformOutput(value)) {
+    return (
+      <Box key={name}>
+        <Output name={name} value={value} />
+      </Box>
+    );
+  }
+
+  return (
+    <Box flexDirection="column" key={name} marginLeft={2} marginBottom={1}>
+      <Text bold>{name}</Text>
+      <Box marginLeft={indentationLevel * 2} flexDirection="column">
+        {Object.entries(value)
+          .sort(compareOutputs(value))
+          .map(([k, v]) => (
+            <NestedOutput
+              indentationLevel={indentationLevel + 1}
+              key={k}
+              name={k}
+              value={v}
+            />
+          ))}
+      </Box>
+    </Box>
+  );
+}
+
+export const Outputs = ({ outputs }: OutputsConfig): React.ReactElement => {
+  return (
+    <Box flexDirection="column">
+      {Object.entries(outputs).map(([key, value]) => (
+        <Box key={key}>
+          <NestedOutput name={key} value={value} />
+        </Box>
+      ))}
+    </Box>
+  );
+};

package/src/bin/cmds/ui/components/stream-view.tsx

@@ -0,0 +1,72 @@
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+
+import React from "react";
+import { Box, Static, Text } from "ink";
+import { LogEntry } from "../hooks/cdktf-project";
+
+const possibleColors = [
+  "yellow",
+  "blue",
+  "cyan",
+  "green",
+  "white",
+  "yellowBright",
+  "blueBright",
+  "cyanBright",
+  "greenBright",
+  "whiteBright",
+];
+
+let colorPointer = 0;
+
+const colorAssignments: Record<string, string> = {};
+
+function getColor(stackName: string): string {
+  if (colorAssignments[stackName]) {
+    return colorAssignments[stackName];
+  }
+
+  const color = possibleColors[colorPointer];
+  colorPointer = (colorPointer + 1) % possibleColors.length;
+  colorAssignments[stackName] = color;
+  return color;
+}
+
+export function StreamPrefix({ stackName }: { stackName: string }) {
+  return (
+    <Text bold color={getColor(stackName)}>
+      {stackName}
+    </Text>
+  );
+}
+
+export function StreamView({
+  logs,
+  children,
+}: {
+  logs: LogEntry[];
+  children: any;
+}) {
+  return (
+    <Box>
+      <Box>
+        <Static items={logs}>
+          {({ content, id, stackName }) => (
+            <Box key={id}>
+              <Box marginRight={2}>
+                <StreamPrefix stackName={stackName} />
+              </Box>
+              <Box>
+                <Text>{content.trim()}</Text>
+              </Box>
+            </Box>
+          )}
+        </Static>
+      </Box>
+      <Box marginTop={1}>{children}</Box>
+    </Box>
+  );
+}

package/src/bin/cmds/ui/deploy.tsx

@@ -0,0 +1,139 @@
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+
+/* eslint-disable no-control-regex */
+import React, { useState } from "react";
+import { Text, Box } from "ink";
+import { DeployingResource, NestedTerraformOutputs } from "@cdktn/cli-core";
+import { useCdktfProject } from "./hooks/cdktf-project";
+import {
+  StreamView,
+  OutputsBottomBar,
+  ApproveBottomBar,
+  OverrideBottomBar,
+  ExecutionStatusBottomBar,
+} from "./components";
+interface DeploySummaryConfig {
+  resources: DeployingResource[];
+}
+
+export const DeploySummary = ({
+  resources,
+}: DeploySummaryConfig): React.ReactElement => {
+  const summary = resources.reduce(
+    (accumulator, resource) => {
+      if (accumulator[resource.applyState] !== undefined) {
+        accumulator[resource.applyState] += 1;
+      }
+
+      return accumulator;
+    },
+    {
+      created: 0,
+      updated: 0,
+      destroyed: 0,
+    } as any,
+  );
+
+  return (
+    <>
+      {Object.keys(summary).map((key, i) => (
+        <Box key={key}>
+          {i > 0 && <Text>, </Text>}
+          <Text>
+            {summary[key]} {key}
+          </Text>
+        </Box>
+      ))}
+    </>
+  );
+};
+
+interface DeployConfig {
+  outDir: string;
+  targetStacks?: string[];
+  synthCommand: string;
+  autoApprove: boolean;
+  onOutputsRetrieved: (outputs: NestedTerraformOutputs) => void;
+  outputsPath?: string;
+  ignoreMissingStackDependencies?: boolean;
+  parallelism?: number;
+  refreshOnly?: boolean;
+  terraformParallelism?: number;
+  vars?: string[];
+  varFiles?: string[];
+  noColor?: boolean;
+  migrateState?: boolean;
+  skipSynth?: boolean;
+  skipProviderLock?: boolean;
+}
+
+export const Deploy = ({
+  outDir,
+  targetStacks,
+  synthCommand,
+  autoApprove,
+  onOutputsRetrieved,
+  outputsPath,
+  ignoreMissingStackDependencies,
+  parallelism,
+  refreshOnly,
+  terraformParallelism,
+  vars,
+  varFiles,
+  noColor,
+  migrateState,
+  skipSynth,
+  skipProviderLock,
+}: DeployConfig): React.ReactElement => {
+  const [outputs, setOutputs] = useState<NestedTerraformOutputs>();
+  const { status, logEntries } = useCdktfProject(
+    { outDir, synthCommand },
+    async (project) => {
+      await project.deploy({
+        stackNames: targetStacks,
+        autoApprove,
+        ignoreMissingStackDependencies,
+        parallelism,
+        refreshOnly,
+        terraformParallelism,
+        vars,
+        varFiles,
+        noColor,
+        migrateState,
+        skipSynth,
+        skipProviderLock,
+      });
+
+      if (onOutputsRetrieved) {
+        onOutputsRetrieved(project.outputsByConstructId);
+      }
+      setOutputs(project.outputsByConstructId);
+    },
+  );
+
+  const bottomBar =
+    status.type === "done" ? (
+      <OutputsBottomBar outputs={outputs} outputsFile={outputsPath} />
+    ) : status?.type === "waiting for approval of stack" ? (
+      <ApproveBottomBar
+        stackName={status.stackName}
+        onApprove={status.approve}
+        onDismiss={status.dismiss}
+        onStop={status.stop}
+      />
+    ) : status?.type ===
+      "waiting for override of sentinel policy check failure" ? (
+      <OverrideBottomBar
+        stackName={status.stackName}
+        onOverride={status.override}
+        onReject={status.reject}
+      />
+    ) : (
+      <ExecutionStatusBottomBar status={status} actionName="deploying" />
+    );
+
+  return <StreamView logs={logEntries}>{bottomBar}</StreamView>;
+};

package/src/bin/cmds/ui/destroy.tsx

@@ -0,0 +1,86 @@
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+
+/* eslint-disable no-control-regex */
+import React from "react";
+
+import { useCdktfProject } from "./hooks/cdktf-project";
+import {
+  StreamView,
+  ExecutionStatusBottomBar,
+  ApproveBottomBar,
+  OverrideBottomBar,
+} from "./components";
+
+interface DestroyConfig {
+  outDir: string;
+  targetStacks?: string[];
+  synthCommand: string;
+  autoApprove: boolean;
+  ignoreMissingStackDependencies?: boolean;
+  parallelism?: number;
+  terraformParallelism?: number;
+  noColor?: boolean;
+  migrateState?: boolean;
+  vars?: string[];
+  varFiles?: string[];
+  skipSynth?: boolean;
+  skipProviderLock?: boolean;
+}
+
+export const Destroy = ({
+  outDir,
+  targetStacks,
+  synthCommand,
+  autoApprove,
+  ignoreMissingStackDependencies,
+  parallelism,
+  terraformParallelism,
+  noColor,
+  migrateState,
+  vars,
+  varFiles,
+  skipSynth,
+  skipProviderLock,
+}: DestroyConfig): React.ReactElement => {
+  const { status, logEntries } = useCdktfProject(
+    { outDir, synthCommand },
+    (project) =>
+      project.destroy({
+        stackNames: targetStacks,
+        autoApprove,
+        ignoreMissingStackDependencies,
+        parallelism,
+        terraformParallelism,
+        noColor,
+        migrateState,
+        vars,
+        varFiles,
+        skipSynth,
+        skipProviderLock,
+      }),
+  );
+
+  const bottomBar =
+    status?.type === "waiting for approval of stack" ? (
+      <ApproveBottomBar
+        stackName={status.stackName}
+        onApprove={status.approve}
+        onDismiss={status.dismiss}
+        onStop={status.stop}
+      />
+    ) : status?.type ===
+      "waiting for override of sentinel policy check failure" ? (
+      <OverrideBottomBar
+        stackName={status.stackName}
+        onOverride={status.override}
+        onReject={status.reject}
+      />
+    ) : (
+      <ExecutionStatusBottomBar status={status} actionName="destroying" />
+    );
+
+  return <StreamView logs={logEntries}>{bottomBar}</StreamView>;
+};

package/src/bin/cmds/ui/diff.tsx

@@ -0,0 +1,59 @@
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+
+import React from "react";
+
+import { useCdktfProject } from "./hooks/cdktf-project";
+import { StreamView, StatusBottomBar } from "./components";
+
+interface DiffConfig {
+  outDir: string;
+  targetStack?: string;
+  synthCommand: string;
+  refreshOnly?: boolean;
+  terraformParallelism?: number;
+  vars?: string[];
+  varFiles?: string[];
+  noColor?: boolean;
+  migrateState?: boolean;
+  skipSynth?: boolean;
+  skipProviderLock?: boolean;
+}
+
+export const Diff = ({
+  outDir,
+  targetStack,
+  synthCommand,
+  refreshOnly,
+  terraformParallelism,
+  vars,
+  varFiles,
+  noColor,
+  migrateState,
+  skipSynth,
+  skipProviderLock,
+}: DiffConfig): React.ReactElement => {
+  const { status, logEntries } = useCdktfProject(
+    { outDir, synthCommand },
+    (project) =>
+      project.diff({
+        stackName: targetStack,
+        refreshOnly,
+        terraformParallelism,
+        vars,
+        varFiles,
+        noColor,
+        migrateState,
+        skipSynth,
+        skipProviderLock,
+      }),
+  );
+
+  return (
+    <StreamView logs={logEntries}>
+      <StatusBottomBar status={status} />
+    </StreamView>
+  );
+};