@reldens/storage 0.88.0 → 0.89.0

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

@@ -6,6 +6,7 @@
 
 const { BaseDriver } = require('../base-driver');
 const { Logger, sc } = require('@reldens/utils');
+const { Collection } = require('@mikro-orm/core');
 
 class MikroOrmDriver extends BaseDriver
 {
@@ -27,7 +28,19 @@ class MikroOrmDriver extends BaseDriver
         }
         this.orm = props.orm;
         this.server = props.server;
-        this.repository = this.orm.em.getRepository(this.rawModel);
+        this.entitySchema = (sc.isObject(this.rawModel) && sc.hasOwn(this.rawModel, 'schema')) ? this.rawModel.schema : this.rawModel;
+        this.repository = this.orm.em.getRepository(this.entitySchema);
+        this.mikroOrmOperators = {
+            'GT': '$gt',
+            'GTE': '$gte',
+            'LT': '$lt',
+            'LTE': '$lte',
+            'NE': '$ne',
+            'NOT': '$ne',
+            'IN': '$in',
+            'NOT IN': '$nin'
+        };
+        this.fkMappings = this.rawModel._fkMappings || this.entitySchema._fkMappings || {};
     }
 
     databaseName()
@@ -37,17 +50,17 @@ class MikroOrmDriver extends BaseDriver
 
     id()
     {
-        return this.rawModel.entity.name || this.name();
+        return (this.rawModel.entity || this.rawModel).name || this.name();
     }
 
     name()
     {
-        return this.rawModel.entity.name || this.config.dbName;
+        return (this.rawModel.entity || this.rawModel).name || this.config.dbName;
     }
 
     tableName()
     {
-        return this.rawModel.entity.name;
+        return (this.rawModel.entity || this.rawModel).name;
     }
 
     property(propertyName)
@@ -57,16 +70,25 @@ class MikroOrmDriver extends BaseDriver
 
     getAllRelations()
     {
-        if('function' !== typeof this.rawModel.entity.relationMappings){
+        if(!this.entitySchema.meta || !this.entitySchema.meta.properties){
             return [];
         }
-        return Object.keys(this.rawModel.entity.relationMappings() || {});
+        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'){
+                relations.push(propName);
+            }
+        }
+        return relations;
     }
 
     async create(params)
     {
-        let newInstance = await this.orm.em.create(this.rawModel, params);
+        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();
         return newInstance;
     }
 
@@ -80,53 +102,61 @@ class MikroOrmDriver extends BaseDriver
         return await this.appendRelationsToCollection(newInstance, relations);
     }
 
-    async update(filters, updatePatch)
+    async applyUpdateToEntities(processedFilters, updatePatch)
     {
-        let processedFilters = this.processFilters(filters);
         let entities = await this.repository.find(processedFilters, this.queryBuilder(true, true, true));
         if(0 === entities.length){
             return false;
         }
+        let transformed = this.transformFkToRelations(updatePatch);
         for(let entity of entities){
-            Object.assign(entity, updatePatch);
+            Object.assign(entity, transformed);
             await this.orm.em.upsert(entity);
             await this.orm.em.flush();
         }
         return entities;
     }
 
+    async update(filters, updatePatch)
+    {
+        let processedFilters = this.processFilters(filters);
+        return this.applyUpdateToEntities(processedFilters, updatePatch);
+    }
+
     async updateBy(field, fieldValue, updatePatch, operator = null)
     {
         let filter = this.createSingleFilter(field, fieldValue, operator);
         let processedFilters = this.processFilters(filter);
-        let entities = await this.repository.find(processedFilters, this.queryBuilder(true, true, true));
-        if(0 === entities.length){
-            return false;
-        }
-        for(let entity of entities){
-            Object.assign(entity, updatePatch);
-            await this.orm.em.upsert(entity);
-            await this.orm.em.flush();
-        }
-        return entities;
+        return this.applyUpdateToEntities(processedFilters, updatePatch);
     }
 
-    updateById(id, params)
+    async updateById(id, params)
     {
-        return this.update({id}, params);
+        let entities = await this.update({id}, params);
+        if(!entities){
+            return false;
+        }
+        if(1 < entities.length){
+            Logger.warning('Multiple entities updated by ID: '+entities.map(e => e.id).join(', '));
+        }
+        return entities.shift();
     }
 
     async upsert(params, filters)
     {
         if(params.id){
-            let patch = Object.assign({}, params);
-            delete patch.id;
-            return this.updateById(params.id, patch);
+            let existent = await this.loadById(params.id);
+            if(existent){
+                let patch = Object.assign({}, params);
+                delete patch.id;
+                return this.updateById(params.id, patch);
+            }
         }
         if(filters){
             let existent = await this.loadOne(filters);
             if(existent){
-                return this.updateById(existent.id, params);
+                let transformed = this.transformFkToRelations(params);
+                return this.updateById(existent.id, transformed);
             }
         }
         return this.create(params);
@@ -136,17 +166,25 @@ class MikroOrmDriver extends BaseDriver
     {
         let processedFilters = this.processFilters(filters);
         let entries = await this.repository.find(processedFilters);
-        if(!entries){
+        if(!entries || 0 === entries.length){
             return false;
         }
         for(let entry of entries){
-            await this.repository.nativeDelete(entry.id);
+            await this.orm.em.remove(entry);
         }
+        await this.orm.em.flush();
+        return true;
     }
 
-    deleteById(id)
+    async deleteById(id)
     {
-        return this.repository.nativeDelete(id);
+        let entity = await this.loadById(id);
+        if(!entity){
+            return false;
+        }
+        await this.orm.em.remove(entity);
+        await this.orm.em.flush();
+        return true;
     }
 
     async count(filters)
@@ -161,31 +199,30 @@ class MikroOrmDriver extends BaseDriver
             relations = this.getAllRelations();
         }
         let processedFilters = this.processFilters(filters);
-        if(0 === relations.length || 'function' !== typeof this.rawModel.entity.relationMappings){
+        if(0 === relations.length || !this.entitySchema.meta || !this.entitySchema.meta.properties){
             return this.repository.count(processedFilters);
         }
-        let queryBuilder = this.orm.em.createQueryBuilder(this.rawModel);
-        let relationMappings = this.rawModel.entity.relationMappings();
+        let queryBuilder = this.orm.em.createQueryBuilder(this.entitySchema);
+        let properties = this.entitySchema.meta.properties;
         let aliasCounter = 0;
         for(let relationName of relations){
-            let relation = relationMappings[relationName];
-            if(!relation){
+            let prop = properties[relationName];
+            if(!prop || !prop.kind || (prop.kind !== 'm:1' && prop.kind !== '1:m')){
                 continue;
             }
-            let relationEntity = this.server.entityManager.get(relation.entityName);
-            if(!relationEntity || !relationEntity.rawModel){
+            let relationDriver = this.server.entityManager.get(prop.entity);
+            if(!relationDriver || !relationDriver.entitySchema){
                 continue;
             }
             let alias = 'rel_'+aliasCounter;
-            let joinField = relation.join.from;
-            let targetField = relation.join.to;
-            let isManyToOne = 'm:1' === relation.reference;
-            let isOneToMany = '1:m' === relation.reference;
-            if(isManyToOne){
-                queryBuilder.leftJoin(relationEntity.rawModel, alias, 'e.'+joinField+' = '+alias+'.'+targetField);
+            if('m:1' === prop.kind && prop.joinColumn){
+                queryBuilder.leftJoin(relationName, alias, 'e.'+prop.joinColumn+' = '+alias+'.id');
             }
-            if(isOneToMany){
-                queryBuilder.leftJoin(relationEntity.rawModel, alias, 'e.'+joinField+' = '+alias+'.'+targetField);
+            if('1:m' === prop.kind && prop.mappedBy){
+                let mappedProp = relationDriver.entitySchema.meta.properties[prop.mappedBy];
+                if(mappedProp && mappedProp.joinColumn){
+                    queryBuilder.leftJoin(relationName, alias, 'e.id = '+alias+'.'+mappedProp.joinColumn);
+                }
             }
             aliasCounter++;
         }
@@ -245,7 +282,7 @@ class MikroOrmDriver extends BaseDriver
 
     loadById(id)
     {
-        return this.loadBy('id', id);
+        return this.loadOneBy('id', id);
     }
 
     async loadByIdWithRelations(id, relations)
@@ -253,7 +290,7 @@ class MikroOrmDriver extends BaseDriver
         if(!sc.isArray(relations) || 0 === relations.length){
             relations = this.getAllRelations();
         }
-        let entity = await this.loadBy('id', id);
+        let entity = await this.loadOneBy('id', id);
         return await this.appendRelationsToCollection(entity, relations);
     }
 
@@ -305,6 +342,10 @@ class MikroOrmDriver extends BaseDriver
         let processedFilters = {};
         for(let key of Object.keys(filters)){
             let value = filters[key];
+            if('AND' === key && sc.isArray(value)){
+                processedFilters.$and = value.map(condition => this.processFilters(condition));
+                continue;
+            }
             if('OR' === key && sc.isArray(value)){
                 processedFilters.$or = value.map(condition => this.processFilters(condition));
                 continue;
@@ -328,26 +369,22 @@ class MikroOrmDriver extends BaseDriver
         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;
+        if('EQ' === upperOperator){
+            return value;
+        }
+        if(sc.hasOwn(this.mikroOrmOperators, upperOperator)){
+            return {[this.mikroOrmOperators[upperOperator]]: value};
+        }
+        return value;
     }
 
     handleLikeOperator(value, fieldName)
     {
         let cleanValue = String(value).replace(/%/g, '');
         if(this.isJsonField(fieldName)){
-            return {$like: '%' + cleanValue + '%'};
+            return {$like: '%'+cleanValue+'%'};
         }
-        return {$like: '%' + cleanValue + '%'};
+        return {$like: '%'+cleanValue+'%'};
     }
 
     queryBuilder(useLimit = false, useOffset = false, useSort = false)
@@ -362,7 +399,7 @@ class MikroOrmDriver extends BaseDriver
         if(useOffset && 0 !== this.offset){
             queryBuilder.offset = this.offset;
         }
-        if(useSort && false !== this.sortBy && false !== this.sortDirection){
+        if(useSort && this.sortBy && this.sortDirection){
             queryBuilder.orderBy = {
                 [this.sortBy]: this.sortDirection,
             };
@@ -381,99 +418,130 @@ class MikroOrmDriver extends BaseDriver
         return filter;
     }
 
-    async appendRelationsToCollection(entitiesCollection, relations)
+    convertCollectionsToArrays(entity)
     {
-        if('function' !== typeof this.rawModel.entity.relationMappings){
-            return entitiesCollection;
-        }
-        if(!sc.isArray(relations) || 0 === relations.length){
-            relations = this.getAllRelations();
-        }
-        if(0 === relations.length){
-            return entitiesCollection;
+        if(!entity){
+            return entity;
         }
-        if(sc.isArray(entitiesCollection)){
-            for(let entity of entitiesCollection){
-                await this.appendRelatedEntities(entity, relations);
+        for(let key of Object.keys(entity)){
+            if(entity[key] && entity[key] instanceof Collection){
+                entity[key] = entity[key].getItems();
             }
         }
-        if(!sc.isArray(entitiesCollection)){
-            await this.appendRelatedEntities(entitiesCollection, relations);
-        }
-        return entitiesCollection;
+        return entity;
     }
 
-    async appendRelatedEntities(entity, relations)
+    addFkFieldsFromRelations(entity)
     {
-        if('function' !== typeof this.rawModel.entity.relationMappings){
+        if(!entity){
             return entity;
         }
-        let relationMappings = this.rawModel.entity.relationMappings();
-        for(let i of relations){
-            let relation = relationMappings[i];
-            let relationRepository = this.server.getEntity(relation.entityName);
-            let isManyToOne = 'm:1' === relation.reference;
-            let isOneToMany = '1:m' === relation.reference;
-            if(isManyToOne){
-                entity[i] = await relationRepository.loadOneBy(relation.join.to, entity[relation.join.from]);
+        for(let fkColumn of Object.keys(this.fkMappings)){
+            let mapping = this.fkMappings[fkColumn];
+            let relation = entity[mapping.relationKey];
+            if(!relation){
+                continue;
+            }
+            if(sc.hasOwn(relation, mapping.referencedColumn)){
+                entity[fkColumn] = relation[mapping.referencedColumn];
+                continue;
             }
-            if(isOneToMany){
-                entity[i] = await relationRepository.loadBy(relation.join.to, entity[relation.join.from]);
+            if(sc.hasOwn(relation, 'id')){
+                entity[fkColumn] = relation.id;
             }
         }
         return entity;
     }
 
+    async appendRelationsToCollection(entitiesCollection, relations)
+    {
+        if(!relations || 0 === relations.length){
+            return entitiesCollection;
+        }
+        if(!entitiesCollection){
+            return entitiesCollection;
+        }
+        await this.orm.em.populate(entitiesCollection, relations);
+        if(sc.isArray(entitiesCollection)){
+            for(let entity of entitiesCollection){
+                this.convertCollectionsToArrays(entity);
+            }
+            return entitiesCollection;
+        }
+        return this.convertCollectionsToArrays(entitiesCollection);
+    }
+
     async createNested(newInstance, params, relations)
     {
-        if('function' !== typeof this.rawModel.entity.relationMappings){
+        if(!this.entitySchema.meta || !this.entitySchema.meta.properties){
             return false;
         }
-        let relationMappings = this.rawModel.entity.relationMappings();
-        for(let i of Object.keys(relationMappings)){
-            if(sc.isArray(relations) && 0 < relations.length && -1 === relations.indexOf(i)){
+        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')){
                 continue;
             }
-            let relation = relationMappings[i];
-            let relationEntity = this.server.entityManager.get(relation.entityName).rawModel.entity;
-            if(!relationEntity){
-                Logger.warning('Factory not found for relation definition:', relation);
+            if(sc.isArray(relations) && 0 < relations.length && -1 === relations.indexOf(relationName)){
                 continue;
             }
-            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, relation);
+            let relationDriver = this.server.entityManager.get(prop.entity);
+            if(!relationDriver){
+                Logger.warning('Entity not found for relation:', prop.entity);
+                continue;
+            }
+            let isOneToMany = '1:m' === prop.kind;
+            let isManyToOne = 'm:1' === prop.kind;
+            if(isManyToOne && sc.hasOwn(params, relationName)){
+                await this.createOne(params, relationName, relationDriver, newInstance, prop);
                 continue;
             }
-            if(isArray){
-                await this.createMany(params, i, relationEntity, newInstance, relation);
+            if(isOneToMany && sc.hasOwn(params, relationName) && sc.isArray(params[relationName])){
+                await this.createMany(params, relationName, relationDriver, newInstance, prop);
             }
         }
     }
 
-    async createOne(params, i, relationEntity, newInstance, relation)
+    async createOne(params, relationName, relationDriver, newInstance, prop)
     {
-        params[i] = newInstance[relation.join.from];
-        let nestedObject = relationEntity.createByProps(params[i]);
-        await this.repository.persist(nestedObject).flush();
+        let nestedData = params[relationName];
+        if(prop.joinColumn){
+            nestedData[prop.joinColumn] = newInstance.id;
+        }
+        let nestedObject = await relationDriver.create(nestedData);
         await this.orm.em.flush();
-        newInstance[i] = nestedObject;
+        newInstance[relationName] = nestedObject;
     }
 
-    async createMany(params, i, relationEntity, newInstance, relation)
+    async createMany(params, relationName, relationDriver, newInstance, prop)
     {
         let nestedArray = [];
-        for(let objectData of params[i]){
-            objectData[relation.join.to] = newInstance[relation.join.from];
-            let nestedObject = relationEntity.createByProps(objectData);
-            await this.repository.persist(nestedObject).flush();
+        for(let objectData of params[relationName]){
+            if(prop.joinColumn){
+                objectData[prop.joinColumn] = newInstance.id;
+            }
+            let nestedObject = await relationDriver.create(objectData);
             await this.orm.em.flush();
             nestedArray.push(nestedObject);
         }
-        newInstance[i] = nestedArray;
+        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;
     }
 
 }