4.0.0

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pushrocks/smartdata",
-  "version": "3.1.52",
+  "version": "4.0.0",
   "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/smartstring": "^3.0.18",
-    "@tsclass/tsclass": "^3.0.25",
-    "@types/lodash": "^4.14.161",
-    "@types/mongodb": "^3.5.27",
-    "lodash": "^4.17.20",
-    "mongodb": "^3.6.2",
+    "@pushrocks/smartpromise": "^3.1.5",
+    "@pushrocks/smartstring": "^3.0.24",
+    "@tsclass/tsclass": "^3.0.33",
+    "@types/lodash": "^4.14.169",
+    "@types/mongodb": "^3.6.12",
+    "lodash": "^4.17.21",
+    "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"
   },

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) {
-      console.log(`Filled database with ${counter} of ${totalCars} Cars`);
+    if (counter % 100 === 0) {
+      console.log(
+        `Filled database with ${counter} of ${totalCars} Cars and memory usage ${
+          process.memoryUsage().rss / 1e6
+        } MB`
+      );
     }
   } while (counter < totalCars);
+  console.log(process.memoryUsage());
 });
 
 tap.test('expect to get instance of Car with shallow match', async () => {
+  const totalQueryCycles = totalCars / 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>({
-      'deepData.sodeep': 'yes',
-    } as any);
-    console.log(`took ${Date.now() - timeStart}ms to query a set of 2000`);
+    const myCars2 = await Car.getInstances({
+      deepData: {
+        sodeep: 'yes'
+      },
+    });
+    if (counter % 10 === 0) {
+      console.log(
+        `performed ${counter} of ${totalQueryCycles} total query cycles: took ${
+          Date.now() - timeStart
+        }ms to deep query a set of 2000 with memory footprint ${process.memoryUsage().rss / 1e6} MB`
+      );
+    }
     expect(myCars2[0].deepData.sodeep).to.equal('yes');
     expect(myCars2[0].brand).to.equal('Volvo');
     counter++;
-  } while (counter < 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,13 +200,15 @@ 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
 // =======================================

ts/smartdata.classes.collectionfactory.ts

@@ -3,9 +3,12 @@ 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 | (() => SmartdataDb)
+  ): SmartdataCollection<any> => {
     if (!this.collections[nameArg]) {
       this.collections[nameArg] = (() => {
         if (dbArg instanceof SmartdataDb) {
@@ -18,5 +21,5 @@ export class CollectionFactory {
       })();
     }
     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

@@ -41,7 +41,7 @@ export function unI() {
   };
 }
 
-export class SmartDataDbDoc<T, TImplements> {
+export class SmartDataDbDoc<T extends TImplements, TImplements> {
   /**
    * the collection object an Doc belongs to
    */
@@ -79,13 +79,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 +117,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];
     }