5.3.0

feat(docs): Enhance documentation with updated installation instructions and comprehensive usage examples covering advanced features such as deep queries, automatic indexing, and distributed coordination.
5.2.12
2025-03-10 23:55:45 +00:00 · 2025-03-10 23:55:44 +00:00 · 2025-02-03 14:06:42 +01:00 · 2025-02-03 14:06:42 +01:00 · 2025-02-03 14:03:04 +01:00 · 2025-02-03 14:03:03 +01:00
26 changed files with 4055 additions and 2119 deletions
--- a/.gitea/workflows/default_nottags.yaml
+++ b/.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
--- a/.gitea/workflows/default_tags.yaml
+++ b/.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
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@ -1,128 +0,0 @@
-# gitzone ci_default
-image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
-
-cache:
-  paths:
-    - .npmci_cache/
-  key: '$CI_BUILD_STAGE'
-
-stages:
-  - security
-  - test
-  - release
-  - metadata
-
-before_script:
-  - pnpm install -g pnpm
-  - pnpm install -g @shipzone/npmci
-  - npmci npm prepare
-
-# ====================
-# security stage
-# ====================
-# ====================
-# security stage
-# ====================
-auditProductionDependencies:
-  image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
-  stage: security
-  script:
-     - npmci command npm config set registry https://registry.npmjs.org
-     - npmci command pnpm audit --audit-level=high --prod
-  tags:
-    - lossless
-    - docker
-  allow_failure: true
-
-auditDevDependencies:
-  image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
-  stage: security
-  script:
-    - npmci command npm config set registry https://registry.npmjs.org
-    - npmci command pnpm audit --audit-level=high --dev
-  tags:
-    - lossless
-    - docker
-  allow_failure: true
-
-# ====================
-# test stage
-# ====================
-
-testStable:
-  stage: test
-  script:
-    - npmci node install stable
-    - npmci npm install
-    - npmci npm test
-  coverage: /\d+.?\d+?\%\s*coverage/
-  tags:
-    - docker
-
-testBuild:
-  stage: test
-  script:
-    - npmci node install stable
-    - npmci npm install
-    - npmci command npm run build
-  coverage: /\d+.?\d+?\%\s*coverage/
-  tags:
-    - docker
-
-release:
-  stage: release
-  script:
-    - npmci node install stable
-    - npmci npm publish
-  only:
-    - tags
-  tags:
-    - lossless
-    - docker
-    - notpriv
-
-# ====================
-# metadata stage
-# ====================
-codequality:
-  stage: metadata
-  allow_failure: true
-  only:
-    - tags
-  script:
-    - npmci command npm install -g typescript
-    - npmci npm prepare
-    - npmci npm install
-  tags:
-    - lossless
-    - docker
-    - priv
-
-trigger:
-  stage: metadata
-  script:
-    - npmci trigger
-  only:
-    - tags
-  tags:
-    - lossless
-    - docker
-    - notpriv
-
-pages:
-  stage: metadata
-  script:
-    - npmci node install stable
-    - npmci npm install
-    - npmci command npm run buildDocs
-  tags:
-    - lossless
-    - docker
-    - notpriv
-  only:
-    - tags
-  artifacts:
-    expire_in: 1 week
-    paths:
-      - public
-  allow_failure: true
--- a/changelog.md
+++ b/changelog.md
@ -0,0 +1,179 @@
+# Changelog
+
+## 2025-03-10 - 5.3.0 - feat(docs)
+Enhance documentation with updated installation instructions and comprehensive usage examples covering advanced features such as deep queries, automatic indexing, and distributed coordination.
+
+- Added pnpm installation command
+- Updated User model example to include ObjectId, Binary, and custom serialization
+- Expanded CRUD operations examples with cursor methods and deep query support
+- Enhanced sections on EasyStore, real-time data watching with RxJS integration, and managed collections
+- Included detailed examples for transactions, deep object queries, and document lifecycle hooks
+
+## 2025-02-03 - 5.2.12 - fix(documentation)
+Remove license badge from README
+
+- Removed the license badge from the README file, ensuring compliance with branding guidelines.
+
+## 2025-02-03 - 5.2.11 - fix(documentation)
+Updated project documentation for accuracy and added advanced feature details
+
+- Added details for EasyStore, Distributed Coordination, and Real-time Data Watching features.
+- Updated database connection setup instructions to include user authentication.
+- Re-organized advanced usage section to showcase additional features separately.
+
+## 2024-09-05 - 5.2.10 - fix(smartdata.classes.doc)
+Fix issue with array handling in convertFilterForMongoDb function
+
+- Corrected the logic to properly handle array filters in the convertFilterForMongoDb function to avoid incorrect assignments.
+
+## 2024-09-05 - 5.2.9 - fix(smartdata.classes.doc)
+Fixed issue with convertFilterForMongoDb to handle array operators.
+
+- Updated the convertFilterForMongoDb function in smartdata.classes.doc.ts to properly handle array operators like $in and $all.
+
+## 2024-09-05 - 5.2.8 - fix(smartdata.classes.doc)
+Fix key handling in convertFilterForMongoDb function
+
+- Fixed an issue in convertFilterForMongoDb that allowed keys with dots which could cause errors.
+
+## 2024-09-05 - 5.2.7 - fix(core)
+Fixed issue with handling filter keys containing dots in smartdata.classes.doc.ts
+
+- Fixed an error in the convertFilterForMongoDb function which previously threw an error when keys contained dots.
+
+## 2024-06-18 - 5.2.6 - Chore
+Maintenance Release
+
+- Release version 5.2.6
+
+## 2024-05-31 - 5.2.2 - Bug Fixes
+Fixes and Maintenance
+
+- Fixed issue where `_createdAt` and `_updatedAt` registered saveableProperties for all document types
+
+## 2024-04-15 - 5.1.2 - New Feature
+Enhancements and Bug Fixes
+
+- Added static `.getCount({})` method to `SmartDataDbDoc`
+- Changed fields `_createdAt` and `_updatedAt` to ISO format
+
+## 2024-04-14 - 5.0.43 - New Feature
+New Feature Addition
+
+- Added default `_createdAt` and `_updatedAt` fields, fixes #1
+
+## 2024-03-30 - 5.0.41 - Bug Fixes
+Improvements and Fixes
+
+- Improved `tsconfig.json` for ES Module use
+
+## 2023-07-10 - 5.0.20 - Chore
+Organizational Changes
+
+- Switched to new org scheme
+
+## 2023-07-21 - 5.0.21 to 5.0.26 - Fixes
+Multiple Fix Releases
+
+- Various core updates and bug fixes
+
+## 2023-07-21 - 5.0.20 - Chore
+Organizational Changes
+
+- Switch to the new org scheme
+
+## 2023-06-25 - 5.0.14 to 5.0.19 - Fixes
+Multiple Fix Releases
+
+- Various core updates and bug fixes
+
+## 2022-05-17 - 5.0.0 - Major Update
+Breaking Changes
+
+- Switched to ESM
+
+## 2022-05-18 - 5.0.2 - Bug Fixes
+Bug Fixes
+
+- The `watcher.changeSubject` now emits the correct type into observer functions
+
+## 2022-05-17 - 5.0.1 - Chore
+Testing Improvements
+
+- Tests now use `@pushrocks/smartmongo` backed by `wiredTiger`
+
+## 2022-05-17 to 2022-11-08 - 5.0.8 to 5.0.10
+Multiple Fix Releases
+
+- Various core updates and bug fixes
+
+## 2021-11-12 - 4.0.17 to 4.0.20
+Multiple Fix Releases
+
+- Various core updates and bug fixes
+
+## 2021-09-17 - 4.0.10 to 4.0.16
+Multiple Fix Releases
+
+- Various core updates and bug fixes
+
+## 2021-06-09 - 4.0.1 to 4.0.9
+Multiple Fix Releases
+
+- Various core updates and bug fixes
+
+## 2021-06-06 - 4.0.0 - Major Update
+Major Release
+
+- Maintenance and core updates
+
+## 2021-05-17 - 3.1.56 - Chore
+Maintenance Release
+
+- Release version 3.1.56
+
+## 2020-09-09 - 3.1.44 to 3.1.52
+Multiple Fix Releases
+
+- Various core updates and bug fixes
+
+## 2020-06-12 - 3.1.26 to 3.1.28
+Multiple Fix Releases
+
+- Various core updates and bug fixes
+
+## 2020-02-18 - 3.1.23 to 3.1.25
+Multiple Fix Releases
+
+- Various core updates and bug fixes
+
+## 2019-09-11 - 3.1.20 to 3.1.22
+Multiple Fix Releases
+
+- Various core updates and bug fixes
+
+## 2018-07-10 - 3.0.5 - New Feature
+Added Feature
+
+- Added custom unique indexes to `SmartdataDoc`
+
+## 2018-07-08 - 3.0.1 - Chore
+Dependencies Update
+
+- Updated mongodb dependencies
+
+## 2018-07-08 - 3.0.0 - Major Update
+Refactor and Cleanup
+
+- Cleaned project structure
+
+## 2018-01-16 - 2.0.7 - Breaking Change
+Big Changes
+
+- Switched to `@pushrocks` scope and moved from `rethinkdb` to `mongodb`
+
+## 2018-01-12 - 2.0.0 - Major Release
+Core Updates
+
+- Updated CI configurations
+
--- a/npmextra.json
+++ b/npmextra.json
@ -12,12 +12,25 @@
  "gitzone": {
    "projectType": "npm",
    "module": {
-      "githost": "gitlab.com",
-      "gitscope": "pushrocks",
+      "githost": "code.foss.global",
+      "gitscope": "push.rocks",
      "gitrepo": "smartdata",
-      "description": "do more with data",
-      "npmPackagename": "@pushrocks/smartdata",
-      "license": "MIT"
-    }
+      "description": "An advanced library for NoSQL data organization and manipulation using TypeScript with support for MongoDB, data validation, collections, and custom data types.",
+      "npmPackagename": "@push.rocks/smartdata",
+      "license": "MIT",
+      "keywords": [
+        "data manipulation",
+        "NoSQL",
+        "MongoDB",
+        "TypeScript",
+        "data validation",
+        "collections",
+        "custom data types",
+        "ODM"
+      ]
+    }
+  },
+  "tsdoc": {
+    "legal": "\n## License and Legal Information\n\nThis repository contains open-source code that is licensed under the MIT License. A copy of the MIT License can be found in the [license](license) file within this repository. \n\n**Please note:** The MIT License does not grant permission to use the trade names, trademarks, service marks, or product names of the project, except as required for reasonable and customary use in describing the origin of the work and reproducing the content of the NOTICE file.\n\n### Trademarks\n\nThis project is owned and maintained by Task Venture Capital GmbH. The names and logos associated with Task Venture Capital GmbH and any related products or services are trademarks of Task Venture Capital GmbH and are not included within the scope of the MIT license granted herein. Use of these trademarks must comply with Task Venture Capital GmbH's Trademark Guidelines, and any usage must be approved in writing by Task Venture Capital GmbH.\n\n### Company Information\n\nTask Venture Capital GmbH  \nRegistered at District court Bremen HRB 35230 HB, Germany\n\nFor any legal inquiries or if you require further information, please contact us via email at hello@task.vc.\n\nBy using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works.\n"
  }
 }
--- a/package.json
+++ b/package.json
@ -1,8 +1,8 @@
 {
-  "name": "@pushrocks/smartdata",
-  "version": "5.0.13",
+  "name": "@push.rocks/smartdata",
+  "version": "5.3.0",
  "private": false,
-  "description": "do more with data",
+  "description": "An advanced library for NoSQL data organization and manipulation using TypeScript with support for MongoDB, data validation, collections, and custom data types.",
  "main": "dist_ts/index.js",
  "typings": "dist_ts/index.d.ts",
  "type": "module",
@ -13,36 +13,35 @@
  },
  "repository": {
    "type": "git",
-    "url": "git+ssh://git@gitlab.com/pushrocks/smartdata.git"
+    "url": "https://code.foss.global/push.rocks/smartdata.git"
  },
  "author": "Lossless GmbH",
  "license": "MIT",
  "bugs": {
    "url": "https://gitlab.com/pushrocks/smartdata/issues"
  },
-  "homepage": "https://gitlab.com/pushrocks/smartdata#README",
+  "homepage": "https://code.foss.global/push.rocks/smartdata",
  "dependencies": {
-    "@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"
+    "@push.rocks/lik": "^6.0.14",
+    "@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.7",
+    "@push.rocks/smartstring": "^4.0.15",
+    "@push.rocks/smarttime": "^4.0.6",
+    "@push.rocks/smartunique": "^3.0.8",
+    "@push.rocks/taskbuffer": "^3.1.7",
+    "@tsclass/tsclass": "^4.0.52",
+    "mongodb": "^6.5.0"
  },
  "devDependencies": {
    "@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"
+    "@gitzone/tsrun": "^1.2.44",
+    "@gitzone/tstest": "^1.0.77",
+    "@push.rocks/qenv": "^6.0.5",
+    "@push.rocks/tapbundle": "^5.0.22",
+    "@types/node": "^20.11.30"
  },
  "files": [
    "ts/**/*",
@ -58,5 +57,15 @@
  ],
  "browserslist": [
    "last 1 chrome versions"
+  ],
+  "keywords": [
+    "data manipulation",
+    "NoSQL",
+    "MongoDB",
+    "TypeScript",
+    "data validation",
+    "collections",
+    "custom data types",
+    "ODM"
  ]
 }
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
--- a/qenv.yml
+++ b/qenv.yml
@ -1,4 +1 @@
 required:
-  - MONGO_URL
-  - MONGO_DBNAME
-  - MONGO_PASS
--- a/readme.hints.md
+++ b/readme.hints.md
--- a/readme.md
+++ b/readme.md
@ -1,156 +1,493 @@
-# @pushrocks/smartdata
-do more with data
+# @push.rocks/smartdata

-## 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/)
+[![npm version](https://badge.fury.io/js/@push.rocks%2Fsmartdata.svg)](https://www.npmjs.com/package/@push.rocks/smartdata)

-## Status for master
+A powerful TypeScript-first MongoDB wrapper that provides advanced features for distributed systems, real-time data synchronization, and easy data management.

-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)
+## Features
+
+- **Type-Safe MongoDB Integration**: Full TypeScript support with decorators for schema definition
+- **Document Management**: Type-safe CRUD operations with automatic timestamp tracking
+- **EasyStore**: Simple key-value storage with automatic persistence and sharing between instances
+- **Distributed Coordination**: Built-in support for leader election and distributed task management
+- **Real-time Data Sync**: Watchers for real-time data changes with RxJS integration
+- **Connection Management**: Automatic connection handling with connection pooling
+- **Collection Management**: Type-safe collection operations with automatic indexing
+- **Deep Query Type Safety**: Fully type-safe queries for nested object properties with `DeepQuery<T>` 
+- **MongoDB Compatibility**: Support for all MongoDB query operators and advanced features
+- **Enhanced Cursors**: Chainable, type-safe cursor API with memory efficient data processing
+- **Type Conversion**: Automatic handling of MongoDB types like ObjectId and Binary data
+- **Serialization Hooks**: Custom serialization and deserialization of document properties
+
+## Requirements
+
+- Node.js >= 16.x
+- MongoDB >= 4.4
+- TypeScript >= 4.x (for development)
+
+## Install
+To install `@push.rocks/smartdata`, use npm:
+
+```bash
+npm install @push.rocks/smartdata --save
+```
+
+Or with pnpm:
+
+```bash
+pnpm add @push.rocks/smartdata
+```

 ## Usage
+`@push.rocks/smartdata` enables efficient data handling and operation management with a focus on using MongoDB. It leverages TypeScript for strong typing and ESM syntax for modern JavaScript 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.
+### Setting Up and Connecting to the Database
+Before interacting with the database, you need to set up and establish a connection. The `SmartdataDb` class handles connection pooling and automatic reconnection.

 ```typescript
-// Assuming toplevel await
-import * as smartdata from 'smartdata';
+import { SmartdataDb } from '@push.rocks/smartdata';

-const smartdataDb = new smartdata.SmartdataDb({
-  mongoDbUrl: '//someurl',
-  mongoDbName: 'myDatabase',
-  mongoDbPass: 'mypassword',
+// Create a new instance of SmartdataDb with MongoDB connection details
+const db = new SmartdataDb({
+  mongoDbUrl: 'mongodb://<USERNAME>:<PASSWORD>@localhost:27017/<DBNAME>',
+  mongoDbName: 'your-database-name',
+  mongoDbUser: 'your-username',
+  mongoDbPass: 'your-password',
 });

-await smartdataDb.connect();
+// Initialize and connect to the database
+// This sets up a connection pool with max 100 connections
+await db.init();
 ```

-### 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
+### Defining Data Models
+Data models in `@push.rocks/smartdata` are classes that represent collections and documents in your MongoDB database. Use decorators such as `@Collection`, `@unI`, and `@svDb` to define your data models.

 ```typescript
-// Assuming toplevel await
-// continues from the block before...
+import { SmartDataDbDoc, Collection, unI, svDb, oid, bin, index } from '@push.rocks/smartdata';
+import { ObjectId } from 'mongodb';

-@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
+@Collection(() => db)  // Associate this model with the database instance
+class User extends SmartDataDbDoc<User, User> {
+  @unI()
+  public id: string = 'unique-user-id'; // Mark 'id' as a unique index
  
-  property2: number; // this one is not marked, so it won't be save upon calling this.save()
+  @svDb()
+  public username: string;  // Mark 'username' to be saved in DB
  
-  constructor() {
-    super(); // the super call is important ;) But you probably know that.
+  @svDb()
+  @index() // Create a regular index for this field
+  public email: string;  // Mark 'email' to be saved in DB
+  
+  @svDb()
+  @oid() // Automatically handle as ObjectId type
+  public organizationId: ObjectId; // Will be automatically converted to/from ObjectId
+  
+  @svDb()
+  @bin() // Automatically handle as Binary data
+  public profilePicture: Buffer; // Will be automatically converted to/from Binary
+  
+  @svDb({ 
+    serialize: (data) => JSON.stringify(data), // Custom serialization
+    deserialize: (data) => JSON.parse(data)    // Custom deserialization
+  })
+  public preferences: Record<string, any>;
+  
+  constructor(username: string, email: string) {
+    super();
+    this.username = username;
+    this.email = email;
+  }
+}
+```
+
+### CRUD Operations
+`@push.rocks/smartdata` simplifies CRUD operations with intuitive methods on model instances.
+
+#### Create
+```typescript
+const newUser = new User('myUsername', 'myEmail@example.com');
+await newUser.save();  // Save the new user to the database
+```
+
+#### Read
+```typescript
+// Fetch a single user by a unique attribute
+const user = await User.getInstance({ username: 'myUsername' });
+
+// Fetch multiple users that match criteria
+const users = await User.getInstances({ email: 'myEmail@example.com' });
+
+// Using a cursor for large collections
+const cursor = await User.getCursor({ active: true });
+
+// Process documents one at a time (memory efficient)
+await cursor.forEach(async (user, index) => {
+  // Process each user with its position
+  console.log(`Processing user ${index}: ${user.username}`);
+});
+
+// Chain cursor methods like in the MongoDB native driver
+const paginatedCursor = await User.getCursor({ active: true })
+  .limit(10)  // Limit results
+  .skip(20)   // Skip first 20 results
+  .sort({ createdAt: -1 }); // Sort by creation date descending
+
+// Convert cursor to array (when you know the result set is small)
+const userArray = await paginatedCursor.toArray();
+
+// Other cursor operations
+const nextUser = await cursor.next(); // Get the next document
+const hasMoreUsers = await cursor.hasNext(); // Check if more documents exist
+const count = await cursor.count(); // Get the count of documents in the cursor
+
+// Always close cursors when done with them
+await cursor.close();
+```
+
+#### Update
+```typescript
+// Assuming 'user' is an instance of User
+user.email = 'newEmail@example.com';
+await user.save();  // Update the user in the database
+
+// Upsert operations (insert if not exists, update if exists)
+const upsertedUser = await User.upsert(
+  { id: 'user-123' },  // Query to find the user
+  {                    // Fields to update or insert
+    username: 'newUsername', 
+    email: 'newEmail@example.com'
+  }
+);
+```
+
+#### Delete
+```typescript
+// Assuming 'user' is an instance of User
+await user.delete();  // Delete the user from the database
+```
+
+## Advanced Features
+
+### EasyStore
+EasyStore provides a simple key-value storage system with automatic persistence:
+
+```typescript
+// Create an EasyStore instance with a specific type
+interface ConfigStore {
+  apiKey: string;
+  settings: {
+    theme: string;
+    notifications: boolean;
+  };
+}
+
+// Create a type-safe EasyStore
+const store = await db.createEasyStore<ConfigStore>('app-config');
+
+// Write and read data with full type safety
+await store.writeKey('apiKey', 'secret-api-key-123');
+await store.writeKey('settings', { theme: 'dark', notifications: true });
+
+const apiKey = await store.readKey('apiKey'); // Type: string
+const settings = await store.readKey('settings'); // Type: { theme: string, notifications: boolean }
+
+// Check if a key exists
+const hasKey = await store.hasKey('apiKey'); // true
+
+// Delete a key
+await store.deleteKey('apiKey');
+```
+
+### Distributed Coordination
+Built-in support for distributed systems with leader election:
+
+```typescript
+// Create a distributed coordinator
+const coordinator = new SmartdataDistributedCoordinator(db);
+
+// Start coordination
+await coordinator.start();
+
+// Handle leadership changes
+coordinator.on('leadershipChange', (isLeader) => {
+  if (isLeader) {
+    // This instance is now the leader
+    // Run leader-specific tasks
+    startPeriodicJobs();
+  } else {
+    // This instance is no longer the leader
+    stopPeriodicJobs();
+  }
+});
+
+// Access leadership status anytime
+if (coordinator.isLeader) {
+  // Run leader-only operations
+}
+
+// Execute a task only on the leader
+await coordinator.executeIfLeader(async () => {
+  // This code only runs on the leader instance
+  await runImportantTask();
+});
+
+// Stop coordination when shutting down
+await coordinator.stop();
+```
+
+### Real-time Data Watching
+Watch for changes in your collections with RxJS integration using MongoDB Change Streams:
+
+```typescript
+// Create a watcher for a specific collection with a query filter
+const watcher = await User.watch({
+  active: true  // Only watch for changes to active users
+}, {
+  fullDocument: true,    // Include the full document in change notifications
+  bufferTimeMs: 100      // Buffer changes for 100ms to reduce notification frequency
+});
+
+// Subscribe to changes using RxJS
+watcher.changeSubject.subscribe((change) => {
+  console.log('Change operation:', change.operationType); // 'insert', 'update', 'delete', etc.
+  console.log('Document changed:', change.docInstance);   // The full document instance
+  
+  // Handle different types of changes
+  if (change.operationType === 'insert') {
+    console.log('New user created:', change.docInstance.username);
+  } else if (change.operationType === 'update') {
+    console.log('User updated:', change.docInstance.username);
+  } else if (change.operationType === 'delete') {
+    console.log('User deleted');
+  }
+});
+
+// Manual observation with event emitter pattern
+watcher.on('change', (change) => {
+  console.log('Document changed:', change);
+});
+
+// Stop watching when no longer needed
+await watcher.stop();
+```
+
+### Managed Collections
+For more complex data models that require additional context:
+
+```typescript
+@Collection(() => db)
+class ManagedDoc extends SmartDataDbDoc<ManagedDoc, ManagedDoc> {
+  @unI()
+  public id: string = 'unique-id';
+  
+  @svDb()
+  public data: string;
+  
+  @managed()
+  public manager: YourCustomManager;
+  
+  // The manager can provide additional functionality
+  async specialOperation() {
+    return this.manager.doSomethingSpecial(this);
+  }
+}
+```
+
+### Automatic Indexing
+Define indexes directly in your model class:
+
+```typescript
+@Collection(() => db)
+class Product extends SmartDataDbDoc<Product, Product> {
+  @unI() // Unique index
+  public id: string = 'product-id';
+  
+  @svDb()
+  @index() // Regular index for faster queries
+  public category: string;
+  
+  @svDb()
+  @index({ sparse: true }) // Sparse index with options
+  public optionalField?: string;
+  
+  // Compound indexes can be defined in the collection decorator
+  @Collection(() => db, {
+    indexMap: {
+      compoundIndex: { 
+        fields: { category: 1, name: 1 },
+        options: { background: true }
+      }
+    }
+  })
+}
+```
+
+### Transaction Support
+Use MongoDB transactions for atomic operations:
+
+```typescript
+const session = await db.startSession();
+try {
+  await session.withTransaction(async () => {
+    const user = await User.getInstance({ id: 'user-id' }, { session });
+    user.balance -= 100;
+    await user.save({ session });
+    
+    const recipient = await User.getInstance({ id: 'recipient-id' }, { session });
+    recipient.balance += 100;
+    await user.save({ session });
+  });
+} finally {
+  await session.endSession();
+}
+```
+
+### Deep Object Queries
+SmartData provides fully type-safe deep property queries with the `DeepQuery` type:
+
+```typescript
+// If your document has nested objects
+class UserProfile extends SmartDataDbDoc<UserProfile, UserProfile> {
+  @unI()
+  public id: string = 'profile-id';
+  
+  @svDb()
+  public user: {
+    details: {
+      firstName: string;
+      lastName: string;
+      address: {
+        city: string;
+        country: string;
+      }
+    }
+  };
+}
+
+// Type-safe string literals for dot notation
+const usersInUSA = await UserProfile.getInstances({
+  'user.details.address.country': 'USA'
+});
+
+// Fully typed deep queries with the DeepQuery type
+import { DeepQuery } from '@push.rocks/smartdata';
+
+const typedQuery: DeepQuery<UserProfile> = {
+  id: 'profile-id',
+  'user.details.firstName': 'John',
+  'user.details.address.country': 'USA'
+};
+
+// TypeScript will error if paths are incorrect
+const results = await UserProfile.getInstances(typedQuery);
+
+// MongoDB query operators are supported
+const operatorQuery: DeepQuery<UserProfile> = {
+  'user.details.address.country': 'USA',
+  'user.details.address.city': { $in: ['New York', 'Los Angeles'] }
+};
+
+const filteredResults = await UserProfile.getInstances(operatorQuery);
+```
+
+### Document Lifecycle Hooks
+Implement custom logic at different stages of a document's lifecycle:
+
+```typescript
+@Collection(() => db)
+class Order extends SmartDataDbDoc<Order, Order> {
+  @unI()
+  public id: string = 'order-id';
+  
+  @svDb()
+  public total: number;
+  
+  @svDb()
+  public items: string[];
+  
+  // Called before saving the document
+  async beforeSave() {
+    // Calculate total based on items
+    this.total = await calculateTotal(this.items);
+    
+    // Validate the document
+    if (this.items.length === 0) {
+      throw new Error('Order must have at least one item');
    }
  }
  
-// start to instantiate instances of classes from scratch or database
+  // Called after the document is saved
+  async afterSave() {
+    // Notify other systems about the saved order
+    await notifyExternalSystems(this);
+  }
  
-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
+  // Called before deleting the document
+  async beforeDelete() {
+    // Check if order can be deleted
+    const canDelete = await checkOrderDeletable(this.id);
+    if (!canDelete) {
+      throw new Error('Order cannot be deleted');
+    }
+  }
+}
 ```

-### class DbDoc
+## Best Practices

-represents a individual document in a collection
-and thereby is ideally suited to extend the class you want to actually store.
+### Connection Management
+- Always call `db.init()` before using any database features
+- Use `db.disconnect()` when shutting down your application
+- Set appropriate connection pool sizes based on your application's needs

-### CRUD operations
+### Document Design
+- Use appropriate decorators (`@svDb`, `@unI`, `@index`) to optimize database operations
+- Implement type-safe models by properly extending `SmartDataDbDoc`
+- Consider using interfaces to define document structures separately from implementation

-smartdata supports full CRUD operations
+### Performance Optimization
+- Use cursors for large datasets instead of loading all documents into memory
+- Create appropriate indexes for frequent query patterns
+- Use projections to limit the fields returned when you don't need the entire document

-**Store** or **Update** instances of classes to MongoDB:
-DbDoc extends your class with the following methods:
+### Distributed Systems
+- Implement proper error handling for leader election events
+- Ensure all instances have synchronized clocks when using time-based coordination
+- Use the distributed coordinator's task management features for coordinated operations

- 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
+### Type Safety
+- Take advantage of the `DeepQuery<T>` type for fully type-safe queries
+- Define proper types for your document models to enhance IDE auto-completion
+- Use generic type parameters to specify exact document types when working with collections

-**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:
+## Contributing

- 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).
+We welcome contributions to @push.rocks/smartdata! Here's how you can help:

-**Delete** instances from MongoDb:
-smartdata extends your class with a method to easily delete the doucment from DB:
+1. Fork the repository
+2. Create a feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'Add amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request

- async `.delete()`will delete the document from DB.
+Please make sure to update tests as appropriate and follow our coding standards.

-## TypeScript
+## License and Legal Information

-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.
+This repository contains open-source code that is licensed under the MIT License. A copy of the MIT License can be found in the [license](license) file within this repository. 

-## Contribution
+**Please note:** The MIT License does not grant permission to use the trade names, trademarks, service marks, or product names of the project, except as required for reasonable and customary use in describing the origin of the work and reproducing the content of the NOTICE file.

-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). :)
+### Trademarks

-For further information read the linked docs at the top of this readme.
+This project is owned and maintained by Task Venture Capital GmbH. The names and logos associated with Task Venture Capital GmbH and any related products or services are trademarks of Task Venture Capital GmbH and are not included within the scope of the MIT license granted herein. Use of these trademarks must comply with Task Venture Capital GmbH's Trademark Guidelines, and any usage must be approved in writing by Task Venture Capital GmbH.

-> MIT licensed | **&copy;** [Lossless GmbH](https://lossless.gmbh)
-| By using this npm module you agree to our [privacy policy](https://lossless.gmbH/privacy)
+### Company Information

-[![repo-footer](https://lossless.gitlab.io/publicrelations/repofooter.svg)](https://maintainedby.lossless.com)
+Task Venture Capital GmbH  
+Registered at District court Bremen HRB 35230 HB, Germany
+
+For any legal inquiries or if you require further information, please contact us via email at hello@task.vc.
+
+By using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works.
--- a/test/test.distributedcoordinator.ts
+++ b/test/test.distributedcoordinator.ts
@ -0,0 +1,112 @@
+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();
+    const initialTime = distributedCoordinator.ownInstance.data.lastUpdated;
+    await distributedCoordinator.sendHeartbeat();
+    const updatedTime = distributedCoordinator.ownInstance.data.lastUpdated;
+    expect(updatedTime).toBeGreaterThan(initialTime);
+    await distributedCoordinator.stop();
+});
+
+tap.test('should instantiate SmartdataDistributedCoordinator', async (tools) => {
+    const distributedCoordinator = new SmartdataDistributedCoordinator(testDb);
+    await distributedCoordinator.start();
+    expect(distributedCoordinator).toBeInstanceOf(SmartdataDistributedCoordinator);
+    await distributedCoordinator.stop();
+});
+
+tap.test('SmartdataDistributedCoordinator should update leader status', async (tools) => {
+    const distributedCoordinator = new SmartdataDistributedCoordinator(testDb);
+    await distributedCoordinator.start();
+    await distributedCoordinator.checkAndMaybeLead();
+    expect(distributedCoordinator.ownInstance.data.elected).toBeOneOf([true, false]);
+    await distributedCoordinator.stop();
+});
+
+tap.test('SmartdataDistributedCoordinator should handle distributed task requests', async (tools) => {
+    const distributedCoordinator = new SmartdataDistributedCoordinator(testDb);
+    await distributedCoordinator.start();
+
+    const mockTaskRequest: taskbuffer.distributedCoordination.IDistributedTaskRequest = {
+        submitterId: "mockSubmitter12345",    // Some unique mock submitter ID
+        requestResponseId: 'uni879873462hjhfkjhsdf', // Some unique ID for the request-response
+        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 distributedCoordinator.fireDistributedTaskRequest(mockTaskRequest);
+    console.log(response)  // based on your expected structure for the response
+    await distributedCoordinator.stop();
+});
+
+tap.test('SmartdataDistributedCoordinator should update distributed task requests', async (tools) => {
+    const distributedCoordinator = new SmartdataDistributedCoordinator(testDb);
+    
+    await distributedCoordinator.start();
+
+    const mockTaskRequest: taskbuffer.distributedCoordination.IDistributedTaskRequest = {
+        submitterId: "mockSubmitter12345",    // Some unique mock submitter ID
+        requestResponseId: 'uni879873462hjhfkjhsdf', // Some unique ID for the request-response
+        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 distributedCoordinator.updateDistributedTaskRequest(mockTaskRequest);
+    // Here, we can potentially check if a DB entry got updated or some other side-effect of the update method.
+    await distributedCoordinator.stop();
+});
+
+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.start()));
+    const leaders = coordinators.filter(coordinator => coordinator.ownInstance.data.elected);
+    for (const leader of leaders) {
+        console.log(leader.ownInstance);
+    }
+    expect(leaders.length).toEqual(1);
+
+    // stopping clears a coordinator from being elected.
+    await Promise.all(coordinators.map(coordinator => coordinator.stop()));
+});
+
+tap.test('should clean up', async () => {
+    await smartmongoInstance.stopAndDumpToDir(`.nogit/dbdump/test.distributedcoordinator.ts`);
+    setTimeout(() => process.exit(), 2000);
+})
+
+tap.start({ throwOnError: true });
--- a/test/test.easystore.ts
+++ b/test/test.easystore.ts
@ -1,6 +1,6 @@
-import { tap, expect } from '@pushrocks/tapbundle';
-import { Qenv } from '@pushrocks/qenv';
-import * as smartmongo from '@pushrocks/smartmongo';
+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/');
@ -26,7 +26,7 @@ tap.test('should create a testinstance as database', async () => {
 tap.skip.test('should connect to atlas', async (tools) => {
  const databaseName = `test-smartdata-${smartunique.shortId()}`;
  testDb = new smartdata.SmartdataDb({
-    mongoDbUrl: testQenv.getEnvVarOnDemand('MONGO_URL'),
+    mongoDbUrl: await testQenv.getEnvVarOnDemand('MONGO_URL'),
    mongoDbName: databaseName,
  });
  await testDb.init();
--- a/test/test.ts
+++ b/test/test.ts
@ -1,6 +1,6 @@
-import { tap, expect } from '@pushrocks/tapbundle';
-import { Qenv } from '@pushrocks/qenv';
-import * as smartmongo from '@pushrocks/smartmongo';
+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 mongodb from 'mongodb';
@ -30,7 +30,7 @@ tap.test('should create a testinstance as database', async () => {
 tap.skip.test('should connect to atlas', async (tools) => {
  const databaseName = `test-smartdata-${smartunique.shortId()}`;
  testDb = new smartdata.SmartdataDb({
-    mongoDbUrl: testQenv.getEnvVarOnDemand('MONGO_URL'),
+    mongoDbUrl: await testQenv.getEnvVarOnDemand('MONGO_URL'),
    mongoDbName: databaseName,
  });
  await testDb.init();
@ -72,6 +72,11 @@ class Car extends smartdata.SmartDataDbDoc<Car, Car> {
  }
 }

+tap.test('should create a new id', async () => {
+  const newid = await Car.getNewId();
+  console.log(newid);
+});
+
 tap.test('should save the car to the db', async (toolsArg) => {
  const myCar = new Car('red', 'Volvo');
  await myCar.save();
@ -194,12 +199,18 @@ tap.test('should store a new Truck', async () => {
  const truck = new Truck('blue', 'MAN');
  await truck.save();
  const myTruck2 = await Truck.getInstance({ color: 'blue' });
+  expect(myTruck2.color).toEqual('blue');
  myTruck2.color = 'red';
  await myTruck2.save();
  const myTruck3 = await Truck.getInstance({ color: 'blue' });
-  console.log(myTruck3);
+  expect(myTruck3).toBeNull();
 });

+tap.test('should return a count', async () => {
+  const truckCount = await Truck.getCount();
+  expect(truckCount).toEqual(1);
+})
+
 tap.test('should use a cursor', async () => {
  const cursor = await Car.getCursor({});
  let counter = 0;
@ -213,11 +224,13 @@ tap.test('should use a cursor', async () => {
 // close the database connection
 // =======================================
 tap.test('close', async () => {
+  if (smartmongoInstance) {
+    await smartmongoInstance.stopAndDumpToDir('./.nogit/dbdump/test.ts');
+  } else {
    await testDb.mongoDb.dropDatabase();
    await testDb.close();
-  if (smartmongoInstance) {
-    await smartmongoInstance.stop();
  }
+  setTimeout(() => process.exit(), 2000);
 });

 tap.start({ throwOnError: true });
--- a/test/test.typescript.ts
+++ b/test/test.typescript.ts
@ -1,6 +1,6 @@
-import { tap, expect } from '@pushrocks/tapbundle';
-import { Qenv } from '@pushrocks/qenv';
-import * as smartmongo from '@pushrocks/smartmongo';
+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/');
@ -28,7 +28,7 @@ tap.test('should create a testinstance as database', async () => {
 tap.skip.test('should connect to atlas', async (tools) => {
  const databaseName = `test-smartdata-${smartunique.shortId()}`;
  testDb = new smartdata.SmartdataDb({
-    mongoDbUrl: testQenv.getEnvVarOnDemand('MONGO_URL'),
+    mongoDbUrl: await testQenv.getEnvVarOnDemand('MONGO_URL'),
    mongoDbName: databaseName,
  });
  await testDb.init();
--- a/test/test.watch.ts
+++ b/test/test.watch.ts
@ -1,6 +1,6 @@
-import { tap, expect } from '@pushrocks/tapbundle';
-import { Qenv } from '@pushrocks/qenv';
-import * as smartmongo from '@pushrocks/smartmongo';
+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/');
@ -28,7 +28,7 @@ tap.test('should create a testinstance as database', async () => {
 tap.skip.test('should connect to atlas', async (tools) => {
  const databaseName = `test-smartdata-${smartunique.shortId()}`;
  testDb = new smartdata.SmartdataDb({
-    mongoDbUrl: testQenv.getEnvVarOnDemand('MONGO_URL'),
+    mongoDbUrl: await testQenv.getEnvVarOnDemand('MONGO_URL'),
    mongoDbName: databaseName,
  });
  await testDb.init();
--- a/ts/00_commitinfo_data.ts
+++ b/ts/00_commitinfo_data.ts
@ -1,8 +1,8 @@
 /**
- * autocreated commitinfo by @pushrocks/commitinfo
+ * autocreated commitinfo by @push.rocks/commitinfo
 */
 export const commitinfo = {
-  name: '@pushrocks/smartdata',
-  version: '5.0.13',
-  description: 'do more with data'
+  name: '@push.rocks/smartdata',
+  version: '5.3.0',
+  description: 'An advanced library for NoSQL data organization and manipulation using TypeScript with support for MongoDB, data validation, collections, and custom data types.'
 }
--- a/ts/index.ts
+++ b/ts/index.ts
@ -6,9 +6,7 @@ export * from './smartdata.classes.cursor.js';

 import * as convenience from './smartadata.convenience.js';

-export {
-  convenience
-}
+export { convenience };

 // to be removed with the next breaking update
 import type * as plugins from './smartdata.plugins.js';
--- a/ts/smartadata.convenience.ts
+++ b/ts/smartadata.convenience.ts
@ -2,4 +2,4 @@ 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
@ -26,7 +26,8 @@ const collectionFactory = new CollectionFactory();
 */
 export function Collection(dbArg: SmartdataDb | TDelayed<SmartdataDb>) {
  return function classDecorator<T extends { new (...args: any[]): {} }>(constructor: T) {
-    return class extends constructor {
+    const decoratedClass = class extends constructor {
+      public static className = constructor.name;
      public static get collection() {
        if (!(dbArg instanceof SmartdataDb)) {
          dbArg = dbArg();
@ -40,6 +41,7 @@ export function Collection(dbArg: SmartdataDb | TDelayed<SmartdataDb>) {
        return collectionFactory.getCollection(constructor.name, dbArg);
      }
    };
+    return decoratedClass;
  };
 }

@ -56,9 +58,10 @@ export const setDefaultManagerForDoc = <T>(managerArg: IManager, dbDocArg: T): T
 * 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>) {
+export function managed<TManager extends IManager>(managerArg?: TManager | TDelayed<TManager>) {
  return function classDecorator<T extends { new (...args: any[]): any }>(constructor: T) {
-    return class extends constructor {
+    const decoratedClass = class extends constructor {
+      public static className = constructor.name;
      public static get collection() {
        let dbArg: SmartdataDb;
        if (!managerArg) {
@ -106,9 +109,15 @@ export function Manager<TManager extends IManager>(managerArg?: TManager | TDela
        return manager;
      }
    };
+    return decoratedClass;
  };
 }

+/**
+ * @dpecrecated use @managed instead
+ */
+export const Manager = managed;
+
 export class SmartdataCollection<T> {
  /**
   * the collection that is used
@ -264,12 +273,17 @@ export class SmartdataCollection<T> {
    await this.mongoDbCollection.deleteOne(identifiableObject);
  }

+  public async getCount(filterObject: any) {
+    await this.init();
+    return this.mongoDbCollection.countDocuments(filterObject);
+  }
+
  /**
   * 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>();
+    const done = plugins.smartpromise.defer<void>();
    let validationResult = true;
    if (this.objectValidation) {
      validationResult = this.objectValidation(docArg);
--- a/ts/smartdata.classes.db.ts
+++ b/ts/smartdata.classes.db.ts
@ -1,5 +1,4 @@
 import * as plugins from './smartdata.plugins.js';
-import { ObjectMap } from '@pushrocks/lik';

 import { SmartdataCollection } from './smartdata.classes.collection.js';
 import { EasyStore } from './smartdata.classes.easystore.js';
@ -17,7 +16,7 @@ export class SmartdataDb {
  mongoDb: plugins.mongodb.Db;
  status: TConnectionStatus;
  statusConnectedDeferred = plugins.smartpromise.defer();
-  smartdataCollectionMap = new ObjectMap<SmartdataCollection<any>>();
+  smartdataCollectionMap = new plugins.lik.ObjectMap<SmartdataCollection<any>>();

  constructor(smartdataOptions: plugins.tsclass.database.IMongoDescriptor) {
    this.smartdataOptions = smartdataOptions;
--- a/ts/smartdata.classes.distributedcoordinator.ts
+++ b/ts/smartdata.classes.distributedcoordinator.ts
@ -1,30 +1,32 @@
 import * as plugins from './smartdata.plugins.js';
 import { SmartdataDb } from './smartdata.classes.db.js';
-import { Manager, setDefaultManagerForDoc } from './smartdata.classes.collection.js';
+import { managed, setDefaultManagerForDoc } from './smartdata.classes.collection.js';
 import { SmartDataDbDoc, svDb, unI } from './smartdata.classes.doc.js';
+import { SmartdataDbWatcher } from './smartdata.classes.watcher.js';

-@Manager()
-class DistributedClass extends SmartDataDbDoc<DistributedClass, DistributedClass> {
+@managed()
+export class DistributedClass extends SmartDataDbDoc<DistributedClass, DistributedClass> {
  // INSTANCE
  @unI()
  public id: string;

  @svDb()
  public data: {
-    status: 'bidding' | 'settled' | 'initializing' | 'stopped';
+    status: 'initializing' | 'bidding' | 'settled' | 'stopped';
    biddingShortcode?: string;
+    biddingStartTime?: number;
    lastUpdated: number;
    elected: boolean;
    /**
     * used to store request
     */
-    taskRequests: plugins.taskbuffer.distributedCoordination.IDistributedTaskRequest[],
+    taskRequests: plugins.taskbuffer.distributedCoordination.IDistributedTaskRequest[];

    /**
     * only used by the leader to convey consultation results
     */
    taskRequestResults: plugins.taskbuffer.distributedCoordination.IDistributedTaskRequestResult[];
-  }
+  };
 }

 /**
@ -37,14 +39,14 @@ export class SmartdataDistributedCoordinator extends plugins.taskbuffer.distribu
  public readyPromise: Promise<any>;
  public db: SmartdataDb;
  private asyncExecutionStack = new plugins.lik.AsyncExecutionStack();
-  private ownInstance: DistributedClass;
+  public ownInstance: DistributedClass;
+  public distributedWatcher: SmartdataDbWatcher<DistributedClass>;

-  constructor(dbArg?: SmartdataDb) {
+  constructor(dbArg: SmartdataDb) {
    super();
    this.db = dbArg;
    setDefaultManagerForDoc(this, DistributedClass);
    this.readyPromise = this.db.statusConnectedDeferred.promise;
-    this.init();
  }

  // smartdata specific stuff
@ -53,26 +55,56 @@ export class SmartdataDistributedCoordinator extends plugins.taskbuffer.distribu
  }

  public async stop() {
+    await this.asyncExecutionStack.getExclusiveExecutionSlot(async () => {
+      if (this.distributedWatcher) {
+        await this.distributedWatcher.close();
+      }
      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.`);
      }
+      if (this.ownInstance?.data.status === 'stopped') {
+        console.log(`stopping a distributed instance that has not been started yet.`);
+      }
+      this.ownInstance.data.status = 'stopped';
+      await this.ownInstance.save();
+      console.log(`stopped ${this.ownInstance.id}`);
+    });
  }

  public id = plugins.smartunique.uni('distributedInstance');

  private startHeartbeat = async () => {
    while (this.ownInstance.data.status !== 'stopped') {
+      await this.sendHeartbeat();
+      await plugins.smartdelay.delayForRandom(5000, 10000);
+    }
+  };
+
+  public async sendHeartbeat() {
    await this.asyncExecutionStack.getExclusiveExecutionSlot(async () => {
+      if (this.ownInstance.data.status === 'stopped') {
+        console.log(`aborted sending heartbeat because status is stopped`);
+        return;
+      }
      await this.ownInstance.updateFromDb();
      this.ownInstance.data.lastUpdated = Date.now();
      await this.ownInstance.save();
+      console.log(`sent heartbeat for ${this.ownInstance.id}`);
+      const allInstances = DistributedClass.getInstances({});
    });
-      await plugins.smartdelay.delayFor(10000);
+    if (this.ownInstance.data.status === 'stopped') {
+      console.log(`aborted sending heartbeat because status is stopped`);
+      return;
    }
-  };
-  public async init() {
+    const eligibleLeader = await this.getEligibleLeader();
+    // not awaiting here because we don't want to block the heartbeat
+    this.asyncExecutionStack.getExclusiveExecutionSlot(async () => {
+      if (!eligibleLeader && this.ownInstance.data.status === 'settled') {
+        this.checkAndMaybeLead();
+      }
+    });
+  }
+  private async init() {
    await this.readyPromise;
    if (!this.ownInstance) {
      await this.asyncExecutionStack.getExclusiveExecutionSlot(async () => {
@ -83,10 +115,12 @@ export class SmartdataDistributedCoordinator extends plugins.taskbuffer.distribu
          lastUpdated: Date.now(),
          status: 'initializing',
          taskRequests: [],
-          taskRequestResults: []
+          taskRequestResults: [],
        };
        await this.ownInstance.save();
      });
+    } else {
+      console.warn(`distributed instance already initialized`);
    }

    // lets enable the heartbeat
@ -98,42 +132,73 @@ export class SmartdataDistributedCoordinator extends plugins.taskbuffer.distribu
    return this.ownInstance;
  }

+  public async getEligibleLeader() {
+    return this.asyncExecutionStack.getExclusiveExecutionSlot(async () => {
+      const allInstances = await DistributedClass.getInstances({});
+      let leaders = allInstances.filter((instanceArg) => instanceArg.data.elected === true);
+      const eligibleLeader = leaders.find(
+        (leader) =>
+          leader.data.lastUpdated >=
+          Date.now() - plugins.smarttime.getMilliSecondsFromUnits({ seconds: 20 })
+      );
+      return eligibleLeader;
+    });
+  }
+
  // --> 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 () => {
+      this.ownInstance.data.status = 'initializing';
+      this.ownInstance.save();
+    });
+    if (await this.getEligibleLeader()) {
      await this.asyncExecutionStack.getExclusiveExecutionSlot(async () => {
        await this.ownInstance.updateFromDb();
        this.ownInstance.data.status = 'settled';
        await this.ownInstance.save();
+        console.log(`${this.ownInstance.id} settled as follower`);
      });
      return;
+    } else if (
+      (await DistributedClass.getInstances({})).find((instanceArg) => {
+        instanceArg.data.status === 'bidding' &&
+          instanceArg.data.biddingStartTime <= Date.now() - 4000 &&
+          instanceArg.data.biddingStartTime >= Date.now() - 30000;
+      })
+    ) {
+      console.log('too late to the bidding party... waiting for next round.');
+      return;
    } else {
      await this.asyncExecutionStack.getExclusiveExecutionSlot(async () => {
+        await this.ownInstance.updateFromDb();
        this.ownInstance.data.status = 'bidding';
+        this.ownInstance.data.biddingStartTime = Date.now();
        this.ownInstance.data.biddingShortcode = plugins.smartunique.shortId();
        await this.ownInstance.save();
+        console.log('bidding code stored.');
      });
-      await plugins.smartdelay.delayFor(plugins.smarttime.getMilliSecondsFromUnits({ minutes: 2 }));
+      console.log(`bidding for leadership...`);
+      await plugins.smartdelay.delayFor(
+        plugins.smarttime.getMilliSecondsFromUnits({ seconds: 5 })
+      );
      await this.asyncExecutionStack.getExclusiveExecutionSlot(async () => {
        let biddingInstances = await DistributedClass.getInstances({});
        biddingInstances = biddingInstances.filter(
          (instanceArg) =>
-            !instanceArg.data.elected &&
+            instanceArg.data.status === 'bidding' &&
            instanceArg.data.lastUpdated >=
-              Date.now() - plugins.smarttime.getMilliSecondsFromUnits({ minutes: 1 })
+              Date.now() - plugins.smarttime.getMilliSecondsFromUnits({ seconds: 10 })
        );
+        console.log(`found ${biddingInstances.length} bidding instances...`);
        this.ownInstance.data.elected = true;
        for (const biddingInstance of biddingInstances) {
          if (biddingInstance.data.biddingShortcode < this.ownInstance.data.biddingShortcode) {
            this.ownInstance.data.elected = false;
          }
        }
+        await plugins.smartdelay.delayFor(5000);
+        console.log(`settling with status elected = ${this.ownInstance.data.elected}`);
+        this.ownInstance.data.status = 'settled';
        await this.ownInstance.save();
      });
      if (this.ownInstance.data.elected) {
@ -148,45 +213,83 @@ export class SmartdataDistributedCoordinator extends plugins.taskbuffer.distribu
   * the leading is implemented here
   */
  public async leadFunction() {
-    const ownInstance = await this.init();
-    const watcher = await DistributedClass.watch({});
+    this.distributedWatcher = await DistributedClass.watch({});
+
+    const currentTaskRequests: Array<{
+      taskName: string;
+      taskExecutionTime: number;
      /**
-     * this function is started once per unique job request
+       * all instances that requested this task
       */
-    const startResultTimer = async () => {
+      requestingDistibutedInstanceIds: string[];
+      responseTimeout: plugins.smartdelay.Timeout<any>;
+    }> = [];

-    }
-    
-    watcher.changeSubject.subscribe({
+    this.distributedWatcher.changeSubject.subscribe({
      next: async (distributedDoc) => {
-        distributedDoc
-      }
-    })
-    while (this.ownInstance.data.status !== 'stopped') {
-      await plugins.smartdelay.delayFor(1000);
+        if (!distributedDoc) {
+          console.log(`registered deletion of instance...`);
+          return;
        }
+        console.log(distributedDoc);
+        console.log(`registered change for ${distributedDoc.id}`);
+        distributedDoc;
+      },
+    });
+
+    while (this.ownInstance.data.status !== 'stopped' && this.ownInstance.data.elected) {
+      const allInstances = await DistributedClass.getInstances({});
+      for (const instance of allInstances) {
+        if (instance.data.status === 'stopped') {
+          await instance.delete();
        };
+      }
+      await plugins.smartdelay.delayFor(10000);
+    }
+  }

  // 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 () => {
+      if (!this.ownInstance) {
+        console.error('instance need to be started first...');
+        return;
+      }
+      await this.ownInstance.updateFromDb();
      this.ownInstance.data.taskRequests.push(taskRequestArg);
      await this.ownInstance.save();
    });
+    await plugins.smartdelay.delayFor(10000);
+    const result = await this.asyncExecutionStack.getExclusiveExecutionSlot(async () => {
+      await this.ownInstance.updateFromDb();
+      const taskRequestResult = this.ownInstance.data.taskRequestResults.find((resultItem) => {
+        return resultItem.requestResponseId === taskRequestArg.requestResponseId;
+      });
+      return taskRequestResult;
+    });
+    if (!result) {
+      console.warn('no result found for task request...');
      return null;
    }
+    return result;
+  }

  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;
+      const existingInfoBasis = this.ownInstance.data.taskRequests.find((infoBasisItem) => {
+        return (
+          infoBasisItem.taskName === infoBasisArg.taskName &&
+          infoBasisItem.taskExecutionTime === infoBasisArg.taskExecutionTime
+        );
      });
+      if (!existingInfoBasis) {
+        console.warn('trying to update a non existing task request... aborting!');
+        return;
+      }
      Object.assign(existingInfoBasis, infoBasisArg);
      await this.ownInstance.save();
      plugins.smartdelay.delayFor(60000).then(() => {
@ -194,8 +297,8 @@ export class SmartdataDistributedCoordinator extends plugins.taskbuffer.distribu
          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,7 +1,5 @@
 import * as plugins from './smartdata.plugins.js';

-import { ObjectMap } from '@pushrocks/lik';
-
 import { SmartdataDb } from './smartdata.classes.db.js';
 import { SmartdataDbCursor } from './smartdata.classes.cursor.js';
 import { type IManager, SmartdataCollection } from './smartdata.classes.collection.js';
@ -9,6 +7,16 @@ import { SmartdataDbWatcher } from './smartdata.classes.watcher.js';

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

+export function globalSvDb() {
+  return (target: SmartDataDbDoc<unknown, unknown>, key: string) => {
+    console.log(`called svDb() on >${target.constructor.name}.${key}<`);
+    if (!target.globalSaveableProperties) {
+      target.globalSaveableProperties = [];
+    }
+    target.globalSaveableProperties.push(key);
+  };
+}
+
 /**
 * saveable - saveable decorator to be used on class properties
 */
@ -45,8 +53,12 @@ export function unI() {

 export const convertFilterForMongoDb = (filterArg: { [key: string]: any }) => {
  const convertedFilter: { [key: string]: any } = {};
+
  const convertFilterArgument = (keyPathArg2: string, filterArg2: any) => {
-    if (typeof filterArg2 === 'object') {
+    if (Array.isArray(filterArg2)) {
+      // Directly assign arrays (they might be using operators like $in or $all)
+      convertFilterArgument(keyPathArg2, filterArg2[0]);
+    } else if (typeof filterArg2 === 'object' && filterArg2 !== null) {
      for (const key of Object.keys(filterArg2)) {
        if (key.startsWith('$')) {
          convertedFilter[keyPathArg2] = filterArg2;
@ -62,6 +74,7 @@ export const convertFilterForMongoDb = (filterArg: { [key: string]: any }) => {
      convertedFilter[keyPathArg2] = filterArg2;
    }
  };
+
  for (const key of Object.keys(filterArg)) {
    convertFilterArgument(key, filterArg[key]);
  }
@ -129,6 +142,13 @@ export class SmartDataDbDoc<T extends TImplements, TImplements, TManager extends
    }
  }

+  /**
+   * get a unique id prefixed with the class name
+   */
+  public static async getNewId<T = any>(this: plugins.tsclass.typeFest.Class<T>, lengthArg: number = 20) {
+    return `${(this as any).className}:${plugins.smartunique.shortId(lengthArg)}`;
+  }
+
  /**
   * get cursor
   * @returns
@ -176,6 +196,17 @@ export class SmartDataDbDoc<T extends TImplements, TImplements, TManager extends
    await cursor.forEach(forEachFunction);
  }

+  /**
+   * returns a count of the documents in the collection
+   */
+  public static async getCount<T>(
+    this: plugins.tsclass.typeFest.Class<T>,
+    filterArg: plugins.tsclass.typeFest.PartialDeep<T> = ({} as any)
+  ) {
+    const collection: SmartdataCollection<T> = (this as any).collection;
+    return await collection.getCount(filterArg);
+  }
+
  // INSTANCE

  /**
@ -183,13 +214,30 @@ export class SmartDataDbDoc<T extends TImplements, TImplements, TManager extends
   */
  public creationStatus: TDocCreation = 'new';

+  /**
+   * updated from db in any case where doc comes from db
+   */
+  @globalSvDb()
+  _createdAt: string = (new Date()).toISOString();
+
+  /**
+   * will be updated everytime the doc is saved
+   */
+  @globalSvDb()
+  _updatedAt: string = (new Date()).toISOString();
+
+  /**
+   * an array of saveable properties of ALL doc
+   */
+  public globalSaveableProperties: string[];
+
  /**
   * unique indexes
   */
  public uniqueIndexes: string[];

  /**
-   * an array of saveable properties of a doc
+   * an array of saveable properties of a specific doc
   */
  public saveableProperties: string[];

@ -216,6 +264,9 @@ export class SmartDataDbDoc<T extends TImplements, TImplements, TManager extends
    // tslint:disable-next-line: no-this-assignment
    const self: any = this;
    let dbResult: any;
+
+    this._updatedAt = (new Date()).toISOString();
+
    switch (this.creationStatus) {
      case 'db':
        dbResult = await this.collection.update(self);
@ -241,9 +292,9 @@ export class SmartDataDbDoc<T extends TImplements, TImplements, TManager extends
   * also store any referenced objects to DB
   * better for data consistency
   */
-  public saveDeep(savedMapArg: ObjectMap<SmartDataDbDoc<any, any>> = null) {
+  public saveDeep(savedMapArg: plugins.lik.ObjectMap<SmartDataDbDoc<any, any>> = null) {
    if (!savedMapArg) {
-      savedMapArg = new ObjectMap<SmartDataDbDoc<any, any>>();
+      savedMapArg = new plugins.lik.ObjectMap<SmartDataDbDoc<any, any>>();
    }
    savedMapArg.add(this);
    this.save();
@ -259,7 +310,7 @@ export class SmartDataDbDoc<T extends TImplements, TImplements, TManager extends
   * updates an object from db
   */
  public async updateFromDb() {
-    const mongoDbNativeDoc = await this.collection.findOne(this.createIdentifiableObject());
+    const mongoDbNativeDoc = await this.collection.findOne(await this.createIdentifiableObject());
    for (const key of Object.keys(mongoDbNativeDoc)) {
      this[key] = mongoDbNativeDoc[key];
    }
@ -270,7 +321,11 @@ export class SmartDataDbDoc<T extends TImplements, TImplements, TManager extends
   */
  public async createSavableObject(): Promise<TImplements> {
    const saveableObject: unknown = {}; // is not exposed to outside, so any is ok here
-    for (const propertyNameString of this.saveableProperties) {
+    const saveableProperties = [
+      ...this.globalSaveableProperties,
+      ...this.saveableProperties
+    ]
+    for (const propertyNameString of saveableProperties) {
      saveableObject[propertyNameString] = this[propertyNameString];
    }
    return saveableObject as TImplements;
--- a/ts/smartdata.classes.easystore.ts
+++ b/ts/smartdata.classes.easystore.ts
@ -37,7 +37,16 @@ export class EasyStore<T> {
    this.nameId = nameIdArg;
  }

-  private async getEasyStore() {
+  private easyStorePromise: Promise<InstanceType<typeof this.easyStoreClass>>;
+  private async getEasyStore(): Promise<InstanceType<typeof this.easyStoreClass>> {
+    if (this.easyStorePromise) {
+      return this.easyStorePromise;
+    };
+
+    // first run from here
+    const deferred = plugins.smartpromise.defer<InstanceType<typeof this.easyStoreClass>>();
+    this.easyStorePromise = deferred.promise;
+
    let easyStore = await this.easyStoreClass.getInstance({
      nameId: this.nameId,
    });
@ -48,7 +57,8 @@ export class EasyStore<T> {
      easyStore.data = {};
      await easyStore.save();
    }
-    return easyStore;
+    deferred.resolve(easyStore);
+    return this.easyStorePromise;
  }

  /**
@ -70,7 +80,7 @@ export class EasyStore<T> {
  /**
   * writes a specific key to the keyValueStore
   */
-  public async writeKey(keyArg: keyof T, valueArg: any) {
+  public async writeKey<TKey extends keyof T>(keyArg: TKey, valueArg: T[TKey]) {
    const easyStore = await this.getEasyStore();
    easyStore.data[keyArg] = valueArg;
    await easyStore.save();
@ -101,8 +111,9 @@ export class EasyStore<T> {
  }

  public async cleanUpEphermal() {
-    while(await this.smartdataDbRef.statusConnectedDeferred.promise && this.smartdataDbRef.status === 'connected') {
-      
-    }
+    while (
+      (await this.smartdataDbRef.statusConnectedDeferred.promise) &&
+      this.smartdataDbRef.status === 'connected'
+    ) {}
  }
 }
--- a/ts/smartdata.classes.watcher.ts
+++ b/ts/smartdata.classes.watcher.ts
@ -17,9 +17,13 @@ export class SmartdataDbWatcher<T = any> {
    smartdataDbDocArg: typeof SmartDataDbDoc
  ) {
    this.changeStream = changeStreamArg;
-    this.changeStream.on('change', async (item: T) => {
+    this.changeStream.on('change', async (item: any) => {
+      if (!item.fullDocument) {
+        this.changeSubject.next(null);
+        return;
+      }
      this.changeSubject.next(
-        smartdataDbDocArg.createInstanceFromMongoDbNativeDoc(item) as any as T
+        smartdataDbDocArg.createInstanceFromMongoDbNativeDoc(item.fullDocument) as any as T
      );
    });
    plugins.smartdelay.delayFor(0).then(() => {
--- a/ts/smartdata.plugins.ts
+++ b/ts/smartdata.plugins.ts
@ -4,16 +4,15 @@ import * as tsclass from '@tsclass/tsclass';
 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 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 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 {
@ -21,7 +20,6 @@ export {
  smartdelay,
  smartpromise,
  smartlog,
-  smartq,
  smartrx,
  mongodb,
  smartstring,
--- a/tsconfig.json
+++ b/tsconfig.json
@ -3,7 +3,12 @@
    "experimentalDecorators": true,
    "useDefineForClassFields": false,
    "target": "ES2022",
-    "module": "ES2022",
-    "moduleResolution": "nodenext"
-  }
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "esModuleInterop": true,
+    "verbatimModuleSyntax": true
+  },
+  "exclude": [
+    "dist_*/**/*.d.ts"
+  ]
 }
Author	SHA1	Message	Date
Philipp Kunz	7a08700451	5.3.0	2025-03-10 23:55:45 +00:00
Philipp Kunz	ebaf3e685c	feat(docs): Enhance documentation with updated installation instructions and comprehensive usage examples covering advanced features such as deep queries, automatic indexing, and distributed coordination.	2025-03-10 23:55:44 +00:00
Philipp Kunz	c8d51a30d8	5.2.12	2025-02-03 14:06:42 +01:00
Philipp Kunz	d957e911de	fix(documentation): Remove license badge from README	2025-02-03 14:06:42 +01:00
Philipp Kunz	fee936c75f	5.2.11	2025-02-03 14:03:04 +01:00
Philipp Kunz	ac867401de	fix(documentation): Updated project documentation for accuracy and added advanced feature details	2025-02-03 14:03:03 +01:00
Philipp Kunz	c066464526	5.2.10	2024-09-05 15:28:53 +02:00
Philipp Kunz	0105aa2a18	fix(smartdata.classes.doc): Fix issue with array handling in convertFilterForMongoDb function	2024-09-05 15:28:52 +02:00
Philipp Kunz	4c2477c269	5.2.9	2024-09-05 15:06:36 +02:00
Philipp Kunz	ea0d2bb251	fix(smartdata.classes.doc): Fixed issue with convertFilterForMongoDb to handle array operators.	2024-09-05 15:06:35 +02:00
Philipp Kunz	b3e30a8711	5.2.8	2024-09-05 13:45:56 +02:00
Philipp Kunz	64621dd38f	fix(smartdata.classes.doc): Fix key handling in convertFilterForMongoDb function	2024-09-05 13:45:55 +02:00
Philipp Kunz	117c257a27	5.2.7	2024-09-05 13:02:28 +02:00
Philipp Kunz	b30522c505	fix(core): Fixed issue with handling filter keys containing dots in smartdata.classes.doc.ts	2024-09-05 13:02:27 +02:00
Philipp Kunz	57d2d56d00	5.2.6	2024-06-18 20:12:15 +02:00
Philipp Kunz	90751002aa	fix(core): update	2024-06-18 20:12:14 +02:00
Philipp Kunz	7606e074a5	5.2.5	2024-06-18 20:11:41 +02:00
Philipp Kunz	7ec39e397e	fix(core): update	2024-06-18 20:11:40 +02:00
Philipp Kunz	21d8d3dc32	5.2.4	2024-05-31 18:47:49 +02:00
Philipp Kunz	6d456955d8	fix(core): update	2024-05-31 18:47:48 +02:00
Philipp Kunz	d08544c782	5.2.3	2024-05-31 18:39:34 +02:00
Philipp Kunz	bda9ac8a07	fix(saveableProperties): fix issue where _createdAt and _updatedAt registered saveableProperties for all document types	2024-05-31 18:39:33 +02:00
Philipp Kunz	d27dafba2b	5.2.2	2024-05-31 18:25:52 +02:00
Philipp Kunz	b6594de18c	fix(core): update	2024-05-31 18:25:51 +02:00
Philipp Kunz	d9246cbeac	update description	2024-05-29 14:12:26 +02:00
Philipp Kunz	9a5864656e	5.2.1	2024-04-16 07:47:25 +02:00
Philipp Kunz	307f0c7277	fix(core): update	2024-04-16 07:47:24 +02:00
Philipp Kunz	62dc897e73	5.2.0	2024-04-15 18:34:14 +02:00
Philipp Kunz	552b344914	feat(SmartDataDbDoc): add static .getCount({}) method	2024-04-15 18:34:13 +02:00
Philipp Kunz	5a2cc2406c	5.1.2	2024-04-15 14:26:22 +02:00
Philipp Kunz	73a11370b6	fix(_createdAt/_updatedAt): fields are now ISO format	2024-04-15 14:26:21 +02:00
Philipp Kunz	162265f353	5.1.1	2024-04-14 04:00:56 +02:00
Philipp Kunz	06776d74c8	fix(core): update	2024-04-14 04:00:56 +02:00
Philipp Kunz	b4cd6b0fe1	5.1.0	2024-04-14 01:26:11 +02:00
Philipp Kunz	b282f69b35	feat(_createdAt & _updatedAt): adds default _createdAt and _updatedAt fields, fixes #1	2024-04-14 01:26:11 +02:00
Philipp Kunz	203a284c88	5.0.43	2024-04-14 01:24:22 +02:00
Philipp Kunz	30ae641a9c	fix(core): update	2024-04-14 01:24:21 +02:00
Philipp Kunz	cfe733621f	update npmextra.json: githost	2024-04-01 21:34:27 +02:00
Philipp Kunz	1f76e2478e	update npmextra.json: githost	2024-04-01 19:57:58 +02:00
Philipp Kunz	7d668bee05	update npmextra.json: githost	2024-03-30 21:46:55 +01:00
Philipp Kunz	bef7f68360	5.0.42	2024-03-30 12:26:43 +01:00
Philipp Kunz	56e9754725	fix(TypeScript): improve tsconfig.json for ES Module use	2024-03-30 12:26:42 +01:00
Philipp Kunz	30d81581cf	5.0.41	2024-03-27 17:32:02 +01:00
Philipp Kunz	5e9db12955	fix(core): update	2024-03-27 17:32:01 +01:00
Philipp Kunz	ad2f422c86	5.0.40	2024-03-27 17:30:51 +01:00
Philipp Kunz	17ce14bcb9	fix(core): update	2024-03-27 17:30:50 +01:00
Philipp Kunz	32319e6e77	5.0.39	2024-03-27 17:30:15 +01:00
Philipp Kunz	4cd284eaa9	fix(core): update	2024-03-27 17:30:14 +01:00
Philipp Kunz	00ec2e57c2	5.0.38	2024-03-27 16:24:58 +01:00
Philipp Kunz	765356ce3d	fix(core): update	2024-03-27 16:24:57 +01:00
Philipp Kunz	56b8581d2b	5.0.37	2024-03-26 13:22:34 +01:00
Philipp Kunz	37a9df9086	fix(core): update	2024-03-26 13:22:33 +01:00
Philipp Kunz	090fb668cd	5.0.36	2024-03-26 13:21:37 +01:00
Philipp Kunz	a1c807261c	fix(core): update	2024-03-26 13:21:36 +01:00
Philipp Kunz	a2ccf15f69	5.0.35	2024-03-26 00:25:06 +01:00
Philipp Kunz	84d48f1914	fix(core): update	2024-03-26 00:25:06 +01:00
Philipp Kunz	1e258e5ffb	5.0.34	2024-03-22 18:36:35 +01:00
Philipp Kunz	19d5f553b9	fix(core): update	2024-03-22 18:36:34 +01:00
Philipp Kunz	7a257ea925	5.0.33	2023-08-21 12:39:49 +02:00
Philipp Kunz	2fa1e89f34	fix(core): update	2023-08-21 12:39:48 +02:00
Philipp Kunz	d6b3896dd3	5.0.32	2023-08-16 13:16:40 +02:00
Philipp Kunz	49b11b17ce	fix(core): update	2023-08-16 13:16:39 +02:00
Philipp Kunz	4ac8a4c0cd	5.0.31	2023-08-16 12:08:28 +02:00
Philipp Kunz	7f9983382a	fix(core): update	2023-08-16 12:08:27 +02:00
Philipp Kunz	54f529b0a7	5.0.30	2023-08-15 19:55:53 +02:00
Philipp Kunz	f542463bf6	fix(core): update	2023-08-15 19:55:52 +02:00
Philipp Kunz	1235ae2eb3	5.0.29	2023-08-15 19:55:23 +02:00
Philipp Kunz	8166d2f7c2	fix(core): update	2023-08-15 19:55:22 +02:00
Philipp Kunz	7c9f27e02f	5.0.28	2023-08-15 01:24:30 +02:00
Philipp Kunz	842e4b280b	fix(core): update	2023-08-15 01:24:29 +02:00
Philipp Kunz	009f3297b2	5.0.27	2023-08-15 01:01:16 +02:00
Philipp Kunz	2ff3a4e0b7	fix(core): update	2023-08-15 01:01:16 +02:00
Philipp Kunz	0e55cd8876	5.0.26	2023-08-12 23:32:40 +02:00
Philipp Kunz	eccdf3f00a	fix(core): update	2023-08-12 23:32:39 +02:00
Philipp Kunz	c7544133d9	5.0.25	2023-08-12 23:32:02 +02:00
Philipp Kunz	c7c9acf5bd	fix(core): update	2023-08-12 23:32:02 +02:00
Philipp Kunz	c99ec50853	5.0.24	2023-08-10 18:06:46 +02:00
Philipp Kunz	4dd9557e1d	fix(core): update	2023-08-10 18:06:45 +02:00
Philipp Kunz	52b34a6da1	5.0.23	2023-07-21 20:09:51 +02:00
Philipp Kunz	1bf74fe04d	fix(core): update	2023-07-21 20:09:51 +02:00
Philipp Kunz	fdd875ad31	5.0.22	2023-07-21 20:08:50 +02:00
Philipp Kunz	a7bf0c0298	fix(core): update	2023-07-21 20:08:50 +02:00
Philipp Kunz	59d6336e43	5.0.21	2023-07-21 20:08:18 +02:00
Philipp Kunz	e0fc81179a	fix(core): update	2023-07-21 20:08:18 +02:00
Philipp Kunz	5aa81a56a2	switch to new org scheme	2023-07-10 02:43:00 +02:00
Philipp Kunz	9ae26177b8	5.0.20	2023-06-25 02:01:20 +02:00
Philipp Kunz	26ac52d6c5	fix(core): update	2023-06-25 02:01:19 +02:00
Philipp Kunz	fb39463b7d	5.0.19	2023-06-25 01:53:17 +02:00
Philipp Kunz	44acba80c1	fix(core): update	2023-06-25 01:53:17 +02:00
Philipp Kunz	8cf8315577	5.0.18	2023-06-25 01:51:44 +02:00
Philipp Kunz	9b44b64a50	fix(core): update	2023-06-25 01:51:43 +02:00
Philipp Kunz	699e25201c	5.0.17	2023-06-25 01:30:14 +02:00
Philipp Kunz	2ef9aace68	fix(core): update	2023-06-25 01:30:14 +02:00
Philipp Kunz	cc55a57dfd	5.0.16	2023-06-25 01:29:40 +02:00
Philipp Kunz	b2df512552	fix(core): update	2023-06-25 01:29:39 +02:00
Philipp Kunz	23c62fbd69	5.0.15	2023-06-25 01:28:30 +02:00
Philipp Kunz	5f70ea0b05	fix(core): update	2023-06-25 01:28:29 +02:00
Philipp Kunz	49a595876a	5.0.14	2023-06-25 01:27:10 +02:00
Philipp Kunz	db38a1ef85	fix(core): update	2023-06-25 01:27:09 +02:00