How to use

LoDashFp

in

lodash

async function insert(params) {
 const user = joi.attempt(params, insertSchema)

 return db(tableName)
  .insert(user)
  .returning('*')
  .then(fp.first)
}

function addPrefixAliasToColumns(tableName, columns) {
 const fn = fp.map((column) => `${tableName}.${column} as ${tableName}_${column}`)

 if (columns) {
  return fn(columns)
 }

 return fn
}

function getColumnsByTableNamePrefix(tableName, columns) {
 const fn = fp.compose([
  fp.mapKeys(fp.replace(`${tableName}_`, '')),
  fp.pickBy((value, key) => fp.startsWith(`${tableName}_`, key))
 ])

 if (columns) {
  return fn(columns)
 }

 return fn
}

function getColumns(tableName) {
 return db('information_schema.columns')
  .where({ table_name: tableName })
  .select('column_name')
  .options({ rowMode: 'array' })
  .then(fp.map(fp.first))
}

async function insertOrReplace(params) {
 const contribution = joi.attempt(params, insertSchema)

 const query = `
  INSERT INTO :tableName: ("user", repository, line_count)
   VALUES (:user, :repository, :line_count)
   ON CONFLICT ("user", repository) DO UPDATE SET line_count = :line_count
   RETURNING *;
 `

 return db.raw(query, Object.assign({ tableName }, contribution))
  .then(fp.first)
}

const errors = fp.compose([
 fp.mapValues(fp.map('message')),
 fp.groupBy('context.key')
])(err.details)

const condition = fp.omitBy(fp.isUndefined, {
 [`${tableName}.id`]: repository.id,
 [`${tableName}.full_name`]: repository.full_name
const omitUserColumns = fp.omitBy((value, column) => fp.startsWith(`${User.tableName}_`, column))
return Object.assign(omitUserColumns(repo), {
 owner: getColumnsByTableNamePrefix(User.tableName, repo),

 owner: fp.pick(['id', 'login', 'avatar_url', 'html_url', 'type'], item.owner),
 repository: fp.compose([
  fp.assign({ owner: item.owner.id }),
  fp.defaults({ description: '', language: '' }),
  fp.omitBy(fp.isNil),
  fp.pick(['id', 'full_name', 'description', 'html_url', 'language', 'stargazers_count'])
 ])(item)
}))

const condition = fp.omitBy(fp.isUndefined, {
 [`${User.tableName}.id`]: user.id,
 [`${User.tableName}.login`]: user.login,
const omitUserAndRepositoryColumns = fp.compose([
 fp.omitBy((value, column) => fp.startsWith(`${User.tableName}_`, column)),
 fp.omitBy((value, column) => fp.startsWith(`${Repository.tableName}_`, column))
])
return fp.map((contribution) => Object.assign(omitUserAndRepositoryColumns(contribution), {
 user: getColumnsByTableNamePrefix(User.tableName, contribution),
 repository: getColumnsByTableNamePrefix(Repository.tableName, contribution)

program
  .command('app:version [project-dir]')
  .description('Prints the version in app.json')
  .action(act(async (dir) => {
    const projectManifest = await readBuildManifest(dir);
    const version = F.getOr('0.0.0', ['version'], projectManifest);
    console.log(version);
    return true;
  }));

const getPaths = (obj, basePath = []) =>
 _.reduce(
  (memo, path) =>
   _.isPlainObject(obj[path])
    ? [...memo, ...getPaths(obj[path], [...basePath, path])]
    : [...memo, [...basePath, path]],
  [],
  _.keys(obj)
 )

const createAllModules = (dependencyGraph, existingModules, moduleDefinitions) => f.flow(
  f.keys,
  f.reduce(
    (accumulatedModules, name) =>
      createModule(name, dependencyGraph, accumulatedModules, moduleDefinitions),
    existingModules
  )
)(dependencyGraph)

F.compose(
  x => x.length > 0,
  F.filter(x => x.status === 'in-progress'),
  F.propOr([], 'jobs')
)

async function insert(params) {
 const repository = joi.attempt(params, insertSchema)

 return db(tableName)
  .insert(repository)
  .returning('*')
  .then(fp.first)
}

async function insert(params) {
 const contribution = joi.attempt(params, insertSchema)

 return db(tableName)
  .insert(contribution)
  .returning('*')
  .then(fp.first)
}