返回异步数据，然后在 Node.js 中同步导出

Question

背景

我正在从 AWS Secrets Manager 返回数据并使用 aws-sdk 执行此操作。早些时候我问了一个关于如何正确返回数据并将其导出的问题，因为导出的对象在导出导入其他地方时从未解析过数据。这导致我得到一堆未定义的。

在解决了这个问题后，确定处理这个问题的方法是将 aws-sdk 函数包装在一个 Promise 中，然后在另一个文件中使用 async await 调用该 Promise。这给我带来了问题。

示例

如果我像这样从 AWS 请求并返回数据，

let secrets = {
  jwtHash: 10,
};

const client = new AWS.SecretsManager({
  region: region
});

const promise = new Promise((resolve, reject) => {
  client.getSecretValue({ SecretId: secretName }, async (err, data) => {
    if (err) {
      reject(err);
    } else {
      const res = await JSON.parse(data.SecretString);
      secrets.dbUsername = res.username;
      secrets.dbPassword = res.password;
      secrets.dbHost = res.host;
      secrets.dbPort = res.port;
      secrets.dbDatabase = res.dbname;
      resolve(secrets);
    }
  });
});

module.exports = promise;

然后我可以将它导入另一个文件并使用这样的数据，

const promise = require('../secrets');

(async () => {
  const secrets = await promise;
  // use secrets here
})();

现在假设在我尝试使用机密的那个文件中，我有这样的东西，

const pool = new Pool({
  user: secrets.dbUsername,
  host: secrets.dbHost,
  database: secrets.dbDatabase,
  password: secrets.dbPassword,
  port: secrets.dbPort
});

pool.on('error', err => {
  console.error('Unexpected error on idle client', err);
  process.exit(-1);
});

module.exports = pool;

如果我将 pool 函数包装在异步自调用函数中，我将无法导出它，以便在我需要数据库连接时可以在我的应用程序的任何地方使用它。类似地，我的应用程序中有许多需要访问机密数据的功能。如果我要遍历将所有代码包装在异步函数中的应用程序，它将继续导致更多这些困难。

问题

在我看来，这里最好的解决方案是异步返回数据，一旦解决，同步导出。

如何在这种情况下完成这样的任务？

这里的胜利将是，

1. 在 /secrets/index.js 中提出请求
2. 在同一个文件中构建 secrets 对象
3. 将机密导出为对象，无需异步函数即可轻松导入应用程序的其他任何位置。

我想如何使用它的示例

const secrets = require('../secrets');

const pool = new Pool({
      user: secrets.dbUsername,
      host: secrets.dbHost,
      database: secrets.dbDatabase,
      password: secrets.dbPassword,
      port: secrets.dbPort
    });

    pool.on('error', err => {
      console.error('Unexpected error on idle client', err);
      process.exit(-1);
    });

    module.exports = pool;

Answer 1

因为所需的数据是异步获取的，所以无法将依赖它的所有内容（以某种方式）也设为异步。在涉及异步性的情况下，一种可能性是通常导出可以按需调用的函数，而不是导出对象：

• 在数据返回之前无法有意义地导出依赖于异步数据的对象
• 如果您导出函数而不是对象，您可以确保控制流从您的单个入口点开始并流向下游，而不是每个模块都同时初始化自身（当某些模块可能会出现问题）如您所见，依赖于其他人来正确初始化）

另一方面，请注意，如果您有一个需要解析的Promise，则在其上调用.then 可能比使用async 函数更容易。例如，而不是

const promise = require('../secrets');

(async () => {
  // try/catch is needed to handle rejected promises when using await:
  try {
    const secrets = await promise;
    // use secrets here
  } catch(e) {
    // handle errors
  }
})();

你可以考虑：

const promise = require('../secrets');

promise
  .then((secrets) => {
    // use secrets here
  })
  .catch((err) => {
    // handle errors
  });

它不那么冗长，而且可能更容易一目了然 - 比自我调用 async IIFE 更好。 IMO，使用await 的地方是当你有多个 Promises 需要解决，链接.thens 和返回Promises 一起变得太丑陋了。

依赖secrets 执行的模块必须 在其代码中具有有效等待secrets 填充的内容。虽然能够在您的较低代码示例中使用您的const secrets = require('../secrets'); 将是很好，但这是不可能的。您可以导出一个将secrets 作为参数 而不是require 的函数，然后（同步！）return 实例化pool：

// note, secrets is *not* imported
function makePool(secrets) {
  const pool = new Pool({
    user: secrets.dbUsername,
    host: secrets.dbHost,
    database: secrets.dbDatabase,
    password: secrets.dbPassword,
    port: secrets.dbPort
  });

  pool.on('error', err => {
    console.error('Unexpected error on idle client', err);
    process.exit(-1);
  });
  return pool;
}

module.exports = makePool;

然后，要在另一个模块中使用它，一旦创建了secrets，使用secrets 调用makePool，然后使用/传递返回的pool：

const secretsProm = require('../secrets');
const makePool = require('./makePool');
secretsProm.then((secrets) => {
  const pool = makePool(secrets);
  doSomethingWithPool(pool);
})
.catch((err) => {
  // handle errors
});

请注意，doSomethingWithPool 函数可以是完全同步的，makePool 也是如此 - secrets 的异步特性，一旦在 one 中使用 .then 处理> 模块，不必在其他任何地方异步处理，只要其他模块导出函数，而不是对象。

Answer 2

我建议在 1 个文件中完成所有操作，然后不要导出您创建的对象，而是导出一个返回对象的函数。该函数将始终可以访问对象的最新版本，您可以从任何文件调用它来访问同一对象。

示例： 在一个文件夹中创建两个文件。在第一个文件中，我们将这样做：

• 定义一个值。
• 设置超时以在一段时间后更改值
• 导出值本身
• 导出一个返回值的函数

values.js

let x = 0 ; // set initial value
setTimeout(() => { x = 5; }, 2000); // sometime later, value will change

const getValueOfX = () => { return x; }; 

module.exports = {
    x: x,
    getValueOfX: getValueOfX
}; 

现在在另一个文件中，我们只是从前一个文件中导入两个导出（我们将它们都放在一个对象中以便于导出）。然后我们可以注销它们，等待一段时间过去，然后再次注销它们。

index.js

let values = require('./values');

console.log(`Single value test. x = ${values.x}`);
console.log(`Function return value test. x = ${values.getValueOfX()}`);
setTimeout(() => { console.log(`Single value test. x = ${values.x}`); }, 4000);
setTimeout(() => { console.log(`Function return value test. x = ${values.getValueOfX()}`); }, 4000);

要运行代码，只需打开终端或命令提示符，然后在与这两个文件相同的目录中运行 node index.js

您会看到，当仅导出值（对象、数组、w/e）时，它会在导出运行时按原样导出 - 几乎总是在 API 调用完成之前。

但是 - 如果您导出一个返回值的函数（对象、数组、w/e），那么该函数将在调用它时检索该值的最新版本！非常适合 API 调用！

所以您的代码可能如下所示：

let secrets = { jwtHash: 10 };
const client = new AWS.SecretsManager({
    region: region
});

let pool = null; 

client.getSecretValue({ SecretId: secretName }, async (err, data) => {
    if (err) {
        reject(err);
    } else {
        const res = await JSON.parse(data.SecretString);
        pool = new Pool({
            user: res.username,
            host: res.host
            database: res.dbname
            password: res.password
            port: res.port
        }); 
        pool.on('error', err=> {
            console.error('Unexpected error on idle client', err);
            process.exit(-1);
        }); 
    }
});

module.exports = function(){ return pool; };