4.0.9

package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@pushrocks/smartdata",
-  "version": "4.0.1",
+  "version": "4.0.9",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@pushrocks/smartdata",
-      "version": "4.0.1",
+      "version": "4.0.9",
       "license": "MIT",
       "dependencies": {
         "@pushrocks/lik": "^4.0.20",

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pushrocks/smartdata",
-  "version": "4.0.1",
+  "version": "4.0.9",
   "private": false,
   "description": "do more with data",
   "main": "dist_ts/index.js",

test/test.ts

@@ -213,6 +213,7 @@ 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,107 @@
+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
+// ------
+class CarTemplate extends smartdata.SmartDataDbDoc<CarTemplate, CarTemplate> {
+  @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) => {
+  console.log(this);
+  @smartdata.Collection(() => {
+    return dbArg;
+  })
+  class Car extends CarTemplate {};
+  return Car;
+};
+
+tap.test('should prodice a car', async () => {
+  const CarClass = createCarClass(testDb);
+  const carInstance = new CarClass('red', 'Mercedes');
+  await carInstance.save();
+});
+
+// =======================================
+// 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,76 @@ 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
+}
+
+/**
+ * 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[]): {} }>(constructor: T) {
+    return class extends constructor {
+      public static get collection() {
+        let dbArg: SmartdataDb;
+        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['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

@@ -7,16 +7,13 @@ export class CollectionFactory {
 
   public getCollection = (
     nameArg: string,
-    dbArg: SmartdataDb | (() => SmartdataDb)
+    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);
         }
       })();
     }

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,14 @@ export function unI() {
   };
 }
 
-export class SmartDataDbDoc<T extends TImplements, 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 manager;
+  public manager: TManager;
 
   /**
    * how the Doc in memory was created, may prove useful later.