4.0.23

.gitignore

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

.gitlab-ci.yml

@@ -1,16 +1,20 @@
-# gitzone standard
+# gitzone ci_default
-image: hosttoday/ht-docker-node:npmci
+image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
 
 cache:
   paths:
-  - .npmci_cache/
+    - .npmci_cache/
-  key: "$CI_BUILD_STAGE"
+  key: '$CI_BUILD_STAGE'
 
 stages:
-- security
+  - security
-- test
+  - test
-- release
+  - release
-- metadata
+  - metadata
+
+before_script:
+  - apt-get update && apt-get install -y libcurl3 libssl-dev openssl libssl1.0.0 mongodb
+  - npm install -g @shipzone/npmci
 
 # ====================
 # security stage
@@ -18,108 +22,115 @@ stages:
 mirror:
   stage: security
   script:
-  - npmci git mirror
+    - npmci git mirror
+  only:
+    - tags
   tags:
-  - docker
+    - lossless
-  - notpriv
+    - docker
+    - notpriv
 
-snyk:
+auditProductionDependencies:
+  image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
   stage: security
   script:
-    - npmci command npm install -g snyk
+    - npmci npm prepare
-    - npmci command npm install --ignore-scripts
+    - npmci command npm install --production --ignore-scripts
-    - npmci command snyk test
+    - npmci command npm config set registry https://registry.npmjs.org
+    - npmci command npm audit --audit-level=high --only=prod --production
   tags:
-  - docker
+    - docker
-  - notpriv
+  allow_failure: true
+
+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
 
 # ====================
 # test stage
 # ====================
-testLEGACY:
-  stage: test
-  script:
-  - npmci node install legacy
-  - npmci npm install
-  - npmci npm test
-  coverage: /\d+.?\d+?\%\s*coverage/
-  tags:
-  - docker
-  - notpriv
-  allow_failure: true
 
-testLTS:
+testStable:
   stage: test
   script:
-  - npmci node install lts
+    - npmci npm prepare
-  - npmci npm install
+    - npmci node install stable
-  - npmci npm test
+    - npmci npm install
+    - npmci npm test
   coverage: /\d+.?\d+?\%\s*coverage/
   tags:
-  - docker
+    - docker
-  - notpriv
+
-    
+testBuild:
-testSTABLE:
   stage: test
   script:
-  - npmci node install stable
+    - npmci npm prepare
-  - npmci npm install
+    - npmci node install stable
-  - npmci npm test
+    - npmci npm install
+    - npmci command npm run build
   coverage: /\d+.?\d+?\%\s*coverage/
   tags:
-  - docker
+    - docker
-  - notpriv
 
 release:
   stage: release
   script:
-  - npmci node install stable
+    - npmci node install stable
-  - npmci npm publish
+    - npmci npm publish
   only:
-  - tags
+    - tags
   tags:
-  - docker
+    - lossless
-  - notpriv
+    - docker
+    - notpriv
 
 # ====================
 # metadata stage
 # ====================
 codequality:
   stage: metadata
-  image: docker:stable
   allow_failure: true
-  services:
+  only:
-    - docker:stable-dind
+    - tags
   script:
-    - export SP_VERSION=$(echo "$CI_SERVER_VERSION" | sed 's/^\([0-9]*\)\.\([0-9]*\).*/\1-\2-stable/')
+    - npmci command npm install -g tslint typescript
-    - docker run
+    - npmci npm prepare
-        --env SOURCE_CODE="$PWD"
+    - npmci npm install
-        --volume "$PWD":/code
+    - npmci command "tslint -c tslint.json ./ts/**/*.ts"
-        --volume /var/run/docker.sock:/var/run/docker.sock
-        "registry.gitlab.com/gitlab-org/security-products/codequality:$SP_VERSION" /code
-  artifacts:
-    paths: [codeclimate.json]
   tags:
-  - docker
+    - lossless
-  - priv
+    - docker
+    - priv
 
 trigger:
   stage: metadata
   script:
-  - npmci trigger
+    - npmci trigger
   only:
-  - tags
+    - tags
   tags:
-  - docker
+    - lossless
-  - notpriv
+    - docker
+    - notpriv
 
 pages:
-  image: hosttoday/ht-docker-node:npmci
   stage: metadata
   script:
-    - npmci command npm install -g npmpage
+    - npmci node install lts
-    - npmci command npmpage
+    - npmci command npm install -g @gitzone/tsdoc
+    - npmci npm prepare
+    - npmci npm install
+    - npmci command tsdoc
   tags:
+    - lossless
     - docker
     - notpriv
   only:
@@ -127,15 +138,5 @@ pages:
   artifacts:
     expire_in: 1 week
     paths:
-    - public
+      - public
-  allow_failure: true
-
-windowsCompatibility:
-  image: stefanscherer/node-windows:10-build-tools
-  stage: metadata
-  script:
-  - npm install & npm test
-  coverage: /\d+.?\d+?\%\s*coverage/
-  tags:
-  - windows
   allow_failure: true

.vscode/launch.json

@@ -0,0 +1,11 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "command": "npm test",
+      "name": "Run npm test",
+      "request": "launch",
+      "type": "node-terminal"
+    }
+  ]
+}

.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,129 +0,0 @@
-# @pushrocks/smartdata
-
-do more with data and RethinkDB
-
-## Availabililty
-
-[![npm](https://pushrocks.gitlab.io/assets/repo-button-npm.svg)](https://www.npmjs.com/package/smartdata)
-[![git](https://pushrocks.gitlab.io/assets/repo-button-git.svg)](https://GitLab.com/pushrocks/smartdata)
-[![git](https://pushrocks.gitlab.io/assets/repo-button-mirror.svg)](https://github.com/pushrocks/smartdata)
-[![docs](https://pushrocks.gitlab.io/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)
-[![npm downloads per month](https://img.shields.io/npm/dm/smartdata.svg)](https://www.npmjs.com/package/smartdata)
-[![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)
-[![Known Vulnerabilities](https://snyk.io/test/npm/smartdata/badge.svg)](https://snyk.io/test/npm/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/)
-
-## 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(optionsArg: { property1: string; property2: number }) {
-    super();
-  }
-}
-
-// start to instantiate instances of classes from scratch or database
-
-let 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.
-
-**sStore** instances of classes to Db:
-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
-
-**Get** a new class instance from a Doc in the DB:
-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. Yes, let that sink in a minute :)
-
-So you can just call `.getInstance({ /* filter props here */ })`.
-
-## 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.
-
-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.html)
-
-[![repo-footer](https://pushrocks.gitlab.io/assets/repo-footer.svg)](https://push.rocks)

docs/index.md

@@ -1,29 +0,0 @@
-# smartdata
-
-do more with data
-
-## Availabililty
-
-[![npm](https://pushrocks.gitlab.io/assets/repo-button-npm.svg)](https://www.npmjs.com/package/smartdata)
-[![git](https://pushrocks.gitlab.io/assets/repo-button-git.svg)](https://GitLab.com/pushrocks/smartdata)
-[![git](https://pushrocks.gitlab.io/assets/repo-button-mirror.svg)](https://github.com/pushrocks/smartdata)
-[![docs](https://pushrocks.gitlab.io/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)
-[![npm downloads per month](https://img.shields.io/npm/dm/smartdata.svg)](https://www.npmjs.com/package/smartdata)
-[![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/)
-
-For further information read the linked docs at the top of this README.
-
-> MIT licensed | **©** [Lossless GmbH](https://lossless.gmbh)
-> | By using this npm module you agree to our [privacy policy](https://lossless.gmbH/privacy.html)
-
-[![repo-footer](https://pushrocks.gitlab.io/assets/repo-footer.svg)](https://push.rocks)

npmextra.json

@@ -5,14 +5,19 @@
     "dockerSock": false
   },
   "npmci": {
-    "npmGlobalTools": [
+    "npmGlobalTools": [],
-      "@gitzone/npmts"
+    "npmAccessLevel": "public",
-    ],
+    "npmRegistryUrl": "registry.npmjs.org"
-    "npmAccessLevel": "public"
   },
-  "npmts": {
+  "gitzone": {
-    "testConfig": {
+    "projectType": "npm",
-      "parallel": false
+    "module": {
+      "githost": "gitlab.com",
+      "gitscope": "pushrocks",
+      "gitrepo": "smartdata",
+      "shortDescription": "do more with data",
+      "npmPackagename": "@pushrocks/smartdata",
+      "license": "MIT"
     }
   }
-}
+}

package.json

@@ -1,14 +1,14 @@
 {
   "name": "@pushrocks/smartdata",
-  "version": "3.1.2",
+  "version": "4.0.23",
   "private": false,
   "description": "do more with data",
-  "main": "dist/index.js",
+  "main": "dist_ts/index.js",
-  "typings": "dist/index.d.ts",
+  "typings": "dist_ts/index.d.ts",
   "scripts": {
-    "test": "tsrun test/test.ts",
+    "test": "(tstest test/)",
     "testLocal": "(npmdocker)",
-    "build": "(npmts)"
+    "build": "(tsbuild --web)"
   },
   "repository": {
     "type": "git",
@@ -21,23 +21,43 @@
   },
   "homepage": "https://gitlab.com/pushrocks/smartdata#README",
   "dependencies": {
-    "@pushrocks/smartlog": "^1.0.6",
+    "@pushrocks/lik": "^5.0.0",
-    "@pushrocks/smartpromise": "^2.0.5",
+    "@pushrocks/smartlog": "^2.0.44",
-    "@types/lodash": "^4.14.110",
+    "@pushrocks/smartpromise": "^3.1.5",
-    "@types/mongodb": "^3.1.1",
+    "@pushrocks/smartstring": "^3.0.24",
-    "lik": "^2.0.5",
+    "@pushrocks/smartunique": "^3.0.3",
-    "lodash": "^4.17.10",
+    "@tsclass/tsclass": "^3.0.36",
-    "mongodb": "^3.1.1",
+    "@types/lodash": "^4.14.176",
-    "runtime-type-checks": "0.0.4",
+    "@types/mongodb": "^4.0.7",
-    "smartstring": "^2.0.28"
+    "lodash": "^4.17.21",
+    "mongodb": "^4.1.4",
+    "runtime-type-checks": "0.0.4"
   },
   "devDependencies": {
-    "@gitzone/tsrun": "^1.1.2",
+    "@gitzone/tsbuild": "^2.1.28",
-    "@types/node": "^10.5.2",
+    "@gitzone/tstest": "^1.0.60",
+    "@pushrocks/qenv": "^4.0.10",
+    "@pushrocks/tapbundle": "^3.2.14",
+    "@types/mongodb-memory-server": "^2.3.0",
+    "@types/node": "^16.11.7",
     "@types/shortid": "0.0.29",
-    "mongodb-memory-server": "^1.9.0",
+    "mongodb-memory-server": "^8.0.2",
-    "qenv": "^1.1.7",
+    "tslint": "^6.1.3",
-    "shortid": "^2.2.11",
+    "tslint-config-prettier": "^1.18.0"
-    "tapbundle": "^2.0.2"
+  },
-  }
+  "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

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

readme.md

@@ -0,0 +1,156 @@
+# @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
+// Assuming toplevel await
+import * as smartdata from 'smartdata';
+
+const smartdataDb = new smartdata.SmartdataDb({
+  mongoDbUrl: '//someurl',
+  mongoDbName: 'myDatabase',
+  mongoDbPass: 'mypassword',
+});
+
+await 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
+// Assuming toplevel await
+// continues from the block before...
+
+@smartdata.Collection(smartdataDb)
+class MyObject extends smartdata.DbDoc<MyObject /* ,[an optional interface to implement] */> {
+  // 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: {
+    deep: 3,
+  },
+});
+await localObject.save(); // saves the object to the database
+
+// start retrieving instances
+
+// .getInstance is staticly inheritied, yet fully typed static function to get instances with fully typed filters
+const myInstance = await MyObject.getInstance({
+  property1: 'hi',
+  property2: {
+    deep: {
+      $gt: 2,
+    } as any,
+  },
+}); // 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.easystore.ts

@@ -0,0 +1,64 @@
+import { tap, expect } from '@pushrocks/tapbundle';
+import { Qenv } from '@pushrocks/qenv';
+
+const testQenv = new Qenv(process.cwd(), process.cwd() + '/.nogit/');
+
+console.log(process.memoryUsage());
+
+// the tested module
+import * as smartdata from '../ts/index';
+
+import * as mongoPlugin from 'mongodb-memory-server';
+import { smartunique } from '../ts/smartdata.plugins';
+
+// =======================================
+// Connecting to the database server
+// =======================================
+
+let testDb: smartdata.SmartdataDb;
+let smartdataOptions: smartdata.IMongoDescriptor;
+let mongod: mongoPlugin.MongoMemoryServer;
+
+tap.skip.test('should create a testinstance as database', async () => {
+  mongod = await mongoPlugin.MongoMemoryServer.create();
+  console.log('created mongod instance');
+  console.log('mongod started');
+  smartdataOptions = {
+    mongoDbUrl: mongod.getUri(),
+  };
+  console.log(smartdataOptions);
+  testDb = new smartdata.SmartdataDb(smartdataOptions);
+  await testDb.init();
+});
+
+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,
+  });
+  await testDb.init();
+});
+
+let easyStore: smartdata.EasyStore<{
+  key1: string;
+  key2: string;
+}>;
+
+tap.test('should create an easystore', async () => {
+  easyStore = await testDb.createEasyStore('hellothere');
+  await easyStore.writeKey('key1', 'hello');
+  const retrievedKey = await easyStore.readKey('key1');
+  expect(retrievedKey).to.equal('hello');
+});
+
+tap.test('close', async () => {
+  if (mongod) {
+    await mongod.stop();
+  } else {
+    await testDb.mongoDb.dropDatabase();
+  }
+  await testDb.close();
+});
+
+tap.start();

test/test.ts

@@ -1,26 +1,45 @@
-import { tap, expect } from 'tapbundle';
+import { tap, expect } from '@pushrocks/tapbundle';
-import * as smartpromise from '@pushrocks/smartpromise';
+import { Qenv } from '@pushrocks/qenv';
-import { Qenv } from 'qenv';
 
-let testQenv = new Qenv(process.cwd(), process.cwd() + '/.nogit/');
+const testQenv = new Qenv(process.cwd(), process.cwd() + '/.nogit/');
+
+console.log(process.memoryUsage());
 
 // the tested module
 import * as smartdata from '../ts/index';
-import { smartstring } from '../ts/smartdata.plugins';
+
-import * as shortid from 'shortid';
+import * as mongoPlugin from 'mongodb-memory-server';
+import { smartunique } from '../ts/smartdata.plugins';
 
 // =======================================
 // Connecting to the database server
 // =======================================
 
-let testDb = new smartdata.SmartdataDb({
+let testDb: smartdata.SmartdataDb;
-  mongoDbName: process.env.MONGO_DBNAME,
+let smartdataOptions: smartdata.IMongoDescriptor;
-  mongoDbUrl: process.env.MONGO_URL,
+let mongod: mongoPlugin.MongoMemoryServer;
-  mongoDbPass: process.env.MONGO_PASS
+
+const totalCars = 2000;
+
+tap.skip.test('should create a testinstance as database', async () => {
+  mongod = await mongoPlugin.MongoMemoryServer.create();
+  console.log('created mongod instance');
+  console.log('mongod started');
+  smartdataOptions = {
+    mongoDbUrl: mongod.getUri(),
+  };
+  console.log(smartdataOptions);
+  testDb = new smartdata.SmartdataDb(smartdataOptions);
+  await testDb.init();
 });
 
-tap.test('should establish a connection to the rethink Db cluster', async () => {
+tap.test('should connect to atlas', async (tools) => {
-  await testDb.connect();
+  const databaseName = `test-smartdata-${smartunique.shortId()}`;
+  testDb = new smartdata.SmartdataDb({
+    mongoDbUrl: testQenv.getEnvVarOnDemand('MONGO_URL'),
+    mongoDbName: databaseName,
+  });
+  await testDb.init();
 });
 
 // =======================================
@@ -31,11 +50,24 @@ tap.test('should establish a connection to the rethink Db cluster', async () =>
 // Collections
 // ------
 
-@smartdata.Collection(testDb)
+@smartdata.Collection(() => {
-class Car extends smartdata.SmartDataDbDoc<Car> {
+  return testDb;
-  @smartdata.unI() index: string = shortid();
+})
-  @smartdata.svDb() color: string;
+class Car extends smartdata.SmartDataDbDoc<Car, Car> {
-  @smartdata.svDb() brand: string;
+  @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;
@@ -46,20 +78,145 @@ class Car extends smartdata.SmartDataDbDoc<Car> {
 tap.test('should save the car to the db', async () => {
   const myCar = new Car('red', 'Volvo');
   await myCar.save();
+
+  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', async () => {
+tap.test('expect to get instance of Car with shallow match', async () => {
-  let myCars = await Car.getInstances<Car>({
+  const totalQueryCycles = totalCars / 4;
-    brand: 'Volvo'
+  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();
+
+  @smartdata.svDb()
+  public color: string;
+
+  @smartdata.svDb()
+  public brand: string;
+
+  constructor(colorArg: string, brandArg: string) {
+    super();
+    this.color = colorArg;
+    this.brand = brandArg;
+  }
+}
+
+tap.test('should store a new Truck', async () => {
+  const truck = new Truck('blue', 'MAN');
+  await truck.save();
+  const myTruck2 = await Truck.getInstance({ color: 'blue' });
+  myTruck2.color = 'red';
+  await myTruck2.save();
+  const myTruck3 = await Truck.getInstance({ color: 'blue' });
+  console.log(myTruck3);
+});
+
+tap.test('should use a cursor', async () => {
+  const cursor = await Truck.getCursor({});
+  cursor.forEach(async truckArg => {
+    console.log(truckArg.id);
   });
-  expect(myCars[0].color).to.equal('red');
 });
 
 // =======================================
 // close the database connection
 // =======================================
-tap.test('should close the database connection', async tools => {
+tap.test('close', async () => {
+  if (mongod) {
+    await mongod.stop();
+  } else {
+    await testDb.mongoDb.dropDatabase();
+  }
   await testDb.close();
 });
 
-tap.start({throwOnError: true});
+tap.start({ throwOnError: true });

test/test.typescript.ts

@@ -0,0 +1,104 @@
+import { tap, expect } from '@pushrocks/tapbundle';
+import { Qenv } from '@pushrocks/qenv';
+
+const testQenv = new Qenv(process.cwd(), process.cwd() + '/.nogit/');
+
+console.log(process.memoryUsage());
+
+// the tested module
+import * as smartdata from '../ts/index';
+
+import * as mongoPlugin from 'mongodb-memory-server';
+import { smartunique } from '../ts/smartdata.plugins';
+
+// =======================================
+// 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 = await mongoPlugin.MongoMemoryServer.create();
+  console.log('created mongod instance');
+  console.log('mongod started');
+  smartdataOptions = {
+    mongoDbUrl: mongod.getUri(),
+  };
+  console.log(smartdataOptions);
+  testDb = new smartdata.SmartdataDb(smartdataOptions);
+  await testDb.init();
+});
+
+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,
+  });
+  await testDb.init();
+});
+
+// =======================================
+// The actual tests
+// =======================================
+
+// ------
+// Collections
+// ------
+@smartdata.Manager()
+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;
+  }
+}
+
+const createCarClass = (dbArg: smartdata.SmartdataDb) => {
+  smartdata.setDefaultManagerForDoc({ db: dbArg }, Car);
+  return Car;
+};
+
+tap.test('should produce a car', async () => {
+  const CarClass = createCarClass(testDb);
+  const carInstance = new CarClass('red', 'Mercedes');
+  await carInstance.save();
+});
+
+tap.test('should get a car', async () => {
+  const car = Car.getInstance({
+    color: 'red',
+  });
+});
+
+// =======================================
+// close the database connection
+// =======================================
+tap.test('close', async () => {
+  if (mongod) {
+    await mongod.stop();
+  } else {
+    await testDb.mongoDb.dropDatabase();
+  }
+  await testDb.close();
+});
+
+tap.start({ throwOnError: true });

ts/index.ts

@@ -1,3 +1,6 @@
 export * from './smartdata.classes.db';
 export * from './smartdata.classes.collection';
 export * from './smartdata.classes.doc';
+export * from './smartdata.classes.easystore';
+
+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

@@ -1,6 +1,8 @@
 import * as plugins from './smartdata.plugins';
 import { SmartdataDb } from './smartdata.classes.db';
+import { SmartdataDbCursor } from './smartdata.classes.cursor';
 import { SmartDataDbDoc } from './smartdata.classes.doc';
+import { CollectionFactory } from './smartdata.classes.collectionfactory';
 
 export interface IFindOptions {
   limit?: number;
@@ -13,61 +15,145 @@ export interface IDocValidationFunc<T> {
   (doc: T): boolean;
 }
 
+export type TDelayed<TDelayedArg> = () => TDelayedArg;
+
+const collectionFactory = new CollectionFactory();
+
 /**
  * This is a decorator that will tell the decorated class what dbTable to use
- * @param db
+ * @param dbArg
  */
-export function Collection(db: SmartdataDb) {
+export function Collection(dbArg: SmartdataDb | TDelayed<SmartdataDb>) {
-  return function(constructor) {
+  return function classDecorator<T extends { new (...args: any[]): {} }>(constructor: T) {
-    constructor['smartdataCollection'] = new SmartdataCollection(constructor, db);
+    return class extends constructor {
+      public static get collection() {
+        if (!(dbArg instanceof SmartdataDb)) {
+          dbArg = dbArg();
+        }
+        return collectionFactory.getCollection(constructor.name, dbArg);
+      }
+      public get collection() {
+        if (!(dbArg instanceof SmartdataDb)) {
+          dbArg = dbArg();
+        }
+        return collectionFactory.getCollection(constructor.name, dbArg);
+      }
+    };
   };
 }
 
+export interface IManager {
+  db: SmartdataDb;
+}
+
+export const setDefaultManagerForDoc = <T>(managerArg: IManager, dbDocArg: T): T => {
+  (dbDocArg as any).prototype.defaultManager = managerArg;
+  return dbDocArg;
+};
+
+/**
+ * This is a decorator that will tell the decorated class what dbTable to use
+ * @param dbArg
+ */
+export function Manager<TManager extends IManager>(managerArg?: TManager | TDelayed<TManager>) {
+  return function classDecorator<T extends { new (...args: any[]): any }>(constructor: T) {
+    return class extends constructor {
+      public static get collection() {
+        let dbArg: SmartdataDb;
+        if (!managerArg) {
+          dbArg = this.prototype.defaultManager.db;
+        } else if (managerArg['db']) {
+          dbArg = (managerArg as TManager).db;
+        } else {
+          dbArg = (managerArg as TDelayed<TManager>)().db;
+        }
+        return collectionFactory.getCollection(constructor.name, dbArg);
+      }
+      public get collection() {
+        let dbArg: SmartdataDb;
+        if (!managerArg) {
+          //console.log(this.defaultManager.db);
+          //process.exit(0)
+          dbArg = this.defaultManager.db;
+        } else if (managerArg['db']) {
+          dbArg = (managerArg as TManager).db;
+        } else {
+          dbArg = (managerArg as TDelayed<TManager>)().db;
+        }
+        return collectionFactory.getCollection(constructor.name, dbArg);
+      }
+      public static get manager() {
+        let manager: TManager;
+        if (!managerArg) {
+          manager = this.prototype.defaultManager
+        } else if (managerArg['db']) {
+          manager = managerArg as TManager;
+        } else {
+          manager = (managerArg as TDelayed<TManager>)();
+        }
+        return manager;
+      }
+      public get manager() {
+        let manager: TManager;
+        if (!managerArg) {
+          manager = this.defaultManager
+        } else if (managerArg['db']) {
+          manager = managerArg as TManager;
+        } else {
+          manager = (managerArg as TDelayed<TManager>)();
+        }
+        return manager;
+      }
+    };
+  };
+}
+
+// tslint:disable-next-line: max-classes-per-file
 export class SmartdataCollection<T> {
   /**
    * the collection that is used
    */
-  mongoDbCollection: plugins.mongodb.Collection;
+  public mongoDbCollection: plugins.mongodb.Collection;
-  objectValidation: IDocValidationFunc<T> = null;
+  public objectValidation: IDocValidationFunc<T> = null;
-  collectionName: string;
+  public collectionName: string;
-  smartdataDb: SmartdataDb;
+  public smartdataDb: SmartdataDb;
-  uniqueIndexes: string[] = [];
+  public uniqueIndexes: string[] = [];
 
-  constructor(collectedClassArg: T & SmartDataDbDoc<T>, smartDataDbArg: SmartdataDb) {
+  constructor(classNameArg: string, smartDataDbArg: SmartdataDb) {
     // tell the collection where it belongs
-    this.collectionName = collectedClassArg.name;
+    this.collectionName = classNameArg;
     this.smartdataDb = smartDataDbArg;
 
     // tell the db class about it (important since Db uses different systems under the hood)
-    this.smartdataDb.addTable(this);
+    this.smartdataDb.addCollection(this);
   }
 
   /**
    * makes sure a collection exists within MongoDb that maps to the SmartdataCollection
    */
-  async init() {
+  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 => {
+      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 = await this.smartdataDb.mongoDb.collection(this.collectionName);
+      this.mongoDbCollection = this.smartdataDb.mongoDb.collection(this.collectionName);
-      console.log(`Successfully initiated Collection ${this.collectionName}`)
     }
   }
 
   /**
    * mark unique index
    */
-  markUniqueIndexes(keyArrayArg: string[] = []) {
+  public markUniqueIndexes(keyArrayArg: string[] = []) {
-    for(let key of keyArrayArg) {
+    for (const key of keyArrayArg) {
-      if(!this.uniqueIndexes.includes(key)) {
+      if (!this.uniqueIndexes.includes(key)) {
         this.mongoDbCollection.createIndex(key, {
-          unique: true
+          unique: true,
         });
         // make sure we only call this once and not for every doc we create
         this.uniqueIndexes.push(key);
@@ -78,28 +164,46 @@ export class SmartdataCollection<T> {
   /**
    * adds a validation function that all newly inserted and updated objects have to pass
    */
-  addDocValidation(funcArg: IDocValidationFunc<T>) {
+  public addDocValidation(funcArg: IDocValidationFunc<T>) {
     this.objectValidation = funcArg;
   }
 
   /**
    * finds an object in the DbCollection
    */
-  async find(filterObject: any): Promise<any> {
+   public async findOne(filterObject: any): Promise<any> {
     await this.init();
-    const result = await this.mongoDbCollection.find(filterObject).toArray();
+    const cursor = this.mongoDbCollection.find(filterObject);
+    const result = await cursor.next();
+    cursor.close();
+    return result;
+  }
+
+  public async getCursor(filterObject: any): Promise<SmartdataDbCursor<any>> {
+    await this.init();
+    const cursor = this.mongoDbCollection.find(filterObject);
+    return new SmartdataDbCursor(cursor);
+  }
+
+  /**
+   * finds an object in the DbCollection
+   */
+  public async findAll(filterObject: any): Promise<any[]> {
+    await this.init();
+    const cursor = this.mongoDbCollection.find(filterObject);
+    const result = await cursor.toArray();
+    cursor.close();
     return result;
   }
 
   /**
    * create an object in the database
    */
-  async insert(dbDocArg: T & SmartDataDbDoc<T>): Promise<any> {
+  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();
-    console.log(saveableObject);
     const result = await this.mongoDbCollection.insertOne(saveableObject);
     return result;
   }
@@ -107,11 +211,31 @@ export class SmartdataCollection<T> {
   /**
    * inserts object into the DbCollection
    */
-  async update(dbDocArg: T & SmartDataDbDoc<T>): Promise<any> {
+  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();
-    this.mongoDbCollection.updateOne(saveableObject.dbDocUniqueId, saveableObject);
+    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);
   }
 
   /**
@@ -119,7 +243,7 @@ export class SmartdataCollection<T> {
    * if this.objectValidation is not set it passes.
    */
   private checkDoc(docArg: T): Promise<void> {
-    let done = plugins.smartq.defer<void>();
+    const done = plugins.smartq.defer<void>();
     let validationResult = true;
     if (this.objectValidation) {
       validationResult = this.objectValidation(docArg);

ts/smartdata.classes.collectionfactory.ts

@@ -0,0 +1,19 @@
+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): 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);
+        }
+      })();
+    }
+    return this.collections[nameArg];
+  };
+}

ts/smartdata.classes.cursor.ts

@@ -0,0 +1,39 @@
+import * as plugins from './smartdata.plugins';
+
+/**
+ * a wrapper for the native mongodb cursor. Exposes better 
+ */
+export class SmartdataDbCursor<T = any> {
+  // STATIC
+
+  // INSTANCE
+  public mongodbCursor: plugins.mongodb.FindCursor<T>;
+  constructor(cursorArg: plugins.mongodb.FindCursor<T>) {
+    this.mongodbCursor = cursorArg
+  };
+
+  public async next(closeAtEnd = true) {
+    const result = await this.mongodbCursor.next();
+    if (!result && closeAtEnd) {
+      await this.close();
+    };
+    return result;
+  };
+
+  public async forEach(forEachFuncArg: (itemArg: T) => Promise<any>, closeCursorAtEnd = true) {
+    let currentValue: T;
+    do {
+      currentValue = await this.mongodbCursor.next();
+      if (currentValue) {
+        await forEachFuncArg(currentValue);
+      }
+    } while (currentValue);
+    if (closeCursorAtEnd) {
+      await this.close();
+    }
+  }
+
+  public async close() {
+    await this.mongodbCursor.close();
+  }
+}

ts/smartdata.classes.db.ts

@@ -1,64 +1,55 @@
 import * as plugins from './smartdata.plugins';
-import { Objectmap } from 'lik';
+import { ObjectMap } from '@pushrocks/lik';
 
 import { SmartdataCollection } from './smartdata.classes.collection';
+import { EasyStore } from './smartdata.classes.easystore';
 
-import * as mongoHelpers from './smartdata.mongohelpers';
+import { logger } from './smartdata.logging';
+import { IMongoDescriptor } from './interfaces';
 
 /**
  * interface - indicates the connection status of the db
  */
 export type TConnectionStatus = 'initial' | 'disconnected' | 'connected' | 'failed';
 
-export interface ISmartdataOptions {
-  /**
-   * the URL to connect to
-   */
-  mongoDbUrl: string;
-
-  /**
-   * the db to use for the project
-   */
-  mongoDbName: string;
-
-  /**
-   * an optional password that will be replace <PASSWORD> in the connection string
-   */
-  mongoDbPass?: string;
-}
-
 export class SmartdataDb {
-  smartdataOptions: ISmartdataOptions;
+  smartdataOptions: IMongoDescriptor;
   mongoDbClient: plugins.mongodb.MongoClient;
   mongoDb: plugins.mongodb.Db;
   status: TConnectionStatus;
-  smartdataCollectionMap = new Objectmap<SmartdataCollection<any>>();
+  smartdataCollectionMap = new ObjectMap<SmartdataCollection<any>>();
 
-  constructor(smartdataOptions: ISmartdataOptions) {
+  constructor(smartdataOptions: IMongoDescriptor) {
     this.smartdataOptions = smartdataOptions;
     this.status = 'initial';
   }
 
+  // easystore
+  public async createEasyStore(nameIdArg: string) {
+    const easyStore = new EasyStore(nameIdArg, this);
+    return easyStore;
+  }
+
   // basic connection stuff ----------------------------------------------
 
   /**
    * connects to the database that was specified during instance creation
    */
-  async connect(): Promise<any> {
+  public async init(): Promise<any> {
-    let finalConnectionUrl = this.smartdataOptions.mongoDbUrl;
+    const finalConnectionUrl = this.smartdataOptions.mongoDbUrl
-    if (this.smartdataOptions.mongoDbPass) {
+      .replace('<USERNAME>', this.smartdataOptions.mongoDbUser)
-      finalConnectionUrl = mongoHelpers.addPassword(
+      .replace('<username>', this.smartdataOptions.mongoDbUser)
-        this.smartdataOptions.mongoDbUrl,
+      .replace('<USER>', this.smartdataOptions.mongoDbUser)
-        this.smartdataOptions.mongoDbPass
+      .replace('<user>', this.smartdataOptions.mongoDbUser)
-      );
+      .replace('<PASSWORD>', this.smartdataOptions.mongoDbPass)
-    }
+      .replace('<password>', this.smartdataOptions.mongoDbPass)
-    console.log(finalConnectionUrl);
+      .replace('<DBNAME>', this.smartdataOptions.mongoDbName)
-    this.mongoDbClient = await plugins.mongodb.MongoClient.connect(
+      .replace('<dbname>', this.smartdataOptions.mongoDbName);
-      finalConnectionUrl,
+
-      {
+    this.mongoDbClient = await plugins.mongodb.MongoClient.connect(finalConnectionUrl, {
-        useNewUrlParser: true
+      maxPoolSize: 100,
-      }
+      maxIdleTimeMS: 10,
-    );
+    });
     this.mongoDb = this.mongoDbClient.db(this.smartdataOptions.mongoDbName);
     this.status = 'connected';
     console.log(`Connected to database ${this.smartdataOptions.mongoDbName}`);
@@ -67,17 +58,15 @@ export class SmartdataDb {
   /**
    * closes the connection to the databse
    */
-  async close(): Promise<any> {
+  public async close(): Promise<any> {
     await this.mongoDbClient.close();
     this.status = 'disconnected';
-    plugins.smartlog
+    logger.log('info', `disconnected from database ${this.smartdataOptions.mongoDbName}`);
-      .getDefaultLogger()
-      .info(`disconnected from database ${this.smartdataOptions.mongoDbName}`);
   }
 
   // handle table to class distribution
 
-  addTable(SmartdataCollectionArg: SmartdataCollection<any>) {
+  public addCollection(SmartdataCollectionArg: SmartdataCollection<any>) {
     this.smartdataCollectionMap.add(SmartdataCollectionArg);
   }
 
@@ -86,8 +75,8 @@ export class SmartdataDb {
    * @param nameArg
    * @returns DbTable
    */
-  async getSmartdataCollectionByName<T>(nameArg: string): Promise<SmartdataCollection<T>> {
+  public async getSmartdataCollectionByName<T>(nameArg: string): Promise<SmartdataCollection<T>> {
-    let resultCollection = this.smartdataCollectionMap.find(dbTableArg => {
+    const resultCollection = await this.smartdataCollectionMap.find(async (dbTableArg) => {
       return dbTableArg.collectionName === nameArg;
     });
     return resultCollection;

ts/smartdata.classes.doc.ts

@@ -1,9 +1,10 @@
 import * as plugins from './smartdata.plugins';
 
-import { Objectmap } from 'lik';
+import { ObjectMap } from '@pushrocks/lik';
 
 import { SmartdataDb } from './smartdata.classes.db';
-import { SmartdataCollection } from './smartdata.classes.collection';
+import { SmartdataDbCursor } from './smartdata.classes.cursor';
+import { IManager, SmartdataCollection } from './smartdata.classes.collection';
 
 export type TDocCreation = 'db' | 'new' | 'mixed';
 
@@ -11,8 +12,8 @@ export type TDocCreation = 'db' | 'new' | 'mixed';
  * saveable - saveable decorator to be used on class properties
  */
 export function svDb() {
-  return (target: SmartDataDbDoc<any>, key: string) => {
+  return (target: SmartDataDbDoc<unknown, unknown>, key: string) => {
-    console.log(`called svDb() on ${key}`);
+    console.log(`called svDb() on >${target.constructor.name}.${key}<`);
     if (!target.saveableProperties) {
       target.saveableProperties = [];
     }
@@ -24,8 +25,8 @@ export function svDb() {
  * unique index - decorator to mark a unique index
  */
 export function unI() {
-  return (target: SmartDataDbDoc<any>, key: string) => {
+  return (target: SmartDataDbDoc<unknown, unknown>, key: string) => {
-    console.log('called unI');
+    console.log(`called unI on >>${target.constructor.name}.${key}<<`);
 
     // mark the index as unique
     if (!target.uniqueIndexes) {
@@ -39,113 +40,214 @@ export function unI() {
     }
     target.saveableProperties.push(key);
   };
-} 
+}
 
-export class SmartDataDbDoc<T> {
+export const convertFilterForMongoDb = (filterArg: { [key: string]: any }) => {
+  const convertedFilter: { [key: string]: any } = {};
+  const convertFilterArgument = (keyPathArg2: string, filterArg2: any) => {
+    if (typeof filterArg2 === 'object') {
+      for (const key of Object.keys(filterArg2)) {
+        if (key.startsWith('$')) {
+          convertedFilter[keyPathArg2] = filterArg2;
+          return;
+        } else if (key.includes('.')) {
+          throw new Error('keys cannot contain dots');
+        }
+      }
+      for (const key of Object.keys(filterArg2)) {
+        convertFilterArgument(`${keyPathArg2}.${key}`, filterArg2[key]);
+      }
+    } else {
+      convertedFilter[keyPathArg2] = filterArg2;
+    }
+  };
+  for (const key of Object.keys(filterArg)) {
+    convertFilterArgument(key, filterArg[key]);
+  }
+  return convertedFilter;
+};
+
+export class SmartDataDbDoc<T extends TImplements, TImplements, TManager extends IManager = any> {
   /**
    * the collection object an Doc belongs to
    */
-  collection: SmartdataCollection<T>;
+  public static collection: SmartdataCollection<any>;
+  public collection: SmartdataCollection<any>;
+  public static defaultManager;
+  public static manager;
+  public manager: TManager;
 
   /**
    * how the Doc in memory was created, may prove useful later.
    */
-  creationStatus: TDocCreation = 'new';
+  public creationStatus: TDocCreation = 'new';
 
   /**
    * unique indexes
    */
-  uniqueIndexes: string[];
+  public uniqueIndexes: string[];
 
   /**
    * an array of saveable properties of a doc
    */
-  saveableProperties: string[];
+  public saveableProperties: string[];
 
   /**
    * name
    */
-  name: string;
+  public name: string;
 
   /**
    * primary id in the database
    */
-  dbDocUniqueId: string;
+  public dbDocUniqueId: string;
 
   /**
    * class constructor
    */
-  constructor() {
+  constructor() {}
-    this.name = this.constructor['name'];
+
-    this.collection = this.constructor['smartdataCollection'];
+  public static createInstanceFromMongoDbNativeDoc<T>(
+    this: plugins.tsclass.typeFest.Class<T>,
+    mongoDbNativeDocArg: any
+  ): T {
+    const newInstance = new this();
+    (newInstance as any).creationStatus = 'db';
+    for (const key of Object.keys(mongoDbNativeDocArg)) {
+      newInstance[key] = mongoDbNativeDocArg[key];
+    }
+    return newInstance;
   }
 
-  static async getInstances<T>(filterArg): Promise<T[]> {
+  /**
-    let self: any = this; // fool typesystem
+   * gets all instances as array
-    let referenceMongoDBCollection: SmartdataCollection<T> = self.smartdataCollection;
+   * @param this
-    const foundDocs = await referenceMongoDBCollection.find(filterArg);
+   * @param filterArg
+   * @returns
+   */
+  public static async getInstances<T>(
+    this: plugins.tsclass.typeFest.Class<T>,
+    filterArg: plugins.tsclass.typeFest.PartialDeep<T>
+  ): Promise<T[]> {
+    const foundDocs = await (this as any).collection.findAll(convertFilterForMongoDb(filterArg));
     const returnArray = [];
-    for (let item of foundDocs) {
+    for (const foundDoc of foundDocs) {
-      let newInstance = new this();
+      const newInstance: T = (this as any).createInstanceFromMongoDbNativeDoc(foundDoc);
-      for (let key in item) {
-        if (key !== 'id') {
-          newInstance[key] = item[key];
-        }
-      }
       returnArray.push(newInstance);
     }
     return returnArray;
   }
 
-  static async getInstance<T>(filterArg): Promise<T> {
+  /**
-    let result = await this.getInstances<T>(filterArg);
+   * gets the first matching instance
-    if (result && result.length > 0) {
+   * @param this
-      return result[0];
+   * @param filterArg
+   * @returns
+   */
+  public static async getInstance<T>(
+    this: plugins.tsclass.typeFest.Class<T>,
+    filterArg: plugins.tsclass.typeFest.PartialDeep<T>
+  ): Promise<T> {
+    const foundDoc = await (this as any).collection.findOne(convertFilterForMongoDb(filterArg));
+    if (foundDoc) {
+      const newInstance: T = (this as any).createInstanceFromMongoDbNativeDoc(foundDoc);
+      return newInstance;
+    } else {
+      return null;
     }
   }
 
+  /**
+   * get cursor
+   * @returns
+   */
+  public static async getCursor<T>(
+    this: plugins.tsclass.typeFest.Class<T>,
+    filterArg: plugins.tsclass.typeFest.PartialDeep<T>
+  ) {
+    const cursor: SmartdataDbCursor<T> = await (this as any).collection.getCursor(convertFilterForMongoDb(filterArg));
+    return cursor;
+  }
+
+  /**
+   * run a function for all instances
+   * @returns
+   */
+  public static async forEach<T>(
+    this: plugins.tsclass.typeFest.Class<T>,
+    filterArg: plugins.tsclass.typeFest.PartialDeep<T>,
+    forEachFunction: (itemArg: T) => Promise<any>
+  ) {
+    const cursor: SmartdataDbCursor<T> = await (this as any).getCursor(filterArg);
+    await cursor.forEach(forEachFunction)
+  }
+
   /**
    * saves this instance but not any connected items
    * may lead to data inconsistencies, but is faster
    */
-  async save() {
+  public async save() {
-    let self: any = this;
+    // tslint:disable-next-line: no-this-assignment
+    const self: any = this;
+    let dbResult: any;
     switch (this.creationStatus) {
       case 'db':
-        await this.collection.update(self);
+        dbResult = await this.collection.update(self);
         break;
       case 'new':
-        let writeResult = await this.collection.insert(self);
+        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
    */
-  saveDeep(savedMapArg: Objectmap<SmartDataDbDoc<any>> = null) {
+  public saveDeep(savedMapArg: ObjectMap<SmartDataDbDoc<any, any>> = null) {
     if (!savedMapArg) {
-      savedMapArg = new Objectmap<SmartDataDbDoc<any>>();
+      savedMapArg = new ObjectMap<SmartDataDbDoc<any, any>>();
     }
     savedMapArg.add(this);
     this.save();
-    for (let propertyKey in this) {
+    for (const propertyKey of Object.keys(this)) {
-      let property: any = this[propertyKey];
+      const property: any = this[propertyKey];
       if (property instanceof SmartDataDbDoc && !savedMapArg.checkForObject(property)) {
         property.saveDeep(savedMapArg);
       }
     }
   }
 
-  async createSavableObject() {
+  /**
-    let saveableObject: any = {}; // is not exposed to outside, so any is ok here
+   * creates a saveable object so the instance can be persisted as json in the database
-    for (let propertyNameString of this.saveableProperties) {
+   */
+  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;
+    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.classes.easystore.ts

@@ -0,0 +1,93 @@
+import * as plugins from './smartdata.plugins';
+import { Collection } from './smartdata.classes.collection';
+import { SmartdataDb } from './smartdata.classes.db';
+import { SmartDataDbDoc, svDb, unI } from './smartdata.classes.doc';
+
+/**
+ * EasyStore allows the storage of easy objects. It also allows easy sharing of the object between different instances
+ */
+export class EasyStore<T> {
+  // instance
+  public smartdataDbRef: SmartdataDb;
+  public nameId: string;
+
+  private easyStoreClass = (() => {
+    @Collection(() => this.smartdataDbRef)
+    class SmartdataEasyStore extends SmartDataDbDoc<SmartdataEasyStore, SmartdataEasyStore> {
+      @unI()
+      public nameId: string;
+
+      @svDb()
+      public data: Partial<T>;
+    }
+    return SmartdataEasyStore;
+  })();
+
+  constructor(nameIdArg: string, smnartdataDbRefArg: SmartdataDb) {
+    this.smartdataDbRef = smnartdataDbRefArg;
+    this.nameId = nameIdArg;
+  }
+
+  private async getEasyStore() {
+    let easyStore = await this.easyStoreClass.getInstance({
+      nameId: this.nameId,
+    });
+
+    if (!easyStore) {
+      easyStore = new this.easyStoreClass();
+      easyStore.nameId = this.nameId;
+      easyStore.data = {};
+      await easyStore.save();
+    }
+    return easyStore;
+  }
+
+  /**
+   * reads all keyValue pairs at once and returns them
+   */
+  public async readAll() {
+    const easyStore = await this.getEasyStore();
+    return easyStore.data;
+  }
+
+  /**
+   * reads a keyValueFile from disk
+   */
+  public async readKey(keyArg: keyof T) {
+    const easyStore = await this.getEasyStore();
+    return easyStore.data[keyArg];
+  }
+
+  /**
+   * writes a specific key to the keyValueStore
+   */
+  public async writeKey(keyArg: keyof T, valueArg: any) {
+    const easyStore = await this.getEasyStore();
+    easyStore.data[keyArg] = valueArg;
+    await easyStore.save();
+  }
+
+  public async deleteKey(keyArg: keyof T) {
+    const easyStore = await this.getEasyStore();
+    delete easyStore.data[keyArg];
+    await easyStore.save();
+  }
+
+  /**
+   * writes all keyValue pairs in the object argument
+   */
+  public async writeAll(keyValueObject: Partial<T>) {
+    const easyStore = await this.getEasyStore();
+    easyStore.data = { ...easyStore.data, ...keyValueObject };
+    await easyStore.save();
+  }
+
+  /**
+   * wipes a key value store from disk
+   */
+  public async wipe() {
+    const easyStore = await this.getEasyStore();
+    easyStore.data = {};
+    await easyStore.save();
+  }
+}

ts/smartdata.logging.ts

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

ts/smartdata.mongohelpers.ts

@@ -1,3 +0,0 @@
-export const addPassword = (mongoUrlArg: string, passwordArg: string): string => {
-  return mongoUrlArg.replace('<PASSWORD>', passwordArg);
-};

ts/smartdata.plugins.ts

@@ -1,8 +1,14 @@
-import * as assert from 'assert';
+// tsclass scope
+import * as tsclass from '@tsclass/tsclass';
+
+export { tsclass };
+
+// @pushrocks scope
 import * as smartlog from '@pushrocks/smartlog';
 import * as lodash from 'lodash';
 import * as mongodb from 'mongodb';
-import * as smartq from 'smartq';
+import * as smartq from '@pushrocks/smartpromise';
-import * as smartstring from 'smartstring';
+import * as smartstring from '@pushrocks/smartstring';
+import * as smartunique from '@pushrocks/smartunique';
 
-export { assert, smartlog, lodash, smartq, mongodb, smartstring };
+export { smartlog, lodash, smartq, mongodb, smartstring, smartunique };

tslint.json

@@ -0,0 +1,17 @@
+{
+  "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"
+}