feat: Add a base store to be overriden

index.ts

@@ -1,9 +1,10 @@
 import { MongoPortable } from "./src/core";
+import { BaseStore } from "./src/store"
 
 try {
     if (window) {
         window["MongoPortable"] = MongoPortable;
     }
 } catch(e) { /* window not found -> not a browser environment */ }
 
-export { MongoPortable };
+export { MongoPortable, BaseStore };

src/store/BaseStore.ts

@@ -0,0 +1,57 @@
+import * as Promise from "promise";
+
+import { IAbstractStore } from "./IAbstractStore";
+
+export class BaseStore implements IAbstractStore {
+	createCollection(event): boolean | Promise<boolean> {
+		return Promise.resolve(true);
+	}
+
+    insert(event): boolean | Promise<boolean> {
+		return Promise.resolve(true);
+	}
+
+    save(event): object | Promise<object> {
+		return Promise.resolve({});
+	}
+
+    all(event): object | Promise<object> {
+		return Promise.resolve({});
+	}
+
+    find(event): object | Promise<object> {
+		return Promise.resolve({});
+	}
+
+    findOne(event): object | Promise<object> {
+		return Promise.resolve({});
+	}
+
+    update(event): boolean | Promise<boolean> {
+		return Promise.resolve(true);
+	}
+
+    remove(event): boolean | Promise<boolean> {
+		return Promise.resolve(true);
+	}
+
+    ensureIndex(event): object | Promise<object> {
+		return Promise.resolve({});
+	}
+
+    backup(event): object | Promise<object> {
+		return Promise.resolve({});
+	}
+
+    backups(event): object | Promise<object> {
+		return Promise.resolve({});
+	}
+
+    removeBackup(event): object | Promise<object> {
+		return Promise.resolve({});
+	}
+
+    restore(event): object | Promise<object> {
+		return Promise.resolve({});
+	}
+}

src/store/IAbstractStore.ts

@@ -0,0 +1,29 @@
+import * as Promise from "promise";
+
+export interface IAbstractStore {
+	createCollection(event): boolean | Promise<boolean>;
+
+    insert(event): boolean | Promise<boolean>;
+
+    save(event): object | Promise<object>;
+
+    all(event): object | Promise<object>;
+
+    find(event): object | Promise<object>;
+
+    findOne (event): object | Promise<object>;
+
+    update(event): boolean | Promise<boolean>;
+
+    remove(event): boolean | Promise<boolean>;
+
+    ensureIndex(event): object | Promise<object>;
+
+    backup(event): object | Promise<object>;
+
+    backups(event): object | Promise<object>;
+
+    removeBackup(event): object | Promise<object>;
+
+    restore(event): object | Promise<object>;
+}

src/store/index.ts

@@ -0,0 +1 @@
+export * from "./BaseStore";

test/unit/store/BaseStore.spec.ts

@@ -0,0 +1,214 @@
+import "mocha";
+import { expect } from "chai";
+
+import { TestHelper } from "../../helper/index";
+import { MongoPortable } from "../../../src/core/index";
+import { BaseStore } from "../../../src/store/index";
+
+TestHelper.initLogger();
+
+let db = null;
+
+describe("- BaseStore", function() {
+   describe("#Constructor", function() {
+        it("should have the dependencies ready", function() {
+            TestHelper.assertDependencies([MongoPortable, BaseStore]);
+        });
+
+        it("should be able to instanciate", function() {
+            let store = new BaseStore();
+
+            expect(store).to.exist;
+        });
+    });
+
+    describe("#Emit", function() {
+		before(function() {
+			db = new MongoPortable("PRUEBAS", null);
+
+			db.addStore(new BaseStore());
+		});
+
+		it("should emit a 'createCollection' event", function(done) {
+			db.emit("createCollection", {})
+			.then((result) => {
+			    // Result: void
+				expect(result).to.not.exist;
+
+				done();
+			}).catch(error => {
+			    expect(error).to.not.exist;
+
+			    done();
+			});
+		});
+
+		it("should emit a 'insert' event", function(done) {
+			db.emit("insert", {})
+			.then((result) => {
+			    // Result: void
+				expect(result).to.not.exist;
+
+				done();
+			}).catch(error => {
+			    expect(error).to.not.exist;
+
+			    done();
+			});
+		});
+
+		it("should emit a 'save' event", function(done) {
+			db.emit("save", {})
+			.then((result) => {
+			    // Result: void
+				expect(result).to.not.exist;
+
+				done();
+			}).catch(error => {
+			    expect(error).to.not.exist;
+
+			    done();
+			});
+		});
+
+		it("should emit a 'all' event", function(done) {
+			db.emit("all", {})
+			.then((result) => {
+			    // Result: void
+				expect(result).to.not.exist;
+
+				done();
+			}).catch(error => {
+			    expect(error).to.not.exist;
+
+			    done();
+			});
+		});
+
+		it("should emit a 'find' event", function(done) {
+			db.emit("find", {})
+			.then((result) => {
+			    // Result: void
+				expect(result).to.not.exist;
+
+				done();
+			}).catch(error => {
+			    expect(error).to.not.exist;
+
+			    done();
+			});
+		});
+
+		it("should emit a 'findOne' event", function(done) {
+			db.emit("findOne", {})
+			.then((result) => {
+			    // Result: void
+				expect(result).to.not.exist;
+
+				done();
+			}).catch(error => {
+			    expect(error).to.not.exist;
+
+			    done();
+			});
+		});
+
+		it("should emit a 'update' event", function(done) {
+			db.emit("update", {})
+			.then((result) => {
+			    // Result: void
+				expect(result).to.not.exist;
+
+				done();
+			}).catch(error => {
+			    expect(error).to.not.exist;
+
+			    done();
+			});
+		});
+
+		it("should emit a 'remove' event", function(done) {
+			db.emit("remove", {})
+			.then((result) => {
+			    // Result: void
+				expect(result).to.not.exist;
+
+				done();
+			}).catch(error => {
+			    expect(error).to.not.exist;
+
+			    done();
+			});
+		});
+
+		it("should emit a 'ensureIndex' event", function(done) {
+			db.emit("ensureIndex", {})
+			.then((result) => {
+			    // Result: void
+				expect(result).to.not.exist;
+
+				done();
+			}).catch(error => {
+			    expect(error).to.not.exist;
+
+			    done();
+			});
+		});
+
+		it("should emit a 'backup' event", function(done) {
+			db.emit("backup", {})
+			.then((result) => {
+			    // Result: void
+				expect(result).to.not.exist;
+
+				done();
+			}).catch(error => {
+			    expect(error).to.not.exist;
+
+			    done();
+			});
+		});
+
+		it("should emit a 'backups' event", function(done) {
+			db.emit("backups", {})
+			.then((result) => {
+			    // Result: void
+				expect(result).to.not.exist;
+
+				done();
+			}).catch(error => {
+			    expect(error).to.not.exist;
+
+			    done();
+			});
+		});
+
+		it("should emit a 'removeBackup' event", function(done) {
+			db.emit("removeBackup", {})
+			.then((result) => {
+			    // Result: void
+				expect(result).to.not.exist;
+
+				done();
+			}).catch(error => {
+			    expect(error).to.not.exist;
+
+			    done();
+			});
+		});
+
+		it("should emit a 'restore' event", function(done) {
+			db.emit("restore", {})
+			.then((result) => {
+			    // Result: void
+				expect(result).to.not.exist;
+
+				done();
+			}).catch(error => {
+			    expect(error).to.not.exist;
+
+			    done();
+			});
+		});
+    });
+});