4.0.11

.vscode/launch.json

@@ -2,28 +2,10 @@
   "version": "0.2.0",
   "configurations": [
     {
-      "name": "current file",
+      "command": "npm test",
-      "type": "node",
+      "name": "Run npm test",
       "request": "launch",
-      "args": [
+      "type": "node-terminal"
-        "${relativeFile}"
-      ],
-      "runtimeArgs": ["-r", "@gitzone/tsrun"],
-      "cwd": "${workspaceRoot}",
-      "protocol": "inspector",
-      "internalConsoleOptions": "openOnSessionStart"
-    },
-    {
-      "name": "test.ts",
-      "type": "node",
-      "request": "launch",
-      "args": [
-        "test/test.ts"
-      ],
-      "runtimeArgs": ["-r", "@gitzone/tsrun"],
-      "cwd": "${workspaceRoot}",
-      "protocol": "inspector",
-      "internalConsoleOptions": "openOnSessionStart"
     }
   ]
 }

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pushrocks/smartdata",
-  "version": "3.1.52",
+  "version": "4.0.11",
   "private": false,
   "description": "do more with data",
   "main": "dist_ts/index.js",
@@ -21,27 +21,27 @@
   },
   "homepage": "https://gitlab.com/pushrocks/smartdata#README",
   "dependencies": {
-    "@pushrocks/lik": "^4.0.17",
+    "@pushrocks/lik": "^4.0.20",
     "@pushrocks/smartlog": "^2.0.39",
-    "@pushrocks/smartpromise": "^3.0.6",
+    "@pushrocks/smartpromise": "^3.1.5",
-    "@pushrocks/smartstring": "^3.0.18",
+    "@pushrocks/smartstring": "^3.0.24",
-    "@tsclass/tsclass": "^3.0.25",
+    "@tsclass/tsclass": "^3.0.33",
-    "@types/lodash": "^4.14.161",
+    "@types/lodash": "^4.14.169",
-    "@types/mongodb": "^3.5.27",
+    "@types/mongodb": "^3.6.12",
-    "lodash": "^4.17.20",
+    "lodash": "^4.17.21",
-    "mongodb": "^3.6.2",
+    "mongodb": "^3.6.6",
     "runtime-type-checks": "0.0.4"
   },
   "devDependencies": {
     "@gitzone/tsbuild": "^2.1.25",
-    "@gitzone/tstest": "^1.0.44",
+    "@gitzone/tstest": "^1.0.54",
     "@pushrocks/qenv": "^4.0.10",
     "@pushrocks/smartunique": "^3.0.3",
-    "@pushrocks/tapbundle": "^3.2.9",
+    "@pushrocks/tapbundle": "^3.2.14",
     "@types/mongodb-memory-server": "^2.3.0",
-    "@types/node": "^14.11.2",
+    "@types/node": "^15.3.0",
     "@types/shortid": "0.0.29",
-    "mongodb-memory-server": "^6.8.0",
+    "mongodb-memory-server": "^6.9.6",
     "tslint": "^6.1.3",
     "tslint-config-prettier": "^1.18.0"
   },

readme.md

@@ -49,6 +49,7 @@ How RethinkDB's terms map to the ones of smartdata:
 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({
@@ -57,7 +58,7 @@ const smartdataDb = new smartdata.SmartdataDb({
   mongoDbPass: 'mypassword',
 });
 
-smartdataDb.connect();
+await smartdataDb.connect();
 ```
 
 ### class DbCollection
@@ -68,10 +69,11 @@ A collection is defined by the object class (that is extending smartdata.dbdoc)
 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> {
+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
@@ -87,14 +89,22 @@ class MyObject extends smartdata.DbDoc<MyObject> {
 
 const localObject = new MyObject({
   property1: 'hi',
-  property2: 2,
+  property2: {
+    deep: 3
+  },
 });
-localObject.save(); // saves the object to the database
+await localObject.save(); // saves the object to the database
 
 // start retrieving instances
 
-MyObject.getInstance<MyObject>({
+// .getInstance is staticly inheritied, yet fully typed static function to get instances with fully typed filters
-  property: 'hi',
+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
 ```
 

test/test.ts

@@ -3,6 +3,8 @@ import { Qenv } from '@pushrocks/qenv';
 
 const testQenv = new Qenv(process.cwd(), process.cwd() + '/.nogit/');
 
+console.log(process.memoryUsage());
+
 // the tested module
 import * as smartdata from '../ts/index';
 
@@ -17,6 +19,8 @@ let testDb: smartdata.SmartdataDb;
 let smartdataOptions: smartdata.IMongoDescriptor;
 let mongod: mongoPlugin.MongoMemoryServer;
 
+const totalCars = 2000;
+
 tap.skip.test('should create a testinstance as database', async () => {
   mongod = new mongoPlugin.MongoMemoryServer({});
   console.log('created mongod instance');
@@ -68,7 +72,7 @@ class Car extends smartdata.SmartDataDbDoc<Car, Car> {
 
   @smartdata.svDb()
   deepData = {
-    sodeep: 'yes'
+    sodeep: 'yes',
   };
 
   constructor(colorArg: string, brandArg: string) {
@@ -85,46 +89,65 @@ tap.test('should save the car to the db', async () => {
   const myCar2 = new Car('red', 'Volvo');
   await myCar2.save();
 
-  
-
   let counter = 0;
-  const totalCars = 2000;
+  process.memoryUsage();
   do {
     const myCar3 = new Car('red', 'Renault');
     await myCar3.save();
     counter++;
-    if (counter%100 === 0) {
+    if (counter % 100 === 0) {
-      console.log(`Filled database with ${counter} of ${totalCars} Cars`);
+      console.log(
+        `Filled database with ${counter} of ${totalCars} Cars and memory usage ${
+          process.memoryUsage().rss / 1e6
+        } MB`
+      );
     }
   } while (counter < totalCars);
+  console.log(process.memoryUsage());
 });
 
 tap.test('expect to get instance of Car with shallow match', async () => {
+  const totalQueryCycles = totalCars / 4;
   let counter = 0;
   do {
     const timeStart = Date.now();
-    const myCars = await Car.getInstances<Car>({
+    const myCars = await Car.getInstances({
       brand: 'Renault',
     });
-    console.log(`took ${Date.now() - timeStart}ms to query a set of 2000`);
+    if (counter % 10 === 0) {
+      console.log(
+        `performed ${counter} of ${totalQueryCycles} total query cycles: took ${
+          Date.now() - timeStart
+        }ms to query a set of 2000 with memory footprint ${process.memoryUsage().rss / 1e6} MB`
+      );
+    }
     expect(myCars[0].deepData.sodeep).to.equal('yes');
     expect(myCars[0].brand).to.equal('Renault');
     counter++;
-  } while (counter < 30);
+  } while (counter < totalQueryCycles);
 });
 
 tap.test('expect to get instance of Car with deep match', async () => {
+  const totalQueryCycles = totalCars / 4;
   let counter = 0;
   do {
     const timeStart = Date.now();
-    const myCars2 = await Car.getInstances<Car>({
+    const myCars2 = await Car.getInstances({
-      'deepData.sodeep': 'yes',
+      deepData: {
-    } as any);
+        sodeep: 'yes'
-    console.log(`took ${Date.now() - timeStart}ms to query a set of 2000`);
+      },
+    });
+    if (counter % 10 === 0) {
+      console.log(
+        `performed ${counter} of ${totalQueryCycles} total query cycles: took ${
+          Date.now() - timeStart
+        }ms to deep query a set of 2000 with memory footprint ${process.memoryUsage().rss / 1e6} MB`
+      );
+    }
     expect(myCars2[0].deepData.sodeep).to.equal('yes');
     expect(myCars2[0].brand).to.equal('Volvo');
     counter++;
-  } while (counter < 30);
+  } while (counter < totalQueryCycles);
 });
 
 tap.test('expect to get instance of Car and update it', async () => {
@@ -137,9 +160,9 @@ tap.test('expect to get instance of Car and update it', async () => {
 });
 
 tap.test('should be able to delete an instance of car', async () => {
-  const myCars = await Car.getInstances<Car>({
+  const myCars = await Car.getInstances({
     brand: 'Volvo',
-    color: 'blue'
+    color: 'blue',
   });
   console.log(myCars);
   expect(myCars[0].color).to.equal('blue');
@@ -177,17 +200,20 @@ class Truck extends smartdata.SmartDataDbDoc<Car, Car> {
 tap.test('should store a new Truck', async () => {
   const truck = new Truck('blue', 'MAN');
   await truck.save();
-  const myTruck = await Truck.getInstance<Truck>({ color: 'blue' });
+  const myTruck = await Truck.getInstance({ color: 'blue' });
   myTruck.id = 'foo';
   await myTruck.save();
-  const myTruck2 = await Truck.getInstance<Truck>({ color: 'blue' });
+  const myTruck2 = await Truck.getInstance({ color: 'blue' });
   console.log(myTruck2);
 });
 
+tap.test('should ', async () => {})
+
 // =======================================
 // close the database connection
 // =======================================
 tap.test('should close the database connection', async (tools) => {
+  await testDb.mongoDb.dropDatabase();
   await testDb.close();
   try {
     await mongod.stop();

test/test.typescript.ts

@@ -0,0 +1,110 @@
+import { tap, expect } from '@pushrocks/tapbundle';
+import { Qenv } from '@pushrocks/qenv';
+
+const testQenv = new Qenv(process.cwd(), process.cwd() + '/.nogit/');
+
+console.log(process.memoryUsage());
+
+// the tested module
+import * as smartdata from '../ts/index';
+
+import * as mongoPlugin from 'mongodb-memory-server';
+import { smartunique } from '../ts/smartdata.plugins';
+
+// =======================================
+// Connecting to the database server
+// =======================================
+
+let testDb: smartdata.SmartdataDb;
+let smartdataOptions: smartdata.IMongoDescriptor;
+let mongod: mongoPlugin.MongoMemoryServer;
+
+const totalCars = 2000;
+
+tap.skip.test('should create a testinstance as database', async () => {
+  mongod = new mongoPlugin.MongoMemoryServer({});
+  console.log('created mongod instance');
+  await mongod._startUpInstance().catch((err) => {
+    console.log(err);
+  });
+  console.log('mongod started');
+  smartdataOptions = {
+    mongoDbName: await mongod.getDbName(),
+    mongoDbPass: '',
+    mongoDbUrl: await mongod.getUri(),
+  };
+  console.log(smartdataOptions);
+  testDb = new smartdata.SmartdataDb(smartdataOptions);
+});
+
+tap.test('should connect to atlas', async (tools) => {
+  const databaseName = `test-smartdata-${smartunique.shortId()}`;
+  testDb = new smartdata.SmartdataDb({
+    mongoDbUrl: testQenv.getEnvVarOnDemand('MONGO_URL'),
+    mongoDbName: databaseName,
+  });
+});
+
+tap.test('should establish a connection to mongod', async () => {
+  await testDb.init();
+});
+
+// =======================================
+// The actual tests
+// =======================================
+
+// ------
+// Collections
+// ------
+@smartdata.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('should close the database connection', async (tools) => {
+  await testDb.mongoDb.dropDatabase();
+  await testDb.close();
+  try {
+    await mongod.stop();
+  } catch (e) {}
+});
+
+tap.start({ throwOnError: true });

ts/smartdata.classes.collection.ts

@@ -14,7 +14,7 @@ export interface IDocValidationFunc<T> {
   (doc: T): boolean;
 }
 
-export type TDelayedDbCreation = () => SmartdataDb;
+export type TDelayed<TDelayedArg> = () => TDelayedArg;
 
 const collectionFactory = new CollectionFactory();
 
@@ -22,19 +22,87 @@ const collectionFactory = new CollectionFactory();
  * This is a decorator that will tell the decorated class what dbTable to use
  * @param dbArg
  */
-export function Collection(dbArg: SmartdataDb | TDelayedDbCreation) {
+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 = (managerArg: IManager,  dbDocArg: any) => {
+  dbDocArg.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['db']) {
+          manager = (managerArg as TManager);
+        } else {
+          manager = (managerArg as TDelayed<TManager>)();
+        }
+        return manager;
+      }
+      public get manager() {
+        let manager: TManager;
+        if (managerArg['db']) {
+          manager = (managerArg as TManager);
+        } else {
+          manager = (managerArg as TDelayed<TManager>)();
+        }
+        return manager;
+      }
+    };
+  };
+}
+
 // tslint:disable-next-line: max-classes-per-file
 export class SmartdataCollection<T> {
   /**

ts/smartdata.classes.collectionfactory.ts

@@ -3,20 +3,20 @@ import { SmartdataCollection } from './smartdata.classes.collection';
 import { SmartdataDb } from './smartdata.classes.db';
 
 export class CollectionFactory {
-  public collections: {[key: string]: SmartdataCollection<any>} = {};
+  public collections: { [key: string]: SmartdataCollection<any> } = {};
 
-  public getCollection = (nameArg: string, dbArg: SmartdataDb | (() => SmartdataDb)): 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);
-        } else {
-          dbArg = dbArg();
-          return new SmartdataCollection(nameArg, dbArg);
         }
       })();
     }
     return this.collections[nameArg];
-  }
+  };
 }

ts/smartdata.classes.db.ts

@@ -43,7 +43,7 @@ export class SmartdataDb {
       useNewUrlParser: true,
       useUnifiedTopology: true,
       maxPoolSize: 100,
-      maxIdleTimeMS: 10
+      maxIdleTimeMS: 10,
     });
     this.mongoDb = this.mongoDbClient.db(this.smartdataOptions.mongoDbName);
     this.status = 'connected';

ts/smartdata.classes.doc.ts

@@ -3,7 +3,7 @@ import * as plugins from './smartdata.plugins';
 import { ObjectMap } from '@pushrocks/lik';
 
 import { SmartdataDb } from './smartdata.classes.db';
-import { SmartdataCollection } from './smartdata.classes.collection';
+import { IManager, SmartdataCollection } from './smartdata.classes.collection';
 
 export type TDocCreation = 'db' | 'new' | 'mixed';
 
@@ -41,12 +41,15 @@ export function unI() {
   };
 }
 
-export class SmartDataDbDoc<T, TImplements> {
+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;
 
   /**
    * how the Doc in memory was created, may prove useful later.
@@ -79,13 +82,35 @@ export class SmartDataDbDoc<T, TImplements> {
   constructor() {}
 
   public static async getInstances<T>(
+    this: plugins.tsclass.typeFest.Class<T>,
     filterArg: plugins.tsclass.typeFest.PartialDeep<T>
   ): Promise<T[]> {
-    const foundDocs = await this.collection.find(filterArg);
+    const convertedFilter: any = {};
+    const convertFilterArgument = (keyPathArg: string, filterArg2: any) => {
+      if (typeof filterArg2 === 'object') {
+        for (const key of Object.keys(filterArg2)) {
+          if (key.startsWith('$')) {
+            convertedFilter[keyPathArg] = filterArg2;
+            return;
+          } else if (key.includes('.')) {
+            throw new Error('keys cannot contain dots');
+          }
+        }
+        for (const key of Object.keys(filterArg2)) {
+          convertFilterArgument(`${keyPathArg}.${key}`, filterArg2[key]);
+        } 
+      } else {
+        convertedFilter[keyPathArg] = filterArg2
+      }
+    }
+    for (const key of Object.keys(filterArg)) {
+      convertFilterArgument(key, filterArg[key]);
+    }
+    const foundDocs = await (this as any).collection.find(convertedFilter);
     const returnArray = [];
     for (const item of foundDocs) {
       const newInstance = new this();
-      newInstance.creationStatus = 'db';
+      (newInstance as any).creationStatus = 'db';
       for (const key of Object.keys(item)) {
         newInstance[key] = item[key];
       }
@@ -95,9 +120,10 @@ export class SmartDataDbDoc<T, TImplements> {
   }
 
   public static async getInstance<T>(
+    this: plugins.tsclass.typeFest.Class<T>,
     filterArg: plugins.tsclass.typeFest.PartialDeep<T>
   ): Promise<T> {
-    const result = await this.getInstances<T>(filterArg);
+    const result = await (this as any).getInstances(filterArg);
     if (result && result.length > 0) {
       return result[0];
     }