update update script

Author: krausest

cli.js

@@ -2,7 +2,7 @@
 import { program } from "commander";
 
 import {
-  checkObsoleteFrameworks,
+  updateFrameworks,
   cleanFrameworkDirectories,
   configureStyles,
   copyProjectToDist,
@@ -17,11 +17,11 @@ program.command("zip").description("Create a zip archive of frameworks").action(
 program.command("copy").description("Copy project to dist directory").action(copyProjectToDist);
 
 program
-  .command("check-obsolete")
-  .description("Check for obsolete frameworks in the frameworks directory")
-  .option("--debug [boolean]", "", false)
+  .command("update-frameworks")
+  .option("--type [types...]", "", ["keyed", "non-keyed"])
+  .description("Update implementations in the frameworks directory")
   .action((options) => {
-    checkObsoleteFrameworks(options);
+    updateFrameworks(options);
   });
 
 program

cli/index.js

@@ -1,4 +1,4 @@
-export { checkObsoleteFrameworks } from "./check-obsolete.js";
+export { updateFrameworks } from "./update-frameworks.js";
 export { cleanFrameworkDirectories } from "./cleanup.js";
 export { configureStyles } from "./configure-styles.js";
 export { copyProjectToDist } from "./copy.js";

cli/rebuild-build-single.js

@@ -22,7 +22,7 @@ Pass list of frameworks
  * @param {string|undefined} cwd - The current working directory (optional)
  */
 function runCommand(command, cwd) {
-  console.log(command);
+  console.log(`running '${command}' in '${cwd}'`);
   if (cwd && !fs.existsSync(cwd)) {
     throw `working directory ${cwd} doesn't exist.`;
   }
@@ -54,7 +54,7 @@ function rebuildFramework(framework, useCi) {
     console.log(`ERROR: invalid name ${framework}. It must contain exactly one /.`);
     process.exit(1);
   }
-
+  console.log("Rebuilding framework", framework);
   const [keyed, name] = components;
   const frameworkPath = path.join("frameworks", keyed, name);
 

cli/rebuild-check-single.js

@@ -33,10 +33,10 @@ export function rebuildCheckSingle({ frameworks }) {
   const frameworkNames = frameworks.join(" ");
 
   try {
-    const benchCmd = `npm run bench -- --headless true --smoketest true ${frameworkNames}`;
+    const benchCmd = `npm run bench -- --runner playwright  --headless true --smoketest true ${frameworkNames}`;
     runCommand(benchCmd, "webdriver-ts");
 
-    const keyedCmd = `npm run isKeyed -- --headless true ${frameworkNames}`;
+    const keyedCmd = `npm run isKeyed -- --runner playwright --headless true ${frameworkNames}`;
     runCommand(keyedCmd, "webdriver-ts");
 
     const cspCmd = `npm run checkCSP -- --headless true ${frameworkNames}`;

cli/rebuild-single-framework.js

@@ -34,6 +34,7 @@ export function rebuildSingleFramework({ frameworks, ci }) {
 
     rebuildCheckSingle({ frameworks });
   } catch (error) {
+    console.log("ERROR", error);
     console.log(`ERROR: Rebuilding  ${frameworks} was not successful`);
   }
 }

cli/check-obsolete.js renamed to cli/update-frameworks.js

@@ -3,8 +3,10 @@ import JSON5 from "json5";
 import { execSync } from "node:child_process";
 import * as fs from "node:fs";
 import path from "node:path";
+import semver from 'semver'
 
 import { getFrameworks } from "./helpers/frameworks.js";
+import { rebuildSingleFramework } from "./rebuild-single-framework.js";
 
 /**
  * @typedef {Object} Framework
@@ -14,6 +16,23 @@ import { getFrameworks } from "./helpers/frameworks.js";
 
 const frameworks = getFrameworks();
 
+
+function performUpdate(frameworkPath, frameworkName) {
+  console.log(`Updating ${frameworkName}`);
+  try {
+    const npmCmd = `ncu -u`;
+    execSync(npmCmd, {
+      cwd: frameworkPath,
+      stdio: "inherit",
+    });
+    rebuildSingleFramework({frameworks: [frameworkName], ci: false});
+    return `Sucessfully updated ${frameworkPath}`;
+  } catch (error) {
+    console.error(`Failed to update ${frameworkPath}. Error Code ${error.status} and message: ${error.message}`);
+    return `Failed to update ${frameworkPath}`;
+  }
+}
+
 /**
  * Looks for duplicate frameworks
  * @param {{type: string, name: string}[]} frameworks
@@ -29,9 +48,56 @@ function findDuplicateFrameworks(frameworks) {
 const duplicateFrameworks = findDuplicateFrameworks(frameworks);
 const frameworksCache = new Map();
 
-/**
- * @param {string} packageName
- */
+function getVersionFromPackageLock(packageJSONLockPath, packageNames) {
+  if (!fs.existsSync(packageJSONLockPath)) {
+    throw new Error(`package-lock.json not found at ${packageJSONLockPath}`);
+  }
+
+  let versions = {};
+
+  for (let packageName of packageNames) {
+    const packageLockJSON = JSON.parse(fs.readFileSync(packageJSONLockPath, "utf8"));
+    const packageVersion =
+    packageLockJSON.dependencies?.[packageName]?.version ||
+    packageLockJSON.packages?.[`node_modules/${packageName}`]?.version ||
+    "ERROR: Not found in package-lock";
+    versions[packageName] = packageVersion;
+  }
+  return versions;
+}
+
+function shouldUpdate(packageJSONLockPath, packageNames, DEBUG) {
+  try {
+    let versions = getVersionFromPackageLock(packageJSONLockPath, packageNames);
+    console.log(versions);
+
+    for (let packageName of packageNames) {
+      const npmCmd = `npm view ${packageName} version`;
+
+
+      const newestVersion = execSync(npmCmd, {
+        stdio: ["ignore", "pipe", "ignore"],
+      }).toString();
+
+      let res = semver.diff(versions[packageName], newestVersion);
+      console.log(`Latest version for ${packageName} is ${newestVersion} and the 
+        current version is ${versions[packageName]} comparison result is ${res}`);
+        if (res === 'major' || res === 'minor') {
+          if (DEBUG) {
+            console.log(`Update required for ${packageName}`);
+          }
+          return true;
+        }
+    }
+  } catch (error) {
+    console.error(
+      `Failed to get latest versions for ${packageNames}. Error Code ${error.status} and message: ${error.message}`
+    );
+    return { isObsolete: false, lastUpdate: null, packageNames };
+  }    
+  return false;
+}
+
 function maybeObsolete(packageName) {
   try {
     const npmCmd = `npm view ${packageName} time`;
@@ -82,14 +148,19 @@ const manualChecks = [];
  * @param {Object} options
  * @param {boolean} options.debug
  */
-export function checkObsoleteFrameworks({ debug }) {
-  console.log("Check obsolete frameworks", "debug", debug);
+export function updateFrameworks({ type, debug }) {
+  let types = type || ["keyed", "non-keyed"];
+  console.log("Check implementations for updates", "debug", debug,"type", type);  
+  let log = [];
 
   const DEBUG = debug;
 
   for (const { name, type } of frameworks) {
+    if (!types.includes(type)) continue
+    console.log(`Checking ${type}/${name}`);  
     const frameworkPath = path.join("frameworks", type, name);
     const packageJSONPath = path.join(frameworkPath, "package.json");
+    const packageJSONLockPath = path.join(frameworkPath, "package-lock.json");
 
     if (!fs.existsSync(packageJSONPath)) {
       missingPackageWarnings.push(`WARN: skipping ${type}/${name} since there's no package.json`);
@@ -109,28 +180,29 @@ export function checkObsoleteFrameworks({ debug }) {
     }
 
     const packages = mainPackages.split(":");
-    const isPackageObsolete = packages.map((element) => maybeObsolete(element));
-
-    if (DEBUG) {
-      console.log(`Results for ${type}/${name} ${isPackageObsolete}`);
-    }
-
-    const anyPackageObsolete = isPackageObsolete.some((packageFramework) => packageFramework.isObsolete);
-
-    if (anyPackageObsolete) {
-      const formattedPackages = isPackageObsolete
-        .map((result) => `${result.packageName}:${result.lastUpdate}`)
-        .join(", ");
-
-      console.log(`Last npm update for ${type}/${name} - ${mainPackages} is older than a year: ${formattedPackages}`);
-      continue;
-    }
-
-    if (DEBUG) {
-      console.log(`Last npm update for ${type}/${name} ${mainPackages} is newer than a year`);
+    const update = shouldUpdate(packageJSONLockPath, packages);
+    
+    if (update) {
+      log.push(performUpdate(frameworkPath, type+"/"+name));
+    } else {
+      const isPackageObsolete = packages.map((element) => maybeObsolete(element));
+      const anyPackageObsolete = isPackageObsolete.some((packageFramework) => packageFramework.isObsolete);
+  
+      if (anyPackageObsolete) {
+        const formattedPackages = isPackageObsolete
+          .map((result) => `${result.packageName}:${result.lastUpdate}`)
+          .join(", ");
+  
+        console.log(`Last npm update for ${type}/${name} - ${mainPackages} is older than a year: ${formattedPackages}`);
+        log.push(`Retire ${type}/${name} - ${mainPackages} is older than a year`);
+      }  
+      else if (DEBUG) {
+        log.push(`Nothing to do for ${type}/${name}`);
+      }
     }
   }
 
+  console.log("Log:\n", log.join("\n"));
   if (missingPackageWarnings.length > 0) console.warn("\nWarnings:\n" + missingPackageWarnings.join("\n"));
   if (manualChecks.length > 0)
     console.warn("\nThe following frameworks must be checked manually\n" + manualChecks.join("\n"));