}, (error: Error, result) => {
   if (error) {
     logger.error('failed to insert batch: %s', error.message);
     return callback(error);
   }
   logger.debug('inserting batch took %d ms', result.took);
   if (result.errors) {
     logger.warning('batch insert encountered non-fatal errors: %j', result.errors);
   }
   callback();
 });

  fs.readFile(REGISTRY_CACHE_FILEPATH, {encoding: 'utf8'}, (err, data) => {
    // all we need from the cache is the latest `_updated` value
    if (err || data === '') {
      data = '{"_updated":0}';
    }
    var registry = JSON.parse(data);
    var _updated: number = registry._updated;

    // updating the locally-cached registry file happens the same way regardless
    // of the updates_only flag
    var url = `https://registry.npmjs.org/-/all/since?stale=update_after&startkey=${_updated}`;
    logger.debug('fetching url: "%s"', url);
    request.get({url: url, json: true}, (error, response, body) => {
      if (error) return callback(error);

      logger.debug('fetched %d updates', Object.keys(body).length - 1);

      // update and save the cached registry, but don't wait for it
      _.assign(registry, body);
      fs.writeFile(REGISTRY_CACHE_FILEPATH, JSON.stringify(registry), {encoding: 'utf8'}, (error) => {
        if (error) {
          return logger.error('failed to save registry: %s', error.message);
        }
        logger.debug('saved updated registry file');
      });

      var names = updates_only ? Object.keys(body) : Object.keys(registry);
      var packages = names.filter(name => name !== '_updated').map(name => normalizePackage(registry[name]));
      callback(null, packages);
    });
  });

    mergeAverageDownloadsPerDay(packages, (error, packages) => {
      if (error) return callback(error);

      logger.debug('updating with %d packages (%s)', packages.length, updates_only ? 'updates only' : 'all packages');
      var batches = _.chunk(packages, 500);
      async.eachSeries(batches, insertPackages, callback);
    });

const server = http.createServer((req, res) => {
  logger.debug('%s %s', req.method, req.url)
  // enable CORS
  res.setHeader('Access-Control-Allow-Origin', '*')
  res.setHeader('Access-Control-Allow-Methods', '*')
  controller.route(req, res)
})

function insertPackages(packages: registry.Package[], callback: (error?: Error) => void) {
  logger.debug('inserting batch of %d packages, from %s to %s', packages.length,
    packages[0].name, packages[packages.length - 1].name);

  var body = [];
  packages.forEach(pkg => {
    body.push({index: {_id: pkg.name}}, pkg);
  });

  client.bulk({
    index: 'npm',
    type: 'packages',
    body: body
  }, (error: Error, result) => {
    if (error) {
      logger.error('failed to insert batch: %s', error.message);
      return callback(error);
    }
    logger.debug('inserting batch took %d ms', result.took);
    if (result.errors) {
      logger.warning('batch insert encountered non-fatal errors: %j', result.errors);
    }
    callback();
  });
}

 .execute((error: Error, rows: {name: string, average: number}[]) => {
   if (error) return callback(error)
   logger.info('averaged downloads for %d packages', rows.length)
   const packages: {[index: string]: number} = {}
   rows.forEach(row => packages[row.name] = row.average)
   callback(null, packages)
 })

    .execute((selectError: Error, local_statistics: Statistic[]) => {
      if (selectError) return callback(selectError)

      // 2. determine what we want to get next
      const [start, end] = determineNeededEndpoints(local_statistics, min_range_days, max_range_days)

      // 3. determineNeededEndpoints may return [null, null] if there are no
      // remaining ranges that we need to fetch
      if (start === null && end === null) {
        logger.debug('not fetching any data for "%s"', name)
        return callback(null, local_statistics)
      }

      // 4. get the next unseen statistics
      getRangeStatistics(name, start, end, (statsError, statistics) => {
        if (statsError) return callback(statsError)

        // 5. save the values we just fetched
        const [sql, args] = buildMultirowInsert(package_row.id, statistics)
        db.executeSQL(sql, args, (sqlError: Error) => {
          if (sqlError) return callback(sqlError)

          // 6. merge local and new statistics for the response
          const total_statistics = statistics.concat(local_statistics).sort((a, b) => a.day.getTime() - b.day.getTime())
          callback(null, total_statistics)
        })
      })
    })

 readableStream.pipe(new Parser({lowerCaseTags: argv.lower === true})).on('finish', function() {
   logger.debug('document=%j', this.document);
   const xmlSerializer = new XMLSerializer('  ', argv.limit);
   const formattedHTML = xmlSerializer.serializeToString(this.document);
   process.stdout.write(formattedHTML);
   process.stdout.write('\n');
 });