@catladder/cli 0.0.0-node16-ddfae617 → 0.0.0-perf-cli-reduce-bundle-size-with-tsconfig-optimization-3556aaa4

package/src/apps/cli/commands/general/index.ts

@@ -1,13 +1,12 @@
 import memoizee from "memoizee";
-import Vorpal from "vorpal";
+import type Vorpal from "vorpal";
 import { getk8sApi } from "../../../../k8sApi";
 import { getCurrentContext } from "../../../../utils/cluster";
 import { logError } from "../../../../utils/log";
-import { syncBitwarden } from "../../../../utils/passwordstore";
 import {
   getAllRunningPortForwards,
   stopPortForward,
-} from "../../../../utils/portForward";
+} from "../../../../utils/portForwards";
 import { getShell } from "../../../../utils/shell";
 import { namespaceAutoCompletion } from "./namespaceAutoCompletion";
 import portForward from "./portForward";
@@ -18,7 +17,7 @@ const getAllNamespaces = memoizee(
     const res = await k8sApi.listNamespace();
     return res.body.items;
   },
-  { maxAge: 30000, promise: true }
+  { maxAge: 30000, promise: true },
 );
 
 export const getAllNamespacesNames = async () => {
@@ -26,19 +25,19 @@ export const getAllNamespacesNames = async () => {
   return namespaces.map((n) => n.metadata.name);
 };
 export default async (vorpal: Vorpal) => {
-  vorpal.command("current-context").action(async function () {
+  vorpal.command("kube-current-context").action(async function () {
     this.log(await getCurrentContext());
   });
 
   vorpal
-    .command("list-namespaces", "list all namespaces")
+    .command("kube-list-namespaces", "list all namespaces")
     .action(async function () {
       const namespaces = await getAllNamespacesNames();
       this.log(namespaces.join("\n"));
     });
 
   vorpal
-    .command("list-secrets <namespace>", "show secrets")
+    .command("kube-list-secrets <namespace>", "show secrets")
     .autocomplete(namespaceAutoCompletion)
     .action(async function ({ namespace }) {
       const k8sApi = getk8sApi();
@@ -47,13 +46,8 @@ export default async (vorpal: Vorpal) => {
       this.log(res.body.items.map((n) => n.metadata.name).join("\n"));
     });
 
-  vorpal.command("bw-sync", "force sync bitwarden").action(async function () {
-    await syncBitwarden(true);
-    this.log("done");
-  });
-
   vorpal
-    .command("list-pods <namespace>", "list all pods of namespace")
+    .command("kube-list-pods <namespace>", "list all pods of namespace")
     .autocomplete(namespaceAutoCompletion)
     .action(async function ({ namespace }) {
       const k8sApi = getk8sApi();
@@ -62,14 +56,17 @@ export default async (vorpal: Vorpal) => {
     });
 
   vorpal
-    .command("stop-portforward <name>", "stop a running port forward")
+    .command("kube-stop-portforward <name>", "stop a running port forward")
     .autocomplete({ data: async () => getAllRunningPortForwards() })
     .action(async function ({ name }) {
       stopPortForward(name.trim());
     });
 
   vorpal
-    .command("get-shell <namespace>", "get a shell to a pod in the environment")
+    .command(
+      "kube-get-shell <namespace>",
+      "get a shell to a pod in the environment",
+    )
     .autocomplete(namespaceAutoCompletion)
     .action(async function ({ namespace }) {
       const k8sApi = getk8sApi();

package/src/apps/cli/commands/general/namespaceAutoCompletion.ts

@@ -3,5 +3,5 @@ export const namespaceAutoCompletion = {
   async data() {
     const namespaces = await getAllNamespacesNames();
     return namespaces;
-  }
+  },
 };

package/src/apps/cli/commands/general/portForward.ts

@@ -1,14 +1,14 @@
-import Vorpal from "vorpal";
+import type Vorpal from "vorpal";
 import { logError } from "../../../../utils/log";
 
-import { startPortForward } from "../../../../utils/portForward";
+import { startKubePortForward } from "../../../../kubernetes/portForward";
 
 import { getk8sApi } from "../../../../k8sApi";
 import { namespaceAutoCompletion } from "./namespaceAutoCompletion";
 
 export default async (vorpal: Vorpal) =>
   vorpal
-    .command("port-forward <namespace>", "start port-forwarding")
+    .command("kube-port-forward <namespace>", "start port-forwarding")
     .autocomplete(namespaceAutoCompletion)
     .action(async function ({ namespace }) {
       const k8sApi = getk8sApi();
@@ -44,5 +44,5 @@ export default async (vorpal: Vorpal) =>
         message: "Remote port: ",
       });
 
-      return startPortForward(podName, localPort, remotePort, namespace);
+      return startKubePortForward(podName, localPort, remotePort, namespace);
     });

package/src/apps/cli/commands/mongodb/index.ts

@@ -1,4 +1,4 @@
-import Vorpal from "vorpal";
+import type Vorpal from "vorpal";
 import projectMongoDestroyMember from "./projectMongoDestroyMember";
 import projectMongoGetShell from "./projectMongoGetShell";
 import projectMongoPortForward from "./projectMongoPortForward";

package/src/apps/cli/commands/mongodb/projectMongoDestroyMember.ts

@@ -1,10 +1,8 @@
 import { exec } from "child-process-promise";
-import Vorpal from "vorpal";
+import type Vorpal from "vorpal";
+import { getProjectPvcs } from "../../../../kubernetes";
 import { logError } from "../../../../utils/log";
-import {
-  getProjectNamespace,
-  getProjectPvcs,
-} from "../../../../utils/projects";
+import { getProjectNamespace } from "../../../../utils/projects";
 import { envAndComponents } from "../project/utils/autocompletions";
 import ensureCluster from "../project/utils/ensureCluster";
 import { getMongoDbPodsWithReplInfo } from "./utils";
@@ -12,22 +10,22 @@ import { getMongoDbPodsWithReplInfo } from "./utils";
 const removeFinalizer = async (
   namespace: string,
   type: "pod" | "pv" | "pvc",
-  name: string
+  name: string,
 ) =>
   exec(
-    `kubectl patch --namespace ${namespace} ${type} ${name} -p '{"metadata":{"finalizers":null}}'`
+    `kubectl patch --namespace ${namespace} ${type} ${name} -p '{"metadata":{"finalizers":null}}'`,
   );
 
 const deleteResource = async (
   namespace: string,
   type: "pod" | "pv" | "pvc",
-  name: string
+  name: string,
 ) => exec(`kubectl delete --namespace ${namespace} ${type} ${name}`);
 
 const removeFinalizerAndDelete = async (
   namespace: string,
   type: "pod" | "pv" | "pvc",
-  name: string
+  name: string,
 ) => {
   return Promise.all([
     removeFinalizer(namespace, type, name),
@@ -38,29 +36,29 @@ export default async (vorpal: Vorpal) =>
   vorpal
     .command(
       "project-mongo-destroy-member <envComponent>",
-      "DESTROY a member of a replicaset in order to reinitialize it"
+      "DESTROY a member of a replicaset in order to reinitialize it",
     )
     .autocomplete(await envAndComponents())
     .action(async function ({ envComponent }) {
       await ensureCluster.call(this, envComponent);
       this.log(
-        "this command tries to delete a (secondary) member of the replicaset, it's persistent volume claim (pvc) and the volume"
+        "this command tries to delete a (secondary) member of the replicaset, it's persistent volume claim (pvc) and the volume",
       );
       this.log("");
       this.log(
-        "this is useful, if you update the stateful set with new volume configuration (different size or storage class)"
+        "this is useful, if you update the stateful set with new volume configuration (different size or storage class)",
       );
       this.log("");
       this.log(
-        "Kubernetes will usually recreate the missing member with the updated config and mongodb will start synchronizing the new member."
+        "Kubernetes will usually recreate the missing member with the updated config and mongodb will start synchronizing the new member.",
       );
       this.log("");
       this.log(
-        "This works without downtime, but should be done when load on the db is low. Also it has not been tested with large dbs (> 10gi)"
+        "This works without downtime, but should be done when load on the db is low. Also it has not been tested with large dbs (> 10gi)",
       );
       this.log("");
       this.log(
-        "Deleting the volume and claim often stuck, just wait or cancel and restart."
+        "Deleting the volume and claim often stuck, just wait or cancel and restart.",
       );
       this.log("");
       const { understood } = await this.prompt({
@@ -98,7 +96,7 @@ export default async (vorpal: Vorpal) =>
       ).podName;
 
       const thePvc = pvcs.find(
-        (pvc) => pvc.metadata.name === `datadir-${podName}`
+        (pvc) => pvc.metadata.name === `datadir-${podName}`,
       );
       if (!thePvc) {
         logError(this, `sorry, no pvc found for ${podName}`);

package/src/apps/cli/commands/mongodb/projectMongoGetShell.ts

@@ -1,4 +1,4 @@
-import Vorpal from "vorpal";
+import type Vorpal from "vorpal";
 import { logError } from "../../../../utils/log";
 import { getProjectNamespace } from "../../../../utils/projects";
 import { envAndComponents } from "../project/utils/autocompletions";
@@ -12,15 +12,14 @@ export default async (vorpal: Vorpal) =>
   vorpal
     .command(
       "project-mongo-get-shell <envComponent>",
-      "get a shell to a mongodb in the environment"
+      "get a shell to a mongodb in the environment",
     )
     .autocomplete(await envAndComponents())
     .action(async function ({ envComponent }) {
       await ensureCluster.call(this, envComponent);
       const namespace = await getProjectNamespace(envComponent);
-      const podNames = await getProjectMongodbAllPodsSortedWithLabel(
-        envComponent
-      );
+      const podNames =
+        await getProjectMongodbAllPodsSortedWithLabel(envComponent);
       if (podNames.length === 0) {
         logError(this, "sorry, no pods found");
         return;

package/src/apps/cli/commands/mongodb/projectMongoPortForward.ts

@@ -1,24 +1,28 @@
-import Vorpal from "vorpal";
+import type Vorpal from "vorpal";
+import {
+  getEnvVarsResolved,
+  parseChoice,
+} from "../../../../config/getProjectConfig";
 import { logError } from "../../../../utils/log";
-import { startPortForward } from "../../../../utils/portForward";
+import { startKubePortForward } from "../../../../kubernetes/portForward";
 import { getProjectNamespace } from "../../../../utils/projects";
 import { envAndComponents } from "../project/utils/autocompletions";
 import ensureCluster from "../project/utils/ensureCluster";
 import { getProjectMongodbAllPodsSortedWithLabel } from "./utils";
+import clipboard from "clipboardy";
 
 export default async (vorpal: Vorpal) =>
   vorpal
     .command(
       "project-mongo-port-forward <envComponent>",
-      "port foward to a mongodb"
+      "port foward to a mongodb",
     )
     .autocomplete(await envAndComponents())
     .action(async function ({ envComponent }) {
       await ensureCluster.call(this, envComponent);
       const namespace = await getProjectNamespace(envComponent);
-      const podNames = await getProjectMongodbAllPodsSortedWithLabel(
-        envComponent
-      );
+      const podNames =
+        await getProjectMongodbAllPodsSortedWithLabel(envComponent);
       if (podNames.length === 0) {
         logError(this, "sorry, no pods found");
         return;
@@ -43,5 +47,18 @@ export default async (vorpal: Vorpal) =>
         default: "30000",
         message: "Local port: ",
       });
-      return startPortForward(podName, localPort, 27017, namespace);
+      const { env, componentName } = parseChoice(envComponent);
+      const envVars = await getEnvVarsResolved(this, env, componentName);
+      const MONGODB_ROOT_PASSWORD = envVars?.MONGODB_ROOT_PASSWORD;
+      const connectionUrl = `mongodb://root:${MONGODB_ROOT_PASSWORD}@localhost:${localPort}`;
+      clipboard.writeSync(connectionUrl);
+      this.log("");
+      this.log("username: root");
+      this.log(`password: ${MONGODB_ROOT_PASSWORD}`);
+      this.log(`connection string: ${connectionUrl}`);
+      this.log("");
+      this.log("👆 connection string has been copied to your clipboard!");
+      this.log("");
+
+      return startKubePortForward(podName, localPort, 27017, namespace);
     });

package/src/apps/cli/commands/mongodb/utils/index.ts

@@ -1,11 +1,14 @@
 import { exec, spawn } from "child-process-promise";
-import {
-  getProjectNamespace,
-  getProjectPodNames,
-} from "../../../../../utils/projects";
+import { getProjectPodNames } from "../../../../../kubernetes";
+import { getProjectNamespace } from "../../../../../utils/projects";
 
 const filterMongoDbs = (podNames: string[]) =>
-  podNames.filter((name) => name.includes("mongodb-replicaset"));
+  podNames.filter(
+    (name) =>
+      name.includes("mongodb") &&
+      !name.includes("mongodb-backup") &&
+      !name.includes("arbiter"),
+  );
 
 export const getProjectMongodbAllPods = async (envComponent: string) =>
   filterMongoDbs(await getProjectPodNames(envComponent));
@@ -29,7 +32,7 @@ export const getMongodbShell = async (namespace: string, podName: string) => {
 export const executeMongodbCommand = async (
   namespace: string,
   podName: string,
-  mongoCommand: string
+  mongoCommand: string,
 ) => {
   const fullCommand = `kubectl exec -it ${podName} --namespace ${namespace} -- mongo --quiet --eval "JSON.stringify(${mongoCommand})"`;
   const { stdout } = await exec(fullCommand, {
@@ -43,13 +46,18 @@ export const executeMongodbCommand = async (
 };
 
 export const podIsMaster = async (namespace: string, podName: string) => {
-  const result = await executeMongodbCommand(
-    namespace,
-    podName,
-    "db.isMaster()"
-  );
+  try {
+    const result = await executeMongodbCommand(
+      namespace,
+      podName,
+      "db.isMaster()",
+    );
 
-  return result.ismaster;
+    return result.ismaster;
+  } catch (e) {
+    // maybe shutting down ?
+    return null;
+  }
 };
 
 const spaces = (n: number) => " ".repeat(n);
@@ -58,28 +66,26 @@ export const getMongoDbPodsWithReplInfo = async (envComponent: string) => {
   const namespace = await getProjectNamespace(envComponent);
   return (
     await Promise.all(
-      (
-        await getProjectMongodbAllPods(envComponent)
-      ).map(async (podName) => ({
+      (await getProjectMongodbAllPods(envComponent)).map(async (podName) => ({
         podName,
         componentName: podName.replace(/-mongodb-replicaset-[0-9]+/, ""),
         isMaster: await podIsMaster(namespace, podName),
-      }))
+      })),
     )
   ).sort((podA, podB) => (podA.isMaster ? (podB.isMaster ? 0 : -1) : 1));
 };
 
 export const getProjectMongodbAllPodsSortedWithLabel = async (
-  envComponent: string
+  envComponent: string,
 ) => {
   const pods = await getMongoDbPodsWithReplInfo(envComponent);
   const maxComponentNameLength = Math.max(
-    ...pods.map((c) => c.componentName.length)
+    ...pods.map((c) => c.componentName.length),
   );
   return pods.map(({ podName, isMaster, componentName }) => ({
     value: podName,
     name: `[ ${componentName}${spaces(
-      maxComponentNameLength - componentName.length
+      maxComponentNameLength - componentName.length,
     )} ${isMaster ? "  PRIMARY  " : " secondary "}] ${podName}`,
   }));
 };

package/src/apps/cli/commands/project/cloudSql/commandProjectRestoreDb.ts

@@ -0,0 +1,175 @@
+import type Vorpal from "vorpal";
+import {
+  getEnvVarsResolved,
+  getPipelineContextByChoice,
+} from "../../../../../config/getProjectConfig";
+import type { CloudSqlBackgroundProxy } from "../../../../../gcloud/cloudSql/startProxy";
+import { startCloudSqlProxyInBackground } from "../../../../../gcloud/cloudSql/startProxy";
+import { envAndComponents } from "../utils/autocompletions";
+
+import { ConnectionStringParser } from "connection-string-parser";
+import { spawnCopyDb } from "../../../../../gcloud/cloudSql/copyDb";
+
+export default async (vorpal: Vorpal) =>
+  vorpal
+    .command(
+      "project-cloud-sql-restore-db",
+      "restores a project db from one source to another target",
+    )
+    .action(async function restoreDb() {
+      const envs = await envAndComponents();
+
+      const { sourceEnvAndComponent } = await this.prompt({
+        type: "list",
+        name: "sourceEnvAndComponent",
+        choices: envs,
+
+        message: "Source instance (connection string or 'local')? 🤔 ",
+      });
+
+      const [sourceEnv, sourceComponent] = sourceEnvAndComponent.split(":");
+
+      const sourceContext = await getPipelineContextByChoice(
+        sourceEnv,
+        sourceComponent,
+      );
+
+      const sourceEnvVars = await getEnvVarsResolved(
+        this,
+        sourceContext.env,
+        sourceContext.name,
+      );
+
+      let sourceProxy: CloudSqlBackgroundProxy;
+      let sourceDbName: string;
+
+      let sourceUsername: string;
+      let sourcePassword: string;
+
+      let targetUsername: string;
+      let targetPassword: string;
+      let targetProxy: CloudSqlBackgroundProxy;
+
+      let sourcePort: number;
+      let targetPort: number;
+      let targetDbName: string;
+
+      const closeAll = () => {
+        sourceProxy?.stop();
+        targetProxy?.stop();
+      };
+
+      if (sourceEnv === "local") {
+        const parser = new ConnectionStringParser({
+          scheme: "postgres",
+          hosts: [],
+        });
+
+        const parsersResult = parser.parse(sourceEnvVars.DATABASE_URL);
+        sourcePort = parsersResult.hosts?.[0]?.port;
+        sourceUsername = parsersResult.username;
+        sourcePassword = parsersResult.password;
+        sourceDbName = parsersResult.endpoint;
+      } else {
+        sourcePort = 54399;
+        sourceProxy = await startCloudSqlProxyInBackground({
+          instanceName: sourceEnvVars.CLOUD_SQL_INSTANCE_CONNECTION_NAME,
+          localPort: sourcePort,
+        });
+
+        sourceUsername = sourceEnvVars.DB_USER;
+        sourcePassword = sourceEnvVars.DB_PASSWORD;
+        sourceDbName = sourceEnvVars.DB_NAME;
+      }
+
+      const { targetEnvAndComponent } = await this.prompt({
+        type: "list",
+        name: "targetEnvAndComponent",
+        choices: envs,
+
+        message: "target env? 🤔 ",
+      });
+
+      const [targetEnv, targetComponent] = targetEnvAndComponent.split(":");
+
+      const targetContext = await getPipelineContextByChoice(
+        targetEnv,
+        targetComponent,
+      );
+
+      const targetEnvVars = await getEnvVarsResolved(
+        this,
+        targetContext.env,
+        targetContext.name,
+      );
+
+      if (targetEnv === "local") {
+        const parser = new ConnectionStringParser({
+          scheme: "postgres",
+          hosts: [],
+        });
+
+        const parsersResult = parser.parse(targetEnvVars.DATABASE_URL);
+
+        targetPort = parsersResult.hosts?.[0]?.port;
+        targetUsername = parsersResult.username;
+        targetPassword = parsersResult.password;
+        targetDbName = parsersResult.endpoint;
+      } else {
+        targetPort = 54499;
+        targetProxy = await startCloudSqlProxyInBackground({
+          instanceName: targetEnvVars.CLOUD_SQL_INSTANCE_CONNECTION_NAME,
+          localPort: targetPort,
+        });
+
+        targetUsername = targetEnvVars.DB_USER;
+        targetPassword = targetEnvVars.DB_PASSWORD;
+        targetDbName = targetEnvVars.DB_NAME;
+      }
+
+      const { shouldContinue } = await this.prompt({
+        type: "confirm",
+        name: "shouldContinue",
+        message: `This will drop ${targetEnv}/${targetDbName} and replace it with ${sourceEnv}/${sourceDbName}. Continue? 🤔 `,
+      });
+
+      if (!shouldContinue) {
+        this.log("abort");
+        closeAll();
+        return;
+      }
+
+      if (targetContext.environment.envType === "prod") {
+        this.log(
+          `\n🚨 You are overriding a production environment. Please type in ${targetEnvVars.CLOUD_SQL_INSTANCE_CONNECTION_NAME} to continue\n\n`,
+        );
+        const { confirmInstance } = await this.prompt({
+          type: "input",
+          name: "confirmInstance",
+          message: "confirm: ",
+        });
+
+        if (
+          confirmInstance !== targetEnvVars.CLOUD_SQL_INSTANCE_CONNECTION_NAME
+        ) {
+          this.log("abort");
+          closeAll();
+          return;
+        }
+      }
+
+      try {
+        await spawnCopyDb({
+          targetPassword,
+          targetPort,
+          targetUsername,
+          sourceUsername,
+          sourcePassword,
+          sourcePort,
+          sourceDbName,
+          targetDbName,
+        });
+      } finally {
+        closeAll();
+      }
+    });