@electerm/nedb 1.8.0

package/LICENSE

@@ -0,0 +1,22 @@
+(The MIT License)
+
+Copyright (c) 2013 Louis Chatriot <louis.chatriot@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,22 @@
+
+# @electerm/nedb
+
+**Note: This is an fork of [yetzt/nedb](https://github.com/yetzt/nedb), which itself is a fork of the original [nedb](https://github.com/louischatriot/nedb) by [Louis Chatriot](https://github.com/louischatriot). This version includes additional improvements and maintenance updates.**
+
+**Embedded persistent or in memory database for Node.js, nw.js, Electron, 100% JavaScript, no binary dependency**. API is a subset of MongoDB's and it's <a href="#speed">plenty fast</a>.
+
+## About this Fork
+
+This fork specially for electerm use, removed async/underscore for smaller size
+
+## Installation, tests
+Module name on npm is `@electerm/nedb`.
+
+```bash
+npm install @electerm/nedb --save    # Put latest version in your package.json
+npm test                             # You'll need the dev dependencies to launch tests
+```
+
+## License
+
+See [License](LICENSE)

package/index.js

@@ -0,0 +1,3 @@
+var Datastore = require('./lib/datastore');
+
+module.exports = Datastore;

package/lib/async.js

@@ -0,0 +1,237 @@
+/**
+ * Custom async utilities to replace the async library
+ * Uses modern async/await internally while maintaining callback compatibility
+ */
+
+/**
+ * Promisify a callback-based function
+ */
+function promisify(fn) {
+  return function(...args) {
+    return new Promise((resolve, reject) => {
+      fn(...args, (err, ...results) => {
+        if (err) reject(err);
+        else resolve(results.length <= 1 ? results[0] : results);
+      });
+    });
+  };
+}
+
+/**
+ * Execute functions in series (waterfall pattern)
+ * Each function receives the result of the previous function as its parameters (except the last which is always the callback)
+ */
+function waterfall(tasks, finalCallback) {
+  finalCallback = finalCallback || function() {};
+  
+  if (!Array.isArray(tasks) || tasks.length === 0) {
+    return finalCallback(null);
+  }
+  
+  let taskIndex = 0;
+  
+  function runNextTask(err, ...results) {
+    if (err) {
+      return finalCallback(err);
+    }
+    
+    if (taskIndex >= tasks.length) {
+      return finalCallback(null, ...results);
+    }
+    
+    const task = tasks[taskIndex++];
+    
+    try {
+      if (typeof task === 'function') {
+        // Regular function
+        if (taskIndex === 1) {
+          // First task gets only the callback
+          task(runNextTask);
+        } else {
+          // Subsequent tasks get results from previous task, then callback
+          task(...results, runNextTask);
+        }
+      } else if (task && task.__async_apply) {
+        // Handle async.apply case
+        const args = [...task.args];
+        if (taskIndex > 1) {
+          // If not the first task, add results from previous task
+          args.push(...results);
+        }
+        args.push(runNextTask);
+        task.fn.apply(null, args);
+      } else {
+        return finalCallback(new Error('Invalid task in waterfall'));
+      }
+    } catch (error) {
+      return finalCallback(error);
+    }
+  }
+  
+  runNextTask();
+}
+
+/**
+ * Apply partial application to a function (like async.apply)
+ */
+function apply(fn, ...args) {
+  return {
+    __async_apply: true,
+    fn: fn,
+    args: args
+  };
+}
+
+/**
+ * Execute a function for each item in an array, in series
+ */
+function eachSeries(array, iterator, callback) {
+  callback = callback || function() {};
+  
+  let index = 0;
+  
+  function processNext(err) {
+    if (err) {
+      return callback(err);
+    }
+    
+    if (index >= array.length) {
+      return callback(null);
+    }
+    
+    const item = array[index++];
+    
+    try {
+      iterator(item, processNext);
+    } catch (error) {
+      return callback(error);
+    }
+  }
+  
+  processNext();
+}
+
+/**
+ * Execute a function for each item in an array, in parallel
+ */
+function each(array, iterator, callback) {
+  callback = callback || function() {};
+  
+  if (array.length === 0) {
+    return callback(null);
+  }
+  
+  let completed = 0;
+  let hasError = false;
+  
+  array.forEach(function(item) {
+    iterator(item, function(err) {
+      if (hasError) return;
+      
+      if (err) {
+        hasError = true;
+        return callback(err);
+      }
+      
+      completed++;
+      if (completed === array.length) {
+        callback(null);
+      }
+    });
+  });
+}
+
+/**
+ * Execute a function repeatedly while a condition is true
+ */
+function whilst(test, iterator, callback) {
+  callback = callback || function() {};
+  
+  function iterate(err) {
+    if (err) {
+      return callback(err);
+    }
+    
+    if (!test()) {
+      return callback(null);
+    }
+    
+    try {
+      iterator(iterate);
+    } catch (error) {
+      return callback(error);
+    }
+  }
+  
+  iterate();
+}
+
+/**
+ * Task queue implementation
+ */
+function queue(worker, concurrency = 1) {
+  const tasks = [];
+  let running = 0;
+  let paused = false;
+
+  function processTasks() {
+    while (tasks.length > 0 && running < concurrency && !paused) {
+      const task = tasks.shift();
+      running++;
+      
+      worker(task.data, function(err) {
+        running--;
+        task.callback(err);
+        
+        // Process next tasks
+        if (tasks.length > 0) {
+          setImmediate(processTasks);
+        }
+      });
+    }
+  }
+
+  return {
+    push: function(data, callback) {
+      callback = callback || function() {};
+      tasks.push({ data, callback });
+      setImmediate(processTasks);
+    },
+    
+    unshift: function(data, callback) {
+      callback = callback || function() {};
+      tasks.unshift({ data, callback });
+      setImmediate(processTasks);
+    },
+    
+    pause: function() {
+      paused = true;
+    },
+    
+    resume: function() {
+      paused = false;
+      setImmediate(processTasks);
+    },
+    
+    length: function() {
+      return tasks.length;
+    },
+    
+    running: function() {
+      return running;
+    },
+    
+    idle: function() {
+      return tasks.length === 0 && running === 0;
+    }
+  };
+}
+
+module.exports = {
+  waterfall,
+  apply,
+  eachSeries,
+  each,
+  whilst,
+  queue
+};

package/lib/cursor.js

@@ -0,0 +1,204 @@
+/**
+ * Manage access to data, be it to find, update or remove it
+ */
+var model = require('./model')
+  , _ = require('./underscore')
+  ;
+
+
+
+/**
+ * Create a new cursor for this collection
+ * @param {Datastore} db - The datastore this cursor is bound to
+ * @param {Query} query - The query this cursor will operate on
+ * @param {Function} execFn - Handler to be executed after cursor has found the results and before the callback passed to find/findOne/update/remove
+ */
+function Cursor (db, query, execFn) {
+  this.db = db;
+  this.query = query || {};
+  if (execFn) { this.execFn = execFn; }
+}
+
+
+/**
+ * Set a limit to the number of results
+ */
+Cursor.prototype.limit = function(limit) {
+  this._limit = limit;
+  return this;
+};
+
+
+/**
+ * Skip a the number of results
+ */
+Cursor.prototype.skip = function(skip) {
+  this._skip = skip;
+  return this;
+};
+
+
+/**
+ * Sort results of the query
+ * @param {SortQuery} sortQuery - SortQuery is { field: order }, field can use the dot-notation, order is 1 for ascending and -1 for descending
+ */
+Cursor.prototype.sort = function(sortQuery) {
+  this._sort = sortQuery;
+  return this;
+};
+
+
+/**
+ * Add the use of a projection
+ * @param {Object} projection - MongoDB-style projection. {} means take all fields. Then it's { key1: 1, key2: 1 } to take only key1 and key2
+ *                              { key1: 0, key2: 0 } to omit only key1 and key2. Except _id, you can't mix takes and omits
+ */
+Cursor.prototype.projection = function(projection) {
+  this._projection = projection;
+  return this;
+};
+
+
+/**
+ * Apply the projection
+ */
+Cursor.prototype.project = function (candidates) {
+  var res = [], self = this
+    , keepId, action, keys
+    ;
+
+  if (this._projection === undefined || Object.keys(this._projection).length === 0) {
+    return candidates;
+  }
+
+  keepId = this._projection._id === 0 ? false : true;
+  this._projection = _.omit(this._projection, '_id');
+
+  // Check for consistency
+  keys = Object.keys(this._projection);
+  keys.forEach(function (k) {
+    if (action !== undefined && self._projection[k] !== action) { throw new Error("Can't both keep and omit fields except for _id"); }
+    action = self._projection[k];
+  });
+
+  // Do the actual projection
+  candidates.forEach(function (candidate) {
+    var toPush;
+    if (action === 1) {   // pick-type projection
+      toPush = { $set: {} };
+      keys.forEach(function (k) {
+        toPush.$set[k] = model.getDotValue(candidate, k);
+        if (toPush.$set[k] === undefined) { delete toPush.$set[k]; }
+      });
+      toPush = model.modify({}, toPush);
+    } else {   // omit-type projection
+      toPush = { $unset: {} };
+      keys.forEach(function (k) { toPush.$unset[k] = true });
+      toPush = model.modify(candidate, toPush);
+    }
+    if (keepId) {
+      toPush._id = candidate._id;
+    } else {
+      delete toPush._id;
+    }
+    res.push(toPush);
+  });
+
+  return res;
+};
+
+
+/**
+ * Get all matching elements
+ * Will return pointers to matched elements (shallow copies), returning full copies is the role of find or findOne
+ * This is an internal function, use exec which uses the executor
+ *
+ * @param {Function} callback - Signature: err, results
+ */
+Cursor.prototype._exec = function(_callback) {
+  var res = [], added = 0, skipped = 0, self = this
+    , error = null
+    , i, keys, key
+    ;
+
+  function callback (error, res) {
+    if (self.execFn) {
+      return self.execFn(error, res, _callback);
+    } else {
+      return _callback(error, res);
+    }
+  }
+
+  this.db.getCandidates(this.query, function (err, candidates) {
+    if (err) { return callback(err); }
+
+    try {
+      for (i = 0; i < candidates.length; i += 1) {
+        if (model.match(candidates[i], self.query)) {
+          // If a sort is defined, wait for the results to be sorted before applying limit and skip
+          if (!self._sort) {
+            if (self._skip && self._skip > skipped) {
+              skipped += 1;
+            } else {
+              res.push(candidates[i]);
+              added += 1;
+              if (self._limit && self._limit <= added) { break; }
+            }
+          } else {
+            res.push(candidates[i]);
+          }
+        }
+      }
+    } catch (err) {
+      return callback(err);
+    }
+
+    // Apply all sorts
+    if (self._sort) {
+      keys = Object.keys(self._sort);
+
+      // Sorting
+      var criteria = [];
+      for (i = 0; i < keys.length; i++) {
+        key = keys[i];
+        criteria.push({ key: key, direction: self._sort[key] });
+      }
+      res.sort(function(a, b) {
+        var criterion, compare, i;
+        for (i = 0; i < criteria.length; i++) {
+          criterion = criteria[i];
+          compare = criterion.direction * model.compareThings(model.getDotValue(a, criterion.key), model.getDotValue(b, criterion.key), self.db.compareStrings);
+          if (compare !== 0) {
+            return compare;
+          }
+        }
+        return 0;
+      });
+
+      // Applying limit and skip
+      var limit = self._limit || res.length
+        , skip = self._skip || 0;
+
+      res = res.slice(skip, skip + limit);
+    }
+
+    // Apply projection
+    try {
+      res = self.project(res);
+    } catch (e) {
+      error = e;
+      res = undefined;
+    }
+
+    return callback(error, res);
+  });
+};
+
+Cursor.prototype.exec = function () {
+  this.db.executor.push({ this: this, fn: this._exec, arguments: arguments });
+};
+
+
+
+// Interface
+module.exports = Cursor;

package/lib/customUtils.js

@@ -0,0 +1,22 @@
+var crypto = require('crypto')
+  ;
+
+/**
+ * Return a random alphanumerical string of length len
+ * There is a very small probability (less than 1/1,000,000) for the length to be less than len
+ * (il the base64 conversion yields too many pluses and slashes) but
+ * that's not an issue here
+ * The probability of a collision is extremely small (need 3*10^12 documents to have one chance in a million of a collision)
+ * See http://en.wikipedia.org/wiki/Birthday_problem
+ */
+function uid (len) {
+  return crypto.randomBytes(Math.ceil(Math.max(8, len * 2)))
+    .toString('base64')
+    .replace(/[+\/]/g, '')
+    .slice(0, len);
+}
+
+
+// Interface
+module.exports.uid = uid;
+