initial

Author: disjunction

.gitignore

@@ -0,0 +1 @@
+node_modules

Makefile

@@ -0,0 +1,6 @@
+.PHONY: test 
+
+default: test
+
+test:
+	./node_modules/.bin/mocha

package.json

@@ -0,0 +1,22 @@
+{
+  "name": "cache-manager-mongoose",
+  "version": "0.0.1",
+  "description": "mongoose store for node-cache-manager",
+  "main": "src/index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "cache-manager": "^1.4.0",
+    "chai": "^3.5.0",
+    "mocha": "^2.4.5",
+    "mongoose-mock": "^0.4.0",
+    "proxyquire": "^1.7.4",
+    "sinon": "^1.17.3"
+  },
+  "dependencies": {
+    "mongoose": "^4.4.4"
+  }
+}

src/index.js

@@ -0,0 +1,94 @@
+"use strict";
+
+const mongoose = require("mongoose");
+
+
+const schemaTemplate = {
+    obj: {
+        _id: String,
+        val: mongoose.Schema.Types.Mixed,
+        exp: Number
+    }, 
+    options: {
+        collection: "cacheman",
+        versionKey: false
+    }
+};
+
+const EMPTY = {};
+
+class MongooseStoreError extends Error {};
+
+class MongooseStore {
+    constructor(args) {
+        if (args.model) {
+            switch (typeof args.model) {
+                case "object":
+                    this.model = args.model;
+                    break;
+                case "string":
+                    this.model = mongoose.model(args.model);
+                    break;
+                default:
+                    throw new MongooseStoreError("unexpected type of args.model in constructor");
+            }
+        } else {
+            this.model = this.makeModel(args);
+        }
+        this.ttl = args.ttl || 60;
+    }
+
+    makeModel(args) {
+        const options = Object.assign({}, schemaTemplate.options, args.modelOptions);
+        const schema = new mongoose.Schema(
+            schemaTemplate.obj,
+            options
+        );
+        return mongoose.model(args.model, schema);
+    }
+
+    result(fn, error, result) {
+        if (fn) {
+            fn(error, result);
+        }
+    }
+
+    get(key, options, fn) {
+        return this.model.findOne({_id: key})
+    }
+
+    set(key, val, options, fn) {
+        try {
+            options = options || {};
+            let ttl = options.ttl || this.ttl;
+            
+            return this.model.update(
+                {_id: key},
+                {
+                    val: val,
+                    exp: Date.now() + ttl * 1000
+                },
+                {upsert: true}
+            ).then(() => {
+                this.result(fn);
+            }).catch(e => {
+                this.result(fn, e)
+            });
+        } catch (e) {
+            this.result(fn, e)
+        }
+    }
+
+    del(key, options, fn) {
+
+    }
+
+    reset(key, fn) {
+    }
+}
+
+module.exports = {
+  create : function (args) {
+    return new MongooseStore(args);
+  }
+};

test/indexSpec.js

@@ -0,0 +1,54 @@
+"use strict";
+
+let mongoose = require("mongoose-mock"),
+    proxyquire = require("proxyquire"),
+    cmm = proxyquire("../src/index", {mongoose: mongoose}),
+    cm = require("cache-manager"),
+    sinon = require("sinon"),
+    expect = require("chai").expect;
+
+describe("cache-manager-mongoose", function() {
+    let modelStub = {
+        testProp: true,
+        update: () => Promise.resolve(),
+        findOne: () => Promise.resolve(),
+        remove: () => Promise.resolve()
+    };
+
+    it("accepts model passed directly", function() {
+        let cache = cm.caching({
+            store: cmm,
+            model: modelStub
+        });
+        expect(cache.store.model.testProp).to.be.true;
+    });
+
+    it("finds model if passed as string", sinon.test(function() {
+        this.stub(mongoose, "model").returns({dummyField: true});
+        let cache = cm.caching({
+            store: cmm,
+            model: "dummyModel"
+        });
+        sinon.assert.calledOnce(mongoose.model);
+        expect(cache.store.model.dummyField).to.be.true;
+    }));
+
+    it("creates new model if model not provided", function() {
+        let cache = cm.caching({
+            store: cmm
+        });
+        expect(cache.store.model).not.to.be.undefined;
+    });
+
+    it("set saves key, value, expires record", sinon.test(function(done) {
+        let cache = cm.caching({
+            store: cmm,
+            model: modelStub
+        });
+        cache.set("someKey", "someValue", null, function (err, result) {
+            done();
+        });
+        let updateSpy = sinon.stub(modelStub, "update");
+        sinon.assert.calledOnce(updateSpy);
+    }));
+});