@reldens/storage 0.5.0-beta.7 → 0.10.0-beta.21

package/index.js

@@ -6,18 +6,21 @@
 
 const { BaseDataServer } = require('./lib/base-data-server');
 const { BaseDriver } = require('./lib/base-driver');
-const { ObjectionJsDriver } = require('./lib/objection-js-driver');
-const { ObjectionJsDataServer } = require('./lib/objection-js-data-server');
-const { MikroOrmDriver } = require('./lib/mikro-orm-driver');
-const { ModelClassDeprecated } = require('./lib/objection-js-model-deprecated');
+const { ObjectionJsDriver } = require('./lib/objection-js/objection-js-driver');
+const { ObjectionJsDataServer } = require('./lib/objection-js/objection-js-data-server');
+const { Model } = require('objection');
+const { MikroOrmDriver } = require('./lib/mikro-orm/mikro-orm-driver');
+const { MikroOrmDataServer } = require('./lib/mikro-orm/mikro-orm-data-server');
 
 module.exports = {
-    ModelClassDeprecated: ModelClassDeprecated,
-    // databases:
+    // base:
     BaseDataServer: BaseDataServer,
-    ObjectionJsDataServer: ObjectionJsDataServer,
-    // drivers:
     BaseDriver: BaseDriver,
+    // objection-js:
+    ObjectionJsDataServer: ObjectionJsDataServer,
     ObjectionJsDriver: ObjectionJsDriver,
+    ObjectionJsRawModel: Model,
+    // mikro-orm:
+    MikroOrmDataServer: MikroOrmDataServer,
     MikroOrmDriver: MikroOrmDriver
 };

package/lib/base-data-server.js

@@ -34,6 +34,11 @@ class BaseDataServer
         ErrorManager.error('BaseDriver generateEntities() not implemented.');
     }
 
+    getEntity(entityName)
+    {
+        return this.entityManager.get(entityName);
+    }
+
 }
 
 module.exports.BaseDataServer = BaseDataServer;

package/lib/base-driver.js

@@ -4,7 +4,7 @@
  *
  */
 
-const { ErrorManager, sc } = require('@reldens/utils');
+const { ErrorManager, sc, Logger} = require('@reldens/utils');
 
 class BaseDriver
 {
@@ -27,99 +27,108 @@ class BaseDriver
         ErrorManager.error('BaseDriver name() not implemented.');
     }
 
-    async create(params)
+    create(params)
     {
         ErrorManager.error('BaseDriver create() not implemented.');
     }
 
-    async update(filters, updatePatch)
+    createWithRelations(params, relations)
+    {
+        ErrorManager.error('BaseDriver create() not implemented.');
+    }
+
+    update(filters, updatePatch)
     {
         ErrorManager.error('BaseDriver update() not implemented.');
     }
 
-    async updateBy(field, fieldValue, updatePatch)
+    updateBy(field, fieldValue, updatePatch)
     {
         ErrorManager.error('BaseDriver updateBy() not implemented.');
     }
 
-    async updateById(id, params)
+    updateById(id, params)
     {
         ErrorManager.error('BaseDriver updateById() not implemented.');
     }
 
-    async delete(id)
+    delete(id)
     {
         ErrorManager.error('BaseDriver delete() not implemented.');
     }
 
-    async count(filters)
+    count(filters)
     {
         ErrorManager.error('BaseDriver count() not implemented.');
     }
 
-    async loadAll()
+    loadAll()
     {
         ErrorManager.error('BaseDriver loadAll() not implemented.');
     }
 
-    async loadAllWithRelations(relations)
+    loadAllWithRelations(relations)
     {
         ErrorManager.error('BaseDriver loadAllWithRelations() not implemented.');
     }
 
-    async load(filters)
+    load(filters)
     {
         ErrorManager.error('BaseDriver load() not implemented.');
     }
 
-    async loadWithRelations(filters, relations)
+    loadWithRelations(filters, relations)
     {
         ErrorManager.error('BaseDriver loadWithRelations() not implemented.');
     }
 
-    async loadBy(field, value)
+    loadBy(field, value)
     {
         ErrorManager.error('BaseDriver loadBy() not implemented.');
     }
 
-    async loadByWithRelations(field, value, relations)
+    loadByWithRelations(field, value, relations)
     {
         ErrorManager.error('BaseDriver loadByWithRelations() not implemented.');
     }
 
-    async loadById(id)
+    loadById(id)
     {
         ErrorManager.error('BaseDriver loadById() not implemented.');
     }
 
-    async loadByIdWithRelations(id, relations)
+    loadByIdWithRelations(id, relations)
     {
         ErrorManager.error('BaseDriver loadByIdWithRelations() not implemented.');
     }
 
-    async loadOne(filters)
+    loadOne(filters)
     {
         ErrorManager.error('BaseDriver load() not implemented.');
     }
 
-    async loadOneWithRelations(filters, relations)
+    loadOneWithRelations(filters, relations)
     {
         ErrorManager.error('BaseDriver loadWithRelations() not implemented.');
     }
 
-    async loadOneBy(field, value)
+    loadOneBy(field, value)
     {
         ErrorManager.error('BaseDriver loadBy() not implemented.');
     }
 
-    async loadOneByWithRelations(field, value, relations)
+    loadOneByWithRelations(field, value, relations)
     {
         ErrorManager.error('BaseDriver loadByWithRelations() not implemented.');
     }
 
-    async orderBy(result)
+    executeCustomQuery(methodName)
     {
-        ErrorManager.error('BaseDriver orderBy() not implemented.');
+        if(typeof this.rawModel[methodName] !== 'function'){
+            Logger.error('Custom query method not found in raw model.', methodName, this.rawModel);
+            return false;
+        }
+        return this.rawModel[methodName]();
     }
 
 }

package/lib/mikro-orm/mikro-orm-data-server.js

@@ -0,0 +1,20 @@
+/**
+ *
+ * Reldens - MikroOrmDataServer
+ *
+ */
+
+const { BaseDataServer } = require('../base-data-server');
+
+class MikroOrmDataServer extends BaseDataServer
+{
+
+    constructor(props)
+    {
+        super(props);
+        // @TODO: implement.
+    }
+
+}
+
+module.exports.MikroOrmDataServer = MikroOrmDataServer;

package/lib/{mikro-orm-driver.js → mikro-orm/mikro-orm-driver.js}

@@ -4,7 +4,7 @@
  *
  */
 
-const { BaseDriver } = require('./base-driver');
+const { BaseDriver } = require('../base-driver');
 
 class MikroOrmDriver extends BaseDriver
 {

package/lib/{objection-js-data-server.js → objection-js/objection-js-data-server.js}

@@ -4,11 +4,10 @@
  *
  */
 
-const { BaseDataServer } = require('./base-data-server');
-const { ModelClassDeprecated } = require('./objection-js-model-deprecated');
+const { BaseDataServer } = require('../base-data-server');
 const { ObjectionJsDriver } = require('./objection-js-driver');
+const { Model } = require('objection');
 const Knex = require('knex');
-const { sc } = require('@reldens/utils');
 
 class ObjectionJsDataServer extends BaseDataServer
 {
@@ -16,8 +15,10 @@ class ObjectionJsDataServer extends BaseDataServer
     constructor(props)
     {
         super(props);
-        this.rawModel = sc.getDef(props, 'rawModel', ModelClassDeprecated);
         this.knex = false;
+        if(!this.rawModel){
+            this.rawModel = Model;
+        }
     }
 
     connect()

package/lib/{objection-js-driver.js → objection-js/objection-js-driver.js}

@@ -4,7 +4,7 @@
  *
  */
 
-const { BaseDriver } = require('./base-driver');
+const { BaseDriver } = require('../base-driver');
 const { sc } = require('@reldens/utils');
 
 class ObjectionJsDriver extends BaseDriver
@@ -25,105 +25,101 @@ class ObjectionJsDriver extends BaseDriver
         return this.name || this.rawModel.tableName;
     }
 
-    async create(params)
+    create(params)
     {
         this.rawModel.query().insert(params);
     }
 
-    async update(filters, updatePatch)
+    createWithRelations(params, relations)
+    {
+        return this.rawModel.query().insertGraphAndFetch(params);
+    }
+
+    update(filters, updatePatch)
     {
         return this.rawModel.query().patch(updatePatch).where(filters);
     }
 
-    async updateBy(field, fieldValue, updatePatch)
+    updateBy(field, fieldValue, updatePatch)
     {
         return this.rawModel.query().patch(updatePatch).where(field, fieldValue);
     }
 
-    async updateById(id, params)
+    updateById(id, params)
     {
-        return this.rawModel.query().patch(params).where(this.id, id);
+        return this.rawModel.query().patchAndFetchById(id, params);
     }
 
-    async delete(id)
+    delete(id)
     {
-        return this.rawModel.delete().where(this.id, id);
+        return this.rawModel.query().deleteById(id);
     }
 
-    async count(filters)
+    count(filters)
     {
         return this.rawModel.query().count().where(filters);
     }
 
-    async loadAll()
+    loadAll()
     {
         return this.rawModel.query();
     }
 
-    async loadAllWithRelations(relations)
+    loadAllWithRelations(relations)
     {
         return this.appendRelationsToQuery(this.rawModel.query(), relations);
     }
 
-    async load(filters)
+    load(filters)
     {
         return this.rawModel.query().where(filters);
     }
 
-    async loadWithRelations(filters, relations)
+    loadWithRelations(filters, relations)
     {
         return this.appendRelationsToQuery(this.rawModel.query().where(filters), relations);
     }
 
-    async loadBy(field, value)
+    loadBy(field, value)
     {
         return this.rawModel.query().where(field, value);
     }
 
-    async loadByWithRelations(field, value, relations)
+    loadByWithRelations(field, value, relations)
     {
         return this.appendRelationsToQuery(this.rawModel.query().where(field, value), relations);
     }
 
-    async loadById(id)
+    loadById(id)
     {
         return this.rawModel.query().findById(id);
     }
 
-    async loadByIdWithRelations(id, relations)
+    loadByIdWithRelations(id, relations)
     {
         return this.appendRelationsToQuery(this.rawModel.query().findById(id), relations);
     }
 
-    async loadOne(filters)
+    loadOne(filters)
     {
         return this.rawModel.query().where(filters).limit(1).first();
     }
 
-    async loadOneWithRelations(filters, relations)
+    loadOneWithRelations(filters, relations)
     {
         return this.appendRelationsToQuery(this.rawModel.query().where(field, value), relations).limit(1).first();
     }
 
-    async loadOneBy(field, value)
+    loadOneBy(field, value)
     {
         return this.rawModel.query().where(field, value).first();
     }
 
-    async loadOneByWithRelations(field, value, relations)
+    loadOneByWithRelations(field, value, relations)
     {
         return this.appendRelationsToQuery(this.rawModel.query().where(field, value), relations).limit(1).first();
     }
 
-    async orderBy(result, fieldName)
-    {
-        return result.modifiers({
-            orderByKey(builder){
-                builder.orderBy(fieldName);
-            }
-        });
-    }
-
     appendRelationsToQuery(queryBuilder, relations)
     {
         if(!sc.isArray(relations) || relations.length === 0){

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@reldens/storage",
     "scope": "@reldens",
-    "version": "0.5.0-beta.7",
+    "version": "0.10.0-beta.21",
     "description": "Reldens - Storage",
     "author": "Damian A. Pastorini",
     "license": "MIT",
@@ -15,8 +15,12 @@
     "keywords": [
         "reldens",
         "storage",
+        "objection",
         "objectionjs",
+        "objection-js",
+        "mikro",
         "mikroorm",
+        "mikro-orm",
         "driver",
         "orm",
         "database",
@@ -40,9 +44,9 @@
         "url": "https://github.com/damian-pastorini/reldens-storage/issues"
     },
     "dependencies": {
-        "@reldens/utils": "^0.4.6",
-        "knex": "^0.21.21",
-        "objection": "^2.2.15",
+        "@reldens/utils": "^0.5.0",
+        "knex": "^0.95.14",
+        "objection": "^3.0.0",
         "mysql": "^2.18.1"
     }
 }

package/lib/objection-js-model-deprecated.js

@@ -1,51 +0,0 @@
-/**
- *
- * Reldens - ObjectionModel
- *
- * Objection JS Model wrapper.
- *
- */
-
-const { Model } = require('objection');
-
-class ObjectionJsModelDeprecated extends Model
-{
-
-    static loadAll(withRelations)
-    {
-        let result = this.query();
-        let relations = Object.keys(this.relationMappings || {});
-        if(withRelations === true && relations){
-            result.withGraphFetched('['+relations.join(',')+']');
-        }
-        return result;
-    }
-
-    static loadById(id, withRelations)
-    {
-        let result = this.query();
-        let relations = Object.keys(this.relationMappings || {});
-        if(withRelations === true && relations.length > 0){
-            result.withGraphFetched('['+relations.join(',')+']');
-        }
-        return result.findById(id);
-    }
-
-    static loadBy(field, value, withRelations)
-    {
-        let result = this.query();
-        let relations = Object.keys((this.relationMappings || {}));
-        if(withRelations === true && relations.length > 0){
-            result.withGraphFetched('['+relations.join(',')+']');
-        }
-        return result.where(field, value);
-    }
-
-    static updateBy(field, fieldValue, updatePatch)
-    {
-        return this.query().patch(updatePatch).where(field, fieldValue);
-    }
-
-}
-
-module.exports.ModelClassDeprecated = ObjectionJsModelDeprecated;