@catladder/cli 0.0.0-next-95928577 → 0.0.0-next-e7541a00

package/src/utils/gitlab.ts

@@ -1,34 +1,33 @@
 import { getSecretVarName } from "@catladder/pipeline";
-import { exec } from "child-process-promise";
-import { has, isObject } from "lodash";
+import { has, isObject } from "lodash-es";
 import memoizee from "memoizee";
 import fetch from "node-fetch";
 import open from "open";
-import type { CommandInstance } from "vorpal";
+import type { IO } from "../core/types";
 import { getPreference, hasPreference, setPreference } from "./preferences";
+import { getGitRemoteHostAndPath } from "../git/gitProjectInformation";
 
 const TOKEN_KEY = "gitlab-personal-access-token";
 
 export const hasGitlabToken = async () => await hasPreference(TOKEN_KEY);
-export const setupGitlabToken = async (vorpal: CommandInstance) => {
-  vorpal.log("");
-  vorpal.log("☝ in order to access the api, we need a personal access token");
-  vorpal.log("Its best to create one specifically for catladder");
-  vorpal.log("");
-  vorpal.log("☝ we open up the settings page for you!");
-  vorpal.log("");
-  const { shouldContinue } = await vorpal.prompt({
-    default: true,
-    message: "Ok",
-    name: "shouldContinue",
-    type: "prompt",
-  });
-
-  open("https://git.panter.ch/-/profile/personal_access_tokens");
-
-  vorpal.log("Please type in gitlab's personal access token");
-
-  const { personalToken } = await vorpal.prompt({
+export const setupGitlabToken = async (io: IO) => {
+  io.log("");
+  io.log("☝ in order to access the api, we need a personal access token");
+  io.log("Its best to create one specifically for catladder");
+  io.log("Scopes needed: api");
+  io.log("");
+  io.log("☝ we open up the settings page for you!");
+  io.log("");
+  const [shouldContinue, { gitRemoteHost }] = await Promise.all([
+    io.confirm("Ok"),
+    getGitRemoteHostAndPath(),
+  ]);
+
+  open(`https://${gitRemoteHost}/-/user_settings/personal_access_tokens`);
+
+  io.log("Please type in gitlab's personal access token");
+
+  const personalToken = await io.promptDirect({
     type: "string",
     name: "personalToken",
     default: "",
@@ -38,31 +37,34 @@ export const setupGitlabToken = async (vorpal: CommandInstance) => {
     await setPreference(TOKEN_KEY, personalToken);
   }
 };
-export const getGitlabToken = async (vorpal: CommandInstance | null) => {
+export const getGitlabToken = async (io: IO | null) => {
   if (!(await hasGitlabToken())) {
-    if (!vorpal) {
+    if (!io) {
       console.error(
         "⚠️ gitlab token missing, please run catladder to set it up",
       );
       process.exit(1);
     }
-    await setupGitlabToken(vorpal);
+    await setupGitlabToken(io);
   }
   return getPreference(TOKEN_KEY);
 };
 
 type Method = "GET" | "PUT" | "POST" | "DELETE";
 export const doGitlabRequest = async <T = any>(
-  vorpal: CommandInstance | null,
+  io: IO | null,
   path: string,
   data: any = undefined,
   method: Method = "GET",
 ): Promise<T> => {
-  const rootToken = await getGitlabToken(vorpal);
+  const [rootToken, { gitRemoteHost }] = await Promise.all([
+    getGitlabToken(io),
+    getGitRemoteHostAndPath(),
+  ]);
 
   //const method = data ? (update ? "PUT" : "POST") : "GET";
 
-  const result = await fetch(`https://git.panter.ch/api/v4/${path}`, {
+  const result = await fetch(`https://${gitRemoteHost}/api/v4/${path}`, {
     method,
     headers: {
       "Content-Type": "application/json",
@@ -89,18 +91,12 @@ export const doGitlabRequest = async <T = any>(
 };
 
 export const getProjectInfo = async (
-  vorpal: CommandInstance | null,
+  io: IO | null,
 ): Promise<{ id: string; web_url: string }> => {
-  const gitRemoteOriginUrl = (
-    await exec("git config --get remote.origin.url")
-  ).stdout.trim();
-  const projectPath =
-    /(https:\/\/|git@)git\.panter\.ch[:/]([^.]*)(\.git)?/g.exec(
-      gitRemoteOriginUrl,
-    );
+  const { gitRemotePath } = await getGitRemoteHostAndPath();
   const project = await doGitlabRequest(
-    vorpal,
-    `projects/${encodeURIComponent(projectPath[2])}`,
+    io,
+    `projects/${encodeURIComponent(gitRemotePath)}`,
   );
   return project;
 };
@@ -115,10 +111,10 @@ type GitlabVariable = {
 };
 export const getAllVariables = memoizee(
   async (
-    vorpal: CommandInstance | null,
+    io: IO | null,
     n = 5, // how many requests to do in parallel, 5 seems a good value for many projects, ideally we would do one request in parallel per component
   ): Promise<Array<GitlabVariable>> => {
-    const { id } = await getProjectInfo(vorpal);
+    const { id } = await getProjectInfo(io);
 
     let all: Array<GitlabVariable> = [];
     let result: Array<Array<GitlabVariable>> = [];
@@ -128,7 +124,7 @@ export const getAllVariables = memoizee(
       // Create an array of promises for N pages
       const promises = Array.from({ length: n }, (_, i) => {
         return doGitlabRequest(
-          vorpal,
+          io,
           `projects/${id}/variables?per_page=100&page=${page + i}`,
         );
       });
@@ -149,11 +145,8 @@ export const getAllVariables = memoizee(
   { promise: true },
 );
 
-export const getVariableValueByRawName = async (
-  vorpal: CommandInstance,
-  rawName: string,
-) => {
-  const allVariables = await getAllVariables(vorpal);
+export const getVariableValueByRawName = async (io: IO, rawName: string) => {
+  const allVariables = await getAllVariables(io);
   return allVariables.find((v) => v.key === rawName)?.value;
 };
 
@@ -161,7 +154,7 @@ const maskableRegex = new RegExp("^[a-zA-Z0-9_+=/@:.~-]{8,}$"); // SEE https://g
 const isMaskable = (value: string): boolean => maskableRegex.test(value);
 
 const createVariable = async (
-  vorpal: CommandInstance,
+  io: IO,
   projectId: string,
   key: string,
   value: string,
@@ -169,7 +162,7 @@ const createVariable = async (
   environment_scope = "*",
 ) => {
   return await doGitlabRequest(
-    vorpal,
+    io,
     `projects/${projectId}/variables`,
     {
       key,
@@ -182,14 +175,14 @@ const createVariable = async (
 };
 
 const updateVariable = async (
-  vorpal: CommandInstance,
+  io: IO,
   projectId: string,
   key: string,
   value: string,
   masked = true,
 ) => {
   return await doGitlabRequest(
-    vorpal,
+    io,
     `projects/${projectId}/variables/${key}`,
     {
       value,
@@ -199,21 +192,17 @@ const updateVariable = async (
   );
 };
 
-const deleteVariable = async (
-  vorpal: CommandInstance,
-  projectId: string,
-  key: string,
-) => {
+const deleteVariable = async (io: IO, projectId: string, key: string) => {
   return await doGitlabRequest(
-    vorpal,
+    io,
     `projects/${projectId}/variables/${key}`,
     undefined,
     "DELETE",
   );
 };
 
-const getAllCatladderEnvVarsInGitlab = async (vorpal: CommandInstance) => {
-  const allVariables = await getAllVariables(vorpal).then((v) =>
+const getAllCatladderEnvVarsInGitlab = async (io: IO) => {
+  const allVariables = await getAllVariables(io).then((v) =>
     v.reduce<{
       [key: string]: {
         value?: string;
@@ -256,32 +245,32 @@ const getAllCatladderEnvVarsInGitlab = async (vorpal: CommandInstance) => {
 
 const getBackupKey = (fullKey: string, timestamp: number) =>
   `${fullKey}_backup_${timestamp}`;
-export const clearBackups = async (vorpal: CommandInstance, keep: number) => {
-  const existingVariables = await getAllCatladderEnvVarsInGitlab(vorpal);
-  const { id } = await getProjectInfo(vorpal);
+export const clearBackups = async (io: IO, keep: number) => {
+  const existingVariables = await getAllCatladderEnvVarsInGitlab(io);
+  const { id } = await getProjectInfo(io);
   for (const [key, { backups }] of Object.entries(existingVariables)) {
     const backupsSorted = backups.sort((a, b) => b - a);
     //const toKeep = backupsSorted.slice(0, keep);
     const toDelete = backupsSorted.slice(keep);
 
     for (const timestamp of toDelete) {
-      await deleteVariable(vorpal, id, getBackupKey(key, timestamp));
+      await deleteVariable(io, id, getBackupKey(key, timestamp));
     }
   }
 };
 
 export const upsertAllVariables = async (
-  vorpal: CommandInstance,
+  io: IO,
   variables: Record<string, any>,
   env: string,
   componentName: string,
   backup = true,
   masked = true, // FIXME: would be better to have this per variable
 ): Promise<void> => {
-  const { id } = await getProjectInfo(vorpal);
+  const { id } = await getProjectInfo(io);
 
   // we list all existing variables. We also gather backup versions, but its currently unused
-  const existingVariables = await getAllCatladderEnvVarsInGitlab(vorpal);
+  const existingVariables = await getAllCatladderEnvVarsInGitlab(io);
   for (const [key, value] of Object.entries(variables ?? {})) {
     const fullKey = getSecretVarName(env, componentName, key);
     const valueSanitized = isObject(value) ? JSON.stringify(value) : `${value}`;
@@ -291,13 +280,13 @@ export const upsertAllVariables = async (
     const changed = oldValue !== valueSanitized;
     if (changed) {
       if (exists) {
-        vorpal.log(`changed: ${key}`);
+        io.log(`changed: ${key}`);
 
-        await updateVariable(vorpal, id, fullKey, valueSanitized, masked);
+        await updateVariable(io, id, fullKey, valueSanitized, masked);
         // write backup
         if (backup) {
           await createVariable(
-            vorpal,
+            io,
             id,
             getBackupKey(fullKey, new Date().getTime()),
             oldValue,
@@ -306,11 +295,11 @@ export const upsertAllVariables = async (
           );
         }
       } else {
-        vorpal.log(`new    : ${key}`);
-        await createVariable(vorpal, id, fullKey, valueSanitized, masked);
+        io.log(`new    : ${key}`);
+        await createVariable(io, id, fullKey, valueSanitized, masked);
       }
     } else {
-      vorpal.log(`skip   : ${key}`);
+      io.log(`skip   : ${key}`);
     }
   }
   getAllVariables.clear();

package/src/utils/log.ts

@@ -1,13 +1,113 @@
+import type { IO } from "../core/types";
+
+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 =
+  | IO
+  | Console
+  | HasSomeKindOfLogMethod
+  | null
+  | undefined;
+
+type LinesArgItem =
+  | string
+  | number
+  | boolean
+  | Date
+  | RegExp
+  | 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[]
+) {
+  for (const line of lines.flat()) {
+    (cmd ?? console).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, "", `[ERROR] 🙀 :${message}`);
+  if (additionalMessages?.length) {
+    logLines(cmd, ...additionalMessages.flat());
+  }
+  logLines(cmd, "");
+};
+
+/**
+ * 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());
   }
+  logLines(cmd, "");
 };

package/src/utils/preferences.ts

@@ -0,0 +1,60 @@
+import { readFile, writeFile, mkdir, cp, chmod } from "fs/promises";
+import { existsSync } from "fs";
+import { join, dirname } from "path";
+import { homedir } from "os";
+import { parse, stringify } from "yaml";
+
+const legacyPreferencesPath = join(homedir(), ".catladder/preferences.yml");
+const preferencesPath = join(homedir(), ".config/catladder/preferences.yml");
+
+const ensurePreferencesFile = async () => {
+  if (existsSync(preferencesPath)) {
+    return;
+  }
+  await mkdir(dirname(preferencesPath), { recursive: true, mode: 0o700 });
+  if (!existsSync(legacyPreferencesPath)) {
+    return writeFile(preferencesPath, "---\n{}", {
+      encoding: "utf-8",
+      mode: 0o600,
+    });
+  }
+  await cp(legacyPreferencesPath, preferencesPath);
+  await chmod(preferencesPath, 0o600);
+  await cp(
+    preferencesPath,
+    join(dirname(preferencesPath), "old_preferences_backup.yml"),
+  );
+};
+
+const loadPreferences = async () => {
+  await ensurePreferencesFile();
+  return readFile(preferencesPath, { encoding: "utf-8" });
+};
+
+export const getPreferences = async () => {
+  const yamlContent = await loadPreferences();
+  return (parse(yamlContent) ?? {}) as Record<string, string>;
+};
+
+export const hasPreference = async (key: string) => {
+  const preferences = await getPreferences();
+  return key in preferences;
+};
+export const getPreference = async (key: string) => {
+  const preferences = await getPreferences();
+  return preferences[key];
+};
+
+export const setPreference = async (key: string, value: string | number) => {
+  const preferences = await getPreferences();
+
+  const newPreferences = {
+    ...preferences,
+    [key]: value,
+  };
+
+  await writeFile(preferencesPath, stringify(newPreferences), {
+    encoding: "utf-8",
+    mode: 0o600,
+  });
+};

package/bin/catci

@@ -1,3 +0,0 @@
-#!/usr/bin/env node
-// tslint:disable-next-line:no-var-requires
-require("../dist/bundles/catci/index.js");

package/bin/catci-dev

@@ -1,3 +0,0 @@
-#!/usr/bin/env node
-// tslint:disable-next-line:no-var-requires
-require("../dist/cli/src/catci.js");