@reldens/storage 0.116.0 → 0.118.0

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

@@ -6,7 +6,6 @@
 
 const { BaseDriver } = require('../base-driver');
 const { Logger, sc } = require('@reldens/utils');
-const { Collection } = require('@mikro-orm/core');
 
 class MikroOrmDriver extends BaseDriver
 {
@@ -26,6 +25,12 @@ class MikroOrmDriver extends BaseDriver
             Logger.critical('Missing raw entity on Mikro ORM driver.');
             return false;
         }
+        this.mikroOrmModules = sc.get(props, 'mikroOrmModules', false);
+        if(!this.mikroOrmModules){
+            Logger.critical('Missing Mikro ORM modules on Mikro ORM driver.');
+            return false;
+        }
+        this.Collection = this.mikroOrmModules.Collection;
         this.orm = props.orm;
         this.server = props.server;
         this.entitySchema = (sc.isObject(this.rawModel) && sc.hasOwn(this.rawModel, 'schema')) ? this.rawModel.schema : this.rawModel;
@@ -76,28 +81,109 @@ class MikroOrmDriver extends BaseDriver
         let relations = [];
         for(let propName of Object.keys(this.entitySchema.meta.properties)){
             let prop = this.entitySchema.meta.properties[propName];
-            if(prop.kind === 'm:1' || prop.kind === '1:m' || prop.kind === 'm:n'){
+            if('m:1' === prop.kind || '1:1' === prop.kind || '1:m' === prop.kind || 'm:n' === prop.kind){
                 relations.push(propName);
             }
         }
         return relations;
     }
 
-    async create(params)
+    isOwningRelation(prop)
     {
-        let transformed = this.transformFkToRelations(params);
-        let newInstance = await this.orm.em.create(this.entitySchema, transformed);
-        await this.orm.em.upsert(newInstance);
-        await this.orm.em.flush();
+        if('m:1' === prop.kind){
+            return true;
+        }
+        return '1:1' === prop.kind && Boolean(prop.owner);
+    }
+
+    isInverseRelation(prop)
+    {
+        if('1:m' === prop.kind){
+            return true;
+        }
+        return '1:1' === prop.kind && !prop.owner;
+    }
+
+    inverseRelationOwnerJoinColumn(prop, relationDriver)
+    {
+        if(!this.isInverseRelation(prop)){
+            return false;
+        }
+        if(!prop.mappedBy){
+            return false;
+        }
+        if(!relationDriver.entitySchema){
+            return false;
+        }
+        if(!relationDriver.entitySchema.meta){
+            return false;
+        }
+        let mappedProp = relationDriver.entitySchema.meta.properties[prop.mappedBy];
+        if(!mappedProp){
+            return false;
+        }
+        if(!mappedProp.joinColumns){
+            return false;
+        }
+        return mappedProp.joinColumns[0] || false;
+    }
+
+    nestedFkColumn(prop, relationDriver)
+    {
+        if(!this.isOwningRelation(prop)){
+            return this.inverseRelationOwnerJoinColumn(prop, relationDriver);
+        }
+        if(!prop.joinColumns){
+            return false;
+        }
+        return prop.joinColumns[0] || false;
+    }
+
+    removeRelationsFromParams(params)
+    {
+        if(!params || 'object' !== typeof params){
+            return params;
+        }
+        let columnsOnly = {...params};
+        for(let relationName of this.getAllRelations()){
+            delete columnsOnly[relationName];
+        }
+        return columnsOnly;
+    }
+
+    async createEntity(params)
+    {
+        let writeManager = this.orm.em.fork();
+        let newInstance = await writeManager.create(this.entitySchema, this.removeRelationsFromParams(params));
+        await writeManager.upsert(newInstance);
+        await writeManager.flush();
         return newInstance;
     }
 
-    async createWithRelations(params, relations)
+    async create(params)
     {
-        if(!sc.isArray(relations) || 0 === relations.length){
-            relations = this.getAllRelations();
+        return this.withoutUninitializedCollections(await this.createEntity(params));
+    }
+
+    withoutUninitializedCollections(entity)
+    {
+        if(!entity || !this.Collection){
+            return entity;
         }
-        let newInstance = await this.create(params);
+        let result = {};
+        for(let key of Object.keys(entity)){
+            if(entity[key] instanceof this.Collection && !entity[key].isInitialized()){
+                continue;
+            }
+            result[key] = entity[key];
+        }
+        return result;
+    }
+
+    async createWithRelations(params, relations)
+    {
+        relations = this.normalizeRelations(relations);
+        let newInstance = await this.createEntity(params);
         await this.createNested(newInstance, params, relations);
         return await this.appendRelationsToCollection(newInstance, relations);
     }
@@ -108,9 +194,9 @@ class MikroOrmDriver extends BaseDriver
         if(0 === entities.length){
             return false;
         }
-        let transformed = this.transformFkToRelations(updatePatch);
+        let columnsOnly = this.removeRelationsFromParams(updatePatch);
         for(let entity of entities){
-            Object.assign(entity, transformed);
+            Object.assign(entity, columnsOnly);
             await this.orm.em.upsert(entity);
             await this.orm.em.flush();
         }
@@ -139,7 +225,7 @@ class MikroOrmDriver extends BaseDriver
         if(1 < entities.length){
             Logger.warning('Multiple entities updated by ID: '+entities.map(e => e.id).join(', '));
         }
-        return entities.shift();
+        return this.withoutUninitializedCollections(entities.shift());
     }
 
     async upsert(params, filters)
@@ -155,8 +241,7 @@ class MikroOrmDriver extends BaseDriver
         if(filters){
             let existent = await this.loadOne(filters);
             if(existent){
-                let transformed = this.transformFkToRelations(params);
-                return this.updateById(existent.id, transformed);
+                return this.updateById(existent.id, params);
             }
         }
         return this.create(params);
@@ -173,18 +258,18 @@ class MikroOrmDriver extends BaseDriver
             await this.orm.em.remove(entry);
         }
         await this.orm.em.flush();
-        return true;
+        return entries.length;
     }
 
     async deleteById(id)
     {
-        let entity = await this.loadById(id);
+        let entity = await this.repository.findOne(this.processFilters({id}));
         if(!entity){
             return false;
         }
         await this.orm.em.remove(entity);
         await this.orm.em.flush();
-        return true;
+        return 1;
     }
 
     async count(filters)
@@ -195,9 +280,7 @@ class MikroOrmDriver extends BaseDriver
 
     async countWithRelations(filters, relations)
     {
-        if(!sc.isArray(relations) || 0 === relations.length){
-            relations = this.getAllRelations();
-        }
+        relations = this.normalizeRelations(relations);
         let processedFilters = this.processFilters(filters);
         if(0 === relations.length || !this.entitySchema.meta || !this.entitySchema.meta.properties){
             return this.repository.count(processedFilters);
@@ -207,22 +290,20 @@ class MikroOrmDriver extends BaseDriver
         let aliasCounter = 0;
         for(let relationName of relations){
             let prop = properties[relationName];
-            if(!prop || !prop.kind || (prop.kind !== 'm:1' && prop.kind !== '1:m')){
+            if(!prop || !prop.kind || (!this.isOwningRelation(prop) && !this.isInverseRelation(prop))){
                 continue;
             }
-            let relationDriver = this.server.entityManager.get(prop.entity);
+            let relationDriver = this.relationDriverFor(prop);
             if(!relationDriver || !relationDriver.entitySchema){
                 continue;
             }
             let alias = 'rel_'+aliasCounter;
-            if('m:1' === prop.kind && prop.joinColumns && prop.joinColumns[0]){
+            if(this.isOwningRelation(prop) && prop.joinColumns && prop.joinColumns[0]){
                 queryBuilder.leftJoin(relationName, alias, 'e.'+prop.joinColumns[0]+' = '+alias+'.id');
             }
-            if('1:m' === prop.kind && prop.mappedBy){
-                let mappedProp = relationDriver.entitySchema.meta.properties[prop.mappedBy];
-                if(mappedProp && mappedProp.joinColumns && mappedProp.joinColumns[0]){
-                    queryBuilder.leftJoin(relationName, alias, 'e.id = '+alias+'.'+mappedProp.joinColumns[0]);
-                }
+            let ownerJoinColumn = this.inverseRelationOwnerJoinColumn(prop, relationDriver);
+            if(ownerJoinColumn){
+                queryBuilder.leftJoin(relationName, alias, 'e.id = '+alias+'.'+ownerJoinColumn);
             }
             aliasCounter++;
         }
@@ -232,106 +313,180 @@ class MikroOrmDriver extends BaseDriver
         return queryBuilder.getCount();
     }
 
-    loadAll()
+    async loadAll()
     {
-        return this.repository.findAll();
+        return this.toPlainResult(await this.repository.findAll());
     }
 
-    async loadAllWithRelations(relations)
+    normalizeRelations(relations)
     {
+        if(sc.isString(relations)){
+            relations = this.parseRelationsString(relations);
+        }
         if(!sc.isArray(relations) || 0 === relations.length){
-            relations = this.getAllRelations();
+            return this.getAllRelations();
         }
-        let entities = await this.loadAll();
-        return await this.appendRelationsToCollection(entities, relations);
+        return relations;
     }
 
-    load(filters)
+    toPlainResult(result, populatedPaths, ancestors)
     {
-        let processedFilters = this.processFilters(filters);
-        return this.repository.find(processedFilters, this.queryBuilder(true, true, true));
+        if(!result || 'object' !== typeof result || result instanceof Date){
+            return result;
+        }
+        if(!ancestors){
+            ancestors = new Set();
+        }
+        if(!populatedPaths){
+            populatedPaths = {};
+        }
+        if(result instanceof this.Collection){
+            if(!result.isInitialized()){
+                return [];
+            }
+            return this.toPlainList(result.getItems(), populatedPaths, ancestors);
+        }
+        if(sc.isArray(result)){
+            return this.toPlainList(result, populatedPaths, ancestors);
+        }
+        return this.toPlainEntity(result, populatedPaths, ancestors);
     }
 
-    async loadWithRelations(filters, relations)
+    toPlainList(result, populatedPaths, ancestors)
     {
-        if(!sc.isArray(relations) || 0 === relations.length){
-            relations = this.getAllRelations();
+        ancestors.add(result);
+        let plainList = [];
+        for(let item of result){
+            if(ancestors.has(item)){
+                continue;
+            }
+            plainList.push(this.toPlainResult(item, populatedPaths, ancestors));
         }
-        let processedFilters = this.processFilters(filters);
-        let entitiesCollection = await this.repository.find(processedFilters, this.queryBuilder(true, true, true));
-        return await this.appendRelationsToCollection(entitiesCollection, relations);
+        ancestors.delete(result);
+        return plainList;
     }
 
-    loadBy(field, fieldValue, operator = null)
+    toPlainEntity(result, populatedPaths, ancestors)
     {
-        let filter = this.createSingleFilter(field, fieldValue, operator);
-        let processedFilters = this.processFilters(filter);
-        return this.repository.find(processedFilters, this.queryBuilder(true, true, true));
+        ancestors.add(result);
+        let relationKeys = this.getAllRelations();
+        let plainEntity = {};
+        for(let key of Object.keys(result)){
+            if(ancestors.has(result[key])){
+                continue;
+            }
+            if(-1 === relationKeys.indexOf(key)){
+                plainEntity[key] = result[key];
+                continue;
+            }
+            if(!populatedPaths[key]){
+                continue;
+            }
+            plainEntity[key] = this.toPlainRelation(key, result[key], populatedPaths[key], ancestors);
+        }
+        ancestors.delete(result);
+        return plainEntity;
     }
 
-    async loadByWithRelations(field, fieldValue, relations, operator = null)
+    toPlainRelation(propName, relationValue, populatedPaths, ancestors)
     {
-        if(!sc.isArray(relations) || 0 === relations.length){
-            relations = this.getAllRelations();
+        let relationDriver = this.relationDriverFor(this.entitySchema.meta.properties[propName]);
+        if(!relationDriver){
+            return this.toPlainResult(relationValue, populatedPaths, ancestors);
         }
+        return relationDriver.toPlainResult(relationValue, populatedPaths, ancestors);
+    }
+
+    async plainRelationsResult(entitiesCollection, relations)
+    {
+        return this.toPlainResult(
+            await this.appendRelationsToCollection(entitiesCollection, relations),
+            this.populatedPathsTree(relations)
+        );
+    }
+
+    findEntities(filters)
+    {
+        return this.repository.find(this.processFilters(filters), this.queryBuilder(true, true, true));
+    }
+
+    findOneEntity(filters)
+    {
+        return this.repository.findOne(this.processFilters(filters), this.queryBuilder(false, true, true));
+    }
+
+    async loadAllWithRelations(relations)
+    {
+        relations = this.normalizeRelations(relations);
+        let entities = await this.repository.findAll();
+        return this.plainRelationsResult(entities, relations);
+    }
+
+    async load(filters)
+    {
+        return this.toPlainResult(await this.findEntities(filters));
+    }
+
+    async loadWithRelations(filters, relations)
+    {
+        relations = this.normalizeRelations(relations);
+        let entitiesCollection = await this.findEntities(filters);
+        return this.plainRelationsResult(entitiesCollection, relations);
+    }
+
+    async loadBy(field, fieldValue, operator = null)
+    {
+        return this.toPlainResult(await this.findEntities(this.createSingleFilter(field, fieldValue, operator)));
+    }
+
+    async loadByWithRelations(field, fieldValue, relations, operator = null)
+    {
+        relations = this.normalizeRelations(relations);
         let filter = this.createSingleFilter(field, fieldValue, operator);
-        let processedFilters = this.processFilters(filter);
-        let entitiesCollection = await this.repository.find(processedFilters, this.queryBuilder(true, true, true));
-        return await this.appendRelationsToCollection(entitiesCollection, relations);
+        let entitiesCollection = await this.findEntities(filter);
+        return this.plainRelationsResult(entitiesCollection, relations);
     }
 
-    loadById(id)
+    async loadById(id)
     {
-        return this.loadOneBy('id', id);
+        return this.toPlainResult(await this.findOneEntity({id}));
     }
 
     async loadByIdWithRelations(id, relations)
     {
-        if(!sc.isArray(relations) || 0 === relations.length){
-            relations = this.getAllRelations();
-        }
-        let entity = await this.loadOneBy('id', id);
-        return await this.appendRelationsToCollection(entity, relations);
+        relations = this.normalizeRelations(relations);
+        let entity = await this.findOneEntity({id});
+        return this.plainRelationsResult(entity, relations);
     }
 
-    loadByIds(ids)
+    async loadByIds(ids)
     {
-        let processedFilters = this.processFilters({id: {$in: ids}});
-        return this.repository.find(processedFilters);
+        return this.toPlainResult(await this.repository.find(this.processFilters({id: {$in: ids}})));
     }
 
-    loadOne(filters)
+    async loadOne(filters)
     {
-        let processedFilters = this.processFilters(filters);
-        return this.repository.findOne(processedFilters, this.queryBuilder(false, true, true));
+        return this.toPlainResult(await this.findOneEntity(filters));
     }
 
     async loadOneWithRelations(filters, relations)
     {
-        if(!sc.isArray(relations) || 0 === relations.length){
-            relations = this.getAllRelations();
-        }
-        let processedFilters = this.processFilters(filters);
-        let entitiesCollection = await this.repository.findOne(processedFilters, this.queryBuilder(false, true, true));
-        return this.appendRelationsToCollection(entitiesCollection, relations);
+        relations = this.normalizeRelations(relations);
+        let entitiesCollection = await this.findOneEntity(filters);
+        return this.plainRelationsResult(entitiesCollection, relations);
     }
 
-    loadOneBy(field, fieldValue, operator = null)
+    async loadOneBy(field, fieldValue, operator = null)
     {
-        let filter = this.createSingleFilter(field, fieldValue, operator);
-        let processedFilters = this.processFilters(filter);
-        return this.repository.findOne(processedFilters, this.queryBuilder(false, true, true));
+        return this.toPlainResult(await this.findOneEntity(this.createSingleFilter(field, fieldValue, operator)));
     }
 
     async loadOneByWithRelations(field, fieldValue, relations, operator = null)
     {
-        if(!sc.isArray(relations) || 0 === relations.length){
-            relations = this.getAllRelations();
-        }
+        relations = this.normalizeRelations(relations);
         let filter = this.createSingleFilter(field, fieldValue, operator);
-        let processedFilters = this.processFilters(filter);
-        let entitiesCollection = await this.repository.findOne(processedFilters, this.queryBuilder(false, true, true));
-        return this.appendRelationsToCollection(entitiesCollection, relations);
+        let entitiesCollection = await this.findOneEntity(filter);
+        return this.plainRelationsResult(entitiesCollection, relations);
     }
 
     processFilters(filters)
@@ -342,6 +497,9 @@ class MikroOrmDriver extends BaseDriver
         let processedFilters = {};
         for(let key of Object.keys(filters)){
             let value = filters[key];
+            if(('AND' === key || 'OR' === key) && sc.isArray(value) && 0 === value.length){
+                continue;
+            }
             if('AND' === key && sc.isArray(value)){
                 processedFilters.$and = value.map(condition => this.processFilters(condition));
                 continue;
@@ -418,15 +576,39 @@ class MikroOrmDriver extends BaseDriver
         return filter;
     }
 
-    convertCollectionsToArrays(entity)
+    populatedPathsTree(relations)
+    {
+        let tree = {};
+        if(!sc.isArray(relations)){
+            return tree;
+        }
+        for(let relationPath of relations){
+            let node = tree;
+            for(let pathPart of String(relationPath).split('.')){
+                if(!node[pathPart]){
+                    node[pathPart] = {};
+                }
+                node = node[pathPart];
+            }
+        }
+        return tree;
+    }
+
+    convertCollectionsToArrays(entity, populatedPaths)
     {
         if(!entity){
             return entity;
         }
-        for(let key of Object.keys(entity)){
-            if(entity[key] && entity[key] instanceof Collection){
-                entity[key] = entity[key].getItems();
+        for(let key of Object.keys(populatedPaths)){
+            if(!entity[key] || !(entity[key] instanceof this.Collection)){
+                continue;
             }
+            if(!entity[key].isInitialized()){
+                Logger.warning('Relation "'+key+'" was not populated on '+this.tableName()+', it will be empty.');
+                entity[key] = [];
+                continue;
+            }
+            entity[key] = entity[key].getItems();
         }
         return entity;
     }
@@ -462,13 +644,104 @@ class MikroOrmDriver extends BaseDriver
             return entitiesCollection;
         }
         await this.orm.em.populate(entitiesCollection, relations);
+        let populatedPaths = this.populatedPathsTree(relations);
         if(sc.isArray(entitiesCollection)){
             for(let entity of entitiesCollection){
-                this.convertCollectionsToArrays(entity);
+                this.restoreRelatedForeignKeys(entity, new Set(), populatedPaths);
+                await this.resolveKeyMappedRelations(entity, populatedPaths);
             }
             return entitiesCollection;
         }
-        return this.convertCollectionsToArrays(entitiesCollection);
+        this.restoreRelatedForeignKeys(entitiesCollection, new Set(), populatedPaths);
+        await this.resolveKeyMappedRelations(entitiesCollection, populatedPaths);
+        return entitiesCollection;
+    }
+
+    async resolveKeyMappedRelations(entity, populatedPaths)
+    {
+        if(!entity || !this.entitySchema.meta || !this.entitySchema.meta.properties){
+            return entity;
+        }
+        for(let propName of Object.keys(populatedPaths)){
+            let prop = this.entitySchema.meta.properties[propName];
+            if(!prop || !prop.mapToPk || !prop.targetKey || sc.isObject(entity[propName])){
+                continue;
+            }
+            if(null === entity[propName] || 'undefined' === typeof entity[propName]){
+                continue;
+            }
+            let relationDriver = this.relationDriverFor(prop);
+            if(!relationDriver){
+                continue;
+            }
+            entity[propName] = await relationDriver.loadOneBy(prop.targetKey, entity[propName]);
+        }
+        return entity;
+    }
+
+    restoreRelatedForeignKeys(entity, visited, populatedPaths)
+    {
+        if(!entity || visited.has(entity)){
+            return;
+        }
+        visited.add(entity);
+        this.convertCollectionsToArrays(entity, populatedPaths);
+        this.addFkFieldsFromRelations(entity);
+        if(!this.entitySchema.meta || !this.entitySchema.meta.properties){
+            return;
+        }
+        for(let propName of Object.keys(populatedPaths)){
+            let relationDriver = this.relationDriverFor(this.entitySchema.meta.properties[propName]);
+            if(!relationDriver){
+                continue;
+            }
+            relationDriver.restoreRelatedEntities(entity[propName], visited, populatedPaths[propName]);
+        }
+    }
+
+    restoreRelatedEntities(relatedValue, visited, populatedPaths)
+    {
+        if(!relatedValue || relatedValue instanceof this.Collection){
+            return;
+        }
+        if(sc.isArray(relatedValue)){
+            for(let relatedEntity of relatedValue){
+                this.restoreRelatedForeignKeys(relatedEntity, visited, populatedPaths);
+            }
+            return;
+        }
+        this.restoreRelatedForeignKeys(relatedValue, visited, populatedPaths);
+    }
+
+    relationTargetClass(prop)
+    {
+        if(!sc.isFunction(prop?.entity)){
+            return false;
+        }
+        return prop.entity();
+    }
+
+    relationDriverFor(prop)
+    {
+        let targetClass = this.relationTargetClass(prop);
+        let targetClassName = (prop && prop.targetMeta) ? prop.targetMeta.className : false;
+        if(!targetClass && !targetClassName){
+            return false;
+        }
+        let entities = this.server.entityManager.entities;
+        for(let entityKey of Object.keys(entities)){
+            let candidate = entities[entityKey];
+            if(!candidate || !candidate.entitySchema || !candidate.entitySchema.meta){
+                continue;
+            }
+            if(targetClass && candidate.entitySchema.meta.class === targetClass){
+                return candidate;
+            }
+            if(targetClassName && candidate.entitySchema.meta.className === targetClassName){
+                return candidate;
+            }
+        }
+        return false;
     }
 
     async createNested(newInstance, params, relations)
@@ -479,36 +752,42 @@ class MikroOrmDriver extends BaseDriver
         let properties = this.entitySchema.meta.properties;
         for(let relationName of Object.keys(properties)){
             let prop = properties[relationName];
-            if(!prop.kind || (prop.kind !== 'm:1' && prop.kind !== '1:m')){
+            if(!prop.kind || (!this.isOwningRelation(prop) && !this.isInverseRelation(prop))){
                 continue;
             }
             if(sc.isArray(relations) && 0 < relations.length && -1 === relations.indexOf(relationName)){
                 continue;
             }
-            let relationDriver = this.server.entityManager.get(prop.entity);
+            if(!sc.hasOwn(params, relationName)){
+                continue;
+            }
+            let relationDriver = this.relationDriverFor(prop);
             if(!relationDriver){
-                Logger.warning('Entity not found for relation:', prop.entity);
+                Logger.warning('Entity not found for relation: '+relationName);
                 continue;
             }
-            let isOneToMany = '1:m' === prop.kind;
-            let isManyToOne = 'm:1' === prop.kind;
-            if(isManyToOne && sc.hasOwn(params, relationName)){
+            if(this.isOwningRelation(prop)){
                 await this.createOne(params, relationName, relationDriver, newInstance, prop);
                 continue;
             }
-            if(isOneToMany && sc.hasOwn(params, relationName) && sc.isArray(params[relationName])){
+            if(sc.isArray(params[relationName])){
                 await this.createMany(params, relationName, relationDriver, newInstance, prop);
+                continue;
+            }
+            if('1:1' === prop.kind && sc.isObject(params[relationName])){
+                await this.createOne(params, relationName, relationDriver, newInstance, prop);
             }
         }
     }
 
     async createOne(params, relationName, relationDriver, newInstance, prop)
     {
-        let nestedData = params[relationName];
-        if(prop.joinColumns && prop.joinColumns[0]){
-            nestedData[prop.joinColumns[0]] = newInstance.id;
+        let nestedData = Object.assign({}, params[relationName]);
+        let fkColumn = this.nestedFkColumn(prop, relationDriver);
+        if(fkColumn){
+            nestedData[fkColumn] = newInstance.id;
         }
-        let nestedObject = await relationDriver.create(nestedData);
+        let nestedObject = await relationDriver.createEntity(nestedData);
         await this.orm.em.flush();
         newInstance[relationName] = nestedObject;
     }
@@ -516,34 +795,19 @@ class MikroOrmDriver extends BaseDriver
     async createMany(params, relationName, relationDriver, newInstance, prop)
     {
         let nestedArray = [];
+        let fkColumn = this.nestedFkColumn(prop, relationDriver);
         for(let objectData of params[relationName]){
-            if(prop.joinColumns && prop.joinColumns[0]){
-                objectData[prop.joinColumns[0]] = newInstance.id;
+            let nestedData = Object.assign({}, objectData);
+            if(fkColumn){
+                nestedData[fkColumn] = newInstance.id;
             }
-            let nestedObject = await relationDriver.create(objectData);
+            let nestedObject = await relationDriver.createEntity(nestedData);
             await this.orm.em.flush();
             nestedArray.push(nestedObject);
         }
         newInstance[relationName] = nestedArray;
     }
 
-    transformFkToRelations(params)
-    {
-        if(!params || 'object' !== typeof params){
-            return params;
-        }
-        let transformed = {...params};
-        for(let fkColumn of Object.keys(this.fkMappings)){
-            if(!sc.hasOwn(params, fkColumn) || null === params[fkColumn]){
-                continue;
-            }
-            let mapping = this.fkMappings[fkColumn];
-            transformed[mapping.relationKey] = this.orm.em.getReference(mapping.entityName, params[fkColumn]);
-            delete transformed[fkColumn];
-        }
-        return transformed;
-    }
-
 }
 
 module.exports.MikroOrmDriver = MikroOrmDriver;