Callbacks

Here's how you'd create your array of promises and use it to aggregate ans then invoke your cb() once. I also suggest using the Node.js callback convention of cb(error, result) rather than cb(result), since there are multiple steps that can error, and the caller of getDestination() should be notified both when the query succeeds or when it fails.

static getDestination (envName, cb) {
  DataBase.initDB(db => {
    const envCollection = db.collection('Environment');
    const promises = envName.map(value => new Promise((resolve, reject) => {
      envCollection.find({ environmentName: value }, (error, data) => {
        if (error) return reject(error);

        data.toArray((error, content) => {
          if (error) reject(error);
          else resolve(content);
        });
      });
    }));

    Promise.all(promises).then(contents => {
      const ans = contents.reduce(
        (ans, content) => content.reduce(
          (ans, doc) => ans.add(doc.destination),
          ans
        ),
        new Set()
      );

      cb(null, [...ans]);
    }).catch(error => {
      cb(error);
    });
  });
}

Notice that each new Promise() is constructed synchronously, and resolve() or reject() is called asynchronously. This is necessary because your database queries do not already return a Promise.

If you use an API that does return promises, you should avoid the explicit promise construction antipattern and chain from the existing promises instead.

I also optimized your aggregation of ans by using a Set instead of an array, so we can actually omit checking for existing values since a set only keeps one of each unique value unlike an array.

Promise chains

If you want your getDestination() function to return a promise instead of accepting a callback, you can rewrite it like this:

static getDestination (envName) {
  return new Promise(resolve => {
    DataBase.initDB(resolve);
  }).then(db => {
    const envCollection = db.collection('Environment');
    const promises = envName.map(value => new Promise((resolve, reject) => {
      envCollection.find({ environmentName: value }, (error, data) => {
        if (error) return reject(error);

        data.toArray((error, content) => {
          if (error) reject(error);
          else resolve(content);
        });
      });
    }));

    return Promise.all(promises);
  }).then(contents => {
    const ans = contents.reduce(
      (ans, content) => content.reduce(
        (ans, doc) => ans.add(doc.destination),
        ans
      ),
      new Set()
    );

    return [...ans];
  });
}

The key differences are:

• wrap DataBase.initDB() in another Promise because the result depends on db
• return the promise chain from getDestination()
• return [...ans] from .then() instead of passing it to a callback
• remove .catch() and let the caller handle any errors

Notice that because we return Promises.all(promises) from a .then(), we can get contents from the outer promise instead of chaining to the inner Promise.all(). This is one of the major benefits that promises offer to escape from callback hell.

Async / Await

Lastly, if you want to use async / await instead of .then(), you can rewrite it once more like this:

static async getDestination (envName) {
  const db = await new Promise(resolve => {
    DataBase.initDB(resolve);
  });

  const envCollection = db.collection('Environment');
  const promises = envName.map(value => new Promise((resolve, reject) => {
    envCollection.find({ environmentName: value }, (error, data) => {
      if (error) return reject(error);

      data.toArray((error, content) => {
        if (error) reject(error);
        else resolve(content);
      });
    });
  }));

  const contents = await Promise.all(promises);
  const ans = contents.reduce(
    (ans, content) => content.reduce(
      (ans, doc) => ans.add(doc.destination),
      ans
    ),
    new Set()
  );

  return [...ans];
}

The key difference here is that each

return somePromise.then(someVariable => { ... });

is replaced by

const someVariable = await somePromise;
...

Modularization

P.S. if you want to remove the constructed promises from your getDestination() function, you can refactor your code into two helper functions that can be used like this:

static getCollection (collectionName) {
  return new Promise(resolve => {
    DataBase.initDB(resolve);
  }).then(
    db => db.collection(collectionName)
  );
}

static getDocuments (collection, ...args) {
  return new Promise((resolve, reject) => {
    collection.find(...args, (error, data) => {
      if (error) return reject(error);

      data.toArray((error, content) => {
        if (error) reject(error);
        else resolve(content);
      });
    });
  });
}

static async getDestination (envName) {
  const envCollection = await this.getCollection('Environment');
  const promises = envName.map(
    environmentName => this.getDocuments(
      envCollection,
      { environmentName }
    )
  );

  const contents = await Promise.all(promises);
  const ans = contents.reduce(
    (ans, content) => content.reduce(
      (ans, doc) => ans.add(doc.destination),
      ans
    ),
    new Set()
  );

  return [...ans];
}

It may be slightly more code than before, but now you have two re-usable functions that can be called from other kinds of queries besides getDestination().