@engine9-io/input-tools 1.9.11 → 2.0.1

package/file/tools.js

@@ -1,22 +1,22 @@
-const fs = require('node:fs');
+import fs from 'node:fs';
+import path from 'node:path';
+import debug$0 from 'debug';
+import os from 'node:os';
+import { mkdirp } from 'mkdirp';
+import nodestream from 'node:stream';
+import JSON5 from 'json5';
+import unzipper from 'unzipper';
+import dayjs from 'dayjs';
+import clientS3 from '@aws-sdk/client-s3';
+import { v7 as uuidv7 } from 'uuid';
 
 const fsp = fs.promises;
-const path = require('node:path');
-const debug = require('debug')('@engine9/input-tools');
-const os = require('node:os');
-const { mkdirp } = require('mkdirp');
-const { Transform } = require('node:stream');
+const debug = debug$0('@engine9/input-tools');
 
-const JSON5 = require('json5');
-const { PassThrough } = require('node:stream');
-const progress = require('debug')('info:@engine9/input-tools');
-const unzipper = require('unzipper');
-
-const dayjs = require('dayjs');
-
-const { S3Client, HeadObjectCommand, GetObjectCommand } = require('@aws-sdk/client-s3');
-
-const { v7: uuidv7 } = require('uuid');
+const { Transform } = nodestream;
+const { PassThrough } = nodestream;
+const progress = debug$0('info:@engine9/input-tools');
+const { S3Client, HeadObjectCommand, GetObjectCommand } = clientS3;
 
 async function getTempDir({ accountId = 'engine9' }) {
   const dir = [os.tmpdir(), accountId, new Date().toISOString().substring(0, 10)].join(path.sep);
@@ -27,7 +27,6 @@ async function getTempDir({ accountId = 'engine9' }) {
   }
   return dir;
 }
-
 /*
  Get a new, timestamp based filename, creating any necessary directories
  options:
@@ -36,22 +35,18 @@ async function getTempDir({ accountId = 'engine9' }) {
 */
 async function getTempFilename(options) {
   let dir = await getTempDir(options);
-
   const target = options.targetFilename;
   if (target) {
     if (target.indexOf('/') === 0 || target.indexOf('\\') === 0) {
       // assume a full directory path has been specified
       return target;
     }
-
     // make a distinct directory, so we don't overwrite the file
     dir = `${dir}/${new Date()
       .toISOString()
       .slice(0, -6)
       .replace(/[^0-9]/g, '_')}`;
-
     const newDir = await mkdirp(dir);
-
     return `${newDir}/${target}`;
   }
   let { prefix } = options;
@@ -62,30 +57,23 @@ async function getTempFilename(options) {
     postfix = `_${options.source.split('/').pop()}`;
     postfix = postfix.replace(/['"\\]/g, '').replace(/[^a-zA-Z0-9_.-]/g, '_');
   }
-
   if (prefix) prefix += '_';
-
   const p = `${dir}/${prefix || ''}${uuidv7()}${postfix || '.txt'}`;
   return p;
 }
-
 async function writeTempFile(options) {
   const { content, postfix = '.txt' } = options;
   const filename = await getTempFilename({ ...options, postfix });
-
   await fsp.writeFile(filename, content);
   return { filename };
 }
-
 async function getPacketFiles({ packet }) {
   if (packet.indexOf('s3://') === 0) {
     const parts = packet.split('/');
     const Bucket = parts[2];
     const Key = parts.slice(3).join('/');
     const s3Client = new S3Client({});
-
     debug('Getting ', { Bucket, Key });
-
     //    const directory = await unzipper.Open.s3(s3Client, { Bucket, Key });
     let size = null;
     const directory = await unzipper.Open.custom({
@@ -100,7 +88,6 @@ async function getPacketFiles({ packet }) {
         progress(`Retrieving file of size ${size / (1024 * 1024)} MB`);
         return info.ContentLength;
       },
-
       stream(offset, length) {
         const ptStream = new PassThrough();
         s3Client
@@ -117,17 +104,14 @@ async function getPacketFiles({ packet }) {
           .catch((error) => {
             ptStream.emit('error', error);
           });
-
         return ptStream;
       }
     });
-
     return directory;
   }
   const directory = await unzipper.Open.file(packet);
   return directory;
 }
-
 async function getManifest({ packet }) {
   if (!packet) throw new Error('no packet option specififed');
   const { files } = await getPacketFiles({ packet });
@@ -136,7 +120,6 @@ async function getManifest({ packet }) {
   const manifest = JSON.parse(content.toString());
   return manifest;
 }
-
 function getBatchTransform({ batchSize = 100 }) {
   return {
     transform: new Transform({
@@ -167,7 +150,6 @@ function getDebatchTransform() {
     })
   };
 }
-
 async function getFile({ filename, packet, type }) {
   if (!packet && !filename) throw new Error('no packet option specififed');
   let content = null;
@@ -196,7 +178,6 @@ async function getFile({ filename, packet, type }) {
   }
   return content;
 }
-
 async function streamPacket({ packet, type }) {
   if (!packet) throw new Error('no packet option specififed');
   const manifest = await getManifest({ packet });
@@ -208,11 +189,9 @@ async function streamPacket({ packet, type }) {
   const handle = files.find((d) => d.path === filePath);
   return { stream: handle.stream(), path: filePath };
 }
-
 async function downloadFile({ packet, type = 'person' }) {
   const { stream: fileStream, path: filePath } = await streamPacket({ packet, type });
   const filename = await getTempFilename({ targetFilename: filePath.split('/').pop() });
-
   return new Promise((resolve, reject) => {
     fileStream
       .pipe(fs.createWriteStream(filename))
@@ -222,13 +201,10 @@ async function downloadFile({ packet, type = 'person' }) {
       });
   });
 }
-
 function isValidDate(d) {
   // we WANT to use isNaN, not the Number.isNaN -- we're checking the date type
-
   return d instanceof Date && !isNaN(d);
 }
-
 function bool(x, _defaultVal) {
   const defaultVal = _defaultVal === undefined ? false : _defaultVal;
   if (x === undefined || x === null || x === '') return defaultVal;
@@ -241,7 +217,6 @@ function getStringArray(s, nonZeroLength) {
   let a = s || [];
   if (typeof a === 'number') a = String(a);
   if (typeof a === 'string') a = [a];
-
   if (typeof s === 'string') a = s.split(',');
   a = a.map((x) => x.toString().trim()).filter(Boolean);
   if (nonZeroLength && a.length === 0) a = [0];
@@ -252,21 +227,17 @@ function relativeDate(s, _initialDate) {
   if (!s || s === 'none') return null;
   if (typeof s.getMonth === 'function') return s;
   // We actually want a double equals here to test strings as well
-
   if (parseInt(s, 10) == s) {
     const r = new Date(parseInt(s, 10));
     if (!isValidDate(r)) throw new Error(`Invalid integer date:${s}`);
     return r;
   }
-
   if (initialDate) {
     initialDate = new Date(initialDate);
   } else {
     initialDate = new Date();
   }
-
   let r = s.match(/^([+-]{1})([0-9]+)([YyMwdhms]{1})([.a-z]*)$/);
-
   if (r) {
     let period = null;
     switch (r[3]) {
@@ -274,7 +245,6 @@ function relativeDate(s, _initialDate) {
       case 'y':
         period = 'years';
         break;
-
       case 'M':
         period = 'months';
         break;
@@ -297,9 +267,7 @@ function relativeDate(s, _initialDate) {
         period = 'minutes';
         break;
     }
-
     let d = dayjs(initialDate);
-
     if (r[1] === '+') {
       d = d.add(parseInt(r[2], 10), period);
     } else {
@@ -312,7 +280,6 @@ function relativeDate(s, _initialDate) {
       else if (opts[0] === 'end') d = d.endOf(opts[1] || 'day');
       else throw new Error(`Invalid relative date,unknown options:${r[4]}`);
     }
-
     return d.toDate();
   }
   if (s === 'now') {
@@ -323,7 +290,6 @@ function relativeDate(s, _initialDate) {
   if (!isValidDate(r)) throw new Error(`Invalid Date: ${s}`);
   return r;
 }
-
 /*
   When comparing two objects, some may come from a file (thus strings), and some from
   a database or elsewhere (not strings), so for deduping make sure to make them all strings
@@ -341,7 +307,6 @@ function appendPostfix(filename, postfix) {
     .split('.')
     .filter(Boolean)
     .filter((d) => d !== postfix);
-
   let targetFile = null;
   if (fileParts.slice(-1)[0] === 'gz') {
     targetFile = fileParts.slice(0, -2).concat(postfix).concat(fileParts.slice(-2)).join('.');
@@ -350,7 +315,6 @@ function appendPostfix(filename, postfix) {
   }
   return filenameParts.slice(0, -1).concat(targetFile).join('/');
 }
-
 function parseJSON5(o, defaultVal) {
   if (o) {
     if (typeof o === 'object') return o;
@@ -359,8 +323,23 @@ function parseJSON5(o, defaultVal) {
   }
   return defaultVal || o;
 }
-
-module.exports = {
+export { appendPostfix };
+export { bool };
+export { downloadFile };
+export { getTempFilename };
+export { getTempDir };
+export { getBatchTransform };
+export { getDebatchTransform };
+export { getFile };
+export { getManifest };
+export { getPacketFiles };
+export { getStringArray };
+export { makeStrings };
+export { parseJSON5 };
+export { relativeDate };
+export { streamPacket };
+export { writeTempFile };
+export default {
   appendPostfix,
   bool,
   downloadFile,

package/index.js

@@ -1,16 +1,16 @@
-const fs = require('node:fs');
-
-const path = require('node:path');
-const dayjs = require('dayjs');
-
-const debug = require('debug')('@engine9/input-tools');
-
-const unzipper = require('unzipper');
-const { v4: uuidv4, v5: uuidv5, v7: uuidv7, validate: uuidIsValid } = require('uuid');
-const archiver = require('archiver');
-const handlebars = require('handlebars');
-
-const FileUtilities = require('./file/FileUtilities');
+import fs from 'node:fs';
+import path from 'node:path';
+import dayjs from 'dayjs';
+import debug$0 from 'debug';
+import unzipper from 'unzipper';
+import { v4 as uuidv4, v5 as uuidv5, v7 as uuidv7, validate as uuidIsValid } from 'uuid';
+import archiver from 'archiver';
+import handlebars from 'handlebars';
+import FileUtilities from './file/FileUtilities.js';
+import tools from './file/tools.js';
+import ForEachEntry from './ForEachEntry.js';
+import { TIMELINE_ENTRY_TYPES } from './timelineTypes.js';
+const debug = debug$0('@engine9/input-tools');
 
 const {
   appendPostfix,
@@ -30,40 +30,28 @@ const {
   streamPacket,
   makeStrings,
   writeTempFile
-} = require('./file/tools');
-
-const ForEachEntry = require('./ForEachEntry');
-
-const { TIMELINE_ENTRY_TYPES } = require('./timelineTypes');
-
+} = tools;
 function getFormattedDate(dateObject, format = 'MMM DD,YYYY') {
   let d = dateObject;
   if (d === 'now') d = new Date();
   if (d) return dayjs(d).format(format);
   return '';
 }
-
 handlebars.registerHelper('date', (d, f) => {
   let format;
   if (typeof f === 'string') format = f;
   return getFormattedDate(d, format);
 });
 handlebars.registerHelper('json', (d) => JSON.stringify(d));
-
 handlebars.registerHelper('uuid', () => uuidv7());
-
 handlebars.registerHelper('percent', (a, b) => `${((100 * a) / b).toFixed(2)}%`);
-
 handlebars.registerHelper('or', (a, b, c) => a || b || c);
-
 async function list(_path) {
   const directory = await unzipper.Open.file(_path);
-
   return new Promise((resolve, reject) => {
     directory.files[0].stream().pipe(fs.createWriteStream('firstFile')).on('error', reject).on('finish', resolve);
   });
 }
-
 async function extract(_path, _file) {
   const directory = await unzipper.Open(_path);
   // return directory.files.map((f) => f.path);
@@ -73,7 +61,6 @@ async function extract(_path, _file) {
     file.stream().pipe(fs.createWriteStream(tempFilename)).on('error', reject).on('finish', resolve);
   });
 }
-
 function appendFiles(existingFiles, _newFiles, options) {
   const newFiles = getStringArray(_newFiles);
   if (newFiles.length === 0) return;
@@ -82,7 +69,6 @@ function appendFiles(existingFiles, _newFiles, options) {
   if (!dateCreated) dateCreated = new Date().toISOString();
   let arr = newFiles;
   if (!Array.isArray(newFiles)) arr = [arr];
-
   arr.forEach((p) => {
     const item = {
       type,
@@ -90,13 +76,11 @@ function appendFiles(existingFiles, _newFiles, options) {
       isNew: true,
       dateCreated
     };
-
     if (typeof p === 'string') {
       item.originalFilename = path.resolve(process.cwd(), p);
     } else {
       item.originalFilename = path.resolve(process.cwd(), item.originalFilename);
     }
-
     const file = item.originalFilename.split(path.sep).pop();
     item.path = `${type}/${file}`;
     const existingFile = existingFiles.find((f) => f.path === item.path);
@@ -104,7 +88,6 @@ function appendFiles(existingFiles, _newFiles, options) {
     existingFiles.push(item);
   });
 }
-
 async function create(options) {
   const {
     accountId = 'engine9',
@@ -116,16 +99,13 @@ async function create(options) {
     statisticsFiles = [] // files with aggregate statistics
   } = options;
   if (options.peopleFiles) throw new Error('Unknown option: peopleFiles, did you mean personFiles?');
-
   const files = [];
   const dateCreated = new Date().toISOString();
   appendFiles(files, messageFiles, { type: 'message', dateCreated });
   appendFiles(files, personFiles, { type: 'person', dateCreated });
   appendFiles(files, timelineFiles, { type: 'timeline', dateCreated });
   appendFiles(files, statisticsFiles, { type: 'statistics', dateCreated });
-
   const zipFilename = target || (await getTempFilename({ postfix: '.packet.zip' }));
-
   const manifest = {
     accountId,
     source: {
@@ -134,7 +114,6 @@ async function create(options) {
     dateCreated,
     files
   };
-
   // create a file to stream archive data to.
   const output = fs.createWriteStream(zipFilename);
   const archive = archiver('zip', {
@@ -152,37 +131,30 @@ async function create(options) {
         bytes: archive.pointer()
       });
     });
-
     // This event is fired when the data source is drained no matter what was the data source.
     // It is not part of this library but rather from the NodeJS Stream API.
     // @see: https://nodejs.org/api/stream.html#stream_event_end
     output.on('end', () => {
       // debug('end event -- Data has been drained');
     });
-
     // warnings could be file not founds, etc, but we error even on those
     archive.on('warning', (err) => {
       reject(err);
     });
-
     // good practice to catch this error explicitly
     archive.on('error', (err) => {
       reject(err);
     });
-
     archive.pipe(output);
-
     files.forEach(({ path: name, originalFilename }) => archive.file(originalFilename, { name }));
     files.forEach((f) => {
       delete f.originalFilename;
       delete f.isNew;
     });
-
     archive.append(Buffer.from(JSON.stringify(manifest, null, 4), 'utf8'), { name: 'manifest.json' });
     archive.finalize();
   });
 }
-
 function intToByteArray(_v) {
   // we want to represent the input as a 8-bytes array
   const byteArray = [0, 0, 0, 0, 0, 0, 0, 0];
@@ -192,14 +164,12 @@ function intToByteArray(_v) {
     byteArray[index] = byte;
     v = (v - byte) / 256;
   }
-
   return byteArray;
 }
 function getPluginUUID(uniqueNamespaceLikeDomainName, valueWithinNamespace) {
   // Random custom namespace for plugins -- not secure, just a namespace:
   return uuidv5(`${uniqueNamespaceLikeDomainName}::${valueWithinNamespace}`, 'f9e1024d-21ac-473c-bac6-64796dd771dd');
 }
-
 function getInputUUID(a, b) {
   let pluginId = a;
   let remoteInputId = b;
@@ -207,7 +177,6 @@ function getInputUUID(a, b) {
     pluginId = a.pluginId;
     remoteInputId = a.remoteInputId;
   }
-
   if (!pluginId) throw new Error('getInputUUID: Cowardly rejecting a blank plugin_id');
   if (!uuidIsValid(pluginId)) throw new Error(`Invalid pluginId:${pluginId}, should be a UUID`);
   const rid = (remoteInputId || '').trim();
@@ -216,7 +185,6 @@ function getInputUUID(a, b) {
   // 3d0e5d99-6ba9-4fab-9bb2-c32304d3df8e
   return uuidv5(`${pluginId}:${rid}`, '3d0e5d99-6ba9-4fab-9bb2-c32304d3df8e');
 }
-
 const timestampMatch = /^\d{13}$/;
 function dateFromString(s) {
   if (typeof s === 'number') return new Date(s);
@@ -225,7 +193,6 @@ function dateFromString(s) {
   }
   return new Date(s);
 }
-
 function getUUIDv7(date, inputUuid) {
   /* optional date and input UUID */
   const uuid = inputUuid || uuidv7();
@@ -234,7 +201,6 @@ function getUUIDv7(date, inputUuid) {
     const d = dateFromString(date);
     // isNaN behaves differently than Number.isNaN -- we're actually going for the
     // attempted conversion here
-
     if (isNaN(d)) throw new Error(`getUUIDv7 got an invalid date:${date || '<blank>'}`);
     const dateBytes = intToByteArray(d.getTime()).reverse();
     dateBytes.slice(2, 8).forEach((b, i) => {
@@ -248,7 +214,6 @@ function getUUIDTimestamp(uuid) {
   const ts = parseInt(`${uuid}`.replace(/-/g, '').slice(0, 12), 16);
   return new Date(ts);
 }
-
 function getEntryTypeId(o, { defaults = {} } = {}) {
   let id = o.entry_type_id || defaults.entry_type_id;
   if (id) return id;
@@ -263,32 +228,27 @@ function getEntryTypeId(o, { defaults = {} } = {}) {
 function getEntryType(o, defaults = {}) {
   let etype = o.entry_type || defaults.entry_type;
   if (etype) return etype;
-
   const id = o.entry_type_id || defaults.entry_type_id;
-
   etype = TIMELINE_ENTRY_TYPES[id];
   if (etype === undefined) throw new Error(`Invalid entry_type: ${etype}`);
   return etype;
 }
-
 const requiredTimelineEntryFields = ['ts', 'entry_type_id', 'input_id', 'person_id'];
-
 function getTimelineEntryUUID(inputObject, { defaults = {} } = {}) {
   const o = { ...defaults, ...inputObject };
   /*
-      Outside systems CAN specify a unique UUID as remote_entry_uuid,
-      which will be used for updates, etc.
-      If not, it will be generated using whatever info we have
-    */
+        Outside systems CAN specify a unique UUID as remote_entry_uuid,
+        which will be used for updates, etc.
+        If not, it will be generated using whatever info we have
+      */
   if (o.remote_entry_uuid) {
     if (!uuidIsValid(o.remote_entry_uuid)) throw new Error('Invalid remote_entry_uuid, it must be a UUID');
     return o.remote_entry_uuid;
   }
   /*
-        Outside systems CAN specify a unique remote_entry_id
-        If not, it will be generated using whatever info we have
-      */
-
+          Outside systems CAN specify a unique remote_entry_id
+          If not, it will be generated using whatever info we have
+        */
   if (o.remote_entry_id) {
     // get a temp ID
     if (!o.input_id)
@@ -300,17 +260,13 @@ function getTimelineEntryUUID(inputObject, { defaults = {} } = {}) {
     return getUUIDv7(o.ts, uuid);
   }
   o.entry_type_id = getEntryTypeId(o);
-
   const missing = requiredTimelineEntryFields.filter((d) => o[d] === undefined); // 0 could be an entry type value
-
   if (missing.length > 0) throw new Error(`Missing required fields to append an entry_id:${missing.join(',')}`);
   const ts = new Date(o.ts);
   // isNaN behaves differently than Number.isNaN -- we're actually going for the
   // attempted conversion here
-
   if (isNaN(ts)) throw new Error(`getTimelineEntryUUID got an invalid date:${o.ts || '<blank>'}`);
   const idString = `${ts.toISOString()}-${o.person_id}-${o.entry_type_id}-${o.source_code_id || 0}`;
-
   if (!uuidIsValid(o.input_id)) {
     throw new Error(`Invalid input_id:'${o.input_id}', type ${typeof o.input_id} -- should be a uuid`);
   }
@@ -321,13 +277,11 @@ function getTimelineEntryUUID(inputObject, { defaults = {} } = {}) {
   // may not match this standard, uuid sorting isn't guaranteed
   return getUUIDv7(ts, uuid);
 }
-
 function getDateRangeArray(startDate, endDate) {
   const start = new Date(startDate);
   const end = new Date(endDate);
   const result = [];
   const msInDay = 24 * 60 * 60 * 1000;
-
   function addDays(date, days) {
     const d = new Date(date);
     d.setDate(d.getDate() + days);
@@ -343,13 +297,10 @@ function getDateRangeArray(startDate, endDate) {
     d.setFullYear(d.getFullYear() + years);
     return d;
   }
-
   const diffDays = Math.floor((end - start) / msInDay);
   const diffMonths = (end.getFullYear() - start.getFullYear()) * 12 + (end.getMonth() - start.getMonth());
   const diffYears = end.getFullYear() - start.getFullYear();
-
   let current = new Date(start);
-
   let stepFn;
   if (diffDays < 10) {
     stepFn = (date) => addDays(date, 1);
@@ -364,7 +315,6 @@ function getDateRangeArray(startDate, endDate) {
   } else {
     stepFn = (date) => addYears(date, 1);
   }
-
   while (current <= end) {
     result.push(new Date(current));
     const next = stepFn(current);
@@ -377,7 +327,6 @@ function getDateRangeArray(startDate, endDate) {
   }
   return result;
 }
-
 class ObjectError extends Error {
   constructor(data) {
     if (typeof data === 'string') {
@@ -394,8 +343,44 @@ class ObjectError extends Error {
     }
   }
 }
-
-module.exports = {
+export { appendPostfix };
+export { bool };
+export { create };
+export { list };
+export { downloadFile };
+export { extract };
+export { ForEachEntry };
+export { FileUtilities };
+export { getBatchTransform };
+export { getDateRangeArray };
+export { getDebatchTransform };
+export { getEntryType };
+export { getEntryTypeId };
+export { getFile };
+export { getManifest };
+export { getStringArray };
+export { getTempDir };
+export { getTempFilename };
+export { getTimelineEntryUUID };
+export { getPacketFiles };
+export { getPluginUUID };
+export { getInputUUID };
+export { getUUIDv7 };
+export { getUUIDTimestamp };
+export { handlebars };
+export { isValidDate };
+export { makeStrings };
+export { ObjectError };
+export { parseJSON5 };
+export { relativeDate };
+export { streamPacket };
+export { TIMELINE_ENTRY_TYPES };
+export { writeTempFile };
+export { uuidIsValid };
+export { uuidv4 };
+export { uuidv5 };
+export { uuidv7 };
+export default {
   appendPostfix,
   bool,
   create,

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@engine9-io/input-tools",
-  "version": "1.9.11",
+  "version": "2.0.1",
+  "type": "module",
   "description": "Tools for dealing with Engine9 inputs",
   "main": "index.js",
   "scripts": {

package/test/cli.js

@@ -1,10 +1,9 @@
-const argv = require('yargs/yargs')(process.argv.slice(2)).parse();
-const methods = require('../index');
-
+import yargs from 'yargs/yargs';
+import methods from '../index.js';
+const argv = yargs(process.argv.slice(2)).parse();
 async function run() {
   if (typeof methods[argv._[0]] !== 'function') throw new Error(`${argv._[0]} is not a function`);
   const output = await methods[argv._[0]](argv);
-  // eslint-disable-next-line no-console
   console.log(output);
 }
 run();

package/test/file.js

@@ -1,9 +1,9 @@
-const { it } = require('node:test');
-const assert = require('node:assert');
-const debug = require('debug')('files');
-
-const { FileUtilities } = require('../index');
-
+import nodetest from 'node:test';
+import assert from 'node:assert';
+import * as debug$0 from 'debug';
+import { FileUtilities } from '../index.js';
+const { it } = nodetest;
+const debug = debug$0('files');
 it('Should list a directory', async () => {
   const futil = new FileUtilities({ accountId: 'test' });
   let files = await futil.list({ directory: '.' });
@@ -14,7 +14,6 @@ it('Should list a directory', async () => {
   let endTest = await futil.list({ directory: '.', end: '1900-01-01' });
   assert(endTest.length === 0, 'Should NOT have any files before past end date');
 });
-
 it('Should be able to analyze CSV files with and without header lines', async () => {
   const futil = new FileUtilities({ accountId: 'test' });
   const f1 = await futil.columns({ filename: __dirname + '/sample/fileWithHead.csv' });