How to use

flatMap

function

in

Collection

// Helper to get init source config
const getInitSourceConfig = dirs => _(dirs)
 .filter(dir => fs.existsSync(dir))
 .flatMap(dir => glob.sync(path.join(dir, '*.js')))
 .map(file => require(file))
 .flatMap(source => source.sources)
 .value()

// Helper to get init config
const getInitConfig = dirs => _(dirs)
 .filter(dir => fs.existsSync(dir))
 .flatMap(dir => glob.sync(path.join(dir, '*', 'init.js')))
 .map(file => require(file))
 .value()

_(files)
 .flatMap(file => traverseUp(path.resolve(startFrom, file)))
 .sortBy().reverse()
 .filter(file => fs.existsSync(file) && path.isAbsolute(file))
 .thru(files => _.isEmpty(files) ? [] : [_.first(files)])
 .flatMap(dirFile => _.map(files, file => path.join(path.dirname(dirFile), file)))
 .filter(file => fs.existsSync(file))
 .value()

// Add proxy URLS to our app info
  _.forEach(['post-start', 'post-init'], event => {
   app.events.on(event, () => {
    // Get last known ports
    const ports = lando.cache.get(lando.config.proxyCache);
    // Map to protocol and add portz
    // @TODO: do something more meaningful below like logging?, obviously starting to not GAS
    if (ports) {
     _(app.info)
      .filter(service => _.has(app, `config.proxy.${service.service}`))
      .flatMap(s => s.urls = _.uniq(s.urls.concat(utils.parse2Info(
       app.config.proxy[s.service],
       ports,
       _.get(s, 'hasCerts', false)
      ))))
      .value();
    }
   });
  });

_(_.merge(_.get(data, 'Config.ExposedPorts', []), {'443/tcp': {}}))
 .map((value, port) => ({
  port: _.head(port.split('/')),
  protocol: (_.includes(secured, port.split('/')[0])) ? 'https' : 'http'}
 ))
 .filter(exposed => _.includes(scan, exposed.port))
 .flatMap(ports => _.map(_.get(data, `NetworkSettings.Ports.${ports.port}/tcp`, []), i => _.merge({}, ports, i)))
 .filter(ports => _.includes([bindAddress, '0.0.0.0'], ports.HostIp))
 .map(ports => url.format({
  protocol: ports.protocol,
  hostname: 'localhost',
  port: _.includes(scan, ports.port) ? ports.HostPort : '',
 }))
 .thru(urls => ({service: data.Config.Labels['com.docker.compose.service'], urls}))
 .value()

/*
 * Helper to bootstrap app stuffs
 */
const bootstrapApp = lando => {
 const Factory = require('./factory');
 const Yaml = require('./yaml');
 lando.factory = new Factory();
 lando.yaml = new Yaml(lando.log);
 // Load in all our builders in the correct order
 const builders = _(['compose', 'types', 'services', 'recipes'])
  .flatMap(type => _.map(lando.config.plugins, plugin => plugin[type]))
  .filter(dir => fs.existsSync(dir))
  .flatMap(dir => glob.sync(path.join(dir, '*', 'builder.js')))
  .map(file => lando.factory.add(require(file)).name)
  .value();
 // Log
 _.forEach(builders, builder => lando.log.debug('autoloaded builder %s', builder));
}

_(_.flatten([data]))
 .flatMap(group => _.map(group.data, (compose, index) => ({data: compose, file: `${group.id}-${index}.yml`})))
 .map(compose => yaml.dump(path.join(dir, compose.file), compose.data))
 .value()

const initSources = _(inits).filter(init => _.has(init, 'sources')).flatMap(init => init.sources).value();

_(composeData)
 .flatMap(data => data.data)
 .flatMap(data => _.keys(data.services))
 .uniq()
 .value()

_(urls)
 .map(url => exports.parseUrl(url))
 .flatMap(url => getInfoUrls(url, ports, hasCerts))
 .value()

_(lernaJson.packages)
  .map((package) => package + "/package.json")
  .flatMap((package) => glob.sync(package))
  .map((packagePath) => {
    const packageJson = require(path.resolve(packagePath));
    return packageJson;
  })
  .filter(function (packageJson) {
    return filters.every(({ key, value }) => {
      return (
        _.get(packageJson.magda, key, "").toString() === value &&
        value.toString()
      );
    });
  })
  .map((packageJson) => packageJson.name)
  .value()

} else {
  const regionNames: string[] = _(boostRegions)
    .flatMap((region) => [
      region.regionName,
      region.regionShortName