4.0.0

.gitignore

@@ -1,5 +1,20 @@
-node_modules/
-test/data
-pages/
+.nogit/
+
+# artifacts
 coverage/
 public/
+pages/
+
+# installs
+node_modules/
+
+# caches
+.yarn/
+.cache/
+.rpt2_cache
+
+# builds
+dist/
+dist_*/
+
+# custom

.gitlab-ci.yml

@@ -1,43 +1,137 @@
-image: hosttoday/ht-docker-node:npmts
+# gitzone ci_default
+image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
+
+cache:
+  paths:
+    - .npmci_cache/
+  key: '$CI_BUILD_STAGE'
 
 stages:
-- test
-- release
+  - security
+  - test
+  - release
+  - metadata
 
-before_script:
-  - apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv EA312927
-  - echo "deb http://repo.mongodb.org/apt/ubuntu xenial/mongodb-org/3.2 multiverse" | tee /etc/apt/sources.list.d/mongodb-org-3.2.list
-  - apt-get update
-  - apt-get install -y mongodb-org
-
-testLEGACY:
-  stage: test
+# ====================
+# security stage
+# ====================
+mirror:
+  stage: security
   script:
-    - npmci test legacy
+    - npmci git mirror
+  only:
+    - tags
+  tags:
+    - lossless
+    - docker
+    - notpriv
+
+auditProductionDependencies:
+  image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
+  stage: security
+  script:
+    - npmci npm prepare
+    - npmci command npm install --production --ignore-scripts
+    - npmci command npm config set registry https://registry.npmjs.org
+    - npmci command npm audit --audit-level=high --only=prod --production
+  tags:
+    - docker
+
+auditDevDependencies:
+  image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
+  stage: security
+  script:
+    - npmci npm prepare
+    - npmci command npm install --ignore-scripts
+    - npmci command npm config set registry https://registry.npmjs.org
+    - npmci command npm audit --audit-level=high --only=dev
   tags:
     - docker
   allow_failure: true
 
-testLTS:
+# ====================
+# test stage
+# ====================
+
+testStable:
   stage: test
   script:
-    - npmci test lts
+    - npmci npm prepare
+    - npmci node install stable
+    - npmci npm install
+    - npmci npm test
+  coverage: /\d+.?\d+?\%\s*coverage/
   tags:
     - docker
-    
-testSTABLE:
+
+testBuild:
   stage: test
   script:
-    - npmci test stable
+    - npmci npm prepare
+    - npmci node install stable
+    - npmci npm install
+    - npmci command npm run build
+  coverage: /\d+.?\d+?\%\s*coverage/
   tags:
     - docker
 
 release:
   stage: release
-  environment: npm_registry
   script:
-    - npmci publish
+    - npmci node install stable
+    - npmci npm publish
   only:
     - tags
   tags:
-    - docker
+    - lossless
+    - docker
+    - notpriv
+
+# ====================
+# metadata stage
+# ====================
+codequality:
+  stage: metadata
+  allow_failure: true
+  only:
+    - tags
+  script:
+    - npmci command npm install -g tslint typescript
+    - npmci npm prepare
+    - npmci npm install
+    - npmci command "tslint -c tslint.json ./ts/**/*.ts"
+  tags:
+    - lossless
+    - docker
+    - priv
+
+trigger:
+  stage: metadata
+  script:
+    - npmci trigger
+  only:
+    - tags
+  tags:
+    - lossless
+    - docker
+    - notpriv
+
+pages:
+  stage: metadata
+  script:
+    - npmci node install lts
+    - npmci command npm install -g @gitzone/tsdoc
+    - npmci npm prepare
+    - npmci npm install
+    - npmci command tsdoc
+  tags:
+    - lossless
+    - docker
+    - notpriv
+  only:
+    - tags
+  artifacts:
+    expire_in: 1 week
+    paths:
+      - public
+  allow_failure: true

.vscode/launch.json

@@ -0,0 +1,29 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "name": "current file",
+      "type": "node",
+      "request": "launch",
+      "args": [
+        "${relativeFile}"
+      ],
+      "runtimeArgs": ["-r", "@gitzone/tsrun"],
+      "cwd": "${workspaceRoot}",
+      "protocol": "inspector",
+      "internalConsoleOptions": "openOnSessionStart"
+    },
+    {
+      "name": "test.ts",
+      "type": "node",
+      "request": "launch",
+      "args": [
+        "test/test.ts"
+      ],
+      "runtimeArgs": ["-r", "@gitzone/tsrun"],
+      "cwd": "${workspaceRoot}",
+      "protocol": "inspector",
+      "internalConsoleOptions": "openOnSessionStart"
+    }
+  ]
+}

.vscode/settings.json

@@ -0,0 +1,26 @@
+{
+  "json.schemas": [
+    {
+      "fileMatch": ["/npmextra.json"],
+      "schema": {
+        "type": "object",
+        "properties": {
+          "npmci": {
+            "type": "object",
+            "description": "settings for npmci"
+          },
+          "gitzone": {
+            "type": "object",
+            "description": "settings for gitzone",
+            "properties": {
+              "projectType": {
+                "type": "string",
+                "enum": ["website", "element", "service", "npm", "wcc"]
+              }
+            }
+          }
+        }
+      }
+    }
+  ]
+}

README.md

@@ -1,105 +0,0 @@
-# smartdata
-
-> Note: Still in Beta
-
-## Availabililty
-[![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 an ODM that uses TypeScript,
-acts smart while still embracing the NoSQL idea we didn't find a matching solution.
-This is why we started smartdata.
-
-How MongoDB terms map to smartdata classes
-
-MongoDB term | smartdata class
---- | ---
-Database | smartdata.Db
-Collection | smartdata.DbCollection
-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.
-```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()
-
-// continues in next block... 
-```
-
-### class DbCollection
-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
-```javascript
-// continues from the block before...
-
-@Collection(myDb1)
-class myObject extends smartdata.DbDoc<myObject> { // read the next block about DbDoc
-    @smartdata.saveable property1: string // @smartdata.saveable marks the property for db save
-    property2: number // this one is not marked, so it won't be save upon calling this.save() 
-    constructor(optionsArg:{
-        property1: string,
-        property2: number
-    }) {
-        super()
-    }
-}
-let myCollection = myDb1.getCollectionByName<myObject>(myObject)
-
-// start to instantiate classes from scratch or database
-``` 
-
-> Alert: You NEVER instantiate a collection.
-This is done for you!!!
-
-### class DbDoc
-represents a individual document in a collection
-and thereby is ideally suited to extend the class you want to actually store.
-
-DbDoc extends your class with the following methods:
-
-* `.save()` will save (or update) the object you call it on only. Any referenced non-savable objects will not get stored.
-* `.saveDeep()` does the same like `.save()`.
-  In addition it will look for properties that reference an object
-  that extends DbDoc as well and call .saveDeep() on them as well.
-  Loops are prevented
-
-So now we can **store** instances of classes to Db...
-How do we **get** a new class instance from a Doc in the DB?
-
-## TypeScript
-How does TypeScript play into this?
-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. 
-
-[![npm](https://push.rocks/assets/repo-header.svg)](https://push.rocks)

dist/index.d.ts

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

dist/index.js

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

dist/smartdata.classes.db.d.ts

@@ -1,33 +0,0 @@
-/// <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;
-    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,64 +0,0 @@
-"use strict";
-const plugins = require("./smartdata.plugins");
-const lik_1 = require("lik");
-class Db {
-    constructor(dbUrlArg, dbTypeArg = 'mongodb') {
-        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);
-                }
-                plugins.assert.equal(null, err);
-                this.db = 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,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

dist/smartdata.classes.dbcollection.d.ts

@@ -1,41 +0,0 @@
-/// <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
-     */
-    addDocValidation(funcArg: IDocValidation<T>): void;
-    /**
-     * finds an object in the DbCollection
-     */
-    find(docMatchArg: T | any, optionsArg?: IFindOptions): plugins.q.Promise<T[]>;
-    /**
-     * inserts object into the DbCollection
-     */
-    insertOne(docArg: T): plugins.q.Promise<void>;
-    /**
-     * inserts many objects at once into the DbCollection
-     */
-    insertMany(docArrayArg: T[]): plugins.q.Promise<void>;
-    /**
-     * checks a Doc for constraints
-     */
-    private checkDoc(docArg);
-}

dist/smartdata.classes.dbdoc.d.ts

@@ -1,34 +0,0 @@
-import { DbCollection } from './smartdata.classes.dbcollection';
-export declare type TDocCreation = 'db' | 'new' | 'mixed';
-/**
- * saveable - 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,46 +0,0 @@
-"use strict";
-/**
- * saveable - 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];
-        }
-        switch (this.creationType) {
-            case 'db':
-                this.collection; // TODO implement collection.update()
-                break;
-            case 'new':
-                this.collection.insertOne(saveableObject);
-        }
-    }
-    /**
-     * also store any referenced objects to DB
-     * better for data consistency
-     */
-    saveDeep() {
-        this.save();
-    }
-}
-exports.DbDoc = DbDoc;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRkYXRhLmNsYXNzZXMuZGJkb2MuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9zbWFydGRhdGEuY2xhc3Nlcy5kYmRvYy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBT0E7O0dBRUc7QUFDSCxrQkFBeUIsTUFBa0IsRUFBRSxHQUFXO0lBQ3BELE9BQU8sQ0FBQyxHQUFHLENBQUMsWUFBWSxDQUFDLENBQUE7SUFDekIsRUFBRSxDQUFDLENBQUMsQ0FBQyxNQUFNLENBQUMsa0JBQWtCLENBQUMsQ0FBQyxDQUFDO1FBQUMsTUFBTSxDQUFDLGtCQUFrQixHQUFHLEVBQUUsQ0FBQTtJQUFDLENBQUM7SUFDbEUsTUFBTSxDQUFDLGtCQUFrQixDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQTtBQUN2QyxDQUFDO0FBSkQsNEJBSUM7QUFFRDtJQWlCSTs7T0FFRztJQUNIO1FBQ0ksSUFBSSxDQUFDLFVBQVUsR0FBRyxJQUFJLENBQUMsV0FBVyxDQUFDLGNBQWMsQ0FBQyxDQUFBO0lBQ3RELENBQUM7SUFFRDs7O09BR0c7SUFDSCxJQUFJO1FBQ0EsSUFBSSxjQUFjLEdBQUcsRUFBRSxDQUFBO1FBQ3ZCLEdBQUcsQ0FBQyxDQUFDLElBQUksa0JBQWtCLElBQUksSUFBSSxDQUFDLGtCQUFrQixDQUFDLENBQUMsQ0FBQztZQUNyRCxjQUFjLENBQUMsa0JBQWtCLENBQUMsR0FBRyxJQUFJLENBQUMsa0JBQWtCLENBQUMsQ0FBQTtRQUNqRSxDQUFDO1FBQ0QsTUFBTSxDQUFDLENBQUMsSUFBSSxDQUFDLFlBQVksQ0FBQyxDQUFDLENBQUM7WUFDeEIsS0FBSyxJQUFJO2dCQUNMLElBQUksQ0FBQyxVQUFVLENBQUEsQ0FBQyxxQ0FBcUM7Z0JBQ3JELEtBQUssQ0FBQTtZQUNULEtBQUssS0FBSztnQkFDTixJQUFJLENBQUMsVUFBVSxDQUFDLFNBQVMsQ0FBQyxjQUFjLENBQUMsQ0FBQTtRQUNqRCxDQUFDO0lBQ0wsQ0FBQztJQUVEOzs7T0FHRztJQUNILFFBQVE7UUFDSixJQUFJLENBQUMsSUFBSSxFQUFFLENBQUE7SUFDZixDQUFDO0NBQ0o7QUFqREQsc0JBaURDIn0=

dist/smartdata.plugins.d.ts

@@ -1,8 +0,0 @@
-import 'typings-global';
-import * as assert from 'assert';
-import * as beautylog from 'beautylog';
-import * as lodash from 'lodash';
-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,15 +0,0 @@
-"use strict";
-require("typings-global");
-const assert = require("assert");
-exports.assert = assert;
-const beautylog = require("beautylog");
-exports.beautylog = beautylog;
-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=

docs/index.md

@@ -1,19 +0,0 @@
-# smartdata
-
-smartdata is a ODM that adheres to TypeScript practices and uses classes to organize data.
-It uses MongoDB as persistent storage.
-
-## Intention
-There are many ODMs out there, however when we searched for a ODM that uses TypeScript,
-acts smart while still embracing an easy the NoSQL idea we didn't find a matching solution.
-This is why we started smartdata
-
-How MongoDB terms map to smartdata classes
-
-MongoDB term | smartdata class
---- | ---
-Database | smartdata.DbConnection
-Collection | smartdata.DbCollection
-Document | smartdata.DbDoc
-
-[![npm](https://push.rocks/assets/repo-header.svg)](https://push.rocks)

npmextra.json

@@ -0,0 +1,23 @@
+{
+  "npmdocker": {
+    "baseImage": "hosttoday/ht-docker-node:mongo",
+    "command": "npmci test stable",
+    "dockerSock": false
+  },
+  "npmci": {
+    "npmGlobalTools": [],
+    "npmAccessLevel": "public",
+    "npmRegistryUrl": "registry.npmjs.org"
+  },
+  "gitzone": {
+    "projectType": "npm",
+    "module": {
+      "githost": "gitlab.com",
+      "gitscope": "pushrocks",
+      "gitrepo": "smartdata",
+      "shortDescription": "do more with data",
+      "npmPackagename": "@pushrocks/smartdata",
+      "license": "MIT"
+    }
+  }
+}

package.json

@@ -1,12 +1,14 @@
 {
-  "name": "smartdata",
-  "version": "1.0.21",
+  "name": "@pushrocks/smartdata",
+  "version": "4.0.0",
+  "private": false,
   "description": "do more with data",
-  "main": "dist/index.js",
-  "typings": "dist/index.d.ts",
+  "main": "dist_ts/index.js",
+  "typings": "dist_ts/index.d.ts",
   "scripts": {
-    "test": "(npm run prepareMongo && npmts)",
-    "prepareMongo": "(rm -rf ./test/data && mkdir ./test/data/)"
+    "test": "(tstest test/)",
+    "testLocal": "(npmdocker)",
+    "build": "(tsbuild --web)"
   },
   "repository": {
     "type": "git",
@@ -19,25 +21,43 @@
   },
   "homepage": "https://gitlab.com/pushrocks/smartdata#README",
   "dependencies": {
-    "@types/lodash": "^4.14.39",
-    "@types/mongodb": "^2.1.34",
-    "@types/nedb": "0.0.31",
-    "@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"
+    "@pushrocks/lik": "^4.0.20",
+    "@pushrocks/smartlog": "^2.0.39",
+    "@pushrocks/smartpromise": "^3.1.5",
+    "@pushrocks/smartstring": "^3.0.24",
+    "@tsclass/tsclass": "^3.0.33",
+    "@types/lodash": "^4.14.169",
+    "@types/mongodb": "^3.6.12",
+    "lodash": "^4.17.21",
+    "mongodb": "^3.6.6",
+    "runtime-type-checks": "0.0.4"
   },
   "devDependencies": {
-    "@types/shelljs": "^0.3.32",
-    "@types/should": "^8.1.30",
-    "shelljs": "^0.7.5",
-    "should": "^11.1.1",
-    "smartstring": "^2.0.22",
-    "typings-test": "^1.0.3"
-  }
+    "@gitzone/tsbuild": "^2.1.25",
+    "@gitzone/tstest": "^1.0.54",
+    "@pushrocks/qenv": "^4.0.10",
+    "@pushrocks/smartunique": "^3.0.3",
+    "@pushrocks/tapbundle": "^3.2.14",
+    "@types/mongodb-memory-server": "^2.3.0",
+    "@types/node": "^15.3.0",
+    "@types/shortid": "0.0.29",
+    "mongodb-memory-server": "^6.9.6",
+    "tslint": "^6.1.3",
+    "tslint-config-prettier": "^1.18.0"
+  },
+  "files": [
+    "ts/**/*",
+    "ts_web/**/*",
+    "dist/**/*",
+    "dist_*/**/*",
+    "dist_ts/**/*",
+    "dist_ts_web/**/*",
+    "assets/**/*",
+    "cli.js",
+    "npmextra.json",
+    "readme.md"
+  ],
+  "browserslist": [
+    "last 1 chrome versions"
+  ]
 }

qenv.yml

@@ -0,0 +1,4 @@
+required:
+  - MONGO_URL
+  - MONGO_DBNAME
+  - MONGO_PASS

readme.md

@@ -0,0 +1,146 @@
+# @pushrocks/smartdata
+do more with data
+
+## Availabililty and Links
+* [npmjs.org (npm package)](https://www.npmjs.com/package/@pushrocks/smartdata)
+* [gitlab.com (source)](https://gitlab.com/pushrocks/smartdata)
+* [github.com (source mirror)](https://github.com/pushrocks/smartdata)
+* [docs (typedoc)](https://pushrocks.gitlab.io/smartdata/)
+
+## Status for master
+
+Status Category | Status Badge
+-- | --
+GitLab Pipelines | [![pipeline status](https://gitlab.com/pushrocks/smartdata/badges/master/pipeline.svg)](https://lossless.cloud)
+GitLab Pipline Test Coverage | [![coverage report](https://gitlab.com/pushrocks/smartdata/badges/master/coverage.svg)](https://lossless.cloud)
+npm | [![npm downloads per month](https://badgen.net/npm/dy/@pushrocks/smartdata)](https://lossless.cloud)
+Snyk | [![Known Vulnerabilities](https://badgen.net/snyk/pushrocks/smartdata)](https://lossless.cloud)
+TypeScript Support | [![TypeScript](https://badgen.net/badge/TypeScript/>=%203.x/blue?icon=typescript)](https://lossless.cloud)
+node Support | [![node](https://img.shields.io/badge/node->=%2010.x.x-blue.svg)](https://nodejs.org/dist/latest-v10.x/docs/api/)
+Code Style | [![Code Style](https://badgen.net/badge/style/prettier/purple)](https://lossless.cloud)
+PackagePhobia (total standalone install weight) | [![PackagePhobia](https://badgen.net/packagephobia/install/@pushrocks/smartdata)](https://lossless.cloud)
+PackagePhobia (package size on registry) | [![PackagePhobia](https://badgen.net/packagephobia/publish/@pushrocks/smartdata)](https://lossless.cloud)
+BundlePhobia (total size when bundled) | [![BundlePhobia](https://badgen.net/bundlephobia/minzip/@pushrocks/smartdata)](https://lossless.cloud)
+Platform support | [![Supports Windows 10](https://badgen.net/badge/supports%20Windows%2010/yes/green?icon=windows)](https://lossless.cloud) [![Supports Mac OS X](https://badgen.net/badge/supports%20Mac%20OS%20X/yes/green?icon=apple)](https://lossless.cloud)
+
+## Usage
+
+Use TypeScript for best in class instellisense.
+
+smartdata is an ODM that adheres to TypeScript practices and uses classes to organize data.
+It uses RethinkDB as persistent storage.
+
+## Intention
+
+There are many ODMs out there, however when we searched for an ODM that uses TypeScript,
+acts smart while still embracing the NoSQL idea we didn't find a matching solution.
+This is why we started smartdata.
+
+How RethinkDB's terms map to the ones of smartdata:
+
+| MongoDb term | smartdata class               |
+| ------------ | ----------------------------- |
+| Database     | smartdata.SmartdataDb         |
+| Collection   | smartdata.SmartdataCollection |
+| Document     | smartdata.SmartadataDoc       |
+
+### class Db
+
+represents a Database. Naturally it has .connect() etc. methods on it.
+
+```typescript
+import * as smartdata from 'smartdata';
+
+const smartdataDb = new smartdata.SmartdataDb({
+  mongoDbUrl: '//someurl',
+  mongoDbName: 'myDatabase',
+  mongoDbPass: 'mypassword',
+});
+
+smartdataDb.connect();
+```
+
+### class DbCollection
+
+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
+// continues from the block before...
+
+@smartdata.Collection(smartdataDb)
+class MyObject extends smartdata.DbDoc<MyObject> {
+  // read the next block about DbDoc
+  @smartdata.svDb()
+  property1: string; // @smartdata.svDb() marks the property for db save
+
+  property2: number; // this one is not marked, so it won't be save upon calling this.save()
+
+  constructor() {
+    super(); // the super call is important ;) But you probably know that.
+  }
+}
+
+// start to instantiate instances of classes from scratch or database
+
+const localObject = new MyObject({
+  property1: 'hi',
+  property2: 2,
+});
+localObject.save(); // saves the object to the database
+
+// start retrieving instances
+
+MyObject.getInstance<MyObject>({
+  property: 'hi',
+}); // outputs a new instance of MyObject with the values from db assigned
+```
+
+### class DbDoc
+
+represents a individual document in a collection
+and thereby is ideally suited to extend the class you want to actually store.
+
+### CRUD operations
+
+smartdata supports full CRUD operations
+
+**Store** or **Update** instances of classes to MongoDB:
+DbDoc extends your class with the following methods:
+
+- async `.save()` will save (or update) the object you call it on only. Any referenced non-savable objects will not get stored.
+- async `.saveDeep()` does the same like `.save()`.
+  In addition it will look for properties that reference an object
+  that extends DbDoc as well and call .saveDeep() on them as well.
+  Loops are prevented
+
+**Get** a new class instance from MongoDB:
+DbDoc exposes a static method that allows you specify a filter to retrieve a cloned class of the one you used to that doc at some point later in time:
+
+- static async `.getInstance({ /* filter props here */ })` gets you an instance that has the data of the first matched document as properties.
+- static async `getInstances({ /* filter props here */ })` get you an array instances (one instance for every matched document).
+
+**Delete** instances from MongoDb:
+smartdata extends your class with a method to easily delete the doucment from DB:
+
+- async `.delete()`will delete the document from DB.
+
+## TypeScript
+
+How does TypeScript play into this?
+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. You don't need to install any additional types for smartdata.
+
+## Contribution
+
+We are always happy for code contributions. If you are not the code contributing type that is ok. Still, maintaining Open Source repositories takes considerable time and thought. If you like the quality of what we do and our modules are useful to you we would appreciate a little monthly contribution: You can [contribute one time](https://lossless.link/contribute-onetime) or [contribute monthly](https://lossless.link/contribute). :)
+
+For further information read the linked docs at the top of this readme.
+
+> MIT licensed | **&copy;** [Lossless GmbH](https://lossless.gmbh)
+| By using this npm module you agree to our [privacy policy](https://lossless.gmbH/privacy)
+
+[![repo-footer](https://lossless.gitlab.io/publicrelations/repofooter.svg)](https://maintainedby.lossless.com)

test/test.d.ts

@@ -1 +0,0 @@
-import 'typings-test';

test/test.ts

@@ -1,133 +1,222 @@
-import 'typings-test'
+import { tap, expect } from '@pushrocks/tapbundle';
+import { Qenv } from '@pushrocks/qenv';
 
-import * as shelljs from 'shelljs'
-import * as should from 'should'
-import * as smartstring from 'smartstring'
+const testQenv = new Qenv(process.cwd(), process.cwd() + '/.nogit/');
+
+console.log(process.memoryUsage());
 
 // the tested module
-import * as smartdata from '../dist/index'
+import * as smartdata from '../ts/index';
 
-let mongoChildProcess
-let testDb: smartdata.Db
+import * as mongoPlugin from 'mongodb-memory-server';
+import { smartunique } from '../ts/smartdata.plugins';
 
-interface ITestObject1 {
-    value1: string
-    value2?: number
-    value3?: string
+// =======================================
+// Connecting to the database server
+// =======================================
+
+let testDb: smartdata.SmartdataDb;
+let smartdataOptions: smartdata.IMongoDescriptor;
+let mongod: mongoPlugin.MongoMemoryServer;
+
+const totalCars = 2000;
+
+tap.skip.test('should create a testinstance as database', async () => {
+  mongod = new mongoPlugin.MongoMemoryServer({});
+  console.log('created mongod instance');
+  await mongod._startUpInstance().catch((err) => {
+    console.log(err);
+  });
+  console.log('mongod started');
+  smartdataOptions = {
+    mongoDbName: await mongod.getDbName(),
+    mongoDbPass: '',
+    mongoDbUrl: await mongod.getUri(),
+  };
+  console.log(smartdataOptions);
+  testDb = new smartdata.SmartdataDb(smartdataOptions);
+});
+
+tap.test('should connect to atlas', async (tools) => {
+  const databaseName = `test-smartdata-${smartunique.shortId()}`;
+  testDb = new smartdata.SmartdataDb({
+    mongoDbUrl: testQenv.getEnvVarOnDemand('MONGO_URL'),
+    mongoDbName: databaseName,
+  });
+});
+
+tap.test('should establish a connection to mongod', async () => {
+  await testDb.init();
+});
+
+// =======================================
+// The actual tests
+// =======================================
+
+// ------
+// Collections
+// ------
+
+@smartdata.Collection(() => {
+  return testDb;
+})
+class Car extends smartdata.SmartDataDbDoc<Car, Car> {
+  @smartdata.unI()
+  public index: string = smartunique.shortId();
+
+  @smartdata.svDb()
+  public color: string;
+
+  @smartdata.svDb()
+  public brand: string;
+
+  @smartdata.svDb()
+  deepData = {
+    sodeep: 'yes',
+  };
+
+  constructor(colorArg: string, brandArg: string) {
+    super();
+    this.color = colorArg;
+    this.brand = brandArg;
+  }
 }
 
-let testDbCollection: smartdata.DbCollection<ITestObject1>
+tap.test('should save the car to the db', async () => {
+  const myCar = new Car('red', 'Volvo');
+  await myCar.save();
 
-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 *** : '))
-            if (!doneCalled) {
-                if (/waiting for connections on port 27017/.test(data)) {
-                    doneCalled = true
-                    done()
-                }
-            }
-        })
-    })
+  const myCar2 = new Car('red', 'Volvo');
+  await myCar2.save();
+
+  let counter = 0;
+  process.memoryUsage();
+  do {
+    const myCar3 = new Car('red', 'Renault');
+    await myCar3.save();
+    counter++;
+    if (counter % 100 === 0) {
+      console.log(
+        `Filled database with ${counter} of ${totalCars} Cars and memory usage ${
+          process.memoryUsage().rss / 1e6
+        } MB`
+      );
+    }
+  } while (counter < totalCars);
+  console.log(process.memoryUsage());
+});
+
+tap.test('expect to get instance of Car with shallow match', async () => {
+  const totalQueryCycles = totalCars / 4;
+  let counter = 0;
+  do {
+    const timeStart = Date.now();
+    const myCars = await Car.getInstances({
+      brand: 'Renault',
+    });
+    if (counter % 10 === 0) {
+      console.log(
+        `performed ${counter} of ${totalQueryCycles} total query cycles: took ${
+          Date.now() - timeStart
+        }ms to query a set of 2000 with memory footprint ${process.memoryUsage().rss / 1e6} MB`
+      );
+    }
+    expect(myCars[0].deepData.sodeep).to.equal('yes');
+    expect(myCars[0].brand).to.equal('Renault');
+    counter++;
+  } while (counter < totalQueryCycles);
+});
+
+tap.test('expect to get instance of Car with deep match', async () => {
+  const totalQueryCycles = totalCars / 4;
+  let counter = 0;
+  do {
+    const timeStart = Date.now();
+    const myCars2 = await Car.getInstances({
+      deepData: {
+        sodeep: 'yes'
+      },
+    });
+    if (counter % 10 === 0) {
+      console.log(
+        `performed ${counter} of ${totalQueryCycles} total query cycles: took ${
+          Date.now() - timeStart
+        }ms to deep query a set of 2000 with memory footprint ${process.memoryUsage().rss / 1e6} MB`
+      );
+    }
+    expect(myCars2[0].deepData.sodeep).to.equal('yes');
+    expect(myCars2[0].brand).to.equal('Volvo');
+    counter++;
+  } while (counter < totalQueryCycles);
+});
+
+tap.test('expect to get instance of Car and update it', async () => {
+  const myCar = await Car.getInstance<Car>({
+    brand: 'Volvo',
+  });
+  expect(myCar.color).to.equal('red');
+  myCar.color = 'blue';
+  await myCar.save();
+});
+
+tap.test('should be able to delete an instance of car', async () => {
+  const myCars = await Car.getInstances({
+    brand: 'Volvo',
+    color: 'blue',
+  });
+  console.log(myCars);
+  expect(myCars[0].color).to.equal('blue');
+  for (const myCar of myCars) {
+    await myCar.delete();
+  }
+
+  const myCar2 = await Car.getInstance<Car>({
+    brand: 'Volvo',
+  });
+  expect(myCar2.color).to.equal('red');
+});
+
+// tslint:disable-next-line: max-classes-per-file
+@smartdata.Collection(() => {
+  return testDb;
 })
+class Truck extends smartdata.SmartDataDbDoc<Car, Car> {
+  @smartdata.unI()
+  public id: string = smartunique.shortId();
 
-describe('smartdata', function () {
-    it('should establish a connection to mongodb', function (done) {
-        testDb = new smartdata.Db('mongodb://localhost:27017/smartdata')
-        testDb.connect().then(() => { done() })
-    })
-    it('should create a collection', function () {
-        testDbCollection = new smartdata.DbCollection<ITestObject1>('something', testDb)
-    })
-    it('should insert a doc into the collection', function (done) {
-        testDbCollection.insertOne({ value1: 'test' }).then(() => { done() })
-    })
-    it('should find all docs of testDbCollection', function (done) {
-        testDbCollection.find({}).then((resultArray) => {
-            console.log(resultArray)
-            should(resultArray[0].value1).equal('test')
-            done()
-        })
-    })
-    it('should insert many docs into the collection', function (done) {
-        testDbCollection.insertMany([
-            { value1: 'test2' },
-            { value1: 'test', value2: 3, value3: 'hi' }
-        ]).then(() => { done() })
-    })
-    it('should find a specified doc', function (done) {
-        testDbCollection.find({ 'value3': { '$exists': true } }).then((resultArray) => {
-            console.log(resultArray)
-            should(resultArray[0].value3).equal('hi')
-            done()
-        }).catch(console.log)
-    })
-    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
-        })
+  @smartdata.svDb()
+  public color: string;
 
-        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 () {
+  @smartdata.svDb()
+  public brand: string;
 
-        })
-    })
-})
+  constructor(colorArg: string, brandArg: string) {
+    super();
+    this.color = colorArg;
+    this.brand = brandArg;
+  }
+}
 
-describe('mongodb', function () {
-    it('should kill mongodb', function (done) {
-        this.timeout(30000)
-        mongoChildProcess.stdout.on('data', function (data) {
-            if (/dbexit:  rc: 0/.test(data)) {
-                done()
-            }
-        })
-        shelljs.exec('mongod --dbpath=./test/data --shutdown')
-        mongoChildProcess.kill('SIGTERM')
-    })
-})
+tap.test('should store a new Truck', async () => {
+  const truck = new Truck('blue', 'MAN');
+  await truck.save();
+  const myTruck = await Truck.getInstance({ color: 'blue' });
+  myTruck.id = 'foo';
+  await myTruck.save();
+  const myTruck2 = await Truck.getInstance({ color: 'blue' });
+  console.log(myTruck2);
+});
 
-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)
-    })
+tap.test('should ', async () => {})
 
-    it('should insert a doc', function(done){
-        testCollection.insertOne({ value1: 'hi' }).then(() => {done()})
-    })
+// =======================================
+// close the database connection
+// =======================================
+tap.test('should close the database connection', async (tools) => {
+  await testDb.close();
+  try {
+    await mongod.stop();
+  } catch (e) {}
+});
 
-    it('should find the inserted document', function(done){
-        testCollection.find({ value1: 'hi' }).then(x => {
-            console.log(x)
-            done()
-        })
-    })
-})
+tap.start({ throwOnError: true });

ts/index.ts

@@ -1,5 +1,5 @@
-import * as plugins from './smartdata.plugins'
+export * from './smartdata.classes.db';
+export * from './smartdata.classes.collection';
+export * from './smartdata.classes.doc';
 
-export * from './smartdata.classes.db'
-export * from './smartdata.classes.dbcollection'
-export * from './smartdata.classes.dbdoc'
+export { IMongoDescriptor } from './interfaces';

ts/interfaces/index.ts

@@ -0,0 +1 @@
+export * from './mongodescriptor';

ts/interfaces/mongodescriptor.ts

@@ -0,0 +1,22 @@
+export interface IMongoDescriptor {
+  /**
+   * the URL to connect to
+   */
+  mongoDbUrl: string;
+
+  /**
+   * the db to use for the project
+   */
+  mongoDbName?: string;
+
+  /**
+   * a username to use to connect to the database
+   */
+
+  mongoDbUser?: string;
+
+  /**
+   * an optional password that will be replace <PASSWORD> in the connection string
+   */
+  mongoDbPass?: string;
+}

ts/smartdata.classes.collection.ts

@@ -0,0 +1,168 @@
+import * as plugins from './smartdata.plugins';
+import { SmartdataDb } from './smartdata.classes.db';
+import { SmartDataDbDoc } from './smartdata.classes.doc';
+import { CollectionFactory } from './smartdata.classes.collectionfactory';
+
+export interface IFindOptions {
+  limit?: number;
+}
+
+/**
+ *
+ */
+export interface IDocValidationFunc<T> {
+  (doc: T): boolean;
+}
+
+export type TDelayedDbCreation = () => SmartdataDb;
+
+const collectionFactory = new CollectionFactory();
+
+/**
+ * This is a decorator that will tell the decorated class what dbTable to use
+ * @param dbArg
+ */
+export function Collection(dbArg: SmartdataDb | TDelayedDbCreation) {
+  return function classDecorator<T extends { new (...args: any[]): {} }>(constructor: T) {
+    return class extends constructor {
+      public static get collection() {
+        return collectionFactory.getCollection(constructor.name, dbArg);
+      }
+      public get collection() {
+        return collectionFactory.getCollection(constructor.name, dbArg);
+      }
+    };
+  };
+}
+
+// tslint:disable-next-line: max-classes-per-file
+export class SmartdataCollection<T> {
+  /**
+   * the collection that is used
+   */
+  public mongoDbCollection: plugins.mongodb.Collection;
+  public objectValidation: IDocValidationFunc<T> = null;
+  public collectionName: string;
+  public smartdataDb: SmartdataDb;
+  public uniqueIndexes: string[] = [];
+
+  constructor(classNameArg: string, smartDataDbArg: SmartdataDb) {
+    // tell the collection where it belongs
+    this.collectionName = classNameArg;
+    this.smartdataDb = smartDataDbArg;
+
+    // tell the db class about it (important since Db uses different systems under the hood)
+    this.smartdataDb.addCollection(this);
+  }
+
+  /**
+   * makes sure a collection exists within MongoDb that maps to the SmartdataCollection
+   */
+  public async init() {
+    if (!this.mongoDbCollection) {
+      // connect this instance to a MongoDB collection
+      const availableMongoDbCollections = await this.smartdataDb.mongoDb.collections();
+      const wantedCollection = availableMongoDbCollections.find((collection) => {
+        return collection.collectionName === this.collectionName;
+      });
+      if (!wantedCollection) {
+        await this.smartdataDb.mongoDb.createCollection(this.collectionName);
+        console.log(`Successfully initiated Collection ${this.collectionName}`);
+      }
+      this.mongoDbCollection = this.smartdataDb.mongoDb.collection(this.collectionName);
+    }
+  }
+
+  /**
+   * mark unique index
+   */
+  public markUniqueIndexes(keyArrayArg: string[] = []) {
+    for (const key of keyArrayArg) {
+      if (!this.uniqueIndexes.includes(key)) {
+        this.mongoDbCollection.createIndex(key, {
+          unique: true,
+        });
+        // make sure we only call this once and not for every doc we create
+        this.uniqueIndexes.push(key);
+      }
+    }
+  }
+
+  /**
+   * adds a validation function that all newly inserted and updated objects have to pass
+   */
+  public addDocValidation(funcArg: IDocValidationFunc<T>) {
+    this.objectValidation = funcArg;
+  }
+
+  /**
+   * finds an object in the DbCollection
+   */
+  public async find(filterObject: any): Promise<any> {
+    await this.init();
+    const result = await this.mongoDbCollection.find(filterObject).toArray();
+    return result;
+  }
+
+  /**
+   * create an object in the database
+   */
+  public async insert(dbDocArg: T & SmartDataDbDoc<T, unknown>): Promise<any> {
+    await this.init();
+    await this.checkDoc(dbDocArg);
+    this.markUniqueIndexes(dbDocArg.uniqueIndexes);
+    const saveableObject = await dbDocArg.createSavableObject();
+    const result = await this.mongoDbCollection.insertOne(saveableObject);
+    return result;
+  }
+
+  /**
+   * inserts object into the DbCollection
+   */
+  public async update(dbDocArg: T & SmartDataDbDoc<T, unknown>): Promise<any> {
+    await this.init();
+    await this.checkDoc(dbDocArg);
+    const identifiableObject = await dbDocArg.createIdentifiableObject();
+    const saveableObject = await dbDocArg.createSavableObject();
+    const updateableObject: any = {};
+    for (const key of Object.keys(saveableObject)) {
+      if (identifiableObject[key]) {
+        continue;
+      }
+      updateableObject[key] = saveableObject[key];
+    }
+    const result = await this.mongoDbCollection.updateOne(
+      identifiableObject,
+      { $set: updateableObject },
+      { upsert: true }
+    );
+    return result;
+  }
+
+  public async delete(dbDocArg: T & SmartDataDbDoc<T, unknown>): Promise<any> {
+    await this.init();
+    await this.checkDoc(dbDocArg);
+    const identifiableObject = await dbDocArg.createIdentifiableObject();
+    await this.mongoDbCollection.deleteOne(identifiableObject, {
+      w: 1,
+    });
+  }
+
+  /**
+   * checks a Doc for constraints
+   * if this.objectValidation is not set it passes.
+   */
+  private checkDoc(docArg: T): Promise<void> {
+    const done = plugins.smartq.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.collectionfactory.ts

@@ -0,0 +1,25 @@
+import * as plugins from './smartdata.plugins';
+import { SmartdataCollection } from './smartdata.classes.collection';
+import { SmartdataDb } from './smartdata.classes.db';
+
+export class CollectionFactory {
+  public collections: { [key: string]: SmartdataCollection<any> } = {};
+
+  public getCollection = (
+    nameArg: string,
+    dbArg: SmartdataDb | (() => SmartdataDb)
+  ): SmartdataCollection<any> => {
+    if (!this.collections[nameArg]) {
+      this.collections[nameArg] = (() => {
+        if (dbArg instanceof SmartdataDb) {
+          // tslint:disable-next-line: no-string-literal
+          return new SmartdataCollection(nameArg, dbArg);
+        } else {
+          dbArg = dbArg();
+          return new SmartdataCollection(nameArg, dbArg);
+        }
+      })();
+    }
+    return this.collections[nameArg];
+  };
+}

ts/smartdata.classes.db.ts

@@ -1,82 +1,79 @@
-import * as plugins from './smartdata.plugins'
-import { Objectmap } from 'lik'
+import * as plugins from './smartdata.plugins';
+import { ObjectMap } from '@pushrocks/lik';
 
-import { DbCollection } from './smartdata.classes.dbcollection'
+import { SmartdataCollection } from './smartdata.classes.collection';
 
-/**
- * interface - indicates the database type
- */
-export type TDbType = 'mongodb' | 'nedb'
+import { logger } from './smartdata.logging';
+import { IMongoDescriptor } from './interfaces';
 
 /**
  * interface - indicates the connection status of the db
  */
-export type TConnectionStatus = 'disconnected' | 'connected' | 'failed'
+export type TConnectionStatus = 'initial' | 'disconnected' | 'connected' | 'failed';
 
-export class Db {
-    dbType: TDbType
-    dbUrl: string
-    db: plugins.mongodb.Db
-    status: TConnectionStatus
-    collections = new Objectmap<DbCollection<any>>()
+export class SmartdataDb {
+  smartdataOptions: IMongoDescriptor;
+  mongoDbClient: plugins.mongodb.MongoClient;
+  mongoDb: plugins.mongodb.Db;
+  status: TConnectionStatus;
+  smartdataCollectionMap = new ObjectMap<SmartdataCollection<any>>();
 
-    constructor(dbUrlArg: string, dbTypeArg: TDbType = 'mongodb') {
-        this.dbType = dbTypeArg
-        this.dbUrl = dbUrlArg
-    }
+  constructor(smartdataOptions: IMongoDescriptor) {
+    this.smartdataOptions = smartdataOptions;
+    this.status = 'initial';
+  }
 
-    // basic connection stuff ----------------------------------------------
+  // 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)
-                this.db = 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
-    }
+  /**
+   * connects to the database that was specified during instance creation
+   */
+  public async init(): Promise<any> {
+    const finalConnectionUrl = this.smartdataOptions.mongoDbUrl
+      .replace('<USERNAME>', this.smartdataOptions.mongoDbUser)
+      .replace('<username>', this.smartdataOptions.mongoDbUser)
+      .replace('<USER>', this.smartdataOptions.mongoDbUser)
+      .replace('<user>', this.smartdataOptions.mongoDbUser)
+      .replace('<PASSWORD>', this.smartdataOptions.mongoDbPass)
+      .replace('<password>', this.smartdataOptions.mongoDbPass)
+      .replace('<DBNAME>', this.smartdataOptions.mongoDbName)
+      .replace('<dbname>', this.smartdataOptions.mongoDbName);
 
-    /**
-     * 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
-    }
+    this.mongoDbClient = await plugins.mongodb.MongoClient.connect(finalConnectionUrl, {
+      useNewUrlParser: true,
+      useUnifiedTopology: true,
+      maxPoolSize: 100,
+      maxIdleTimeMS: 10,
+    });
+    this.mongoDb = this.mongoDbClient.db(this.smartdataOptions.mongoDbName);
+    this.status = 'connected';
+    console.log(`Connected to database ${this.smartdataOptions.mongoDbName}`);
+  }
 
-    // advanced communication with the database --------------------------------
+  /**
+   * closes the connection to the databse
+   */
+  public async close(): Promise<any> {
+    await this.mongoDbClient.close();
+    this.status = 'disconnected';
+    logger.log('info', `disconnected from database ${this.smartdataOptions.mongoDbName}`);
+  }
 
-    /**
-     * 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
-    };
+  // handle table to class distribution
 
-    addCollection(dbCollectionArg: DbCollection<any>) {
-        this.collections.add(dbCollectionArg)
-    }
-    
+  public addCollection(SmartdataCollectionArg: SmartdataCollection<any>) {
+    this.smartdataCollectionMap.add(SmartdataCollectionArg);
+  }
+
+  /**
+   * Gets a collection's name and returns a SmartdataCollection instance
+   * @param nameArg
+   * @returns DbTable
+   */
+  public async getSmartdataCollectionByName<T>(nameArg: string): Promise<SmartdataCollection<T>> {
+    const resultCollection = this.smartdataCollectionMap.find((dbTableArg) => {
+      return dbTableArg.collectionName === nameArg;
+    });
+    return resultCollection;
+  }
 }

ts/smartdata.classes.dbcollection.ts

@@ -1,144 +0,0 @@
-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
-     */
-    addDocValidation(funcArg: IDocValidation<T>) {
-        this.objectValidation = funcArg
-    }
-
-    /**
-     * finds an object in the DbCollection
-     */
-    find(docMatchArg: T | any, optionsArg?: IFindOptions): plugins.q.Promise<T[]> {
-        let done = plugins.q.defer<T[]>()
-        if (this.db.dbType === 'mongodb') {
-            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
-    }
-
-    /**
-     * inserts object into the DbCollection
-     */
-    insertOne(docArg: T): plugins.q.Promise<void> {
-        let done = plugins.q.defer<void>()
-        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
-    }
-
-    /**
-     * inserts many objects at once into the DbCollection
-     */
-    insertMany(docArrayArg: T[]): plugins.q.Promise<void> {
-        let done = plugins.q.defer<void>()
-        let checkDocPromiseArray: plugins.q.Promise<void>[] = []
-        for (let docArg of docArrayArg) {
-            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
-    }
-
-    /**
-     * 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

@@ -1,66 +0,0 @@
-import * as plugins from './smartdata.plugins'
-
-import { Db } from './smartdata.classes.db'
-import { DbCollection } from './smartdata.classes.dbcollection'
-
-export type TDocCreation = 'db' | 'new' | 'mixed'
-
-/**
- * saveable - 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]
-        }
-        switch (this.creationType) {
-            case 'db':
-                this.collection // TODO implement collection.update()
-                break
-            case 'new':
-                this.collection.insertOne(saveableObject)
-        }
-    }
-
-    /**
-     * also store any referenced objects to DB
-     * better for data consistency
-     */
-    saveDeep() {
-        this.save()
-    }
-}

ts/smartdata.classes.doc.ts

@@ -0,0 +1,197 @@
+import * as plugins from './smartdata.plugins';
+
+import { ObjectMap } from '@pushrocks/lik';
+
+import { SmartdataDb } from './smartdata.classes.db';
+import { SmartdataCollection } from './smartdata.classes.collection';
+
+export type TDocCreation = 'db' | 'new' | 'mixed';
+
+/**
+ * saveable - saveable decorator to be used on class properties
+ */
+export function svDb() {
+  return (target: SmartDataDbDoc<unknown, unknown>, key: string) => {
+    console.log(`called svDb() on >${target.constructor.name}.${key}<`);
+    if (!target.saveableProperties) {
+      target.saveableProperties = [];
+    }
+    target.saveableProperties.push(key);
+  };
+}
+
+/**
+ * unique index - decorator to mark a unique index
+ */
+export function unI() {
+  return (target: SmartDataDbDoc<unknown, unknown>, key: string) => {
+    console.log(`called unI on >>${target.constructor.name}.${key}<<`);
+
+    // mark the index as unique
+    if (!target.uniqueIndexes) {
+      target.uniqueIndexes = [];
+    }
+    target.uniqueIndexes.push(key);
+
+    // and also save it
+    if (!target.saveableProperties) {
+      target.saveableProperties = [];
+    }
+    target.saveableProperties.push(key);
+  };
+}
+
+export class SmartDataDbDoc<T extends TImplements, TImplements> {
+  /**
+   * the collection object an Doc belongs to
+   */
+  public static collection: SmartdataCollection<any>;
+  public collection: SmartdataCollection<any>;
+
+  /**
+   * how the Doc in memory was created, may prove useful later.
+   */
+  public creationStatus: TDocCreation = 'new';
+
+  /**
+   * unique indexes
+   */
+  public uniqueIndexes: string[];
+
+  /**
+   * an array of saveable properties of a doc
+   */
+  public saveableProperties: string[];
+
+  /**
+   * name
+   */
+  public name: string;
+
+  /**
+   * primary id in the database
+   */
+  public dbDocUniqueId: string;
+
+  /**
+   * class constructor
+   */
+  constructor() {}
+
+  public static async getInstances<T>(
+    this: plugins.tsclass.typeFest.Class<T>,
+    filterArg: plugins.tsclass.typeFest.PartialDeep<T>
+  ): Promise<T[]> {
+    const convertedFilter: any = {};
+    const convertFilterArgument = (keyPathArg: string, filterArg2: any) => {
+      if (typeof filterArg2 === 'object') {
+        for (const key of Object.keys(filterArg2)) {
+          if (key.startsWith('$')) {
+            convertedFilter[keyPathArg] = filterArg2;
+            return;
+          } else if (key.includes('.')) {
+            throw new Error('keys cannot contain dots');
+          }
+        }
+        for (const key of Object.keys(filterArg2)) {
+          convertFilterArgument(`${keyPathArg}.${key}`, filterArg2[key]);
+        } 
+      } else {
+        convertedFilter[keyPathArg] = filterArg2
+      }
+    }
+    for (const key of Object.keys(filterArg)) {
+      convertFilterArgument(key, filterArg[key]);
+    }
+    const foundDocs = await (this as any).collection.find(convertedFilter);
+    const returnArray = [];
+    for (const item of foundDocs) {
+      const newInstance = new this();
+      (newInstance as any).creationStatus = 'db';
+      for (const key of Object.keys(item)) {
+        newInstance[key] = item[key];
+      }
+      returnArray.push(newInstance);
+    }
+    return returnArray;
+  }
+
+  public static async getInstance<T>(
+    this: plugins.tsclass.typeFest.Class<T>,
+    filterArg: plugins.tsclass.typeFest.PartialDeep<T>
+  ): Promise<T> {
+    const result = await (this as any).getInstances(filterArg);
+    if (result && result.length > 0) {
+      return result[0];
+    }
+  }
+
+  /**
+   * saves this instance but not any connected items
+   * may lead to data inconsistencies, but is faster
+   */
+  public async save() {
+    // tslint:disable-next-line: no-this-assignment
+    const self: any = this;
+    let dbResult: any;
+    switch (this.creationStatus) {
+      case 'db':
+        dbResult = await this.collection.update(self);
+        break;
+      case 'new':
+        dbResult = await this.collection.insert(self);
+        this.creationStatus = 'db';
+        break;
+      default:
+        console.error('neither new nor in db?');
+    }
+    return dbResult;
+  }
+
+  /**
+   * deletes a document from the database
+   */
+  public async delete() {
+    await this.collection.delete(this);
+  }
+
+  /**
+   * also store any referenced objects to DB
+   * better for data consistency
+   */
+  public saveDeep(savedMapArg: ObjectMap<SmartDataDbDoc<any, any>> = null) {
+    if (!savedMapArg) {
+      savedMapArg = new ObjectMap<SmartDataDbDoc<any, any>>();
+    }
+    savedMapArg.add(this);
+    this.save();
+    for (const propertyKey of Object.keys(this)) {
+      const property: any = this[propertyKey];
+      if (property instanceof SmartDataDbDoc && !savedMapArg.checkForObject(property)) {
+        property.saveDeep(savedMapArg);
+      }
+    }
+  }
+
+  /**
+   * creates a saveable object so the instance can be persisted as json in the database
+   */
+  public async createSavableObject(): Promise<TImplements> {
+    const saveableObject: unknown = {}; // is not exposed to outside, so any is ok here
+    for (const propertyNameString of this.saveableProperties) {
+      saveableObject[propertyNameString] = this[propertyNameString];
+    }
+    return saveableObject as TImplements;
+  }
+
+  /**
+   * creates an identifiable object for operations that require filtering
+   */
+  public async createIdentifiableObject() {
+    const identifiableObject: any = {}; // is not exposed to outside, so any is ok here
+    for (const propertyNameString of this.uniqueIndexes) {
+      identifiableObject[propertyNameString] = this[propertyNameString];
+    }
+    return identifiableObject;
+  }
+}

ts/smartdata.logging.ts

@@ -0,0 +1,3 @@
+import * as plugins from './smartdata.plugins';
+
+export const logger = new plugins.smartlog.ConsoleLog();

ts/smartdata.plugins.ts

@@ -1,16 +1,14 @@
-import 'typings-global'
-import * as assert from 'assert'
-import * as beautylog from 'beautylog'
-import * as lodash from 'lodash'
-import * as mongodb from 'mongodb'
-import * as q from 'q'
-let nedb = require('nedb')
+// tsclass scope
+import * as tsclass from '@tsclass/tsclass';
 
-export {
-    assert,
-    beautylog,
-    lodash,
-    mongodb,
-    q,
-    nedb
-}
+export { tsclass };
+
+// @pushrocks scope
+import * as smartlog from '@pushrocks/smartlog';
+import * as lodash from 'lodash';
+import * as mongodb from 'mongodb';
+import * as smartq from '@pushrocks/smartpromise';
+import * as smartstring from '@pushrocks/smartstring';
+import * as smartunique from '@pushrocks/smartunique';
+
+export { smartlog, lodash, smartq, mongodb, smartstring, smartunique };

tsconfig.json

@@ -1,5 +1,7 @@
 {
-    "compilerOptions": {
-        "experimentalDecorators": true
-    }
+  "compilerOptions": {
+    "experimentalDecorators": true,
+    "target": "es2017",
+    "module": "commonjs"
+  }
 }

tslint.json

@@ -1,3 +1,17 @@
 {
-    "extends": "tslint-config-standard"
-}
+  "extends": ["tslint:latest", "tslint-config-prettier"],
+  "rules": {
+    "semicolon": [true, "always"],
+    "no-console": false,
+    "ordered-imports": false,
+    "object-literal-sort-keys": false,
+    "member-ordering": {
+      "options":{
+        "order": [
+          "static-method"
+        ]
+      }
+    }
+  },
+  "defaultSeverity": "warning"
+}