@reldens/storage 0.59.0 → 0.61.0

package/lib/base-data-server.js

@@ -5,7 +5,7 @@
  */
 
 const { EntityManager } = require('./entity-manager');
-const { ErrorManager, sc } = require('@reldens/utils');
+const { ErrorManager, Logger, sc } = require('@reldens/utils');
 
 class BaseDataServer
 {
@@ -16,6 +16,9 @@ class BaseDataServer
         if(!this.config.host){
             this.config.host = 'localhost';
         }
+        if(!this.config.port){
+            this.config.port = 3306;
+        }
         this.client = sc.get(props, 'client', '');
         this.poolConfig = sc.get(props, 'poolConfig', {});
         this.connectStringOptions = sc.get(props, 'connectStringOptions', '');
@@ -27,16 +30,23 @@ class BaseDataServer
         this.initialized = sc.get(props, 'initialized', false);
         this.rawEntities = props.rawEntities;
         this.entities = props.entities || {};
+        this.entitiesConfig = sc.get(props, 'entitiesConfig', {});
         this.entityManager = new EntityManager({entities: this.entities});
     }
 
     createConnectionString()
     {
-        return (this.client || 'client-not-specified')+'://'
-            +(this.config.user || 'user-not-specified')
+        if('' === this.client){
+            Logger.warning('Client is empty, connection may fail.');
+        }
+        if('' === this.config.user){
+            Logger.warning('User is empty, connection may fail.');
+        }
+        return (this.client || '')+'://'
+            +(this.config.user || '')
             +(this.config.password ? ':'+this.config.password : '')
             +'@'+this.config.host
-            +':'+(this.config.port || 3306)
+            +':'+this.config.port
             +(this.config.database ? '/'+this.config.database : '')
             +(this.connectStringOptions ? '?'+this.connectStringOptions : '');
     }

package/lib/base-driver.js

@@ -20,6 +20,7 @@ class BaseDriver
         this.offset = sc.get(props, 'offset', 0);
         this.sortBy = sc.get(props, 'sortBy', false);
         this.sortDirection = sc.get(props, 'sortDirection', 'ASC');
+        this.entityConfig = sc.get(props, 'entityConfig', {});
     }
 
     databaseName()
@@ -164,7 +165,7 @@ class BaseDriver
 
     executeCustomQuery(methodName, methodOptions)
     {
-        if(typeof this.rawModel[methodName] !== 'function'){
+        if('function' !== typeof this.rawModel[methodName]){
             Logger.error('Custom query method not found in raw model.', methodName, this.rawModel);
             return false;
         }
@@ -176,6 +177,68 @@ class BaseDriver
         ErrorManager.error('BaseDriver rawQuery() not implemented.');
     }
 
+    isJsonField(fieldName)
+    {
+        if(!this.entityConfig || !this.rawName){
+            return false;
+        }
+        let properties = sc.get(this.entityConfig, 'properties', {});
+        let fieldConfig = sc.get(properties, fieldName, {});
+        let fieldType = sc.get(fieldConfig, 'type', '');
+        return 'json' === fieldType.toLowerCase();
+    }
+
+    parseRelationsString(relationsString)
+    {
+        if(!relationsString || '' === relationsString.trim()){
+            return [];
+        }
+        return relationsString.split(',').map(relation => relation.trim()).filter(relation => '' !== relation);
+    }
+
+    applyQueryOptions(queryOptions)
+    {
+        if(sc.hasOwn(queryOptions, 'limit')){
+            this.limit = queryOptions.limit;
+        }
+        if(sc.hasOwn(queryOptions, 'offset')){
+            this.offset = queryOptions.offset;
+        }
+        if(sc.hasOwn(queryOptions, 'sortBy')){
+            this.sortBy = queryOptions.sortBy;
+        }
+        if(sc.hasOwn(queryOptions, 'sortDirection')){
+            this.sortDirection = queryOptions.sortDirection;
+        }
+    }
+
+    preserveEntityState()
+    {
+        return {
+            limit: this.limit,
+            offset: this.offset,
+            sortBy: this.sortBy,
+            sortDirection: this.sortDirection
+        };
+    }
+
+    restoreEntityState(originalState)
+    {
+        this.limit = originalState.limit;
+        this.offset = originalState.offset;
+        this.sortBy = originalState.sortBy;
+        this.sortDirection = originalState.sortDirection;
+    }
+
+    async loadEntityData(filters, queryOptions, relationsString)
+    {
+        this.applyQueryOptions(queryOptions);
+        let relations = this.parseRelationsString(relationsString);
+        return 0 < relations.length
+            ? await this.loadWithRelations(filters, relations)
+            : 0 < Object.keys(filters).length ? await this.load(filters) : await this.loadAll();
+    }
+
 }
 
 module.exports.BaseDriver = BaseDriver;

package/lib/mikro-orm/mikro-orm-driver.js

@@ -68,7 +68,8 @@ class MikroOrmDriver extends BaseDriver
 
     async update(filters, updatePatch)
     {
-        let entities = await this.repository.find(filters, this.queryBuilder(true, true, true));
+        let processedFilters = this.processFilters(filters);
+        let entities = await this.repository.find(processedFilters, this.queryBuilder(true, true, true));
         if(0 === entities.length){
             return false;
         }
@@ -83,7 +84,8 @@ class MikroOrmDriver extends BaseDriver
     async updateBy(field, fieldValue, updatePatch, operator = null)
     {
         let filter = this.createSingleFilter(field, fieldValue, operator);
-        let entities = await this.repository.find(filter, this.queryBuilder(true, true, true));
+        let processedFilters = this.processFilters(filter);
+        let entities = await this.repository.find(processedFilters, this.queryBuilder(true, true, true));
         if(0 === entities.length){
             return false;
         }
@@ -118,8 +120,9 @@ class MikroOrmDriver extends BaseDriver
 
     async delete(filters = {})
     {
-        let entries = await this.load(filters);
-        if (!entries){
+        let processedFilters = this.processFilters(filters);
+        let entries = await this.repository.find(processedFilters);
+        if(!entries){
             return false;
         }
         for(let entry of entries){
@@ -134,13 +137,14 @@ class MikroOrmDriver extends BaseDriver
 
     async count(filters)
     {
-        return this.repository.count(filters);
+        let processedFilters = this.processFilters(filters);
+        return this.repository.count(processedFilters);
     }
 
     async countWithRelations(filters, relations)
     {
-        // @TODO - BETA - Look a way to filter by sub-entities properties before count.
-        return this.count(filters);
+        let processedFilters = this.processFilters(filters);
+        return this.repository.count(processedFilters);
     }
 
     loadAll()
@@ -156,74 +160,135 @@ class MikroOrmDriver extends BaseDriver
 
     load(filters)
     {
-        return this.repository.find(filters, this.queryBuilder(true, true, true));
+        let processedFilters = this.processFilters(filters);
+        return this.repository.find(processedFilters, this.queryBuilder(true, true, true));
     }
 
     async loadWithRelations(filters, relations)
     {
-        let entitiesCollection = await this.repository.findAll(filters, this.queryBuilder(true, true, true));
+        let processedFilters = this.processFilters(filters);
+        let entitiesCollection = await this.repository.find(processedFilters, this.queryBuilder(true, true, true));
         return await this.appendRelationsToCollection(entitiesCollection, relations);
     }
 
     loadBy(field, fieldValue, operator = null)
     {
         let filter = this.createSingleFilter(field, fieldValue, operator);
-        return this.repository.find(filter, this.queryBuilder(true, true, true));
+        let processedFilters = this.processFilters(filter);
+        return this.repository.find(processedFilters, this.queryBuilder(true, true, true));
     }
 
     async loadByWithRelations(field, fieldValue, relations, operator = null)
     {
         let filter = this.createSingleFilter(field, fieldValue, operator);
-        let entitiesCollection = await this.repository.find(filter, this.queryBuilder(true, true, true));
+        let processedFilters = this.processFilters(filter);
+        let entitiesCollection = await this.repository.find(processedFilters, this.queryBuilder(true, true, true));
         return await this.appendRelationsToCollection(entitiesCollection, relations);
     }
 
     loadById(id)
     {
-        return this.loadBy({id});
+        return this.loadBy('id', id);
     }
 
     async loadByIdWithRelations(id, relations)
     {
-        let entity = await this.loadBy({id});
+        let entity = await this.loadBy('id', id);
         return await this.appendRelationsToCollection(entity, relations);
     }
 
     loadByIds(ids)
     {
-        this.repository.find({id: {$in: ids}});
+        let processedFilters = this.processFilters({id: {$in: ids}});
+        return this.repository.find(processedFilters);
     }
 
     loadOne(filters)
     {
-        return this.repository.findOne(filters, this.queryBuilder(false, true, true));
+        let processedFilters = this.processFilters(filters);
+        return this.repository.findOne(processedFilters, this.queryBuilder(false, true, true));
     }
 
     async loadOneWithRelations(filters, relations)
     {
-        let entitiesCollection = await this.loadOne(filters);
+        let processedFilters = this.processFilters(filters);
+        let entitiesCollection = await this.repository.findOne(processedFilters, this.queryBuilder(false, true, true));
         return this.appendRelationsToCollection(entitiesCollection, relations);
     }
 
     loadOneBy(field, fieldValue, operator = null)
     {
         let filter = this.createSingleFilter(field, fieldValue, operator);
-        return this.repository.findOne(filter, this.queryBuilder(false, true, true));
+        let processedFilters = this.processFilters(filter);
+        return this.repository.findOne(processedFilters, this.queryBuilder(false, true, true));
     }
 
     async loadOneByWithRelations(field, fieldValue, relations, operator = null)
     {
         let filter = this.createSingleFilter(field, fieldValue, operator);
-        let entitiesCollection = await this.repository.findOne(filter, this.queryBuilder(false, true, true));
+        let processedFilters = this.processFilters(filter);
+        let entitiesCollection = await this.repository.findOne(processedFilters, this.queryBuilder(false, true, true));
         return this.appendRelationsToCollection(entitiesCollection, relations);
     }
 
-    // @TODO - BETA - Refactor and improve.
+    processFilters(filters)
+    {
+        if(!sc.isObject(filters)){
+            return filters;
+        }
+        let processedFilters = {};
+        for(let key of Object.keys(filters)){
+            let value = filters[key];
+            if('OR' === key && sc.isArray(value)){
+                processedFilters.$or = value.map(condition => this.processFilters(condition));
+                continue;
+            }
+            if(sc.hasOwn(value, 'operator') && sc.hasOwn(value, 'value')){
+                processedFilters[key] = this.applyOperator(value.value, value.operator, key);
+                continue;
+            }
+            if(sc.isObject(value) && !sc.isArray(value)){
+                processedFilters[key] = this.processFilters(value);
+                continue;
+            }
+            processedFilters[key] = value;
+        }
+        return processedFilters;
+    }
+
+    applyOperator(value, operator, fieldName = null)
+    {
+        let upperOperator = operator ? operator.toUpperCase() : '';
+        if('LIKE' === upperOperator){
+            return this.handleLikeOperator(value, fieldName);
+        }
+        let operatorsMap = {
+            '=': value,
+            '!=': {$ne: value},
+            '>': {$gt: value},
+            '>=': {$gte: value},
+            '<': {$lt: value},
+            '<=': {$lte: value},
+            'IN': {$in: value},
+            'NOT IN': {$nin: value}
+        };
+        return operatorsMap[upperOperator] || value;
+    }
+
+    handleLikeOperator(value, fieldName)
+    {
+        let cleanValue = String(value).replace(/%/g, '');
+        if(this.isJsonField(fieldName)){
+            return {$like: '%' + cleanValue + '%'};
+        }
+        return {$like: '%' + cleanValue + '%'};
+    }
+
     queryBuilder(useLimit = false, useOffset = false, useSort = false)
     {
         let queryBuilder = {};
         if(0 < this.select.length){
-            queryBuilder.select(...this.select);
+            queryBuilder.select = this.select;
         }
         if(useLimit && 0 !== this.limit){
             queryBuilder.limit = this.limit;
@@ -239,7 +304,6 @@ class MikroOrmDriver extends BaseDriver
         return queryBuilder;
     }
 
-    // @TODO - BETA - Refactor and improve.
     createSingleFilter(field, fieldValue, operator = null)
     {
         let filter = {};
@@ -247,15 +311,12 @@ class MikroOrmDriver extends BaseDriver
             filter[field] = fieldValue;
             return filter;
         }
-        filter[field] = {};
-        filter[field][operator] = fieldValue;
+        filter[field] = {operator, value: fieldValue};
         return filter;
     }
 
-    // @TODO - BETA - Refactor and improve.
     async appendRelationsToCollection(entitiesCollection, relations)
     {
-        // @TODO - BETA - Refactor. I would like to use populate but it may not work if the driver is not Mongo DB.
         if('function' !== typeof this.rawModel.entity.relationMappings){
             return entitiesCollection;
         }
@@ -276,7 +337,6 @@ class MikroOrmDriver extends BaseDriver
         return entitiesCollection;
     }
 
-    // @TODO - BETA - Refactor and improve.
     async appendRelatedEntities(entity, relations)
     {
         if('function' !== typeof this.rawModel.entity.relationMappings){
@@ -298,7 +358,6 @@ class MikroOrmDriver extends BaseDriver
         return entity;
     }
 
-    // @TODO - BETA - Refactor and improve.
     async createNested(newInstance, params)
     {
         if('function' !== typeof this.rawModel.entity.relationMappings){
@@ -326,7 +385,6 @@ class MikroOrmDriver extends BaseDriver
         }
     }
 
-    // @TODO - BETA - Refactor and improve.
     async createOne(params, i, relationEntity, newInstance, relation)
     {
         params[i] = newInstance[relation.join.from];
@@ -336,7 +394,6 @@ class MikroOrmDriver extends BaseDriver
         newInstance[i] = nestedObject;
     }
 
-    // @TODO - BETA - Refactor and improve.
     async createMany(params, i, relationEntity, newInstance, relation)
     {
         let nestedArray = [];

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

@@ -208,10 +208,29 @@ class ObjectionJsDriver extends BaseDriver
 
     appendSingleFilter(queryBuilder, field, fieldValue, operator = null)
     {
-        (null === operator) ? queryBuilder.where(field, fieldValue) : queryBuilder.where(field, operator, fieldValue);
+        if(null === operator){
+            queryBuilder.where(field, fieldValue);
+            return queryBuilder;
+        }
+        if('LIKE' === operator.toUpperCase()){
+            this.handleLikeFilter(queryBuilder, field, fieldValue);
+            return queryBuilder;
+        }
+        queryBuilder.where(field, operator, fieldValue);
         return queryBuilder;
     }
 
+    handleLikeFilter(queryBuilder, field, fieldValue)
+    {
+        let cleanValue = String(fieldValue).replace(/%/g, '');
+        if(this.isJsonField(field)){
+            let { ref } = this.rawModel.knex();
+            queryBuilder.where(ref(field).castText(), 'like', '%' + cleanValue + '%');
+            return;
+        }
+        queryBuilder.where(field, 'like', '%' + cleanValue + '%');
+    }
+
     appendFilters(queryBuilder, filters = {})
     {
         let filtersKeys = Object.keys(filters);
@@ -220,6 +239,16 @@ class ObjectionJsDriver extends BaseDriver
         }
         for(let i of filtersKeys){
             let filter = filters[i];
+            if('OR' === i && sc.isArray(filter)){
+                queryBuilder.where(function(){
+                    for(let condition of filter){
+                        this.orWhere(function(){
+                            this.appendFilters(this, condition);
+                        }.bind(this));
+                    }
+                }.bind(this));
+                continue;
+            }
             let filterOperator = sc.get(filter, 'operator');
             if(filterOperator){
                 if('OR' === filterOperator){
@@ -232,6 +261,11 @@ class ObjectionJsDriver extends BaseDriver
                 }
                 if('NOT' === filterOperator){
                     queryBuilder.whereNot(i, filter.value);
+                    continue;
+                }
+                if('LIKE' === filterOperator){
+                    this.handleLikeFilter(queryBuilder, i, filter.value);
+                    continue;
                 }
                 queryBuilder.where(i, filter.operator, filter.value);
                 continue;
@@ -258,12 +292,12 @@ class ObjectionJsDriver extends BaseDriver
         if(!sc.isArray(relationsModifiers)){
             return queryBuilder;
         }
-        for (let relationModifier of relationsModifiers) {
+        for(let relationModifier of relationsModifiers){
             let relationKey = sc.get(relationModifier, 'key');
-            if (!relationKey) {
+            if(!relationKey){
                 continue;
             }
-            if (-1 === relations.indexOf(relationKey)) {
+            if(-1 === relations.indexOf(relationKey)){
                 continue;
             }
             let relationOrderBy = sc.get(relationModifier, 'orderBy', {});