@n42/cli 0.1.42 → 0.1.63

package/src/db.js

@@ -0,0 +1,157 @@
+const fs = require("fs");
+const path = require("path");
+
+const config = require("./config");
+let DATABASE_FILE = config.DATABASE_FILE;
+let artefactIndex = null;
+
+function setSource(p) {
+  DATABASE_FILE = p;
+}
+
+function load() {
+  if (!fs.existsSync(DATABASE_FILE)) return { 
+    user: [],
+    artefacts: [],
+    usage: [], 
+  };
+  return JSON.parse(fs.readFileSync(DATABASE_FILE, "utf8"));
+}
+
+function save(database) {
+  invalidateArtefactIndex();
+
+  const dir = path.dirname(DATABASE_FILE);
+  fs.mkdirSync(dir, { recursive: true });
+
+  const tmp = DATABASE_FILE + ".tmp";
+
+  // always write tmp
+  fs.writeFileSync(tmp, JSON.stringify(database, null, 2), "utf8");
+
+  try { fs.renameSync(tmp, DATABASE_FILE); } 
+  catch (e) {
+    if (e.code === "ENOENT") {
+      // fallback for first write
+      fs.writeFileSync(DATABASE_FILE, JSON.stringify(database, null, 2), "utf8");
+    } else {
+      throw e;
+    }
+  }
+}
+
+function insert(collection, item) {
+  const db = load();
+  db[collection] ??= [];
+  db[collection].push(item);
+  save(db);
+}
+
+function update(collection, item, key = "id") {
+  const db = load();
+  const idx = db[collection]?.findIndex(x => x[key] === item[key]);
+
+  if (idx < 0) return false;
+
+  db[collection][idx] = { ...db[collection][idx], ...item };
+  save(db);
+  return true;
+}
+
+function upsert(collection, item, key = "id") {
+  const db = load();
+  db[collection] ??= [];
+
+  const idx = db[collection].findIndex(x => x[key] === item[key]);
+  if (idx >= 0) {
+    db[collection][idx] = { ...db[collection][idx], ...item, updatedAt: Date.now() };
+  } else {
+    db[collection].push({ ...item, createdAt: Date.now() });
+  }
+
+  save(db);
+}
+
+function replace(collection, value) {
+  const db = load();
+  db[collection] = value;
+  save(db);
+}
+
+function set(collection, key, value) {
+  const db = load();
+  db[collection] ??= {};
+  db[collection][key] = value;
+  save(db);
+}
+
+function remove(collection, keyValue, key = "id") {
+  const db = load();
+  db[collection] = (db[collection] ?? []).filter(x => x[key] !== keyValue);
+  save(db);
+}
+
+function get(collection) {
+  const db = load();
+  return db[collection] ?? [];
+}
+
+function find(collection, predicate) {
+  const db = load();
+  return (db[collection] ?? []).filter(predicate);
+}
+
+function indexBy(list, key) {
+  const map = Object.create(null);
+
+  for (const item of list) {
+    const k = item?.[key];
+    if (k == null) continue; // skip null/undefined
+    (map[k] ??= []).push(item);
+  }
+
+  return map;
+}
+
+function indexByFn(list, keyFn) {
+  const map = Object.create(null);
+
+  for (const item of list) {
+    const k = keyFn(item);
+    if (k == null) continue;
+    (map[k] ??= []).push(item);
+  }
+
+  return map;
+}
+
+function indexByMap(list, key) {
+  const map = new Map();
+  for (const item of list) {
+    const k = item?.[key];
+    if (k == null) continue;
+    const arr = map.get(k) ?? [];
+    arr.push(item);
+    map.set(k, arr);
+  }
+  return map;
+}
+
+function getArtefactIndex() {
+  if (!artefactIndex) {
+    const list = get("artefacts");
+    artefactIndex = indexBy(list, "participantId");
+  }
+  return artefactIndex;
+}
+
+function invalidateArtefactIndex() {
+  artefactIndex = null;
+}
+
+function artefactsByParticipant(pid) {
+  const idx = getArtefactIndex();
+  return idx[pid] ?? [];
+}
+
+module.exports = { setSource, load, save, insert, update, upsert, replace, set, remove, get, find, indexBy, indexByFn, indexByMap, artefactsByParticipant };

package/src/discover.js

@@ -1,10 +1,11 @@
 const fs = require("fs");
 const path = require("path");
 const pkg = require("../package.json");
+const db = require("./db");
 
 const { fetchWithAuth } = require("./auth");
 const { API_URL, EP_DISCOVER, DEFAULT_OUTPUT, DEFAULT_FORMAT, ARTEFACTS_DIR } = require("./config");
-const { getUserUsage, updateUserUsage } = require("./user");
+const { getUserUsage } = require("./user");
 const { clearScreen, startSpinner, buildDocLabel, promptForDocument } = require("./utils");
 const { handleError } = require("./errors"); 
 
@@ -33,7 +34,7 @@ const DEFAULT_DISCOVERY_INPUT = {
 const discoveryInput = DEFAULT_DISCOVERY_INPUT;
 let docSelected = false;
 
-async function processSupportedDocuments(encodedDocs, environment, participantId, options) {
+async function processSupportedDocuments(encodedDocs, onDone) {
   if (encodedDocs && !docSelected) {
       const docs = JSON.parse(Buffer.from(encodedDocs, "base64").toString("utf8"))
       .map(d => ({ ...d, label: buildDocLabel(d) }));
@@ -52,13 +53,16 @@ async function processSupportedDocuments(encodedDocs, environment, participantId
         discoveryInput.document.value = docSelected.value;
       }
 
-      runDiscovery(environment, participantId, options);
+      if (typeof onDone === "function") {
+        await onDone(); // no args
+      }
     }
   }
 }
 
-async function runDiscovery(environment, participantId, options) {
+async function runDiscovery(participantId, options) {
   const {
+    env,
     output = DEFAULT_OUTPUT,
     format = DEFAULT_FORMAT,
     forceHttps,
@@ -72,7 +76,7 @@ async function runDiscovery(environment, participantId, options) {
 
   const payload = {
     ...discoveryInput,
-    env: environment,
+    env,
     options: {
       output,
       format,
@@ -116,7 +120,16 @@ async function runDiscovery(environment, participantId, options) {
   const currentMonth = new Date().toISOString().slice(0, 7);
   userUsage.serviceUsage.discovery[currentMonth] = serviceUsage;
   
-  updateUserUsage(userUsage);
+  db.replace("serviceUsage", userUsage);
+
+  db.insert("artefacts", {
+    id: refId,
+    participantId,
+    options,
+    output,
+    format,
+    createdAt: Date.now()
+  });
  
   if (output === "plantuml" && format === "svg") {
     const svg = await res.text();
@@ -127,7 +140,9 @@ async function runDiscovery(environment, participantId, options) {
       process.exit(1);
     }
 
-    await processSupportedDocuments(encodedDocs, environment, participantId, options);
+    await processSupportedDocuments(encodedDocs, async () => {
+      await runDiscovery(participantId, options);
+    });
 
     const file = path.join(ARTEFACTS_DIR, `${refId}.svg`);
     fs.writeFileSync(file, svg);
@@ -142,7 +157,9 @@ async function runDiscovery(environment, participantId, options) {
     const text = await res.text();
     stopSpinner();
 
-    await processSupportedDocuments(encodedDocs, environment, participantId, options);
+    await processSupportedDocuments(encodedDocs, async () => {
+      await runDiscovery(participantId, options);
+    });
 
     const file = path.join(ARTEFACTS_DIR, `${refId}.puml`);
     fs.writeFileSync(file, text);
@@ -157,7 +174,9 @@ async function runDiscovery(environment, participantId, options) {
   const json = await res.json();
   stopSpinner();
 
-  await processSupportedDocuments(encodedDocs, environment, participantId, options);
+  await processSupportedDocuments(encodedDocs, async () => {
+    await runDiscovery(participantId, options);
+  });
 
   const file = path.join(ARTEFACTS_DIR, `${refId}.json`);
   fs.writeFileSync(file, JSON.stringify(json, null, 2));

package/src/user.js

@@ -1,64 +1,27 @@
-const fs = require("fs");
-const { NODE42_DIR, USER_FILE, USAGE_FILE } = require("./config");
+const db = require("./db");
 
-function updateUserInfo(user) {
-  fs.mkdirSync(NODE42_DIR, { recursive: true });
-
-  fs.writeFileSync(
-    USER_FILE,
-    JSON.stringify(user, null, 2)
-  );  
-}
-
-function getUserInfo() {
-  try {
-    if (!fs.existsSync(USER_FILE)) {
-      return {
-        userName: "n/a",
-        userMail: "n/a",
-        role: "n/a"
-      };
-    }
-    return JSON.parse(fs.readFileSync(USER_FILE, "utf8"));
-  } catch {
-    return {
-        userName: "n/a",
-        userMail: "n/a",
-        role: "n/a"
+function getUser() {
+  const users = db.get("user");
+  return users.length ? users[0] : {
+      "id": "n/a",
+      "userName": "n/a",
+      "userMail": "n/a",
+      "role": "n/a"
     };
-  }
 }
 
-function updateUserUsage(usage) {
-  fs.mkdirSync(NODE42_DIR, { recursive: true });
+function getUserUsage() {
+  const usage = db.get("serviceUsage");
 
-  fs.writeFileSync(
-    USAGE_FILE,
-    JSON.stringify(usage, null, 2)
-  );
-}
+  if (usage && usage.serviceUsage) return usage;
 
-function getUserUsage() {
-  try {
-    if (!fs.existsSync(USAGE_FILE)) {
-      return {
-        serviceUsage: {
-          discovery: {},
-          validation: {},
-          transactions: {}
-        }
-      };
+  return {
+    serviceUsage: {
+      discovery: {},
+      validation: {},
+      transactions: {}
     }
-    return JSON.parse(fs.readFileSync(USAGE_FILE, "utf8"));
-  } catch {
-    return {
-      serviceUsage: {
-        discovery: {},
-        validation: {},
-        transactions: {}
-      }
-    };
-  }
+  };
 }
 
-module.exports = { updateUserInfo, getUserInfo, updateUserUsage, getUserUsage };
+module.exports = { getUser, getUserUsage };

package/src/utils.js

@@ -1,5 +1,8 @@
+const fs = require("fs");
 const inquirer = require("inquirer");
 const readline = require("readline");
+const config = require("./config");
+
 
 function clearScreen(text) {
   process.stdout.write("\x1Bc");
@@ -8,7 +11,7 @@ function clearScreen(text) {
   }
 }
 
-function ask(question, hidden=false) {
+function ask(question, def, hidden=false) {
   return new Promise(resolve => {
     const rl = readline.createInterface({
       input: process.stdin,
@@ -16,6 +19,8 @@ function ask(question, hidden=false) {
       terminal: true
     });
 
+    const q = def ? `${question} (${def}): ` : `${question}: `;
+
     process.stdin.on("data", char => {
       char = char + "";
       switch (char) {
@@ -28,16 +33,16 @@ function ask(question, hidden=false) {
           if (hidden) {
             process.stdout.clearLine(0);
             process.stdout.cursorTo(0);
-            process.stdout.write(question + "*".repeat(rl.line.length));
+            process.stdout.write(q + "*".repeat(rl.line.length));
           }
           break;
       }
     });
 
-    rl.question(question, answer => {
+    rl.question(q, answer => {
       rl.history = rl.history.slice(1);
       rl.close();
-      resolve(answer);
+      resolve(answer || def);
     });
   });
 }
@@ -56,6 +61,59 @@ function startSpinner(text = "Working") {
   };
 }
 
+async function promptForDocument(docs) {
+  const { document } = await inquirer.prompt([
+    {
+      type: "list",
+      name: "document",
+      message: "Select document type:",
+      choices: docs.map(d => ({
+        name: d.label,
+        value: d
+      }))
+    }
+  ]);
+
+  return document;
+}
+
+function validateEnv(env) {
+  const allowedEnvs = ["TEST", "PROD"];
+  if (!allowedEnvs.includes(env.toUpperCase())) {
+    throw new Error(
+      `Invalid environment: ${env}\nAllowed values: ${allowedEnvs.join(", ")}`
+    );
+  }
+}
+
+function validateId(type, id) {
+  const value = id.replace(/\s+/g, "");
+
+  // ISO 6523–safe; participant id like 0000:12345 or 9915:abcde
+  if (!/^[0-9]{4}:[a-zA-Z0-9\-\._~]{1,135}$/.test(value)) {
+    throw new Error(
+      `Invalid ${type}Id: ${id}\nExpected format: 0007:123456789 or 0007:abcd`
+    );
+  }
+}
+
+function createAppDirs(force=false) {
+  fs.mkdirSync(config.NODE42_DIR, { recursive: true });
+  fs.mkdirSync(config.ARTEFACTS_DIR, { recursive: true });
+  fs.mkdirSync(config.TRANSACTIONS_DIR, { recursive: true });
+  fs.mkdirSync(config.VALIDATION_DIR, { recursive: true });
+
+  if (!fs.existsSync(config.CONFIG_FILE) || force) {
+    fs.writeFileSync(
+      config.CONFIG_FILE,
+      JSON.stringify({
+        DEFAULT_OUTPUT: config.DEFAULT_OUTPUT,
+        DEFAULT_FORMAT: config.DEFAULT_FORMAT
+      }, null, 2)
+    );
+  }
+}
+
 function buildDocLabel({ scheme, value }) {
   // 1. Document name (after :: before ##)
   const docMatch = value.match(/::([^#]+)##/);
@@ -95,40 +153,14 @@ function buildDocLabel({ scheme, value }) {
   return docName;
 }
 
-async function promptForDocument(docs) {
-  const { document } = await inquirer.prompt([
-    {
-      type: "list",
-      name: "document",
-      message: "Select document type:",
-      choices: docs.map(d => ({
-        name: d.label,
-        value: d
-      }))
-    }
-  ]);
-
-  return document;
-}
-
-function validateEnv(env) {
-  const allowedEnvs = ["TEST", "PROD"];
-  if (!allowedEnvs.includes(env.toUpperCase())) {
-    throw new Error(
-      `Invalid environment: ${env}\nAllowed values: ${allowedEnvs.join(", ")}`
-    );
-  }
-}
-
-function validateId(type, id) {
-  const value = id.replace(/\s+/g, "");
-
-  // ISO 6523–safe; participant id like 0000:12345 or 9915:abcde
-  if (!/^[0-9]{4}:[a-zA-Z0-9\-\._~]{1,135}$/.test(value)) {
-    throw new Error(
-      `Invalid ${type}Id: ${id}\nExpected format: 0007:123456789 or 0007:abcd`
-    );
+function getArtefactExt(output, format) {
+  if (output === "plantuml" && format === "svg") {
+    return "svg";
+  } else if (output === "plantuml" && format === "text") {
+    return "puml"
+  } else {
+    return "json";
   }
 }
 
-module.exports = { clearScreen, startSpinner, ask, buildDocLabel, promptForDocument, validateEnv, validateId };
+module.exports = { clearScreen, startSpinner, ask, buildDocLabel, promptForDocument, validateEnv, validateId, createAppDirs, getArtefactExt };

package/test/auth.test.js

@@ -0,0 +1,98 @@
+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.json");
+
+describe("auth", () => {
+  describe("login()", () => {
+    let login;
+    let utils;
+    let auth;
+    let user;
+
+    beforeEach(() => {
+      sinon.restore();
+
+      db.setSource(TEST_DB);
+      if (fs.existsSync(TEST_DB)) fs.unlinkSync(TEST_DB);
+
+      // fresh require each test
+      delete require.cache[require.resolve("../src/utils")];
+      delete require.cache[require.resolve("../src/user")];
+      delete require.cache[require.resolve("../src/auth")];
+
+      utils = require("../src/utils");
+      user = require("../src/user");
+      
+      sinon.stub(utils, "clearScreen");
+      sinon.stub(utils, "ask")
+        .onFirstCall().resolves("user")
+        .onSecondCall().resolves("secret");
+
+      sinon.stub(utils, "startSpinner").callsFake(() => () => {});
+      sinon.stub(user, "getUser").returns({
+        userName: "User",
+        userMail: "user@test.com",
+        role: "user"
+      });
+
+      sinon.stub(fs, "mkdirSync");
+      sinon.stub(fs, "writeFileSync");
+
+      sinon.stub(console, "log");
+      sinon.stub(console, "error");
+      sinon.stub(process, "exit").callsFake(() => {
+          throw new Error("process.exit");
+      });
+
+      auth = require("../src/auth");
+      login = auth.login;
+
+      sinon.stub(auth, "checkAuth").returns(true);
+    });
+
+    afterEach(() => {
+      sinon.restore();
+      delete global.fetch;
+    });
+
+    it("logs in successfully and writes tokens", async () => {
+      // mock fetch
+      global.fetch = sinon.stub().resolves({
+        ok: true,
+        json: async () => ({
+          accessToken: "a",
+          refreshToken: "r",
+          idToken: "i"
+        })
+      });
+
+      await login();
+
+      expect(fs.writeFileSync.called).to.be.true;
+      expect(console.log.calledWithMatch("Authenticated as")).to.be.true;
+    });
+
+    it("exits on http error", async () => {
+      global.fetch = sinon.stub().resolves({
+        ok: false,
+        status: 401,
+        json: async () => ({})
+      });
+
+      try {
+          await login();
+      } catch (e) {
+          // expected
+      }
+
+      expect(console.error.calledWithMatch("Login failed")).to.be.true;
+      expect(process.exit.calledWith(1)).to.be.true;
+      expect(fs.writeFileSync.called).to.be.false;
+    });
+  });
+});