How to use

fn

function

in

lodash

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
}

describe('lowercase', function() {
  it('should return an empty string when undefined.', function() {
   assert.equal(template('<%= lowercase() %>', imports)(), '');
  });
  it('should lower case the characters in a string.', function() {
   var fn = template('<%= lowercase("ABC") %>', imports);
   assert.equal(fn(), 'abc');
  });
 });

describe('first', function() {
 it('should return an empty string when undefined.', function() {
  assert.equal(template('<%= first() %>', imports)(), '');
 });

 it('should return the first item in an array.', function() {
  var fn = template('<%= first(foo) %>', imports);
  assert.equal(fn({foo: ['a', 'b', 'c']}), 'a');
 });

 it('should return an array with the first two items in an array.', function() {
  var fn = template('<%= first(foo, 2) %>', imports);
  assert.deepEqual(fn({foo: ['a', 'b', 'c']}), ['a', 'b'].toString());
 });
});

describe('after', function() {
 it('should return an empty string when undefined.', function() {
  assert.equal(template('<%= after() %>', imports)(), '');
 });

 it('should return all of the items in an array after the given index.', function() {
  var fn = template('<%= after(arr, 5) %>', imports);
  assert.deepEqual(fn(context), ['f', 'g', 'h'].toString());
 });
});

describe('length', function() {
 it('should return an empty string when undefined.', function() {
  assert.equal(template('<%= length() %>', imports)(), '');
 });

 it('should return zero when the value is not an array.', function() {
  var fn = template('<%= length("foo") %>', imports);
  assert.equal(fn(context), '0');
 });

 it('should return the length of an array.', function() {
  var fn = template('<%= length(["b", "c", "a"]) %>', imports);
  assert.equal(fn(context), '3');
 });
});

describe('unique', function() {
 it('should return an empty string when undefined.', function() {
  assert.equal(template('<%= unique() %>', imports)(), '');
 });
 it('should unique items from multiple arrays:', function() {
  var fn = template('<%= unique(["a", "b", "c", "c"]) %>', imports);
  assert.equal(fn(context), 'a,b,c');
 });
});

describe('uppercase', function() {
  it('should return an empty string when undefined.', function() {
   assert.equal(template('<%= uppercase() %>', imports)(), '');
  });
  it('should upper case the characters in a string.', function() {
   var fn = template('<%= uppercase("abc") %>', imports);
   assert.equal(fn(), 'ABC');
  });
 });

describe('compact', function() {
 it('should return an empty string when undefined.', function() {
  assert.equal(template('<%= compact() %>', imports)(), '');
 });

 it('should remove falsey values from an array.', function() {
  var fn = template('<%= compact([null, "a", undefined, 0, false, "b", "c", ""]) %>', imports);
  assert.equal(fn(context), 'a,b,c');
 });
});

describe('before', function() {
 it('should return an empty string when undefined.', function() {
  assert.equal(template('<%= before() %>', imports)(), '');
 });
 it('should return all of the items in an array before the given index.', function() {
  var fn = template('<%= before(arr, 5) %>', imports);
  assert.deepEqual(fn(context), ['a', 'b', 'c'].toString());
 });
});

describe('titlecase', function() {
  it('should return an empty string when undefined.', function() {
   assert.equal(template('<%= titlecase("foo") %>', imports)(), 'Foo');
  });
  it('should upper case the characters in a string.', function() {
   var fn = template('<%= titlecase("one two three") %>', imports);
   assert.equal(fn(), 'One Two Three');
  });
 });

describe('join', function() {
 it('should return an empty string when undefined.', function() {
  assert.equal(template('<%= join() %>', imports)(), '');
 });

 it('should return all items in an array joined by the default separator.', function() {
  var fn = template('<%= join(arr) %>', imports);
  assert.equal(fn(context), 'a, b, c, d, e, f, g, h');
 });

 it('should return all items in an array joined by the given separator.', function() {
  var fn = template('<%= join(arr, " | ") %>', imports);
  assert.equal(fn(context), 'a | b | c | d | e | f | g | h');
 });
});

describe('map', function() {
 it('should return an empty string when undefined.', function() {
  assert.equal(template('<%= map() %>', imports)(), '');
 });

 it('should map the items in the array and return new values.', function() {
  var o = {};
  o.double = function(str) {
   return str + str;
  };
  var fn = template('<%= map(["a","b","c"], double) %>', imports);
  assert.equal(fn(o), 'aa,bb,cc');
 });
});

describe('union', function() {
 it('should return an empty string when undefined.', function() {
  assert.equal(template('<%= union() %>', imports)(), '');
 });

 it('should union items from multiple arrays:', function() {
  var fn = template('<%= union(["a", "c"], ["b", "b"]) %>', imports);
  assert.equal(fn(context), 'a,c,b');
 });

 it('should union items from multiple arrays:', function() {
  var fn = template('<%= union(["a"], ["b"]) %>', imports);
  assert.equal(fn(context), 'a,b');
 });
});

describe('strip', function() {
  it('should return an empty string when undefined.', function() {
   assert.equal(template('<%= strip() %>', imports)(), '');
  });
  it('should strip the given substring from a string.', function() {
   var fn = template('<%= strip("foo", "foobar") %>', imports);
   assert.equal(fn(), 'bar');
  });
  it('should strip the given regex match from a string.', function() {
   var fn = template('<%= strip(/^foo/, "foobarfoo") %>', imports);
   assert.equal(fn(), 'barfoo');
  });
 });