saturn-core-cli 0.0.8 → 0.0.10

package/commands/publish.js

@@ -15,29 +15,41 @@ const SATURN_API_TOKEN =
 var exec = require("child-process-promise").exec;
 var spawn = require("child-process-promise").spawn;
 const semverInc = require("semver/functions/inc");
-
-try {
-  exemptions = require(saturnignore);
-} catch (e) {
-  exemptions = [];
-}
+const { buildChangelog } = require("../lib/changelog");
 
 async function action(release = "patch", options) {
   try {
-    let message = options["message"];
+    try {
+      exemptions = (await import(saturnignore)).default;
+    } catch (e) {
+      console.log(e.message, e);
+      exemptions = [];
+    }
     const packageObj = await fs.readJson(`package.json`);
-    //if (version == undefined) {
-    //let version = packageObj.version;
-    //}
+    console.log("Exemptions", exemptions);
     let version = semverInc(packageObj.version, release);
-    packageObj.version = version;
-    await fs.writeJson(`package.json`, packageObj, { spaces: 2 });
+    if (!version) {
+      throw new Error(`Invalid release type "${release}"`);
+    }
+    let changelog = options.changelog
+      ? await buildChangelog(packageObj.version)
+      : "";
+    let description = [options.message, changelog].filter(Boolean).join("\n\n");
+    // The map checksums package.json, so the bump must land first; a dry run leaves it alone.
+    if (!options.dry) {
+      packageObj.version = version;
+      await fs.writeJson(`package.json`, packageObj, { spaces: 2 });
+    }
     let map = await new mapper({ exemptions: exemptions }).createMap("./");
+    console.log("MAP", map);
     if (options.dry) {
+      console.log(`DESCRIPTION for ${version}\n${description}`);
       return;
     }
+
     let core = await getCoreId(packageObj.saturn.core);
-    await createInstance(map, core.id, version, message);
+    await createInstance(map, core.id, version, description);
+    console.log("DONE");
     await doGitAdd();
     await doGitCommit("SC Publish");
     await doGitPush();
@@ -206,7 +218,7 @@ async function createInstance(map, core, version, message) {
     );
     return response.data.data;
   } catch (e) {
-    console.log("ERROR", e.message);
+    console.log("ERROR", e.message, e);
   }
 }
 
@@ -215,8 +227,9 @@ function command(prog) {
   program = prog;
   program
     .command("publish [release]", { isDefault: true })
-    .option("-d, --dry <template>", "Dry Run", false)
-    .option("-m, --message", "Description of the update", "")
+    .option("-d, --dry", "Dry run: print the map and description without publishing", false)
+    .option("-m, --message <text>", "Description of the update", "")
+    .option("--no-changelog", "Leave the commit changelog out of the description")
     .description("Publish Saturn Version")
     .action(action);
 }

package/lib/changelog.js

@@ -0,0 +1,114 @@
+var execFile = require("child-process-promise").execFile;
+
+// Saturn Instance descriptions are stored by the manager; keep them to a readable size.
+const MAX_LENGTH = 20000;
+const MAX_LISTED_FILES = 10;
+const PUBLISH_SUBJECT = /^"?SC Publish"?$/;
+const TRAILER = /^(Co-Authored-By|Signed-off-by):/i;
+
+async function git(args) {
+  let result = await execFile("git", args, { maxBuffer: 10 * 1024 * 1024 });
+  return result.stdout;
+}
+
+async function tagExists(tag) {
+  try {
+    await git(["rev-parse", "-q", "--verify", `refs/tags/${tag}`]);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+async function resolveBaseTag(previousVersion) {
+  if (previousVersion && (await tagExists(previousVersion))) {
+    return previousVersion;
+  }
+  try {
+    return (await git(["describe", "--tags", "--abbrev=0"])).trim();
+  } catch (e) {
+    return null;
+  }
+}
+
+async function readCommits(base) {
+  let output = await git([
+    "log",
+    "--no-merges",
+    "--reverse",
+    "--format=%h%x1f%s%x1f%b%x1e",
+    `${base}..HEAD`,
+  ]);
+  return output
+    .split("\x1e")
+    .map((record) => record.replace(/^\n/, ""))
+    .filter((record) => record.trim())
+    .map((record) => {
+      let [hash, subject, body = ""] = record.split("\x1f");
+      return { hash, subject: subject.trim(), body };
+    })
+    .filter((commit) => !PUBLISH_SUBJECT.test(commit.subject));
+}
+
+function formatCommit(commit) {
+  let lines = commit.body.split("\n").filter((line) => !TRAILER.test(line.trim()));
+  while (lines.length && !lines[lines.length - 1].trim()) {
+    lines.pop();
+  }
+  while (lines.length && !lines[0].trim()) {
+    lines.shift();
+  }
+  let body = lines.map((line) => (line.trim() ? `  ${line}` : "")).join("\n");
+  return body ? `- ${commit.subject}\n${body}` : `- ${commit.subject}`;
+}
+
+async function uncommittedFiles() {
+  let output = await git(["status", "--porcelain"]);
+  return output
+    .split("\n")
+    .filter((line) => line.trim())
+    .map((line) => line.slice(3).split(" -> ").pop().replace(/^"|"$/g, ""))
+    .filter((file) => file !== "package.json");
+}
+
+function formatUncommitted(files) {
+  let listed = files.slice(0, MAX_LISTED_FILES).join(", ");
+  let more = files.length > MAX_LISTED_FILES ? ` +${files.length - MAX_LISTED_FILES} more` : "";
+  return `- Uncommitted changes in: ${listed}${more}`;
+}
+
+/**
+ * Builds markdown release notes from the commits since the previous published tag, for the
+ * Saturn Instance description. Returns "" when there is no tag to compare against.
+ */
+async function buildChangelog(previousVersion) {
+  let base = await resolveBaseTag(previousVersion);
+  if (!base) {
+    console.log("No previous git tag found, skipping changelog");
+    return "";
+  }
+
+  let entries = (await readCommits(base)).map(formatCommit);
+  let files = await uncommittedFiles();
+  if (files.length) {
+    entries.push(formatUncommitted(files));
+  }
+
+  let kept = [];
+  let length = 0;
+  for (let entry of entries) {
+    if (length + entry.length > MAX_LENGTH) {
+      break;
+    }
+    kept.push(entry);
+    length += entry.length + 1;
+  }
+  if (kept.length < entries.length) {
+    kept.push(`…and ${entries.length - kept.length} more commits`);
+  }
+  return kept.join("\n");
+}
+
+module.exports = {
+  buildChangelog: buildChangelog,
+};

package/mapper.js

@@ -2,23 +2,54 @@ let klawSync = require("klaw-sync");
 let _ = require("lodash");
 let path = require("path");
 let crypto = require("crypto");
-let fs = require("fs");
+let fs = require("graceful-fs");
 
 let exemptions = [];
 let dir_path = ".";
 
+/* function generateChecksum(file) {
+  return new Promise(function (resolve, reject) {
+    try {
+      var hash = crypto.createHash("md5");
+      var stream = fs.createReadStream(file);
+      stream.on("data", function (data) {
+        hash.update(data);
+      });
+      stream.on("end", function () {
+        var sha = hash.digest("hex");
+        resolve(sha);
+      });
+    } catch (e) {
+      reject(e);
+    }
+  });
+} */
 function generateChecksum(file) {
   return new Promise(function (resolve, reject) {
     try {
       var hash = crypto.createHash("md5");
       var stream = fs.createReadStream(file);
+
       stream.on("data", function (data) {
         hash.update(data);
       });
+
+      // Listen for the 'end' event to finish the hash calculation
       stream.on("end", function () {
         var sha = hash.digest("hex");
+        stream.close(); // Manually close the stream (if necessary)
         resolve(sha);
       });
+
+      // Listen for the 'close' event to ensure resources are released
+      stream.on("close", function () {
+        // console.log(`Stream for ${file} closed`);
+      });
+
+      // Handle errors
+      stream.on("error", function (error) {
+        reject(error);
+      });
     } catch (e) {
       reject(e);
     }
@@ -28,7 +59,9 @@ function generateChecksum(file) {
 function isExemptedDirectory(item) {
   let file = _.last(item.path.split(dir_path + "/"));
   let included = _.includes(
-    _.map(exemptions, (exem) => _.startsWith(file, exem)),
+    _.map(exemptions, (exem) => {
+      return _.startsWith(file, exem);
+    }),
     true
   );
   return !included;
@@ -49,10 +82,10 @@ module.exports = class Mapper {
       return _.groupBy(
         await Promise.all(
           files.map(async function (file) {
+            //console.log("Mapping::", file.path);
             return {
               file: _.last(file.path.split(dir_path + "/")),
               size: file.stats.size,
-
               checksum: await generateChecksum(file.path),
               creation_date: file.stats.birthtime,
             };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "saturn-core-cli",
-  "version": "0.0.8",
+  "version": "0.0.10",
   "description": "Saturn Core CLI",
   "main": "index.js",
   "scripts": {
@@ -21,6 +21,7 @@
     "colors": "^1.4.0",
     "commander": "^11.1.0",
     "fs-extra": "^11.1.1",
+    "graceful-fs": "^4.2.11",
     "klaw-sync": "^6.0.0",
     "lodash": "^4.17.21",
     "pluralize": "^8.0.0",