@reldens/storage 0.10.0-beta.35 → 0.10.0-beta.39

package/lib/base-driver.js

@@ -162,7 +162,7 @@ class BaseDriver
             Logger.error('Custom query method not found in raw model.', methodName, this.rawModel);
             return false;
         }
-        return this.rawModel[methodName](methodOptions);
+        return this.rawModel[methodName](methodOptions, this);
     }
 
 }

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

@@ -132,7 +132,7 @@ class MikroOrmDriver extends BaseDriver
 
     async loadAllWithRelations(relations)
     {
-        let entities = await this.repository.find(filter, this.queryBuilder(true, true, true));
+        let entities = await this.loadAll();
         return await this.appendRelationsToCollection(entities, relations);
     }
 
@@ -232,17 +232,22 @@ class MikroOrmDriver extends BaseDriver
     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(typeof this.rawModel.entity.relationsMappings !== 'function'){
-            return false;
+        if('function' !== typeof this.rawModel.entity.relationMappings){
+            return entitiesCollection;
         }
         if(!sc.isArray(relations) || 0 === relations.length){
-            relations = Object.keys(this.rawModel.entity.relationsMappings() || {});
+            relations = Object.keys(this.rawModel.entity.relationMappings() || {});
         }
         if(0 === relations.length){
             return entitiesCollection;
         }
-        for(let entity of entitiesCollection){
-            await this.appendRelatedEntities(entity, relations);
+        if(sc.isArray(entitiesCollection)){
+            for(let entity of entitiesCollection){
+                await this.appendRelatedEntities(entity, relations);
+            }
+        }
+        if(!sc.isArray(entitiesCollection)){
+            await this.appendRelatedEntities(entitiesCollection, relations);
         }
         return entitiesCollection;
     }
@@ -250,12 +255,12 @@ class MikroOrmDriver extends BaseDriver
     async appendRelatedEntities(entity, relations)
     {
         // @TODO - BETA - Refactor and improve.
-        if(typeof this.rawModel.entity.relationsMappings !== 'function'){
-            return false;
+        if('function' !== typeof this.rawModel.entity.relationMappings){
+            return entity;
         }
-        let relationsMappings = typeof this.rawModel.entity.relationsMappings();
+        let relationMappings = this.rawModel.entity.relationMappings();
         for(let i of relations){
-            let relation = relationsMappings[i];
+            let relation = relationMappings[i];
             let relationRepository = this.server.getEntity(relation.entityName);
             let isManyToOne = 'm:1' === relation.reference;
             let isOneToMany = '1:m' === relation.reference;
@@ -266,51 +271,51 @@ class MikroOrmDriver extends BaseDriver
                 entity[i] = await relationRepository.loadBy(relation.join.to, entity[relation.join.from]);
             }
         }
+        return entity;
     }
 
     async createNested(newInstance, params)
     {
-        if(typeof this.rawModel.entity.relationsMappings !== 'function'){
+        if('function' !== typeof this.rawModel.entity.relationMappings){
             return false;
         }
-        let relationsMappings = this.rawModel.entity.relationsMappings();
-        for(let i of Object.keys(relationsMappings)){
+        let relationMappings = this.rawModel.entity.relationMappings();
+        for(let i of Object.keys(relationMappings)){
             // @TODO - BETA - Refactor and improve.
-            let relationData = relationsMappings[i];
-            let relationEntity = this.server.entityManager.get(relationData.entityName).rawModel.entity;
+            let relation = relationMappings[i];
+            let relationEntity = this.server.entityManager.get(relation.entityName).rawModel.entity;
             if(!relationEntity){
-                Logger.warning('Factory not found for relation definition:', relationData);
+                Logger.warning('Factory not found for relation definition:', relation);
                 continue;
             }
-            let isManyToOne = 'm:1' === relationData.reference;
-            let isOneToMany = '1:m' === relationData.reference;
-            if(isManyToOne){
-                if(!sc.hasOwn(params, relationData.join.from) || !params[relationData.join.from]){
+            let isArray = sc.isArray(params);
+            if(!isArray){
+                if(!sc.hasOwn(params, relation.join.from) || !params[relation.join.from]){
                     continue;
                 }
-                await this.createOne(params, i, relationEntity, newInstance, relationData);
+                await this.createOne(params, i, relationEntity, newInstance, relation);
                 continue;
             }
-            if(isOneToMany){
-                await this.createMany(params, i, relationEntity, newInstance, relationData);
+            if(isArray){
+                await this.createMany(params, i, relationEntity, newInstance, relation);
             }
         }
     }
 
-    async createOne(params, i, relationEntity, newInstance, relationData)
+    async createOne(params, i, relationEntity, newInstance, relation)
     {
-        params[i] = newInstance[relationData.join.from];
+        params[i] = newInstance[relation.join.from];
         let nestedObject = relationEntity.createByProps(params[i]);
         await this.repository.persist(nestedObject).flush();
         await this.orm.em.flush();
         newInstance[i] = nestedObject;
     }
 
-    async createMany(params, i, relationEntity, newInstance, relationData)
+    async createMany(params, i, relationEntity, newInstance, relation)
     {
         let nestedArray = [];
         for(let objectData of params[i]){
-            objectData[relationData.join.to] = newInstance[relationData.join.from];
+            objectData[relation.join.to] = newInstance[relation.join.from];
             let nestedObject = relationEntity.createByProps(objectData);
             await this.repository.persist(nestedObject).flush();
             await this.orm.em.flush();

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@reldens/storage",
     "scope": "@reldens",
-    "version": "0.10.0-beta.35",
+    "version": "0.10.0-beta.39",
     "description": "Reldens - Storage",
     "author": "Damian A. Pastorini",
     "license": "MIT",