同时维护Node.js和Electronic的本机模块依赖关系

Question

我正在尝试构建一个需要nodegit的电子应用程序，nodegit是一个原生模块。据我所知，本机模块的本机库必须与运行时引擎（我指的是Node.js或Electron）针对相同的node_module_version。

例如，如果我的电子以node_module_version64运行，那么我的nodegit应该安装以node_module_version64为目标的本机库。

目前我的项目中有一些测试，我想同时在Electron和Node.js上运行它们。因为(1)Electronic更接近最终产品的环境，(2)Node.js调试起来要容易得多。

要实现这一目标，本机模块必须同时与Electronic和Node.js兼容。然而，这几乎是不可能的。

有趣的是，从列出电子版（本图中称为chrome版本）和node.js版本的node_module_version的图表来看，它们的node_module_version很少匹配。很难找到使用node.js的电子版本，该版本同时使用相同的node_module_version。因此，我必须使用不同的node_module_version来处理Electron和node.js。换句话说，原生模块只能兼容Electron或Node.js中的任何一个，而不能同时兼容这两个。

我很好奇是否有可能将Node.js和Electronic使用的本机模块分开，而无需重新构建模块或者是否有版本切换功能让我快速切换本机模块的版本？

或者，如果任何人都能共享一种方法，使电子和node.js使用相同的node_module_version，那就更好了。

Answer 1

不知道有没有更好的解决方案，我想出了一个极其简单的脚本，用环境选择复制和粘贴模块文件（附在下面）。仍然会非常感激任何关于如何解决这个问题的好主意。

'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);
    })
}