systemview 1.18.1 → 1.20.0

package/cli/cookieClient.js

@@ -40,12 +40,13 @@ function cookieHeader() {
   return pairs || null;
 }
 
-function createCookieHttpClient() {
+function createCookieHttpClient(extraHeaders = {}) {
   return {
     request: async ({ method = "get", url, body: data, headers }) => {
       method = method.toLowerCase();
       const cookie = cookieHeader();
-      if (cookie) headers = { ...headers, Cookie: cookie };
+      headers = { ...headers, ...extraHeaders };
+      if (cookie) headers.Cookie = cookie;
       try {
         const res = await axios({ url, method, headers, data });
         captureCookies(res.headers["set-cookie"]);
@@ -66,6 +67,7 @@ function createCookieHttpClient() {
       if (__arguments) form.append("__arguments", JSON.stringify(__arguments));
       const cookie = cookieHeader();
       const allHeaders = {
+        ...extraHeaders,
         ...(cookie ? { Cookie: cookie } : {}),
         ...headers,
         "Content-Type": "multipart/form-data",
@@ -87,5 +89,5 @@ function createCookieHttpClient() {
 
 module.exports = {
   createCookieHttpClient,
-  createCookieClient: () => createClient(createCookieHttpClient()),
+  createCookieClient: (extraHeaders = {}) => createClient(createCookieHttpClient(extraHeaders)),
 };

package/cli/index.js

@@ -2,18 +2,23 @@
 
 process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
 
+const fs = require("fs");
+const path = require("path");
 const { input, flags, showHelp } = require("./utils/cli");
 const init = require("./utils/init");
 const log = require("./logger");
 const launchApp = require("./launchApp");
 const runTests = require("./runTests");
+const listTests = require("./listTests");
 const appIsRunning = require("./appIsRunning");
 const openBrowser = require("./openBrowser");
 const connectService = require("./connectService");
 const probe = require("./probe");
 const { HttpClient } = require("systemlynx");
+const { createCookieClient } = require("./cookieClient");
 
 const DEFAULT_PORT = 3000;
+const VERSION = require("../package.json").version;
 
 async function startApp() {
   const port = isNaN(input[1]) ? DEFAULT_PORT : Number(input[1]);
@@ -34,6 +39,12 @@ async function startTest() {
       json: flags.json,
       verbose: flags.verbose,
       manifest: flags.manifest,
+      headers: flags.headers,
+      bail: flags.bail,
+      dryRun: flags.dryRun,
+      phase: flags.phase,
+      index: flags.index,
+      skip: flags.skip,
     });
     process.exit(exitCode);
   } catch (error) {
@@ -42,6 +53,18 @@ async function startTest() {
   }
 }
 
+async function list() {
+  const project_code = input[1];
+  const namespace = input[2];
+  const url = `http://localhost:${DEFAULT_PORT}`;
+  const api = `${url}/systemview/api`;
+  if (!(await appIsRunning(api))) {
+    await launchApp(DEFAULT_PORT);
+  }
+  await listTests(url, project_code, namespace, { manifest: flags.manifest, verbose: flags.verbose });
+  process.exit(0);
+}
+
 async function open() {
   const project_code = input[1];
   const namespace = input[2];
@@ -50,7 +73,24 @@ async function open() {
   if (!(await appIsRunning(api))) {
     await launchApp(DEFAULT_PORT);
   }
-  openBrowser(ui, project_code, namespace);
+
+  let connectedServices = [];
+  if (namespace && project_code) {
+    const manifestFile = flags.manifest || path.join(process.cwd(), "systemview.manifest.json");
+    if (fs.existsSync(manifestFile)) {
+      try {
+        const raw = JSON.parse(fs.readFileSync(manifestFile, "utf8"));
+        connectedServices = raw.services ? raw.services : [raw];
+      } catch {}
+    } else {
+      try {
+        const { SystemView } = await createCookieClient().loadService(api);
+        connectedServices = (await SystemView.getServices(project_code)) || [];
+      } catch {}
+    }
+  }
+
+  openBrowser(ui, project_code, namespace, connectedServices);
   process.exit(0);
 }
 
@@ -84,8 +124,13 @@ async function quitApp() {
   init();
   const command = input[0];
 
-  if (command === "open") {
+  if (process.argv.includes("--version")) {
+    console.log(VERSION);
+    process.exit(0);
+  } else if (command === "open") {
     await open();
+  } else if (command === "list") {
+    await list();
   } else if (command === "help" || input.includes("help")) {
     showHelp();
   } else if (command === "test") {
@@ -96,7 +141,11 @@ async function quitApp() {
     await connectService(input[1], input[2], { manifest: flags.manifest });
     process.exit(0);
   } else if (command === "probe") {
-    const exitCode = await probe(input[1], input[2], { json: flags.json, manifest: flags.manifest });
+    const exitCode = await probe(input[1], input[2], {
+      json: flags.json,
+      manifest: flags.manifest,
+      headers: flags.headers,
+    });
     process.exit(exitCode || 0);
   } else {
     await startApp();

package/cli/listTests.js

@@ -0,0 +1,162 @@
+const fs = require("fs");
+const path = require("path");
+const { createCookieClient } = require("./cookieClient");
+const log = require("./logger");
+const chalk = require("chalk");
+
+module.exports = async function listTests(url, project_code, namespace, { manifest: manifestPath, verbose = false } = {}) {
+  const api = `${url}/systemview/api`;
+  const Client = createCookieClient();
+
+  if (!project_code) {
+    await listAllProjects(api, Client, verbose);
+    return;
+  }
+
+  const connectedServices = await loadServices(api, project_code, manifestPath, Client);
+  if (!connectedServices.length) {
+    log.warn("No connected services found for project: " + project_code);
+    return;
+  }
+
+  console.log("");
+  console.log(`  ${chalk.bold(project_code)}`);
+
+  for (let si = 0; si < connectedServices.length; si++) {
+    const { serviceId, system } = connectedServices[si];
+    const isLastService = si === connectedServices.length - 1;
+    const servicePrefix = isLastService ? "  └── " : "  ├── ";
+    const childPad = isLastService ? "       " : "  │    ";
+
+    let testList = [];
+    try {
+      const svc = createCookieClient().createService(system.connectionData);
+      testList = await svc.Plugin.getTests();
+    } catch {
+      console.log(`${servicePrefix}${chalk.dim(serviceId)}  ${chalk.dim("(could not load tests)")}`);
+      continue;
+    }
+
+    const filtered = namespace
+      ? testList.filter(({ namespace: n }) =>
+          `${n.serviceId}.${n.moduleName}.${n.methodName}`.includes(namespace)
+        )
+      : testList;
+
+    if (!filtered.length) {
+      console.log(`${servicePrefix}${chalk.dim(serviceId)}  ${chalk.dim("(no matching tests)")}`);
+      continue;
+    }
+
+    const tree = {};
+    filtered.forEach(({ namespace: n, title }) => {
+      if (!tree[n.moduleName]) tree[n.moduleName] = {};
+      if (verbose) {
+        if (!tree[n.moduleName][n.methodName]) tree[n.moduleName][n.methodName] = [];
+        tree[n.moduleName][n.methodName].push(title);
+      } else {
+        tree[n.moduleName][n.methodName] = (tree[n.moduleName][n.methodName] || 0) + 1;
+      }
+    });
+
+    console.log(`${servicePrefix}${chalk.bold(serviceId)}`);
+
+    const modules = Object.keys(tree);
+    modules.forEach((moduleName, mi) => {
+      const isLastModule = mi === modules.length - 1;
+      const modPrefix = childPad + (isLastModule ? "└── " : "├── ");
+      const modPad = childPad + (isLastModule ? "     " : "│    ");
+      console.log(`${modPrefix}${moduleName}`);
+
+      const methods = Object.keys(tree[moduleName]);
+      methods.forEach((methodName, mei) => {
+        const isLastMethod = mei === methods.length - 1;
+        const methodPrefix = modPad + (isLastMethod ? "└── " : "├── ");
+        const methodPad = modPad + (isLastMethod ? "     " : "│    ");
+        if (verbose) {
+          const titles = tree[moduleName][methodName];
+          console.log(`${methodPrefix}${chalk.cyan(methodName)}`);
+          titles.forEach((title, ti) => {
+            const isLastTitle = ti === titles.length - 1;
+            const titlePrefix = methodPad + (isLastTitle ? "└── " : "├── ");
+            console.log(`${titlePrefix}${chalk.dim(title)}`);
+          });
+        } else {
+          const count = tree[moduleName][methodName];
+          const countStr = chalk.dim(`${count} ${count === 1 ? "test" : "tests"}`);
+          console.log(`${methodPrefix}${chalk.cyan(methodName)}   ${countStr}`);
+        }
+      });
+    });
+  }
+
+  console.log("");
+};
+
+async function listAllProjects(api, Client, verbose = false) {
+  let projects;
+  try {
+    const { SystemView } = await Client.loadService(api);
+    projects = await SystemView.getProjects();
+  } catch {
+    log.error("Could not connect to SystemView. Is it running?");
+    return;
+  }
+
+  const codes = Object.keys(projects);
+  if (!codes.length) {
+    log.warn("No connected projects found.");
+    return;
+  }
+
+  const total = codes.reduce((n, c) => n + projects[c].length, 0);
+  console.log("");
+  console.log(chalk.dim(`  ${codes.length} ${codes.length === 1 ? "project" : "projects"}, ${total} ${total === 1 ? "service" : "services"}`));
+  console.log("");
+  codes.forEach((projectCode, pi) => {
+    console.log(`  ${chalk.bold(projectCode)}`);
+    const services = projects[projectCode];
+    services.forEach(({ serviceId, serviceUrl, connectionData }, si) => {
+      const isLastService = si === services.length - 1;
+      const servicePrefix = isLastService ? "  └── " : "  ├── ";
+      const childPad = isLastService ? "       " : "  │    ";
+
+      if (verbose && connectionData && connectionData.modules) {
+        console.log(`${servicePrefix}${chalk.bold(serviceId)}   ${chalk.dim(serviceUrl)}`);
+        const mods = connectionData.modules.filter((m) => m.name !== "Plugin");
+        mods.forEach((mod, mi) => {
+          const isLastMod = mi === mods.length - 1;
+          const modPrefix = childPad + (isLastMod ? "└── " : "├── ");
+          const modPad = childPad + (isLastMod ? "     " : "│    ");
+          console.log(`${modPrefix}${mod.name}`);
+          const methods = mod.methods || [];
+          methods.forEach((m, mei) => {
+            const isLastMethod = mei === methods.length - 1;
+            const methodPrefix = modPad + (isLastMethod ? "└── " : "├── ");
+            console.log(`${methodPrefix}${chalk.cyan(m.fn)}`);
+          });
+        });
+      } else {
+        console.log(`${servicePrefix}${serviceId}   ${chalk.dim(serviceUrl)}`);
+      }
+    });
+    if (pi < codes.length - 1) console.log("");
+  });
+  console.log("");
+}
+
+async function loadServices(api, project_code, manifestPath, Client) {
+  const manifestFile = manifestPath || path.join(process.cwd(), "systemview.manifest.json");
+  if (fs.existsSync(manifestFile)) {
+    try {
+      const raw = JSON.parse(fs.readFileSync(manifestFile, "utf8"));
+      return raw.services ? raw.services : [raw];
+    } catch {}
+  }
+  try {
+    const { SystemView } = await Client.loadService(api);
+    return (await SystemView.getServices(project_code)) || [];
+  } catch {
+    return [];
+  }
+}

package/cli/openBrowser.js

@@ -1,6 +1,7 @@
 const { exec } = require("child_process");
+const resolveNamespace = require("./utils/resolveNamespace");
 
-module.exports = function openBrowser(url, project_code, namespace) {
+module.exports = function openBrowser(url, project_code, namespace, connectedServices) {
   if (!url || typeof url !== "string" || url.trim() === "") {
     console.error("Invalid URL provided");
     return;
@@ -8,15 +9,28 @@ module.exports = function openBrowser(url, project_code, namespace) {
 
   const browserCommand = process.platform === "win32" ? "start" : "open";
   const code = project_code ? "/" + project_code : "";
+
+  if (namespace && connectedServices && connectedServices.length) {
+    const matches = resolveNamespace(namespace, connectedServices);
+    if (matches.length) {
+      matches.forEach(({ serviceId, moduleName, methodName }) => {
+        const nsp = `/${serviceId}/${moduleName}/${methodName}`;
+        const fullUrl = `${url}${code}${nsp}`;
+        console.log(`opening... ${fullUrl}`);
+        exec(`${browserCommand} ${fullUrl}`, (error, stdout, stderr) => {
+          if (error) console.error(`Failed to open browser: ${error.message}`);
+          else if (stderr) console.error(`Failed to open browser: ${stderr}`);
+        });
+      });
+      return;
+    }
+  }
+
   const nsp = code && namespace ? "/" + namespace.replace(/\./g, "/") : "";
   console.log(`opening... ${url}${code}${nsp}`);
   exec(`${browserCommand} ${url}${code}${nsp}`, (error, stdout, stderr) => {
-    if (error) {
-      console.error(`Failed to open browser: ${error.message}`);
-    } else if (stderr) {
-      console.error(`Failed to open browser: ${stderr}`);
-    } else {
-      console.log("Browser opened successfully!");
-    }
+    if (error) console.error(`Failed to open browser: ${error.message}`);
+    else if (stderr) console.error(`Failed to open browser: ${stderr}`);
+    else console.log("Browser opened successfully!");
   });
 };

package/cli/probe.js

@@ -3,7 +3,7 @@ const path = require("path");
 const { createCookieClient } = require("./cookieClient");
 const log = require("./logger");
 
-module.exports = async function probe(namespace, argsStr, { json = false, manifest: manifestPath } = {}) {
+module.exports = async function probe(namespace, argsStr, { json = false, manifest: manifestPath, headers: cliHeaders = {} } = {}) {
   if (!namespace) {
     log.error("Usage: systemview probe <ServiceId.Module.method> [args]");
     return 1;
@@ -48,10 +48,11 @@ module.exports = async function probe(namespace, argsStr, { json = false, manife
     return 1;
   }
 
+  const extraHeaders = { ...(manifest.probeHeaders || {}), ...cliHeaders };
   if (!json) log.info(`${serviceId}.${moduleName}.${methodName}(${argsStr || ""})`);
 
   try {
-    const client = createCookieClient().createService(service.system.connectionData);
+    const client = createCookieClient(extraHeaders).createService(service.system.connectionData);
     const result = await client[moduleName][methodName](...args);
     if (json) {
       process.stdout.write(JSON.stringify({ serviceId, moduleName, methodName, args, result }, null, 2) + "\n");