Refactored and reorganized the code, in preparation for expsing it as a CLI and NPM package in addition to a GitHub Action

Author: JamesMessinger

dist/index.js

@@ -0,0 +1,55 @@
+import { debug, getInput, setFailed, setOutput } from "@actions/core";
+import { npmPublish } from "../npm-publish";
+import { Options } from "../options";
+
+/**
+ * The main entry point of the GitHub Action
+ * @internal
+ */
+async function main(): Promise<void> {
+  try {
+    // Setup global error handlers
+    process.on("uncaughtException", errorHandler);
+    process.on("unhandledRejection", errorHandler);
+
+    // Get the GitHub Actions input options
+    const options: Options = {
+      token: getInput("token", { required: true }),
+      registry: getInput("registry", { required: true }),
+      package: getInput("package", { required: true }),
+      checkVersion: getInput("check-version", { required: true }).toLowerCase() === "true",
+      debug,
+    };
+
+    // Puglish to NPM
+    let results = await npmPublish(options);
+
+    // tslint:disable: no-console
+    if (results.type === "none") {
+      console.log(`\n📦 ${results.package} v${results.version} is already published to NPM`);
+    }
+    else {
+      console.log(`\n📦 Successfully published ${results.package} v${results.version} to NPM`);
+    }
+
+    // Set the GitHub Actions output variables
+    setOutput("type", results.type);
+    setOutput("version", results.version);
+    setOutput("old-version", results.oldVersion);
+  }
+  catch (error) {
+    errorHandler(error as Error);
+  }
+}
+
+/**
+ * Prints errors to the GitHub Actions console
+ */
+function errorHandler(error: Error): void {
+  let message = error.stack || error.message || String(error);
+  setFailed(message);
+  process.exit();
+}
+
+// tslint:disable-next-line: no-floating-promises
+main();

dist/index.js.map

@@ -0,0 +1,32 @@
+import { URL } from "url";
+import { Debug, Options } from "./options";
+
+/**
+ * Normalized and sanitized options
+ * @internal
+ */
+export interface NormalizedOptions {
+  token: string;
+  registry: URL;
+  package: string;
+  checkVersion: boolean;
+  quiet: boolean;
+  debug: Debug;
+}
+
+/**
+ * Normalizes and sanitizes options, and fills-in any default values.
+ * @internal
+ */
+export function normalizeOptions(options: Options): NormalizedOptions {
+  let registryURL = typeof options.registry === "string" ? new URL(options.registry) : options.registry;
+
+  return {
+    token: options.token || "",
+    registry: registryURL || new URL("https://registry.npmjs.org/"),
+    package: options.package || "./package.json",
+    checkVersion: options.checkVersion === undefined ? true : Boolean(options.checkVersion),
+    quiet: options.quiet || false,
+    debug: options.debug || (() => undefined),
+  };
+}

src/action/index.ts

@@ -1,33 +1,31 @@
-import { debug } from "@actions/core";
 import * as ezSpawn from "ez-spawn";
 import { promises as fs } from "fs";
 import { ono } from "ono";
 import { EOL } from "os";
 import { dirname } from "path";
-import { URL } from "url";
-import { Options } from "./options";
+import { NormalizedOptions } from "./normalize-options";
 
 /**
  * Sets/updates the NPM config based on the options.
+ * @internal
  */
-export async function setNpmConfig(options: Options): Promise<void> {
+export async function setNpmConfig(options: NormalizedOptions): Promise<void> {
   // Read the current NPM config
-  let configPath = await getNpmConfigPath();
-  let config = await readNpmConfig(configPath);
+  let configPath = await getNpmConfigPath(options);
+  let config = await readNpmConfig(configPath, options);
 
   // Update the config
   config = updateConfig(config, options);
 
   // Save the new config
-  await writeNpmConfig(configPath, config);
+  await writeNpmConfig(configPath, config, options);
 }
 
 
 /**
  * Updates the given NPM config with the specified options.
  */
-function updateConfig(config: string, options: Options): string {
-  let registry = new URL(options.registry);
+function updateConfig(config: string, { registry, debug }: NormalizedOptions): string {
   let authDomain = registry.origin.slice(registry.protocol.length);
 
   let lines = config.split(/\r?\n/);
@@ -51,7 +49,7 @@ function updateConfig(config: string, options: Options): string {
 /**
  * Gets the path of the NPM config file.
  */
-async function getNpmConfigPath(): Promise<string> {
+async function getNpmConfigPath({ debug }: NormalizedOptions): Promise<string> {
   try {
     debug(`Running command: npm config get userconfig`);
 
@@ -67,7 +65,7 @@ async function getNpmConfigPath(): Promise<string> {
 /**
  * Reads the NPM config file.
  */
-async function readNpmConfig(configPath: string): Promise<string> {
+async function readNpmConfig(configPath: string, { debug }: NormalizedOptions): Promise<string> {
   try {
     debug(`Reading NPM config from ${configPath}`);
 
@@ -90,7 +88,7 @@ async function readNpmConfig(configPath: string): Promise<string> {
 /**
  * Writes the NPM config file.
  */
-async function writeNpmConfig(configPath: string, config: string): Promise<void> {
+async function writeNpmConfig(configPath: string, config: string, { debug }: NormalizedOptions): Promise<void> {
   try {
     debug(`Writing new NPM config to ${configPath}`);
 

src/normalize-options.ts

@@ -1,38 +1,35 @@
-// tslint:disable: no-console
-import { debug } from "@actions/core";
 import * as semver from "semver";
+import { normalizeOptions } from "./normalize-options";
 import { npm } from "./npm";
 import { Options } from "./options";
 import { readManifest } from "./read-manifest";
 import { Results } from "./results";
 
 /**
- * Publishes an package to NPM, if its version has changed
+ * Publishes a package to NPM, if its version has changed
  */
-export async function publishToNPM(options: Options): Promise<Results> {
+export async function npmPublish(opts: Options = {}): Promise<Results> {
+  let options = normalizeOptions(opts);
+
   // Get the old and new version numbers
-  let manifest = await readManifest(options.package);
-  let publishedVersion = await npm.getLatestVersion(manifest.name);
+  let manifest = await readManifest(options.package, options.debug);
+  let publishedVersion = await npm.getLatestVersion(manifest.name, options);
 
   // Determine if/how the version has changed
   let diff = semver.diff(manifest.version, publishedVersion);
 
   if (diff || !options.checkVersion) {
     // Publish the new version to NPM
     await npm.publish(manifest, options);
-
-    console.log(`\n📦 Successfully published ${manifest.name} v${manifest.version} to NPM`);
-  }
-  else {
-    console.log(`\n📦 ${manifest.name} v${publishedVersion} is already published to NPM`);
   }
 
   let results: Results = {
+    package: manifest.name,
     type: diff || "none",
     version: manifest.version.raw,
     oldVersion: publishedVersion.raw,
   };
 
-  debug(`OUTPUT: \n${JSON.stringify(results, undefined, 2)}`);
+  options.debug(`OUTPUT: \n${JSON.stringify(results, undefined, 2)}`);
   return results;
 }

src/npm-config.ts

@@ -1,20 +1,20 @@
-import { debug } from "@actions/core";
 import * as ezSpawn from "ez-spawn";
 import { ono } from "ono";
 import { dirname, resolve } from "path";
 import { SemVer } from "semver";
+import { NormalizedOptions } from "./normalize-options";
 import { setNpmConfig } from "./npm-config";
-import { Options } from "./options";
 import { Manifest } from "./read-manifest";
 
 /**
  * Runs NPM commands.
+ * @internal
  */
 export const npm = {
   /**
    * Gets the latest published version of the specified package.
    */
-  async getLatestVersion(name: string): Promise<SemVer> {
+  async getLatestVersion(name: string, { debug }: NormalizedOptions): Promise<SemVer> {
     try {
       debug(`Running command: npm view ${name} version`);
 
@@ -37,12 +37,12 @@ export const npm = {
   /**
    * Publishes the specified package to NPM
    */
-  async publish({ name, version }: Manifest, options: Options): Promise<void> {
+  async publish({ name, version }: Manifest, options: NormalizedOptions): Promise<void> {
     // Update the NPM config with the specified registry and token
     await setNpmConfig(options);
 
     try {
-      debug(`Running command: npm publish`);
+      options.debug(`Running command: npm publish`);
 
       // Run NPM to publish the package
       await ezSpawn.async("npm", ["publish"], {

src/publish-to-npm.ts src/npm-publish.tssrc/publish-to-npm.ts renamed to src/npm-publish.ts

@@ -1,25 +1,52 @@
+import { URL } from "url";
+
 /**
  * Options that determine how/whether the package is published.
  */
 export interface Options {
   /**
    * The NPM access token to use when publishing
    */
-  token: string;
+  token?: string;
 
   /**
    * The NPM registry URL to use.
+   *
+   * Defaults to "https://registry.npmjs.org/"
    */
-  registry: string;
+  registry?: string | URL;
 
   /**
    * The absolute or relative path of your package.json file.
+   *
+   * Defaults to "./package.json"
    */
-  package: string;
+  package?: string;
 
   /**
    * If set to `true`, then the package will only be published if the version number
    * in package.json differs from the latest on NPM.
+   *
+   * Defaults to `true`
+   */
+  checkVersion?: boolean;
+
+  /**
+   * Suppress console output from NPM and npm-publish
+   *
+   * Defaults to `false`
+   */
+  quiet?: boolean;
+
+  /**
+   * A function to call to log debug messages.
+   *
+   * Defaults to a no-op function
    */
-  checkVersion: boolean;
+  debug?: Debug;
 }
+
+/**
+ * A function that receives debug messages
+ */
+export type Debug = (message: string) => void;

src/npm.ts

@@ -1,11 +1,12 @@
-import { debug } from "@actions/core";
 import { promises as fs } from "fs";
 import { ono } from "ono";
 import { resolve } from "path";
 import { SemVer } from "semver";
+import { Debug } from "./options";
 
 /**
  * A package manifest (package.json)
+ * @internal
  */
 export interface Manifest {
   name: string;
@@ -14,9 +15,10 @@ export interface Manifest {
 
 /**
  * Reads the package manifest (package.json) and returns its parsed contents
+ * @internal
  */
-export async function readManifest(path: string): Promise<Manifest> {
-  debug(`Reading package manifest from ${resolve(path)}`);
+export async function readManifest(path: string, debug?: Debug): Promise<Manifest> {
+  debug && debug(`Reading package manifest from ${resolve(path)}`);
   let json: string;
 
   try {
@@ -38,7 +40,7 @@ export async function readManifest(path: string): Promise<Manifest> {
       version: new SemVer(version as string),
     };
 
-    debug(`MANIFEST: \n${JSON.stringify(manifest, undefined, 2)}`);
+    debug && debug(`MANIFEST: \n${JSON.stringify(manifest, undefined, 2)}`);
     return manifest;
   }
   catch (error) {

src/options.ts

@@ -1,5 +1,7 @@
 import { ReleaseType } from "semver";
 
+export { ReleaseType };
+
 /**
  * Results of the `publish
  */
@@ -9,6 +11,11 @@ export interface Results {
    */
   type: ReleaseType | "none";
 
+  /**
+   * The name of the NPM package that was published
+   */
+  package: string;
+
   /**
    * The version that was published
    */