micro-analytics-adapter-flat-file-db/dist.js

Store your micro-analytics data in flat-file-db!

'use strict';

var _regenerator = require('babel-runtime/regenerator');

var _regenerator2 = _interopRequireDefault(_regenerator);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }

function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }

var path = require('path');
var flatfile = require('flat-file-db');
var promisify = require('then-flat-file-db');
var Observable = require('zen-observable');

var _require = require('micro-analytics-adapter-utils'),
    filterPaths = _require.filterPaths,
    filterViews = _require.filterViews;

var db = void 0;

function init(options) {
  db = promisify(flatfile.sync(path.resolve(process.cwd(), options.dbName || 'views.db')));
}

// This is here for backwards compatability should be removed at some point
init({ dbName: process.env.DB_NAME });

var handlers = [];

var observable = new Observable(function (observer) {
  handlers.push(function (data) {
    return observer.next(data);
  });
  var index = handlers.length;
  return function () {
    handlers = [].concat(_toConsumableArray(handlers.slice(0, index)), _toConsumableArray(handlers.slice(index)));
  };
});

module.exports = {
  options: [{
    name: 'db-name',
    description: 'The name of the flat-file-db file.',
    defaultValue: process.env.DB_NAME || 'views.db'
  }],
  init: init,
  put: function put(key, value) {
    handlers.forEach(function (handler) {
      handler({ key: key, value: value });
    });
    return db.put(key, value);
  },
  has: function has(key) {
    return Promise.resolve(db.has(key));
  },
  keys: function keys() {
    return Promise.resolve(db.keys());
  },
  // Get a value and filter it
  get: function () {
    var _ref = _asyncToGenerator(_regenerator2.default.mark(function _callee(key, options) {
      var value;
      return _regenerator2.default.wrap(function _callee$(_context) {
        while (1) {
          switch (_context.prev = _context.next) {
            case 0:
              value = void 0;
              _context.prev = 1;
              _context.next = 4;
              return db.get(key);

            case 4:
              _context.t0 = _context.sent;

              if (_context.t0) {
                _context.next = 7;
                break;
              }

              _context.t0 = {};

            case 7:
              value = _context.t0;
              _context.next = 13;
              break;

            case 10:
              _context.prev = 10;
              _context.t1 = _context['catch'](1);

              value = { views: [] };

            case 13:
              return _context.abrupt('return', {
                views: filterViews(value.views, options)
              });

            case 14:
            case 'end':
              return _context.stop();
          }
        }
      }, _callee, undefined, [[1, 10]]);
    }));

    return function get(_x, _x2) {
      return _ref.apply(this, arguments);
    };
  }(),
  // Get all values starting with a certain pathname and filter their views
  getAll: function () {
    var _ref2 = _asyncToGenerator(_regenerator2.default.mark(function _callee2(options) {
      var data, keys, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, key;

      return _regenerator2.default.wrap(function _callee2$(_context2) {
        while (1) {
          switch (_context2.prev = _context2.next) {
            case 0:
              data = {};
              _context2.t0 = filterPaths;
              _context2.next = 4;
              return module.exports.keys();

            case 4:
              _context2.t1 = _context2.sent;
              _context2.t2 = options;
              keys = (0, _context2.t0)(_context2.t1, _context2.t2);
              _iteratorNormalCompletion = true;
              _didIteratorError = false;
              _iteratorError = undefined;
              _context2.prev = 10;
              _iterator = keys[Symbol.iterator]();

            case 12:
              if (_iteratorNormalCompletion = (_step = _iterator.next()).done) {
                _context2.next = 20;
                break;
              }

              key = _step.value;
              _context2.next = 16;
              return module.exports.get(key, {
                before: options.before,
                after: options.after
              });

            case 16:
              data[key] = _context2.sent;

            case 17:
              _iteratorNormalCompletion = true;
              _context2.next = 12;
              break;

            case 20:
              _context2.next = 26;
              break;

            case 22:
              _context2.prev = 22;
              _context2.t3 = _context2['catch'](10);
              _didIteratorError = true;
              _iteratorError = _context2.t3;

            case 26:
              _context2.prev = 26;
              _context2.prev = 27;

              if (!_iteratorNormalCompletion && _iterator.return) {
                _iterator.return();
              }

            case 29:
              _context2.prev = 29;

              if (!_didIteratorError) {
                _context2.next = 32;
                break;
              }

              throw _iteratorError;

            case 32:
              return _context2.finish(29);

            case 33:
              return _context2.finish(26);

            case 34:
              _context2.next = 36;
              return Promise.all(keys);

            case 36:
              return _context2.abrupt('return', data);

            case 37:
            case 'end':
              return _context2.stop();
          }
        }
      }, _callee2, this, [[10, 22, 26, 34], [27,, 29, 33]]);
    }));

    function getAll(_x3) {
      return _ref2.apply(this, arguments);
    }

    return getAll;
  }(),
  subscribe: function subscribe(cb) {
    return observable.subscribe(cb);
  },
  clear: function clear() {
    db.clear();
  }
};