@saltcorn/plugins-loader 1.0.0-beta.9 → 1.0.0-rc.10

package/download_utils.js

@@ -2,7 +2,7 @@ const fs = require("fs");
 const { rm } = require("fs").promises;
 const { mkdir, pathExists } = require("fs-extra");
 const { tmpName } = require("tmp-promise");
-const { execSync } = require("child_process");
+const { execFileSync } = require("child_process");
 const { extract } = require("tar");
 const { join } = require("path");
 const { createWriteStream, unlink } = require("fs");
@@ -93,7 +93,10 @@ const loadTarball = (rootFolder, url, name) => {
  */
 const gitPullOrClone = async (plugin, pluginDir) => {
   let keyfnm,
-    setKey = `-c core.sshCommand="ssh -oBatchMode=yes -o 'StrictHostKeyChecking no'" `;
+    setKey = [
+      "-c",
+      `core.sshCommand="ssh -oBatchMode=yes -o 'StrictHostKeyChecking no'"`,
+    ];
   if (plugin.deploy_private_key) {
     keyfnm = await tmpName();
     await fs.promises.writeFile(
@@ -104,12 +107,15 @@ const gitPullOrClone = async (plugin, pluginDir) => {
         encoding: "ascii",
       }
     );
-    setKey = `-c core.sshCommand="ssh -oBatchMode=yes -o 'StrictHostKeyChecking no' -i ${keyfnm}" `;
+    setKey = [
+      "-c",
+      `core.sshCommand="ssh -oBatchMode=yes -o 'StrictHostKeyChecking no' -i ${keyfnm}"`,
+    ];
   }
   if (fs.existsSync(pluginDir)) {
-    execSync(`git ${setKey} -C ${pluginDir} pull`);
+    execFileSync("git", [...setKey, "-C", pluginDir, "pull"]);
   } else {
-    execSync(`git ${setKey} clone ${plugin.location} ${pluginDir}`);
+    execFileSync("git", [...setKey, "clone", plugin.location, pluginDir]);
   }
   if (plugin.deploy_private_key && keyfnm) await fs.promises.unlink(keyfnm);
 };

package/package.json

@@ -1,20 +1,36 @@
 {
   "name": "@saltcorn/plugins-loader",
-  "version": "1.0.0-beta.9",
+  "version": "1.0.0-rc.10",
   "description": "Saltcorn plugin loader",
   "homepage": "https://saltcorn.com",
   "scripts": {
-    "test": "echo 'No tests'",
+    "test": "jest --runInBand",
     "tsc": "echo 'No TypeScript build'",
     "clean": "echo 'No TypeScript build'"
   },
   "dependencies": {
     "env-paths": "^2.2.0",
-    "npm-registry-fetch": "16.0.0",
-    "@saltcorn/data": "1.0.0-beta.9"
+    "npm-registry-fetch": "17.1.0",
+    "@saltcorn/data": "1.0.0-rc.10"
   },
   "author": "Christian Hugo",
   "license": "MIT",
+  "jest": {
+    "testEnvironment": "node",
+    "testPathIgnorePatterns": [
+      "/node_modules/",
+      "/plugin_packages/",
+      "/plugins_folder/"
+    ],
+    "coveragePathIgnorePatterns": [
+      "/node_modules/",
+      "/plugin_packages/",
+      "/plugins_folder/"
+    ],
+    "moduleNameMapper": {
+      "@saltcorn/data/(.*)": "<rootDir>/../saltcorn-data/dist/$1"
+    }
+  },
   "main": "index.js",
   "repository": "github:saltcorn/saltcorn",
   "publishConfig": {

package/plugin_installer.js

@@ -11,6 +11,7 @@ const {
 const { getState } = require("@saltcorn/data/db/state");
 const { rm, rename, cp, readFile } = require("fs").promises;
 const envPaths = require("env-paths");
+const semver = require("semver");
 
 const staticDeps = ["@saltcorn/markup", "@saltcorn/data", "jest"];
 const fixedPlugins = ["@saltcorn/base-plugin", "@saltcorn/sbadmin2"];
@@ -25,19 +26,34 @@ const readPackageJson = async (filePath) => {
   else return null;
 };
 
-const npmInstallNeeded = (oldPckJSON, newPckJSON) => {
-  const oldDeps = oldPckJSON.dependencies || {};
-  const oldDevDeps = oldPckJSON.devDependencies || {};
-  const newDeps = newPckJSON.dependencies || {};
-  const newDevDeps = newPckJSON.devDependencies || {};
-  return (
-    JSON.stringify(oldDeps) !== JSON.stringify(newDeps) ||
-    JSON.stringify(oldDevDeps) !== JSON.stringify(newDevDeps)
-  );
+/**
+ * install when the new package.json has different dependencies
+ * or when the source is local and there are any dependencies
+ * @param source
+ * @param oldPckJSON
+ * @param newPckJSON
+ * @returns
+ */
+const npmInstallNeeded = (source, oldPckJSON, newPckJSON) => {
+  if (source === "local") {
+    return (
+      Object.keys(newPckJSON.dependencies || {}).length > 0 ||
+      Object.keys(newPckJSON.devDependencies || {}).length > 0
+    );
+  } else {
+    const oldDeps = oldPckJSON.dependencies || Object.create(null);
+    const oldDevDeps = oldPckJSON.devDependencies || Object.create(null);
+    const newDeps = newPckJSON.dependencies || Object.create(null);
+    const newDevDeps = newPckJSON.devDependencies || Object.create(null);
+    return (
+      JSON.stringify(oldDeps) !== JSON.stringify(newDeps) ||
+      JSON.stringify(oldDevDeps) !== JSON.stringify(newDevDeps)
+    );
+  }
 };
 
 class PluginInstaller {
-  constructor(plugin, opts = {}) {
+  constructor(plugin, opts = Object.create(null)) {
     this.plugin = plugin;
     this.rootFolder =
       opts.rootFolder || envPaths("saltcorn", { suffix: "plugins" }).data;
@@ -56,13 +72,34 @@ class PluginInstaller {
     this.pckJsonPath = join(this.pluginDir, "package.json");
     this.tempDir = join(this.tempRootFolder, "temp_install", ...tokens);
     this.tempPckJsonPath = join(this.tempDir, "package.json");
+    this.scVersion = opts.scVersion;
+    this.envVars = opts.envVars || {};
+  }
+
+  /**
+   * check if the host supports the plugin and return a warning if not
+   * @param pckJSON
+   * @returns
+   */
+  checkEngineWarning(pckJSON) {
+    const scEngine = pckJSON.engines?.saltcorn;
+    if (
+      this.scVersion &&
+      scEngine &&
+      !semver.satisfies(this.scVersion, scEngine)
+    ) {
+      const warnMsg = `Plugin ${this.plugin.name} requires Saltcorn version ${scEngine} but running ${this.scVersion}`;
+      getState().log(4, warnMsg);
+      return warnMsg;
+    }
+    return null;
   }
 
   async install(force) {
     await this.ensurePluginsRootFolders();
     if (fixedPlugins.includes(this.plugin.location))
       return { plugin_module: require(this.plugin.location) };
-
+    const msgs = [];
     let pckJSON = await readPackageJson(this.pckJsonPath);
     const installer = async () => {
       if (await this.prepPluginsFolder(force, pckJSON)) {
@@ -72,7 +109,11 @@ class PluginInstaller {
         );
         if (
           !pckJSON ||
-          npmInstallNeeded(await this.removeDependencies(pckJSON), tmpPckJSON)
+          npmInstallNeeded(
+            this.plugin.source,
+            await this.removeDependencies(pckJSON),
+            tmpPckJSON
+          )
         )
           await this.npmInstall(tmpPckJSON);
         await this.movePlugin();
@@ -80,6 +121,8 @@ class PluginInstaller {
           await removeTarball(this.rootFolder, this.plugin);
       }
       pckJSON = await readPackageJson(this.pckJsonPath);
+      const msg = this.checkEngineWarning(pckJSON);
+      if (msg && !msgs.includes(msg)) msgs.push(msg);
     };
     await installer();
     let module = null;
@@ -108,6 +151,7 @@ class PluginInstaller {
       location: this.pluginDir,
       name: this.plugin.name,
       loadedWithReload,
+      msgs,
     };
   }
 
@@ -142,6 +186,9 @@ class PluginInstaller {
       case "local":
         if (force || !folderExists) {
           await copy(this.plugin.location, this.tempDir);
+          // if tempdir has a node_modules folder, remove it
+          if (await pathExists(join(this.tempDir, "node_modules")))
+            await rm(join(this.tempDir, "node_modules"), { recursive: true });
           wasLoaded = true;
         }
         break;
@@ -233,6 +280,7 @@ class PluginInstaller {
     ) {
       const child = spawn("npm", ["install"], {
         cwd: this.tempDir,
+        env: { ...process.env, ...this.envVars },
         ...(isWindows ? { shell: true } : {}),
       });
       return new Promise((resolve, reject) => {

package/stable_versioning.js

@@ -0,0 +1,104 @@
+const semver = require("semver");
+const { getState } = require("@saltcorn/data/db/state");
+
+/*
+ internal helper
+*/
+const doCheck = (pluginVersion, versionInfos, scVersion) => {
+  if (!versionInfos[pluginVersion])
+    throw new Error(`Version ${pluginVersion} not found in available versions`);
+  const scEngine = versionInfos[pluginVersion].engines?.saltcorn;
+  if (!scEngine) return true;
+  if (semver.validRange(scEngine) === null) {
+    getState().log(4, `invalid engine property: ${scEngine}`);
+    return true;
+  }
+  if (semver.valid(scVersion) === null) {
+    getState().log(4, `invalid saltcorn version: ${scVersion}`);
+    return true;
+  }
+  return semver.satisfies(scVersion, scEngine);
+};
+
+/**
+ * check if 'pluginVersion' is supported or find the latest supported version
+ * @param pluginVersion - wanted version
+ * @param versionInfos - version infos from the npm registry (resembles the package.json version).
+ *                            Here you'll find the engines.saltcorn property.
+ * @param scVersion - optional saltcorn version (if not set it will be taken from the state)
+ * @returns
+ */
+const supportedVersion = (
+  pluginVersion = "latest",
+  versionInfos,
+  scVersion
+) => {
+  const resolved =
+    pluginVersion === "latest" ? resolveLatest(versionInfos) : pluginVersion;
+  const safeScVersion = scVersion || getState().scVersion;
+  if (doCheck(resolved, versionInfos, safeScVersion)) return resolved;
+  else {
+    const keys = Object.keys(versionInfos);
+    keys.sort((a, b) => semver.rcompare(b, a));
+    // iterate in reverse order to get the latest version
+    for (let i = keys.length - 1; i >= 0; i--) {
+      const version = keys[i];
+      if (doCheck(version, versionInfos, safeScVersion)) return version;
+    }
+    return null;
+  }
+};
+
+/**
+ * check if 'pluginVersion' is supported
+ * @param pluginVersion - wanted version
+ * @param scEngine - version infos from the npm registry (resembles the package.json version)
+ *                        Here you'll find the engines.saltcorn property.
+ *                        If versionInfos is a string, it will be treated as the engines.saltcorn property.
+ * @param scVersion - optional saltcorn version (if not set it will be taken from the state)
+ */
+const isVersionSupported = (pluginVersion, scEngine, scVersion) => {
+  const safeInfos =
+    typeof scEngine === "string"
+      ? { [pluginVersion]: { engines: scEngine } }
+      : scEngine;
+  const safeScVersion = scVersion || getState().scVersion;
+  return doCheck(pluginVersion, safeInfos, safeScVersion);
+};
+
+/**
+ * check if 'scVersion' fullfilles 'scEngine'
+ * @param scEngine fixed version or range of saltcorn versions (e.g. ">=1.0.0")
+ * @param scVersion optional saltcorn version (if not set it will be taken from the state)
+ * @returns true if the saltcorn version fullfilles scEngine
+ */
+const isEngineSatisfied = (scEngine, scVersion) => {
+  if (!scEngine) return true;
+  if (semver.validRange(scEngine) === null) {
+    getState().log(4, `invalid engine property: ${scEngine}`);
+    return true;
+  }
+  const safeScVersion = scVersion || getState().scVersion;
+  if (semver.valid(safeScVersion) === null) {
+    getState().log(4, `invalid saltcorn version: ${scVersion}`);
+    return true;
+  }
+  return semver.satisfies(safeScVersion, scEngine);
+};
+
+/**
+ * change latest to the actual version
+ * @param versionInfos - version infos from the npm registry
+ */
+const resolveLatest = (versionInfos) => {
+  const keys = Object.keys(versionInfos);
+  keys.sort((a, b) => semver.rcompare(a, b));
+  return keys[0];
+};
+
+module.exports = {
+  isVersionSupported,
+  isEngineSatisfied,
+  supportedVersion,
+  resolveLatest,
+};

package/tests/stable_versioning.test.js

@@ -0,0 +1,263 @@
+const npmFetch = require("npm-registry-fetch");
+const semver = require("semver");
+
+const {
+  supportedVersion,
+  isVersionSupported,
+} = require("../stable_versioning");
+
+jest.setTimeout(30000);
+
+const getSortedKeys = (pkgInfo) => {
+  const keys = [...Object.keys(pkgInfo.versions)];
+  keys.sort((a, b) => semver.rcompare(a, b));
+  return keys;
+};
+
+describe("Stable versioning", () => {
+  it("stays compatible to version 1.0.0", async () => {
+    const wantedVersion = "latest";
+    const scVersion = "1.0.0";
+    const plugin = {
+      location: "@saltcorn/html",
+      version: wantedVersion,
+    };
+    const pkgInfo = await npmFetch.json(
+      `https://registry.npmjs.org/${plugin.location}`
+    );
+    const sortedKeys = getSortedKeys(pkgInfo);
+    pkgInfo.versions[sortedKeys[0]].engines = { saltcorn: ">=1.0.1" };
+    pkgInfo.versions[sortedKeys[1]].engines = { saltcorn: ">=1.0.1-beta.1" };
+    pkgInfo.versions[sortedKeys[2]].engines = { saltcorn: "<=1.0.0" };
+    pkgInfo.versions[sortedKeys[3]].engines = { saltcorn: ">=1.0.0-beta.1" };
+    const result = supportedVersion(
+      plugin.version,
+      pkgInfo.versions,
+      scVersion
+    );
+    expect(result).toBe(sortedKeys[2]);
+    expect(isVersionSupported(sortedKeys[0], pkgInfo.versions, scVersion)).toBe(
+      false
+    );
+    expect(isVersionSupported(sortedKeys[1], pkgInfo.versions, scVersion)).toBe(
+      false
+    );
+    expect(isVersionSupported(sortedKeys[2], pkgInfo.versions, scVersion)).toBe(
+      true
+    );
+    expect(isVersionSupported(sortedKeys[3], pkgInfo.versions, scVersion)).toBe(
+      true
+    );
+  });
+
+  it("picks one fixed version instead of a range", async () => {
+    const wantedVersion = "latest";
+    const scVersion = "1.0.0";
+    const plugin = {
+      location: "@saltcorn/html",
+      version: wantedVersion,
+    };
+    const pkgInfo = await npmFetch.json(
+      `https://registry.npmjs.org/${plugin.location}`
+    );
+    const sortedKeys = getSortedKeys(pkgInfo);
+    pkgInfo.versions[sortedKeys[0]].engines = { saltcorn: ">=1.0.1" };
+    pkgInfo.versions[sortedKeys[1]].engines = { saltcorn: ">=1.0.1-beta.1" };
+    pkgInfo.versions[sortedKeys[2]].engines = { saltcorn: "1.0.0" };
+    pkgInfo.versions[sortedKeys[3]].engines = { saltcorn: ">=1.0.0-beta.1" };
+    const result = supportedVersion(
+      plugin.version,
+      pkgInfo.versions,
+      scVersion
+    );
+    expect(result).toBe(sortedKeys[2]);
+    expect(isVersionSupported(sortedKeys[0], pkgInfo.versions, scVersion)).toBe(
+      false
+    );
+    expect(isVersionSupported(sortedKeys[1], pkgInfo.versions, scVersion)).toBe(
+      false
+    );
+    expect(isVersionSupported(sortedKeys[2], pkgInfo.versions, scVersion)).toBe(
+      true
+    );
+    expect(isVersionSupported(sortedKeys[3], pkgInfo.versions, scVersion)).toBe(
+      true
+    );
+  });
+
+  it("warns and takes invalid engine properties", async () => {
+    const wantedVersion = "latest";
+    const scVersion = "1.0.0";
+    const plugin = {
+      location: "@saltcorn/html",
+      version: wantedVersion,
+    };
+    const pkgInfo = await npmFetch.json(
+      `https://registry.npmjs.org/${plugin.location}`
+    );
+    const sortedKeys = getSortedKeys(pkgInfo);
+    pkgInfo.versions[sortedKeys[0]].engines = { saltcorn: ">=1.0.1" };
+    // invalid: >=1.0.1.beta.1 should be >=1.0.1-beta.1
+    pkgInfo.versions[sortedKeys[1]].engines = { saltcorn: ">=1.0.1.beta.1" };
+    pkgInfo.versions[sortedKeys[2]].engines = { saltcorn: "<=1.0.0" };
+    pkgInfo.versions[sortedKeys[3]].engines = { saltcorn: ">=1.0.0-beta.1" };
+    const result = supportedVersion(
+      plugin.version,
+      pkgInfo.versions,
+      scVersion
+    );
+    expect(result).toBe(sortedKeys[1]);
+  });
+
+  it("downgrades latest with greater equal", async () => {
+    const wantedVersion = "latest";
+    const scVersion = "1.0.0-beta.6";
+    const plugin = {
+      location: "@saltcorn/html",
+      version: wantedVersion,
+    };
+    const pkgInfo = await npmFetch.json(
+      `https://registry.npmjs.org/${plugin.location}`
+    );
+    const sortedKeys = getSortedKeys(pkgInfo);
+    pkgInfo.versions[sortedKeys[0]].engines = { saltcorn: ">=1.0.0-beta.7" };
+    pkgInfo.versions[sortedKeys[1]].engines = { saltcorn: ">=1.0.0-beta.6" };
+    const result = supportedVersion(
+      plugin.version,
+      pkgInfo.versions,
+      scVersion
+    );
+    expect(result).toBe(sortedKeys[1]);
+    expect(isVersionSupported(result, pkgInfo.versions, scVersion)).toBe(true);
+    expect(isVersionSupported(sortedKeys[0], pkgInfo.versions, scVersion)).toBe(
+      false
+    );
+  });
+
+  it("takes latest with smaller equal", async () => {
+    const wantedVersion = "latest";
+    const scVersion = "1.0.0-beta.6";
+    const plugin = {
+      location: "@saltcorn/html",
+      version: wantedVersion,
+    };
+    const pkgInfo = await npmFetch.json(
+      `https://registry.npmjs.org/${plugin.location}`
+    );
+    const sortedKeys = getSortedKeys(pkgInfo);
+    pkgInfo.versions[sortedKeys[0]].engines = { saltcorn: "<=1.0.0-beta.7" };
+    pkgInfo.versions[sortedKeys[1]].engines = { saltcorn: "<=1.0.0-beta.6" };
+    const result = supportedVersion(
+      plugin.version,
+      pkgInfo.versions,
+      scVersion
+    );
+    expect(result).toBe(sortedKeys[0]);
+    expect(isVersionSupported(result, pkgInfo.versions, scVersion)).toBe(true);
+    expect(isVersionSupported(sortedKeys[0], pkgInfo.versions, scVersion)).toBe(
+      true
+    );
+  });
+
+  it("resolves latest to the current version", async () => {
+    const wantedVersion = "latest";
+    const scVersion = "1.0.0-beta.6";
+    const plugin = {
+      location: "@saltcorn/html",
+      version: wantedVersion,
+    };
+    const pkgInfo = await npmFetch.json(
+      `https://registry.npmjs.org/${plugin.location}`
+    );
+    const sortedKeys = getSortedKeys(pkgInfo);
+    pkgInfo.versions[sortedKeys[0]].engines = { saltcorn: ">=1.0.0-beta.6" };
+    pkgInfo.versions[sortedKeys[1]].engines = { saltcorn: ">=1.0.0-beta.6" };
+    const result = supportedVersion(
+      plugin.version,
+      pkgInfo.versions,
+      scVersion
+    );
+    expect(result).toBe(sortedKeys[0]);
+    expect(isVersionSupported(result, pkgInfo.versions, scVersion)).toBe(true);
+    expect(isVersionSupported(sortedKeys[1], pkgInfo.versions, scVersion)).toBe(
+      true
+    );
+  });
+
+  it("it takes the latest version, all engine properties are missing", async () => {
+    const wantedVersion = "latest";
+    const scVersion = "1.0.0-beta.6";
+    const plugin = {
+      location: "@saltcorn/html",
+      version: wantedVersion,
+    };
+    const pkgInfo = await npmFetch.json(
+      `https://registry.npmjs.org/${plugin.location}`
+    );
+    const sortedKeys = getSortedKeys(pkgInfo);
+    for (const key of sortedKeys) pkgInfo.versions[key].engines = undefined;
+    const result = supportedVersion(
+      plugin.version,
+      pkgInfo.versions,
+      scVersion
+    );
+    expect(result).toBe(sortedKeys[0]);
+    expect(isVersionSupported(result, pkgInfo.versions, scVersion)).toBe(true);
+    expect(isVersionSupported(sortedKeys[1], pkgInfo.versions, scVersion)).toBe(
+      true
+    );
+  });
+
+  it("takes a version without the engines property", async () => {
+    const wantedVersion = "latest";
+    const scVersion = "1.0.0-beta.6";
+    const plugin = {
+      location: "@saltcorn/html",
+      version: wantedVersion,
+    };
+    const pkgInfo = await npmFetch.json(
+      `https://registry.npmjs.org/${plugin.location}`
+    );
+    const sortedKeys = getSortedKeys(pkgInfo);
+    pkgInfo.versions[sortedKeys[0]].engines = { saltcorn: ">=1.0.0-beta.7" };
+    pkgInfo.versions[sortedKeys[1]].engines = { saltcorn: ">=1.0.0-beta.7" };
+    pkgInfo.versions[sortedKeys[2]].engines = undefined;
+    const result = supportedVersion(
+      plugin.version,
+      pkgInfo.versions,
+      scVersion
+    );
+    expect(result).toBe(sortedKeys[2]);
+    expect(isVersionSupported(result, pkgInfo.versions, scVersion)).toBe(true);
+    expect(isVersionSupported(sortedKeys[0], pkgInfo.versions, scVersion)).toBe(
+      false
+    );
+    expect(isVersionSupported(sortedKeys[1], pkgInfo.versions, scVersion)).toBe(
+      false
+    );
+    expect(isVersionSupported(sortedKeys[2], pkgInfo.versions, scVersion)).toBe(
+      true
+    );
+  });
+
+  it("finds no supported version", async () => {
+    const wantedVersion = "latest";
+    const scVersion = "1.0.0-beta.6";
+    const plugin = {
+      location: "@saltcorn/html",
+      version: wantedVersion,
+    };
+    const pkgInfo = await npmFetch.json(
+      `https://registry.npmjs.org/${plugin.location}`
+    );
+    const sortedKeys = getSortedKeys(pkgInfo);
+    for (const key of sortedKeys)
+      pkgInfo.versions[key].engines = { saltcorn: ">=1.0.0-beta.7" };
+    const result = supportedVersion(
+      plugin.version,
+      pkgInfo.versions,
+      scVersion
+    );
+    expect(result).toBeNull();
+  });
+});