@gluhar/cli 3.0.1 → 3.0.2

package/src/commands/index.ts

@@ -0,0 +1,21 @@
+import build from "./build";
+import deinstall from "./deinstall";
+import deploy from "./deploy";
+import generate from "./generate";
+import reinstall from "./reinstall";
+import release from "./release";
+import version from "./version";
+import upgrade from "./upgrade";
+import dev from "./dev";
+
+export default [
+  deploy,
+  version,
+  release,
+  build,
+  deinstall,
+  reinstall,
+  generate,
+  upgrade,
+  dev,
+];

package/src/commands/reinstall/ReinstallOptions.ts

@@ -0,0 +1,3 @@
+export interface ReinstallOptions {
+  packages?: boolean;
+}

package/src/commands/reinstall/index.ts

@@ -0,0 +1,11 @@
+import { Command } from "commander";
+import { reinstall } from "./reinstall";
+
+export default new Command()
+  .name("reinstall")
+  .description("Reinstall npm dependencies with a fresh package-lock.json.")
+  .option(
+    "-p, --packages",
+    "Reinstall dependencies in when using multiple packages (monorepo)."
+  )
+  .action(reinstall);

package/src/commands/reinstall/log.ts

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

package/src/commands/reinstall/reinstall.ts

@@ -0,0 +1,13 @@
+import { executeCmd } from "src/scripts/cmd";
+import { ReinstallOptions } from "./ReinstallOptions";
+import { log } from "./log";
+import { deinstall } from "../deinstall/deinstall";
+
+export const reinstall = (options: ReinstallOptions) => {
+  // Run deinstall first
+  deinstall(options);
+
+  // Install dependencies
+  log.info("Reinstalling packages.");
+  executeCmd("npm install");
+};

package/src/commands/release/ReleaseOptions.ts

@@ -0,0 +1,8 @@
+export interface ReleaseOptions {
+  pre: boolean | string;
+  dev: boolean;
+  directory: string;
+  yes: boolean;
+  version: boolean;
+  gitTag: boolean | string;
+}

package/src/commands/release/index.ts

@@ -0,0 +1,40 @@
+import { Command } from "commander";
+import { release } from "./release";
+import { pattern } from "./tag";
+
+export default new Command()
+  .name("release")
+  .description("Release and publish packages to the npm registry.")
+  .option(
+    "-y, --yes",
+    "When run with this flag, we will skip all confirmation prompts. NOTE does not currently work.",
+    false
+  )
+  .option(
+    "--pre [id]",
+    "Prerelease identifier. Use this when releasing a prerelease version.",
+    false
+  )
+  .option(
+    "-d, --dev",
+    "Release a dev version. This is a shorthand for a prerelease with a 'dev' identifier.",
+    false
+  )
+  .option(
+    "--dir, --directory <path>",
+    "Subdirectory to publish. Must apply to ALL packages, and MUST contain a package.json file.",
+    "dist"
+  )
+  .option("--no-version", "Disable versioning and changelog gen.")
+  .option(
+    "--git-tag [tag]",
+    [
+      "Create and push git tag(s). Optionally provide a template.",
+      "Template placeholders:",
+      `"${pattern.fullPackageName}" (full package name, e.g. "@gluhar/cli"),`,
+      `"${pattern.shortPackageName}" (short package name, e.g. "cli"),`,
+      `"${pattern.version}" (released package version, e.g. "1.2.3").`,
+      `When set to "true" defaults to: "${pattern.default.independent}" for independent versioning and "${pattern.default.fixed}" for fixed.`,
+    ].join("\n")
+  )
+  .action(release);

package/src/commands/release/log.ts

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

package/src/commands/release/publish.ts

@@ -0,0 +1,18 @@
+import { lerna } from "src/scripts/lerna";
+import type { ReleaseOptions } from "./ReleaseOptions";
+import { log } from "./log";
+import { getPreid } from "../version/getPreid";
+
+export const publish = (options: ReleaseOptions) => {
+  const { yes, pre, dev, directory } = options;
+
+  const distTag = dev ? "dev" : getPreid(pre) ?? "latest";
+  log.info("Dist tag:", distTag);
+  log.info("Directory:", directory);
+
+  lerna.publish({
+    distTag,
+    contents: directory,
+    yes,
+  });
+};

package/src/commands/release/release.ts

@@ -0,0 +1,24 @@
+import { version } from "../version/version";
+import type { ReleaseOptions } from "./ReleaseOptions";
+import { log } from "./log";
+import { publish } from "./publish";
+import { tag } from "./tag";
+
+export const release = async (options: ReleaseOptions) => {
+  log.info("Initiating release...");
+  const { pre, dev, yes } = options;
+  if (yes) log.info("and saying yes to all prompts.");
+
+  if (options.version)
+    await version({
+      pre,
+      dev,
+      yes,
+      changelog: !dev,
+      commit: "chore: Releasing gluhar packages.",
+    });
+
+  publish(options);
+
+  await tag(options);
+};

package/src/commands/release/tag.ts

@@ -0,0 +1,119 @@
+import { lerna } from "src/scripts/lerna";
+import { INDEPENDENT_VERSION } from "src/scripts/lerna/constants";
+import { git } from "src/scripts/git";
+import { confirmQuestion } from "src/utils";
+import type { ReleaseOptions } from "./ReleaseOptions";
+import { log } from "./log";
+
+export const pattern = {
+  /** e.g. `@gluhar/cli` */
+  fullPackageName: "%f",
+  /** e.g. `cli` */
+  shortPackageName: "%s",
+  /** e.g. `1.2.3` */
+  version: "%v",
+  default: {
+    /** e.g. `cli/v1.2.3` */
+    independent: "%f@%v",
+    /** e.g. `v1.2.3` */
+    fixed: "v%v",
+  },
+};
+
+const getGitTagPattern = (
+  gitTag: ReleaseOptions["gitTag"],
+  isIndependent: boolean
+) => {
+  if (typeof gitTag === "string") {
+    return gitTag;
+  }
+
+  if (!gitTag) {
+    return null;
+  }
+
+  return isIndependent ? pattern.default.independent : pattern.default.fixed;
+};
+
+export interface PackageInfo {
+  /** Required for independent versioning. */
+  name?: string;
+  version: string;
+}
+
+export const parsePattern = (tagPattern: string, pkg: PackageInfo): string => {
+  const { name: fullName, version } = pkg;
+  const placeholders: { pattern: string; value: string }[] = [
+    {
+      pattern: pattern.version,
+      value: version,
+    },
+  ];
+
+  if (fullName) {
+    const shortName = fullName.substring(fullName.indexOf("/") + 1);
+    placeholders.push({
+      pattern: pattern.fullPackageName,
+      value: fullName,
+    });
+    placeholders.push({
+      pattern: pattern.shortPackageName,
+      value: shortName,
+    });
+  }
+
+  return placeholders.reduce(
+    (t, ph) => t.replaceAll(ph.pattern, ph.value),
+    tagPattern
+  );
+};
+
+export const tag = async (options: ReleaseOptions) => {
+  const { gitTag, yes } = options;
+  if (!gitTag) {
+    return;
+  }
+
+  const lernaConfig = lerna.getConfig();
+  const isIndependent =
+    !!lernaConfig && lernaConfig.version === INDEPENDENT_VERSION;
+
+  const tagPattern = getGitTagPattern(gitTag, isIndependent);
+  if (!tagPattern) {
+    return;
+  }
+
+  const tags = new Set<string>();
+
+  if (
+    !lernaConfig ||
+    isIndependent ||
+    tagPattern.includes(pattern.fullPackageName) ||
+    tagPattern.includes(pattern.shortPackageName)
+  ) {
+    lerna
+      .changed()
+      .filter((pkg) => !pkg.private)
+      .map((pkg) => parsePattern(tagPattern, pkg))
+      .forEach((t) => tags.add(t));
+  } else {
+    const t = parsePattern(tagPattern, { version: lernaConfig.version });
+    tags.add(t);
+  }
+
+  const tagList = [...tags].map((t) => `\n - ${t}`).join("");
+  log.verbose("Tags to create:", tagList);
+
+  const confirm = await confirmQuestion(
+    `Create and push tag(s): ${tagList}. Confirm?`,
+    yes
+  );
+
+  if (confirm) {
+    tags.forEach((t) => {
+      git.tag.create(t);
+    });
+
+    git.tag.pushAll();
+  }
+};

package/src/commands/upgrade/UpgradeOptions.ts

@@ -0,0 +1,3 @@
+export interface UpgradeOptions {
+  upgrade: boolean;
+}

package/src/commands/upgrade/index.ts

@@ -0,0 +1,10 @@
+import { Command } from "commander";
+import { upgrade } from "./upgrade";
+
+export default new Command()
+  .name("upgrade")
+  .description(
+    "Upgrade all gluhar dependencies in a project to their latest versions."
+  )
+  .option("-b, --upgrade", "A boolean option.")
+  .action(upgrade);

package/src/commands/upgrade/log.ts

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

package/src/commands/upgrade/upgrade.ts

@@ -0,0 +1,10 @@
+import { executeCmd } from "src/scripts/cmd";
+import { UpgradeOptions } from "./UpgradeOptions";
+import { log } from "./log";
+
+export const upgrade = (options: UpgradeOptions) => {
+  log.info("Upgrading gluhar dependencies.");
+
+  // Upgrade all gluhar dependencies in a project to their latest versions.
+  executeCmd("npm update @gluhar/cli @gluhar/app");
+};

package/src/commands/version/VersionOptions.ts

@@ -0,0 +1,7 @@
+export interface VersionOptions {
+  pre: boolean | string;
+  dev: boolean;
+  changelog: boolean;
+  commit: boolean | string;
+  yes?: boolean;
+}

package/src/commands/version/getPreid.ts

@@ -0,0 +1,7 @@
+export const getPreid = (pre: boolean | string) => {
+  if (typeof pre === 'string') {
+    return pre;
+  }
+
+  return pre ? 'beta' : undefined;
+};

package/src/commands/version/index.ts

@@ -0,0 +1,18 @@
+import { Command } from "commander";
+import { version } from "./version";
+
+export default new Command()
+  .name("version")
+  .description("Update package versions and generate change logs.")
+  .option(
+    "--pre [id]",
+    "Prerelease identifier. Use this when creating a prerelease versioning.",
+    false
+  )
+  .option(
+    "-d, --dev",
+    "Release a dev version. This is a shorthand for a prerelease with a 'dev' identifier."
+  )
+  .option("--no-changelog", "Disable generating changelogs.")
+  .option("-c, --commit [msg]", "Commit changes in git.", false)
+  .action(version);

package/src/commands/version/log.ts

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

package/src/commands/version/pimpChangelogs.ts

@@ -0,0 +1,43 @@
+import { log } from "./log";
+import { glob } from "glob";
+import { join } from "path";
+import { readFileSync, writeFileSync } from "fs";
+import { capitalize } from "src/utils/common";
+
+export const pimpChangelogs = async () => {
+  log.info("Pimping changelogs");
+
+  const g = join("packages", "**", "CHANGELOG.md");
+  const filePaths = await glob(g);
+
+  const changelogs = filePaths.map((fp) => {
+    const changelog = readFileSync(fp).toString();
+
+    const lines = changelog.split("\n").map((line) => {
+      if (line.substring(0, 2) === "* ") {
+        if (line.substring(0, 4) === "* **")
+          return `- ${line.substring(2).split("** ").map(capitalize).join("** ")}`;
+
+        return `- ${capitalize(line.substring(2))}`;
+      }
+
+      if (line.includes("**Note:**"))
+        return line.replace("**Note:**", "**📝 Note:**");
+
+      if (line.substring(0, 4) === "### ")
+        return line
+          .replace("### Features", "### 🚀 Enhancements")
+          .replace("### Bug Fixes", "### 🩹 Fixes")
+          .replace("### Chore", "### 🏡 Chore")
+          .replace("### Performance Improvements", "### 🔥 Performance");
+
+      return line;
+    });
+
+    return lines.join("\n");
+  });
+
+  await filePaths.forEach((file, idx) => {
+    writeFileSync(file, changelogs[idx]);
+  });
+};

package/src/commands/version/version.ts

@@ -0,0 +1,33 @@
+import { lerna } from "src/scripts/lerna";
+import { git } from "src/scripts/git";
+import type { VersionOptions } from "./VersionOptions";
+import { log } from "./log";
+import { getPreid } from "./getPreid";
+import { pimpChangelogs } from "./pimpChangelogs";
+
+export const version = async (options: VersionOptions) => {
+  const { pre, dev, changelog, commit, yes } = options;
+
+  lerna.version({
+    conventionalCommits: true,
+    conventionalGraduate: (!dev && !pre) || undefined,
+    conventionalPrerelease: !!dev || !!pre || undefined,
+    preid: dev ? "dev" : getPreid(pre),
+    includeMergedTags: true,
+    gitTagVersion: false,
+    private: false,
+    push: false,
+    changelog,
+    yes,
+  });
+
+  if (changelog) await pimpChangelogs();
+
+  if (commit) {
+    log.info("Commit changes.");
+    const msg = commit === true ? "chore: Prepare Release" : commit;
+    git.commit({
+      m: msg,
+    });
+  }
+};

package/src/constants.ts

@@ -0,0 +1,5 @@
+import { bin, version } from "../package.json";
+
+export const PROGRAM_NAME = Object.keys(bin)[0];
+export const VERSION = version;
+export const CONFIG_FILE = `${PROGRAM_NAME}.json`;

package/src/index.ts

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+import { program } from "commander";
+import { PROGRAM_NAME, VERSION } from "./constants";
+import commands from "./commands";
+import { preAction } from "./preAction";
+
+program
+  .name(PROGRAM_NAME)
+  .description(
+    "A collection of commands and scripts for helping running, building, deploying and assisting in developing with Gluhar, Vue, Nuxt, Tailwind & Sanity."
+  )
+  .version(VERSION, "-v, --version", "Output the version number.")
+  .helpOption("-h, --help", "Display help for a command.")
+  .option("-l, --log-level <level>", "Set log level.", "info")
+  .option("-lp, --log-prefix <prefixes...>", "Set log prefixes.")
+  .option("--ci", "Enable CI mode. Full logging and no prompts.", false)
+  .option("--cwd <path>", "The current working directory for the scripts.")
+  .usage("<command> [options]")
+  .hook("preAction", preAction)
+  .action(() => program.outputHelp());
+
+commands.forEach((cmd) => program.addCommand(cmd));
+
+program.parse(process.argv);

package/src/preAction.ts

@@ -0,0 +1,93 @@
+import { existsSync } from "fs";
+import type { Command } from "commander";
+import { confirmQuestion, init, logger } from "./utils";
+import type { GlobalOptions } from "./GlobalOptions";
+import { cmd, executeCmd, getCmdOutput } from "./scripts/cmd";
+import { PROGRAM_NAME, VERSION } from "./constants";
+import { git } from "./scripts/git";
+// import { getConfigOpt, setConfigOpt } from './config';
+
+const getOptions = <T>(command: Command) => command.opts() as T;
+const log = logger("cli");
+
+// const loadConfig = (rootCmd: Command, actionCmd: Command) => {
+//   const config = getConfigOpt(actionCmd.name());
+//   setConfigOpt(config, rootCmd, actionCmd);
+// };
+
+const setupCi = (rootCmd: Command, actionCmd: Command) => {
+  const { ci } = getOptions<GlobalOptions>(rootCmd);
+  const ciSource = rootCmd.getOptionValueSource("ci") ?? "implied";
+
+  if (ci) {
+    rootCmd.setOptionValueWithSource("yes", true, ciSource);
+    actionCmd.setOptionValueWithSource("yes", true, ciSource);
+    rootCmd.setOptionValueWithSource("logLevel", "verbose", ciSource);
+    rootCmd.setOptionValueWithSource("logPrefix", undefined, ciSource);
+  }
+};
+
+const setupLogging = (rootCmd: Command) => {
+  const { logLevel, logPrefix } = getOptions<GlobalOptions>(rootCmd);
+  init(PROGRAM_NAME, logLevel, logPrefix);
+};
+
+const setup = (rootCmd: Command, actionCmd: Command) => {
+  setupCi(rootCmd, actionCmd);
+  setupLogging(rootCmd);
+};
+
+const logCli = (actionCmd: Command) => {
+  log.notice(`v${VERSION}`);
+
+  log.verbose("Calling command:", actionCmd.name());
+  log.verbose("arguments:", actionCmd.args);
+  log.verbose("options:", getOptions(actionCmd));
+  log.verbose("cwd:", process.cwd());
+};
+
+const checkCliVersion = async () => {
+  const hasGit = existsSync(".git");
+  if (hasGit && git.getRepo() === "gluhar") return;
+
+  const latestVersion = getCmdOutput("npm show @gluhar/cli version");
+
+  // Version is up to date
+  if (latestVersion === VERSION) return;
+
+  // Version is old, ask to install latest
+  const installLatest = await confirmQuestion(
+    `There is a newer version of the gluhar/cli available (v${latestVersion}). \nDo you want to install it now? (npm i -g @gluhar/cli)`
+  );
+  if (installLatest) {
+    executeCmd("npm i -g @gluhar/cli@latest");
+
+    // If we are in a project, also update the local version
+    const isLocal = !getCmdOutput("npm list @gluhar/cli --depth=0").includes(
+      "empty"
+    );
+    if (isLocal) executeCmd("npm update @gluhar/cli");
+  }
+};
+
+export const preAction = async (rootCmd: Command, actionCmd: Command) => {
+  // setup logging before loadConfig, so we can get logging from loadConfig
+  setup(rootCmd, actionCmd);
+
+  const { cwd: initCwd } = getOptions<GlobalOptions>(rootCmd);
+  if (initCwd) cmd.cd(initCwd);
+
+  // Check for newer cli version
+  await checkCliVersion();
+
+  // loadConfig(rootCmd, actionCmd);
+
+  const { cwd: newCwd } = getOptions<GlobalOptions>(rootCmd);
+  if (newCwd && newCwd !== initCwd) cmd.cd(newCwd);
+
+  // setup logging after loadConfig so we apply options from config
+  setup(rootCmd, actionCmd);
+
+  logCli(actionCmd);
+  if (initCwd) log.notice("from", initCwd);
+};

package/src/scripts/cmd/cd.ts

@@ -0,0 +1,9 @@
+import shell from 'shelljs';
+import { log } from './log';
+
+export const cd = (path: string) => {
+  const oldDir = process.cwd();
+  shell.cd(path);
+  const newDir = process.cwd();
+  log.verbose(`cd ${path}: ${oldDir} -> ${newDir}`);
+};

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

@@ -1,10 +1,20 @@
-import type { Args } from './types';
-/**
- * Function that executes a bash script file in the same console from a given relative path. Can pass arguments/flags to the script.
- * @param path A path to a bash script file, relative to one directory up: 'lerna/bootstrap'.
- * @param args Option flags to pass to the script: { m: 'Message', msg: 'asdf' }.
- * @param absolute Flag if you are providing an absolute path.
- * @returns Executes the bash script file in the same stdio.
- */
-export declare const executeBash: (path: string, args?: Args, absolute?: boolean) => import("child_process").SpawnSyncReturns<Buffer>;
-//# sourceMappingURL=executeBash.d.ts.map
+import { spawnSync } from 'child_process';
+import { parseBashArgs } from './parseBashArgs';
+import type { Args } from './types';
+
+/**
+ * Function that executes a bash script file in the same console from a given relative path. Can pass arguments/flags to the script.
+ * @param path A path to a bash script file, relative to one directory up: 'lerna/bootstrap'.
+ * @param args Option flags to pass to the script: { m: 'Message', msg: 'asdf' }.
+ * @param absolute Flag if you are providing an absolute path.
+ * @returns Executes the bash script file in the same stdio.
+ */
+export const executeBash = (path: string, args?: Args, absolute?: boolean) => {
+  const bashArgs = parseBashArgs(path, args, absolute);
+
+  // TODO make stdio configurable
+  // TODO make an async option
+  return spawnSync('bash', bashArgs, {
+    stdio: 'inherit',
+  });
+};

package/src/scripts/cmd/executeCmd.ts

@@ -0,0 +1,23 @@
+import { spawnSync } from 'child_process';
+import { log } from './log';
+import type { Args } from './types';
+import { parseArgs } from './parseArgs';
+
+/**
+ * Function that executes a bash script from string.
+ * @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 Executes the bash script in the same stdio.
+ */
+export const executeCmd = (cmd: string, args?: Args) => {
+  const cmdArgs = [cmd];
+  if (args) {
+    cmdArgs.push(...parseArgs(args));
+  }
+
+  const fullCmd = cmdArgs.join(' ');
+  log.verbose('executeCmd:', fullCmd);
+  return spawnSync(fullCmd, { stdio: 'inherit', shell: true });
+};
+
+// TODO make an async option

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

@@ -1,10 +1,23 @@
-import type { Args } from './types';
-/**
- * Function that executes a bash script file from a given relative path  and returns the output. Can pass arguments/flags to the script.
- * @param cmd A path to a bash script file, relative to one directory up: 'lerna/bootstrap'.
- * @param options Option flags to pass to the script: { m: 'Message', msg: 'asdf' }.
- * @param absolute Flag if you are providing an absolute path.
- * @returns The output of the bash file script as a string.
- */
-export declare const getBashOutput: (path: string, args?: Args, absolute?: boolean) => string;
-//# sourceMappingURL=getBashOutput.d.ts.map
+import { log } from './log';
+import { parseBashArgs } from './parseBashArgs';
+import { getCmdOutput } from './getCmdOutput';
+import type { Args } from './types';
+
+/**
+ * Function that executes a bash script file from a given relative path  and returns the output. Can pass arguments/flags to the script.
+ * @param cmd A path to a bash script file, relative to one directory up: 'lerna/bootstrap'.
+ * @param options Option flags to pass to the script: { m: 'Message', msg: 'asdf' }.
+ * @param absolute Flag if you are providing an absolute path.
+ * @returns The output of the bash file script as a string.
+ */
+export const getBashOutput = (
+  path: string,
+  args?: Args,
+  absolute?: boolean,
+) => {
+  log.verbose('getBashOutput:', args);
+
+  const bashArgs = parseBashArgs(path, args, absolute).join(' ');
+
+  return getCmdOutput(`bash ${bashArgs}`);
+};