feat: improved logging, writing of debug.log file. ES Module export. Improved Types. (#11)

Author: gr2m

README.md

@@ -7,19 +7,20 @@
 ## Usage
 
 ```
-$ octoherd [script] [repos...]
+$ octoherd.js [script] [repos...]
 
 Positionals:
   script  Path to your *.js script
-  repos   One or multiple arrays in the form of 'repo-owner/repo-name'
-                                                                   [default: []]
+  repos   One or multiple arrays in the form of 'repo-owner/repo-name'.
+          'repo-owner/*' will find all repositories for one owner. '*' will find
+          all repositories the user has access to                  [default: []]
 
 Options:
-  --help     Show help                                                 [boolean]
-  --version  Show version number                                       [boolean]
-  --token    Requires the "public_repo" scope for public repositories, "repo"
-             scope for private repositories.                 [string] [required]
-  --cache    Cache responses for debugging            [boolean] [default: false]
+  --help            Show help                                          [boolean]
+  --version         Show version number                                [boolean]
+  --octoherd-token  Requires the "public_repo" scope for public repositories,
+                    "repo" scope for private repositories.   [string] [required]
+  --octoherd-cache  Cache responses for debugging     [boolean] [default: false]
 ```
 
 The `script` must export a `script` function which takes three parameters:

bin/octoherd.js

@@ -1,37 +1,44 @@
 #!/usr/bin/env node
 
-const yargs = require("yargs");
+import yargs from "yargs";
 
-const octoherd = require("..");
+import { octoherd } from "../index.js";
 
-var argv = yargs
+const argv = yargs
   .usage("Usage: $0 [options] [script] [repos...]")
   .example(
     "$0 --token 0123456789012345678901234567890123456789 octokit/rest.js"
   )
   .command("$0 [script] [repos...]", "", (yargs) => {
     yargs.positional("script", {
       demandOption: true,
-      describe: "Path to your *.js script",
+      describe: "Path to *.js script. Must be an ES Module.",
     });
     yargs.positional("repos", {
       demandOption: true,
-      describe: "One or multiple arrays in the form of 'repo-owner/repo-name'",
+      describe:
+        "One or multiple arrays in the form of 'repo-owner/repo-name'. 'repo-owner/*' will find all repositories for one owner. '*' will find all repositories the user has access to",
       default: [],
     });
   })
-  .option("token", {
+  .option("octoherd-token", {
     description:
       'Requires the "public_repo" scope for public repositories, "repo" scope for private repositories.',
     demandOption: true,
     type: "string",
   })
-  .option("cache", {
+  .option("octoherd-cache", {
     description: "Cache responses for debugging",
     type: "boolean",
     default: false,
   })
   .epilog("copyright 2020").argv;
 
-const { _, $0, ...options } = argv;
-octoherd(options).catch(console.error);
+const { _, $0, script, repos, ...options } = argv;
+
+octoherd({ ...options, octoherdScript: script, octoherdRepos: repos }).catch(
+  (error) => {
+    console.error(error);
+    process.exit(1);
+  }
+);

index.d.ts

@@ -1,84 +1,110 @@
-module.exports = octoherd;
+import { resolve } from "path";
+import { appendFileSync } from "fs";
 
-const { resolve } = require("path");
+import { Octokit } from "@octoherd/octokit";
+import chalk from "chalk";
+import tempy from "tempy";
 
-const { Octokit: OctokitCore } = require("@octokit/core");
-const { paginateRest } = require("@octokit/plugin-paginate-rest");
-const { throttling } = require("@octokit/plugin-throttling");
-const { retry } = require("@octokit/plugin-retry");
-const pino = require("pino");
+import { cache as octokitCachePlugin } from "./lib/octokit-plugin-cache.js";
+import { resolveRepositories } from "./lib/resolve-repositories.js";
+import { VERSION } from "./version.js";
 
-const { cache: octokitCachePlugin } = require("./lib/octokit-plugin-cache");
-const { resolveRepositories } = require("./lib/resolve-repositories");
-const { name, version } = require("./package.json");
-
-const logger = pino();
-const Octokit = OctokitCore.plugin(paginateRest, throttling, retry).defaults({
-  log: {
-    debug: logger.debug.bind(logger),
-    info: logger.info.bind(logger),
-    warn: logger.warn.bind(logger),
-    error: logger.error.bind(logger),
-  },
-  userAgent: [name, version].join("/"),
-  throttle: {
-    onAbuseLimit: (error, options, octokit) => {
-      octokit.log.error("onAbuseLimit", error, options);
-    },
-    onRateLimit: (error, options, octokit) => {
-      octokit.log.error("onRateLimit", error, options);
-    },
-  },
-});
+const levelColor = {
+  debug: chalk.bgGray.black,
+  info: chalk.bgGreen.black,
+  warn: chalk.bgYellow.black,
+  error: chalk.bgRed.white.bold,
+};
 
 /**
  * Find all releases in a GitHub repository or organization after a specified date
  *
  * @param {object} options
- * @param {string} options.token Personal Access Token: Requires the "public_repo" scope for public repositories, "repo" scope for private repositories.
- * @param {string} options.script Path to script to run against a repository
- * @param {string} options.repos Array of repository names in the form of "repo-owner/repo-name". To match all repositories for an owner, pass "repo-owner/*"
- * @param {boolean} options.cache Cache responses for debugging
+ * @param {string} options.octoherdToken Personal Access Token: Requires the "public_repo" scope for public repositories, "repo" scope for private repositories.
+ * @param {string} options.octoherdScript Path to script to run against a repository
+ * @param {string} options.octoherdCache Array of repository names in the form of "repo-owner/repo-name". To match all repositories for an owner, pass "repo-owner/*"
+ * @param {boolean} options.octoherdRepos Cache responses for debugging
  */
-async function octoherd(
+export async function octoherd(
   options = {
-    cache: false,
-    repos: [],
+    octoherdCache: false,
+    octoherdRepos: [],
   }
 ) {
-  const { token, script, repos, cache, ...userOptions } = options;
-  const MyOctokit = cache ? Octokit.plugin(octokitCachePlugin) : Octokit;
-  const octokit = new MyOctokit({
-    auth: token,
+  const {
+    octoherdToken,
+    octoherdScript,
+    octoherdCache,
+    octoherdRepos,
+    ...userOptions
+  } = options;
+  const tmpLogFile = tempy.file({ extension: "ndjson.log" });
+
+  const CliOctokit = octoherdCache
+    ? Octokit.plugin(octokitCachePlugin)
+    : Octokit;
+  const octokit = new CliOctokit({
+    auth: octoherdToken,
+    userAgent: ["octoherd-cli", VERSION].join("/"),
+    octoherd: {
+      debug: true,
+      onLogMessage(level, message, additionalData) {
+        console.log(
+          levelColor[level](" " + level.toUpperCase() + " "),
+          Object.keys(additionalData).length
+            ? `${message} ${chalk.gray(JSON.stringify(additionalData))}`
+            : message
+        );
+      },
+      onLogData(data) {
+        appendFileSync(tmpLogFile, JSON.stringify(data));
+      },
+    },
   });
 
   let userScript;
-  const path = resolve(process.cwd(), script);
+  const path = resolve(process.cwd(), octoherdScript);
+
   try {
-    userScript = require(path).script;
+    userScript = (await import(path)).script;
   } catch (error) {
-    throw new Error(`[octoherd] ${script} script could not be found`);
+    throw new Error(`[octoherd] ${octoherdScript} script could not be found`);
   }
 
   if (!userScript) {
     throw new Error(`[octoherd] no "script" exported at ${path}`);
   }
 
-  if (repos.length === 0) {
+  if (octoherdCache.length === 0) {
     throw new Error("[octoherd] No repositories provided");
   }
 
-  state = {
+  const state = {
     log: console,
     octokit,
   };
 
-  const repositories = await resolveRepositories(state, repos);
+  try {
+    const repositories = await resolveRepositories(state, octoherdRepos);
 
-  for (const repository of repositories) {
-    octokit.log.info("Running %s on %s...", script, repository.full_name);
-    await userScript(octokit, repository, userOptions);
-  }
+    for (const repository of repositories) {
+      octokit.log.info(
+        "Running %s on %s...",
+        octoherdScript,
+        repository.full_name
+      );
+      await userScript(octokit, repository, userOptions);
+    }
 
-  octokit.log.info("done");
+    console.log("");
+    console.log(levelColor.info(" DONE "), `Log file written to ${tmpLogFile}`);
+  } catch (error) {
+    octokit.log.error(error);
+    console.log("");
+    console.log(
+      levelColor.error(" DONE "),
+      `Log file written to ${tmpLogFile}`
+    );
+    process.exit(1);
+  }
 }

index.js

@@ -1,12 +1,10 @@
-module.exports = { cache };
+import { URL } from "url";
+import { dirname } from "path";
 
-const { URL } = require("url");
-const { dirname } = require("path");
+import mkdirp from "mkdirp";
+import jsonfile from "jsonfile";
 
-const mkdirp = require("mkdirp");
-const { readFileSync, writeFileSync } = require("jsonfile");
-
-function cache(octokit) {
+export function cache(octokit) {
   octokit.hook.wrap("request", async (request, options) => {
     if (options.method !== "GET") {
       return request(options);
@@ -19,12 +17,12 @@ function cache(octokit) {
     const cachePath = `./cache${pathname}${page ? `-page-${page}` : ""}.json`;
 
     try {
-      return readFileSync(cachePath);
+      return jsonfile.readFileSync(cachePath);
     } catch (error) {
       const response = await request(options);
 
       mkdirp.sync(dirname(cachePath));
-      writeFileSync(cachePath, response);
+      jsonfile.writeFileSync(cachePath, response);
       return response;
     }
   });

lib/octokit-plugin-cache.js

@@ -1,6 +1,4 @@
-module.exports = { resolveRepositories };
-
-async function resolveRepositories(state, repositories) {
+export async function resolveRepositories(state, repositories) {
   const invalidRepositories = repositories.filter((fullName) => {
     /^[a-z0-9_.-]+\/([a-z0-9_.-]+|\*)$/i.test(fullName);
   });