cdktn-cli 0.0.1 → 0.22.0-pre.2

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>
+  );
+};

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

@@ -0,0 +1,134 @@
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+
+import React, { Fragment } from "react";
+
+import { Text, Box, useApp, Newline } from "ink";
+import Spinner from "ink-spinner";
+import { GetOptions } from "@cdktn/provider-generator";
+import {
+  IsErrorType,
+  Language,
+  sendTelemetry,
+  TerraformDependencyConstraint,
+} from "@cdktn/commons";
+import { get, GetStatus as Status } from "@cdktn/cli-core";
+
+interface GetConfig {
+  codeMakerOutput: string;
+  language: Language;
+  constraints: TerraformDependencyConstraint[];
+  parallelism: number;
+  force?: boolean;
+  silent?: boolean;
+  providerSchemaCachePath?: string;
+}
+
+export const Get = ({
+  codeMakerOutput,
+  language,
+  constraints,
+  parallelism,
+  force,
+  silent = false,
+  providerSchemaCachePath,
+}: GetConfig): React.ReactElement => {
+  const [currentStatus, setCurrentStatus] = React.useState<Status>(
+    Status.STARTING,
+  );
+  const { exit } = useApp();
+
+  const constructsOptions: GetOptions = {
+    codeMakerOutput: codeMakerOutput,
+    targetLanguage: language,
+    jsiiParallelism: parallelism,
+  };
+
+  React.useEffect(() => {
+    const runGet = async () => {
+      try {
+        await get({
+          constraints,
+          constructsOptions,
+          cleanDirectory: force,
+          onUpdate: setCurrentStatus,
+          providerSchemaCachePath,
+          reportTelemetry: async (payload) =>
+            await sendTelemetry("get", {
+              language: payload.targetLanguage,
+              ...payload.trackingPayload,
+            }),
+        });
+      } catch (e: any) {
+        // No stack trace for usage errors, as they explain themselves
+        if (!IsErrorType(e, "Usage")) {
+          console.error(e);
+        }
+
+        exit(new Error(e));
+      }
+    };
+    runGet();
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []); // only once, we don't expect props to change
+
+  React.useEffect(() => {
+    if (currentStatus === Status.DONE) {
+      exit();
+    }
+    if (currentStatus === Status.ERROR) {
+      exit(
+        new Error(
+          `ERROR: synthesis failed, app expected to create "${codeMakerOutput}"`,
+        ),
+      );
+    }
+  }, [currentStatus]);
+
+  const isGenerating: boolean = currentStatus != Status.DONE;
+  const statusText = `${currentStatus}...`;
+  const jsonTerraformOutput = (
+    <Text>
+      Generated <Text color="green">{language}</Text> constructs in the output
+      directory: <Text bold>{codeMakerOutput}</Text>
+      {language === Language.GO && (
+        <>
+          <Newline />
+          <Newline />
+          <Text>
+            The generated code depends on{" "}
+            <Text color="cyan">jsii-runtime-go</Text>. If you haven&apos;t yet
+            installed it, you can run{" "}
+            <Text color="blueBright">go mod tidy</Text> to automatically install
+            it.
+          </Text>
+        </>
+      )}
+    </Text>
+  );
+
+  if (silent) {
+    return <Text></Text>;
+  }
+
+  return (
+    <Box>
+      {isGenerating ? (
+        <Fragment>
+          <Text color="green">
+            <Spinner type="dots" />
+          </Text>
+          <Box paddingLeft={1}>
+            <Text>{statusText}</Text>
+          </Box>
+        </Fragment>
+      ) : (
+        <Fragment>
+          <Box>{jsonTerraformOutput}</Box>
+        </Fragment>
+      )}
+    </Box>
+  );
+};

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

@@ -0,0 +1,59 @@
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+
+import React, { Fragment } from "react";
+import { Text, Box } from "ink";
+import { useCdktfProject } from "./hooks/cdktf-project";
+import { StreamView, StatusBottomBar } from "./components";
+
+interface ListConfig {
+  outDir: string;
+  synthCommand: string;
+}
+
+export const List = ({
+  outDir,
+  synthCommand,
+}: ListConfig): React.ReactElement => {
+  const { status, logEntries, returnValue } = useCdktfProject(
+    { outDir, synthCommand },
+    (project) => project.synth(),
+  );
+
+  return (
+    <StreamView logs={logEntries}>
+      <StatusBottomBar status={status}>
+        {status.type === "done" ? (
+          <Box>
+            <Fragment>
+              <Box flexDirection="column">
+                <Box>
+                  <Box width="40%">
+                    <Text bold>Stack name</Text>
+                  </Box>
+                  <Box width="60%">
+                    <Text bold>Path</Text>
+                  </Box>
+                </Box>
+                {returnValue!.map((stack) => (
+                  <Box key={stack.name}>
+                    <Box width="40%" paddingRight={1}>
+                      <Text>{stack.name}</Text>
+                    </Box>
+                    <Box width="60%">
+                      <Text>{stack.workingDirectory}</Text>
+                    </Box>
+                  </Box>
+                ))}
+              </Box>
+            </Fragment>
+          </Box>
+        ) : (
+          <></>
+        )}
+      </StatusBottomBar>
+    </StreamView>
+  );
+};

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

@@ -0,0 +1,52 @@
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+
+/* eslint-disable no-control-regex */
+import React from "react";
+import { NestedTerraformOutputs } from "@cdktn/cli-core";
+import { useCdktfProject } from "./hooks/cdktf-project";
+import { StreamView, OutputsBottomBar, StatusBottomBar } from "./components";
+
+type OutputConfig = {
+  outDir: string;
+  targetStacks?: string[];
+  synthCommand: string;
+  onOutputsRetrieved: (outputs: NestedTerraformOutputs) => void;
+  outputsPath?: string;
+  skipSynth?: boolean;
+  skipProviderLock?: boolean;
+};
+
+export const Output = ({
+  outDir,
+  targetStacks,
+  synthCommand,
+  onOutputsRetrieved,
+  outputsPath,
+  skipSynth,
+  skipProviderLock,
+}: OutputConfig): React.ReactElement => {
+  const { status, logEntries, returnValue } = useCdktfProject(
+    { outDir, synthCommand },
+    async (project) => {
+      const outputs = await project.fetchOutputs({
+        stackNames: targetStacks,
+        skipSynth,
+        skipProviderLock,
+      });
+      onOutputsRetrieved(outputs);
+      return outputs;
+    },
+  );
+
+  const bottomBar =
+    status.type === "done" ? (
+      <OutputsBottomBar outputs={returnValue} outputsFile={outputsPath} />
+    ) : (
+      <StatusBottomBar status={status} />
+    );
+
+  return <StreamView logs={logEntries}>{bottomBar}</StreamView>;
+};

package/src/bin/cmds/ui/provider-list.tsx

@@ -0,0 +1,17 @@
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+
+import React from "react";
+import Table from "ink-table";
+
+interface ProviderListProps {
+  data: any[];
+}
+
+export const ProviderListTable = ({
+  data,
+}: ProviderListProps): React.ReactElement => {
+  return <Table data={data} />;
+};

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

@@ -0,0 +1,51 @@
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+
+import React from "react";
+import { Text } from "ink";
+
+import { useCdktfProject } from "./hooks/cdktf-project";
+import { StreamView } from "./components";
+import { SynthesizedStack } from "@cdktn/cli-core";
+import { StatusBottomBar } from "./components/bottom-bars/status";
+
+interface CommonSynthConfig {
+  outDir: string;
+}
+
+interface SynthConfig extends CommonSynthConfig {
+  synthCommand: string;
+  hcl: boolean;
+}
+type SynthOutputConfig = {
+  stacks: SynthesizedStack[];
+};
+const SynthOutput = ({ stacks }: SynthOutputConfig): React.ReactElement => {
+  return (
+    <Text>
+      Generated Terraform code for the stacks:{" "}
+      {stacks?.map((s) => s.name).join(", ")}
+    </Text>
+  );
+};
+
+export const Synth = ({
+  outDir,
+  synthCommand,
+  hcl,
+}: SynthConfig): React.ReactElement => {
+  const { returnValue, logEntries, status } = useCdktfProject(
+    { outDir, synthCommand, hcl },
+    (project) => project.synth(),
+  );
+
+  return (
+    <StreamView logs={logEntries}>
+      <StatusBottomBar status={status}>
+        <SynthOutput stacks={status.type === "done" ? returnValue! : []} />
+      </StatusBottomBar>
+    </StreamView>
+  );
+};

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

@@ -0,0 +1,80 @@
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+
+import React, { useEffect, useState } from "react";
+import { watch, WatchState } from "@cdktn/cli-core";
+import { StreamView, WatchStatusBottomBar } from "./components";
+import { LogEntry } from "./hooks/cdktf-project";
+
+interface WatchConfig {
+  targetDir: string;
+  targetStacks?: string[];
+  parallelism?: number;
+  synthCommand: string;
+  autoApprove: boolean;
+  terraformParallelism?: number;
+}
+
+export const Watch = ({
+  targetDir,
+  targetStacks,
+  synthCommand,
+  autoApprove,
+  parallelism,
+  terraformParallelism,
+}: WatchConfig): React.ReactElement => {
+  const [logEntryId, setLogEntryId] = useState<number>(0);
+  const [logEntries, setLogEntries] = useState<LogEntry[]>([]);
+  const [currentState, setCurrentState] = useState<WatchState>({
+    type: "waiting",
+  });
+
+  useEffect(() => {
+    const ac = new AbortController();
+    const onAbort = () => {
+      ac.abort();
+    };
+    process.on("SIGINT", onAbort);
+    process.on("SIGTERM", onAbort);
+    process.on("SIGQUIT", onAbort);
+
+    watch(
+      {
+        synthCommand,
+        outDir: targetDir,
+        onUpdate: () => {}, // eslint-disable-line @typescript-eslint/no-empty-function
+        onLog: ({ stackName, message, messageWithConstructPath }) => {
+          setLogEntries((prev) => [
+            ...prev,
+            {
+              id: `${stackName}-${logEntryId}`,
+              stackName: stackName,
+              content: messageWithConstructPath
+                ? messageWithConstructPath
+                : message,
+            },
+          ]);
+          setLogEntryId((current) => current + 1);
+        },
+      },
+      {
+        autoApprove,
+        stackNames: targetStacks,
+        parallelism,
+        terraformParallelism,
+      },
+      ac.signal as any,
+      (state) => {
+        setCurrentState(state);
+      },
+    );
+  }, []);
+
+  return (
+    <StreamView logs={logEntries}>
+      <WatchStatusBottomBar currentState={currentState} />
+    </StreamView>
+  );
+};

package/index.js

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-console.log("cdktn-cli placeholder");