autolevel.js

Automatically use the right abstract-leveldown module for your configuration
git clone git://git.finwo.net/lib/autolevel.js
Log | Files | Refs | README | LICENSE

adapter.js (3499B)

      1 // Our own dependencies
      2 const hasModule      = require('./has-module'),
      3       toAbsolutePath = require('./to-absolute-path');
      4 
      5 // Adapter descriptors
      6 let adapters = [
      7   {
      8     name        : ['ram', 'mem', 'memory'],
      9     backend     : 'memdown',
     10     dependencies: ['levelup', 'memdown'],
     11     options     : {
     12       path: 'omit'
     13     }
     14   }, {
     15     name        : ['file', 'dir', 'leveldb', 'level'],
     16     backend     : 'leveldown',
     17     dependencies: ['levelup', 'leveldown'],
     18     options     : {
     19       path: 'absolute'
     20     }
     21   }, {
     22     name        : ['mongo', 'mongodb'],
     23     backend     : 'mongodown',
     24     dependencies: ['levelup', 'mongodown'],
     25     options     : {
     26       path: {protocol: 'mongodb:'}
     27     }
     28   }
     29 ];
     30 
     31 function wrapper(descriptor) {
     32 
     33   // Sanity checks
     34   if (!descriptor) return;
     35   if (!descriptor.name) return;
     36   if (!descriptor.backend) return;
     37   if (!descriptor.dependencies) return;
     38   if (!descriptor.options) descriptor.options = {};
     39 
     40   // Normalize the names
     41   if ('string' === typeof descriptor.name) {
     42     descriptor.name = [descriptor.name];
     43   }
     44   if (!Array.isArray(descriptor.name)) {
     45     return;
     46   }
     47 
     48   // Missing dependency notifier
     49   for (let dependency of descriptor.dependencies) {
     50     if (!hasModule(dependency)) {
     51       descriptor.backend = function () {
     52         throw new Error("Missing dependency: " + dependency);
     53       };
     54       break;
     55     }
     56   }
     57 
     58   // Some return a levelup(-compatible) instance directly
     59   let levelup = descriptor.options.direct ?
     60     function( leveldown, location, options, callback ) {
     61       return leveldown(location, options, callback);
     62     } :
     63     function( leveldown, location, options, callback ) {
     64       return require('levelup')(leveldown(location), options, callback);
     65     };
     66 
     67   // Let's build the actual wrapper
     68   switch (typeof descriptor.options.path) {
     69     case 'string':
     70       switch (descriptor.options.path) {
     71         case 'omit':
     72           descriptor.wrapper = function (parsedLocation, options, callback) {
     73             let backend = 'function' === typeof descriptor.backend ? descriptor.backend : require(descriptor.backend);
     74             return levelup(backend, undefined, options, callback);
     75           };
     76           break;
     77         case 'absolute':
     78           descriptor.wrapper = function (parsedLocation, options, callback) {
     79             let backend = 'function' === typeof descriptor.backend ? descriptor.backend : require(descriptor.backend);
     80             return levelup(backend, toAbsolutePath(parsedLocation), options, callback);
     81           };
     82           break;
     83       }
     84       break;
     85     case 'object':
     86       descriptor.wrapper = function (parsedLocation, options, callback) {
     87         let backend = 'function' === typeof descriptor.backend ? descriptor.backend : require(descriptor.backend);
     88         Object.assign(parsedLocation, descriptor.options.path);
     89         return levelup(backend, parsedLocation.toString(), options, callback);
     90       };
     91       break;
     92     default:
     93       descriptor.wrapper = function (parsedLocation, options, callback) {
     94         let backend = 'function' === typeof descriptor.backend ? descriptor.backend : require(descriptor.backend);
     95         return levelup(backend, parsedLocation.href || parsedLocation, options, callback);
     96       };
     97       break;
     98   }
     99 
    100   return descriptor;
    101 }
    102 
    103 module.exports = function (autolevel) {
    104   for (let adapter of adapters) {
    105     wrapper(adapter, autolevel);
    106     if (!adapter.wrapper) continue;
    107     for (let name of adapter.name) {
    108       autolevel[name] = adapter.wrapper;
    109     }
    110   }
    111 };