@cmflow/cli 1.1.0 → 1.1.1-alpha.1

package/src/commands/tasks/update-dependencies.js

@@ -1,37 +1,43 @@
-import { npm, yarn } from '../../common/index.js'
-import { refreshMetadata, shouldReinstall } from '../utils/check-install.js'
-import Listr from 'listr'
-import { catchError } from 'rxjs'
+import Listr from "listr";
+import { catchError } from "rxjs";
+
+import { npm, yarn } from "../../common/index.js";
+import { refreshMetadata, shouldReinstall } from "../utils/check-install.js";
 
 export const updateDependencies = ({ useYarn }) => {
-  const manager = useYarn ? yarn : npm
-  const reinstall = shouldReinstall()
+  const manager = useYarn ? yarn : npm;
+  const reinstall = shouldReinstall();
 
-  return ({
-    title: 'Install',
+  return {
+    title: "Install",
     enabled: () => reinstall,
-    task: () => new Listr(
-      [
-        {
-          title: `Restore dependencies using ${useYarn ? 'Yarn' : 'Npm'}`,
-          task: () => manager.restore()
-            .toObservable()
-            .pipe(catchError(error => {
-              if (useYarn) {
-                if (error.stderr.startsWith('error Your lockfile needs to be updated')) {
-                  throw new Error('yarn.lock file is outdated. Run yarn, commit the updated lockfile and try again.')
-                }
-              }
+    task: () =>
+      new Listr(
+        [
+          {
+            title: `Restore dependencies using ${useYarn ? "Yarn" : "Npm"}`,
+            task: () =>
+              manager
+                .restore()
+                .toObservable()
+                .pipe(
+                  catchError((error) => {
+                    if (useYarn) {
+                      if (error.stderr.startsWith("error Your lockfile needs to be updated")) {
+                        throw new Error("yarn.lock file is outdated. Run yarn, commit the updated lockfile and try again.");
+                      }
+                    }
 
-              throw error
-            }))
-        },
-        {
-          title: 'Refresh metadata',
-          task: () => refreshMetadata()
-        }
-      ],
-      { concurrency: false }
-    )
-  })
-}
+                    throw error;
+                  })
+                )
+          },
+          {
+            title: "Refresh metadata",
+            task: () => refreshMetadata()
+          }
+        ],
+        { concurrency: false }
+      )
+  };
+};

package/src/commands/utils/check-install.js

@@ -1,30 +1,31 @@
-import isEqual from 'lodash/isEqual.js'
-import { getPackageJson, git } from '../../common/index.js'
+import isEqual from "lodash/isEqual.js";
 
-function getDeps () {
-  const pkg = getPackageJson()
+import { getPackageJson, git } from "../../common/index.js";
+
+function getDeps() {
+  const pkg = getPackageJson();
   return {
     dependencies: pkg.dependencies,
     devDependencies: pkg.devDependencies
-  }
+  };
 }
 
-export function getHash () {
-  return Buffer.from(JSON.stringify(getDeps())).toString('base64')
+export function getHash() {
+  return Buffer.from(JSON.stringify(getDeps())).toString("base64");
 }
 
-export function getDepsFromHash () {
+export function getDepsFromHash() {
   try {
-    return JSON.parse(Buffer.from(git.config('--local', 'npm.hash'), 'base64').toString('utf8'))
-  } catch (er) {
-    return ''
+    return JSON.parse(Buffer.from(git.config("--local", "npm.hash"), "base64").toString("utf8"));
+  } catch {
+    return "";
   }
 }
 
-export function shouldReinstall () {
-  return !isEqual(getDeps(), getDepsFromHash())
+export function shouldReinstall() {
+  return !isEqual(getDeps(), getDepsFromHash());
 }
 
-export function refreshMetadata () {
-  git.config('--local', 'npm.hash', `${getHash()}`)
+export function refreshMetadata() {
+  git.config("--local", "npm.hash", `${getHash()}`);
 }

package/src/common/cli/cli.js

@@ -1,112 +1,110 @@
-import 'any-observable/register/rxjs-all.js' // eslint-disable-line import/no-unassigned-import
-import execa from 'execa'
-import { fromEvent, merge, map, filter, takeUntil } from 'rxjs'
-import { spawnSync } from 'child_process'
+import "any-observable/register/rxjs-all.js";
+
+import { spawnSync } from "child_process";
+import execa from "execa";
+import { filter, fromEvent, map, merge, takeUntil } from "rxjs";
 export class Cli {
-  constructor (cmd) {
-    this.cmd = cmd
+  constructor(cmd) {
+    this.cmd = cmd;
   }
 
-  sync (...args) {
-    return Cli.run(this.cmd, args).sync()
+  sync(...args) {
+    return Cli.run(this.cmd, args).sync();
   }
 
-  run (...args) {
-    return Cli.run(this.cmd, args)
+  run(...args) {
+    return Cli.run(this.cmd, args);
   }
 
-  get (...args) {
-    return Cli.run(this.cmd, args).get()
+  get(...args) {
+    return Cli.run(this.cmd, args).get();
   }
 
-  static run (cmd, args = [], options = {}) {
+  static run(cmd, args = [], options = {}) {
     const run = (opt = {}) => {
       return execa(cmd, args, {
         cwd: process.cwd(),
         ...opt,
         ...options
-      })
-    }
+      });
+    };
 
-    let isPromise = true
+    let isPromise = true;
 
     const promise = new Promise((resolve, reject) => {
       setTimeout(async () => {
         if (isPromise) {
           try {
             const result = await run({
-              stdio: 'inherit'
-            })
+              stdio: "inherit"
+            });
 
-            resolve(result)
+            resolve(result);
           } catch (err) {
-            // eslint-disable-next-line no-console
-            reject(err)
+            reject(err);
           }
         } else {
-          resolve()
+          resolve();
         }
-      }, 10)
-    })
+      }, 10);
+    });
 
     promise.toObservable = (opt) => {
-      isPromise = false
-      const cp = run(opt)
-      const end$ = fromEvent(cp, 'close')
-      const stdout$ = fromEvent(cp.stdout, 'data').pipe(
+      isPromise = false;
+      const cp = run(opt);
+      const end$ = fromEvent(cp, "close");
+      const stdout$ = fromEvent(cp.stdout, "data").pipe(
         takeUntil(end$),
-        map(data => data.toString())
-      )
-      const stderr$ = fromEvent(cp.stderr, 'data').pipe(
+        map((data) => data.toString())
+      );
+      const stderr$ = fromEvent(cp.stderr, "data").pipe(
         takeUntil(end$),
-        map(data => data.toString())
-      )
+        map((data) => data.toString())
+      );
 
-      return merge(stdout$, stderr$).pipe(
-        filter(Boolean)
-      )
-    }
+      return merge(stdout$, stderr$).pipe(filter(Boolean));
+    };
 
     promise.toStream = (opt) => {
-      isPromise = false
+      isPromise = false;
 
-      return run(opt)
-    }
+      return run(opt);
+    };
 
     promise.cwd = (cwd) => {
-      options.cwd = cwd
-      return promise
-    }
+      options.cwd = cwd;
+      return promise;
+    };
 
     promise.sync = (opt) => {
-      isPromise = false
+      isPromise = false;
       return execa.sync(cmd, args, {
         cwd: process.cwd(),
-        stdio: 'inherit',
+        stdio: "inherit",
         ...options,
         ...opt
-      })
-    }
+      });
+    };
 
     promise.getRaw = (opt) => {
-      isPromise = false
+      isPromise = false;
       return Cli.getRaw(cmd, args, {
         cwd: process.cwd(),
         ...options,
         ...opt
-      })
-    }
+      });
+    };
 
-    promise.get = promise.getRaw
+    promise.get = promise.getRaw;
 
-    return promise
+    return promise;
   }
 
-  static getRaw (cmd, args, options) {
+  static getRaw(cmd, args, options) {
     return spawnSync(cmd, args, options)
-      .output.filter(o => !!o)
-      .map(o => o.toString())
-      .join('\n')
-      .trim()
+      .output.filter((o) => !!o)
+      .map((o) => o.toString())
+      .join("\n")
+      .trim();
   }
 }

package/src/common/cli/docker.js

@@ -1,63 +1,66 @@
-import axios from 'axios'
-import { Cli } from './cli.js'
+import axios from "axios";
+
+import { Cli } from "./cli.js";
 
 class DockerCli extends Cli {
-  constructor () {
-    super('docker')
+  constructor() {
+    super("docker");
   }
 
-  tag (...args) {
-    return this.get('tag', ...args)
+  tag(...args) {
+    return this.get("tag", ...args);
   }
 
-  login (...args) {
-    return this.sync('login', ...args)
+  login(...args) {
+    return this.sync("login", ...args);
   }
 
-  push (...args) {
-    return this.run('push', ...args)
+  push(...args) {
+    return this.run("push", ...args);
   }
 
-  async getToken (username, password) {
-    const { data: { token } } = await axios({
-      method: 'POST',
-      url: 'https://hub.docker.com/v2/users/login/',
+  async getToken(username, password) {
+    const {
+      data: { token }
+    } = await axios({
+      method: "POST",
+      url: "https://hub.docker.com/v2/users/login/",
       headers: {
-        Accept: 'application/json',
-        'Content-Type': 'application/json'
+        Accept: "application/json",
+        "Content-Type": "application/json"
       },
       data: {
         username,
         password
       }
-    })
+    });
 
-    return token
+    return token;
   }
 
-  async getTags ({ token, repository }) {
+  async getTags({ token, repository }) {
     const { data } = await axios({
-      method: 'GET',
+      method: "GET",
       url: `https://hub.docker.com/v2/repositories/${repository}/tags/?page=1&page_size=500`,
       headers: {
-        Accept: 'application/json',
+        Accept: "application/json",
         Authorization: `JWT ${token}`
       }
-    })
+    });
 
-    return data.results
+    return data.results;
   }
 
-  async deleteTag (tag, { token, repository }) {
+  async deleteTag(tag, { token, repository }) {
     await axios({
-      method: 'DELETE',
+      method: "DELETE",
       url: `https://hub.docker.com/v2/repositories/${repository}/tags/${tag}/`,
       headers: {
-        Accept: 'application/json',
+        Accept: "application/json",
         Authorization: `JWT ${token}`
       }
-    })
+    });
   }
 }
 
-export const docker = new DockerCli()
+export const docker = new DockerCli();

package/src/common/cli/docker.test.js

@@ -1,135 +1,133 @@
-import { beforeEach, describe, expect, it, jest } from '@jest/globals'
+vi.mock("axios", () => {
+  return { default: vi.fn() };
+});
+vi.mock("execa", () => {
+  const execaMock = vi.fn();
+  execaMock.sync = vi.fn();
+  return { default: execaMock };
+});
+const { default: execa } = await import("execa");
+const { default: axios } = await import("axios");
+const { docker } = await import("./docker.js");
+const { Cli } = await import("./cli.js");
 
-jest.unstable_mockModule('axios', () => {
-  return { default: jest.fn() }
-})
-jest.unstable_mockModule('execa', () => {
-  const execaMock = jest.fn()
-  execaMock.sync = jest.fn()
-  return { default: execaMock }
-})
-const { default: execa } = await import('execa')
-const { default: axios } = await import('axios')
-const { docker } = await import('./docker.js')
-const { Cli } = await import('./cli.js')
-
-execa.mockReturnValue({})
+execa.mockReturnValue({});
 
 execa.sync.mockImplementation((...args) => {
   return {
-    stdout: `CMD: ${[].concat(...args.filter(arg => typeof arg === 'string' || Array.isArray(arg))).join(' ')}`
-  }
-})
+    stdout: `CMD: ${[].concat(...args.filter((arg) => typeof arg === "string" || Array.isArray(arg))).join(" ")}`
+  };
+});
 
-describe('DockerCli', () => {
+describe("DockerCli", () => {
   beforeEach(() => {
-    jest.spyOn(Cli, 'getRaw').mockImplementation((...args) => {
-      return `CMD: ${[].concat(...args.filter(arg => typeof arg === 'string' || Array.isArray(arg))).join(' ')}`
-    })
-  })
-  describe('tag', () => {
-    it('should run tag cmd', () => {
-      const result = docker.tag('tag-arg', 'image')
+    vi.spyOn(Cli, "getRaw").mockImplementation((...args) => {
+      return `CMD: ${[].concat(...args.filter((arg) => typeof arg === "string" || Array.isArray(arg))).join(" ")}`;
+    });
+  });
+  describe("tag", () => {
+    it("should run tag cmd", () => {
+      const result = docker.tag("tag-arg", "image");
 
-      expect(result).toEqual('CMD: docker tag tag-arg image')
-      expect(Cli.getRaw).toHaveBeenCalledWith('docker', ['tag', 'tag-arg', 'image'], {
+      expect(result).toEqual("CMD: docker tag tag-arg image");
+      expect(Cli.getRaw).toHaveBeenCalledWith("docker", ["tag", "tag-arg", "image"], {
         cwd: process.cwd()
-      })
-    })
-  })
-  describe('login', () => {
-    it('should run login cmd', () => {
-      const result = docker.login('login-arg')
+      });
+    });
+  });
+  describe("login", () => {
+    it("should run login cmd", () => {
+      const result = docker.login("login-arg");
 
-      expect(result.stdout).toEqual('CMD: docker login login-arg')
-      expect(execa.sync).toHaveBeenCalledWith('docker', ['login', 'login-arg'], {
+      expect(result.stdout).toEqual("CMD: docker login login-arg");
+      expect(execa.sync).toHaveBeenCalledWith("docker", ["login", "login-arg"], {
         cwd: process.cwd(),
-        stdio: 'inherit'
-      })
-    })
-  })
-  describe('push', () => {
-    it('should run push cmd', async () => {
-      await docker.push('push-arg')
+        stdio: "inherit"
+      });
+    });
+  });
+  describe("push", () => {
+    it("should run push cmd", async () => {
+      await docker.push("push-arg");
 
-      expect(execa).toHaveBeenCalledWith('docker', ['push', 'push-arg'], {
+      expect(execa).toHaveBeenCalledWith("docker", ["push", "push-arg"], {
         cwd: process.cwd(),
-        stdio: 'inherit'
-      })
-    })
-  })
-  describe('getToken', () => {
+        stdio: "inherit"
+      });
+    });
+  });
+  describe("getToken", () => {
     beforeEach(() => {
-      axios.mockReturnValue({ data: { token: 'token' } })
-    })
-    it('should get token', async () => {
-      const token = await docker.getToken('username', 'password')
+      axios.mockReturnValue({ data: { token: "token" } });
+    });
+    it("should get token", async () => {
+      const token = await docker.getToken("username", "password");
 
       expect(axios).toHaveBeenCalledWith({
-        method: 'POST',
-        url: 'https://hub.docker.com/v2/users/login/',
+        method: "POST",
+        url: "https://hub.docker.com/v2/users/login/",
         headers: {
-          Accept: 'application/json',
-          'Content-Type': 'application/json'
+          Accept: "application/json",
+          "Content-Type": "application/json"
         },
         data: {
-          password: 'password',
-          username: 'username'
+          password: "password",
+          username: "username"
         }
-      })
-      expect(token).toEqual('token')
-    })
-  })
-  describe('getTags', () => {
+      });
+      expect(token).toEqual("token");
+    });
+  });
+  describe("getTags", () => {
     beforeEach(() => {
       axios.mockReturnValue({
         data: {
           results: [
             {
-              name: 'branch-1',
-              last_updated: new Date('2020-06-01')
+              name: "branch-1",
+              last_updated: new Date("2020-06-01")
             }
           ]
         }
-      })
-    })
-    it('should get token', async () => {
+      });
+    });
+    it("should get token", async () => {
       const tags = await docker.getTags({
-        token: 'token',
-        repository: 'owner'
-      })
+        token: "token",
+        repository: "owner"
+      });
 
       expect(tags).toEqual([
         {
-          name: 'branch-1',
-          last_updated: new Date('2020-06-01')
+          name: "branch-1",
+          last_updated: new Date("2020-06-01")
         }
-      ])
+      ]);
       expect(axios).toHaveBeenCalledWith({
-        method: 'GET',
-        url: 'https://hub.docker.com/v2/repositories/owner/tags/?page=1&page_size=500',
+        method: "GET",
+        url: "https://hub.docker.com/v2/repositories/owner/tags/?page=1&page_size=500",
         headers: {
-          Accept: 'application/json',
-          Authorization: 'JWT token'
+          Accept: "application/json",
+          Authorization: "JWT token"
         }
-      })
-    })
-  })
-  describe('deleteTag', () => {
-    it('should run delete Tag', async () => {
-      await docker.deleteTag('my-tag', {
-        token: 'token',
-        repository: 'owner'
-      })
+      });
+    });
+  });
+  describe("deleteTag", () => {
+    it("should run delete Tag", async () => {
+      await docker.deleteTag("my-tag", {
+        token: "token",
+        repository: "owner"
+      });
 
       expect(axios).toHaveBeenCalledWith({
         headers: {
-          Accept: 'application/json',
-          Authorization: 'JWT token'
+          Accept: "application/json",
+          Authorization: "JWT token"
         },
-        method: 'DELETE',
-        url: 'https://hub.docker.com/v2/repositories/owner/tags/my-tag/'
-      })
-    })
-  })
-})
+        method: "DELETE",
+        url: "https://hub.docker.com/v2/repositories/owner/tags/my-tag/"
+      });
+    });
+  });
+});