// delete is a reserved word :(
    remove(opts: SelectOptions,
           callback: (err: IError, results: any) => void) {
        let tablename = this.tablename;
        let conn = DbConnection.getConnection();
        let query = "DELETE FROM " + tablename + " ";

        let values: any[] = [];
        if (!_.isEmpty(opts.where)) {
            query += "WHERE ";
            let whereKeys = _.keys(opts.where);

            let i = 0;
            while (i < whereKeys.length - 1) {
                let columnName = this.columnsMapping[whereKeys[i]];
                query += columnName + " = ? AND ";
                values.push(opts.where[whereKeys[i]]);
                i++;
            }
            let columnName = this.columnsMapping[whereKeys[i]];
            query += columnName + " = ? ";
            values.push(opts.where[whereKeys[i]]);
        }

        console.log("Delete query : " + query);
        conn.query(query, values, (err, results) => {
            if (err) {
                callback(err, null);
            } else {
                callback(null, results);
            }
        });
    }

 _bindRoutes: function () {
   if (!this.routes) return;
   this.routes = _.result(this, 'routes');
   var route, routes = _.keys(this.routes);
   while ((route = routes.pop()) != null) {
     this.route(route, this.routes[route]);
   }
 },

 public static regFromFile(file: string): string[] {
   if (!fs.existsSync(file)) return [];
   let fns = fs.readFileSync(file, 'utf8');
   var func = new Function('require', fns);
   var helpers = func.call(this, require);
   CodeBuider.regs(helpers);
   return _.keys(helpers);
 }

export const reviveChildren = (object: Nodes, storeById: any  = {}) => {
    _.keys(object).filter(k => !k.startsWith('_')).forEach(key => {
        const val = object[key];
        if (val && typeof(val) === 'object') {
            reviveNode(val, object, storeById);
        }
    });
};

 function mergeBuckets<T>(
   bucket1: { [armorType in ArmorTypes]: T },
   bucket2: { [armorType in ArmorTypes]: T }
 ): { [armorType in ArmorTypes]: T } {
   const merged = {};
   _.each(_.keys(bucket1), (type) => {
     merged[type] = bucket1[type].concat(bucket2[type]);
   });
   return merged as { [armorType in ArmorTypes]: T };
 }

export function exportGlobally(toExportGlobally: IExportedGlobally) {
  if (window['Coveo'] == undefined) {
    window['Coveo'] = {};
  }
  _.each(_.keys(toExportGlobally), (key: string) => {
    if (window['Coveo'][key] == null) {
      window['Coveo'][key] = toExportGlobally[key];
    }
  });
}

 async pushStats(statsToPush:any) {
   const stats = (await this.loadStats()) || {};
   _.keys(statsToPush).forEach(function(statName:string){
     if (!stats[statName]) {
       stats[statName] = { blocks: [] };
     }
     stats[statName].blocks = stats[statName].blocks.concat(statsToPush[statName].blocks);
   });
   return this.coreFS.writeJSON('stats.json', stats)
 }

      it('should output a section for each relevant parsed document weights', () => {
        const built = inlineRankingInfo.build();
        const sections = built.findAll('div.coveo-relevance-inspector-inline-ranking-section');
        expect(sections.length).toEqual(10);

        const documentWeights = keys(parsed.documentWeights);
        each(documentWeights, (documentWeight, i) => {
          expect(sections[i].textContent).toContain(`${documentWeight}: ${parsed.documentWeights[documentWeight]}`);
        });
      });

function listInterfaces() {
  const netInterfaces = os.networkInterfaces();
  const keys = _.keys(netInterfaces);
  const res = [];
  for (const name of keys) {
    res.push({
      name: name,
      addresses: netInterfaces[name]
    });
  }
  return res;
}

export const eachChild = (val: any, doer: (node: Nodes) => void) => {
   if (val != null && typeof(val) === 'object') {
       if (val.type) {
           doer(val);
           _.keys(val).forEach(key => {
               if (key === '_parent') return; // stop infinite recursion
               eachChild(val[key], doer);
           })
       }
       else if (Array.isArray(val)) {
           val.forEach(c => eachChild(c, doer));
       }
   }
};