@gluhar/cli 3.0.1 → 3.0.2

package/src/scripts/cmd/getCmdOutput.ts

@@ -0,0 +1,26 @@
+import { execSync } from 'child_process';
+import { log } from './log';
+import type { Args } from './types';
+import { parseArgs } from './parseArgs';
+
+/**
+ * A function that runs a bash script from a string and returns the output.
+ * Mainly used in js logic if you want the output of a bash script.
+ * @param cmd A one-line string of a bash command: 'npm install'.
+ * @param args Option flags to pass to the script: { m: 'Message', msg: 'asdf' }.
+ * @returns The output of the command as a string.
+ */
+export const getCmdOutput = (cmd: string, args?: Args) => {
+  const cmdArgs = [cmd];
+  if (args) {
+    cmdArgs.push(...parseArgs(args));
+  }
+
+  const fullCmd = cmdArgs.join(' ');
+  log.verbose('getCmdOutput:', fullCmd);
+  return execSync(fullCmd).toString().trim();
+};
+
+// TODO make an async option
+// TODO get output from a script file?
+// TODO maybe utilise the other two function instead of execSync?

package/src/scripts/cmd/{index.d.ts → index.ts}

@@ -1,8 +1,10 @@
-export * from './executeBash';
-export * from './executeCmd';
-export * from './getCmdOutput';
-export * from './getBashOutput';
-export declare const cmd: {
-    cd: (path: string) => void;
-};
-//# sourceMappingURL=index.d.ts.map
+import { cd } from './cd';
+
+export * from './executeBash';
+export * from './executeCmd';
+export * from './getCmdOutput';
+export * from './getBashOutput';
+
+export const cmd = {
+  cd,
+};

package/src/scripts/cmd/log.ts

@@ -0,0 +1,3 @@
+import { logger } from 'src/utils';
+
+export const log = logger('cmd');

package/src/scripts/cmd/parseArgs.ts

@@ -0,0 +1,44 @@
+import humps from "humps";
+import type { Args, NotNullableProps, ParsedArg } from "./types";
+
+const hyphenize = (s: string) => humps.decamelize(s, { separator: "-" });
+
+const hasValue = (arg: ParsedArg): arg is NotNullableProps<ParsedArg> => {
+  return arg.value !== undefined;
+};
+
+export const parseArgs = (args: Args): string[] => {
+  return Object.entries(args)
+    .map(
+      ([name, value]): ParsedArg => ({
+        name,
+        parsedName: hyphenize(name),
+        value,
+        parsedValue: JSON.stringify(value),
+      })
+    )
+    .filter(hasValue)
+    .reduce((result, { name, parsedName, value, parsedValue }) => {
+      if (name.length > 1) {
+        result.push(`--${parsedName}`);
+      } else {
+        result.push(`-${parsedName}`);
+      }
+      value.toString();
+
+      if (value !== true) {
+        let v = parsedValue;
+        if (
+          v.length > 2 &&
+          v[0] === '"' &&
+          v[v.length - 1] === '"' &&
+          !v.includes(" ")
+        )
+          v = v.slice(1, -1);
+
+        result.push(v);
+      }
+
+      return result;
+    }, [] as string[]);
+};

package/src/scripts/cmd/parseBashArgs.ts

@@ -0,0 +1,21 @@
+import { log } from './log';
+import type { Args } from './types';
+import { parseArgs } from './parseArgs';
+
+export const parseBashArgs = (
+  path: string,
+  args?: Args,
+  absolute?: boolean,
+) => {
+  const filePath = path.endsWith('.sh') ? path : `${path}.sh`;
+  const absolutePath = !absolute ? `${__dirname}/../${filePath}` : filePath;
+  const flags = [absolutePath];
+
+  if (args) {
+    flags.push(...parseArgs(args));
+  }
+
+  log.verbose('executeBash:', flags.join(' '));
+
+  return flags;
+};

package/src/scripts/cmd/types.ts

@@ -0,0 +1,13 @@
+export type ArgValue = string | number | boolean;
+export type Args = Record<string, ArgValue | undefined> | {};
+
+export interface ParsedArg {
+  name: string;
+  parsedName: string;
+  value: ArgValue | undefined;
+  parsedValue: string | undefined;
+}
+
+export type NotNullableProps<T> = {
+  [K in keyof T]: NonNullable<T[K]>;
+};

package/src/scripts/filesystem/copyDir.ts

@@ -0,0 +1,29 @@
+import { join, relative } from "path";
+import { copyFiles, FileInfoUpdate } from "./copyFiles";
+import { log } from "./log";
+
+/**
+ * Function that copies all files recursively from one dir to another allowing to update their content in the process.
+ * @param sourcePath Directory of files to copy recursively.
+ * @param destinationPath Destination directory to place files.
+ * @param updateContent Optional function that updates the contents of each file.
+ */
+export const copyDir = (
+  sourcePath: string,
+  destinationPath: string,
+  updateFile?: FileInfoUpdate
+) => {
+  log.verbose("copyDir", { sourcePath, destinationPath });
+  const glob = join(sourcePath, "**", "*.*");
+
+  return copyFiles([glob], (file) => {
+    const newDir = join(destinationPath, relative(sourcePath, file.dir));
+    log.verbose("copyDir file from", file.dir, "to", newDir);
+    const f = updateFile ? updateFile(file) : file;
+
+    return {
+      ...f,
+      dir: newDir,
+    };
+  });
+};

package/src/scripts/filesystem/copyFiles.ts

@@ -0,0 +1,75 @@
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { glob } from "glob";
+import { type ParsedPath, parse, resolve, format } from "path";
+import { exists } from "fs-extra";
+import { log } from "./log";
+
+export interface FileInfo extends Omit<ParsedPath, "root"> {
+  name: string;
+  content: string;
+  encoding: BufferEncoding;
+}
+
+export type FileInfoUpdate = (fileInfo: FileInfo) => Partial<FileInfo>;
+
+export const loadFiles = async (globs: string[]): Promise<FileInfo[]> => {
+  const { isText } = await import("istextorbinary");
+
+  log.verbose("Globs:", globs);
+  const filePaths = await glob(globs, {
+    nodir: true,
+    dot: true,
+    nocase: true,
+  });
+  log.verbose("Loaded files:", filePaths.length);
+
+  const files = filePaths.map(async (path): Promise<FileInfo> => {
+    const encoding = isText(path) ? "utf-8" : "binary";
+
+    return {
+      ...parse(path),
+      content: await readFile(path, encoding),
+      encoding,
+    };
+  });
+
+  return Promise.all(files);
+};
+
+export const updateFiles = (
+  files: FileInfo[],
+  update: FileInfoUpdate
+): FileInfo[] => {
+  return files.map((original): FileInfo => {
+    log.verbose("Updating file", original.dir, original.base);
+    const updated = update(original);
+    return {
+      ...original,
+      ...updated,
+    };
+  });
+};
+
+const getPath = (relative: string) => resolve(process.cwd(), relative);
+
+const write = async (files: FileInfo[]) => {
+  const writes = files.map(async (file) => {
+    const dirPath = getPath(file.dir);
+    const dirExists = await exists(dirPath);
+    if (!dirExists) {
+      await mkdir(dirPath, { recursive: true });
+    }
+
+    const filePath = getPath(format(file));
+    log.verbose("Writing file", filePath);
+    await writeFile(filePath, file.content, file.encoding);
+  });
+
+  await Promise.all(writes);
+};
+
+export const copyFiles = async (globs: string[], update: FileInfoUpdate) => {
+  const files = await loadFiles(globs);
+  const updatedFiles = updateFiles(files, update);
+  await write(updatedFiles);
+};

package/src/scripts/filesystem/findFile.ts

@@ -0,0 +1,29 @@
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { log } from './log';
+
+const searchFile = (fileName: string, dir: string): string | null => {
+  const filePath = join(dir, fileName);
+
+  if (existsSync(filePath)) {
+    log.verbose('Found file:', filePath);
+    return filePath;
+  }
+
+  const parent = join(dir, '..');
+
+  if (parent === dir || !existsSync(parent)) {
+    log.verbose('File not found:', fileName);
+    return null;
+  }
+
+  return searchFile(fileName, parent);
+};
+
+export const findFile = (
+  fileName: string,
+  dir: string = process.cwd(),
+): string | null => {
+  log.verbose('Looking for file:', fileName);
+  return searchFile(fileName, dir);
+};

package/src/scripts/filesystem/index.ts

@@ -0,0 +1,15 @@
+import { copyDir } from "./copyDir";
+import { readDirRecursive } from "./readDirRecursive";
+import { loadJsonFile } from "./loadJsonFile";
+import { findFile } from "./findFile";
+import { copyFiles, loadFiles, updateFiles } from "./copyFiles";
+
+export const filesystem = {
+  copyDir,
+  copyFiles,
+  loadFiles,
+  updateFiles,
+  readDirRecursive,
+  loadJsonFile,
+  findFile,
+};

package/src/scripts/filesystem/loadJsonFile.ts

@@ -0,0 +1,17 @@
+import { existsSync, readFileSync } from 'fs';
+import { log } from './log';
+
+export const loadJsonFile = <T>(filePath: string): T | null => {
+  log.verbose('Try to load JSON file:', filePath);
+  const invalidPath = !filePath || !existsSync(filePath);
+  if (invalidPath) {
+    log.verbose('Invalid file path:', filePath);
+    return null;
+  }
+
+  const json = readFileSync(filePath).toString();
+  const result = JSON.parse(json) as T;
+
+  log.verbose('Successfully loaded JSON file:', filePath);
+  return result;
+};

package/src/scripts/filesystem/log.ts

@@ -0,0 +1,3 @@
+import { logger } from 'src/utils';
+
+export const log = logger('filesystem');

package/src/scripts/filesystem/readDirRecursive.ts

@@ -0,0 +1,21 @@
+import { readdirSync, statSync } from 'fs-extra';
+import { resolve, join } from 'path';
+
+const readDirStep = (
+  absoluteDirPath: string,
+  relativeDirPath: string,
+): string[] =>
+  readdirSync(absoluteDirPath).reduce((result: string[], current: string) => {
+    const absPath = resolve(absoluteDirPath, current);
+    const relPath = join(relativeDirPath, current);
+    const isDirectory = statSync(absPath).isDirectory();
+
+    if (isDirectory) {
+      return [...result, ...readDirStep(absPath, relPath)];
+    }
+
+    return [...result, relPath];
+  }, []);
+
+export const readDirRecursive = (dirPath: string): string[] =>
+  readDirStep(dirPath, '');

package/src/scripts/git/branch/branchDelete.ts

@@ -0,0 +1,32 @@
+// BRANCH=${npm_config_branch};
+// LOCAL=$(git branch --list $BRANCH);
+// if [ $LOCAL ];
+// then git branch -D $BRANCH; fi;
+// REMOTE=$(git ls-remote --heads origin $BRANCH);
+// if [ $REMOTE ];
+// then git push origin -d $BRANCH; fi
+
+import { executeCmd } from 'src/scripts/cmd';
+import { log } from '../log';
+
+export interface BranchDeleteOptions {
+  local?: boolean;
+  remote?: boolean;
+}
+
+export const branchDelete = (
+  branch: string,
+  options: BranchDeleteOptions = {},
+) => {
+  const { local, remote } = options;
+
+  if (local) {
+    log.verbose('Delete local branch:', branch);
+    executeCmd(`git branch -D ${branch}`);
+  }
+
+  if (remote) {
+    log.verbose('Delete remote branch:', branch);
+    executeCmd(`git push origin -d ${branch}`);
+  }
+};

package/src/scripts/git/branch/branchExists.ts

@@ -0,0 +1,14 @@
+import { getCmdOutput } from 'src/scripts/cmd';
+import { log } from '../log';
+
+export const branchExists = (branchName: string) => {
+  const local = !!getCmdOutput(`git branch --list ${branchName}`);
+  const remote = !!getCmdOutput(`git ls-remote --heads origin ${branchName}`);
+
+  log.verbose('branchExists:', { local, remote });
+
+  return {
+    local,
+    remote,
+  };
+};

package/src/scripts/git/branch/checkout.ts

@@ -0,0 +1,19 @@
+import { executeCmd } from 'src/scripts/cmd';
+
+export interface CheckoutOptions {
+  newBranch?: boolean;
+}
+
+export const checkout = (branchName: string, opt: CheckoutOptions = {}) => {
+  const { newBranch = false } = opt;
+
+  const cmd = ['git checkout'];
+  if (newBranch) {
+    cmd.push('-b');
+  }
+  cmd.push(branchName);
+
+  const fullCmd = cmd.join(' ');
+
+  return executeCmd(fullCmd);
+};

package/src/scripts/git/branch/getCurrentBranch.ts

@@ -0,0 +1,37 @@
+import { getCmdOutput } from 'src/scripts/cmd';
+import { log } from '../log';
+
+export interface BranchInfo {
+  fullName: string;
+  type?: 'dev' | 'prep' | 'release' | string;
+  name: string;
+  isDev: boolean;
+  isPrep: boolean;
+  isRelease: boolean;
+  isOther: boolean;
+}
+
+export const getCurrentBranch = (): BranchInfo => {
+  const fullName = getCmdOutput('git rev-parse --abbrev-ref HEAD');
+  let [type, name]: (string | undefined)[] = fullName.split('/');
+  if (!name) {
+    name = type;
+    type = undefined;
+  }
+  const isDev = type === 'dev';
+  const isPrep = type === 'prep';
+  const isRelease = type === 'release';
+  const isOther = !isDev && !isPrep && !isRelease;
+
+  log.verbose('Current branch:', fullName);
+
+  return {
+    fullName,
+    type,
+    name,
+    isDev,
+    isPrep,
+    isRelease,
+    isOther,
+  };
+};

package/src/scripts/git/clone.ts

@@ -0,0 +1,20 @@
+import { executeCmd } from "src/scripts/cmd";
+import { log } from "./log";
+
+export interface CloneOptions {
+  branch?: string;
+  singleBranch?: boolean;
+}
+
+/**
+ * Clone a repo.
+ * @param repo The repo name in the format: 'gluharry/starters'.
+ */
+export const clone = (
+  repo: string,
+  dir: string = "",
+  options: CloneOptions = {}
+) => {
+  log.verbose("Cloning:", repo, dir, options);
+  executeCmd(`git clone https://github.com/${repo}.git ${dir}`, options);
+};

package/src/scripts/git/getRepo.ts

@@ -0,0 +1,11 @@
+import { getCmdOutput } from "../cmd";
+
+export const getRepo = (): string => {
+  const url = getCmdOutput("git remote get-url origin");
+  const urlParts = url.split("/");
+
+  // "dev-tools.git"
+  const lastPart = urlParts[urlParts.length - 1];
+  // "dev-tools"
+  return lastPart.split(".")[0];
+};

package/src/scripts/git/index.ts

@@ -0,0 +1,44 @@
+import { executeBash, executeCmd } from "src/scripts/cmd";
+import { branchDelete } from "./branch/branchDelete";
+import { openPr } from "./openPr";
+import { remoteStatus } from "./remoteStatus";
+import { getCurrentBranch } from "./branch/getCurrentBranch";
+import { checkout } from "./branch/checkout";
+import { branchExists } from "./branch/branchExists";
+import { createTag } from "./tag/createTag";
+import type { Args } from "../cmd/types";
+import { getRepo } from "./getRepo";
+import { getTags } from "./tag/getTags";
+import { pushAllTags } from "./tag/pushAllTags";
+import { deleteTag } from "./tag/deleteTag";
+import { renameTag } from "./tag/renameTag";
+import { clone } from "./clone";
+
+export const git = {
+  openPr,
+  getRepo,
+  remoteStatus,
+  commit: (args: Args) => executeBash(`git/commit`, args),
+  push: (branchOrTag: string, remote = "origin") =>
+    executeCmd(`git push ${remote} ${branchOrTag}`),
+  pull: (branchName: string, remote = "origin") =>
+    executeCmd(`git pull ${remote} ${branchName}`),
+  merge: (branchName: string, y?: boolean) =>
+    executeCmd(`git merge ${branchName}${y ? " --no-edit" : ""}`),
+  branch: {
+    exists: branchExists,
+    delete: branchDelete,
+    getCurrent: getCurrentBranch,
+    checkout,
+  },
+  tag: {
+    getAll: getTags,
+    create: createTag,
+    delete: deleteTag,
+    rename: renameTag,
+    pushAll: pushAllTags,
+  },
+  clone,
+};
+
+export type { BranchInfo } from "./branch/getCurrentBranch";

package/src/scripts/git/log.ts

@@ -0,0 +1,3 @@
+import { logger } from 'src/utils';
+
+export const log = logger('git');

package/src/scripts/git/openPr.ts

@@ -0,0 +1,21 @@
+import shell from "shelljs";
+import { log } from "./log";
+import { getRepo } from "./getRepo";
+
+export const openPr = (sourceBranch: string, destinationBranch: string) => {
+  const repo = getRepo();
+
+  const link = [
+    "https://bitbucket.org/pezak/",
+    repo,
+    "/pull-requests/new?",
+    `source=${sourceBranch}`,
+    "&",
+    `dest=${destinationBranch}`,
+  ].join("");
+
+  log.verbose("Open PR Link:", link);
+  log.error("Har: This command does not work for the moment.");
+
+  // shell.open(link);
+};

package/src/scripts/git/remoteStatus.ts

@@ -0,0 +1,28 @@
+import { getCmdOutput } from 'src/scripts/cmd';
+import { log } from './log';
+
+export type RemoteStatus =
+  | 'up-to-date'
+  | 'need-to-pull'
+  | 'need-to-push'
+  | 'diverged';
+
+export const remoteStatus = (branch = '@', upstream = '@{u}'): RemoteStatus => {
+  const local = getCmdOutput(`git rev-parse ${branch}`);
+  const remote = getCmdOutput(`git rev-parse ${upstream}`);
+  const base = getCmdOutput(`git merge-base ${branch} ${upstream}`);
+
+  log.verbose('remoteStatus:', { local, remote, base });
+
+  if (local === remote) {
+    return 'up-to-date';
+  }
+  if (local === base) {
+    return 'need-to-pull';
+  }
+  if (remote === base) {
+    return 'need-to-push';
+  }
+
+  return 'diverged';
+};

package/src/scripts/git/tag/createTag.ts

@@ -0,0 +1,28 @@
+import { executeCmd } from '../../cmd';
+
+export interface TagCreateOptions {
+  /**
+   * The object that the new tag will refer to, usually a commit.
+   * Defaults to HEAD.
+   */
+  object?: string;
+
+  /**
+   * Replace an existing tag with the given name (instead of failing)
+   */
+  force?: boolean;
+}
+
+/**
+ * Create a new annotated tag. Doesn't push it to the remote.
+ * @param name The name of the tag to create.
+ * @param object The object that the new tag will refer to, usually a commit. Defaults to HEAD.
+ */
+export const createTag = (name: string, options: TagCreateOptions = {}) => {
+  const { object = '', force } = options;
+  executeCmd(`git tag ${name} ${object}`, {
+    force,
+    annotate: true,
+    message: '',
+  });
+};

package/src/scripts/git/tag/deleteTag.ts

@@ -0,0 +1,11 @@
+import { executeCmd } from 'src/scripts/cmd';
+import { log } from '../log';
+
+export const deleteTag = (name: string) => {
+  log.verbose('Deleting tag locally and from remote:', name);
+
+  executeCmd('git tag', {
+    d: name,
+  });
+  executeCmd(`git push origin :${name}`);
+};

package/src/scripts/git/tag/getTags.ts

@@ -0,0 +1,6 @@
+import { getCmdOutput } from '../../cmd';
+
+export const getTags = (): string[] =>
+  getCmdOutput('git tag', { list: true })
+    .split('\n')
+    .map((t) => t.trim());

package/src/scripts/git/tag/pushAllTags.ts

@@ -0,0 +1,6 @@
+import { executeCmd } from 'src/scripts/cmd';
+
+export const pushAllTags = (remote = 'origin') =>
+  executeCmd(`git push ${remote}`, {
+    tags: true,
+  });

package/src/scripts/git/tag/renameTag.ts

@@ -0,0 +1,12 @@
+import { log } from '../log';
+import { createTag } from './createTag';
+import { deleteTag } from './deleteTag';
+
+export const renameTag = (oldTagName: string, newTagName: string) => {
+  log.verbose('Renaming tag ', oldTagName, ' -> ', newTagName);
+
+  createTag(newTagName, {
+    object: `${oldTagName}^{}`,
+  });
+  deleteTag(oldTagName);
+};

package/src/scripts/lerna/changed.ts

@@ -0,0 +1,11 @@
+import { getCmdOutput } from '../cmd';
+import type { LernaPackage } from './types';
+
+export const changed = (): LernaPackage[] => {
+  const jsonResult = getCmdOutput('npx lerna changed --json');
+  if (!jsonResult) {
+    return [];
+  }
+  const result = JSON.parse(jsonResult) as LernaPackage[];
+  return result;
+};

package/src/scripts/lerna/constants.ts

@@ -0,0 +1,6 @@
+export const lernaJson = "lerna.json";
+
+export const INDEPENDENT_VERSION = "independent";
+
+export const packagesDir = "packages";
+export const packagesPrefix = "@pezak/";