5.0.26

.gitea/workflows/default_nottags.yaml

@@ -0,0 +1,66 @@
+name: Default (not tags)
+
+on:
+  push:
+    tags-ignore:
+      - '**'
+
+env:
+  IMAGE: registry.gitlab.com/hosttoday/ht-docker-node:npmci
+  NPMCI_COMPUTED_REPOURL: https://${{gitea.repository_owner}}:${{secrets.GITEA_TOKEN}}@gitea.lossless.digital/${{gitea.repository}}.git
+  NPMCI_TOKEN_NPM: ${{secrets.NPMCI_TOKEN_NPM}}
+  NPMCI_TOKEN_NPM2: ${{secrets.NPMCI_TOKEN_NPM2}}
+  NPMCI_GIT_GITHUBTOKEN: ${{secrets.NPMCI_GIT_GITHUBTOKEN}}
+  NPMCI_URL_CLOUDLY: ${{secrets.NPMCI_URL_CLOUDLY}}
+
+jobs:
+  security:
+    runs-on: ubuntu-latest
+    continue-on-error: true
+    container:
+      image: ${{ env.IMAGE }}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Install pnpm and npmci
+        run: |
+          pnpm install -g pnpm
+          pnpm install -g @shipzone/npmci
+
+      - name: Run npm prepare
+        run: npmci npm prepare
+
+      - name: Audit production dependencies
+        run: |
+          npmci command npm config set registry https://registry.npmjs.org
+          npmci command pnpm audit --audit-level=high --prod
+        continue-on-error: true
+
+      - name: Audit development dependencies
+        run: |
+          npmci command npm config set registry https://registry.npmjs.org
+          npmci command pnpm audit --audit-level=high --dev
+        continue-on-error: true
+
+  test:
+    if: ${{ always() }}
+    needs: security
+    runs-on: ubuntu-latest
+    container:
+      image: ${{ env.IMAGE }}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Test stable
+        run: |
+          npmci node install stable
+          npmci npm install
+          npmci npm test
+
+      - name: Test build
+        run: |
+          npmci node install stable
+          npmci npm install
+          npmci npm build

.gitea/workflows/default_tags.yaml

@@ -0,0 +1,124 @@
+name: Default (tags)
+
+on:
+  push:
+    tags:
+      - '*'
+
+env:
+  IMAGE: registry.gitlab.com/hosttoday/ht-docker-node:npmci
+  NPMCI_COMPUTED_REPOURL: https://${{gitea.repository_owner}}:${{secrets.GITEA_TOKEN}}@gitea.lossless.digital/${{gitea.repository}}.git
+  NPMCI_TOKEN_NPM: ${{secrets.NPMCI_TOKEN_NPM}}
+  NPMCI_TOKEN_NPM2: ${{secrets.NPMCI_TOKEN_NPM2}}
+  NPMCI_GIT_GITHUBTOKEN: ${{secrets.NPMCI_GIT_GITHUBTOKEN}}
+  NPMCI_URL_CLOUDLY: ${{secrets.NPMCI_URL_CLOUDLY}}
+
+jobs:
+  security:
+    runs-on: ubuntu-latest
+    continue-on-error: true
+    container:
+      image: ${{ env.IMAGE }}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Prepare
+        run: |
+          pnpm install -g pnpm
+          pnpm install -g @shipzone/npmci
+          npmci npm prepare
+
+      - name: Audit production dependencies
+        run: |
+          npmci command npm config set registry https://registry.npmjs.org
+          npmci command pnpm audit --audit-level=high --prod
+        continue-on-error: true
+
+      - name: Audit development dependencies
+        run: |
+          npmci command npm config set registry https://registry.npmjs.org
+          npmci command pnpm audit --audit-level=high --dev
+        continue-on-error: true
+
+  test:
+    if: ${{ always() }}
+    needs: security
+    runs-on: ubuntu-latest
+    container:
+      image: ${{ env.IMAGE }}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Prepare
+        run: |
+          pnpm install -g pnpm
+          pnpm install -g @shipzone/npmci
+          npmci npm prepare
+
+      - name: Test stable
+        run: |
+          npmci node install stable
+          npmci npm install
+          npmci npm test
+
+      - name: Test build
+        run: |
+          npmci node install stable
+          npmci npm install
+          npmci npm build
+
+  release:
+    needs: test
+    if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags/')
+    runs-on: ubuntu-latest
+    container:
+      image: ${{ env.IMAGE }}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Prepare
+        run: |
+          pnpm install -g pnpm
+          pnpm install -g @shipzone/npmci
+          npmci npm prepare
+
+      - name: Release
+        run: |
+          npmci node install stable
+          npmci npm publish
+
+  metadata:
+    needs: test
+    if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags/')
+    runs-on: ubuntu-latest
+    container:
+      image: ${{ env.IMAGE }}
+    continue-on-error: true
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Prepare
+        run: |
+          pnpm install -g pnpm
+          pnpm install -g @shipzone/npmci
+          npmci npm prepare
+
+      - name: Code quality
+        run: |
+          npmci command npm install -g typescript
+          npmci npm install
+
+      - name: Trigger
+        run: npmci trigger
+
+      - name: Build docs and upload artifacts
+        run: |
+          npmci node install stable
+          npmci npm install
+          pnpm install -g @gitzone/tsdoc
+          npmci command tsdoc
+        continue-on-error: true

.gitignore

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

.gitlab-ci.yml

@@ -1,43 +0,0 @@
-image: hosttoday/ht-docker-node:npmts
-
-stages:
-- test
-- release
-
-before_script:
-  - apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv EA312927
-  - echo "deb http://repo.mongodb.org/apt/ubuntu xenial/mongodb-org/3.2 multiverse" | tee /etc/apt/sources.list.d/mongodb-org-3.2.list
-  - apt-get update
-  - apt-get install -y mongodb-org
-
-testLEGACY:
-  stage: test
-  script:
-    - npmci test legacy
-  tags:
-    - docker
-  allow_failure: true
-
-testLTS:
-  stage: test
-  script:
-    - npmci test lts
-  tags:
-    - docker
-    
-testSTABLE:
-  stage: test
-  script:
-    - npmci test stable
-  tags:
-    - docker
-
-release:
-  stage: release
-  environment: npm_registry
-  script:
-    - npmci publish
-  only:
-    - tags
-  tags:
-    - docker

.vscode/launch.json

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

.vscode/settings.json

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

README.md

@@ -1,89 +0,0 @@
-# smartdata
-
-> Note: Still in Beta
-
-smartdata is a ODM that adheres to TypeScript practices and uses classes to organize data.
-It uses MongoDB as persistent storage.
-
-## Intention
-There are many ODMs out there, however when we searched for a ODM that uses TypeScript,
-acts smart while still embracing an easy the NoSQL idea we didn't find a matching solution.
-This is why we started smartdata
-
-How MongoDB terms map to smartdata classes
-
-MongoDB term | smartdata class
---- | ---
-Database | smartdata.Db
-Collection | smartdata.DbCollection
-Document | smartdata.DbDoc
-
-### class Db
-represents a Database. Naturally it has .connect() etc. methods on it.
-Since it is a class you can have multiple DBs defined.
-```typescript
-import * as smartdata from 'smartdata'
-
-let myDb1 = new smartdata.Db('someConnectionUrl')
-let myDb2 = new smartdata.Db('someConnectionUrl')
-
-myDb1.connect()
-myDb2.connect()
-
-// continues in next block... 
-```
-
-### class DbCollection
-represents a collection of objects.
-A collection is defined by the object class (that is extending smartdata.dbdoc) it respresents
-
-So to get to get access to a specific collection you document
-```typescript
-// continues from the block before...
-
-class myObject extends smartdata.DbDoc { // read the next block about DbDoc
-    property1:string
-    property2:number
-    constructor(optionsArg:{
-        queryArg?:any,
-        dataArg?:{
-            property1:string,
-            property2:number
-        }
-    }) {
-        super(this,optionsArg)
-    }
-} 
-let myCollection = myDb1.getCollection(myObject)
-``` 
-
-> Alert: You NEVER instantiate a collection.
-This is done for you!!!
-
-### class DbDoc
-represents a individual document in a collection
-and thereby is ideally suited to extend the class you want to actually store.
-
-DbDoc extends your class with the following methods:
-
-* `.save()` will save (or update) the object you call it on only. Any referenced non-savable objects will not get stored.
-* `.saveDeep()` does the same like `.save()`.
-  In addition it will look for properties that reference an object
-  that extends DbDoc as well and call .saveDeep() on them as well.
-  Loops are prevented
-
-So now we can **store** instances of classes to Db...
-How do we **get** a new class instance from a Doc in the DB?
-Easy! Take a look at the constructor. When you specify `optionsArg.queryArg`
-smartdata will fill in the data from the database!
-But when you specify a `optionsArg.dataArg` instead
-the data for the class is taken from there :)
-
-## TypeScript
-How does TypeScript play into this?
-Since you define your classes in TapeScript and types flow through smartdata in a generic way
-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 whenimporting smartdata. 
-
-[![npm](https://push.rocks/assets/repo-header.svg)](https://push.rocks)

dist/index.d.ts

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

dist/index.js

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

dist/smartdata.classes.db.d.ts

@@ -1,11 +0,0 @@
-/// <reference types="q" />
-import * as plugins from './smartdata.plugins';
-export declare type TConnectionStatus = 'disconnected' | 'connected' | 'failed';
-export declare class Db {
-    dbUrl: string;
-    db: plugins.mongodb.Db;
-    status: TConnectionStatus;
-    constructor(dbUrl: string);
-    connect(): plugins.q.Promise<any>;
-    close(): plugins.q.Promise<any>;
-}

dist/smartdata.classes.db.js

@@ -1,29 +0,0 @@
-"use strict";
-const plugins = require('./smartdata.plugins');
-class Db {
-    constructor(dbUrl) {
-        this.dbUrl = dbUrl;
-    }
-    connect() {
-        let done = plugins.q.defer();
-        plugins.mongodb.MongoClient.connect(this.dbUrl, (err, db) => {
-            if (err) {
-                console.log(err);
-            }
-            plugins.assert.equal(null, err);
-            this.db = db;
-            plugins.beautylog.success(`connected to database at ${this.dbUrl}`);
-            done.resolve(this.db);
-        });
-        return done.promise;
-    }
-    close() {
-        let done = plugins.q.defer();
-        this.db.close();
-        plugins.beautylog.ok(`disconnected to database at ${this.dbUrl}`);
-        done.resolve();
-        return done.promise;
-    }
-}
-exports.Db = Db;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRkYXRhLmNsYXNzZXMuZGIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9zbWFydGRhdGEuY2xhc3Nlcy5kYi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsTUFBWSxPQUFPLFdBQU0scUJBRXpCLENBQUMsQ0FGNkM7QUFJOUM7SUFLSSxZQUFZLEtBQWE7UUFDckIsSUFBSSxDQUFDLEtBQUssR0FBRyxLQUFLLENBQUE7SUFDdEIsQ0FBQztJQUVELE9BQU87UUFDSCxJQUFJLElBQUksR0FBRyxPQUFPLENBQUMsQ0FBQyxDQUFDLEtBQUssRUFBRSxDQUFBO1FBQzVCLE9BQU8sQ0FBQyxPQUFPLENBQUMsV0FBVyxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsS0FBSyxFQUFFLENBQUMsR0FBRyxFQUFFLEVBQUU7WUFDcEQsRUFBRSxDQUFDLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQztnQkFBQyxPQUFPLENBQUMsR0FBRyxDQUFDLEdBQUcsQ0FBQyxDQUFBO1lBQUMsQ0FBQztZQUM3QixPQUFPLENBQUMsTUFBTSxDQUFDLEtBQUssQ0FBQyxJQUFJLEVBQUUsR0FBRyxDQUFDLENBQUE7WUFDL0IsSUFBSSxDQUFDLEVBQUUsR0FBRyxFQUFFLENBQUE7WUFDWixPQUFPLENBQUMsU0FBUyxDQUFDLE9BQU8sQ0FBQyw0QkFBNEIsSUFBSSxDQUFDLEtBQUssRUFBRSxDQUFDLENBQUE7WUFDbkUsSUFBSSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsRUFBRSxDQUFDLENBQUE7UUFDekIsQ0FBQyxDQUFDLENBQUE7UUFDRixNQUFNLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQTtJQUN2QixDQUFDO0lBRUQsS0FBSztRQUNELElBQUksSUFBSSxHQUFHLE9BQU8sQ0FBQyxDQUFDLENBQUMsS0FBSyxFQUFFLENBQUE7UUFDNUIsSUFBSSxDQUFDLEVBQUUsQ0FBQyxLQUFLLEVBQUUsQ0FBQTtRQUNmLE9BQU8sQ0FBQyxTQUFTLENBQUMsRUFBRSxDQUFDLCtCQUErQixJQUFJLENBQUMsS0FBSyxFQUFFLENBQUMsQ0FBQTtRQUNqRSxJQUFJLENBQUMsT0FBTyxFQUFFLENBQUE7UUFDZCxNQUFNLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQTtJQUN2QixDQUFDO0FBQ0wsQ0FBQztBQTVCWSxVQUFFLEtBNEJkLENBQUEifQ==

dist/smartdata.classes.dbcollection.d.ts

@@ -1,24 +0,0 @@
-/// <reference types="q" />
-import * as plugins from './smartdata.plugins';
-import { Db } from './smartdata.classes.db';
-export declare class DbCollection<T> {
-    collection: plugins.mongodb.Collection;
-    constructor(nameArg: string, dbArg: Db);
-    /**
-     * adds a validation function that all newly inserted and updated objects have to pass
-     */
-    addObjectValidation(funcArg: any): void;
-    /**
-     * finds an object in the DbCollection
-     */
-    find(docMatchArg: T | any): plugins.q.Promise<T[]>;
-    /**
-     * inserts  object into the DbCollection
-     */
-    insertOne(docArg: T): plugins.q.Promise<void>;
-    /**
-     * inserts many objects at once into the DbCollection
-     */
-    insertMany(docArrayArg: T[]): plugins.q.Promise<void>;
-    private checkDoc(doc);
-}

dist/smartdata.classes.dbcollection.js

@@ -1,57 +0,0 @@
-"use strict";
-const plugins = require('./smartdata.plugins');
-class DbCollection {
-    constructor(nameArg, dbArg) {
-        this.collection = dbArg.db.collection(nameArg);
-    }
-    /**
-     * adds a validation function that all newly inserted and updated objects have to pass
-     */
-    addObjectValidation(funcArg) { }
-    /**
-     * finds an object in the DbCollection
-     */
-    find(docMatchArg) {
-        let done = plugins.q.defer();
-        this.collection.find(docMatchArg).toArray((err, docs) => {
-            if (err) {
-                throw err;
-            }
-            done.resolve(docs);
-        });
-        return done.promise;
-    }
-    /**
-     * inserts  object into the DbCollection
-     */
-    insertOne(docArg) {
-        let done = plugins.q.defer();
-        this.checkDoc(docArg).then(() => {
-            this.collection.insertOne(docArg)
-                .then(() => { done.resolve(); });
-        });
-        return done.promise;
-    }
-    /**
-     * inserts many objects at once into the DbCollection
-     */
-    insertMany(docArrayArg) {
-        let done = plugins.q.defer();
-        let checkDocPromiseArray = [];
-        for (let docArg of docArrayArg) {
-            checkDocPromiseArray.push(this.checkDoc(docArg));
-        }
-        plugins.q.all(checkDocPromiseArray).then(() => {
-            this.collection.insertMany(docArrayArg)
-                .then(() => { done.resolve(); });
-        });
-        return done.promise;
-    }
-    checkDoc(doc) {
-        let done = plugins.q.defer();
-        done.resolve();
-        return done.promise;
-    }
-}
-exports.DbCollection = DbCollection;
-//# sourceMappingURL=data:application/json;base64,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

dist/smartdata.classes.dbdoc.js

@@ -1 +0,0 @@
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRkYXRhLmNsYXNzZXMuZGJkb2MuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9zbWFydGRhdGEuY2xhc3Nlcy5kYmRvYy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=

dist/smartdata.plugins.d.ts

@@ -1,5 +0,0 @@
-import 'typings-global';
-export import assert = require('assert');
-export import beautylog = require('beautylog');
-export import mongodb = require('mongodb');
-export import q = require('q');

dist/smartdata.plugins.js

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

docs/index.md

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

npmextra.json

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

package.json

@@ -1,12 +1,15 @@
 {
-  "name": "smartdata",
-  "version": "1.0.13",
+  "name": "@push.rocks/smartdata",
+  "version": "5.0.26",
+  "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": "(npm run prepareMongo && npmts)",
-    "prepareMongo": "(rm -rf ./test/data && mkdir ./test/data/)"
+    "test": "tstest test/",
+    "build": "tsbuild --web --allowimplicitany",
+    "buildDocs": "tsdoc"
   },
   "repository": {
     "type": "git",
@@ -19,19 +22,41 @@
   },
   "homepage": "https://gitlab.com/pushrocks/smartdata#README",
   "dependencies": {
-    "@types/mongodb": "^2.1.32",
-    "@types/q": "0.0.30",
-    "beautylog": "^5.0.23",
-    "mongodb": "^2.2.9",
-    "q": "^1.4.1",
-    "typings-global": "^1.0.14"
+    "@push.rocks/lik": "^6.0.2",
+    "@push.rocks/smartdelay": "^3.0.1",
+    "@push.rocks/smartlog": "^3.0.2",
+    "@push.rocks/smartmongo": "^2.0.10",
+    "@push.rocks/smartpromise": "^4.0.2",
+    "@push.rocks/smartrx": "^3.0.6",
+    "@push.rocks/smartstring": "^4.0.7",
+    "@push.rocks/smarttime": "^4.0.1",
+    "@push.rocks/smartunique": "^3.0.3",
+    "@push.rocks/taskbuffer": "^3.1.2",
+    "@tsclass/tsclass": "^4.0.42",
+    "mongodb": "^5.7.0"
   },
   "devDependencies": {
-    "@types/shelljs": "^0.3.30",
-    "@types/should": "^8.1.29",
-    "shelljs": "^0.7.4",
-    "should": "^11.1.0",
-    "smartstring": "^2.0.17",
-    "typings-test": "^1.0.3"
-  }
+    "@gitzone/tsbuild": "^2.1.66",
+    "@gitzone/tsrun": "^1.2.44",
+    "@gitzone/tstest": "^1.0.77",
+    "@push.rocks/qenv": "^6.0.2",
+    "@push.rocks/tapbundle": "^5.0.15",
+    "@types/node": "^20.4.10",
+    "@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"
+  ]
 }

qenv.yml

@@ -0,0 +1 @@
+required:

readme.md

@@ -0,0 +1,154 @@
+# @push.rocks/smartdata
+do more with data
+
+## Availabililty and Links
+* [npmjs.org (npm package)](https://www.npmjs.com/package/@push.rocks/smartdata)
+* [gitlab.com (source)](https://gitlab.com/push.rocks/smartdata)
+* [github.com (source mirror)](https://github.com/push.rocks/smartdata)
+* [docs (typedoc)](https://push.rocks.gitlab.io/smartdata/)
+
+## Status for master
+
+Status Category | Status Badge
+-- | --
+GitLab Pipelines | [![pipeline status](https://gitlab.com/push.rocks/smartdata/badges/master/pipeline.svg)](https://lossless.cloud)
+GitLab Pipline Test Coverage | [![coverage report](https://gitlab.com/push.rocks/smartdata/badges/master/coverage.svg)](https://lossless.cloud)
+npm | [![npm downloads per month](https://badgen.net/npm/dy/@push.rocks/smartdata)](https://lossless.cloud)
+Snyk | [![Known Vulnerabilities](https://badgen.net/snyk/push.rocks/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/@push.rocks/smartdata)](https://lossless.cloud)
+PackagePhobia (package size on registry) | [![PackagePhobia](https://badgen.net/packagephobia/publish/@push.rocks/smartdata)](https://lossless.cloud)
+BundlePhobia (total size when bundled) | [![BundlePhobia](https://badgen.net/bundlephobia/minzip/@push.rocks/smartdata)](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.
+
+## Legal
+> MIT licensed | **&copy;** [Task Venture Capital GmbH](https://task.vc)
+| By using this npm module you agree to our [privacy policy](https://lossless.gmbH/privacy)

test/test.d.ts

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

test/test.distributedcoordinator.ts

@@ -0,0 +1,104 @@
+import { tap, expect } from '@push.rocks/tapbundle';
+import * as smartmongo from '@push.rocks/smartmongo';
+import type * as taskbuffer from '@push.rocks/taskbuffer';
+
+import * as smartdata from '../ts/index.js';
+import { SmartdataDistributedCoordinator, DistributedClass } from '../ts/smartdata.classes.distributedcoordinator.js'; // path might need adjusting
+const totalInstances = 10;
+
+// =======================================
+// 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.test('should instantiate DistributedClass', async (tools) => {
+    const instance = new DistributedClass();
+    expect(instance).toBeInstanceOf(DistributedClass);
+});
+
+tap.test('DistributedClass should update the time', async (tools) => {
+    const distributedCoordinator = new SmartdataDistributedCoordinator(testDb);
+    await distributedCoordinator.start();
+    console.log('test: started');
+    const initialTime = distributedCoordinator.ownInstance.data.lastUpdated;
+    await distributedCoordinator.sendHeartbeat();
+    console.log('test: sent heartbeat');
+    const updatedTime = distributedCoordinator.ownInstance.data.lastUpdated;
+    expect(updatedTime).toBeGreaterThan(initialTime);
+    await distributedCoordinator.stop();
+});
+
+tap.test('should instantiate SmartdataDistributedCoordinator', async (tools) => {
+    const coordinator = new SmartdataDistributedCoordinator(testDb);
+    await coordinator.start();
+    expect(coordinator).toBeInstanceOf(SmartdataDistributedCoordinator);
+    await coordinator.stop();
+});
+
+tap.test('SmartdataDistributedCoordinator should update leader status', async (tools) => {
+    const coordinator = new SmartdataDistributedCoordinator(testDb);
+    await coordinator.start();
+    await coordinator.checkAndMaybeLead();
+    expect(coordinator.ownInstance.data.elected).toBeOneOf([true, false]);
+    await coordinator.stop();
+    process.exit(0);
+});
+
+tap.test('SmartdataDistributedCoordinator should handle distributed task requests', async (tools) => {
+    const coordinator = new SmartdataDistributedCoordinator(testDb);
+    await coordinator.start();
+
+    const mockTaskRequest: taskbuffer.distributedCoordination.IDistributedTaskRequest = {
+        submitterId: "mockSubmitter12345",    // Some unique mock submitter ID
+        taskName: "SampleTask",
+        taskVersion: "1.0.0",                  // Assuming it's a version string
+        taskExecutionTime: Date.now(),
+        taskExecutionTimeout: 60000,           // Let's say the timeout is 1 minute (60000 ms)
+        taskExecutionParallel: 5,              // Let's assume max 5 parallel executions
+        status: 'requesting'
+    };
+
+    const response = await coordinator.fireDistributedTaskRequest(mockTaskRequest);
+    expect(response).toBeTruthy();  // based on your expected structure for the response
+    await coordinator.stop();
+});
+
+tap.test('SmartdataDistributedCoordinator should update distributed task requests', async (tools) => {
+    const coordinator = new SmartdataDistributedCoordinator(testDb);
+    
+    await coordinator.start();
+
+    const mockTaskRequest: taskbuffer.distributedCoordination.IDistributedTaskRequest = {
+        submitterId: "mockSubmitter12345",    // Some unique mock submitter ID
+        taskName: "SampleTask",
+        taskVersion: "1.0.0",                  // Assuming it's a version string
+        taskExecutionTime: Date.now(),
+        taskExecutionTimeout: 60000,           // Let's say the timeout is 1 minute (60000 ms)
+        taskExecutionParallel: 5,              // Let's assume max 5 parallel executions
+        status: 'requesting'
+    };
+    
+
+    await coordinator.updateDistributedTaskRequest(mockTaskRequest);
+    // Here, we can potentially check if a DB entry got updated or some other side-effect of the update method.
+});
+
+tap.test('should elect only one leader amongst multiple instances', async (tools) => {
+    const coordinators = Array.from({ length: totalInstances }).map(() => new SmartdataDistributedCoordinator(testDb));
+    await Promise.all(coordinators.map(coordinator => coordinator.init()));
+
+    await Promise.all(coordinators.map(coordinator => coordinator.checkAndMaybeLead()));
+
+    const leaders = coordinators.filter(coordinator => coordinator.ownInstance.data.elected);
+    expect(leaders.length).toEqual(1);
+});
+
+tap.start({ throwOnError: true });

test/test.easystore.ts

@@ -0,0 +1,55 @@
+import { tap, expect } from '@push.rocks/tapbundle';
+import { Qenv } from '@push.rocks/qenv';
+import * as smartmongo from '@push.rocks/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();

test/test.js

@@ -1,79 +0,0 @@
-"use strict";
-require('typings-test');
-const shelljs = require('shelljs');
-const should = require('should');
-const smartstring = require('smartstring');
-// the tested module
-const smartdata = require('../dist/index');
-let mongoChildProcess;
-let testDb;
-let testDbCollection;
-class testCar {
-    constructor(colorArg) {
-        this.color = colorArg;
-    }
-}
-describe('mongodb', function () {
-    it('should start mongodb', function (done) {
-        this.timeout(30000);
-        mongoChildProcess = shelljs.exec('mongod --dbpath=./test/data --port 27017', { async: true, silent: true });
-        let doneCalled = false;
-        mongoChildProcess.stdout.on('data', function (data) {
-            console.log(smartstring.indent.indentWithPrefix(data, "*** MongoDB Process *** : "));
-            if (!doneCalled) {
-                if (/waiting for connections on port 27017/.test(data)) {
-                    doneCalled = true;
-                    done();
-                }
-            }
-        });
-    });
-});
-describe('smartdata', function () {
-    it('should establish a connection to mongodb', function (done) {
-        testDb = new smartdata.Db('mongodb://localhost:27017/smartdata');
-        testDb.connect().then(() => { done(); });
-    });
-    it('should create a collection', function () {
-        testDbCollection = new smartdata.DbCollection('something', testDb);
-    });
-    it('should insert a doc into the collection', function (done) {
-        testDbCollection.insertOne({ value1: 'test' }).then(() => { done(); });
-    });
-    it('should find all docs of testDbCollection', function (done) {
-        testDbCollection.find({}).then((resultArray) => {
-            console.log(resultArray);
-            should(resultArray[0].value1).equal('test');
-            done();
-        });
-    });
-    it('should insert many docs into the collection', function (done) {
-        testDbCollection.insertMany([
-            { value1: 'test2' },
-            { value1: 'test', value2: 3, value3: 'hi' }
-        ]).then(() => { done(); });
-    });
-    it('should find a specified doc', function (done) {
-        testDbCollection.find({ 'value3': { '$exists': true } }).then((resultArray) => {
-            console.log(resultArray);
-            should(resultArray[0].value3).equal('hi');
-            done();
-        }).catch(console.log);
-    });
-    it('should close the db Connection', function () {
-        testDb.close();
-    });
-});
-describe('mongodb', function () {
-    it('should kill mongodb', function (done) {
-        this.timeout(30000);
-        mongoChildProcess.stdout.on('data', function (data) {
-            if (/dbexit:  rc: 0/.test(data)) {
-                done();
-            }
-        });
-        shelljs.exec('mongod --dbpath=./test/data --shutdown');
-        mongoChildProcess.kill('SIGTERM');
-    });
-});
-//# sourceMappingURL=data:application/json;base64,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

test/test.ts

@@ -1,93 +1,223 @@
-import 'typings-test'
+import { tap, expect } from '@push.rocks/tapbundle';
+import { Qenv } from '@push.rocks/qenv';
+import * as smartmongo from '@push.rocks/smartmongo';
+import { smartunique } from '../ts/smartdata.plugins.js';
 
-import * as shelljs from 'shelljs'
-import * as should from 'should'
-import * as smartstring from 'smartstring'
+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 '../dist/index'
+import * as smartdata from '../ts/index.js';
 
-let mongoChildProcess
-let testDb: smartdata.Db
+// =======================================
+// Connecting to the database server
+// =======================================
 
-interface ITestObject1 {
-    value1: string
-    value2?: number
-    value3?: string
-}
+let smartmongoInstance: smartmongo.SmartMongo;
+let testDb: smartdata.SmartdataDb;
 
-let testDbCollection: smartdata.DbCollection<ITestObject1>
+const totalCars = 2000;
 
-class testCar {
-    color: string
-    constructor(colorArg:string) {
-        this.color = colorArg
+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: await testQenv.getEnvVarOnDemand('MONGO_URL'),
+    mongoDbName: databaseName,
+  });
+  await testDb.init();
+});
+
+// =======================================
+// The actual tests
+// =======================================
+
+// ------
+// Collections
+// ------
+
+@smartdata.Collection(() => {
+  return testDb;
+})
+class Car extends smartdata.SmartDataDbDoc<Car, Car> {
+  @smartdata.unI()
+  public index: string = smartunique.shortId();
+
+  @smartdata.svDb()
+  public color: string;
+
+  @smartdata.svDb()
+  public brand: string;
+
+  @smartdata.svDb()
+  public testBuffer = Buffer.from('hello');
+
+  @smartdata.svDb()
+  deepData = {
+    sodeep: 'yes',
+  };
+
+  constructor(colorArg: string, brandArg: string) {
+    super();
+    this.color = colorArg;
+    this.brand = brandArg;
   }
 }
 
+tap.test('should save the car to the db', async (toolsArg) => {
+  const myCar = new Car('red', 'Volvo');
+  await myCar.save();
 
-describe('mongodb', function () {
-    it('should start mongodb', function (done) {
-        this.timeout(30000)
-        mongoChildProcess = shelljs.exec('mongod --dbpath=./test/data --port 27017', { async: true, silent: true })
-        let doneCalled = false
-        mongoChildProcess.stdout.on('data', function (data) {
-            console.log(smartstring.indent.indentWithPrefix(data, "*** MongoDB Process *** : "))
-            if (!doneCalled) {
-                if (/waiting for connections on port 27017/.test(data)) {
-                    doneCalled = true
-                    done()
+  const myCar2 = new Car('red', 'Volvo');
+  await myCar2.save();
+
+  let counter = 0;
+
+  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('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;
   }
 }
-        })
-    })
-})
 
-describe('smartdata', function () {
-    it('should establish a connection to mongodb', function (done) {
-        testDb = new smartdata.Db('mongodb://localhost:27017/smartdata')
-        testDb.connect().then(() => { done() })
-    })
-    it('should create a collection', function () {
-        testDbCollection = new smartdata.DbCollection<ITestObject1>('something', testDb)
-    })
-    it('should insert a doc into the collection', function (done) {
-        testDbCollection.insertOne({ value1: 'test' }).then(() => { done() })
-    })
-    it('should find all docs of testDbCollection', function (done) {
-        testDbCollection.find({}).then((resultArray) => {
-            console.log(resultArray)
-            should(resultArray[0].value1).equal('test')
-            done()
-        })
-    })
-    it('should insert many docs into the collection', function (done) {
-        testDbCollection.insertMany([
-            { value1: 'test2' },
-            { value1: 'test', value2: 3, value3: 'hi' }
-        ]).then(() => { done() })
-    })
-    it('should find a specified doc', function (done) {
-        testDbCollection.find({'value3': {'$exists': true}}).then((resultArray) => {
-            console.log(resultArray)
-            should(resultArray[0].value3).equal('hi')
-            done()
-        }).catch(console.log)
-    })
-    it('should close the db Connection', function () {
-        testDb.close()
-    })
-})
+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);
+});
 
-describe('mongodb', function () {
-    it('should kill mongodb', function (done) {
-        this.timeout(30000)
-        mongoChildProcess.stdout.on('data', function (data) {
-            if (/dbexit:  rc: 0/.test(data)) {
-                done()
+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;
+  });
+});
+
+// =======================================
+// close the database connection
+// =======================================
+tap.test('close', async () => {
+  await testDb.mongoDb.dropDatabase();
+  await testDb.close();
+  if (smartmongoInstance) {
+    await smartmongoInstance.stop();
   }
-        })
-        shelljs.exec('mongod --dbpath=./test/data --shutdown')
-        mongoChildProcess.kill('SIGTERM')
-    })
-})
+});
+
+tap.start({ throwOnError: true });

test/test.typescript.ts

@@ -0,0 +1,95 @@
+import { tap, expect } from '@push.rocks/tapbundle';
+import { Qenv } from '@push.rocks/qenv';
+import * as smartmongo from '@push.rocks/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: await 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 });

test/test.watch.ts

@@ -0,0 +1,74 @@
+import { tap, expect } from '@push.rocks/tapbundle';
+import { Qenv } from '@push.rocks/qenv';
+import * as smartmongo from '@push.rocks/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 });

ts/00_commitinfo_data.ts

@@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @pushrocks/commitinfo
+ */
+export const commitinfo = {
+  name: '@push.rocks/smartdata',
+  version: '5.0.26',
+  description: 'do more with data'
+}

ts/index.ts

@@ -1,4 +1,14 @@
-import * as plugins from './smartdata.plugins'
+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';
 
-export * from './smartdata.classes.dbcollection'
-export * from './smartdata.classes.db'
+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 };

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);
+};

ts/smartdata.classes.collection.ts

@@ -0,0 +1,284 @@
+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;
+}
+
+/**
+ *
+ */
+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 dbArg
+ */
+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;
+      }
+    };
+  };
+}
+
+export class SmartdataCollection<T> {
+  /**
+   * the collection that is used
+   */
+  public mongoDbCollection: plugins.mongodb.Collection;
+  public objectValidation: IDocValidationFunc<T> = null;
+  public collectionName: string;
+  public smartdataDb: SmartdataDb;
+  public uniqueIndexes: string[] = [];
+
+  constructor(classNameArg: string, smartDataDbArg: SmartdataDb) {
+    // tell the collection where it belongs
+    this.collectionName = classNameArg;
+    this.smartdataDb = smartDataDbArg;
+
+    // tell the db class about it (important since Db uses different systems under the hood)
+    this.smartdataDb.addCollection(this);
+  }
+
+  /**
+   * makes sure a collection exists within MongoDb that maps to the SmartdataCollection
+   */
+  public async init() {
+    if (!this.mongoDbCollection) {
+      // connect this instance to a MongoDB collection
+      const availableMongoDbCollections = await this.smartdataDb.mongoDb.collections();
+      const wantedCollection = availableMongoDbCollections.find((collection) => {
+        return collection.collectionName === this.collectionName;
+      });
+      if (!wantedCollection) {
+        await this.smartdataDb.mongoDb.createCollection(this.collectionName);
+        console.log(`Successfully initiated Collection ${this.collectionName}`);
+      }
+      this.mongoDbCollection = this.smartdataDb.mongoDb.collection(this.collectionName);
+    }
+  }
+
+  /**
+   * mark unique index
+   */
+  public markUniqueIndexes(keyArrayArg: string[] = []) {
+    for (const key of keyArrayArg) {
+      if (!this.uniqueIndexes.includes(key)) {
+        this.mongoDbCollection.createIndex(key, {
+          unique: true,
+        });
+        // make sure we only call this once and not for every doc we create
+        this.uniqueIndexes.push(key);
+      }
+    }
+  }
+
+  /**
+   * adds a validation function that all newly inserted and updated objects have to pass
+   */
+  public addDocValidation(funcArg: IDocValidationFunc<T>) {
+    this.objectValidation = funcArg;
+  }
+
+  /**
+   * finds an object in the DbCollection
+   */
+  public async findOne(filterObject: any): Promise<any> {
+    await this.init();
+    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
+   */
+  public async insert(dbDocArg: T & SmartDataDbDoc<T, unknown>): Promise<any> {
+    await this.init();
+    await this.checkDoc(dbDocArg);
+    this.markUniqueIndexes(dbDocArg.uniqueIndexes);
+    const saveableObject = await dbDocArg.createSavableObject();
+    const result = await this.mongoDbCollection.insertOne(saveableObject);
+    return result;
+  }
+
+  /**
+   * inserts object into the DbCollection
+   */
+  public async update(dbDocArg: T & SmartDataDbDoc<T, unknown>): Promise<any> {
+    await this.init();
+    await this.checkDoc(dbDocArg);
+    const identifiableObject = await dbDocArg.createIdentifiableObject();
+    const saveableObject = await dbDocArg.createSavableObject();
+    const updateableObject: any = {};
+    for (const key of Object.keys(saveableObject)) {
+      if (identifiableObject[key]) {
+        continue;
+      }
+      updateableObject[key] = saveableObject[key];
+    }
+    const result = await this.mongoDbCollection.updateOne(
+      identifiableObject,
+      { $set: updateableObject },
+      { upsert: true }
+    );
+    return result;
+  }
+
+  public async delete(dbDocArg: T & SmartDataDbDoc<T, unknown>): Promise<any> {
+    await this.init();
+    await this.checkDoc(dbDocArg);
+    const identifiableObject = await dbDocArg.createIdentifiableObject();
+    await this.mongoDbCollection.deleteOne(identifiableObject);
+  }
+
+  /**
+   * checks a Doc for constraints
+   * if this.objectValidation is not set it passes.
+   */
+  private checkDoc(docArg: T): Promise<void> {
+    const done = plugins.smartq.defer<void>();
+    let validationResult = true;
+    if (this.objectValidation) {
+      validationResult = this.objectValidation(docArg);
+    }
+    if (validationResult) {
+      done.resolve();
+    } else {
+      done.reject('validation of object did not pass');
+    }
+    return done.promise;
+  }
+}

ts/smartdata.classes.collectionfactory.ts

@@ -0,0 +1,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];
+  };
+}

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();
+  }
+}

ts/smartdata.classes.db.ts

@@ -1,33 +1,84 @@
-import * as plugins from './smartdata.plugins'
+import * as plugins from './smartdata.plugins.js';
 
-export type TConnectionStatus = 'disconnected' | 'connected' | 'failed'
+import { SmartdataCollection } from './smartdata.classes.collection.js';
+import { EasyStore } from './smartdata.classes.easystore.js';
 
-export class Db {
-    dbUrl: string
-    db: plugins.mongodb.Db
-    status: TConnectionStatus
+import { logger } from './smartdata.logging.js';
 
-    constructor(dbUrl: string) {
-        this.dbUrl = dbUrl
+/**
+ * interface - indicates the connection status of the db
+ */
+export type TConnectionStatus = 'initial' | 'disconnected' | 'connected' | 'failed';
+
+export class SmartdataDb {
+  smartdataOptions: plugins.tsclass.database.IMongoDescriptor;
+  mongoDbClient: plugins.mongodb.MongoClient;
+  mongoDb: plugins.mongodb.Db;
+  status: TConnectionStatus;
+  statusConnectedDeferred = plugins.smartpromise.defer();
+  smartdataCollectionMap = new plugins.lik.ObjectMap<SmartdataCollection<any>>();
+
+  constructor(smartdataOptions: plugins.tsclass.database.IMongoDescriptor) {
+    this.smartdataOptions = smartdataOptions;
+    this.status = 'initial';
   }
 
-    connect(): plugins.q.Promise<any> {
-        let done = plugins.q.defer()
-        plugins.mongodb.MongoClient.connect(this.dbUrl, (err, db) => {
-            if (err) { console.log(err) }
-            plugins.assert.equal(null, err)
-            this.db = db
-            plugins.beautylog.success(`connected to database at ${this.dbUrl}`)
-            done.resolve(this.db)
-        })
-        return done.promise
+  // easystore
+  public async createEasyStore(nameIdArg: string) {
+    const easyStore = new EasyStore(nameIdArg, this);
+    return easyStore;
   }
 
-    close(): plugins.q.Promise<any> {
-        let done = plugins.q.defer()
-        this.db.close()
-        plugins.beautylog.ok(`disconnected to database at ${this.dbUrl}`)
-        done.resolve()
-        return done.promise
+  // basic connection stuff ----------------------------------------------
+
+  /**
+   * connects to the database that was specified during instance creation
+   */
+  public async init(): Promise<any> {
+    const finalConnectionUrl = this.smartdataOptions.mongoDbUrl
+      .replace('<USERNAME>', this.smartdataOptions.mongoDbUser)
+      .replace('<username>', this.smartdataOptions.mongoDbUser)
+      .replace('<USER>', this.smartdataOptions.mongoDbUser)
+      .replace('<user>', this.smartdataOptions.mongoDbUser)
+      .replace('<PASSWORD>', this.smartdataOptions.mongoDbPass)
+      .replace('<password>', this.smartdataOptions.mongoDbPass)
+      .replace('<DBNAME>', this.smartdataOptions.mongoDbName)
+      .replace('<dbname>', this.smartdataOptions.mongoDbName);
+
+    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
+   */
+  public async close(): Promise<any> {
+    await this.mongoDbClient.close();
+    this.status = 'disconnected';
+    logger.log('info', `disconnected from database ${this.smartdataOptions.mongoDbName}`);
+  }
+
+  // handle table to class distribution
+
+  public addCollection(SmartdataCollectionArg: SmartdataCollection<any>) {
+    this.smartdataCollectionMap.add(SmartdataCollectionArg);
+  }
+
+  /**
+   * Gets a collection's name and returns a SmartdataCollection instance
+   * @param nameArg
+   * @returns DbTable
+   */
+  public async getSmartdataCollectionByName<T>(nameArg: string): Promise<SmartdataCollection<T>> {
+    const resultCollection = await this.smartdataCollectionMap.find(async (dbTableArg) => {
+      return dbTableArg.collectionName === nameArg;
+    });
+    return resultCollection;
   }
 }

ts/smartdata.classes.dbcollection.ts

@@ -1,60 +0,0 @@
-import * as plugins from './smartdata.plugins'
-import { Db } from './smartdata.classes.db'
-
-export class DbCollection<T> {
-    collection: plugins.mongodb.Collection
-    constructor(nameArg: string, dbArg: Db) {
-        this.collection = dbArg.db.collection(nameArg)
-    }
-
-    /**
-     * adds a validation function that all newly inserted and updated objects have to pass
-     */
-    addObjectValidation(funcArg) { }
-
-    /**
-     * finds an object in the DbCollection
-     */
-    find(docMatchArg: T | any): plugins.q.Promise<T[]> {
-        let done = plugins.q.defer<T[]>()
-        this.collection.find(docMatchArg).toArray((err, docs) => {
-            if (err) { throw err }
-            done.resolve(docs)
-        })
-        return done.promise
-    }
-
-    /**
-     * inserts  object into the DbCollection
-     */
-    insertOne(docArg: T): plugins.q.Promise<void> {
-        let done = plugins.q.defer<void>()
-        this.checkDoc(docArg).then(() => {
-            this.collection.insertOne(docArg)
-                .then(() => { done.resolve() })
-        })
-        return done.promise
-    }
-
-    /**
-     * inserts many objects at once into the DbCollection
-     */
-    insertMany(docArrayArg: T[]): plugins.q.Promise<void> {
-        let done = plugins.q.defer<void>()
-        let checkDocPromiseArray: plugins.q.Promise<void>[] = []
-        for (let docArg of docArrayArg){
-            checkDocPromiseArray.push(this.checkDoc(docArg))
-        }
-        plugins.q.all(checkDocPromiseArray).then(() => {
-            this.collection.insertMany(docArrayArg)
-                .then(() => { done.resolve() })
-        })
-        return done.promise
-    }
-
-    private checkDoc(doc: T): plugins.q.Promise<void> {
-        let done = plugins.q.defer<void>()
-        done.resolve()
-        return done.promise
-    }
-}

ts/smartdata.classes.distributedcoordinator.ts

@@ -0,0 +1,204 @@
+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()
+export 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();
+  public ownInstance: DistributedClass;
+
+  constructor(dbArg: SmartdataDb) {
+    super();
+    this.db = dbArg;
+    setDefaultManagerForDoc(this, DistributedClass);
+    this.readyPromise = this.db.statusConnectedDeferred.promise;
+  }
+
+  // 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.sendHeartbeat();
+      await plugins.smartdelay.delayFor(10000);
+    }
+  };
+
+  public async sendHeartbeat() {
+    await this.asyncExecutionStack.getExclusiveExecutionSlot(async () => {
+      await this.ownInstance.updateFromDb();
+      this.ownInstance.data.lastUpdated = Date.now();
+      await this.ownInstance.save();
+    });
+  }
+  private 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();
+        });
+      });
+    });
+  }
+}

ts/smartdata.classes.doc.ts

@@ -0,0 +1,287 @@
+import * as plugins from './smartdata.plugins.js';
+
+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';
+
+/**
+ * saveable - saveable decorator to be used on class properties
+ */
+export function svDb() {
+  return (target: SmartDataDbDoc<unknown, unknown>, key: string) => {
+    console.log(`called svDb() on >${target.constructor.name}.${key}<`);
+    if (!target.saveableProperties) {
+      target.saveableProperties = [];
+    }
+    target.saveableProperties.push(key);
+  };
+}
+
+/**
+ * unique index - decorator to mark a unique index
+ */
+export function unI() {
+  return (target: SmartDataDbDoc<unknown, unknown>, key: string) => {
+    console.log(`called unI on >>${target.constructor.name}.${key}<<`);
+
+    // mark the index as unique
+    if (!target.uniqueIndexes) {
+      target.uniqueIndexes = [];
+    }
+    target.uniqueIndexes.push(key);
+
+    // and also save it
+    if (!target.saveableProperties) {
+      target.saveableProperties = [];
+    }
+    target.saveableProperties.push(key);
+  };
+}
+
+export 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
+   */
+  public static collection: SmartdataCollection<any>;
+  public collection: SmartdataCollection<any>;
+  public static defaultManager;
+  public static manager;
+  public manager: TManager;
+
+  // 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;
+  }
+
+  /**
+   * 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 (const foundDoc of foundDocs) {
+      const newInstance: T = (this as any).createInstanceFromMongoDbNativeDoc(foundDoc);
+      returnArray.push(newInstance);
+    }
+    return returnArray;
+  }
+
+  /**
+   * 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
+   */
+  public async save() {
+    // tslint:disable-next-line: no-this-assignment
+    const self: any = this;
+    let dbResult: any;
+    switch (this.creationStatus) {
+      case 'db':
+        dbResult = await this.collection.update(self);
+        break;
+      case 'new':
+        dbResult = await this.collection.insert(self);
+        this.creationStatus = 'db';
+        break;
+      default:
+        console.error('neither new nor in db?');
+    }
+    return dbResult;
+  }
+
+  /**
+   * deletes a document from the database
+   */
+  public async delete() {
+    await this.collection.delete(this);
+  }
+
+  /**
+   * also store any referenced objects to DB
+   * better for data consistency
+   */
+  public saveDeep(savedMapArg: plugins.lik.ObjectMap<SmartDataDbDoc<any, any>> = null) {
+    if (!savedMapArg) {
+      savedMapArg = new plugins.lik.ObjectMap<SmartDataDbDoc<any, any>>();
+    }
+    savedMapArg.add(this);
+    this.save();
+    for (const propertyKey of Object.keys(this)) {
+      const property: any = this[propertyKey];
+      if (property instanceof SmartDataDbDoc && !savedMapArg.checkForObject(property)) {
+        property.saveDeep(savedMapArg);
+      }
+    }
+  }
+
+  /**
+   * 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 as TImplements;
+  }
+
+  /**
+   * creates an identifiable object for operations that require filtering
+   */
+  public async createIdentifiableObject() {
+    const identifiableObject: any = {}; // is not exposed to outside, so any is ok here
+    for (const propertyNameString of this.uniqueIndexes) {
+      identifiableObject[propertyNameString] = this[propertyNameString];
+    }
+    return identifiableObject;
+  }
+}

ts/smartdata.classes.easystore.ts

@@ -0,0 +1,109 @@
+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'
+    ) {}
+  }
+}

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();
+  }
+}

ts/smartdata.logging.ts

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

ts/smartdata.plugins.ts

@@ -1,5 +1,31 @@
-import 'typings-global'
-export import assert = require('assert')
-export import beautylog = require('beautylog')
-export import mongodb = require('mongodb')
-export import q = require('q')
+// tsclass scope
+import * as tsclass from '@tsclass/tsclass';
+
+export { tsclass };
+
+// @pushrocks scope
+import * as lik from '@push.rocks/lik';
+import * as smartdelay from '@push.rocks/smartdelay';
+import * as smartlog from '@push.rocks/smartlog';
+import * as smartpromise from '@push.rocks/smartpromise';
+import * as smartq from '@push.rocks/smartpromise';
+import * as smartrx from '@push.rocks/smartrx';
+import * as smartstring from '@push.rocks/smartstring';
+import * as smarttime from '@push.rocks/smarttime';
+import * as smartunique from '@push.rocks/smartunique';
+import * as taskbuffer from '@push.rocks/taskbuffer';
+import * as mongodb from 'mongodb';
+
+export {
+  lik,
+  smartdelay,
+  smartpromise,
+  smartlog,
+  smartq,
+  smartrx,
+  mongodb,
+  smartstring,
+  smarttime,
+  smartunique,
+  taskbuffer,
+};

tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "compilerOptions": {
+    "experimentalDecorators": true,
+    "useDefineForClassFields": false,
+    "target": "ES2022",
+    "module": "ES2022",
+    "moduleResolution": "nodenext"
+  }
+}

tslint.json

@@ -1,3 +0,0 @@
-{
-    "extends": "tslint-config-standard"
-}