initial commit

Author: aheckmann

.gitignore

@@ -0,0 +1,4 @@
+*.swo
+*.swp
+*.swn
+node_modules/

Makefile

@@ -0,0 +1,5 @@
+
+test:
+	node test/index.js
+
+.PHONY: test

index.js

@@ -0,0 +1 @@
+module.exports = exports = require('./lib/ttl');

lib/ttl.js

@@ -0,0 +1,135 @@
+
+// todo
+// mongoose-ttl
+// mongoose-keywords
+// mongoose-query-cache
+// mongoose-timestamps (use createdAt as default name)
+// mongoose-created
+// more
+
+// + tests <<== START HERE !!!!
+
+var Model = require('mongoose').Model;
+
+module.exports = exports = ttl;
+
+function ttl (schema, options) {
+  options || (options = {});
+
+  var key = '__ttl' // non-configurable
+    , ttl = options.ttl || 60000 // doc age limit
+    , interval = options.interval || 60000*5 // how often to .remove() expired docs
+    , cb = 'function' == typeof options.cb ? cb : undefined // reaper callback
+
+  var o = {};
+  o[key] = Date;
+
+  schema.add(o);
+
+  var index = {};
+  index[key] = 1;
+  schema.index(index);
+
+  schema.pre('save', function (next) {
+    this[key] = new Date;
+    next();
+  });
+
+  function applyTTL (cond) {
+    if (cond[key]) {
+      cond.$and || (cond.$and = []);
+      var a = {};
+      a[key] = cond[key];
+      cond.$and.push(a);
+      var b = {};
+      b[key] = { $gte: Date.now() - ttl };
+      cond.$and.push(b);
+      delete cond[key];
+    } else {
+      cond[key] = { $gte: Date.now() - ttl }
+    }
+  }
+
+  /**
+   * Override Model.init
+   */
+
+  schema.statics.init = function () {
+    init(this);
+    return Model.init.call(this);
+  }
+
+  /**
+   * init
+   *
+   * Hook into all model queries to include the TTL
+   * filter and kick off the expired doc reaper.
+   */
+
+  function init (model) {
+    if (model.__ttl) return;
+
+    var distinct_ = model.distinct;
+    model.distinct = function (field, cond, cb) {
+      applyTTL(cond);
+      return distinct_.call(model, field, cond, cb);
+    }
+
+    'findOne find count'.split(' ').forEach(function (method) {
+      var fn = model[method];
+
+      model[method] = function (cond, fields, opts, cb) {
+        if (!cond) {
+          cond = {};
+        } else if ('function' == typeof cond) {
+          cb = cond;
+          cond = {};
+        }
+
+        applyTTL(cond);
+        return fn.call(model, cond, fields, opts, cb);
+      }
+    });
+
+    'where $where'.split(' ').forEach(function (method) {
+      var fn = model[method];
+      model[method] = function () {
+        var query = fn.apply(this, arguments)
+          , cond = {};
+        applyTTL(cond);
+        return query.find(cond);
+      }
+    });
+
+    startTTL(model);
+  }
+
+  /**
+   * startTTL
+   *
+   * Initializes the timer which removes expired docs
+   * from the DB.
+   */
+
+  function startTTL (model) {
+    var remove;
+    model.__ttl = setInterval(remove = function () {
+      model
+      .remove()
+      .where(key).$lt(Date.now() - ttl)
+      .exec(cb);
+    }, interval);
+    setTimeout(remove, 10000);
+  }
+
+  /**
+   * clearTTL
+   *
+   * Stops hitting the db to remove expired docs.
+   */
+
+  schema.statics.clearTTL = function clearTTL () {
+    clearInterval(this.__ttl);
+  };
+
+}

package.json

@@ -0,0 +1,19 @@
+{
+  "author": "Aaron Heckmann <aaron.heckmann+github@gmail.com>",
+  "name": "mongoose-ttl",
+  "description": "Mongoose Time-To-Live plugin",
+  "version": "0.0.0",
+  "repository": {
+    "url": ""
+  },
+  "scripts": {
+    "test": "make test"
+  },
+  "engines": {
+    "node": "~0.4.12"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "mongoose": "2.4.10"
+  }
+}

test/index.js

@@ -0,0 +1,54 @@
+
+var mongoose = require('mongoose')
+  , Schema = mongoose.Schema
+  , ttl = require('../')
+
+function log (err) {
+  console.error('reaper ran');
+  console.error('error? %s', !!err);
+  if (err) {console.error(err.stack);}
+}
+
+mongoose.set('debug', true);
+
+var ThingSchema = new Schema({ name: String });
+ThingSchema.plugin(ttl, { ttl: 10000, interval: 20000, cb: log });
+
+mongoose.connect('localhost', 'mongoose_test_ttl');
+
+var T = mongoose.model('Thing', ThingSchema);
+
+mongoose.connection.on('open', function () {
+  mongoose.connection.db.dropDatabase(function () {
+
+    var t = new T({ name: 'Tha Blob' });
+    t.save(function (err) {
+      if (err) console.error(err.stack);
+
+      T.find({ name: /Tha Blob/ }).run(function (err, t) {
+        console.error('find', err, t);
+
+        T.where('name').exists().exec(function (err, t) {
+          console.error('where', err, t);
+
+          T.findOne({ name: 'Tha Blob' }, function (err, t) {
+            console.error('findOne', err, t);
+
+            T.count({}, function (err, n) {
+              console.error('count', err, n);
+
+              T.find().where('name', 'Tha Blob').run(function (err, t) {
+                console.error('find()', err, t);
+
+                T.distinct('name', { _id: { $exists: true }}, function (err, t) {
+                  console.error('distinct', err, t);
+                });
+              });
+            });
+          });
+        });
+      });
+    });
+  });
+});
+