@n42/cli 0.2.42 → 0.2.72

package/src/validator.js

@@ -0,0 +1,286 @@
+const fs = require("fs");
+const path = require("path");
+const { DOMParser, XMLSerializer } = require("xmldom");
+const xpath = require("xpath");
+const { NODE42_DIR, VALIDATOR_URL, EP_VALIDATE, VALIDATIONS_DIR } = require("./config");
+const { startSpinner } = require("./utils");
+const { fetchWithAuth } = require("./auth");
+const { handleError } = require("./errors");
+const C = require("./colors");
+
+const infoAssertions = [
+   {
+    identifier: "INFO-SENDER",
+    flag: "INFO1",
+    location: "/sbdh:StandardBusinessDocumentHeader/sbdh:Sender/sbdh:Identifier",
+    text: "Sender participant identifier"
+  },
+  {
+    identifier: "INFO-RECEIVER",
+    flag: "INFO2",
+    location: "/sbdh:StandardBusinessDocumentHeader/sbdh:Receiver/sbdh:Identifier",
+    text: "Receiver participant identifier"
+  },
+  {
+    identifier: "INFO-DOC-STANDARD",
+    flag: "INFO1",
+    location: "/sbdh:StandardBusinessDocumentHeader/sbdh:DocumentIdentification/sbdh:Standard",
+    text: "UBL document standard"
+  },
+  {
+    identifier: "INFO-DOC-ID",
+    flag: "INFO2",
+    location: "/sbdh:StandardBusinessDocumentHeader/sbdh:DocumentIdentification/sbdh:InstanceIdentifier",
+    text: "UBL document identifier"
+  },
+  {
+    identifier: "INFO-DOC-CREATION-DATE",
+    flag: "INFO1",
+    location: "/sbdh:StandardBusinessDocumentHeader/sbdh:DocumentIdentification/sbdh:CreationDateAndTime",
+    text: "UBL document creation date"
+  },
+  {
+    identifier: "INFO-DOCUMENTID",
+    flag: "INFO0",
+    location: "/sbdh:StandardBusinessDocumentHeader/sbdh:BusinessScope/sbdh:Scope[sbdh:Type='DOCUMENTID']/sbdh:InstanceIdentifier",
+    text: "Document Identifier (Peppol Document ID)"
+  },
+  {
+    identifier: "INFO-PROCESSID",
+    flag: "INFO0",
+    location: "/sbdh:StandardBusinessDocumentHeader/sbdh:BusinessScope/sbdh:Scope[sbdh:Type='PROCESSID']/sbdh:InstanceIdentifier",
+    text: "Peppol Business Process Identifier"
+  },
+  {
+    identifier: "INFO-COUNTRY",
+    flag: "INFO0",
+    location: "/sbdh:StandardBusinessDocumentHeader/sbdh:BusinessScope/sbdh:Scope[sbdh:Type='COUNTRY_C1']/sbdh:InstanceIdentifier",
+    text: "Country code used for routing (C1)"
+  }
+];
+
+function wrapXml(docName, refId, xml) {
+  let html;
+
+  const now = new Date();
+  const timeText = now.toLocaleTimeString([], {
+    hour: "2-digit",
+    minute: "2-digit"
+  });
+
+  const templateFile = path.join(NODE42_DIR, "assets/validator.html.template");
+  const template = fs.readFileSync(templateFile, "utf8");
+  
+  html = template.replace("<!-- XML -->", xml);
+  html = html.replace("<!-- TIME -->", `${timeText}  •  ${docName}`);
+  html = html.replace("/--UUID--/", refId);
+  
+  const htmlFile = path.join(VALIDATIONS_DIR, `validation.html`);
+  fs.writeFileSync(htmlFile, html);
+  return htmlFile;
+}
+
+function parseXml(xmlString) {
+  const parser = new DOMParser();
+  const doc = parser.parseFromString(xmlString, "application/xml");
+
+  const errors = doc.getElementsByTagName("parsererror");
+  if (errors.length > 0) {
+    throw new Error("Invalid XML");
+  }
+  return doc;
+}
+
+function normalizeLocation(path) {
+  // already normalized → do NOTHING
+  if (path.includes("local-name()")) {
+    return path;
+  }
+
+  const parts = path.split("/").filter(Boolean);
+  if (!parts.length) return "";
+
+  return parts.reduce((xp, part, i) => {
+    // split "Name[predicate]" into base + predicateText
+    const base = part.split("[")[0];                 // e.g. "Scope" or "ubl:Invoice"
+    const baseName = base.includes(":") ? base.split(":")[1] : base;
+
+    // collect predicates: [1] and [x:Type='DOCUMENTID']
+    const preds = [...part.matchAll(/\[([^\]]+)\]/g)].map(m => m[1]);
+
+    let cond = `local-name()='${baseName}'`;
+    let pos = "";
+
+    for (const p of preds) {
+      // positional: [1]
+      if (/^\d+$/.test(p)) {
+        pos = `[${p}]`;
+        continue;
+      }
+      // typed predicate: [sbdh:Type='DOCUMENTID']
+      const m = p.match(/^[A-Za-z0-9_-]+:([A-Za-z0-9_-]+)\s*=\s*'([^']*)'$/);
+      if (m) {
+        const [, childName, value] = m;
+        cond += ` and *[local-name()='${childName}']='${value}'`;
+      }
+    }
+
+    const step = `*[${cond}]${pos}`;
+    return xp + (i === 0 ? `//${step}` : `/${step}`);
+  }, "");
+}
+
+function serializeHighlightedXml(doc) {
+  const serializer = new XMLSerializer();
+  let xml = serializer.serializeToString(doc);
+
+  xml = xml
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;");
+
+  xml = xml.replace(
+    /(&lt;[^&\n>]*data-highlight="true"[^&\n>]*&gt;[\s\S]*?&lt;\/[^&\n>]+&gt;)/g,
+    m => {
+      const level = /data-level="(INFO0|INFO1|INFO2|ERROR|WARNING)"/.exec(m)?.[1] || "WARNING";
+      const msg = /data-msg="([^"]+)"/.exec(m)?.[1] || "";
+
+      // REMOVE helper attributes from output
+      const cleaned = m
+      .replace(/\sdata-highlight="true"/g, "")
+      .replace(/\sdata-level="[^"]*"/g, "")
+      .replace(/\sdata-msg="[^"]*"/g, "");
+      
+      return `<span class="xml-${level.toLowerCase()}" title="${msg}">${cleaned}</span>`;
+    }
+  );
+
+  return xml;
+}
+
+function highlightByAssertions(xmlString, assertions) {
+  const doc = parseXml(xmlString);
+
+  assertions.forEach(a => {
+    const xp = normalizeLocation(a.location);
+    if (!xp) return;
+
+    const nodes = xpath.select(xp, doc);
+
+    for (const n of nodes) {
+      n.setAttribute("data-highlight", "true");
+      n.setAttribute("data-level", a.flag); // ERROR | WARNING
+      n.setAttribute("data-msg", a.text);   // validator message
+    }
+  });
+
+  return serializeHighlightedXml(doc);
+}
+
+function highligtAssertions(docName, validationReport, xml) {
+   const assertions = [
+    ...infoAssertions,
+    ...(validationReport?.sections?.flatMap(s => s.assertions || []) ?? [])
+  ];
+  //console.log(assertions);
+
+  const refId = crypto.randomUUID();
+
+  const formattedXml = highlightByAssertions(xml, assertions);
+  return wrapXml(docName, refId, formattedXml)
+}
+
+function handleValidationReport(artefactFile, report) {
+  const seen = new Set();
+
+  const counts = (report?.sections ?? [])
+    .flatMap(s =>
+      (s.assertions ?? []).map(a => ({
+        ...a,
+        configuration: s.configuration
+      }))
+    )
+    .filter(a => {
+      const key = `${a.configuration}:${a.identifier}`;
+      if (seen.has(key)) return false;
+      seen.add(key);
+      return true;
+    })
+    .reduce((acc, a) => {
+      if (a.flag === "ERROR") acc.error++;
+      else if (a.flag === "WARNING") acc.warning++;
+      return acc;
+    }, { error: 0, warning: 0 });
+
+  let title = `${C.BOLD}Validation Result${C.RESET}\n\n`;
+  let message = "";
+  let color = `${C.BOLD}`;
+  let tip;
+
+  if (counts.error !== 0 && counts.warning !== 0) {
+    message += `The validator found ${counts.error} error(s) and ${counts.warning} warnings.`;
+    color =  `${C.RED}`;
+    tip = `Review and correct the assertions highlighted,\nthen revalidate before sending.`
+  }
+  else if (counts.error !== 0) {
+    message += `The validator found ${counts.error} error(s).`;
+    color =  `${C.RED}`;
+    tip = `Review and correct the assertions highlighted,\nthen revalidate before sending.`
+  }
+  else if (counts.warning !== 0) {
+    message += `The validator found ${counts.warning} warning(s).`;
+    color =  `${C.YELLOW}`;
+    tip = `Review and correct the assertions highlighted,\nthen revalidate before sending.`
+  }
+  else {
+    message += "The validation completed without any assertions.";
+    tip = "The document has passed validation and is ready to be sent."
+  }
+
+  const link = `\u001B]8;;file://${artefactFile}\u0007View\u001B]8;;\u0007`;
+  console.log(`${title}${color}${message}${C.RESET} ${C.BLUE}[${link}]${C.RESET}\n\n${tip}\n`);
+}
+
+async function runValidation(docName, xmlDoc, options) {
+  const {
+    ruleset,
+    location,
+    runtime,
+  } = options;
+ 
+  const stopSpinner = startSpinner();
+
+  const url = new URL(`${VALIDATOR_URL}/${EP_VALIDATE}`);
+  url.search = new URLSearchParams({
+    ruleset,
+    ...(location && { location: "true" }),
+    ...(runtime && { runtime: "true" }),
+  }).toString();
+
+  const res = await fetchWithAuth(url.toString(), {
+      method: "POST",
+      headers: {
+          "Content-Type": "application/xml"
+      },
+      body: xmlDoc
+  });
+
+  if (!res.ok) {
+    const err = await res.json();
+    stopSpinner();
+
+    if (err.code) {
+      await handleError(err);
+    }
+
+    process.exit(1);
+  }
+
+  const validationReport = await res.json();
+  stopSpinner();
+
+  const artefactFile = highligtAssertions(docName, validationReport, xmlDoc);
+  handleValidationReport(artefactFile, validationReport);
+}
+
+module.exports = { runValidation };

package/test/asserts/validate_tests.js

@@ -0,0 +1,28 @@
+const { execSync } = require("child_process");
+
+function run(cmd) {
+  console.log(`> ${cmd}`);
+  return execSync(cmd, { stdio: "pipe" }).toString();
+}
+
+// detect global vs local
+const CLI = process.env.N42_GLOBAL ? "n42" : "npx n42";
+
+try {
+  // 1. binary exists
+  const version = run(`${CLI} --version`);
+  if (!version.trim()) throw new Error("No version output");
+
+  // 2. help works
+  run(`${CLI} help`);
+
+  // 3. command tree exists
+  run(`${CLI} validate --help`);
+  run(`${CLI} discover --help`);
+
+  console.log("CLI validation OK");
+} catch (err) {
+  console.error("CLI validation FAILED");
+  console.error(err.message);
+  process.exit(1);
+}

package/test/cli.test.js

@@ -0,0 +1,83 @@
+const { expect } = require("chai");
+const sinon = require("sinon");
+
+describe("CLI", () => {
+  let login, logout, runDiscovery;
+
+  beforeEach(() => {
+    sinon.restore();
+
+    // stub process.exit so tests don’t quit
+    sinon.stub(process, "exit").callsFake(() => {
+      throw new Error("process.exit");
+    });
+
+    // stub handlers
+    login = sinon.stub().resolves();
+    logout = sinon.stub().resolves();
+    runDiscovery = sinon.stub();
+
+    // stub requires BEFORE loading CLI
+    sinon.stub(require("../src/auth"), "login").callsFake(login);
+    sinon.stub(require("../src/auth"), "logout").callsFake(logout);
+    sinon.stub(require("../src/discover"), "runDiscovery").callsFake(runDiscovery);
+  });
+
+  afterEach(() => {
+    sinon.restore();
+    delete require.cache[require.resolve("../src/cli")];
+  });
+
+  it("runs login command", async () => {
+    process.argv = ["node", "n42", "login"];
+
+    require("../src/cli");
+
+    expect(login.calledOnce).to.be.true;
+  });
+
+  it("runs logout command", async () => {
+    process.argv = ["node", "n42", "logout"];
+
+    require("../src/cli");
+
+    expect(logout.calledOnce).to.be.true;
+  });
+
+  it("runs peppol discovery", () => {
+    process.argv = [
+      "node",
+      "n42",
+      "discover",
+      "peppol",
+      "9915:123456789",
+      "--env",
+      "TEST"
+    ];
+
+    require("../src/cli");
+
+    expect(runDiscovery.calledOnce).to.be.true;
+    expect(runDiscovery.firstCall.args[0]).to.equal("9915:123456789");
+  });
+
+  it("exits on invalid env", () => {
+    process.argv = [
+      "node",
+      "n42",
+      "discover",
+      "peppol",
+      "9915:123456789",
+      "--env",
+      "INVALID"
+    ];
+
+    try {
+      require("../src/cli");
+    } catch (e) {
+      // expected
+    }
+
+    expect(process.exit.called).to.be.true;
+  });
+});

package/test/discover.test.js

@@ -0,0 +1,112 @@
+const { expect } = require("chai");
+const sinon = require("sinon");
+const fs = require("fs");
+const path = require("path");
+
+describe("runDiscovery()", () => {
+  let runDiscovery;
+  let auth, user, utils, errors, db, config;
+
+  beforeEach(() => {
+    sinon.restore();
+
+    // ---- load modules FIRST ----
+    auth = require("../src/auth");
+    user = require("../src/user");
+    utils = require("../src/utils");
+    errors = require("../src/errors");
+    db = require("../src/db");
+    config = require("../src/config");
+
+    // ---- stub config constants ----
+    sinon.stub(config, "ARTEFACTS_DIR").value("/tmp/node42-artefacts");
+    sinon.stub(config, "NODE42_DIR").value("/tmp/node42");
+    sinon.stub(config, "API_URL").value("https://api.example.com");
+    sinon.stub(config, "EP_DISCOVER").value("discover");
+
+    // ---- fs ----
+    const realRead = fs.readFileSync;
+    sinon.stub(fs, "writeFileSync");
+    sinon.stub(fs, "readFileSync").callsFake((file, enc) => {
+      if (file.includes("wrapper.html.template")) {
+        return "<!-- SVG --><!-- TIME -->/--UUID--/";
+      }
+      return realRead(file, enc);
+    });
+
+    // ---- utils ----
+    sinon.stub(utils, "startSpinner").returns(() => {});
+    sinon.stub(utils, "getShortId").returns("abc123");
+    sinon.stub(utils, "getArtefactExt").returns("json");
+    sinon.stub(utils, "buildDocLabel");
+    sinon.stub(utils, "promptForDocument").resolves(null);
+
+    // ---- auth ----
+    sinon.stub(auth, "fetchWithAuth").resolves({
+      ok: true,
+      headers: {
+        get: (k) => ({
+          "X-Node42-RefId": "ref-123",
+          "X-Node42-ServiceUsage": "1",
+          "X-Node42-RateLimit": "100/100",
+          "X-Node42-Documents": null
+        }[k])
+      },
+      json: async () => ({ result: "ok" })
+    });
+
+    // ---- user ----
+    sinon.stub(user, "getUserWithIndex").returns({ id: "1" });
+    sinon.stub(user, "setUserUsage");
+
+    // ---- db ----
+    sinon.stub(db, "insert");
+
+    sinon.stub(console, "log");
+
+    // ---- require AFTER stubbing ----
+    delete require.cache[require.resolve("../src/discover")];
+    runDiscovery = require("../src/discover").runDiscovery;
+  });
+
+  afterEach(() => sinon.restore());
+
+  it("runs discovery and writes json artefact", async () => {
+    await runDiscovery("9915:test", {
+      env: "TEST",
+      output: "json",
+      format: "json"
+    });
+
+    expect(auth.fetchWithAuth.calledOnce).to.be.true;
+    expect(db.insert.calledOnce).to.be.true;
+    expect(fs.writeFileSync.called).to.be.true;
+    expect(user.setUserUsage.calledOnce).to.be.true;
+  });
+
+  it("handles API error response", async () => {
+    sinon.restore();
+
+    // stub error path BEFORE require
+    const auth = require("../src/auth");
+    const errors = require("../src/errors");
+
+    sinon.stub(auth, "fetchWithAuth").resolves({
+        ok: false,
+        json: async () => ({ code: "N42E-5000", message: "fail" })
+    });
+
+    sinon.stub(errors, "handleError");
+    sinon.stub(process, "exit").throws(new Error("exit"));
+
+    delete require.cache[require.resolve("../src/discover")];
+    const runDiscovery = require("../src/discover").runDiscovery;
+
+    try {
+        await runDiscovery("9915:test", { env: "TEST" });
+    } catch {}
+
+    expect(errors.handleError.calledOnce).to.be.true;
+    expect(process.exit.calledOnce).to.be.true;
+  });
+});

package/test/errors.test.js

@@ -0,0 +1,61 @@
+const { expect } = require("chai");
+const sinon = require("sinon");
+
+const config = require("../src/config");
+const { handleError } = require("../src/errors");
+
+describe("handleError()", () => {
+  let errorStub;
+
+  beforeEach(() => {
+    sinon.restore();
+    sinon.stub(console, "error");
+    errorStub = sinon.stub(config, "WWW_URL").value("https://example.com");
+  });
+
+  afterEach(() => {
+    sinon.restore();
+  });
+
+  it("prints formatted error with code and message", () => {
+    handleError({
+      code: "N42E-5101",
+      message: "Rate limit exceeded"
+    });
+
+    expect(console.error.called).to.be.true;
+    expect(console.error.firstCall.args[0]).to.include("Error: 5101");
+    expect(console.error.firstCall.args[0]).to.include("Rate limit exceeded");
+    expect(console.error.firstCall.args[0]).to.include("View details");
+  });
+
+  it("prints error without message using documentation fallback", () => {
+    handleError({
+      code: "N42E-9032"
+    });
+
+    expect(console.error.called).to.be.true;
+    expect(console.error.firstCall.args[0]).to.include("Error: 9032");
+    expect(console.error.firstCall.args[0]).to.include("For details, see the documentation");
+  });
+
+  it("handles error without N42E prefix", () => {
+    handleError({
+      code: "UNKNOWN",
+      message: "Something failed"
+    });
+
+    expect(console.error.called).to.be.true;
+    expect(console.error.firstCall.args[0]).to.include("Error:");
+    expect(console.error.firstCall.args[0]).to.include("Something failed");
+  });
+
+  it("handles error without code", () => {
+    handleError({
+      message: "Generic failure"
+    });
+
+    expect(console.error.called).to.be.true;
+    expect(console.error.firstCall.args[0]).to.include("Generic failure");
+  });
+});

package/test/user.test.js

@@ -0,0 +1,103 @@
+const { expect } = require("chai");
+const sinon = require("sinon");
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+
+const db = require("../src/db");
+
+const TEST_DB = path.join(os.tmpdir(), "test-db-user.json");
+
+describe("user", () => {
+  let user;
+
+  beforeEach(() => {
+    sinon.restore();
+
+    db.setSource(TEST_DB);
+    if (fs.existsSync(TEST_DB)) fs.unlinkSync(TEST_DB);
+
+    // fresh require
+    delete require.cache[require.resolve("../src/user")];
+    user = require("../src/user");
+  });
+
+  afterEach(() => {
+    sinon.restore();
+    if (fs.existsSync(TEST_DB)) fs.unlinkSync(TEST_DB);
+  });
+
+  it("returns default user when index does not exist", () => {
+    const u = user.getUserWithIndex(0);
+
+    expect(u.id).to.equal("n/a");
+    expect(u.userName).to.equal("n/a");
+  });
+
+  it("returns user by index when present", () => {
+    db.save({
+      user: [{
+        id: "1",
+        userName: "User",
+        userMail: "user@test.com",
+        role: "user"
+      }]
+    });
+
+    const u = user.getUserWithIndex(0);
+    expect(u.id).to.equal("1");
+  });
+
+  it("returns user by id when present", () => {
+    db.save({
+      user: [{
+        id: "1",
+        userName: "User",
+        userMail: "user@test.com",
+        role: "user"
+      }]
+    });
+
+    const u = user.getUserWithId("1");
+    expect(u.userMail).to.equal("user@test.com");
+  });
+
+  it("returns default user when id is missing", () => {
+    const u = user.getUserWithId("missing");
+    expect(u.id).to.equal("n/a");
+  });
+
+  it("returns undefined usage when none exists", () => {
+    db.save({
+      user: [{
+        id: "1",
+        serviceUsage: {}
+      }]
+    });
+
+    const usage = user.getUserUsage("1", "discovery", "2026-02");
+    expect(usage).to.be.undefined;
+  });
+
+  it("sets and retrieves service usage", () => {
+    db.save({
+      user: [{
+        id: "1",
+        serviceUsage: {}
+      }]
+    });
+
+    user.setUserUsage("1", "discovery", "2026-02", 5);
+
+    const usage = user.getUserUsage("1", "discovery", "2026-02");
+    expect(usage).to.equal(5);
+  });
+
+  it("does nothing when setting usage for missing user", () => {
+    const spy = sinon.spy(db, "save");
+
+    user.setUserUsage("missing", "discovery", "2026-02", 5);
+
+    expect(spy.called).to.be.false;
+  });
+});