5.0.13

fix(core): update
5.0.12
2023-06-24 23:57:35 +02:00 · 2023-06-24 23:57:34 +02:00 · 2023-03-21 20:16:08 +01:00 · 2023-03-21 20:16:07 +01:00 · 2023-02-06 11:43:11 +01:00 · 2023-02-06 11:43:11 +01:00
31 changed files with 7492 additions and 2016 deletions
--- a/.gitignore
+++ b/.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
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@ -1,125 +1,122 @@
-# gitzone standard
-image: hosttoday/ht-docker-node:npmci
+# gitzone ci_default
+image: registry.gitlab.com/hosttoday/ht-docker-node:npmci

 cache:
  paths:
-  - .npmci_cache/
-  key: "$CI_BUILD_STAGE"
+    - .npmci_cache/
+  key: '$CI_BUILD_STAGE'

 stages:
- security
- test
- release
- metadata
+  - security
+  - test
+  - release
+  - metadata
+
+before_script:
+  - pnpm install -g pnpm
+  - pnpm install -g @shipzone/npmci
+  - npmci npm prepare

 # ====================
 # security stage
 # ====================
-mirror:
+# ====================
+# security stage
+# ====================
+auditProductionDependencies:
+  image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
  stage: security
  script:
-  - npmci git mirror
+     - npmci command npm config set registry https://registry.npmjs.org
+     - npmci command pnpm audit --audit-level=high --prod
  tags:
-  - docker
-  - notpriv
+    - lossless
+    - docker
+  allow_failure: true

-snyk:
+auditDevDependencies:
+  image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
  stage: security
  script:
-    - npmci command npm install -g snyk
-    - npmci command npm install --ignore-scripts
-    - npmci command snyk test
+    - npmci command npm config set registry https://registry.npmjs.org
+    - npmci command pnpm audit --audit-level=high --dev
  tags:
-  - docker
-  - notpriv
+    - lossless
+    - 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 install
-  - npmci npm test
+    - npmci node install stable
+    - npmci npm install
+    - npmci npm test
  coverage: /\d+.?\d+?\%\s*coverage/
  tags:
-  - docker
-  - notpriv
-    
-testSTABLE:
+    - docker
+
+testBuild:
  stage: test
  script:
-  - npmci node install stable
-  - npmci npm install
-  - npmci npm test
+    - npmci node install stable
+    - npmci npm install
+    - npmci command npm run build
  coverage: /\d+.?\d+?\%\s*coverage/
  tags:
-  - docker
-  - notpriv
+    - docker

 release:
  stage: release
  script:
-  - npmci node install stable
-  - npmci npm publish
+    - npmci node install stable
+    - npmci npm publish
  only:
-  - tags
+    - tags
  tags:
-  - docker
-  - notpriv
+    - lossless
+    - docker
+    - notpriv

 # ====================
 # metadata stage
 # ====================
 codequality:
  stage: metadata
-  image: docker:stable
  allow_failure: true
-  services:
-    - docker:stable-dind
+  only:
+    - tags
  script:
-    - export SP_VERSION=$(echo "$CI_SERVER_VERSION" | sed 's/^\([0-9]*\)\.\([0-9]*\).*/\1-\2-stable/')
-    - docker run
-        --env SOURCE_CODE="$PWD"
-        --volume "$PWD":/code
-        --volume /var/run/docker.sock:/var/run/docker.sock
-        "registry.gitlab.com/gitlab-org/security-products/codequality:$SP_VERSION" /code
-  artifacts:
-    paths: [codeclimate.json]
+    - npmci command npm install -g typescript
+    - npmci npm prepare
+    - npmci npm install
  tags:
-  - docker
-  - priv
+    - lossless
+    - docker
+    - priv

 trigger:
  stage: metadata
  script:
-  - npmci trigger
+    - npmci trigger
  only:
-  - tags
+    - tags
  tags:
-  - docker
-  - notpriv
+    - lossless
+    - docker
+    - notpriv

 pages:
-  image: hosttoday/ht-docker-node:npmci
  stage: metadata
  script:
-    - npmci command npm install -g npmpage
-    - npmci command npmpage
+    - npmci node install stable
+    - npmci npm install
+    - npmci command npm run buildDocs
  tags:
+    - lossless
    - docker
    - notpriv
  only:
@ -127,15 +124,5 @@ pages:
  artifacts:
    expire_in: 1 week
    paths:
-    - 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
+      - public
  allow_failure: true
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@ -0,0 +1,11 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "command": "npm test",
+      "name": "Run npm test",
+      "request": "launch",
+      "type": "node-terminal"
+    }
+  ]
+}
--- a/.vscode/settings.json
+++ b/.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"]
+              }
+            }
+          }
+        }
+      }
+    }
+  ]
+}
--- a/README.md
+++ b/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)
--- a/docs/index.md
+++ b/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 | **&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)
--- a/npmextra.json
+++ b/npmextra.json
@ -5,14 +5,19 @@
    "dockerSock": false
  },
  "npmci": {
-    "npmGlobalTools": [
-      "@gitzone/npmts"
-    ],
-    "npmAccessLevel": "public"
+    "npmGlobalTools": [],
+    "npmAccessLevel": "public",
+    "npmRegistryUrl": "registry.npmjs.org"
  },
-  "npmts": {
-    "testConfig": {
-      "parallel": false
+  "gitzone": {
+    "projectType": "npm",
+    "module": {
+      "githost": "gitlab.com",
+      "gitscope": "pushrocks",
+      "gitrepo": "smartdata",
+      "description": "do more with data",
+      "npmPackagename": "@pushrocks/smartdata",
+      "license": "MIT"
    }
  }
-}
+}
--- a/package-lock.json
+++ b/package-lock.json
--- a/package.json
+++ b/package.json
@ -1,14 +1,15 @@
 {
  "name": "@pushrocks/smartdata",
-  "version": "3.1.1",
+  "version": "5.0.13",
  "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",
+  "type": "module",
  "scripts": {
-    "test": "tsrun test/test.ts",
-    "testLocal": "(npmdocker)",
-    "build": "(npmts)"
+    "test": "tstest test/",
+    "build": "tsbuild --web --allowimplicitany",
+    "buildDocs": "tsdoc"
  },
  "repository": {
    "type": "git",
@ -21,23 +22,41 @@
  },
  "homepage": "https://gitlab.com/pushrocks/smartdata#README",
  "dependencies": {
-    "@pushrocks/smartlog": "^1.0.6",
-    "@pushrocks/smartpromise": "^2.0.5",
-    "@types/lodash": "^4.14.110",
-    "@types/mongodb": "^3.1.1",
-    "lik": "^2.0.5",
-    "lodash": "^4.17.10",
-    "mongodb": "^3.1.1",
-    "runtime-type-checks": "0.0.4",
-    "smartstring": "^2.0.28"
+    "@pushrocks/lik": "^6.0.2",
+    "@pushrocks/smartdelay": "^3.0.1",
+    "@pushrocks/smartlog": "^3.0.1",
+    "@pushrocks/smartmongo": "^2.0.7",
+    "@pushrocks/smartpromise": "^4.0.2",
+    "@pushrocks/smartrx": "^3.0.2",
+    "@pushrocks/smartstring": "^4.0.2",
+    "@pushrocks/smarttime": "^4.0.1",
+    "@pushrocks/smartunique": "^3.0.3",
+    "@pushrocks/taskbuffer": "^3.0.10",
+    "@tsclass/tsclass": "^4.0.42",
+    "mongodb": "^5.6.0"
  },
  "devDependencies": {
-    "@gitzone/tsrun": "^1.1.2",
-    "@types/node": "^10.5.2",
-    "@types/shortid": "0.0.29",
-    "mongodb-memory-server": "^1.9.0",
-    "qenv": "^1.1.7",
-    "shortid": "^2.2.11",
-    "tapbundle": "^2.0.2"
-  }
+    "@gitzone/tsbuild": "^2.1.66",
+    "@gitzone/tsrun": "^1.2.42",
+    "@gitzone/tstest": "^1.0.74",
+    "@pushrocks/qenv": "^5.0.2",
+    "@pushrocks/tapbundle": "^5.0.8",
+    "@types/node": "^20.3.1",
+    "@types/shortid": "0.0.29"
+  },
+  "files": [
+    "ts/**/*",
+    "ts_web/**/*",
+    "dist/**/*",
+    "dist_*/**/*",
+    "dist_ts/**/*",
+    "dist_ts_web/**/*",
+    "assets/**/*",
+    "cli.js",
+    "npmextra.json",
+    "readme.md"
+  ],
+  "browserslist": [
+    "last 1 chrome versions"
+  ]
 }
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
--- a/qenv.yml
+++ b/qenv.yml
@ -1,4 +1,4 @@
-vars:
+required:
  - MONGO_URL
  - MONGO_DBNAME
  - MONGO_PASS
--- a/readme.md
+++ b/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)
--- a/test/test.easystore.ts
+++ b/test/test.easystore.ts
@ -0,0 +1,55 @@
+import { tap, expect } from '@pushrocks/tapbundle';
+import { Qenv } from '@pushrocks/qenv';
+import * as smartmongo from '@pushrocks/smartmongo';
+import { smartunique } from '../ts/smartdata.plugins.js';
+
+const testQenv = new Qenv(process.cwd(), process.cwd() + '/.nogit/');
+
+console.log(process.memoryUsage());
+
+// the tested module
+import * as smartdata from '../ts/index.js';
+
+// =======================================
+// Connecting to the database server
+// =======================================
+
+let smartmongoInstance: smartmongo.SmartMongo;
+let testDb: smartdata.SmartdataDb;
+
+tap.test('should create a testinstance as database', async () => {
+  smartmongoInstance = await smartmongo.SmartMongo.createAndStart();
+  testDb = new smartdata.SmartdataDb(await smartmongoInstance.getMongoDescriptor());
+  await testDb.init();
+});
+
+tap.skip.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).toEqual('hello');
+});
+
+tap.test('close', async () => {
+  await testDb.mongoDb.dropDatabase();
+  await testDb.close();
+  if (smartmongoInstance) {
+    await smartmongoInstance.stop();
+  }
+});
+
+tap.start();
--- a/test/test.ts
+++ b/test/test.ts
@ -1,26 +1,39 @@
-import { tap, expect } from 'tapbundle';
-import * as smartpromise from '@pushrocks/smartpromise';
-import { Qenv } from 'qenv';
+import { tap, expect } from '@pushrocks/tapbundle';
+import { Qenv } from '@pushrocks/qenv';
+import * as smartmongo from '@pushrocks/smartmongo';
+import { smartunique } from '../ts/smartdata.plugins.js';

-let testQenv = new Qenv(process.cwd(), process.cwd() + '/.nogit/');
+import * as mongodb from 'mongodb';
+
+const testQenv = new Qenv(process.cwd(), process.cwd() + '/.nogit/');
+
+console.log(process.memoryUsage());

 // the tested module
-import * as smartdata from '../ts';
-import { smartstring } from '../ts/smartdata.plugins';
-import * as shortid from 'shortid';
+import * as smartdata from '../ts/index.js';

 // =======================================
 // Connecting to the database server
 // =======================================

-let testDb = new smartdata.SmartdataDb({
-  mongoDbName: process.env.MONGO_DBNAME,
-  mongoDbUrl: process.env.MONGO_URL,
-  mongoDbPass: process.env.MONGO_PASS
+let smartmongoInstance: smartmongo.SmartMongo;
+let testDb: smartdata.SmartdataDb;
+
+const totalCars = 2000;
+
+tap.test('should create a testinstance as database', async () => {
+  smartmongoInstance = await smartmongo.SmartMongo.createAndStart();
+  testDb = new smartdata.SmartdataDb(await smartmongoInstance.getMongoDescriptor());
+  await testDb.init();
 });

-tap.test('should establish a connection to the rethink Db cluster', async () => {
-  await testDb.connect();
+tap.skip.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();
 });

 // =======================================
@ -31,11 +44,27 @@ tap.test('should establish a connection to the rethink Db cluster', async () =>
 // Collections
 // ------

-@smartdata.Collection(testDb)
-class Car extends smartdata.SmartDataDbDoc<Car> {
-  @smartdata.unI() index: string = shortid();
-  @smartdata.svDb() color: string;
-  @smartdata.svDb() brand: string;
+@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()
+  public testBuffer = Buffer.from('hello');
+
+  @smartdata.svDb()
+  deepData = {
+    sodeep: 'yes',
+  };
+
  constructor(colorArg: string, brandArg: string) {
    super();
    this.color = colorArg;
@ -43,23 +72,152 @@ class Car extends smartdata.SmartDataDbDoc<Car> {
  }
 }

-tap.test('should save the car to the db', async () => {
+tap.test('should save the car to the db', async (toolsArg) => {
  const myCar = new Car('red', 'Volvo');
  await myCar.save();
+
+  const myCar2 = new Car('red', 'Volvo');
+  await myCar2.save();
+
+  let counter = 0;
+
+  const gottenCarInstance = await Car.getInstance({});
+  console.log(gottenCarInstance.testBuffer instanceof mongodb.Binary);
+  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 / 2;
+  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).toEqual('yes');
+    expect(myCars[0].brand).toEqual('Renault');
+    counter++;
+  } while (counter < totalQueryCycles);
+});
+
+tap.test('expect to get instance of Car with deep match', async () => {
+  const totalQueryCycles = totalCars / 6;
+  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).toEqual('yes');
+    expect(myCars2[0].brand).toEqual('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).toEqual('red');
+  myCar.color = 'blue';
+  await myCar.save();
 });

-tap.test('expect to get instance of Car', async () => {
-  let myCars = await Car.getInstances<Car>({
-    brand: 'Volvo'
+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).toEqual('blue');
+  for (const myCar of myCars) {
+    await myCar.delete();
+  }
+
+  const myCar2 = await Car.getInstance<Car>({
+    brand: 'Volvo',
+  });
+  expect(myCar2.color).toEqual('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 Car.getCursor({});
+  let counter = 0;
+  await cursor.forEach(async (carArg) => {
+    counter++;
+    counter % 50 === 0 ? console.log(`50 more of ${carArg.color}`) : null;
  });
-  expect(myCars[0].color).to.equal('red');
 });

 // =======================================
 // close the database connection
 // =======================================
-tap.test('should close the database connection', async tools => {
+tap.test('close', async () => {
+  await testDb.mongoDb.dropDatabase();
  await testDb.close();
+  if (smartmongoInstance) {
+    await smartmongoInstance.stop();
+  }
 });

-tap.start({throwOnError: true});
+tap.start({ throwOnError: true });
--- a/test/test.typescript.ts
+++ b/test/test.typescript.ts
@ -0,0 +1,95 @@
+import { tap, expect } from '@pushrocks/tapbundle';
+import { Qenv } from '@pushrocks/qenv';
+import * as smartmongo from '@pushrocks/smartmongo';
+import { smartunique } from '../ts/smartdata.plugins.js';
+
+const testQenv = new Qenv(process.cwd(), process.cwd() + '/.nogit/');
+
+console.log(process.memoryUsage());
+
+// the tested module
+import * as smartdata from '../ts/index.js';
+
+// =======================================
+// Connecting to the database server
+// =======================================
+
+let smartmongoInstance: smartmongo.SmartMongo;
+let testDb: smartdata.SmartdataDb;
+
+const totalCars = 2000;
+
+tap.test('should create a testinstance as database', async () => {
+  smartmongoInstance = await smartmongo.SmartMongo.createAndStart();
+  testDb = new smartdata.SmartdataDb(await smartmongoInstance.getMongoDescriptor());
+  await testDb.init();
+});
+
+tap.skip.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 () => {
+  await testDb.mongoDb.dropDatabase();
+  await testDb.close();
+  if (smartmongoInstance) {
+    await smartmongoInstance.stop();
+  }
+});
+
+tap.start({ throwOnError: true });
--- a/test/test.watch.ts
+++ b/test/test.watch.ts
@ -0,0 +1,74 @@
+import { tap, expect } from '@pushrocks/tapbundle';
+import { Qenv } from '@pushrocks/qenv';
+import * as smartmongo from '@pushrocks/smartmongo';
+import { smartunique } from '../ts/smartdata.plugins.js';
+
+const testQenv = new Qenv(process.cwd(), process.cwd() + '/.nogit/');
+
+console.log(process.memoryUsage());
+
+// the tested module
+import * as smartdata from '../ts/index.js';
+
+// =======================================
+// Connecting to the database server
+// =======================================
+
+let smartmongoInstance: smartmongo.SmartMongo;
+let testDb: smartdata.SmartdataDb;
+
+const totalCars = 2000;
+
+tap.test('should create a testinstance as database', async () => {
+  smartmongoInstance = await smartmongo.SmartMongo.createAndStart();
+  testDb = new smartdata.SmartdataDb(await smartmongoInstance.getMongoDescriptor());
+  await testDb.init();
+});
+
+tap.skip.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();
+});
+
+@smartdata.Collection(() => testDb)
+class House extends smartdata.SmartDataDbDoc<House, House> {
+  @smartdata.unI()
+  public id: string = smartunique.shortId();
+
+  @smartdata.svDb()
+  public data = {
+    id: smartunique.shortId(),
+    hello: 'hello',
+  };
+}
+
+tap.test('should watch a collection', async (toolsArg) => {
+  const done = toolsArg.defer();
+  const watcher = await House.watch({});
+  watcher.changeSubject.subscribe(async (houseArg) => {
+    console.log('hey there, we observed a house');
+    await watcher.close();
+    done.resolve();
+  });
+  const newHouse = new House();
+  await newHouse.save();
+  console.log('saved a house');
+  await done.promise;
+});
+
+// =======================================
+// close the database connection
+// =======================================
+tap.test('close', async () => {
+  await testDb.mongoDb.dropDatabase();
+  await testDb.close();
+  if (smartmongoInstance) {
+    await smartmongoInstance.stop();
+  }
+});
+
+tap.start({ throwOnError: true });
--- a/ts/00_commitinfo_data.ts
+++ b/ts/00_commitinfo_data.ts
@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @pushrocks/commitinfo
+ */
+export const commitinfo = {
+  name: '@pushrocks/smartdata',
+  version: '5.0.13',
+  description: 'do more with data'
+}
--- a/ts/index.ts
+++ b/ts/index.ts
@ -1,3 +1,16 @@
-export * from './smartdata.classes.db';
-export * from './smartdata.classes.collection';
-export * from './smartdata.classes.doc';
+export * from './smartdata.classes.db.js';
+export * from './smartdata.classes.collection.js';
+export * from './smartdata.classes.doc.js';
+export * from './smartdata.classes.easystore.js';
+export * from './smartdata.classes.cursor.js';
+
+import * as convenience from './smartadata.convenience.js';
+
+export {
+  convenience
+}
+
+// to be removed with the next breaking update
+import type * as plugins from './smartdata.plugins.js';
+type IMongoDescriptor = plugins.tsclass.database.IMongoDescriptor;
+export type { IMongoDescriptor };
--- a/ts/smartadata.convenience.ts
+++ b/ts/smartadata.convenience.ts
@ -0,0 +1,5 @@
+import * as plugins from './smartdata.plugins.js';
+
+export const getNewUniqueId = async (prefixArg?: string) => {
+  return plugins.smartunique.uni(prefixArg);
+}
--- a/ts/smartdata.classes.collection.ts
+++ b/ts/smartdata.classes.collection.ts
@ -1,6 +1,9 @@
-import * as plugins from './smartdata.plugins';
-import { SmartdataDb } from './smartdata.classes.db';
-import { SmartDataDbDoc } from './smartdata.classes.doc';
+import * as plugins from './smartdata.plugins.js';
+import { SmartdataDb } from './smartdata.classes.db.js';
+import { SmartdataDbCursor } from './smartdata.classes.cursor.js';
+import { SmartDataDbDoc } from './smartdata.classes.doc.js';
+import { SmartdataDbWatcher } from './smartdata.classes.watcher.js';
+import { CollectionFactory } from './smartdata.classes.collectionfactory.js';

 export interface IFindOptions {
  limit?: number;
@ -13,13 +16,96 @@ 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) {
-  return function(constructor) {
-    constructor['smartdataCollection'] = new SmartdataCollection(constructor, db);
+export function Collection(dbArg: SmartdataDb | TDelayed<SmartdataDb>) {
+  return function classDecorator<T extends { new (...args: any[]): {} }>(constructor: T) {
+    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;
+      }
+    };
  };
 }

@ -27,47 +113,47 @@ export class SmartdataCollection<T> {
  /**
   * the collection that is used
   */
-  mongoDbCollection: plugins.mongodb.Collection;
-  objectValidation: IDocValidationFunc<T> = null;
-  collectionName: string;
-  smartdataDb: SmartdataDb;
-  uniqueIndexes: string[] = [];
+  public mongoDbCollection: plugins.mongodb.Collection;
+  public objectValidation: IDocValidationFunc<T> = null;
+  public collectionName: string;
+  public smartdataDb: SmartdataDb;
+  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);
-      console.log(`Successfully initiated Collection ${this.collectionName}`)
+      this.mongoDbCollection = this.smartdataDb.mongoDb.collection(this.collectionName);
    }
  }

  /**
   * mark unique index
   */
-  markUniqueIndexes(keyArrayArg: string[] = []) {
-    for(let key of keyArrayArg) {
-      if(!this.uniqueIndexes.includes(key)) {
+  public markUniqueIndexes(keyArrayArg: string[] = []) {
+    for (const key of keyArrayArg) {
+      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,72 @@ 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(
+    filterObjectArg: any,
+    dbDocArg: typeof SmartDataDbDoc
+  ): Promise<SmartdataDbCursor<any>> {
+    await this.init();
+    const cursor = this.mongoDbCollection.find(filterObjectArg);
+    return new SmartdataDbCursor(cursor, dbDocArg);
+  }
+
+  /**
+   * 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;
+  }
+
+  /**
+   * watches the collection while applying a filter
+   */
+  public async watch(
+    filterObject: any,
+    smartdataDbDocArg: typeof SmartDataDbDoc
+  ): Promise<SmartdataDbWatcher> {
+    await this.init();
+    const changeStream = this.mongoDbCollection.watch(
+      [
+        {
+          $match: filterObject,
+        },
+      ],
+      {
+        fullDocument: 'updateLookup',
+      }
+    );
+    const smartdataWatcher = new SmartdataDbWatcher(changeStream, smartdataDbDocArg);
+    await smartdataWatcher.readyDeferred.promise;
+    return smartdataWatcher;
+  }
+
  /**
   * 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 +237,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 +269,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);
--- a/ts/smartdata.classes.collectionfactory.ts
+++ b/ts/smartdata.classes.collectionfactory.ts
@ -0,0 +1,19 @@
+import * as plugins from './smartdata.plugins.js';
+import { SmartdataCollection } from './smartdata.classes.collection.js';
+import { SmartdataDb } from './smartdata.classes.db.js';
+
+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];
+  };
+}
--- a/ts/smartdata.classes.cursor.ts
+++ b/ts/smartdata.classes.cursor.ts
@ -0,0 +1,46 @@
+import { SmartDataDbDoc } from './smartdata.classes.doc.js';
+import * as plugins from './smartdata.plugins.js';
+
+/**
+ * a wrapper for the native mongodb cursor. Exposes better
+ */
+export class SmartdataDbCursor<T = any> {
+  // STATIC
+
+  // INSTANCE
+  public mongodbCursor: plugins.mongodb.FindCursor<T>;
+  private smartdataDbDoc: typeof SmartDataDbDoc;
+  constructor(cursorArg: plugins.mongodb.FindCursor<T>, dbDocArg: typeof SmartDataDbDoc) {
+    this.mongodbCursor = cursorArg;
+    this.smartdataDbDoc = dbDocArg;
+  }
+
+  public async next(closeAtEnd = true) {
+    const result = this.smartdataDbDoc.createInstanceFromMongoDbNativeDoc(
+      await this.mongodbCursor.next()
+    );
+    if (!result && closeAtEnd) {
+      await this.close();
+    }
+    return result;
+  }
+
+  public async forEach(forEachFuncArg: (itemArg: T) => Promise<any>, closeCursorAtEnd = true) {
+    let nextDocument: any;
+    do {
+      nextDocument = await this.mongodbCursor.next();
+      if (nextDocument) {
+        const nextClassInstance =
+          this.smartdataDbDoc.createInstanceFromMongoDbNativeDoc(nextDocument);
+        await forEachFuncArg(nextClassInstance as any);
+      }
+    } while (nextDocument);
+    if (closeCursorAtEnd) {
+      await this.close();
+    }
+  }
+
+  public async close() {
+    await this.mongodbCursor.close();
+  }
+}
--- a/ts/smartdata.classes.db.ts
+++ b/ts/smartdata.classes.db.ts
@ -1,83 +1,73 @@
-import * as plugins from './smartdata.plugins';
-import { Objectmap } from 'lik';
+import * as plugins from './smartdata.plugins.js';
+import { ObjectMap } from '@pushrocks/lik';

-import { SmartdataCollection } from './smartdata.classes.collection';
+import { SmartdataCollection } from './smartdata.classes.collection.js';
+import { EasyStore } from './smartdata.classes.easystore.js';

-import * as mongoHelpers from './smartdata.mongohelpers';
+import { logger } from './smartdata.logging.js';

 /**
 * 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: plugins.tsclass.database.IMongoDescriptor;
  mongoDbClient: plugins.mongodb.MongoClient;
  mongoDb: plugins.mongodb.Db;
  status: TConnectionStatus;
-  smartdataCollectionMap = new Objectmap<SmartdataCollection<any>>();
+  statusConnectedDeferred = plugins.smartpromise.defer();
+  smartdataCollectionMap = new ObjectMap<SmartdataCollection<any>>();

-  constructor(smartdataOptions: ISmartdataOptions) {
+  constructor(smartdataOptions: plugins.tsclass.database.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> {
-    let finalConnectionUrl = this.smartdataOptions.mongoDbUrl;
-    if (this.smartdataOptions.mongoDbPass) {
-      finalConnectionUrl = mongoHelpers.addPassword(
-        this.smartdataOptions.mongoDbUrl,
-        this.smartdataOptions.mongoDbPass
-      );
-    }
-    console.log(finalConnectionUrl);
-    this.mongoDbClient = await plugins.mongodb.MongoClient.connect(
-      finalConnectionUrl,
-      {
-        useNewUrlParser: true
-      }
-    );
+  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);
+
+    this.mongoDbClient = await plugins.mongodb.MongoClient.connect(finalConnectionUrl, {
+      maxPoolSize: 100,
+      maxIdleTimeMS: 10,
+    });
    this.mongoDb = this.mongoDbClient.db(this.smartdataOptions.mongoDbName);
    this.status = 'connected';
+    this.statusConnectedDeferred.resolve();
    console.log(`Connected to database ${this.smartdataOptions.mongoDbName}`);
  }

  /**
   * closes the connection to the databse
   */
-  async close(): Promise<any> {
+  public async close(): Promise<any> {
    await this.mongoDbClient.close();
    this.status = 'disconnected';
-    plugins.smartlog
-      .getDefaultLogger()
-      .info(`disconnected from database ${this.smartdataOptions.mongoDbName}`);
+    logger.log('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 +76,8 @@ export class SmartdataDb {
   * @param nameArg
   * @returns DbTable
   */
-  async getSmartdataCollectionByName<T>(nameArg: string): Promise<SmartdataCollection<T>> {
-    let resultCollection = this.smartdataCollectionMap.find(dbTableArg => {
+  public async getSmartdataCollectionByName<T>(nameArg: string): Promise<SmartdataCollection<T>> {
+    const resultCollection = await this.smartdataCollectionMap.find(async (dbTableArg) => {
      return dbTableArg.collectionName === nameArg;
    });
    return resultCollection;
--- a/ts/smartdata.classes.distributedcoordinator.ts
+++ b/ts/smartdata.classes.distributedcoordinator.ts
@ -0,0 +1,201 @@
+import * as plugins from './smartdata.plugins.js';
+import { SmartdataDb } from './smartdata.classes.db.js';
+import { Manager, setDefaultManagerForDoc } from './smartdata.classes.collection.js';
+import { SmartDataDbDoc, svDb, unI } from './smartdata.classes.doc.js';
+
+@Manager()
+class DistributedClass extends SmartDataDbDoc<DistributedClass, DistributedClass> {
+  // INSTANCE
+  @unI()
+  public id: string;
+
+  @svDb()
+  public data: {
+    status: 'bidding' | 'settled' | 'initializing' | 'stopped';
+    biddingShortcode?: string;
+    lastUpdated: number;
+    elected: boolean;
+    /**
+     * used to store request
+     */
+    taskRequests: plugins.taskbuffer.distributedCoordination.IDistributedTaskRequest[],
+  
+    /**
+     * only used by the leader to convey consultation results
+     */
+    taskRequestResults: plugins.taskbuffer.distributedCoordination.IDistributedTaskRequestResult[];
+  }
+}
+
+/**
+ * This file implements a distributed coordinator according to the @pushrocks/taskbuffer standard.
+ * you should not set up this yourself. Instead, there is a factory on the SmartdataDb class
+ * that will take care of setting this up.
+ */
+export class SmartdataDistributedCoordinator extends plugins.taskbuffer.distributedCoordination
+  .AbstractDistributedCoordinator {
+  public readyPromise: Promise<any>;
+  public db: SmartdataDb;
+  private asyncExecutionStack = new plugins.lik.AsyncExecutionStack();
+  private ownInstance: DistributedClass;
+
+  constructor(dbArg?: SmartdataDb) {
+    super();
+    this.db = dbArg;
+    setDefaultManagerForDoc(this, DistributedClass);
+    this.readyPromise = this.db.statusConnectedDeferred.promise;
+    this.init();
+  }
+
+  // smartdata specific stuff
+  public async start() {
+    await this.init();
+  }
+
+  public async stop() {
+    if (this.ownInstance?.data.elected) {
+      this.ownInstance.data.elected = false;
+    } else {
+      console.log(`can't stop a distributed instance that has not been started yet.`);
+    }
+  }
+
+  public id = plugins.smartunique.uni('distributedInstance');
+
+  private startHeartbeat = async () => {
+    while (this.ownInstance.data.status !== 'stopped') {
+      await this.asyncExecutionStack.getExclusiveExecutionSlot(async () => {
+        await this.ownInstance.updateFromDb();
+        this.ownInstance.data.lastUpdated = Date.now();
+        await this.ownInstance.save();
+      });
+      await plugins.smartdelay.delayFor(10000);
+    }
+  };
+  public async init() {
+    await this.readyPromise;
+    if (!this.ownInstance) {
+      await this.asyncExecutionStack.getExclusiveExecutionSlot(async () => {
+        this.ownInstance = new DistributedClass();
+        this.ownInstance.id = this.id;
+        this.ownInstance.data = {
+          elected: false,
+          lastUpdated: Date.now(),
+          status: 'initializing',
+          taskRequests: [],
+          taskRequestResults: []
+        };
+        await this.ownInstance.save();
+      });
+    }
+
+    // lets enable the heartbeat
+    this.startHeartbeat();
+
+    // lets do a leader check
+    await this.checkAndMaybeLead();
+
+    return this.ownInstance;
+  }
+
+  // --> leader election
+  public async checkAndMaybeLead() {
+    const allInstances = await DistributedClass.getInstances({});
+    let leader = allInstances.find((instanceArg) => instanceArg.data.elected === true);
+    if (
+      leader &&
+      leader.data.lastUpdated >=
+        Date.now() - plugins.smarttime.getMilliSecondsFromUnits({ minutes: 1 })
+    ) {
+      await this.asyncExecutionStack.getExclusiveExecutionSlot(async () => {
+        await this.ownInstance.updateFromDb();
+        this.ownInstance.data.status = 'settled';
+        await this.ownInstance.save();
+      });
+      return;
+    } else {
+      await this.asyncExecutionStack.getExclusiveExecutionSlot(async () => {
+        this.ownInstance.data.status = 'bidding';
+        this.ownInstance.data.biddingShortcode = plugins.smartunique.shortId();
+        await this.ownInstance.save();
+      });
+      await plugins.smartdelay.delayFor(plugins.smarttime.getMilliSecondsFromUnits({ minutes: 2 }));
+      await this.asyncExecutionStack.getExclusiveExecutionSlot(async () => {
+        let biddingInstances = await DistributedClass.getInstances({});
+        biddingInstances = biddingInstances.filter(
+          (instanceArg) =>
+            !instanceArg.data.elected &&
+            instanceArg.data.lastUpdated >=
+              Date.now() - plugins.smarttime.getMilliSecondsFromUnits({ minutes: 1 })
+        );
+        this.ownInstance.data.elected = true;
+        for (const biddingInstance of biddingInstances) {
+          if (biddingInstance.data.biddingShortcode < this.ownInstance.data.biddingShortcode) {
+            this.ownInstance.data.elected = false;
+          }
+        }
+        await this.ownInstance.save();
+      });
+      if (this.ownInstance.data.elected) {
+        this.leadFunction();
+      }
+    }
+  }
+
+  /**
+   * when it has been determined
+   * that this instance is leading
+   * the leading is implemented here
+   */
+  public async leadFunction() {
+    const ownInstance = await this.init();
+    const watcher = await DistributedClass.watch({});
+    /**
+     * this function is started once per unique job request
+     */
+    const startResultTimer = async () => {
+
+    }
+    
+    watcher.changeSubject.subscribe({
+      next: async (distributedDoc) => {
+        distributedDoc
+      }
+    })
+    while (this.ownInstance.data.status !== 'stopped') {
+      await plugins.smartdelay.delayFor(1000);
+    }
+  };
+
+  // abstract implemented methods
+  public async fireDistributedTaskRequest(
+    taskRequestArg: plugins.taskbuffer.distributedCoordination.IDistributedTaskRequest
+  ): Promise<plugins.taskbuffer.distributedCoordination.IDistributedTaskRequestResult> {
+    const ownInstance = await this.init();
+    await this.asyncExecutionStack.getExclusiveExecutionSlot(async () => {
+      this.ownInstance.data.taskRequests.push(taskRequestArg);
+      await this.ownInstance.save();
+    });
+    return null;
+  }
+
+  public async updateDistributedTaskRequest(
+    infoBasisArg: plugins.taskbuffer.distributedCoordination.IDistributedTaskRequest
+  ): Promise<void> {
+    await this.asyncExecutionStack.getExclusiveExecutionSlot(async () => {
+      const existingInfoBasis = this.ownInstance.data.taskRequests.find(infoBasisItem => {
+        return infoBasisItem.taskName === infoBasisArg.taskName
+          && infoBasisItem.taskExecutionTime === infoBasisArg.taskExecutionTime;
+      });
+      Object.assign(existingInfoBasis, infoBasisArg);
+      await this.ownInstance.save();
+      plugins.smartdelay.delayFor(60000).then(() => {
+        this.asyncExecutionStack.getExclusiveExecutionSlot(async () => {
+          const indexToRemove = this.ownInstance.data.taskRequests.indexOf(existingInfoBasis);
+          this.ownInstance.data.taskRequests.splice(indexToRemove, indexToRemove);
+          await this.ownInstance.save();
+        })
+      })
+    });
+  }
+}
--- a/ts/smartdata.classes.doc.ts
+++ b/ts/smartdata.classes.doc.ts
@ -1,9 +1,11 @@
-import * as plugins from './smartdata.plugins';
+import * as plugins from './smartdata.plugins.js';

-import { Objectmap } from 'lik';
+import { ObjectMap } from '@pushrocks/lik';

-import { SmartdataDb } from './smartdata.classes.db';
-import { SmartdataCollection } from './smartdata.classes.collection';
+import { SmartdataDb } from './smartdata.classes.db.js';
+import { SmartdataDbCursor } from './smartdata.classes.cursor.js';
+import { type IManager, SmartdataCollection } from './smartdata.classes.collection.js';
+import { SmartdataDbWatcher } from './smartdata.classes.watcher.js';

 export type TDocCreation = 'db' | 'new' | 'mixed';

@ -11,8 +13,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) => {
-    console.log(`called svDb() on ${key}`);
+  return (target: SmartDataDbDoc<unknown, unknown>, key: string) => {
+    console.log(`called svDb() on >${target.constructor.name}.${key}<`);
    if (!target.saveableProperties) {
      target.saveableProperties = [];
    }
@ -24,8 +26,8 @@ export function svDb() {
 * unique index - decorator to mark a unique index
 */
 export function unI() {
-  return (target: SmartDataDbDoc<any>, key: string) => {
-    console.log('called 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) {
@ -39,113 +41,249 @@ 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';
-
-  /**
-   * unique indexes
-   */
-  uniqueIndexes: string[];
-
-  /**
-   * an array of saveable properties of a doc
-   */
-  saveableProperties: string[];
-
-  /**
-   * name
-   */
-  name: string;
-
-  /**
-   * primary id in the database
-   */
-  dbDocUniqueId: string;
-
-  /**
-   * class constructor
-   */
-  constructor() {
-    this.name = this.constructor['name'];
-    this.collection = this.constructor['smartdataCollection'];
+  // STATIC
+  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
-    let referenceMongoDBCollection: SmartdataCollection<T> = self.smartdataCollection;
-    const foundDocs = await referenceMongoDBCollection.find(filterArg);
+  /**
+   * gets all instances as array
+   * @param this
+   * @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) {
-      let newInstance = new this();
-      for (let key in item) {
-        if (key !== 'id') {
-          newInstance[key] = item[key];
-        }
-      }
+    for (const foundDoc of foundDocs) {
+      const newInstance: T = (this as any).createInstanceFromMongoDbNativeDoc(foundDoc);
      returnArray.push(newInstance);
    }
    return returnArray;
  }

-  static async getInstance<T>(filterArg): Promise<T> {
-    let result = await this.getInstances<T>(filterArg);
-    if (result && result.length > 0) {
-      return result[0];
+  /**
+   * gets the first matching instance
+   * @param this
+   * @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 collection: SmartdataCollection<T> = (this as any).collection;
+    const cursor: SmartdataDbCursor<T> = await collection.getCursor(
+      convertFilterForMongoDb(filterArg),
+      this as any as typeof SmartDataDbDoc
+    );
+    return cursor;
+  }
+
+  /**
+   * watch the collection
+   * @param this
+   * @param filterArg
+   * @param forEachFunction
+   */
+  public static async watch<T>(
+    this: plugins.tsclass.typeFest.Class<T>,
+    filterArg: plugins.tsclass.typeFest.PartialDeep<T>
+  ) {
+    const collection: SmartdataCollection<T> = (this as any).collection;
+    const watcher: SmartdataDbWatcher<T> = await collection.watch(
+      convertFilterForMongoDb(filterArg),
+      this as any
+    );
+    return watcher;
+  }
+
+  /**
+   * 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);
+  }
+
+  // INSTANCE
+
+  /**
+   * 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() {}
+
  /**
   * saves this instance but not any connected items
   * may lead to data inconsistencies, but is faster
   */
-  async save() {
-    let self: any = this;
+  public async save() {
+    // 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) {
-      let property: any = this[propertyKey];
+    for (const propertyKey of Object.keys(this)) {
+      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
-    for (let propertyNameString of this.saveableProperties) {
+  /**
+   * updates an object from db
+   */
+  public async updateFromDb() {
+    const mongoDbNativeDoc = await this.collection.findOne(this.createIdentifiableObject());
+    for (const key of Object.keys(mongoDbNativeDoc)) {
+      this[key] = mongoDbNativeDoc[key];
+    }
+  }
+
+  /**
+   * 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;
+    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;
  }
 }
--- a/ts/smartdata.classes.easystore.ts
+++ b/ts/smartdata.classes.easystore.ts
@ -0,0 +1,108 @@
+import * as plugins from './smartdata.plugins.js';
+import { Collection } from './smartdata.classes.collection.js';
+import { SmartdataDb } from './smartdata.classes.db.js';
+import { SmartDataDbDoc, svDb, unI } from './smartdata.classes.doc.js';
+
+/**
+ * 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 ephermal: {
+        activated: boolean;
+        timeout: number;
+      };
+
+      @svDb()
+      lastEdit: number;
+
+      @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();
+  }
+
+  public async cleanUpEphermal() {
+    while(await this.smartdataDbRef.statusConnectedDeferred.promise && this.smartdataDbRef.status === 'connected') {
+      
+    }
+  }
+}
--- a/ts/smartdata.classes.watcher.ts
+++ b/ts/smartdata.classes.watcher.ts
@ -0,0 +1,33 @@
+import { SmartDataDbDoc } from './smartdata.classes.doc.js';
+import * as plugins from './smartdata.plugins.js';
+
+/**
+ * a wrapper for the native mongodb cursor. Exposes better
+ */
+export class SmartdataDbWatcher<T = any> {
+  // STATIC
+  public readyDeferred = plugins.smartpromise.defer();
+
+  // INSTANCE
+  private changeStream: plugins.mongodb.ChangeStream<T>;
+
+  public changeSubject = new plugins.smartrx.rxjs.Subject<T>();
+  constructor(
+    changeStreamArg: plugins.mongodb.ChangeStream<T>,
+    smartdataDbDocArg: typeof SmartDataDbDoc
+  ) {
+    this.changeStream = changeStreamArg;
+    this.changeStream.on('change', async (item: T) => {
+      this.changeSubject.next(
+        smartdataDbDocArg.createInstanceFromMongoDbNativeDoc(item) as any as T
+      );
+    });
+    plugins.smartdelay.delayFor(0).then(() => {
+      this.readyDeferred.resolve();
+    });
+  }
+
+  public async close() {
+    await this.changeStream.close();
+  }
+}
--- a/ts/smartdata.logging.ts
+++ b/ts/smartdata.logging.ts
@ -0,0 +1,3 @@
+import * as plugins from './smartdata.plugins.js';
+
+export const logger = new plugins.smartlog.ConsoleLog();
--- a/ts/smartdata.mongohelpers.ts
+++ b/ts/smartdata.mongohelpers.ts
@ -1,3 +0,0 @@
-export const addPassword = (mongoUrlArg: string, passwordArg: string): string => {
-  return mongoUrlArg.replace('<PASSWORD>', passwordArg);
-};
--- a/ts/smartdata.plugins.ts
+++ b/ts/smartdata.plugins.ts
@ -1,8 +1,31 @@
-import * as assert from 'assert';
-import * as smartlog from '@pushrocks/smartlog';
-import * as lodash from 'lodash';
-import * as mongodb from 'mongodb';
-import * as smartq from 'smartq';
-import * as smartstring from 'smartstring';
+// tsclass scope
+import * as tsclass from '@tsclass/tsclass';

-export { assert, smartlog, lodash, smartq, mongodb, smartstring };
+export { tsclass };
+
+// @pushrocks scope
+import * as lik from '@pushrocks/lik';
+import * as smartdelay from '@pushrocks/smartdelay';
+import * as smartlog from '@pushrocks/smartlog';
+import * as smartpromise from '@pushrocks/smartpromise';
+import * as smartq from '@pushrocks/smartpromise';
+import * as smartrx from '@pushrocks/smartrx';
+import * as smartstring from '@pushrocks/smartstring';
+import * as smarttime from '@pushrocks/smarttime';
+import * as smartunique from '@pushrocks/smartunique';
+import * as taskbuffer from '@pushrocks/taskbuffer';
+import * as mongodb from 'mongodb';
+
+export {
+  lik,
+  smartdelay,
+  smartpromise,
+  smartlog,
+  smartq,
+  smartrx,
+  mongodb,
+  smartstring,
+  smarttime,
+  smartunique,
+  taskbuffer,
+};
--- a/tsconfig.json
+++ b/tsconfig.json
@ -1,7 +1,9 @@
 {
  "compilerOptions": {
    "experimentalDecorators": true,
-    "target": "es2017",
-    "module": "commonjs"
+    "useDefineForClassFields": false,
+    "target": "ES2022",
+    "module": "ES2022",
+    "moduleResolution": "nodenext"
  }
-}
+}
Author	SHA1	Message	Date
Philipp Kunz	94854638dd	5.0.13	2023-06-24 23:57:35 +02:00
Philipp Kunz	902fab4cc0	fix(core): update	2023-06-24 23:57:34 +02:00
Philipp Kunz	ed3b19abc5	5.0.12	2023-03-21 20:16:08 +01:00
Philipp Kunz	5b88da7dce	fix(core): update	2023-03-21 20:16:07 +01:00
Philipp Kunz	df273e9efa	5.0.11	2023-02-06 11:43:11 +01:00
Philipp Kunz	fd590e0be3	fix(core): update	2023-02-06 11:43:11 +01:00
Philipp Kunz	ef97b390d4	5.0.10	2022-11-08 10:26:21 +01:00
Philipp Kunz	cd14eb8bf3	fix(core): update	2022-11-08 10:26:20 +01:00
Philipp Kunz	f48443dcd3	5.0.9	2022-11-01 18:23:58 +01:00
Philipp Kunz	3f28ff80cb	fix(core): update	2022-11-01 18:23:57 +01:00
Philipp Kunz	64005a0b32	5.0.8	2022-09-12 11:37:54 +02:00
Philipp Kunz	8a77bb3281	fix(core): update	2022-09-12 11:37:53 +02:00
Philipp Kunz	25f50ecf51	5.0.7	2022-06-14 22:04:35 +02:00
Philipp Kunz	ad87f8147b	fix(core): update	2022-06-14 22:04:34 +02:00
Philipp Kunz	da0c9873eb	5.0.6	2022-06-14 22:02:57 +02:00
Philipp Kunz	2fcd3f1550	fix(core): update	2022-06-14 22:02:57 +02:00
Philipp Kunz	f726cf4c5b	5.0.5	2022-06-05 17:19:12 +02:00
Philipp Kunz	c198969fae	fix(core): update	2022-06-05 17:19:12 +02:00
Philipp Kunz	be1badeb23	5.0.4	2022-06-05 17:18:13 +02:00
Philipp Kunz	fe065b966f	fix(core): update	2022-06-05 17:18:13 +02:00
Philipp Kunz	811e2490b8	5.0.3	2022-05-19 16:15:28 +02:00
Philipp Kunz	206ccd40e9	fix(watcher.changeSubject): now emits correct type into observer functions	2022-05-19 16:15:28 +02:00
Philipp Kunz	055298172f	5.0.2	2022-05-18 18:17:12 +02:00
Philipp Kunz	278f3c8169	fix(tests): now uses @pushrocks/smartmongo backed by wiredTiger	2022-05-18 18:17:11 +02:00
Philipp Kunz	0709ba921b	5.0.1	2022-05-17 23:54:26 +02:00
Philipp Kunz	de1f1110b4	fix(core): update	2022-05-17 23:54:26 +02:00
Philipp Kunz	30f4254428	5.0.0	2022-05-17 21:30:53 +02:00
Philipp Kunz	1c4b03e647	BREAKING CHANGE(core): switch to esm	2022-05-17 21:30:53 +02:00
Philipp Kunz	27cc7651ba	4.0.29	2022-05-17 21:26:17 +02:00
Philipp Kunz	355a2a3f2b	fix(core): update	2022-05-17 21:26:17 +02:00
Philipp Kunz	a739582861	4.0.28	2022-05-17 00:33:44 +02:00
Philipp Kunz	37f9a64735	fix(core): update	2022-05-17 00:33:44 +02:00
Philipp Kunz	83a5170591	4.0.27	2021-11-12 19:32:54 +01:00
Philipp Kunz	f94363cf31	fix(core): update	2021-11-12 19:32:54 +01:00
Philipp Kunz	df02e5bb71	4.0.26	2021-11-12 19:16:11 +01:00
Philipp Kunz	38e438c54f	fix(core): update	2021-11-12 19:16:11 +01:00
Philipp Kunz	11bc1ac6dc	4.0.25	2021-11-12 19:03:06 +01:00
Philipp Kunz	3431e94ddd	fix(core): update	2021-11-12 19:03:06 +01:00
Philipp Kunz	739e040776	4.0.24	2021-11-12 19:02:29 +01:00
Philipp Kunz	28d57efd9e	fix(core): update	2021-11-12 19:02:29 +01:00
Philipp Kunz	f50a61308c	4.0.23	2021-11-12 18:12:59 +01:00
Philipp Kunz	42aa9f9f8a	fix(core): update	2021-11-12 18:12:59 +01:00
Philipp Kunz	3f591ff9d8	4.0.22	2021-11-12 18:04:08 +01:00
Philipp Kunz	7b33347b4c	fix(core): update	2021-11-12 18:04:08 +01:00
Philipp Kunz	3f11cbf595	4.0.21	2021-11-12 17:32:43 +01:00
Philipp Kunz	cf1ec7f9eb	fix(core): update	2021-11-12 17:32:43 +01:00
Philipp Kunz	54060deb8f	4.0.20	2021-11-12 17:22:32 +01:00
Philipp Kunz	48cffb5ac2	fix(core): update	2021-11-12 17:22:31 +01:00
Philipp Kunz	8301eb79a2	4.0.19	2021-11-12 16:36:25 +01:00
Philipp Kunz	ad6366a294	fix(core): update	2021-11-12 16:36:25 +01:00
Philipp Kunz	cb6c03ebfe	4.0.18	2021-11-12 16:23:27 +01:00
Philipp Kunz	551916fe5c	fix(core): update	2021-11-12 16:23:26 +01:00
Philipp Kunz	9b3892c1e8	4.0.17	2021-10-18 14:37:17 +02:00
Philipp Kunz	c1b1af9c5d	fix(dbdoc manager access working again ): update	2021-10-18 14:37:17 +02:00
Philipp Kunz	d3a3d5be9d	4.0.16	2021-10-16 23:33:22 +02:00
Philipp Kunz	c9a734d879	fix(core): update	2021-10-16 23:33:21 +02:00
Philipp Kunz	856e8e7d1f	4.0.15	2021-10-16 21:17:03 +02:00
Philipp Kunz	7a4d557724	fix(core): update	2021-10-16 21:17:02 +02:00
Philipp Kunz	7cbd0bd99b	4.0.14	2021-10-16 19:54:06 +02:00
Philipp Kunz	e10f6585a5	fix(core): update	2021-10-16 19:54:05 +02:00
Philipp Kunz	5c8dffdd9c	4.0.13	2021-10-02 15:03:35 +02:00
Philipp Kunz	846996eeac	fix(core): update	2021-10-02 15:03:35 +02:00
Philipp Kunz	668df09ba0	4.0.12	2021-09-19 17:05:09 +02:00
Philipp Kunz	03656f4ca0	fix(core): update	2021-09-19 17:05:08 +02:00
Philipp Kunz	c4c612f3a9	4.0.11	2021-09-18 00:38:21 +02:00
Philipp Kunz	e357f7581c	fix(core): update	2021-09-18 00:38:20 +02:00
Philipp Kunz	9697b1e48b	4.0.10	2021-09-17 22:34:15 +02:00
Philipp Kunz	aeb35705d4	fix(core): update	2021-09-17 22:34:15 +02:00
Philipp Kunz	236c8c6551	4.0.9	2021-09-16 19:49:55 +02:00
Philipp Kunz	1f28db15e7	fix(core): update	2021-09-16 19:49:55 +02:00
Philipp Kunz	86d600e287	4.0.8	2021-06-09 15:38:15 +02:00
Philipp Kunz	bb81530dac	fix(core): update	2021-06-09 15:38:14 +02:00
Philipp Kunz	b9f9b36b87	4.0.7	2021-06-09 15:37:50 +02:00
Philipp Kunz	df2fadfa01	fix(core): update	2021-06-09 15:37:49 +02:00
Philipp Kunz	8b2beb3485	4.0.6	2021-06-09 14:55:56 +02:00
Philipp Kunz	144a620f43	fix(core): update	2021-06-09 14:55:55 +02:00
Philipp Kunz	c241247845	4.0.5	2021-06-09 14:32:14 +02:00
Philipp Kunz	81e39d09e4	4.0.4	2021-06-09 14:10:08 +02:00
Philipp Kunz	8e51b518b1	fix(core): update	2021-06-09 14:10:08 +02:00
Philipp Kunz	8308d8d03b	4.0.3	2021-06-09 13:40:23 +02:00
Philipp Kunz	97365ddf29	fix(core): update	2021-06-09 13:40:23 +02:00
Philipp Kunz	55d96fa68d	4.0.2	2021-06-09 12:40:55 +02:00
Philipp Kunz	54ec6accdf	fix(core): update	2021-06-09 12:40:55 +02:00
Philipp Kunz	fc5d092b25	4.0.1	2021-06-06 17:54:48 +02:00
Philipp Kunz	dfba057562	fix(core): update	2021-06-06 17:54:47 +02:00
Philipp Kunz	1ad05943b5	4.0.0	2021-06-06 17:48:37 +02:00
Philipp Kunz	302e51a77f	BREAKING CHANGE(filter design): filters now are congruent with their data types. Static extensions of doc base class now are fully typed with automatic reference to their child classes.	2021-06-06 17:48:37 +02:00
Phil Kunz	1330d03af2	3.1.56	2021-05-16 23:26:05 +00:00
Phil Kunz	a298e9d190	fix(core): update	2021-05-16 23:26:05 +00:00
Phil Kunz	e571ef347b	3.1.55	2021-02-05 21:16:46 +00:00
Phil Kunz	39a4c7ef3f	fix(core): update	2021-02-05 21:16:45 +00:00
Phil Kunz	0d3518d990	3.1.54	2020-10-19 16:44:28 +00:00
Phil Kunz	fbdde2268c	fix(core): update	2020-10-19 16:44:28 +00:00
Phil Kunz	8b6c26f45a	3.1.53	2020-10-19 16:37:45 +00:00
Phil Kunz	97e82ed75a	fix(core): update	2020-10-19 16:37:44 +00:00
Phil Kunz	03baffd9fd	3.1.52	2020-09-25 21:05:22 +00:00
Phil Kunz	f29ae67580	fix(core): update	2020-09-25 21:05:21 +00:00
Phil Kunz	e550a8dbd6	3.1.51	2020-09-25 20:42:39 +00:00
Phil Kunz	cf6ef25a8d	fix(core): update	2020-09-25 20:42:38 +00:00
Phil Kunz	29c512b0cc	3.1.50	2020-09-24 14:10:55 +00:00
Phil Kunz	105f69d1c9	fix(core): update	2020-09-24 14:10:54 +00:00
Phil Kunz	4c375f8465	3.1.49	2020-09-10 10:36:01 +00:00
Phil Kunz	9466af6a4a	fix(core): update	2020-09-10 10:36:00 +00:00
Phil Kunz	c5aa747f42	3.1.48	2020-09-10 10:12:18 +00:00
Phil Kunz	b5f2474f65	fix(core): update	2020-09-10 10:12:17 +00:00
Phil Kunz	85f0d99934	3.1.47	2020-09-09 05:05:42 +00:00
Phil Kunz	3b2d3d9072	fix(core): update	2020-09-09 05:05:41 +00:00
Phil Kunz	3ff5c36fdf	3.1.46	2020-09-09 05:00:10 +00:00
Phil Kunz	a5acc2fe4e	fix(core): update	2020-09-09 05:00:09 +00:00
Phil Kunz	9c81257101	3.1.45	2020-09-09 04:51:57 +00:00
Phil Kunz	f7342962f4	fix(core): update	2020-09-09 04:51:56 +00:00
Phil Kunz	bcd10205d3	3.1.44	2020-09-09 03:51:22 +00:00
Phil Kunz	6cab20f32d	fix(core): update	2020-09-09 03:51:21 +00:00
Phil Kunz	5aaa6ad2d6	3.1.43	2020-09-09 02:50:28 +00:00
Phil Kunz	635256f2f6	fix(core): update	2020-09-09 02:50:27 +00:00
Phil Kunz	f799d3efa5	3.1.42	2020-09-09 02:21:16 +00:00
Phil Kunz	f74020ba96	fix(core): update	2020-09-09 02:21:15 +00:00
Phil Kunz	f6d6545ff5	3.1.41	2020-08-18 15:10:45 +00:00
Phil Kunz	85a196c8c1	fix(core): update	2020-08-18 15:10:44 +00:00
Phil Kunz	adb198af01	3.1.40	2020-08-18 13:28:01 +00:00
Phil Kunz	6dce9f3ff8	3.1.39	2020-08-18 13:27:05 +00:00
Phil Kunz	2f6a4ce3e5	fix(core): update	2020-08-18 13:27:04 +00:00
Phil Kunz	0984a1ade4	3.1.38	2020-08-18 12:53:45 +00:00
Phil Kunz	804701c96a	fix(core): update	2020-08-18 12:53:44 +00:00
Phil Kunz	a3759fa484	3.1.37	2020-08-18 12:52:01 +00:00
Phil Kunz	ef38df62be	fix(core): update	2020-08-18 12:52:00 +00:00
Phil Kunz	c17789e92e	3.1.36	2020-08-18 12:46:14 +00:00
Phil Kunz	0bf2ba554d	fix(core): update	2020-08-18 12:46:14 +00:00
Phil Kunz	5cbf1a222a	3.1.35	2020-08-18 12:36:41 +00:00
Phil Kunz	f075530838	fix(core): update	2020-08-18 12:36:41 +00:00
Phil Kunz	efb83853fb	3.1.34	2020-08-18 12:35:16 +00:00
Phil Kunz	73300ca4d3	fix(core): update	2020-08-18 12:35:16 +00:00
Phil Kunz	1e946cdceb	3.1.33	2020-08-18 12:33:17 +00:00
Phil Kunz	608ff93a41	fix(core): update	2020-08-18 12:33:16 +00:00
Phil Kunz	6211953f14	3.1.32	2020-08-18 12:32:55 +00:00
Phil Kunz	99e520b776	fix(core): update	2020-08-18 12:32:54 +00:00
Phil Kunz	eda8297356	3.1.31	2020-08-18 12:05:08 +00:00
Phil Kunz	ffa52a5883	fix(core): update	2020-08-18 12:05:07 +00:00
Phil Kunz	1e83f0a0ef	3.1.30	2020-08-18 12:01:47 +00:00
Phil Kunz	0203eabdfd	fix(core): update	2020-08-18 12:01:46 +00:00
Phil Kunz	72894e3ef1	3.1.29	2020-06-12 05:59:08 +00:00
Phil Kunz	bbe5f8c6a8	fix(core): update	2020-06-12 05:59:07 +00:00
Phil Kunz	02af9f5c4b	3.1.28	2020-06-11 23:08:38 +00:00
Phil Kunz	17de480272	fix(core): update	2020-06-11 23:08:38 +00:00
Phil Kunz	776fd3ee4e	3.1.27	2020-06-11 23:05:46 +00:00
Phil Kunz	3272bb7235	fix(core): update	2020-06-11 23:05:45 +00:00
Phil Kunz	116dfbc3b0	update module structure	2020-06-11 23:05:32 +00:00
Phil Kunz	3f714b1a33	3.1.26	2020-02-19 18:30:35 +00:00
Phil Kunz	e58fa57525	fix(core): update	2020-02-19 18:30:34 +00:00
Phil Kunz	8e7ad5210f	3.1.25	2020-02-08 14:37:45 +00:00
Phil Kunz	cea6c662ac	fix(core): update	2020-02-08 14:37:44 +00:00
Phil Kunz	6eb43a4b9f	3.1.24	2020-02-08 14:01:55 +00:00
Phil Kunz	7f89cbeecd	fix(core): update	2020-02-08 14:01:55 +00:00
Phil Kunz	a042a589a0	3.1.23	2019-09-11 12:36:03 +02:00
Phil Kunz	75b5f6af08	fix(core): update	2019-09-11 12:36:02 +02:00
Phil Kunz	e6a36f22ac	3.1.22	2019-09-11 12:12:51 +02:00
Phil Kunz	246e3486f0	fix(id field now properly populated): update	2019-09-11 12:12:50 +02:00
Phil Kunz	c1c4a29415	3.1.21	2019-09-11 11:56:41 +02:00
Phil Kunz	6448516aa0	fix(core): update	2019-09-11 11:56:41 +02:00
Phil Kunz	24a7b2dbd3	3.1.20	2019-09-04 17:41:53 +02:00
Phil Kunz	afa7c2fe61	fix(core): update	2019-09-04 17:41:53 +02:00
Phil Kunz	b768896fbe	3.1.19	2019-09-04 17:25:50 +02:00
Phil Kunz	8d7d9adef1	fix(core): update	2019-09-04 17:25:50 +02:00
Phil Kunz	ca6d3c60c0	3.1.18	2019-09-02 16:58:19 +02:00
Phil Kunz	38c1fcd53a	fix(core): update	2019-09-02 16:58:19 +02:00
Phil Kunz	e433b9e212	3.1.17	2019-09-02 16:51:22 +02:00
Phil Kunz	bf3656f792	fix(core): update	2019-09-02 16:51:22 +02:00
Phil Kunz	7e9fc62ce7	3.1.16	2019-09-02 16:50:23 +02:00
Phil Kunz	670a0c63fb	fix(core): update	2019-09-02 16:50:22 +02:00
Phil Kunz	64e76b3ed1	3.1.15	2019-09-02 16:42:30 +02:00
Phil Kunz	25803330de	fix(core): update	2019-09-02 16:42:29 +02:00
Phil Kunz	c6cbff1308	3.1.14	2019-02-13 22:08:58 +01:00
Phil Kunz	3eeac7b936	fix(structure): format	2019-02-13 22:08:58 +01:00
Phil Kunz	761b742e21	3.1.13	2019-01-08 19:55:14 +01:00
Phil Kunz	e56def621c	fix(core): update	2019-01-08 19:55:13 +01:00
Phil Kunz	ab1799f4f2	3.1.12	2019-01-08 18:59:36 +01:00
Phil Kunz	9985b849d1	3.1.11	2019-01-08 18:45:31 +01:00
Phil Kunz	1800273b25	fix(core): update	2019-01-08 18:45:30 +01:00
Phil Kunz	e715cc6d37	3.1.10	2019-01-08 18:22:48 +01:00
Phil Kunz	f7abc175aa	fix(core): update	2019-01-08 18:22:48 +01:00
Phil Kunz	bbcb3a614e	3.1.9	2019-01-08 14:37:17 +01:00
Phil Kunz	941d2f0902	fix(core): update	2019-01-08 14:37:17 +01:00
Phil Kunz	5c78f83a28	3.1.8	2019-01-08 13:52:09 +01:00
Phil Kunz	124f117352	fix(core): update	2019-01-08 13:52:08 +01:00
Phil Kunz	f67da898ae	3.1.7	2019-01-08 12:39:00 +01:00
Phil Kunz	3c8f70f77e	fix(core): update	2019-01-08 12:38:59 +01:00
Phil Kunz	3674d7d9a5	3.1.6	2019-01-08 00:09:43 +01:00
Phil Kunz	fe2a622488	3.1.5	2019-01-07 02:50:10 +01:00
Phil Kunz	f092eefbf3	fix(core): update	2019-01-07 02:50:09 +01:00
Phil Kunz	8d0aa361f9	3.1.4	2019-01-07 02:41:38 +01:00
Phil Kunz	692a1223a8	fix(core): update	2019-01-07 02:41:38 +01:00
Phil Kunz	ae7d101ab9	3.1.3	2019-01-07 02:38:30 +01:00
Phil Kunz	3825b15a65	fix(core): update	2019-01-07 02:38:30 +01:00
Phil Kunz	3fc41678d2	3.1.2	2018-07-10 21:45:26 +02:00
Phil Kunz	39f1b7ada1	fix(test): fix import	2018-07-10 21:45:26 +02:00