@reldens/storage 0.10.0-beta.32 → 0.10.0-beta.33

package/README.md

@@ -1,7 +1,58 @@
-[![Reldens - GitHub - Release](https://www.dwdeveloper.com/media/reldens/reldens-mmorpg-platform.png)](https://github.com/damian-pastorini/reldens)
+[![Reldens - GitHub - Release](https://www.dwdeveloper.com/media/reldens/reldens-mmorpg-platform.png)](https://www.reldens.com/)
 
 # Reldens - Storage
 
-### [Reldens](https://github.com/damian-pastorini/reldens/ "Reldens")
+## About this package
+This package is designed to provide a standard drivers support for managing Reldens project data.
+
+This way in Reldens project we can trust that any driver implement will have the exact same methods available to fetch and manage the project entities.
+
+Every time you need to load, create, update or delete data in Reldens, the drivers from this package will be used.
+
+## Current features
+The current drivers are to support two other ORMs:
+- Objection JS (with Knex), for everything that's SQL related.
+```javascript
+let server = new ObjectionJsDataServer({
+    client: 'mysql',
+    config: {
+        user: 'reldens',
+        password: 'reldens',
+        database: 'reldens',
+        port : 3306,
+    }
+});
+```
+- Mikro-ORM, to offer support for MongoDB.
+```javascript
+let server = new MikroOrmDataServer({
+    client: 'mongodb',
+    config: {
+        user: 'reldens',
+        password: 'reldens',
+        database: 'test',
+        port : 27017,
+    },
+    connectStringOptions: 'authSource=reldens&readPreference=primary&appname=MongoDB%20Compass&ssl=false',
+    autoGenerateEntities: false,
+    rawEntities: Object.values(rawRegisteredEntities)
+});
+```
+
+## Custom drivers
+Through this package you can also create your own drivers (to support your own storage system) and later implement it on any Reldens project.
+
+In order to do this, just extend the BaseDataServer and BaseDriver classes and fill all the required methods.
+
+For last, on your Reldens implementation you just need to pass an instance of your data server to the server manager and you are done:
+```
+const appServer = new ServerManager(serverConfig, eventsManager, yourDriverInstance);
+```
+
+You can also check the [skeleton implementation](https://github.com/damian-pastorini/reldens-skeleton/) to see how it works.
+
+For reference see Reldens GitHub: [https://github.com/damian-pastorini/reldens/tree/master](https://github.com/damian-pastorini/reldens/tree/master)
+
+### [Reldens](https://www.reldens.com/ "Reldens")
 
 ##### [By DwDeveloper](https://www.dwdeveloper.com/ "DwDeveloper")

package/lib/base-driver.js

@@ -71,11 +71,16 @@ class BaseDriver
         ErrorManager.error('BaseDriver updateById() not implemented.');
     }
 
-    delete(id)
+    delete(filters)
     {
         ErrorManager.error('BaseDriver delete() not implemented.');
     }
 
+    deleteById(id)
+    {
+        ErrorManager.error('BaseDriver deleteById() not implemented.');
+    }
+
     count(filters)
     {
         ErrorManager.error('BaseDriver count() not implemented.');

package/lib/mikro-orm/mikro-orm-data-server.js

@@ -25,13 +25,9 @@ class MikroOrmDataServer extends BaseDataServer
         }
         this.orm = await MikroORM.init({
             entities: Object.values(this.rawEntities),
-            dbName: this.config.database,
             type: this.clientsMapped[(this.client || 'mongo')],
             clientUrl: this.connectString,
-            host: this.config.host,
-            port: this.config.port,
-            user: this.config.user,
-            password: this.config.password
+            allowGlobalContext: true
         });
         this.initialized = Date.now();
         return this.initialized;
@@ -55,7 +51,8 @@ class MikroOrmDataServer extends BaseDataServer
                 id: i,
                 name: i,
                 config: this.orm.driver.connection.options,
-                orm: this.orm
+                orm: this.orm,
+                server: this
             });
         }
         this.entityManager.setEntities(this.entities);

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

@@ -5,7 +5,7 @@
  */
 
 const { BaseDriver } = require('../base-driver');
-const { ErrorManager, sc } = require('@reldens/utils');
+const { ErrorManager, Logger, sc } = require('@reldens/utils');
 
 class MikroOrmDriver extends BaseDriver
 {
@@ -16,10 +16,14 @@ class MikroOrmDriver extends BaseDriver
         if(!props.orm){
             ErrorManager.error('Missing ORM on Mikro ORM driver.');
         }
+        if(!props.server){
+            ErrorManager.error('Missing Server Driver on Mikro ORM driver.');
+        }
         if(!this.rawModel){
             ErrorManager.error('Missing raw entity on Mikro ORM driver.');
         }
         this.orm = props.orm;
+        this.server = props.server;
         this.repository = this.orm.em.getRepository(this.rawModel.entity);
     }
 
@@ -30,17 +34,17 @@ class MikroOrmDriver extends BaseDriver
 
     id()
     {
-        return this.rawModel.entity || this.name();
+        return this.rawModel.entity.name || this.name();
     }
 
     name()
     {
-        return this.rawModel.entity || this.config.dbName;
+        return this.rawModel.entity.name || this.config.dbName;
     }
 
     tableName()
     {
-        return this.rawModel.entity;
+        return this.rawModel.entity.name;
     }
 
     property(propertyName)
@@ -48,183 +52,263 @@ class MikroOrmDriver extends BaseDriver
         return this.rawModel[propertyName] || null;
     }
 
-    create(params)
+    async create(params)
     {
-        return this.orm.em.create(this.rawModel, params);
+        let newInstance = this.rawModel.factory.create(params);
+        await this.repository.persist(newInstance).flush();
+        return newInstance;
     }
 
-    createWithRelations(params, relations)
+    async createWithRelations(params, relations)
     {
-        return this.create(params, relations);
+        let newInstance = await this.create(params, relations);
+        await this.createNested(newInstance, params);
+        return newInstance;
     }
 
-    update(filters, updatePatch)
+    async update(filters, updatePatch)
     {
-        let queryBuilder = this.queryBuilder(true, true, true);
-        this.appendFilters(queryBuilder, filters);
-        return queryBuilder.patch(updatePatch);
+        let entities = await this.repository.find(filters, this.queryBuilder(true, true, true));
+        if(0 === entities.length){
+            return false;
+        }
+        for(let entity of entities){
+            Object.assign(entity, updatePatch);
+            this.repository.persist(entity).flush();
+        }
+        return entities;
     }
 
-    updateBy(field, fieldValue, updatePatch, operator = null)
+    async updateBy(field, fieldValue, updatePatch, operator = null)
     {
-        let queryBuilder = this.queryBuilder(true, true, true);
-        this.appendSingleFilter(queryBuilder, field, fieldValue, operator);
-        return queryBuilder.patch(updatePatch);
+        let filter = this.createSingleFilter(field, fieldValue, operator);
+        let entities = await this.repository.find(filter, this.queryBuilder(true, true, true));
+        if(0 === entities.length){
+            return false;
+        }
+        for(let entity of entities){
+            Object.assign(entity, updatePatch);
+            this.repository.persist(entity).flush();
+        }
+        return entities;
     }
 
     updateById(id, params)
     {
-        return this.queryBuilder().patchAndFetchById(id, params);
+        return this.update({id}, params);
     }
 
-    delete(id)
+    async delete(filters = {})
     {
-        return this.queryBuilder().deleteById(id);
+        let entries = await this.load(filters);
+        if (!entries){
+            return false;
+        }
+        for(let entry of Object.keys(entries)){
+            await this.repository.nativeDelete(entry.id);
+        }
+    }
+
+    deleteById(id)
+    {
+        return this.repository.nativeDelete(id);
     }
 
     async count(filters)
     {
-        let queryBuilder = this.queryBuilder(true, true, true);
-        this.appendFilters(queryBuilder, filters);
-        let count = await queryBuilder.count().first();
-        return count ? count['count(*)'] : 0;
+        return this.repository.count(filters);
     }
 
     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;
+        // @TODO - BETA - Look a way to filter by sub-entities properties before count.
+        return this.count(filters);
     }
 
     loadAll()
     {
-        return this.queryBuilder();
+        return this.repository.findAll();
     }
 
-    loadAllWithRelations(relations)
+    async loadAllWithRelations(relations)
     {
-        return this.appendRelationsToQuery(this.queryBuilder(), relations);
+        let entities = await this.repository.find(filter, this.queryBuilder(true, true, true));
+        return await this.appendRelationsToCollection(entities, relations);
     }
 
     load(filters)
     {
-        let queryBuilder = this.queryBuilder(true, true, true);
-        this.appendFilters(queryBuilder, filters);
-        return queryBuilder;
+        return this.repository.find(filters, this.queryBuilder(true, true, true));
     }
 
-    loadWithRelations(filters, relations)
+    async loadWithRelations(filters, relations)
     {
-        let queryBuilder = this.queryBuilder(true, true, true);
-        this.appendFilters(queryBuilder, filters);
-        return this.appendRelationsToQuery(queryBuilder, relations);
+        let entitiesCollection = await this.repository.findAll(filters, this.queryBuilder(true, true, true));
+        return await this.appendRelationsToCollection(entitiesCollection, relations);
     }
 
     loadBy(field, fieldValue, operator = null)
     {
-        let queryBuilder = this.queryBuilder(true, true, true);
-        this.appendSingleFilter(queryBuilder, field, fieldValue, operator);
-        return queryBuilder;
+        let filter = this.createSingleFilter(field, fieldValue, operator);
+        return this.repository.find(filter, this.queryBuilder(true, true, true));
     }
 
-    loadByWithRelations(field, fieldValue, relations, operator = null)
+    async loadByWithRelations(field, fieldValue, relations, operator = null)
     {
-        let queryBuilder = this.queryBuilder(true, true, true);
-        this.appendSingleFilter(queryBuilder, field, fieldValue, operator);
-        return this.appendRelationsToQuery(queryBuilder, relations);
+        let filter = this.createSingleFilter(field, fieldValue, operator);
+        let entitiesCollection = await this.repository.find(filter, this.queryBuilder(true, true, true));
+        return await this.appendRelationsToCollection(entitiesCollection, relations);
     }
 
     loadById(id)
     {
-        return this.queryBuilder().findById(id);
+        return this.loadBy({id});
     }
 
-    loadByIdWithRelations(id, relations)
+    async loadByIdWithRelations(id, relations)
     {
-        return this.appendRelationsToQuery(this.queryBuilder().findById(id), relations);
+        let entity = await this.loadBy({id});
+        return await this.appendRelationsToCollection(entity, relations);
     }
 
     loadByIds(ids)
     {
-        return this.queryBuilder().findByIds(ids);
+        this.repository.find({id: {$in: ids}});
     }
 
     loadOne(filters)
     {
-        let queryBuilder = this.queryBuilder(false, true, true);
-        this.appendFilters(queryBuilder, filters);
-        return queryBuilder.limit(1).first();
+        return this.repository.findOne(filters, this.queryBuilder(false, true, true));
     }
 
-    loadOneWithRelations(filters, relations)
+    async loadOneWithRelations(filters, relations)
     {
-        let queryBuilder = this.queryBuilder(false, true, true);
-        this.appendFilters(queryBuilder, filters);
-        return this.appendRelationsToQuery(queryBuilder, relations).limit(1).first();
+        let entitiesCollection = await this.loadOne(filters);
+        return this.appendRelationsToCollection(entitiesCollection, relations);
     }
 
     loadOneBy(field, fieldValue, operator = null)
     {
-        let queryBuilder = this.queryBuilder(false, true, true);
-        this.appendSingleFilter(queryBuilder, field, fieldValue, operator);
-        return queryBuilder.limit(1).first();
+        let filter = this.createSingleFilter(field, fieldValue, operator);
+        return this.repository.findOne(filter, this.queryBuilder(false, true, true));
     }
 
-    loadOneByWithRelations(field, fieldValue, relations, operator = null)
+    async 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();
+        let filter = this.createSingleFilter(field, fieldValue, operator);
+        let entitiesCollection = await this.repository.findOne(filter, this.queryBuilder(false, true, true));
+        return this.appendRelationsToCollection(entitiesCollection, relations);
     }
 
     queryBuilder(useLimit = false, useOffset = false, useSort = false)
     {
-        let queryBuilder = this.orm.em.getKnex();
+        let queryBuilder = {};
         if(useLimit && 0 !== this.limit){
-            queryBuilder.limit(this.limit)
+            queryBuilder.limit = this.limit;
         }
         if(useOffset && 0 !== this.offset){
-            queryBuilder.offset(this.offset)
+            queryBuilder.offset = this.offset;
         }
         if(useSort && false !== this.sortBy && false !== this.sortDirection){
-            queryBuilder.orderBy(this.sortBy, this.sortDirection)
+            queryBuilder.orderBy = {
+                [this.sortBy]: this.sortDirection,
+            };
         }
         return queryBuilder;
     }
 
-    appendSingleFilter(queryBuilder, field, fieldValue, operator = null)
+    createSingleFilter(field, fieldValue, operator = null)
     {
-        (null === operator) ? queryBuilder.where(field, fieldValue) : queryBuilder.where(field, operator, fieldValue);
-        return queryBuilder;
+        let filter = {};
+        if(null === operator) {
+            filter[field] = fieldValue;
+            return filter;
+        }
+        filter[field] = {};
+        filter[field][operator] = fieldValue;
+        return filter;
     }
 
-    appendFilters(queryBuilder, filters)
+    async appendRelationsToCollection(entitiesCollection, relations)
     {
-        let filtersKeys = Object.keys(filters);
-        if(0 === filtersKeys.length){
-            return queryBuilder;
+        // @TODO - BETA - Refactor. I would like to use populate but it may not work if the driver is not Mongo DB.
+        if(!sc.isArray(relations) || 0 === relations.length){
+            relations = Object.keys(this.rawModel.relationsMappings || {});
         }
-        for(let i of filtersKeys){
-            let filter = filters[i];
-            sc.hasOwn(filter, 'operator')
-                ? queryBuilder.where(i, filter.operator, filter.value)
-                : queryBuilder.where(i, filter);
+        if(0 === relations.length){
+            return entitiesCollection;
         }
-        return queryBuilder;
+        for(let entity of entitiesCollection){
+            await this.appendRelatedEntities(entity, relations);
+        }
+        return entitiesCollection;
     }
 
-    async appendRelationsToQuery(queryBuilder, relations)
+    async appendRelatedEntities(entity, relations)
     {
-        if(!sc.isArray(relations) || 0 === relations.length){
-            relations = Object.keys(this.rawModel.relationMappings || {});
+        // @TODO - BETA - Refactor and improve.
+        for(let i of relations){
+            let relation = this.rawModel.relationsMappings[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]);
+            }
+            if(isOneToMany){
+                entity[i] = await relationRepository.loadBy(relation.join.to, entity[relation.join.from]);
+            }
+        }
+    }
+
+    async createNested(newInstance, params)
+    {
+        if(!sc.hasOwn(this.rawModel, 'relationsMappings')){
+            return false;
         }
-        if(0 < relations.length){
-            let result = await queryBuilder;
-            return this.orm.em.populate(result, relations);
+        for(let i of Object.keys(this.rawModel.relationsMappings)){
+            // @TODO - BETA - Refactor and improve.
+            let relationData = this.rawModel.relationsMappings[i];
+            let relationFactory = this.server.entityManager.get(relationData.entityName).rawModel.factory;
+            if(!relationFactory){
+                Logger.warning('Factory not found for relation definition:', relationData);
+                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]){
+                    continue;
+                }
+                await this.createOne(params, i, relationFactory, newInstance, relationData);
+                continue;
+            }
+            if(isOneToMany){
+                await this.createMany(params, i, relationFactory, newInstance, relationData);
+            }
         }
-        return queryBuilder;
+    }
+
+    async createOne(params, i, relationFactory, newInstance, relationData)
+    {
+        params[i] = newInstance[relationData.join.from];
+        let nestedObject = relationFactory.create(params[i]);
+        await this.repository.persist(nestedObject).flush();
+        await this.orm.em.flush();
+        newInstance[i] = nestedObject;
+    }
+
+    async createMany(params, i, relationFactory, newInstance, relationData)
+    {
+        let nestedArray = [];
+        for(let objectData of params[i]){
+            objectData[relationData.join.to] = newInstance[relationData.join.from];
+            let nestedObject = relationFactory.create(objectData);
+            await this.repository.persist(nestedObject).flush();
+            await this.orm.em.flush();
+            nestedArray.push(nestedObject);
+        }
+        newInstance[i] = nestedArray;
     }
 
 }

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

@@ -64,7 +64,14 @@ class ObjectionJsDriver extends BaseDriver
         return this.queryBuilder().patchAndFetchById(id, params);
     }
 
-    delete(id)
+    delete(filters)
+    {
+        let queryBuilder = this.queryBuilder(true, true, true);
+        this.appendFilters(queryBuilder, filters);
+        return queryBuilder.delete();
+    }
+
+    deleteById(id)
     {
         return this.queryBuilder().deleteById(id);
     }

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@reldens/storage",
     "scope": "@reldens",
-    "version": "0.10.0-beta.32",
+    "version": "0.10.0-beta.33",
     "description": "Reldens - Storage",
     "author": "Damian A. Pastorini",
     "license": "MIT",
@@ -44,10 +44,10 @@
         "url": "https://github.com/damian-pastorini/reldens-storage/issues"
     },
     "dependencies": {
-        "@mikro-orm/core": "^4.5.10",
-        "@mikro-orm/mongodb": "^4.5.10",
-        "@reldens/utils": "^0.10.0-beta.3",
-        "knex": "^1.0.1",
+        "@mikro-orm/core": "^5.0.0",
+        "@mikro-orm/mongodb": "^5.0.0",
+        "@reldens/utils": "^0.10.0-beta.4",
+        "knex": "^1.0.3",
         "mysql": "^2.18.1",
         "objection": "^3.0.1"
     }