如何存储 Node.js 部署设置/配置文件？

Question

我一直在开发一些 Node 应用程序，并且一直在寻找一种存储部署相关设置的良好模式。在 Django 世界（我来自的地方）中，常见的做法是拥有一个包含标准设置（时区等）的 settings.py 文件，然后是一个 local_settings.py< /code> 用于部署特定设置，即。与什么数据库通信，什么内存缓存套接字，管理员的电子邮件地址等等。

我一直在为 Node.js 寻找类似的模式。只要有一个配置文件就很好了，因此它不必与 app.js 中的其他所有内容混在一起，但我发现有一种方法可以在文件中包含特定于服务器的配置，这一点很重要这不在源代码管理中。同一个应用程序很可能部署在具有截然不同设置的不同服务器上，并且必须处理合并冲突以及所有这些都不是我的乐趣所在。

那么是否有某种框架/工具可以实现这一点，或者每个人都自己一起开发一些东西？

Answer 1

我使用 package.json 作为我的包，使用 config.js 作为我的配置，它看起来像：

var config = {};

config.twitter = {};
config.redis = {};
config.web = {};

config.default_stuff =  ['red','green','blue','apple','yellow','orange','politics'];
config.twitter.user_name = process.env.TWITTER_USER || 'username';
config.twitter.password=  process.env.TWITTER_PASSWORD || 'password';
config.redis.uri = process.env.DUOSTACK_DB_REDIS;
config.redis.host = 'hostname';
config.redis.port = 6379;
config.web.port = process.env.WEB_PORT || 9980;

module.exports = config;

我从我的项目加载配置：

var config = require('./config');

然后我可以访问我的来自 config.db_host、config.db_port 等的内容...这使我可以使用硬编码参数，或者如果我不想存储，则可以使用存储在环境变量中的参数源代码管理中的密码。

我还生成 package.json 并插入依赖项部分：

"dependencies": {
  "cradle": "0.5.5",
  "jade": "0.10.4",
  "redis": "0.5.11",
  "socket.io": "0.6.16",
  "twitter-node": "0.0.2",
  "express": "2.2.0"
}

当我将项目克隆到本地计算机时，我运行 npm install 来安装软件包。有关该内容的更多信息此处。

该项目存储在 GitHub 中，并为我的生产服务器添加了遥控器。

Answer 2

从 Node v0.5.x 开始，您可以要求 JSON 文件（引用此答案）

config.json:

{
    "username" : "root",
    "password" : "foot"
}

app.js:

var config = require('./config.json');
log_in(config.username, config.password);

Answer 3

很久以后，我发现了一个非常好的用于管理配置的 Node.js 模块：nconf。

一个简单的例子：

var nconf = require('nconf');

// First consider commandline arguments and environment variables, respectively.
nconf.argv().env();

// Then load configuration from a designated file.
nconf.file({ file: 'config.json' });

// Provide default values for settings not provided above.
nconf.defaults({
    'http': {
        'port': 1337
    }
});

// Once this is in place, you can just use nconf.get to get your settings.
// So this would configure `myApp` to listen on port 1337 if the port
// has not been overridden by any of the three configuration inputs
// mentioned above.
myApp.listen(nconf.get('http:port'));

它还支持在 Redis 中存储设置，编写配置文件，并且具有相当可靠的 API，并且还得到以下之一的支持更多受人尊敬的 Node.js 商店 Nodejitsu，作为 Flatiron 的一部分 框架倡议，所以它应该是相当面向未来的。

查看 Github 上的 nconf。

Answer 4

我的解决方案相当简单：

在 ./config/index.js 中加载环境配置 在 ./config/config.global.js

var env = process.env.NODE_ENV || 'development'
  , cfg = require('./config.'+env);

module.exports = cfg;

中定义一些默认值

var config = module.exports = {};

config.env = 'development';
config.hostname = 'dev.example.com';

//mongo database
config.mongo = {};
config.mongo.uri = process.env.MONGO_URI || 'localhost';
config.mongo.db = 'example_dev';

覆盖 ./config/config.test.js 中的默认值

var config = require('./config.global');

config.env = 'test';
config.hostname = 'test.example';
config.mongo.db = 'example_test';

module.exports = config;

在 ./models 中使用它/user.js：

var mongoose = require('mongoose')
, cfg = require('../config')
, db = mongoose.createConnection(cfg.mongo.uri, cfg.mongo.db);

在测试环境中运行您的应用程序：

NODE_ENV=test node ./app.js

Answer 5

您还可以查看dotenv，它遵循12个原则-因素应用程序。

我曾经使用node-config，但出于这个原因创建了dotenv。它完全受到 ruby​​ 的 dotenv 库的启发。

使用非常简单：

var dotenv = require('dotenv');
dotenv.load();

然后您只需创建一个 .env 文件并将设置放入其中，如下所示：

S3_BUCKET=YOURS3BUCKET
SECRET_KEY=YOURSECRETKEYGOESHERE
OTHER_SECRET_STUFF=my_cats_middle_name

这就是 Nodejs 的 dotenv 。

Answer 6

你们使用 npm 来启动脚本（env 等）吗？

如果您使用 .env 文件，您可以将它们包含在 package.json 中
并使用 npm 来获取/启动它们。

示例：

{
  "name": "server",
  "version": "0.0.1",
  "private": true,
  "scripts": {
    "start": "node test.js",
    "start-dev": "source dev.env; node test.js",
    "start-prod": "source prod.env; node test.js"
  },
  "dependencies": {
    "mysql": "*"
  }
}

然后运行 ​​npm 脚本：

$ npm start-dev

此处描述 https://gist.github.com/ericelliott/4152984
全部归功于埃里克·埃利奥特

Answer 7

您还可以查看 node-config ，它根据 $HOST 和 $NODE_ENV 变量（有点像 RoR）：文档。

这对于不同的部署设置（开发、测试或生产）非常有用。

Answer 8

只需使用 exports 执行一个简单的 settings.js：

exports.my_password = 'value'

然后，在您的脚本中执行 require：

var settings = require('./settings.js');

现在您的所有设置都将通过 <代码>设置变量：

settings.my_password // 'value'

Answer 9

Convict 是另一个添加验证模式的选项。与 nconf 一样，它支持从环境变量、参数、文件和 json 对象的任意组合加载设置。

自述文件中的示例：

var convict = require('convict');
var conf = convict({
  env: {
    doc: "The applicaton environment.",
    format: ["production", "development", "test"],
    default: "development",
    env: "NODE_ENV"
  },
  ip: {
    doc: "The IP address to bind.",
    format: "ipaddress",
    default: "127.0.0.1",
    env: "IP_ADDRESS",
  },
  port: {
    doc: "The port to bind.",
    format: "port",
    default: 0,
    env: "PORT"
  }
});

入门文章：
使用 node-convict 驯服配置

Answer 10

我要在这里表示敬意，因为这些答案都没有解决几乎任何系统所需的所有关键组件。注意事项：

• 公共配置（前端可以看到）与私有配置（莫格拉比（mograbi）做对了）。并确保它们分开保存。
• 密钥等秘密
• 默认值与特定于环境的覆盖
• 前端捆绑包

以下是我的配置方式：

• config.default.private.js - 在版本控制中，这些是默认配置选项，只能由后端看到。
• config.default.public.js - 在版本控制中，这些是后端和前端可以看到的默认配置选项
• config.dev.private.js< /code> - 如果您需要不同的开发私有默认值。
• config.dev.public.js - 如果您需要不同的开发公共默认值。
• 的环境特定选项
• config.private.js - 不在版本控制中，这些是覆盖 config.default.private.js config.public.js > - 不在版本控制中，这些是覆盖 config.default.public.js 的环境特定选项
• keys/ - 每个文件存储某种不同秘密的文件夹。这也不受版本控制（密钥永远不应该受版本控制）。

我使用普通的 javascript 文件进行配置，因此我拥有 javascript 语言的全部功能（包括注释和执行诸如在特定于环境的文件中加载默认配置文件之类的操作的能力，以便可以覆盖它们）。如果你想使用环境变量，你可以将它们加载到这些配置文件中（尽管我建议不要使用环境变量，因为我不建议使用 json 文件的原因相同 - 你没有编程语言来构建的能力）你的配置）。

每个密钥位于单独的文件中的原因是供安装程序使用。这允许您拥有一个在计算机上创建密钥并将其存储在密钥文件夹中的安装程序。如果没有这个，当您加载无法访问密钥的配置文件时，安装程​​序可能会失败。通过这种方式，您可以遍历目录并加载该文件夹中的任何关键文件，而不必担心任何给定版本的代码中存在哪些文件以及不存在哪些文件。

由于您可能在私有配置中加载了密钥，因此您肯定不想在任何前端代码中加载您的私有配置。虽然将前端代码库与后端完全分离可能更理想，但很多时候 PITA 是一个足够大的障碍来阻止人们这样做，因此私有配置与公共配置。但是我做了两件事来防止在前端加载私有配置：

1. 我有一个单元测试，确保我的前端包不包含我在私有配置中拥有的密钥之一。
2. 我的前端代码与后端代码位于不同的文件夹中，并且我有两个名为“config.js”的不同文件 - 每一端一个。对于后端，config.js 加载私有配置，对于前端，它加载公共配置。然后你总是只需要 require('config') 并且不用担心它来自哪里。

最后一件事：您的配置应该通过一个与任何其他前端代码完全独立的文件加载到浏览器中。如果您捆绑前端代码，则公共配置应构建为完全独立的捆绑包。否则，您的配置不再是真正的配置 - 它只是代码的一部分。配置需要能够在不同的机器上有所不同。

Answer 11

您可以使用 Konfig 来获取特定于环境的配置文件。它自动加载 json 或 yaml 配置文件，具有默认值和动态配置功能。

Konfig 存储库中的示例：

File: config/app.json
----------------------------
{
    "default": {
        "port": 3000,
        "cache_assets": true,
        "secret_key": "7EHDWHD9W9UW9FBFB949394BWYFG8WE78F"
    },

    "development": {
        "cache_assets": false
    },

    "test": {
        "port": 3001
    },

    "staging": {
        "port": #{process.env.PORT},
        "secret_key": "3F8RRJR30UHERGUH8UERHGIUERHG3987GH8"
    },

    "production": {
        "port": #{process.env.PORT},
        "secret_key": "3F8RRJR30UHERGUH8UERHGIUERHG3987GH8"
    }
}

在开发中：

> config.app.port
3000

在生产中，假设我们使用 $ NODE_ENV=production PORT=4567 node app.js 启动应用程序

> config.app.port
4567

更多详细信息：https://github.com/vngrs/konfig

Answer 12

我将创建一个文件夹作为配置文件，命名为 config.js ，稍后我将在需要的地方使用此文件，如下所示

config.js 示例

module.exports = {
    proxyURL: 'http://url:port',
    TWITTER: {
        consumerkey: 'yourconsumerkey',
        consumerSecrete: 'yourconsumersecrete'
    },
    GOOGLE: {
        consumerkey: 'yourconsumerkey',
        consumerSecrete: 'yourconsumersecrete'
    },
    FACEBOOK: {
        consumerkey: 'yourconsumerkey',
        consumerSecrete: 'yourconsumersecrete'
    }
}

然后，如果我想在某处使用此配置文件，

我将首先如下导入

var config = require('./config');

我可以访问以下值

const oauth = OAuth({
    consumer: {
        key: config.TWITTER.consumerkey,
        secret: config.TWITTER.consumerSecrete
    },
    signature_method: 'HMAC-SHA1',
    hash_function(base_string, key) {
        return crypto.createHmac('sha1', key).update(base_string).digest('base64');
    }
});

Answer 13

只需使用npm模块config（超过300000次下载）

https://www.npmjs.com/package/config

Node-config 为您的应用程序部署组织分层配置。

它允许您定义一组默认参数，并将它们扩展到不同的部署环境（开发、质量保证、登台、生产等）。

$ npm install config
$ mkdir config
$ vi config/default.json


{
      // Customer module configs
      "Customer": {
        "dbConfig": {
          "host": "localhost",
          "port": 5984,
          "dbName": "customers"
        },
        "credit": {
          "initialLimit": 100,
          // Set low for development
          "initialDays": 1
        }
      }
}



$ vi config/production.json

{
  "Customer": {
    "dbConfig": {
      "host": "prod-db-server"
    },
    "credit": {
      "initialDays": 30
    }
  }
}



$ vi index.js

var config = require('config');
//...
var dbConfig = config.get('Customer.dbConfig');
db.connect(dbConfig, ...);

if (config.has('optionalFeature.detail')) {
  var detail = config.get('optionalFeature.detail');
  //...
}


$ export NODE_ENV=production
$ node index.js

Answer 14

有点晚了（仅仅 10 年），但我使用了如下结构的 config.js：

const env = process.env.NODE_ENV || 'development';

var config_temp = {
    default:{
        port: 3000,
        mysql_host: "localhost",
        logging_level: 5,
        secret_api_key: process.env.SECRET_API_KEY
    },
    development: {
        logging_level: 10
    },
    production: {
        port: 3001,
        mysql_host: "not-localhost"
    }
};
var config = {
    ...config_temp.default, 
    ...config_temp[env]
}
module.exports = config;

我加载配置：

var config = require('./config');
var port = config.port;

以这种方式：

• 读取 env 变量包含在 config.js 文件中，这样我就可以避免这种丑陋的情况： require('./config')[process.env.NODE_ENV || '开发']。
• 文件 config.js 可以上传到代码存储库中，因为敏感变量继续由 process.env 处理。
• 如果 default:{ 和 custom_env:{ 中都包含相同的元素，则仅保留第二个元素。
• 没有专用文件夹和多个文件（如 config 中所示）

Answer 15

我知道这是一篇非常旧的帖子。但我想分享我的用于配置环境变量的模块，我认为这是非常灵活的解决方案。
这是模块 json-configurator

var configJson = {
  'baseUrl': 'http://test.com',
  '$prod_baseUrl': 'https://prod.com',
  'endpoints': {
    'users': '<%= baseUrl %>/users',
    'accounts': '<%= baseUrl %>/accounts'
    },
  foo: 'bar',
  foobar: 'foobar',
  $prod_foo: 'foo in prod',
  $test_foo: 'foo in test',
  deep:{
    veryDeep: {
      publicKey: 'abc',
      secret: 'secret',
      $prod_secret: 'super secret'
    }
  }
};

var config = require('json-configurator')(configJson, 'prod');

console.log(config.deep.veryDeep.secret) 
// super secret 

console.log(config.endpoints.users)
// https://prod.com/users 

然后你可以使用 process.env.NODE_ENV 获取您的环境的所有变量。

Answer 16

最好将'开发'和'生产'配置分开。

我使用以下方式：
这是我的 config/index.js 文件：

const config = {
    dev : {
        ip_address : '0.0.0.0',
        port : 8080,
        mongo :{
            url : "mongodb://localhost:27017/story_box_dev",
            options : ""
        }
    },
    prod : {
        ip_address : '0.0.0.0',
        port : 3000,
        mongo :{
            url : "mongodb://localhost:27017/story_box_prod",
            options : ""
        }
    }
} 

对于需要配置，请使用以下内容：

const config = require('../config')[process.env.NODE_ENV];

您可以使用您的配置对象：

const ip_address = config.ip_address;
const port = config.port;

Answer 17

我在游戏中有点晚了，但我在这里或其他地方找不到我需要的东西，所以我自己写了一些东西。

我对配置机制的要求如下：

1. 支持前端。如果前端不能使用配置还有什么意义呢？
2. 支持 settings-overrides.js - 看起来相同，但允许覆盖 settings.js 中的配置。这里的想法是在不更改代码的情况下轻松修改配置。我发现它对于 saas 很有用。

即使我不太关心支持环境 - 也会解释如何将其轻松添加到我的解决方案

var publicConfiguration = {
    "title" : "Hello World"
    "demoAuthToken" : undefined, 
    "demoUserId" : undefined, 
    "errorEmail" : null // if null we will not send emails on errors. 

};

var privateConfiguration = {
    "port":9040,
    "adminAuthToken":undefined,
    "adminUserId":undefined
}

var meConf = null;
try{
    meConf = require("../conf/dev/meConf");
}catch( e ) { console.log("meConf does not exist. ignoring.. ")}




var publicConfigurationInitialized = false;
var privateConfigurationInitialized = false;

function getPublicConfiguration(){
    if (!publicConfigurationInitialized) {
        publicConfigurationInitialized = true;
        if (meConf != null) {
            for (var i in publicConfiguration) {
                if (meConf.hasOwnProperty(i)) {
                    publicConfiguration[i] = meConf[i];
                }
            }
        }
    }
    return publicConfiguration;
}


function getPrivateConfiguration(){
    if ( !privateConfigurationInitialized ) {
        privateConfigurationInitialized = true;

        var pubConf = getPublicConfiguration();

        if ( pubConf != null ){
            for ( var j in pubConf ){
                privateConfiguration[j] = pubConf[j];
            }
        }
        if ( meConf != null ){
              for ( var i in meConf ){
                  privateConfiguration[i] = meConf[i];
              }
        }
    }
    return privateConfiguration;

}


exports.sendPublicConfiguration = function( req, res ){
    var name = req.param("name") || "conf";

    res.send( "window." + name + " = " + JSON.stringify(getPublicConfiguration()) + ";");
};


var prConf = getPrivateConfiguration();
if ( prConf != null ){
    for ( var i in prConf ){
        if ( prConf[i] === undefined ){

            throw new Error("undefined configuration [" + i + "]");
        }
        exports[i] = prConf[i];
    }
}


return exports;

中 解释

• undefined 表示此属性是必需的
• null 表示它是可选的
• meConf - 目前代码的目标是 app 下的文件。 meConf 是针对 conf/dev 的覆盖文件 - 它被我的 vcs 忽略。
• publicConfiguration - 从前端和后端可见。
• privateConfiguration - 仅在后端可见。

• sendPublicConfiguration - 将公开公共配置并将其分配给全局变量的路由。例如，下面的代码将在前端将公共配置公开为全局变量 myConf。默认情况下它将使用全局变量名称conf。

  app.get("/backend/conf", require("conf").sendPublicConfiguration);

覆盖 privateConfiguration 的逻辑

• 与 publicConfiguration 合并，然后与 meConf 合并。
• publicConfiguration 检查每个键是否有覆盖，并使用该覆盖。这样我们就不会暴露任何隐私。

添加环境支持

尽管我不认为“环境支持”有用，但也许有人会。

要添加环境支持，您需要将 meConf require 语句更改为类似这样的内容（伪代码）

if (environment == "Production") {
meConf = require("../conf/dev/meConf"). Production;
}

if (环境==“开发”){
meConf = require("../conf/dev/meConf").development;
同样，

您可以为每个环境创建一个文件

 meConf.development.js
 meConf.production.js

并导入正确的文件。
其余逻辑保持不变。

Answer 18

我刚刚使用的替代示例是因为我想要比典型的 .json 文件更灵活，但不希望将其抽象到需要依赖项的库中，就像这样。基本上，导出一个立即调用的函数，该函数返回一个具有我想要设置的值的对象。提供很大的灵活性。

     module.exports = function(){
       switch(node_env){
         case 'dev':
           return
           { var1 = 'development'};
         }
    }();

这里有一个更好的解释和完整的例子。 在 Node.js 中使用配置文件

Answer 19

这是一种受这篇文章启发的简洁方法。除了无处不在的 lodash 包之外，它不需要任何其他包。此外，它还允许您通过特定于环境的覆盖来管理嵌套默认值。

首先，在包根路径中创建一个 config 文件夹，如下所示，

package
  |_config
      |_ index.js
      |_ defaults.json
      |_ development.json
      |_ test.json
      |_ production.json

这里是 index.js 文件

const _ = require("lodash");
const defaults = require("./defaults.json");
const envConf = require("./" + (process.env.NODE_ENV || "development") + ".json" );
module.exports = _.defaultsDeep(envConf, defaults);

现在假设我们有一个像这样的 defaults.json

{
  "confKey1": "value1",
  "confKey2": {
    "confKey3": "value3",
    "confKey4": "value4"
  }
}

和像这样的development.json，

{
  "confKey2": {
    "confKey3": "value10",
  }
}

如果您执行 config = require(' ./config') 这是您将得到的内容

{
  "confKey1": "value1",
  "confKey2": {
    "confKey3": "value10",
    "confKey4": "value4"
  }
}

。请注意，您将获得除特定于环境的文件中定义的值之外的所有默认值。因此您可以管理配置层次结构。使用defaultsDeep可以确保您甚至可以拥有嵌套的默认值。

Answer 20

npm i config

In config/default.json
{
    "app": {
        "port": 3000
    },
    "db": {
        "port": 27017,
        "name": "dev_db_name"
    }
}

In config/production.json
{
    "app": {
        "port": 4000
    },
    "db": {
        "port": 27000,
        "name": "prod_db_name"
    }
}

In index.js

const config = require('config');

let appPort = config.get('app.port');
console.log(`Application port: ${appPort}`);

let dbPort = config.get('db.port');
console.log(`Database port: ${dbPort}`);

let dbName = config.get('db.name');
console.log(`Database name: ${dbName}`);

console.log('NODE_ENV: ' + config.util.getEnv('NODE_ENV'));

$ node index.js
Application port: 3000
Database port: 27017
Database name: dev_db_name
NODE_ENV: development

For production
$ set NODE_ENV=production
$ node index.js
Application port: 4000
Database port: 27000
Database name: prod_db_name
NODE_ENV: production

Answer 21

除了 nconf 模块 /5869216/how-to-store-node-js-deployment-settings-configuration-files/8563528#8563528">这个答案，以及node-config 1411373">这个答案，还有node-iniparser和 IniReader，它们似乎是更简单的 .ini 配置文件解析器。

Answer 22

我最近刚刚发布了一个小模块来加载任何类型的配置文件。
这非常简单，您可以在 https://github.com/flesler/config-node< /a>

Answer 23

您可以使用 pconf： https://www.npmjs.com/package/pconf

示例：

var Config = require("pconf");
var testConfig = new Config("testConfig");
testConfig.onload = function(){

  testConfig.setValue("test", 1);
  testConfig.getValue("test");
  //testConfig.saveConfig(); Not needed

}

Answer 24

我使用 Dotenv-Flow 进行配置管理。

这正在按预期工作。很多时候你有多个
本地、开发、登台和生产等环境。只要流动这些
创建您自己的环境的步骤。

1. npm i dotenv-flow。

2. 创建类似 .env | 的文件.env.dev | .env.prod。

出于测试目的，请复制此内容

.env

DATABASE_HOST=global
DATABASE_PORT=global
DATABASE_USER=global
DATABASE_PASS=global
DATABASE_NAME=global

.env.dev

DATABASE_NAME=dev
DATABASE_PASS=dev

.env.prod

DATABASE_NAME=prod
DATABASE_PASS=prod

现在使用这些环境变量创建一个测试文件。

test.js

console.log('database host:', process.env.DATABASE_HOST);
console.log('database port:', process.env.DATABASE_PORT);
console.log('database user:', process.env.DATABASE_USER);
console.log('database pass:', process.env.DATABASE_PASS);
console.log('database name:', process.env.DATABASE_NAME);

< strong>现在使用这些命令来运行您的脚本。

node -r dotenv-flow/config test.js
node -r dotenv-flow/config test.js --node-env=dev
node -r dotenv-flow/config test.js --node-env=prod

如果您在特定文件夹中创建这些环境变量文件，就像在我的例子中一样，我已在 envs 文件夹中创建了这些文件，然后使用以下命令。 >

node -r dotenv-flow/config test.js --dotenv-flow-path=./envs
node -r dotenv-flow/config test.js --dotenv-flow-path=./envs --node-env=dev
node -r dotenv-flow/config test.js --dotenv-flow-path=./envs --node-env=prod

Answer 25

对于那些访问这个旧线程的人来说，这里有一个我认为很好的包。

https://www.npmjs.org/package/config

Answer 26

我在这里尝试了一些建议的解决方案，但对它们不满意，所以我创建了自己的模块。它称为 mikro-config，主要区别在于它遵循约定优于配置，因此您只需需要该模块即可开始使用它。

您可以将配置存储在 /config 文件夹中的纯 js 或 json 文件中。首先，它加载 default.js 文件，然后加载 /config 目录中的所有其他文件，然后根据 $NODE_ENV 变量加载环境特定配置。

它还允许使用 local.js 或特定于环境的 /config/env/$NODE_ENV.local.js 覆盖此配置以进行本地开发。

您可以在这里查看它：

https://www.npmjs.com/package/mikro -config

https://github.com/B4nan/mikro-config

Answer 27

长期以来，我一直使用此处解决方案中提到的方法。然而，人们对明文秘密的安全性存在担忧。您可以在 config 之上使用另一个包，以便处理安全位。

看看这个： https://www .attosol.com/secure-application-secrets-using-masterkey-in-azure-key-vault/

Answer 28

我们如何使用 TypeScript 做到这一点。

export const loadConfig = () => {
    const configLoadeded = configLoader.util.toObject() as any
    Config = configLoadeded
}

export interface ConfigI {
    productName: string;
    productId: string;
    googleCloudApiKey: string;
}

Answer 29

如今，在使用数据库时，最简单的方法是根本不处理配置文件，因为仅使用单个环境变量（例如，将其称为 DB_CONNECTION）即可更轻松地设置部署环境，并且根据需要向其传递任何其他配置数据。

配置数据示例：

const config = {
    userIds: [1, 2, 3],
    serviceLimit: 100,
    // etc., configuration data of any complexity    
};
// or you can read it from a config file

创建一个连接字符串，其中包含数据库驱动程序不关心的额外参数：

import {ConnectionString} from 'connection-string';

const cs = new ConnectionString('postgres://localhost@dbname', {
    user: 'user-name',
    password: 'my-password',
    params: {
        config
    }  ​
});

然后我们可以生成结果字符串以将其存储在环境中：

cs.toString();
//=>postgres://localhost:my-password@dbname?config=%7B%22userIds%22%3A%5B1%2C2%2C3%5D%2C%22serviceLimit%22%3A100%7D

因此您可以将其存储在您的环境中，比方说，DB_CONNECTION，在客户端进程中，您可以通过 process.env.DB_CONNECTION 读取它：

const cs = new ConnectionString(process.env.DB_CONNECTION);

const config = JSON.parse(cs.params?.config); // parse extra configuration
//=> { userIds: [ 1, 2, 3 ], serviceLimit: 100 }

这样您将同时拥有连接和所有额外的信息。所需的配置全部在一个单一的环境变量，无需搞乱配置文件。

Answer 30

尝试使用properties-gen
https://www.npmjs.com/package/properties-gen

非常类似于node-config 加载配置基础文件并根据您设置的环境使用 ext 文件对其进行扩展，但这是一个按需运行且完全可配置的 cli。

npx properties-gen init

要创建 cli 配置，然后将其安装在项目中

npm install properties-gen --save-dev

定义配置文件（基本文件和扩展文件）并在构建过程之前或在项目中启动开发服务器之前运行 generate 命令。

{
  "name": "myApp",
  "scripts": {
    "config": "properties-gen generate",
    "dev": "npm run config && next dev",
    "build": "npm run config && next build",
    "start": "next start"
  }
}

一件很酷的事情是，您可以定义多个配置组，以防您需要生成多个输出，例如客户端和服务器特定文件。