Maintaining native module dependencies for node.js and electron at the same time - node.js

Question

I am trying to build an Electron app that requires nodegit, which is a native module. As far as I know, a native module's native library must targets the same NODE_MODULE_VERSION as the run-time engine (I mean Node.js or Electron) does.
For example, if my Electron runs with NODE_MODULE_VERSION 64, then my nodegit should be installed with a native library that targets NODE_MODULE_VERSION 64.
Current I have some tests in my project, and I would like to run them on both Electron and Node.js. Because (1) Electron is closer to the environment of the final product and (2) Node.js is much easier to debug.
To achieve this goal, the native module must be compatible with both Electron and Node.js at the same time. However, this is nearly impossible.
The funny thing is that, from the charts that list the NODE_MODULE_VERSION of Electron versions (it is called Chrome version in this chart) and Node.js versions, their NODE_MODULE_VERSION rarely match. It is hard to find a Electron version that uses a Node.js which also use the same NODE_MODULE_VERSION. As a consequence, I have to settle down with Electron and Node.js using different NODE_MODULE_VERSION. In other words, the native module can only be compatible with either Electron or Node.js, not both of them.
I am curious about if it is possible to separate the native module used by Node.js and Electron without rebuilding the module or is there a version switching functionality to let me quickly switch the version of the native module?
Or it would be event better if anyone can share a way to make the Electron and Node.js use the same NODE_MODULE_VERSION.

Answer 1

Don't know if there is a better solution, I came up with an extremely simple script that copy and paste module files with environment selection (attached below).
Would still greatly appreciate any good idea about how to solve this problem.
'use strict';
const fs = require('fs-extra');
const path = require('path');
let args = process.argv.slice(2);
let cachePath = path.resolve(__dirname, '../.module_cache');
let configPath = path.join(cachePath, '.config');
let modulePath = path.resolve(__dirname, '../node_modules');
wrapper(args)
.catch(err => {
console.error(err);
})
function wrapper(args) {
switch (args[0]) {
case 'save':
return saveModule(args[1], args[2]);
case 'load':
return loadModule(args[1], args[2]);
case 'drop':
if (args.length === 3) {
return dropModuleEnvironment(args[1]);
}
else {
return dropModule(args[1]);
}
case 'ls':
return listModules();
case 'which':
return printWhichModule(args[1]);
case 'versions':
return listModuleVersions(args[1]);
case 'help':
printUsage();
return Promise.resolve();
default:
printUsage();
return Promise.reject(new Error("Unexcepted arguments: " + args.join(', ')));
}
}
function printUsage() {
console.log(`
Usage:
save <module> <environment>: cache a module environment for later use
load <module> <environment>: load a previously saved module environment, and set it to be active
drop <module> [environment]: remove all cached module environments,
or when [environment] is provided, remove the specified environment
ls: list all cached modules and their current environment
which <module>: show the active environment for the module
versions <module>: list all available environments for the module. Active environment is marked by "*"
help: show this help info`);
}
function saveModule(moduleName, envName) {
let storePath = path.join(cachePath, moduleName, envName);
let sourcePath = path.join(modulePath, moduleName);
return fs.emptyDir(storePath)
.then(() => {
return fs.copy(sourcePath, storePath);
})
.then(() => {
return updateConfig(moduleName, ".system.");
});
}
function loadModule(moduleName, envName) {
let storePath = path.join(cachePath, moduleName, envName);
let targetPath = path.join(modulePath, moduleName);
return whichModuleVersion(moduleName)
.then(currentVersion => {
if (currentVersion === envName) {
console.log(`Not loading ${envName} for ${moduleName} because it is current version`);
return Promise.resolve();
}
else {
return fs.emptyDir(targetPath)
.then(() => {
return fs.copy(storePath, targetPath);
})
.then(() => {
return updateConfig(moduleName, envName);
})
}
})
}
function dropModuleEnvironment(moduleName, envName) {
let storePath = path.join(cachePath, moduleName, envName);
return fs.remove(storePath)
.then(() => {
return fs.readFile(configPath)
.then(configRaw => {
let config = JSON.parse(configRaw);
let currentEnv = config[moduleName];
if (currentEnv && currentEnv === envName) {
config[currentEnv] = '.system.';
}
return JSON.stringify(config);
})
.then(configRaw => {
return fs.writeFile(configPath, configRaw);
});
});
}
function dropModule(moduleName) {
return fs.remove(path.join(cachePath, moduleName))
.then(() => {
return fs.readFile(configPath)
.then(configRaw => {
let config = JSON.parse(configRaw);
if (config[moduleName]) {
delete config[moduleName];
}
return JSON.stringify(config);
})
.then(configRaw => {
return fs.writeFile(configPath, configRaw);
});
})
}
function listModules() {
return fs.readFile(configPath)
.then(configRaw => {
let config = JSON.parse(configRaw);
Object.keys(config).forEach(moduleName => {
printModuleVersion(moduleName, config[moduleName]);
})
})
}
function printWhichModule(moduleName) {
return whichModuleVersion(moduleName)
.then(version => {
printModuleVersion(moduleName, version);
});
}
function listModuleVersions(moduleName) {
let modulePath = path.join(cachePath, moduleName);
return fs.exists(modulePath)
.then(exists => {
if (exists) {
let currentVersion;
return whichModuleVersion(moduleName)
.then(version => currentVersion = version)
.then(() => fs.readdir(modulePath))
.then(envNames => {
envNames.forEach(envName => {
if (currentVersion === envName) {
console.log('* ' + envName);
}
else {
console.log(' ' + envName);
}
});
});
}
else {
console.log('not installed');
}
})
}
function whichModuleVersion(moduleName) {
return fs.readFile(configPath)
.then(configRaw => {
let config = JSON.parse(configRaw);
return config[moduleName];
});
}
function printModuleVersion(moduleName, moduleVersion) {
console.log(`${moduleName}: ${moduleVersion || 'not installed'}`);
}
function updateConfig(moduleName, envName) {
return fs.readFile(configPath)
.then(configRaw => {
let config = JSON.parse(configRaw);
config[moduleName] = envName;
return JSON.stringify(config);
})
.then(configRaw => {
fs.writeFile(configPath, configRaw);
})
}