stack-analyze 1.1.2 → 1.1.6

package/index.js

@@ -1,404 +1,359 @@
-#!/usr/bin/env node
-
 // modules
-const { performance } = require("perf_hooks");
-const inquirer = require("inquirer");
-const { textSync } = require("figlet");
+const axios = require("axios").default;
+const CoinGecko = require("coingecko-api");
 const {
-  yellow,
-  green,
-  red
-} = require("colors");
-const { printTable, Table } = require("console-table-printer");
+  cpu,
+  mem,
+  osInfo,
+  diskLayout,
+  graphics,
+  bios
+} = require("systeminformation");
+const Wappalyzer = require("wappalyzer");
 
-// options
-const {
-  aboutApp,
-  developers,
-  nonolive,
-  projects,
-  twitch,
-  youtubeDev
-} = require("./about");
+// init coingecko api
+const CoinGeckoClient = new CoinGecko();
 
-// analyze web
-const singleStack = require("./functions/singleStack");
-const multipleStack = require("./functions/multipleStack");
+// functions
 
-// pagespeed web
-const { desktop, mobile } = require("./functions/pageSpeed");
+const animeSearch = async (query) => {
+  /* error manager */
+  try {
+    // call api
+    const { data } = await axios.get("https://api.jikan.moe/v3/search/anime", {
+      params: {
+        q: query,
+        limit: 10
+      }
+    });
 
-// github info
-const githubInfo = require("./functions/gitUser");
+    return data.results;
 
-// anime search
-const animeSearch = require("./functions/animeInfo");
+  } catch (err) { return err; }
+};
 
-// hardware modules
-const {
-  cpuInfo,
-  ramMemInfo,
-  osDetail,
-  diskInfo,
-  controllerInfo,
-  displayInfo,
-  biosInfo
-} = require("./functions/hardware");
-
-/**
- * @description about selected anw
- * @param { string } result - about option selected
- * @return { void }
- */
-function aboutSelected(result) {
-
-  // tables
-  const youtubeDevTable = new Table({
-    columns: [
-      {
-        name: "youtubeChannel",
-        alignment: "left",
-        color: "green"
-      },
-      {
-        name: "recomendation",
-        alignment: "left",
-        color: "cyan"
-      }
-    ]
-  });
-  const nonoliveTable = new Table({
-    columns: [
+const bitlyInfo = async (link, token) => {
+  try {
+    const { data } = await axios.post(
+      "https://api-ssl.bitly.com/v4/expand",
       {
-        name: "nonoID",
-        alignment: "left",
-        color: "red"
+        bitlink_id: link
       },
       {
-        name: "name",
-        alignment: "left",
-        color: "yellow"
+        headers: {
+          Authorization: `Bearer ${token}`,
+          "Content-Type": "application/json"
+        }
       }
-    ]
-  });
-
-  switch (result) {
-    case "main info":
-      console.clear();
-      console.table(aboutApp);
-      setTimeout(aboutOpts, 1000);
-      break;
-    case "devolepers lineup":
-      console.clear();
-      printTable(developers.map((dev, i) => ({ index: i + 1, dev })));
-      setTimeout(aboutOpts, 1000);
-      break;
-    case "youtube streamers recomendation":
-      console.clear();
-      youtubeDevTable.addRows(youtubeDev);
-      youtubeDevTable.printTable();
-      setTimeout(aboutOpts, 1000);
-      break;
-    case "nonolive recomendation":
-      console.clear();
-      nonoliveTable.addRows(nonolive);
-      nonoliveTable.printTable();
-      setTimeout(aboutOpts, 1000);
-      break;
-    case "twitch recomendation":
-      console.clear();
-      printTable(twitch.map((streamer, i) => ({ index: i + 1, streamer })));
-      setTimeout(aboutOpts, 1000);
-      break;
-    case "projects recomendation":
-      console.clear();
-      printTable(projects.map((project, i) => ({ index: i + 1, project })));
-      setTimeout(aboutOpts, 1000);
-      break;
-
-    default:
-      console.clear();
-      question();
-      break;
-  }
-}
+    );
+
+    return data;
+  } catch (err) { return err; }
+};
 
-/** 
- * @description about menu
- * @return { void }
+/*
+ *
+ * @descripiton call the crypto market list
+ * @returns { Promise<void> } - return results search
+ *
  */
-function aboutOpts() {
-  inquirer.prompt({
-    type: "list",
-    name: "about",
-    message: "select about option info",
-    choices: [
-      "main info",
-      "devolepers lineup",
-      "youtube streamers recomendation",
-      "nonolive recomendation",
-      "twitch recomendation",
-      "projects recomendation",
-      "return to main menu"
-    ]
-  }).then(({ about }) => aboutSelected(about))
-    .catch((err) => console.error(red(err.message)));
+const cryptoMarket = async () => {
+  try {
+    // start crypto
+    const coinData = await CoinGeckoClient.coins.markets({
+      per_page: 10
+    });
+
+    // map coinData
+    return coinData.data;
+  } catch (err) { return err; }
+};
+
+async function githubInfo(user) {
+  try {
+    const { data } = await axios.get(`https://api.github.com/users/${user}`);
+
+    return data;
+  } catch (err) { return err; }
 }
 
+async function cpuInfo() {
+  try {
+    const {
+      manufacturer,
+      brand,
+      speed,
+      cores,
+      physicalCores,
+      processors,
+      vendor,
+      family,
+      model
+    } = await cpu();
 
-/**
- * 
- * @description call the async function return list to question list
- * @return { Promise<void> } - return in boolean a result question list
- * 
- */
-async function returnQuestion() {
+    // show results
+    return {
+      manufacturer,
+      brand,
+      speed,
+      cores,
+      physicalCores,
+      processors,
+      vendor,
+      family,
+      model
+    };
+  } catch (err) { return err; }
+}
+
+async function ramMemInfo() {
   try {
-    const anw = await inquirer.prompt([
-      {
-        type: "confirm",
-        name: "return",
-        message: "do you want go to the main menu?",
-      }
-    ]);
-
-    if (anw.return) {
-      console.clear();
-      question();
-    } else {
-      console.info(green("thanks for use stack-analyze"));
-
-    }
-  } catch (err) {
-    console.error(red(err.message));
-  }
+    const {
+      total,
+      free,
+      used,
+      active,
+      available
+    } = await mem();
+
+    // show results
+    return {
+      total_mem: `${(total / 1073741824).toFixed(2)} GB`,
+      free_mem: `${(free / 1073741824).toFixed(2)} GB`,
+      used_mem: `${(used / 1073741824).toFixed(2)} GB`,
+      active_mem: `${(active / 1073741824).toFixed(2)} GB`,
+      available_mem: `${(available / 1073741824).toFixed(2)} GB`
+    };
+  } catch (err) { return err; }
 }
 
-/** 
- * @description select a hardware option
- * @param { string } result - selected a option hardware
- * @return { void }
-*/
-function hardwareSelected(result) {
-  switch (result) {
-    case "cpu":
-      console.clear();
-      cpuInfo();
-      setTimeout(hardwareOpts, 1000);
-      break;
-    case "ram memory":
-      console.clear();
-      ramMemInfo();
-      setTimeout(hardwareOpts, 1000);
-      break;
-    case "os":
-      console.clear();
-      osDetail();
-      setTimeout(hardwareOpts, 1000);
-      break;
-    case "disk":
-      console.clear();
-      diskInfo();
-      setTimeout(hardwareOpts, 1000);
-      break;
-    case "controller":
-      console.clear();
-      controllerInfo();
-      setTimeout(hardwareOpts, 1000);
-      break;
-    case "display":
-      console.clear();
-      displayInfo();
-      setTimeout(hardwareOpts, 1000);
-      break;
-    case "bios":
-      console.clear();
-      biosInfo();
-      setTimeout(hardwareOpts, 1000);
-      break;
-
-    default:
-      console.clear();
-      question();
-      break;
-  }
+async function osDetail() {
+  try {
+    const {
+      hostname,
+      platform,
+      distro,
+      release,
+      kernel,
+      arch,
+      serial,
+      uefi
+    } = await osInfo();
+
+    // show results
+    return {
+      hostname,
+      platform,
+      distro,
+      release,
+      kernel,
+      arch,
+      serial,
+      uefi
+    };
+  } catch (err) { return err; }
 }
 
-/**
- * @description call hardware information options
- * @return { void }
- */
-function hardwareOpts() {
-  inquirer.prompt({
-    type: "list",
-    name: "hardware",
-    message: "select a hardware-information option:",
-    choices: [
-      "cpu",
-      "ram memory",
-      "os",
-      "disk",
-      "controller",
-      "display",
-      "bios",
-      "exit to main menu"
-    ]
-  }).then(({ hardware }) => hardwareSelected(hardware));
+async function diskInfo() {
+  try {
+    const disks = await diskLayout();
+
+    const disksList = disks.map(({
+      type,
+      name,
+      vendor,
+      size,
+      interfaceType
+    }) => ({
+      type,
+      name,
+      vendor,
+      diskSize: `${(size / 1073741824).toFixed(2)} GB`,
+      interfaceType
+    }));
+
+    return disksList;
+
+  } catch (err) { return err; }
 }
 
-/**
- * 
- * @description function register option anwser
- * @param { string } result - result option anwser
- * @return { void }
- * 
- */
-function anwOption(result) {
-  // options conditional
-  switch (result) {
-    case "single":
-      console.clear();
-      inquirer.prompt({
-        name: "url",
-        message: "enter url for analyze the tech stack:"
-      })
-        .then(({ url }) => {
-          if (url.indexOf("http") === 0) {
-            singleStack(url);
-            const timeEnd = performance.now();
-            setTimeout(returnQuestion, timeEnd);
-          } else {
-            console.error(red("please insert a URL with parameter http:// or https://"));
-            question();
-          }
-        });
-      break;
-    case "multiple":
-      console.clear();
-      inquirer.prompt({
-        name: "urls",
-        message: "enter URLs for analyze the tech stacks with whitespace without quotes example 'http://example.com https://nodejs.org': \n"
-      })
-        .then(({ urls }) => {
-          if (
-            urls.match(/(http|https)/g) !== null ||
-            urls.match(/(http|https)/g) >= 2
-          ) {
-            const websites = urls.split(" ");
-            console.clear();
-            multipleStack(websites);
-            const timeEnd = performance.now();
-            setTimeout(returnQuestion, timeEnd);
-          } else {
-            console.error(red("please in each URL insert a website the parameter https:// or http://"));
-            question();
-          }
-        });
-      break;
-    case "pagespeed":
-      console.clear();
-      inquirer.prompt({
-        name: "speedWeb",
-        message: "insert URL for page speed analyze:"
-      })
-        .then(({ speedWeb }) => {
-          if (speedWeb.indexOf("http") === 0) {
-            console.clear();
-            console.info(green(textSync(speedWeb)));
-
-            // start pagespeed results mobile
-            textSync(speedWeb, "Small");
-            mobile(speedWeb);
-            const timeEndA = performance.now();
-
-            // start pagespeed results mobile
-            desktop(speedWeb);
-            const timeEndB = performance.now();
-
-            // stop time
-            setTimeout(returnQuestion, (timeEndA + timeEndB));
-          } else {
-            console.error(red("please insert a URL with parameter https;// or http://"));
-            question();
-          }
-        });
-      break;
-    case "github-info":
-      inquirer.prompt({
-        name: "user",
-        message: "enter a github user"
+async function controllerInfo() {
+  try {
+    const { controllers } = await graphics();
+
+    const controllersList = controllers.map(({
+      model,
+      vendor,
+      vram
+    }) => ({
+      model,
+      vendor,
+      vramSize: vram < 1024
+        ? `${vram} MB`
+        : `${(vram / 1024).toFixed(2)} GB`
+    }));
+
+    return controllersList;
+  } catch (err) { return err; }
+}
+
+async function displayInfo() {
+  try {
+    const { displays } = await graphics();
+
+    const displayList = displays.map(({
+      model,
+      main,
+      connection,
+      resolutionX,
+      resolutionY
+    }) => ({
+      model,
+      main,
+      connection,
+      resolutionX,
+      resolutionY
+    }));
+
+    return displayList;
+  } catch (err) { return err; }
+}
+
+async function biosInfo() {
+  try {
+    const {
+      releaseDate,
+      vendor,
+      revision,
+      version
+    } = await bios();
+
+    return { releaseDate, vendor, revision, version };
+  } catch (err) { return err; }
+}
+
+const movieDB = async (api_key, query) => {
+  try {
+    const { data } = await axios.get("https://api.themoviedb.org/3/search/movie", {
+      params: {
+        api_key,
+        query,
+        page: 1
+      }
+    });
+
+    const movieData = data.results
+      .map(({
+        title,
+        original_language,
+        popularity,
+        vote_average,
+        release_date
+      }) => ({
+        title,
+        original_language,
+        popularity,
+        vote_average,
+        release_date
+      }))
+      .sort((x, y) => {
+        // date values
+        const primaryDate = new Date(x.release_date);
+        const secondaryDate = new Date(y.release_date);
+
+        return primaryDate.getTime() - secondaryDate.getTime();
       })
-        .then(({ user }) => {
-          if (user !== "") {
-            console.clear();
-            githubInfo(user);
-            setTimeout(returnQuestion, 2000);
-          } else {
-            console.error(red("please the github username is required"));
-            question();
-          }
-        });
-      break;
-    case "anime-search":
-      inquirer.prompt({
-        name: "anime",
-        message: "enter a anime, music or ova search"
+      .filter(({ release_date }) => release_date !== undefined && release_date !== "");
+
+    return movieData;
+  } catch (err) { return err; }
+};
+
+async function multipleStack(urls) {
+  let result;
+  const wappalyzer = new Wappalyzer();
+  try {
+    await wappalyzer.init();
+    result = await Promise.all(
+      urls.map(async (url) => {
+        const { technologies } = await wappalyzer.open(url).analyze();
+        return {
+          url,
+          technologies
+        };
       })
-        .then(({ anime }) => {
-          if (anime !== "") {
-            console.clear();
-            animeSearch(anime);
-            setTimeout(returnQuestion, 5000);
-          } else {
-            console.error(red("please the anime is required"));
-            question();
-          }
-        });
-      break;
-    case "hardware-information":
-      console.clear();
-      hardwareOpts();
-      break;
-    case "about":
-      // about info cli
-      console.clear();
-      aboutOpts();
-      break;
-    default:
-      console.clear();
-      console.info(green("thanks for use stack-analyze"));
-      break;
-  }
+    );
+  } catch (err) { result = err; }
+  await wappalyzer.destroy();
+  return result;
 }
 
-/**
- * 
- * @description call the function question raw list options
- * @return { void }
- * 
- */
-function question() {
-  console.info(yellow(textSync("stack-analyze")));
-  inquirer.prompt({
-    type: "rawlist",
-    name: "analyze",
-    message: "what option do you want to analyze stack",
-    choices: [
-      "single",
-      "multiple",
-      "pagespeed",
-      "github-info",
-      "anime-search",
-      "hardware-information",
-      "about",
-      "exit"
-    ]
-  })
-    .then(({ analyze }) => anwOption(analyze))
-    .catch((err) => console.error(red(err.message)));
+const pageSpeed = async (url) => {
+  try {
+    const resMobile = await axios.get("https://www.googleapis.com/pagespeedonline/v5/runPagespeed", {
+      params: {
+        url,
+        key: "AIzaSyBEDaW4FxSZ2s1vz5CdD5Ai6PGZGdAzij0",
+        strategy: "mobile"
+      }
+    });
+
+    const resDesktop = await axios.get("https://www.googleapis.com/pagespeedonline/v5/runPagespeed", {
+      params: {
+        url,
+        key: "AIzaSyBEDaW4FxSZ2s1vz5CdD5Ai6PGZGdAzij0",
+        strategy: "desktop"
+      }
+    });
+
+    // extract results
+    const mobile = Math.round(resMobile.data.lighthouseResult.categories.performance.score * 100);
+    const desktop = Math.round(resDesktop.data.lighthouseResult.categories.performance.score * 100);
+
+    return {mobile, desktop};
+  } catch (err) { return err; }
+};
+
+async function singleStack(url) {
+  const wappalyzer = await new Wappalyzer;
+
+  let result;
+  try {
+    await wappalyzer.init();
+
+    const { technologies } = await wappalyzer.open(url).analyze();
+
+    result = technologies.map(({
+      name,
+      website,
+      categories
+    }) => ({
+      techName: name,
+      techWebsite: website,
+      techCategories: categories.map(({ name }) => name).join(", ")
+    }));
+  } catch (err) { result = err; }
+
+  await wappalyzer.destroy();
+  return result;
 }
 
-// call the message title and question list
-console.clear();
-question();
 
+// exports
+exports = {
+  animeSearch,
+  bitlyInfo,
+  cryptoMarket,
+  githubInfo,
+  controllerInfo,
+  osDetail,
+  diskInfo,
+  displayInfo,
+  biosInfo,
+  cpuInfo,
+  ramMemInfo,
+  movieDB,
+  multipleStack,
+  pageSpeed,
+  singleStack
+};