@catladder/cli 0.0.0-refactor-untangle-gitlab-api-requests-from-vorpal-57cf3cf2 → 0.0.0-reference-database-url-1befbbee

package/package.json

@@ -53,7 +53,7 @@
     }
   ],
   "license": "MIT",
-  "version": "0.0.0-refactor-untangle-gitlab-api-requests-from-vorpal-57cf3cf2",
+  "version": "0.0.0-reference-database-url-1befbbee",
   "scripts": {
     "lint": "eslint \"src/**/*.ts\"",
     "lint:fix": "eslint \"src/**/*.ts\" --fix",

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

@@ -3,12 +3,11 @@ import { last } from "lodash";
 import open from "open";
 import type { CommandInstance } from "vorpal";
 import type Vorpal from "vorpal";
-import type { GitLabApiDataOptional } from "../../../../utils/gitlab-without-vorpal";
 import {
-  getGitLabHostPathToken,
-  getGitLabProjectId,
-} from "../../../../utils/gitlab-without-vorpal";
-import { doGitlabRequest, getGitlabToken } from "../../../../utils/gitlab";
+  doGitlabRequest,
+  getGitlabToken,
+  getProjectInfo,
+} from "../../../../utils/gitlab";
 
 const statusEmojiMap: any = {
   failed: "🙀",
@@ -34,23 +33,8 @@ const getCurrentCommit = async () => {
 const delay = async (ms: any) =>
   new Promise((resolve) => setTimeout(resolve, ms));
 
-const promptJob = async (
-  vorpal: CommandInstance,
-  projectId: any,
-  ctx: any,
-  existing: GitLabApiDataOptional = {},
-) => {
-  const {
-    host,
-    path,
-    token: inputToken,
-  } = await getGitLabHostPathToken(existing, vorpal);
-  const token = inputToken || (await getGitlabToken(vorpal, host));
-  const jobs = await doGitlabRequest(vorpal, {
-    path: `projects/${projectId}/jobs`,
-    host,
-    token,
-  });
+const promptJob = async (vorpal: CommandInstance, projectId: any, ctx: any) => {
+  const jobs = await doGitlabRequest(vorpal, `projects/${projectId}/jobs`);
 
   const commitId = await getCurrentCommit();
 
@@ -81,53 +65,33 @@ const promptJob = async (
   return jobs.find((j: any) => j.id === jobId);
 };
 
-const commandGitlabCi = async (
-  vorpal: Vorpal,
-  {
-    projectId,
-    ...existing
-  }: GitLabApiDataOptional & { projectId?: number | string } = {},
-) => {
+export default async (vorpal: Vorpal) => {
   vorpal.command("project-ci-job-open", "Open a Job").action(async function () {
-    const {
-      host,
-      path,
-      token: inputToken,
-    } = await getGitLabHostPathToken(existing, vorpal);
-    const token = inputToken || (await getGitlabToken(this, host));
-    const id =
-      projectId || (await getGitLabProjectId({ host, path, token }, vorpal));
-
-    const job = await promptJob(this, id, this, { host, path, token });
+    const { id: projectId } = await getProjectInfo(this);
+
+    const job = await promptJob(this, projectId, this);
     open(job.web_url);
   });
 
   vorpal
     .command("project-ci-job-log", "Show a job's log")
     .action(async function () {
-      const {
-        host,
-        path,
-        token: inputToken,
-      } = await getGitLabHostPathToken(existing, vorpal);
-      const token = inputToken || (await getGitlabToken(this, host));
-      const apiData = { host, path, token };
-      const pId =
-        projectId || (await getGitLabProjectId({ host, path, token }, vorpal));
-
-      const { id } = await promptJob(this, pId, this, apiData);
+      const { id: projectId } = await getProjectInfo(this);
+
+      const { id } = await promptJob(this, projectId, this);
 
       let finished = false;
       while (!finished) {
         const trace = await exec(
-          `curl -s --header "PRIVATE-TOKEN: ${token}" "https://git.panter.ch/api/v4/projects/${pId}/jobs/${id}/trace"`,
+          `curl -s --header "PRIVATE-TOKEN: ${await getGitlabToken(
+            this,
+          )}" "https://git.panter.ch/api/v4/projects/${projectId}/jobs/${id}/trace"`,
         );
 
-        const job = await doGitlabRequest(this, {
-          path: `projects/${pId}/jobs/${id}`,
-          host,
-          token,
-        });
+        const job = await doGitlabRequest(
+          this,
+          `projects/${projectId}/jobs/${id}`,
+        );
 
         if (trace.stdout) {
           vorpal.ui.redraw(`${trace.stdout}`);
@@ -149,5 +113,3 @@ const commandGitlabCi = async (
       }
     });
 };
-
-export default commandGitlabCi;

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

@@ -1,12 +1,14 @@
 import type Vorpal from "vorpal";
 import { setupProject } from "./setup";
+import { allComponents } from "./utils/autocompletions";
 
 export default async (vorpal: Vorpal) =>
   vorpal
     .command(
-      "project-setup",
+      "project-setup [component]",
       "Initializes all environments and creates requires resources, service accounts, etc.",
     )
-    .action(async function () {
-      await setupProject(this);
+    .autocomplete(await allComponents())
+    .action(async function ({ component }) {
+      await setupProject(this, component);
     });

package/src/apps/cli/commands/project/setup/index.ts

@@ -1,34 +1,24 @@
 import type { CommandInstance } from "vorpal";
 import { getAllPipelineContexts } from "../../../../../config/getProjectConfig";
-import { projectConfigSecrets } from "../commandConfigSecrets";
 import { setupAccessTokens } from "./setupAccessTokens";
 import { setupContext } from "./setupContext";
 import { setupTopic } from "./setupTopic";
 
-export const setupProject = async (instance: CommandInstance) => {
-  const allContext = await getAllPipelineContexts();
-
+export const setupProject = async (
+  instance: CommandInstance,
+  onlyComponents?: string | string[],
+) => {
+  const allContext = await getAllPipelineContexts(onlyComponents);
+  instance.log("will setup those contexts:");
+  allContext.forEach((context) => {
+    instance.log(` - ${context.name}:${context.env}`);
+  });
   for (const context of allContext) {
     await setupContext(instance, context);
   }
   await setupAccessTokens(instance);
   await setupTopic(instance);
   instance.log("");
-  const { configSecrets } = await instance.prompt({
-    default: true,
-    message: "Before deployments work, you need to config secrets. Do it now?",
-    name: "configSecrets",
-    type: "confirm",
-  });
-  instance.log("");
-  if (configSecrets) {
-    await projectConfigSecrets(instance);
-  } else {
-    instance.log(
-      "👆 don't forget to config secret using `project-config-secrets`",
-    );
-  }
-  instance.log("");
   instance.log("gitlab is ready! 🥂");
   instance.log("\n");
   instance.log("do not forget to make sure that:");

package/src/apps/cli/commands/project/setup/setupAccessTokens.ts

@@ -1,87 +1,70 @@
 import type { CommandInstance } from "vorpal";
-import { add } from "date-fns";
-import {
-  getGitLabHostPathToken,
-  gitLabProjectAccessToken,
-  type GitLabApiDataOptional,
-  gitLabVariable,
-  FetchGitLabError,
-  getGitLabProjectId,
-} from "../../../../../utils/gitlab-without-vorpal";
-import { getGitlabToken } from "../../../../../utils/gitlab";
+import { add, format } from "date-fns";
+import { doGitlabRequest, getProjectInfo } from "../../../../../utils/gitlab";
 
 const TOKEN_NAME = "semantic-release";
 
-export const setupAccessTokens = async (
-  vorpal: CommandInstance,
-  {
-    projectId,
-    ...existing
-  }: GitLabApiDataOptional & { projectId?: number | string } = {},
-) => {
-  const {
-    host,
-    path,
-    token: inputToken,
-  } = await getGitLabHostPathToken(existing, vorpal);
-  const token = inputToken || (await getGitlabToken(vorpal, host));
-  const id =
-    projectId || (await getGitLabProjectId({ host, path, token }, vorpal));
+export const setupAccessTokens = async (instance: CommandInstance) => {
+  const { id: projectId } = await getProjectInfo(instance);
 
-  const projectTokens = await gitLabProjectAccessToken.getList(
-    { projectId: id, token, host },
-    vorpal,
+  const projectTokens = await doGitlabRequest(
+    instance,
+    `projects/${projectId}/access_tokens`,
   );
-  const accessToken = projectTokens.find(
+  const token = projectTokens.find(
     (t) => t.name === TOKEN_NAME && t.active === true,
   );
 
-  const expires_at = add(new Date(), { years: 1, days: -1 });
+  const expires_at = format(
+    add(new Date(), { years: 1, days: -1 }),
+    "yyyy-MM-dd",
+  );
 
-  const newToken = accessToken
-    ? await gitLabProjectAccessToken.rotate(
-        {
-          projectId: id,
-          tokenId: accessToken.id,
-          token,
-          host,
-          data: { expires_at },
-        },
-        vorpal,
+  const newToken = token
+    ? await doGitlabRequest(
+        instance,
+        `projects/${projectId}/access_tokens/${token.id}/rotate`,
+        { expires_at },
+        "POST",
       )
-    : await gitLabProjectAccessToken.create(
+    : await doGitlabRequest(
+        instance,
+        `projects/${projectId}/access_tokens`,
         {
-          projectId: id,
-          token,
-          host,
-          data: {
-            expires_at,
-            name: TOKEN_NAME,
-            scopes: ["api", "read_repository"],
-            access_level: 40, // Maintainer
-          },
+          name: TOKEN_NAME,
+          scopes: ["api", "read_repository"],
+          access_level: 40, // Maintainer
+          expires_at,
         },
-        vorpal,
+        "POST",
       );
 
-  const fetchCommon = { key: "GL_TOKEN", projectId: id, host, token };
   try {
-    await gitLabVariable.get(fetchCommon, vorpal);
-    await gitLabVariable.update(
-      { ...fetchCommon, value: newToken.token },
-      vorpal,
+    await doGitlabRequest(instance, `projects/${projectId}/variables/GL_TOKEN`);
+    await doGitlabRequest(
+      instance,
+      `projects/${projectId}/variables/GL_TOKEN`,
+      { value: newToken.token },
+      "PUT",
     );
   } catch (e) {
-    if (!(e instanceof FetchGitLabError)) throw e;
-    if (e.status !== 404) throw e;
+    if (e.message !== "not found") {
+      throw e;
+    }
     // not found
-    await gitLabVariable.create(
-      { ...fetchCommon, value: newToken.token, masked: true },
-      vorpal,
+    await doGitlabRequest(
+      instance,
+      `projects/${projectId}/variables`,
+      {
+        key: "GL_TOKEN",
+        value: newToken.token,
+        masked: true,
+      },
+      "POST",
     );
   }
 
-  vorpal.log(
+  instance.log(
     "Token configured for semantic release. Renew me again in a year!",
   );
 };

package/src/apps/cli/commands/project/setup/setupKubernetes.ts

@@ -1,87 +1,68 @@
-import { exec } from "child-process-promise";
-import type { CommandInstance } from "vorpal";
-
+import type { ComponentContext } from "@catladder/pipeline";
 import {
-  type ComponentContext,
   getFullKubernetesClusterName,
   isOfDeployType,
 } from "@catladder/pipeline";
-import ensureNamespace from "../utils/ensureNamespace";
-import type { GitLabApiDataOptional } from "../../../../../utils/gitlab-without-vorpal";
-import {
-  getGitLabHostPathToken,
-  getGitLabProjectId,
-} from "../../../../../utils/gitlab-without-vorpal";
+import type { CommandInstance } from "vorpal";
+import { exec } from "child-process-promise";
+import { connectToCluster } from "../../../../../utils/cluster";
 import {
   doGitlabRequest,
-  getGitlabToken,
+  getProjectInfo,
   upsertAllVariables,
 } from "../../../../../utils/gitlab";
-import { connectToCluster } from "../../../../../utils/cluster";
+import ensureNamespace from "../utils/ensureNamespace";
 
 export const setupKubernetes = async (
-  vorpal: CommandInstance,
+  instance: CommandInstance,
   context: ComponentContext,
-  {
-    projectId,
-    ...existing
-  }: GitLabApiDataOptional & { projectId?: number | string } = {},
 ) => {
   const deployConfig = context.deploy?.config;
   if (!isOfDeployType(deployConfig, "kubernetes")) {
     throw new Error("cannot run setupKubernetes on non-kubernetes deployments");
   }
-  const {
-    host,
-    path,
-    token: inputToken,
-  } = await getGitLabHostPathToken(existing, vorpal);
-  const token = inputToken || (await getGitlabToken(vorpal, host));
-  const id =
-    projectId || (await getGitLabProjectId({ host, path, token }, vorpal));
-  const requestInfo = { host, path, token, projectId: id };
-  const deploy_tokens = await doGitlabRequest(vorpal, {
-    path: `projects/${id}/deploy_tokens`,
-    host,
-    token,
-  });
+
+  const { id: projectId } = await getProjectInfo(instance);
+  const deploy_tokens = await doGitlabRequest(
+    instance,
+    `projects/${projectId}/deploy_tokens`,
+  );
 
   if (
     !deploy_tokens.find(
       (v: { name: string }) => v.name === "gitlab-deploy-token",
     )
   ) {
-    vorpal.log(
+    instance.log(
       "I will setup the 'GitLab Deploy Token', so Kubernetes can pull images from this project.",
     );
 
-    await doGitlabRequest(vorpal, {
-      path: `projects/${id}/deploy_tokens`,
-      data: {
-        id,
+    await doGitlabRequest(
+      instance,
+      `projects/${projectId}/deploy_tokens`,
+      {
+        id: projectId,
         name: "gitlab-deploy-token",
         scopes: ["read_registry"],
       },
-      method: "POST",
-      host,
-      token,
-    });
+      "POST",
+    );
   }
 
   const fullName = getFullKubernetesClusterName(deployConfig.cluster);
-  vorpal.log(`cluster: ${fullName}`);
+  instance.log(`cluster: ${fullName}`);
 
   await connectToCluster(fullName);
-  vorpal.log("");
-  vorpal.log("ensuring namespace ...");
+  instance.log("");
+  instance.log("ensuring namespace ...");
   const namespace = await ensureNamespace(context);
-  vorpal.log("Namespace " + namespace + " created / updated!");
-  vorpal.log("");
+  instance.log("Namespace " + namespace + " created / updated!");
+  instance.log("");
   //$.verbose = true;
 
   // we name the service account and the role and the role binding with the same name
   // we currently create one per component to better separate them
-  vorpal.log("ensuring service accounts...");
+  instance.log("ensuring service accounts...");
   const serviceAccountName = `cl-${context.name}-deploy`;
   const KUBE_URL = await exec(
     `TERM=dumb kubectl cluster-info | grep -E 'Kubernetes master|Kubernetes control plane' | awk '/http/ {print $NF}'`,
@@ -174,19 +155,17 @@ EOF
     );
   }
 
-  vorpal.log("service accounts created / updated!");
+  instance.log("service accounts created / updated!");
 
-  vorpal.log("");
-  vorpal.log("pusing secrets to gitlab...");
+  instance.log("");
+  instance.log("pusing secrets to gitlab...");
 
   await upsertAllVariables(
-    vorpal,
+    instance,
     vars,
     context.env,
     context.name,
     false, // no backup
-    undefined,
-    requestInfo,
   );
-  vorpal.log("done!");
+  instance.log("done!");
 };

package/src/apps/cli/commands/project/setup/setupTopic.ts

@@ -1,22 +1,17 @@
 import type { CommandInstance } from "vorpal";
-import type { GitLabApiDataOptional } from "../../../../../utils/gitlab-without-vorpal";
-import {
-  getGitLabHostPathToken,
-  insertProjectTopics,
-} from "../../../../../utils/gitlab-without-vorpal";
-import { getGitlabToken } from "../../../../../utils/gitlab";
+import { doGitlabRequest, getProjectInfo } from "../../../../../utils/gitlab";
 
 const catladderTopic = "catladder";
 
-export const setupTopic = async (
-  vorpal: CommandInstance,
-  existing: GitLabApiDataOptional = {},
-) => {
-  const {
-    host,
-    path,
-    token: inputToken,
-  } = await getGitLabHostPathToken(existing, vorpal);
-  const token = inputToken || (await getGitlabToken(vorpal, host));
-  return insertProjectTopics({ topics: [catladderTopic], token, host }, vorpal);
+export const setupTopic = async (instance: CommandInstance) => {
+  const { id: projectId } = await getProjectInfo(instance);
+
+  const { topics } = await doGitlabRequest(instance, `projects/${projectId}`);
+
+  await doGitlabRequest(
+    instance,
+    `projects/${projectId}`,
+    { topics: [catladderTopic, ...topics] },
+    "PUT",
+  );
 };

package/src/apps/cli/commands/project/utils/autocompletions.ts

@@ -12,6 +12,15 @@ export const allEnvs = async () => {
   return getAllEnvsInAllComponents(config);
 };
 
+export const allComponents = async () => {
+  const config = await getProjectConfig();
+  if (!config) {
+    return [];
+  }
+
+  return Object.keys(config.components);
+};
+
 export const envAndComponents = async () => {
   const allEnvAndcomponents = await getAllComponentsWithAllEnvsFlat();
 

package/src/apps/cli/utils/getGoogleAuthUserNumber.ts

@@ -1,33 +1,23 @@
-import { logError, logLines } from "../../../utils/log";
-import { getPreferences, upsertPreferences } from "../../../utils/preferences";
+import {
+  getPreference,
+  hasPreference,
+  setPreference,
+} from "../../../utils/preferences";
 
+const KEY = "googleAuthUserNumber";
 export const getGoogleAuthUserNumber = async function () {
-  const preferences = await getPreferences(this);
-  if (
-    typeof preferences.googleAuthUserNumber === "number" ||
-    typeof preferences.googleAuthUserNumber === "string"
-  ) {
-    return preferences.googleAuthUserNumber;
-  }
-  logLines(
-    this,
-    "Please type in your google auth user number (0 if you have only one google account or maybe 1 if you have multiple)",
-  );
+  if (!(await hasPreference(KEY))) {
+    this.log(
+      "Please type in your google auth user number (0 if you have only one google account or maybe 1 if you have multiple)",
+    );
 
-  const { authUserNumber: googleAuthUserNumber } = await this.prompt({
-    type: "number",
-    name: "authUserNumber",
-    default: "0",
-    message: "Auth user ",
-  });
-  if (
-    typeof googleAuthUserNumber === "number" ||
-    (typeof googleAuthUserNumber === "string" &&
-      googleAuthUserNumber.length > 0)
-  ) {
-    await upsertPreferences({ googleAuthUserNumber }, this);
-    return googleAuthUserNumber;
+    const { authUserNumber } = await this.prompt({
+      type: "number",
+      name: "authUserNumber",
+      default: "0",
+      message: "Auth user ",
+    });
+    await setPreference(KEY, authUserNumber);
   }
-  logError(this, "google auth user number input missing!");
-  process.exit(1);
+  return getPreference(KEY);
 };

package/src/apps/cli/verify/index.ts

@@ -1,32 +1,14 @@
 import type Vorpal from "vorpal";
 
-import { setupGitlabToken } from "../../../utils/gitlab";
-import { getPreferences, upsertPreferences } from "../../../utils/preferences";
-import { getGitRemoteHostAndPath } from "../../../git";
+import { hasGitlabToken, setupGitlabToken } from "../../../utils/gitlab";
 
 export const verify = async (vorpal: Vorpal) => {
-  const [preferences, { gitRemoteHost }] = await Promise.all([
-    getPreferences(vorpal),
-    getGitRemoteHostAndPath(),
-  ]);
   // check if has all settings
-  if (preferences.gitlabTokens[gitRemoteHost]?.length) {
-    return;
-  }
-  if (preferences["gitlab-personal-access-token"]?.length) {
-    // Add the token to the hostname based preferences
-    await upsertPreferences(
-      {
-        gitlabTokens: {
-          [gitRemoteHost]: preferences["gitlab-personal-access-token"],
-        },
-      },
-      vorpal,
-    );
-    return;
+
+  if (!(await hasGitlabToken())) {
+    vorpal.command("setup-gitlab-token").action(async function () {
+      await setupGitlabToken(this);
+    });
+    vorpal.exec("setup-gitlab-token");
   }
-  vorpal.command("setup-gitlab-token").action(async function () {
-    await setupGitlabToken(this, gitRemoteHost);
-  });
-  vorpal.exec("setup-gitlab-token");
 };