1.0.19

README.md

@@ -2,13 +2,29 @@
 
 > Note: Still in Beta
 
-smartdata is a ODM that adheres to TypeScript practices and uses classes to organize data.
+## Availabililty
-It uses MongoDB as persistent storage.
+[![npm](https://push.rocks/assets/repo-button-npm.svg)](https://www.npmjs.com/package/smartdata)
+[![git](https://push.rocks/assets/repo-button-git.svg)](https://gitlab.com/pushrocks/smartdata)
+[![git](https://push.rocks/assets/repo-button-mirror.svg)](https://github.com/pushrocks/smartdata)
+[![docs](https://push.rocks/assets/repo-button-docs.svg)](https://pushrocks.gitlab.io/smartdata/)
+
+## Status for master
+[![build status](https://gitlab.com/pushrocks/smartdata/badges/master/build.svg)](https://gitlab.com/pushrocks/smartdata/commits/master)
+[![coverage report](https://gitlab.com/pushrocks/smartdata/badges/master/coverage.svg)](https://gitlab.com/pushrocks/smartdata/commits/master)
+[![Dependency Status](https://david-dm.org/pushrocks/smartdata.svg)](https://david-dm.org/pushrocks/smartdata)
+[![bitHound Dependencies](https://www.bithound.io/github/pushrocks/smartdata/badges/dependencies.svg)](https://www.bithound.io/github/pushrocks/smartdata/master/dependencies/npm)
+[![bitHound Code](https://www.bithound.io/github/pushrocks/smartdata/badges/code.svg)](https://www.bithound.io/github/pushrocks/smartdata)
+[![TypeScript](https://img.shields.io/badge/TypeScript-2.x-blue.svg)](https://nodejs.org/dist/latest-v6.x/docs/api/)
+[![node](https://img.shields.io/badge/node->=%206.x.x-blue.svg)](https://nodejs.org/dist/latest-v6.x/docs/api/)
+[![JavaScript Style Guide](https://img.shields.io/badge/code%20style-standard-brightgreen.svg)](http://standardjs.com/)
+
+smartdata is an ODM that adheres to TypeScript practices and uses classes to organize data.
+It uses MongoDB or NeDb as persistent storage.
 
 ## Intention
-There are many ODMs out there, however when we searched for a ODM that uses TypeScript,
+There are many ODMs out there, however when we searched for an ODM that uses TypeScript,
-acts smart while still embracing an easy the NoSQL idea we didn't find a matching solution.
+acts smart while still embracing the NoSQL idea we didn't find a matching solution.
-This is why we started smartdata
+This is why we started smartdata.
 
 How MongoDB terms map to smartdata classes
 
@@ -21,12 +37,16 @@ Document | smartdata.DbDoc
 ### class Db
 represents a Database. Naturally it has .connect() etc. methods on it.
 Since it is a class you can have multiple DBs defined.
-```typescript
+```javascript
 import * as smartdata from 'smartdata'
 
+// mongodb
 let myDb1 = new smartdata.Db('someConnectionUrl')
 let myDb2 = new smartdata.Db('someConnectionUrl')
 
+// nedb
+let myDb3 = new smartdata('/some/path/for/persistence', 'nedb') // you may set first argument to null for just in memory db
+
 myDb1.connect()
 myDb2.connect()
 
@@ -38,23 +58,23 @@ represents a collection of objects.
 A collection is defined by the object class (that is extending smartdata.dbdoc) it respresents
 
 So to get to get access to a specific collection you document
-```typescript
+```javascript
 // continues from the block before...
 
-class myObject extends smartdata.DbDoc { // read the next block about DbDoc
+@Collection(myDb1)
+class myObject extends smartdata.DbDoc<myObject> { // read the next block about DbDoc
     property1:string
     property2:number
     constructor(optionsArg:{
-        queryArg?:any,
-        dataArg?:{
         property1:string,
         property2:number
-        }
     }) {
-        super(this,optionsArg)
+        super()
     }
 }
-let myCollection = myDb1.getCollection(myObject)
+let myCollection = myDb1.getCollectionByName<myObject>(myObject)
+
+// start to instantiate classes from scratch or database
 ``` 
 
 > Alert: You NEVER instantiate a collection.
@@ -74,14 +94,10 @@ DbDoc extends your class with the following methods:
 
 So now we can **store** instances of classes to Db...
 How do we **get** a new class instance from a Doc in the DB?
-Easy! Take a look at the constructor. When you specify `optionsArg.queryArg`
-smartdata will fill in the data from the database!
-But when you specify a `optionsArg.dataArg` instead
-the data for the class is taken from there :)
 
 ## TypeScript
 How does TypeScript play into this?
-Since you define your classes in TapeScript and types flow through smartdata in a generic way
+Since you define your classes in TypeScript and types flow through smartdata in a generic way
 you should get all the Intellisense and type checking you love when using smartdata.
 smartdata itself also bundles typings.
 So you don't need to install any additional types when importing smartdata. 

dist/index.d.ts

@@ -1,2 +1,3 @@
-export * from './smartdata.classes.dbcollection';
 export * from './smartdata.classes.db';
+export * from './smartdata.classes.dbcollection';
+export * from './smartdata.classes.dbdoc';

dist/index.js

@@ -2,6 +2,7 @@
 function __export(m) {
     for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
 }
-__export(require('./smartdata.classes.dbcollection'));
+__export(require("./smartdata.classes.db"));
-__export(require('./smartdata.classes.db'));
+__export(require("./smartdata.classes.dbcollection"));
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7O0FBRUEsaUJBQWMsa0NBQ2QsQ0FBQyxFQUQrQztBQUNoRCxpQkFBYyx3QkFDZCxDQUFDLEVBRHFDIn0=
+__export(require("./smartdata.classes.dbdoc"));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7O0FBRUEsNENBQXNDO0FBQ3RDLHNEQUFnRDtBQUNoRCwrQ0FBeUMifQ==

dist/smartdata.classes.db.d.ts

@@ -1,11 +1,33 @@
 /// <reference types="q" />
 import * as plugins from './smartdata.plugins';
+import { Objectmap } from 'lik';
+import { DbCollection } from './smartdata.classes.dbcollection';
+/**
+ * interface - indicates the database type
+ */
+export declare type TDbType = 'mongodb' | 'nedb';
+/**
+ * interface - indicates the connection status of the db
+ */
 export declare type TConnectionStatus = 'disconnected' | 'connected' | 'failed';
 export declare class Db {
+    dbType: TDbType;
     dbUrl: string;
     db: plugins.mongodb.Db;
     status: TConnectionStatus;
-    constructor(dbUrl: string);
+    collections: Objectmap<DbCollection<any>>;
+    constructor(dbUrlArg: string, dbTypeArg?: TDbType);
+    /**
+     * connects to the database that was specified during instance creation
+     */
     connect(): plugins.q.Promise<any>;
+    /**
+     * closes the connection to the databse
+     */
     close(): plugins.q.Promise<any>;
+    /**
+     * gets a collection by name: string
+     */
+    getCollectionByName<T>(nameArg: string): plugins.q.Promise<DbCollection<T>>;
+    addCollection(dbCollectionArg: DbCollection<any>): void;
 }

dist/smartdata.classes.db.js

@@ -1,11 +1,19 @@
 "use strict";
-const plugins = require('./smartdata.plugins');
+const plugins = require("./smartdata.plugins");
+const lik_1 = require("lik");
 class Db {
-    constructor(dbUrl) {
+    constructor(dbUrlArg, dbTypeArg = 'mongodb') {
-        this.dbUrl = dbUrl;
+        this.collections = new lik_1.Objectmap();
+        this.dbType = dbTypeArg;
+        this.dbUrl = dbUrlArg;
     }
+    // basic connection stuff ----------------------------------------------
+    /**
+     * connects to the database that was specified during instance creation
+     */
     connect() {
         let done = plugins.q.defer();
+        if (this.dbType === 'mongodb') {
             plugins.mongodb.MongoClient.connect(this.dbUrl, (err, db) => {
                 if (err) {
                     console.log(err);
@@ -15,15 +23,42 @@ class Db {
                 plugins.beautylog.success(`connected to database at ${this.dbUrl}`);
                 done.resolve(this.db);
             });
+        }
+        else if (this.dbType === 'nedb') {
+            this.db = null;
+        }
         return done.promise;
     }
+    /**
+     * closes the connection to the databse
+     */
     close() {
         let done = plugins.q.defer();
+        if (this.dbType === 'mongodb') {
             this.db.close();
+        }
         plugins.beautylog.ok(`disconnected to database at ${this.dbUrl}`);
         done.resolve();
         return done.promise;
     }
+    // advanced communication with the database --------------------------------
+    /**
+     * gets a collection by name: string
+     */
+    getCollectionByName(nameArg) {
+        let done = plugins.q.defer();
+        let resultCollection = this.collections.find((dbCollectionArg) => {
+            return dbCollectionArg.name === nameArg;
+        });
+        if (resultCollection !== null) {
+            done.resolve(resultCollection);
+        }
+        return done.promise;
+    }
+    ;
+    addCollection(dbCollectionArg) {
+        this.collections.add(dbCollectionArg);
+    }
 }
 exports.Db = Db;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRkYXRhLmNsYXNzZXMuZGIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9zbWFydGRhdGEuY2xhc3Nlcy5kYi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsTUFBWSxPQUFPLFdBQU0scUJBRXpCLENBQUMsQ0FGNkM7QUFJOUM7SUFLSSxZQUFZLEtBQWE7UUFDckIsSUFBSSxDQUFDLEtBQUssR0FBRyxLQUFLLENBQUE7SUFDdEIsQ0FBQztJQUVELE9BQU87UUFDSCxJQUFJLElBQUksR0FBRyxPQUFPLENBQUMsQ0FBQyxDQUFDLEtBQUssRUFBRSxDQUFBO1FBQzVCLE9BQU8sQ0FBQyxPQUFPLENBQUMsV0FBVyxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsS0FBSyxFQUFFLENBQUMsR0FBRyxFQUFFLEVBQUU7WUFDcEQsRUFBRSxDQUFDLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQztnQkFBQyxPQUFPLENBQUMsR0FBRyxDQUFDLEdBQUcsQ0FBQyxDQUFBO1lBQUMsQ0FBQztZQUM3QixPQUFPLENBQUMsTUFBTSxDQUFDLEtBQUssQ0FBQyxJQUFJLEVBQUUsR0FBRyxDQUFDLENBQUE7WUFDL0IsSUFBSSxDQUFDLEVBQUUsR0FBRyxFQUFFLENBQUE7WUFDWixPQUFPLENBQUMsU0FBUyxDQUFDLE9BQU8sQ0FBQyw0QkFBNEIsSUFBSSxDQUFDLEtBQUssRUFBRSxDQUFDLENBQUE7WUFDbkUsSUFBSSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsRUFBRSxDQUFDLENBQUE7UUFDekIsQ0FBQyxDQUFDLENBQUE7UUFDRixNQUFNLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQTtJQUN2QixDQUFDO0lBRUQsS0FBSztRQUNELElBQUksSUFBSSxHQUFHLE9BQU8sQ0FBQyxDQUFDLENBQUMsS0FBSyxFQUFFLENBQUE7UUFDNUIsSUFBSSxDQUFDLEVBQUUsQ0FBQyxLQUFLLEVBQUUsQ0FBQTtRQUNmLE9BQU8sQ0FBQyxTQUFTLENBQUMsRUFBRSxDQUFDLCtCQUErQixJQUFJLENBQUMsS0FBSyxFQUFFLENBQUMsQ0FBQTtRQUNqRSxJQUFJLENBQUMsT0FBTyxFQUFFLENBQUE7UUFDZCxNQUFNLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQTtJQUN2QixDQUFDO0FBQ0wsQ0FBQztBQTVCWSxVQUFFLEtBNEJkLENBQUEifQ==
+//# sourceMappingURL=data:application/json;base64,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

dist/smartdata.classes.dbcollection.d.ts

@@ -1,17 +1,31 @@
 /// <reference types="q" />
 import * as plugins from './smartdata.plugins';
 import { Db } from './smartdata.classes.db';
+export interface IFindOptions {
+    limit?: number;
+}
+export interface IDocValidation<T> {
+    (doc: T): boolean;
+}
+export declare function Collection(db: Db): (constructor: any) => void;
 export declare class DbCollection<T> {
+    /**
+     * the collection that is used, defaults to mongodb collection,
+     * can be nedb datastore (sub api of mongodb)
+     */
     collection: plugins.mongodb.Collection;
+    name: string;
+    db: Db;
+    objectValidation: IDocValidation<T>;
     constructor(nameArg: string, dbArg: Db);
     /**
      * adds a validation function that all newly inserted and updated objects have to pass
      */
-    addObjectValidation(funcArg: any): void;
+    addDocValidation(funcArg: IDocValidation<T>): void;
     /**
      * finds an object in the DbCollection
      */
-    find(docMatchArg: T | any): plugins.q.Promise<T[]>;
+    find(docMatchArg: T | any, optionsArg?: IFindOptions): plugins.q.Promise<T[]>;
     /**
      * inserts object into the DbCollection
      */
@@ -20,5 +34,8 @@ export declare class DbCollection<T> {
      * inserts many objects at once into the DbCollection
      */
     insertMany(docArrayArg: T[]): plugins.q.Promise<void>;
-    private checkDoc(doc);
+    /**
+     * checks a Doc for constraints
+     */
+    private checkDoc(docArg);
 }

dist/smartdata.classes.dbdoc.d.ts

@@ -0,0 +1,34 @@
+import { DbCollection } from './smartdata.classes.dbcollection';
+export declare type TDocCreation = 'db' | 'data' | 'mixed';
+/**
+ * sva - saveable decorator to be used on class properties
+ */
+export declare function saveable(target: DbDoc<any>, key: string): void;
+export declare class DbDoc<T> {
+    /**
+     * the collection object an Doc belongs to
+     */
+    collection: DbCollection<T>;
+    /**
+     * how the Doc in memory was created, may prove useful later.
+     */
+    creationType: TDocCreation;
+    /**
+     * an array of saveable properties of a doc
+     */
+    saveableProperties: string[];
+    /**
+     * class constructor
+     */
+    constructor();
+    /**
+     * saves this instance but not any connected items
+     * may lead to data inconsistencies, but is faster
+     */
+    save(): void;
+    /**
+     * also store any referenced objects to DB
+     * better for data consistency
+     */
+    saveDeep(): void;
+}

dist/smartdata.classes.dbdoc.js

@@ -1 +1,39 @@
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRkYXRhLmNsYXNzZXMuZGJkb2MuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9zbWFydGRhdGEuY2xhc3Nlcy5kYmRvYy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=
+"use strict";
+/**
+ * sva - saveable decorator to be used on class properties
+ */
+function saveable(target, key) {
+    console.log('called sva');
+    if (!target.saveableProperties) {
+        target.saveableProperties = [];
+    }
+    target.saveableProperties.push(key);
+}
+exports.saveable = saveable;
+class DbDoc {
+    /**
+     * class constructor
+     */
+    constructor() {
+        this.collection = this.constructor['dbCollection'];
+    }
+    /**
+     * saves this instance but not any connected items
+     * may lead to data inconsistencies, but is faster
+     */
+    save() {
+        let saveableObject = {};
+        for (let propertyNameString of this.saveableProperties) {
+            saveableObject[propertyNameString] = this[propertyNameString];
+        }
+    }
+    /**
+     * also store any referenced objects to DB
+     * better for data consistency
+     */
+    saveDeep() {
+        this.save();
+    }
+}
+exports.DbDoc = DbDoc;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRkYXRhLmNsYXNzZXMuZGJkb2MuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9zbWFydGRhdGEuY2xhc3Nlcy5kYmRvYy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBT0E7O0dBRUc7QUFDSCxrQkFBeUIsTUFBa0IsRUFBRSxHQUFXO0lBQ3BELE9BQU8sQ0FBQyxHQUFHLENBQUMsWUFBWSxDQUFDLENBQUE7SUFDekIsRUFBRSxDQUFDLENBQUMsQ0FBQyxNQUFNLENBQUMsa0JBQWtCLENBQUMsQ0FBQyxDQUFDO1FBQUMsTUFBTSxDQUFDLGtCQUFrQixHQUFHLEVBQUUsQ0FBQTtJQUFDLENBQUM7SUFDbEUsTUFBTSxDQUFDLGtCQUFrQixDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQTtBQUN2QyxDQUFDO0FBSkQsNEJBSUM7QUFFRDtJQWlCSTs7T0FFRztJQUNIO1FBQ0ksSUFBSSxDQUFDLFVBQVUsR0FBRyxJQUFJLENBQUMsV0FBVyxDQUFDLGNBQWMsQ0FBQyxDQUFBO0lBQ3RELENBQUM7SUFFRDs7O09BR0c7SUFDSCxJQUFJO1FBQ0EsSUFBSSxjQUFjLEdBQUcsRUFBRSxDQUFBO1FBQ3ZCLEdBQUcsQ0FBQyxDQUFDLElBQUksa0JBQWtCLElBQUksSUFBSSxDQUFDLGtCQUFrQixDQUFDLENBQUMsQ0FBQztZQUNyRCxjQUFjLENBQUMsa0JBQWtCLENBQUMsR0FBRyxJQUFJLENBQUMsa0JBQWtCLENBQUMsQ0FBQTtRQUNqRSxDQUFDO0lBQ0wsQ0FBQztJQUVEOzs7T0FHRztJQUNILFFBQVE7UUFDSixJQUFJLENBQUMsSUFBSSxFQUFFLENBQUE7SUFDZixDQUFDO0NBQ0o7QUExQ0Qsc0JBMENDIn0=

dist/smartdata.plugins.d.ts

@@ -1,5 +1,8 @@
 import 'typings-global';
-export import assert = require('assert');
+import * as assert from 'assert';
-export import beautylog = require('beautylog');
+import * as beautylog from 'beautylog';
-export import mongodb = require('mongodb');
+import * as lodash from 'lodash';
-export import q = require('q');
+import * as mongodb from 'mongodb';
+import * as q from 'q';
+declare let nedb: any;
+export { assert, beautylog, lodash, mongodb, q, nedb };

dist/smartdata.plugins.js

@@ -1,7 +1,15 @@
 "use strict";
-require('typings-global');
+require("typings-global");
-exports.assert = require('assert');
+const assert = require("assert");
-exports.beautylog = require('beautylog');
+exports.assert = assert;
-exports.mongodb = require('mongodb');
+const beautylog = require("beautylog");
-exports.q = require('q');
+exports.beautylog = beautylog;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRkYXRhLnBsdWdpbnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9zbWFydGRhdGEucGx1Z2lucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsUUFBTyxnQkFDUCxDQUFDLENBRHNCO0FBQ1QsY0FBTSxXQUFXLFFBQVEsQ0FBQyxDQUFBO0FBQzFCLGlCQUFTLFdBQVcsV0FBVyxDQUFDLENBQUE7QUFDaEMsZUFBTyxXQUFXLFNBQVMsQ0FBQyxDQUFBO0FBQzVCLFNBQUMsV0FBVyxHQUFHLENBQUMsQ0FBQSJ9
+const lodash = require("lodash");
+exports.lodash = lodash;
+const mongodb = require("mongodb");
+exports.mongodb = mongodb;
+const q = require("q");
+exports.q = q;
+let nedb = require('nedb');
+exports.nedb = nedb;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRkYXRhLnBsdWdpbnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9zbWFydGRhdGEucGx1Z2lucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsMEJBQXVCO0FBQ3ZCLGlDQUFnQztBQVE1Qix3QkFBTTtBQVBWLHVDQUFzQztBQVFsQyw4QkFBUztBQVBiLGlDQUFnQztBQVE1Qix3QkFBTTtBQVBWLG1DQUFrQztBQVE5QiwwQkFBTztBQVBYLHVCQUFzQjtBQVFsQixjQUFDO0FBUEwsSUFBSSxJQUFJLEdBQUcsT0FBTyxDQUFDLE1BQU0sQ0FBQyxDQUFBO0FBUXRCLG9CQUFJIn0=

package.json

@@ -1,6 +1,6 @@
 {
   "name": "smartdata",
-  "version": "1.0.13",
+  "version": "1.0.19",
   "description": "do more with data",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -19,19 +19,25 @@
   },
   "homepage": "https://gitlab.com/pushrocks/smartdata#README",
   "dependencies": {
-    "@types/mongodb": "^2.1.32",
+    "@types/lodash": "^4.14.39",
-    "@types/q": "0.0.30",
+    "@types/mongodb": "^2.1.34",
-    "beautylog": "^5.0.23",
+    "@types/nedb": "0.0.31",
-    "mongodb": "^2.2.9",
+    "@types/q": "0.0.32",
+    "beautylog": "^6.0.0",
+    "lik": "^1.0.24",
+    "lodash": "^4.17.2",
+    "mongodb": "^2.2.11",
+    "nedb": "^1.8.0",
     "q": "^1.4.1",
+    "runtime-type-checks": "0.0.4",
     "typings-global": "^1.0.14"
   },
   "devDependencies": {
-    "@types/shelljs": "^0.3.30",
+    "@types/shelljs": "^0.3.32",
-    "@types/should": "^8.1.29",
+    "@types/should": "^8.1.30",
-    "shelljs": "^0.7.4",
+    "shelljs": "^0.7.5",
-    "should": "^11.1.0",
+    "should": "^11.1.1",
-    "smartstring": "^2.0.17",
+    "smartstring": "^2.0.22",
     "typings-test": "^1.0.3"
   }
 }

test/test.ts

@@ -18,21 +18,13 @@ interface ITestObject1 {
 
 let testDbCollection: smartdata.DbCollection<ITestObject1>
 
-class testCar {
-    color: string
-    constructor(colorArg:string) {
-        this.color = colorArg
-    }
-}
-
-
 describe('mongodb', function () {
     it('should start mongodb', function (done) {
         this.timeout(30000)
         mongoChildProcess = shelljs.exec('mongod --dbpath=./test/data --port 27017', { async: true, silent: true })
         let doneCalled = false
         mongoChildProcess.stdout.on('data', function (data) {
-            console.log(smartstring.indent.indentWithPrefix(data, "*** MongoDB Process *** : "))
+            console.log(smartstring.indent.indentWithPrefix(data, '*** MongoDB Process *** : '))
             if (!doneCalled) {
                 if (/waiting for connections on port 27017/.test(data)) {
                     doneCalled = true
@@ -77,6 +69,33 @@ describe('smartdata', function () {
     it('should close the db Connection', function () {
         testDb.close()
     })
+    it('should create an extended class', function () {
+        @smartdata.Collection(testDb)
+        class TestCar extends smartdata.DbDoc<TestCar> {
+            @smartdata.saveable
+            color: string
+            constructor(optionsArg: {
+                color: string,
+                property2: number
+            }) {
+                super()
+                this.color = optionsArg.color
+            }
+        };
+        let testCarInstance = new TestCar({
+            color: 'red',
+            property2: 2
+        })
+
+        should(testCarInstance.saveableProperties[0]).equal('color')
+        console.log(TestCar)
+        should(testCarInstance.collection).be.instanceof(smartdata.DbCollection)
+        should(testCarInstance).be.instanceof(smartdata.DbDoc)
+        testCarInstance.save()
+        it('should get a collection for testCar', function () {
+
+        })
+    })
 })
 
 describe('mongodb', function () {
@@ -91,3 +110,24 @@ describe('mongodb', function () {
         mongoChildProcess.kill('SIGTERM')
     })
 })
+
+describe('smartdata with nedb', function () {
+    let testDb: smartdata.Db
+    let testCollection: smartdata.DbCollection<ITestObject1>
+    it('should create a DB with nedb', function () {
+        testDb = new smartdata.Db('any', 'nedb')
+        testDb.connect()
+        testCollection = new smartdata.DbCollection<ITestObject1>('anyName', testDb)
+    })
+
+    it('should insert a doc', function(done){
+        testCollection.insertOne({ value1: 'hi' }).then(() => {done()})
+    })
+
+    it('should find the inserted document', function(done){
+        testCollection.find({ value1: 'hi' }).then(x => {
+            console.log(x)
+            done()
+        })
+    })
+})

ts/index.ts

@@ -1,4 +1,5 @@
 import * as plugins from './smartdata.plugins'
 
-export * from './smartdata.classes.dbcollection'
 export * from './smartdata.classes.db'
+export * from './smartdata.classes.dbcollection'
+export * from './smartdata.classes.dbdoc'

ts/smartdata.classes.db.ts

@@ -1,18 +1,38 @@
 import * as plugins from './smartdata.plugins'
+import { Objectmap } from 'lik'
 
+import { DbCollection } from './smartdata.classes.dbcollection'
+
+/**
+ * interface - indicates the database type
+ */
+export type TDbType = 'mongodb' | 'nedb'
+
+/**
+ * interface - indicates the connection status of the db
+ */
 export type TConnectionStatus = 'disconnected' | 'connected' | 'failed'
 
 export class Db {
+    dbType: TDbType
     dbUrl: string
     db: plugins.mongodb.Db
     status: TConnectionStatus
+    collections = new Objectmap<DbCollection<any>>()
 
-    constructor(dbUrl: string) {
+    constructor(dbUrlArg: string, dbTypeArg: TDbType = 'mongodb') {
-        this.dbUrl = dbUrl
+        this.dbType = dbTypeArg
+        this.dbUrl = dbUrlArg
     }
 
+    // basic connection stuff ----------------------------------------------
+
+    /**
+     * connects to the database that was specified during instance creation
+     */
     connect(): plugins.q.Promise<any> {
         let done = plugins.q.defer()
+        if (this.dbType === 'mongodb') {
             plugins.mongodb.MongoClient.connect(this.dbUrl, (err, db) => {
                 if (err) { console.log(err) }
                 plugins.assert.equal(null, err)
@@ -20,14 +40,43 @@ export class Db {
                 plugins.beautylog.success(`connected to database at ${this.dbUrl}`)
                 done.resolve(this.db)
             })
+        } else if (this.dbType === 'nedb') {
+            this.db = null
+        }
         return done.promise
     }
 
+    /**
+     * closes the connection to the databse
+     */
     close(): plugins.q.Promise<any> {
         let done = plugins.q.defer()
+        if (this.dbType === 'mongodb') {
             this.db.close()
+        }
         plugins.beautylog.ok(`disconnected to database at ${this.dbUrl}`)
         done.resolve()
         return done.promise
     }
+
+    // advanced communication with the database --------------------------------
+
+    /**
+     * gets a collection by name: string
+     */
+    getCollectionByName<T>(nameArg: string): plugins.q.Promise<DbCollection<T>> {
+        let done = plugins.q.defer<DbCollection<any>>()
+        let resultCollection = this.collections.find((dbCollectionArg) => {
+            return dbCollectionArg.name === nameArg
+        })
+        if (resultCollection !== null) {
+            done.resolve(resultCollection)
+        }
+        return done.promise
+    };
+
+    addCollection(dbCollectionArg: DbCollection<any>) {
+        this.collections.add(dbCollectionArg)
+    }
+    
 }

ts/smartdata.classes.dbcollection.ts

@@ -1,26 +1,74 @@
 import * as plugins from './smartdata.plugins'
 import { Db } from './smartdata.classes.db'
 
+export interface IFindOptions {
+    limit?: number
+}
+
+export interface IDocValidation<T> {
+    (doc: T): boolean
+}
+
+export function Collection(db: Db) {
+    return function (constructor) {
+        constructor['dbCollection'] = new DbCollection(constructor.name, db)
+    }
+}
+
 export class DbCollection<T> {
+    /**
+     * the collection that is used, defaults to mongodb collection,
+     * can be nedb datastore (sub api of mongodb)
+     */
     collection: plugins.mongodb.Collection
+    name: string
+    db: Db
+    objectValidation: IDocValidation<T> = null
+
+
     constructor(nameArg: string, dbArg: Db) {
+        this.name = nameArg
+        this.db = dbArg
+        if (this.db.dbType === 'mongodb') {
             this.collection = dbArg.db.collection(nameArg)
+        } else {
+            this.collection = new plugins.nedb()
+        }
     }
 
     /**
      * adds a validation function that all newly inserted and updated objects have to pass
      */
-    addObjectValidation(funcArg) { }
+    addDocValidation(funcArg: IDocValidation<T>) {
+        this.objectValidation = funcArg
+    }
 
     /**
      * finds an object in the DbCollection
      */
-    find(docMatchArg: T | any): plugins.q.Promise<T[]> {
+    find(docMatchArg: T | any, optionsArg?: IFindOptions): plugins.q.Promise<T[]> {
         let done = plugins.q.defer<T[]>()
-        this.collection.find(docMatchArg).toArray((err, docs) => {
+        if (this.db.dbType === 'mongodb') {
-            if (err) { throw err }
+            let findCursor = this.collection.find(docMatchArg)
+            if (optionsArg) {
+                if (optionsArg.limit) { findCursor = findCursor.limit(1) }
+            }
+            findCursor.toArray((err, docs) => {
+                if (err) {
+                    done.reject(err)
+                    throw err
+                }
                 done.resolve(docs)
             })
+        } else if (this.db.dbType === 'nedb') {
+            this.collection.find(docMatchArg, (err, docs) => {
+                if (err) {
+                    done.reject(err)
+                    throw err
+                }
+                done.resolve(docs)
+            })
+        }
         return done.promise
     }
 
@@ -29,9 +77,23 @@ export class DbCollection<T> {
      */
     insertOne(docArg: T): plugins.q.Promise<void> {
         let done = plugins.q.defer<void>()
-        this.checkDoc(docArg).then(() => {
+        this.checkDoc(docArg).then(
+            () => {
+                if (this.db.dbType === 'mongodb') {
                     this.collection.insertOne(docArg)
                         .then(() => { done.resolve() })
+                } else if (this.db.dbType === 'nedb') {
+                    this.collection.insert(docArg, (err, newDoc) => {
+                        if (err) {
+                            done.reject(err)
+                            throw err
+                        }
+                        done.resolve()
+                    })
+                }
+            },
+            () => {
+                done.reject(new Error('one the docs did not pass validation'))
             })
         return done.promise
     }
@@ -46,15 +108,37 @@ export class DbCollection<T> {
             checkDocPromiseArray.push(this.checkDoc(docArg))
         }
         plugins.q.all(checkDocPromiseArray).then(() => {
+            if (this.db.dbType === 'mongodb') {
                 this.collection.insertMany(docArrayArg)
                     .then(() => { done.resolve() })
+            } else if (this.db.dbType === 'nedb') {
+                let paramArray = plugins.lodash.concat<any>(docArrayArg, (err, newDoc) => {
+                    if (err) {
+                        done.reject(err)
+                        throw err
+                    }
+                    done.resolve()
+                })
+                this.collection.insert.apply(null, paramArray)
+            }
         })
         return done.promise
     }
 
-    private checkDoc(doc: T): plugins.q.Promise<void> {
+    /**
+     * checks a Doc for constraints
+     */
+    private checkDoc(docArg: T): plugins.q.Promise<void> {
         let done = plugins.q.defer<void>()
+        let validationResult = true
+        if (this.objectValidation) {
+            validationResult = this.objectValidation(docArg)
+        }
+        if (validationResult) {
             done.resolve()
+        } else {
+            done.reject('validation of object did not pass')
+        }
         return done.promise
     }
 }

ts/smartdata.classes.dbdoc.ts

@@ -0,0 +1,59 @@
+import * as plugins from './smartdata.plugins'
+
+import { Db } from './smartdata.classes.db'
+import { DbCollection } from './smartdata.classes.dbcollection'
+
+export type TDocCreation = 'db' | 'data' | 'mixed'
+
+/**
+ * sva - saveable decorator to be used on class properties
+ */
+export function saveable(target: DbDoc<any>, key: string) {
+    console.log('called sva')
+    if (!target.saveableProperties) { target.saveableProperties = [] }
+    target.saveableProperties.push(key)
+}
+
+export class DbDoc<T> {
+
+    /**
+     * the collection object an Doc belongs to
+     */
+    collection: DbCollection<T>
+
+    /**
+     * how the Doc in memory was created, may prove useful later.
+     */
+    creationType: TDocCreation
+
+    /**
+     * an array of saveable properties of a doc
+     */
+    saveableProperties: string[]
+
+    /**
+     * class constructor
+     */
+    constructor() {
+        this.collection = this.constructor['dbCollection']
+    }
+
+    /**
+     * saves this instance but not any connected items
+     * may lead to data inconsistencies, but is faster
+     */
+    save() {
+        let saveableObject = {}
+        for (let propertyNameString of this.saveableProperties) {
+            saveableObject[propertyNameString] = this[propertyNameString]
+        }
+    }
+
+    /**
+     * also store any referenced objects to DB
+     * better for data consistency
+     */
+    saveDeep() {
+        this.save()
+    }
+}

ts/smartdata.plugins.ts

@@ -1,5 +1,16 @@
 import 'typings-global'
-export import assert = require('assert')
+import * as assert from 'assert'
-export import beautylog = require('beautylog')
+import * as beautylog from 'beautylog'
-export import mongodb = require('mongodb')
+import * as lodash from 'lodash'
-export import q = require('q')
+import * as mongodb from 'mongodb'
+import * as q from 'q'
+let nedb = require('nedb')
+
+export {
+    assert,
+    beautylog,
+    lodash,
+    mongodb,
+    q,
+    nedb
+}

tsconfig.json

@@ -0,0 +1,5 @@
+{
+    "compilerOptions": {
+        "experimentalDecorators": true
+    }
+}