runtime-eol/index.js

check runtime versions

#!/usr/bin/env node

const child_process = require("child_process");

const argHelper = require('./helpers/arg');
const eol = require('./helpers/eol');
const sls = require("./helpers/adapters/sls");
const ver = require("./helpers/version");

const extractTargetVersion = (collection, label, lvl='min') => {
  const found = collection.find(x => x.label === label);
  if( !found ){
    console.error('extract - not found - label = %s | collection = %j',
      label, collection.map(x => x.label)
    );
    return 'not_found';
  }

  return found[lvl].cycle;
};

const verifyTool = (name, ref, local) => {

  const localVersion = typeof(local) === 'function' ? local() : local;
  if( !localVersion || localVersion === 'unknown' ){
    console.log('did not find local version for = %s ⚠️', name)
    return false;
  }

  if( typeof(ref) === 'string' ){
    const msg = `${name} - system = ${localVersion} | target = ${ref}`
    const compareResult = ver.compareVersions(localVersion, ref);
    if( compareResult < 0 ){
      console.warn(msg + ` => current is Lower than target ❌`);
      return false;
    }
    
    console.log(msg + ' => OK ✅');
    return true;
  }
  else {
    const msg = `${name} - system = ${localVersion}`;
    const found = ref.find(r => r.cycle === localVersion);
    if( !found ){
      console.warn(msg + ` => Your version is Not Supported ❌`);
      return false;
    }
    else {
      console.log(msg + ' => OK ✅');
      return true;
    }
  }
};

const checker = (argTools, refTools, recommend=false) => {

  const results = [];
  const lvl = recommend ? 'recommended' : 'min';

  for(let t of argTools){
    if(t === 'node'){
      results.push(
        verifyTool('Node', extractTargetVersion(refTools, 'node', lvl), process.versions.node)
      );
    }
    else if(t === 'python'){
      results.push(
        verifyTool('Python', extractTargetVersion(refTools, 'python', lvl), () => {
          const p = child_process.execSync("python --version").toString();
          return p.replace('Python ', '').replace(/\s/g, '');
        })
      );
    }
    else if(t === 'sls'){
      const slsVersions = refTools.find(x => x.label === 'sls');
      results.push(
        verifyTool(
          'Lambda',
          slsVersions.supported,
          sls.getCurrent
        )
      );
    }
    else {
      results.push(
        verifyTool(
          t,
          extractTargetVersion(refTools, t, lvl),
          'unknown',
        )
      );
    }
  }

  return results;
};

const checkVersion = async (opts={}) => {

  const addTools = (opts.tools || []).map(x => {
    if(['aws-lambda', 'lambda'].includes(x)){
      return 'sls';
    }
    return x;
  });
  const targetTools = ['node', ...addTools];
  
  const reference = await eol.getReference(opts.skipRemote, targetTools);
  console.log('check - before - reference = %j', reference);
  console.log('## ⏩ ##');

  const results = checker(targetTools, reference.tools, opts.recommend);
  const positive = results.filter(x => x).length;
  const total = results.length;
  const pass = (total === positive);

  console.log('###');
  const emoji = pass ? "♥️" : "☹️";
  console.log('versions ok => %s out of %s %s', positive, total, emoji);
  return pass;
};

const main = (arg) => {
  const opts = argHelper.argParser(arg);

  if( opts.mode === 'help' ){
    return argHelper.printHelp();
  }
  if( opts.mode === 'check' ){
    return checkVersion(opts);
  }
};

module.exports = checkVersion;

if (require.main === module) {
  main(process.argv.slice(2));
}