@catladder/cli 0.0.0-fix-config-move-not-working-again-bf012644 → 0.0.0-fix-handle-missing-cloud-sql-proxy-command-error-and-show-nice-4dbbecce

package/package.json

@@ -53,7 +53,7 @@
     }
   ],
   "license": "MIT",
-  "version": "0.0.0-fix-config-move-not-working-again-bf012644",
+  "version": "0.0.0-fix-handle-missing-cloud-sql-proxy-command-error-and-show-nice-4dbbecce",
   "scripts": {
     "lint": "eslint \"src/**/*.ts\"",
     "lint:fix": "eslint \"src/**/*.ts\" --fix",

package/src/apps/catenv/printVariables.ts

@@ -55,4 +55,7 @@ export const printVariables = async (config: Config, choice?: Choice) => {
 };
 
 const makeExportKeyValuestring = (variables: Record<string, string>) =>
-  makeKeyValueString(variables, "export ");
+  makeKeyValueString(variables, {
+    keyPrefix: "export ",
+    escapeOptions: { quoteMode: "always" },
+  });

package/src/apps/catenv/utils.ts

@@ -1,4 +1,4 @@
-import type { Config } from "@catladder/pipeline";
+import type { Config, EscapeForDotEnvOptions } from "@catladder/pipeline";
 import { join } from "path";
 import { getGitRoot } from "../../utils/projects";
 import type { Choice } from "./types";
@@ -32,13 +32,22 @@ export const getCurrentComponentAndEnvFromChoice = async (
   };
 };
 
+export type MakeKeyValueStringOptions = {
+  keyPrefix?: string;
+  escapeOptions?: EscapeForDotEnvOptions;
+};
 export const makeKeyValueString = (
   variables: Record<string, string>,
-  keyPrefix = "",
+  { keyPrefix, escapeOptions }: MakeKeyValueStringOptions = {
+    keyPrefix: "",
+  },
 ) =>
   Object.entries(variables)
     // quotes are important, otherwise line breaks don't work properly
-    .map(([key, value]) => `${keyPrefix}${key}=${escapeForDotEnv(value)}`)
+    .map(
+      ([key, value]) =>
+        `${keyPrefix}${key}=${escapeForDotEnv(value, escapeOptions)}`,
+    )
     .join("\n");
 
 export const sanitizeEnvVarName = (name: string) =>

package/src/apps/cli/commands/project/commandCloudSqlProxy.ts

@@ -1,17 +1,23 @@
 import type { ComponentContext } from "@catladder/pipeline";
 import {
   createKubernetesCloudsqlBaseValues,
+  getDeployConfigType,
   isOfDeployType,
 } from "@catladder/pipeline";
 import type Vorpal from "vorpal";
 import type { CommandInstance } from "vorpal";
+import clipboard from "clipboardy";
 import {
   getEnvVarsResolved,
   getPipelineContextByChoice,
   parseChoice,
 } from "../../../../config/getProjectConfig";
 import { envAndComponents } from "./utils/autocompletions";
-import { startCloudSqlProxyInCurrentShell } from "../../../../gcloud/cloudSql/startProxy";
+import {
+  ERROR_NOT_INSTALLED,
+  startCloudSqlProxyInCurrentShell,
+} from "../../../../gcloud/cloudSql/startProxy";
+import { logError, logLines, logWarning } from "../../../../utils/log";
 
 type ProxyInfo = {
   instanceName: string;
@@ -19,61 +25,15 @@ type ProxyInfo = {
   DB_PASSWORD: string;
   DB_USER: string;
 };
-export default async (vorpal: Vorpal) =>
-  vorpal
-    .command("project-cloud-sql-proxy <envComponent>", "proxy to cloud sql db")
-    .autocomplete(await envAndComponents())
-    .action(async function ({ envComponent }) {
-      const { env, componentName } = parseChoice(envComponent);
-      if (!componentName) {
-        this.log("need componentName");
-        return;
-      }
-
-      const context = await getPipelineContextByChoice(env, componentName);
-      let proxyInfo: ProxyInfo;
-
-      if (env === "review") {
-        vorpal.log(
-          "⚠️ connection string does not include mr information on review environments",
-        );
-      }
-      if (isOfDeployType(context.deploy?.config, "kubernetes")) {
-        proxyInfo = await getProxyInfoForKubernetes(this, context);
-      } else if (isOfDeployType(context.deploy?.config, "google-cloudrun")) {
-        proxyInfo = await getProxyInfoForCloudRun(this, context);
-      } else {
-        throw new Error("unsupported environment");
-      }
-
-      // skynet-164509:europe-west6:pvl-cyclomania-review=tcp:5432
-      const { DB_PASSWORD, DB_NAME, DB_USER, instanceName } = proxyInfo;
-      const { localPort } = await this.prompt({
-        type: "number",
-        name: "localPort",
-        default: "54320",
-        message: "Local port: ",
-      });
-
-      this.log("");
-      this.log(`postgres-PW: ${DB_PASSWORD}`);
-      this.log("");
-      this.log("connection strings:");
-      this.log("");
-      this.log(
-        `DATABASE_URL=postgresql://${DB_USER}:${DB_PASSWORD}@localhost:${localPort}/${DB_NAME}?schema=public`,
-      );
-      this.log("");
-      this.log(
-        `DATABASE_JDBC_URL=jdbc:postgresql://localhost:${localPort}/${DB_NAME}?schema=public&user=${DB_USER}&password=${DB_PASSWORD}`,
-      );
-      this.log("");
 
-      await startCloudSqlProxyInCurrentShell({
-        instanceName,
-        localPort,
-      });
-    });
+const getProxyInfo = (context: ComponentContext) => {
+  if (isOfDeployType(context.deploy?.config, "kubernetes")) {
+    return getProxyInfoForKubernetes(this, context);
+  } else if (isOfDeployType(context.deploy?.config, "google-cloudrun")) {
+    return getProxyInfoForCloudRun(this, context);
+  }
+  throw new Error(`unsupported environment: ${context.deploy?.config?.type}`);
+};
 
 const getProxyInfoForKubernetes = async (
   vorpal: CommandInstance,
@@ -111,20 +71,124 @@ const getProxyInfoForCloudRun = async (
     !isOfDeployType(context.deploy?.config, "google-cloudrun") ||
     !context.deploy?.config.cloudSql
   ) {
-    throw new Error("unsupported");
+    const deployType = getDeployConfigType(context.deploy?.config);
+    const errorMessage =
+      deployType === "google-cloudrun"
+        ? `DeployConfig is missing the cloudSql property`
+        : `Unsupported DeployConfig type: ${deployType}`;
+    logError(vorpal, errorMessage);
+    throw new Error(errorMessage);
   }
-
   const envVars = await getEnvVarsResolved(vorpal, context.env, context.name);
-
-  const DB_PASSWORD = envVars?.DB_PASSWORD?.toString();
-  const DB_USER = envVars?.DB_USER?.toString();
-
-  const DB_NAME = context.environment.envVars.DB_NAME.toString();
-
   return {
     instanceName: context.deploy?.config.cloudSql.instanceConnectionName,
-    DB_PASSWORD,
-    DB_NAME,
-    DB_USER,
+    DB_PASSWORD: envVars?.DB_PASSWORD?.toString(),
+    DB_NAME: context.environment.envVars.DB_NAME.toString(),
+    DB_USER: envVars?.DB_USER?.toString(),
   };
 };
+
+const getDbUrl = (
+  { DB_PASSWORD, DB_NAME, DB_USER }: ProxyInfo,
+  localPort: string,
+  additional: string = "",
+) =>
+  `DATABASE_URL="postgresql://${DB_USER}:${DB_PASSWORD}@localhost:${localPort}/${DB_NAME}${additional}"`;
+
+const getJdbcUrl = (
+  { DB_PASSWORD, DB_NAME, DB_USER }: ProxyInfo,
+  localPort: string,
+) =>
+  `DATABASE_JDBC_URL="jdbc:postgresql://localhost:${localPort}/${DB_NAME}?schema=public&user=${DB_USER}&password=${DB_PASSWORD}"`;
+
+export default async (vorpal: Vorpal) =>
+  vorpal
+    .command("project-cloud-sql-proxy <envComponent>", "proxy to cloud sql db")
+    .autocomplete(await envAndComponents())
+    .action(async function ({ envComponent }) {
+      const { env, componentName } = parseChoice(envComponent);
+      if (!componentName) {
+        logWarning(this, "need componentName");
+        return;
+      }
+
+      const context = await getPipelineContextByChoice(env, componentName);
+
+      if (env === "review") {
+        logWarning(
+          this,
+          "connection string does not include mr information on review environments",
+        );
+      }
+
+      const { localPort } = await this.prompt({
+        type: "number",
+        name: "localPort",
+        default: "54320",
+        message: "Local port: ",
+      });
+
+      const proxyInfo = await getProxyInfo(context);
+
+      /**
+       * Env variables for libpq (e.g. psql client)
+       * https://www.postgresql.org/docs/current/libpq-envars.html#LIBPQ-ENVARS
+       */
+      const psqlEnvVars = {
+        PGPASSWORD: proxyInfo.DB_PASSWORD,
+        PGUSER: proxyInfo.DB_USER,
+        PGDATABASE: proxyInfo.DB_NAME,
+        PGHOST: "localhost",
+        PGPORT: localPort,
+      };
+      const lipbqEnvVarDeclarations = Object.entries(psqlEnvVars).map(
+        ([key, value]) => `${key}="${value}"`,
+      );
+      const dbUrl = getDbUrl(proxyInfo, localPort);
+      const jdbcUrl = getJdbcUrl(proxyInfo, localPort);
+
+      clipboard.writeSync(
+        [
+          "",
+          "## CloudSQL proxy connection .env variables",
+          dbUrl,
+          jdbcUrl,
+          "## DATABASE_URL with schema=public parameter (e. g. Prisma requires this):",
+          `# ${getDbUrl(proxyInfo, localPort, `?schema=public`)}`,
+          "## Env variables for libpq (e.g. psql client https://www.postgresql.org/docs/current/libpq-envars.html#LIBPQ-ENVARS)",
+          ...lipbqEnvVarDeclarations,
+          "",
+        ].join("\n"),
+      );
+
+      logLines(
+        this,
+        null,
+        "Connection strings env variables DATABASE_URL and those for the 'psql' client (copied to your clipboard for .env file):",
+        dbUrl,
+        jdbcUrl,
+        ...lipbqEnvVarDeclarations,
+        null,
+        "DATABASE_URL with schema=public parameter (e. g. Prisma requires this):",
+        getDbUrl(proxyInfo, localPort, `?schema=public`),
+        null,
+      );
+
+      try {
+        await startCloudSqlProxyInCurrentShell({
+          instanceName: proxyInfo.instanceName,
+          localPort,
+        });
+      } catch (error) {
+        if (!(error instanceof Error)) throw error;
+        if (error.message !== ERROR_NOT_INSTALLED) throw error;
+        logError(
+          this,
+          error.message,
+          null,
+          "Please install the Cloud SQL Auth Proxy from:",
+          `https://cloud.google.com/sql/docs/postgres/connect-auth-proxy#install`,
+          null,
+        );
+      }
+    });

package/src/utils/log.ts

@@ -1,13 +1,109 @@
+import type { CommandInstance } from "vorpal";
+
+type AnyMessagesFn = (message?: any, ...optionalParams: any[]) => void;
+type StringMessagesFn = (message?: string, ...optionalParams: string[]) => void;
+type AnyMessageFn = (message?: any) => void;
+type StringMessageFn = (message?: string) => void;
+type StringMessageSpreadFn = (...message: string[]) => void;
+type AnyMessageSpreadFn = (...message: any[]) => void;
+type SomeKindOfLogFn =
+  | AnyMessagesFn
+  | StringMessagesFn
+  | AnyMessageFn
+  | StringMessageFn
+  | StringMessageSpreadFn
+  | AnyMessageSpreadFn;
+type HasSomeKindOfLogMethod = { log: SomeKindOfLogFn };
+
+/**
+ * Something that has a .log method taking a string argument.
+ *
+ * null and undefined will fall back to console.log.
+ */
+export type LoggerCmdInstance =
+  | CommandInstance
+  | Console
+  | HasSomeKindOfLogMethod
+  | null
+  | undefined;
+
+type LinesArgItem = string | null | undefined;
+type LinesArg = LinesArgItem | LinesArgItem[];
+
+/**
+ * Logs multiple lines using the log method of the provided {@link LoggerCmdInstance}.
+ *
+ * Line items that are `null` or `undefined` are logged as empty lines.
+ *
+ * @param cmd - The logger instance to use. If `null` or `undefined`, `console` will be used.
+ *
+ * @example
+ * ```ts
+ * logLines(cmd, "line 1", "line 2", null, "line 3");
+ * logLines(cmd, ...linesArray); // arrays can be spread into the function
+ * logLines(cmd, linesArray); // but it will flatten the plain array for convenience
+ * ```
+ */
+export function logLines(
+  cmd: LoggerCmdInstance = console,
+  ...lines: LinesArg[]
+) {
+  const logger = cmd ?? console;
+  for (const line of lines.flat()) {
+    if (line === null || line === undefined) {
+      logger.log("");
+    } else {
+      logger.log(line);
+    }
+  }
+}
+
+/**
+ * Logs an error message using the log method of the provided {@link LoggerCmdInstance}.
+ *
+ * Line items that are `null` or `undefined` are logged as empty lines.
+ *
+ * @example
+ * ```ts
+ * logError(cmd, "Message");
+ * logError(cmd, "Message", "Additional message");
+ * logError(cmd, "Message", "Additional message", "Another additional message line");
+ * logError(cmd, "Message", ...additionalMessages); // arrays can be spread into the function
+ * logError(cmd, "Message", additionalMessages); // but it will flatten the plain array for convenience
+ * ```
+ */
 export const logError = (
-  cmd: any,
+  cmd: LoggerCmdInstance = console,
+  message: string,
+  ...additionalMessages: LinesArg[]
+) => {
+  logLines(cmd, null, `[ERROR] 🙀 :${message}`, null);
+  if (additionalMessages?.length) {
+    logLines(cmd, ...additionalMessages.flat(), null);
+  }
+};
+
+/**
+ * Logs a warning message using the log method of the provided {@link LoggerCmdInstance}.
+ *
+ * Line items that are `null` or `undefined` are logged as empty lines.
+ *
+ * @example
+ * ```ts
+ * logWarning(cmd, "Message");
+ * logWarning(cmd, "Message", "Additional message");
+ * logWarning(cmd, "Message", "Additional message", "Another additional message line");
+ * logWarning(cmd, "Message", ...additionalMessages); // arrays can be spread into the function
+ * logWarning(cmd, "Message", additionalMessages); // but it will flatten the plain array for convenience
+ * ```
+ */
+export const logWarning = (
+  cmd: LoggerCmdInstance = console,
   message: string,
-  additionalMessage?: any,
+  ...additionalMessages: LinesArg[]
 ) => {
-  cmd.log("");
-  cmd.log(`[ERROR] 🙀 :${message}`);
-  cmd.log("");
-  if (additionalMessage) {
-    cmd.log(additionalMessage);
-    cmd.log("");
+  logLines(cmd, `[WARNING] ⚠️ : ${message}`);
+  if (additionalMessages?.length) {
+    logLines(cmd, ...additionalMessages.flat(), null);
   }
 };