@reldens/storage 0.5.0-beta.9 → 0.10.0-beta.23

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, Logger} = require('@reldens/utils');
+const { ErrorManager, Logger, sc } = require('@reldens/utils');
 
 class BaseDriver
 {
@@ -13,8 +13,17 @@ class BaseDriver
     {
         this.config = sc.getDef(props, 'config', false);
         this.rawModel = sc.getDef(props, 'rawModel', false);
-        this.id = sc.getDef(props, 'id', false);
-        this.name = sc.getDef(props, 'name', false);
+        this.rawId = sc.getDef(props, 'id', false);
+        this.rawName = sc.getDef(props, 'name', false);
+        this.limit = sc.getDef(props, 'limit', 0);
+        this.offset = sc.getDef(props, 'offset', 0);
+        this.sortBy = sc.getDef(props, 'sortBy', false);
+        this.sortDirection = sc.getDef(props, 'sortDirection', false);
+    }
+
+    databaseName()
+    {
+        ErrorManager.error('BaseDriver databaseName() not implemented.');
     }
 
     id()
@@ -32,12 +41,17 @@ class BaseDriver
         ErrorManager.error('BaseDriver create() not implemented.');
     }
 
+    createWithRelations(params, relations)
+    {
+        ErrorManager.error('BaseDriver create() not implemented.');
+    }
+
     update(filters, updatePatch)
     {
         ErrorManager.error('BaseDriver update() not implemented.');
     }
 
-    updateBy(field, fieldValue, updatePatch)
+    updateBy(field, fieldValue, updatePatch, operator = null)
     {
         ErrorManager.error('BaseDriver updateBy() not implemented.');
     }
@@ -57,6 +71,11 @@ class BaseDriver
         ErrorManager.error('BaseDriver count() not implemented.');
     }
 
+    countWithRelations(filters, relations)
+    {
+        ErrorManager.error('BaseDriver countWithRelations() not implemented.');
+    }
+
     loadAll()
     {
         ErrorManager.error('BaseDriver loadAll() not implemented.');
@@ -77,12 +96,12 @@ class BaseDriver
         ErrorManager.error('BaseDriver loadWithRelations() not implemented.');
     }
 
-    loadBy(field, value)
+    loadBy(field, fieldValue, operator = null)
     {
         ErrorManager.error('BaseDriver loadBy() not implemented.');
     }
 
-    loadByWithRelations(field, value, relations)
+    loadByWithRelations(field, fieldValue, relations, operator = null)
     {
         ErrorManager.error('BaseDriver loadByWithRelations() not implemented.');
     }
@@ -97,6 +116,11 @@ class BaseDriver
         ErrorManager.error('BaseDriver loadByIdWithRelations() not implemented.');
     }
 
+    loadByIds(ids)
+    {
+        ErrorManager.error('BaseDriver loadByIds() not implemented.');
+    }
+
     loadOne(filters)
     {
         ErrorManager.error('BaseDriver load() not implemented.');
@@ -107,23 +131,23 @@ class BaseDriver
         ErrorManager.error('BaseDriver loadWithRelations() not implemented.');
     }
 
-    loadOneBy(field, value)
+    loadOneBy(field, fieldValue, operator = null)
     {
         ErrorManager.error('BaseDriver loadBy() not implemented.');
     }
 
-    loadOneByWithRelations(field, value, relations)
+    loadOneByWithRelations(field, fieldValue, relations, operator = null)
     {
         ErrorManager.error('BaseDriver loadByWithRelations() not implemented.');
     }
 
-    executeCustomQuery(methodName)
+    executeCustomQuery(methodName, methodOptions)
     {
         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]();
+        return this.rawModel[methodName](methodOptions);
     }
 
 }

package/lib/objection-js/objection-js-driver.js

@@ -15,104 +15,195 @@ class ObjectionJsDriver extends BaseDriver
         super(props);
     }
 
+    databaseName()
+    {
+        return this.rawModel.knex().client.config.connection.database || '';
+    }
+
     id()
     {
-        return this.id || this.name();
+        return this.rawModel.tableName || this.name();
     }
 
     name()
     {
-        return this.name || this.rawModel.tableName;
+        return this.rawName || this.rawModel.tableName;
+    }
+
+    tableName()
+    {
+        return this.rawModel.tableName;
     }
 
     create(params)
     {
-        this.rawModel.query().insert(params);
+        return this.queryBuilder().insert(params);
+    }
+
+    createWithRelations(params, relations)
+    {
+        return this.queryBuilder().insertGraphAndFetch(params);
     }
 
     update(filters, updatePatch)
     {
-        return this.rawModel.query().patch(updatePatch).where(filters);
+        let queryBuilder = this.queryBuilder(true, true, true);
+        this.appendFilters(queryBuilder, filters);
+        return queryBuilder.patch(updatePatch);
     }
 
-    updateBy(field, fieldValue, updatePatch)
+    updateBy(field, fieldValue, updatePatch, operator = null)
     {
-        return this.rawModel.query().patch(updatePatch).where(field, fieldValue);
+        let queryBuilder = this.queryBuilder(true, true, true);
+        this.appendSingleFilter(queryBuilder, field, fieldValue, operator);
+        return queryBuilder.patch(updatePatch);
     }
 
     updateById(id, params)
     {
-        return this.rawModel.query().patch(params).where(this.id, id);
+        return this.queryBuilder().patchAndFetchById(id, params);
     }
 
     delete(id)
     {
-        return this.rawModel.delete().where(this.id, id);
+        return this.queryBuilder().deleteById(id);
     }
 
-    count(filters)
+    async count(filters)
     {
-        return this.rawModel.query().count().where(filters);
+        let queryBuilder = this.queryBuilder(true, true, true);
+        this.appendFilters(queryBuilder, filters);
+        let count = await queryBuilder.count().first();
+        return count ? count['count(*)'] : 0;
+    }
+
+    async countWithRelations(filters, relations)
+    {
+        let queryBuilder = this.queryBuilder(true, true, true);
+        this.appendFilters(queryBuilder, filters);
+        let count = await this.appendRelationsToQuery(queryBuilder, relations).count().first();
+        return count ? count['count(*)'] : 0;
     }
 
     loadAll()
     {
-        return this.rawModel.query();
+        return this.queryBuilder();
     }
 
     loadAllWithRelations(relations)
     {
-        return this.appendRelationsToQuery(this.rawModel.query(), relations);
+        return this.appendRelationsToQuery(this.queryBuilder(), relations);
     }
 
     load(filters)
     {
-        return this.rawModel.query().where(filters);
+        let queryBuilder = this.queryBuilder(true, true, true);
+        this.appendFilters(queryBuilder, filters);
+        return queryBuilder;
     }
 
     loadWithRelations(filters, relations)
     {
-        return this.appendRelationsToQuery(this.rawModel.query().where(filters), relations);
+        let queryBuilder = this.queryBuilder(true, true, true);
+        this.appendFilters(queryBuilder, filters);
+        return this.appendRelationsToQuery(queryBuilder, relations);
     }
 
-    loadBy(field, value)
+    loadBy(field, fieldValue, operator = null)
     {
-        return this.rawModel.query().where(field, value);
+        let queryBuilder = this.queryBuilder(true, true, true);
+        this.appendSingleFilter(queryBuilder, field, fieldValue, operator);
+        return queryBuilder;
     }
 
-    loadByWithRelations(field, value, relations)
+    loadByWithRelations(field, fieldValue, relations, operator = null)
     {
-        return this.appendRelationsToQuery(this.rawModel.query().where(field, value), relations);
+        let queryBuilder = this.queryBuilder(true, true, true);
+        this.appendSingleFilter(queryBuilder, field, fieldValue, operator);
+        return this.appendRelationsToQuery(queryBuilder, relations);
     }
 
     loadById(id)
     {
-        return this.rawModel.query().findById(id);
+        return this.queryBuilder().findById(id);
     }
 
     loadByIdWithRelations(id, relations)
     {
-        return this.appendRelationsToQuery(this.rawModel.query().findById(id), relations);
+        return this.appendRelationsToQuery(this.queryBuilder().findById(id), relations);
+    }
+
+    loadByIds(ids)
+    {
+        let queryBuilder = this.queryBuilder();
+        for(let id of ids){
+            queryBuilder.where(this.rawModel.idColumn, id);
+        }
+        return queryBuilder;
     }
 
     loadOne(filters)
     {
-        return this.rawModel.query().where(filters).limit(1).first();
+        let queryBuilder = this.queryBuilder(false, true, true);
+        this.appendFilters(queryBuilder, filters);
+        return queryBuilder.limit(1).first();
     }
 
     loadOneWithRelations(filters, relations)
     {
-        return this.appendRelationsToQuery(this.rawModel.query().where(field, value), relations).limit(1).first();
+        let queryBuilder = this.queryBuilder(false, true, true);
+        this.appendFilters(queryBuilder, filters);
+        return this.appendRelationsToQuery(queryBuilder, relations).limit(1).first();
+    }
+
+    loadOneBy(field, fieldValue, operator = null)
+    {
+        let queryBuilder = this.queryBuilder(false, true, true);
+        this.appendSingleFilter(queryBuilder, field, fieldValue, operator);
+        return queryBuilder.limit(1).first();
+    }
+
+    loadOneByWithRelations(field, fieldValue, relations, operator = null)
+    {
+        let queryBuilder = this.queryBuilder(false, true, true);
+        this.appendSingleFilter(queryBuilder, field, fieldValue, operator);
+        return this.appendRelationsToQuery(queryBuilder, relations).limit(1).first();
+    }
+
+    queryBuilder(useLimit = false, useOffset = false, useSort = false)
+    {
+        let queryBuilder = this.rawModel.query();
+        if(useLimit && 0 !== this.limit){
+            queryBuilder.limit(this.limit)
+        }
+        if(useOffset && 0 !== this.offset){
+            queryBuilder.offset(this.offset)
+        }
+        if(useSort && false !== this.sortBy && false !== this.sortDirection){
+            queryBuilder.orderBy(this.sortBy, this.sortDirection)
+        }
+        return queryBuilder;
     }
 
-    loadOneBy(field, value)
+    appendSingleFilter(queryBuilder, field, fieldValue, operator = null)
     {
-        return this.rawModel.query().where(field, value).first();
+        (null === operator) ? queryBuilder.where(field, fieldValue) : queryBuilder.where(field, operator, fieldValue);
+        return queryBuilder;
     }
 
-    loadOneByWithRelations(field, value, relations)
+    appendFilters(queryBuilder, filters)
     {
-        return this.appendRelationsToQuery(this.rawModel.query().where(field, value), relations).limit(1).first();
+        let filtersKeys = Object.keys(filters);
+        if(0 === filtersKeys.length){
+            return queryBuilder;
+        }
+        for(let i of filtersKeys){
+            let filter = filters[i];
+            sc.hasOwn(filter, 'operator')
+                ? queryBuilder.where(i, filter.operator, filter.value)
+                : queryBuilder.where(i, filter);
+        }
+        return queryBuilder;
     }
 
     appendRelationsToQuery(queryBuilder, relations)

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@reldens/storage",
     "scope": "@reldens",
-    "version": "0.5.0-beta.9",
+    "version": "0.10.0-beta.23",
     "description": "Reldens - Storage",
     "author": "Damian A. Pastorini",
     "license": "MIT",
@@ -44,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"
     }
 }