How to use

map

function

in

Object

/*
 * Helper to get dynamic service keys for stripping
 */
const getDynamicKeys = (answer, answers = {}) => _(answers)
 .map((value, key) => ({key, value}))
 .filter(data => data.value === answer)
 .map(data => data.key)
 .map(key => (_.size(key) === 1) ? `-${key}` : `--${key}`)
 .value()

/*
 * Helper to parse service relationships
 */
const parseServiceRelationships = ({relationships = {}}) => {
 // This is most things
 if (_.isEmpty(relationships)) return {};

 // Otherwise
 return _(relationships)
  .map((config, name) => ([name, [{
   service: config.split(':')[0],
   host: config.split(':')[0],
   port: 80,
  }]]))
  .fromPairs()
  .value();
}

_(services)
  .groupBy('platformsh.type')
  .map((service, type) => _.merge({}, {type}, {
   services: _.flatten(_.map(service, s => parsedRelationships[s.name])),
  }))
  .value()

_(services)
 .map((config, name) => _.merge({}, config, {
  aliases: _.has(relationships, name) ? _.map(relationships[name], 'alias') : [],
  application: false,
  creds: _(_.get(relationships, name, {}))
   .map('creds')
   .flatten()
   .value(),
  hostname: name,
  name,
  opener: JSON.stringify({relationships: parseServiceRelationships(config)}),
 }))
 .value()

_(normalizeRoutes(routes))
 // Map redirects to upstreams
 .map(route => getUpstream(route, normalizeRoutes(routes)))
 // Remove blank entries
 .compact()
 // Parse to lando things
 .map(route => _.merge({}, url.parse(route.key), {service: route.upstream.split(':')[0]}))
 // Filter unsupported upstreams
 .filter(route => _.includes(_.map(supported, 'name'), route.service))
 // Merge in port data
 .map(route => _.merge({}, route, _.find(supported, {name: route.service})))
 // Add port to data
 .map(route => ({service: route.service, config: getProxyMiddlewares(route)}))
 // Group by service
 .groupBy('service')
 // Map to lando proxy config
 .map((entries, service) => ([service, _.map(entries, 'config')]))
 // objectify
 .fromPairs()
 // Return
 .value()

.map((version, thing) => ({
 name: thing,
 link: supportedVersions[thing].link[process.platform],
}))
.map(thing => _.merge({}, thing, {
 dockerVersion: true,
 satisfied: semver.satisfies(thing.semversion, `${thing.semmin} - ${thing.semmax}`, true),

/*
 * Helper to get passthru options
 */
const handlePassthruOpts = (options = {}, answers = {}) => _(options)
 .map((value, key) => _.merge({}, {name: key}, value))
 .filter(value => value.passthrough === true && !_.isNil(answers[value.name]))
 .map(value => `--${value.name}=${answers[value.name]}`)
 .value()

const supported = _.map(options.services, service => ({name: service.name, port: service.proxyPort}));
options.proxy = getLandoProxyRoutes(platformConfig.routes, supported);
const serviceContainers = _(options.services)
 .filter(service => _.includes(relatableServices, service.name))
 .map(service => service)
 .value();
const serviceTooling = tooling.getServiceTooling(serviceContainers, openData, closestApp.name);
 .map((data, name) => ([
 .map((data, name) => ([

_(relationships)
 .map(relationship => relationship)
 .flatten()
 .map('service')
 .uniqBy()
 .value()

/*
 * Helper to normalize routes into arrays
 */
const normalizeRoutes = (routes = {}) => _(routes)
 .map((data, key) => _.merge({}, data, {key}))
 .value()

// Helper to sort tokens
const sortTokens = (...sources) => _(_.flatten([...sources]))
 .sortBy('date')
 .groupBy('user')
 .map(tokens => _.last(tokens))
 .value()

_(relationships)
 .map((relationship, alias) => ({alias, path: relationship.replace(':', '.')}))
 .value()

i.map(s => s.match(/(.+?)-(\d+)\[(.+?)]/))
  .map(([, data, sector, checksum]) => ({
    sector, checksum,
    chars: require('lodash')(data.replace(/-/g, ''))
      .countBy()
      .map((n, c) => ({c, n}))
      .orderBy(['n', 'c'], ['desc', 'asc'])
      .take(5)
      .map('c')
      .join``
  }))
  .filter(v => v.checksum === v.chars)
  .reduce((p, v) => p + +v.sector, 0)

_(_.flatten([...sources]))
 .sortBy('date')
 .groupBy('email')
 .map(tokens => _.last(tokens))
 .value()

_(_.flatten([...sources]))
 .sortBy('date')
 .groupBy('email')
 .map(tokens => _.last(tokens))
 .value()