@reldens/storage 0.10.0-beta.29 → 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/index.js

@@ -11,6 +11,7 @@ const { ObjectionJsDataServer } = require('./lib/objection-js/objection-js-data-
 const { Model } = require('objection');
 const { MikroOrmDriver } = require('./lib/mikro-orm/mikro-orm-driver');
 const { MikroOrmDataServer } = require('./lib/mikro-orm/mikro-orm-data-server');
+const MikroOrmCore = require('@mikro-orm/core');
 
 module.exports = {
     // base:
@@ -21,6 +22,7 @@ module.exports = {
     ObjectionJsDriver: ObjectionJsDriver,
     ObjectionJsRawModel: Model,
     // mikro-orm:
+    MikroOrmCore,
     MikroOrmDataServer: MikroOrmDataServer,
     MikroOrmDriver: MikroOrmDriver
 };

package/lib/base-data-server.js

@@ -12,21 +12,36 @@ class BaseDataServer
 
     constructor(props)
     {
-        this.config = sc.get(props, 'config', false);
-        this.client = sc.get(props, 'client', false);
-        this.poolConfig = sc.get(props, 'poolConfig', false);
-        this.connectString = sc.get(props, 'connectString', false);
+        this.config = sc.get(props, 'config', {});
+        if(!this.config.host){
+            this.config.host = 'localhost';
+        }
+        this.client = sc.get(props, 'client', '');
+        this.poolConfig = sc.get(props, 'poolConfig', {});
+        this.connectStringOptions = sc.get(props, 'connectStringOptions', '');
+        this.connectString = sc.get(props, 'connectString', this.createConnectionString());
         this.rawModel = sc.get(props, 'rawModel', false);
         this.name = sc.get(props, 'name', false);
         this.initialized = sc.get(props, 'initialized', false);
         this.rawEntities = props.rawEntities;
-        let entities = props.entities || props.rawEntities ? this.generateEntities(props.rawEntities) : {};
-        this.entityManager = new EntityManager({entities});
+        this.entities = props.entities || {};
+        this.entityManager = new EntityManager({entities: this.entities});
     }
 
-    connect()
+    createConnectionString()
     {
-        ErrorManager.error('BaseDriver connect() not implemented.');
+        return (this.client || 'client-not-specified')+'://'
+            +(this.config.user || 'user-not-specified')
+            +(this.config.password ? ':'+this.config.password : '')
+            +'@'+this.config.host
+            +':'+(this.config.port || 3306)
+            +(this.config.database ? '/'+this.config.database : '')
+            +(this.connectStringOptions ? '?'+this.connectStringOptions : '');
+    }
+
+    getEntity(entityName)
+    {
+        return this.entityManager.get(entityName);
     }
 
     generateEntities(rawEntities)
@@ -34,9 +49,9 @@ class BaseDataServer
         ErrorManager.error('BaseDriver generateEntities() not implemented.');
     }
 
-    getEntity(entityName)
+    async connect()
     {
-        return this.entityManager.get(entityName);
+        ErrorManager.error('BaseDriver connect() not implemented.');
     }
 
 }

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

@@ -4,15 +4,64 @@
  *
  */
 
+const { MikroOrmDriver } = require('./mikro-orm-driver');
 const { BaseDataServer } = require('../base-data-server');
+const { MikroORM } = require('@mikro-orm/core');
+const { Logger } = require('@reldens/utils');
 
 class MikroOrmDataServer extends BaseDataServer
 {
 
-    constructor(props)
+    orm = {};
+    clientsMapped = {
+        mysql: 'mysql',
+        mongodb: 'mongo'
+    };
+
+    async connect()
+    {
+        if(this.initialized){
+            return this.initialized;
+        }
+        this.orm = await MikroORM.init({
+            entities: Object.values(this.rawEntities),
+            type: this.clientsMapped[(this.client || 'mongo')],
+            clientUrl: this.connectString,
+            allowGlobalContext: true
+        });
+        this.initialized = Date.now();
+        return this.initialized;
+    }
+
+    generateEntities(rawEntities)
+    {
+        if(!this.initialized){
+            Logger.critical('In order to generate entities with Mikro ORM driver you need to connect to the server.');
+            return {};
+        }
+        if(!this.rawEntities){
+            Logger.warning('Empty raw entities array, none entities generated.');
+            return {};
+        }
+        this.entities = {};
+        for(let i of Object.keys(rawEntities)){
+            let rawEntity = rawEntities[i];
+            this.entities[i] = new MikroOrmDriver({
+                rawModel: rawEntity,
+                id: i,
+                name: i,
+                config: this.orm.driver.connection.options,
+                orm: this.orm,
+                server: this
+            });
+        }
+        this.entityManager.setEntities(this.entities);
+        return this.entities;
+    }
+
+    name()
     {
-        super(props);
-        // @TODO: implement.
+        return this.name || 'Mikro-ORM Data Server Driver';
     }
 
 }

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

@@ -5,6 +5,7 @@
  */
 
 const { BaseDriver } = require('../base-driver');
+const { ErrorManager, Logger, sc } = require('@reldens/utils');
 
 class MikroOrmDriver extends BaseDriver
 {
@@ -12,7 +13,302 @@ class MikroOrmDriver extends BaseDriver
     constructor(props)
     {
         super(props);
-        // @TODO: implement.
+        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);
+    }
+
+    databaseName()
+    {
+        return this.config.dbName || '';
+    }
+
+    id()
+    {
+        return this.rawModel.entity.name || this.name();
+    }
+
+    name()
+    {
+        return this.rawModel.entity.name || this.config.dbName;
+    }
+
+    tableName()
+    {
+        return this.rawModel.entity.name;
+    }
+
+    property(propertyName)
+    {
+        return this.rawModel[propertyName] || null;
+    }
+
+    async create(params)
+    {
+        let newInstance = this.rawModel.factory.create(params);
+        await this.repository.persist(newInstance).flush();
+        return newInstance;
+    }
+
+    async createWithRelations(params, relations)
+    {
+        let newInstance = await this.create(params, relations);
+        await this.createNested(newInstance, params);
+        return newInstance;
+    }
+
+    async update(filters, 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;
+    }
+
+    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));
+        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.update({id}, params);
+    }
+
+    async delete(filters = {})
+    {
+        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)
+    {
+        return this.repository.count(filters);
+    }
+
+    async countWithRelations(filters, relations)
+    {
+        // @TODO - BETA - Look a way to filter by sub-entities properties before count.
+        return this.count(filters);
+    }
+
+    loadAll()
+    {
+        return this.repository.findAll();
+    }
+
+    async loadAllWithRelations(relations)
+    {
+        let entities = await this.repository.find(filter, this.queryBuilder(true, true, true));
+        return await this.appendRelationsToCollection(entities, relations);
+    }
+
+    load(filters)
+    {
+        return this.repository.find(filters, this.queryBuilder(true, true, true));
+    }
+
+    async loadWithRelations(filters, 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 filter = this.createSingleFilter(field, fieldValue, operator);
+        return this.repository.find(filter, 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));
+        return await this.appendRelationsToCollection(entitiesCollection, relations);
+    }
+
+    loadById(id)
+    {
+        return this.loadBy({id});
+    }
+
+    async loadByIdWithRelations(id, relations)
+    {
+        let entity = await this.loadBy({id});
+        return await this.appendRelationsToCollection(entity, relations);
+    }
+
+    loadByIds(ids)
+    {
+        this.repository.find({id: {$in: ids}});
+    }
+
+    loadOne(filters)
+    {
+        return this.repository.findOne(filters, this.queryBuilder(false, true, true));
+    }
+
+    async loadOneWithRelations(filters, relations)
+    {
+        let entitiesCollection = await this.loadOne(filters);
+        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));
+    }
+
+    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));
+        return this.appendRelationsToCollection(entitiesCollection, relations);
+    }
+
+    queryBuilder(useLimit = false, useOffset = false, useSort = false)
+    {
+        let queryBuilder = {};
+        if(useLimit && 0 !== this.limit){
+            queryBuilder.limit = this.limit;
+        }
+        if(useOffset && 0 !== this.offset){
+            queryBuilder.offset = this.offset;
+        }
+        if(useSort && false !== this.sortBy && false !== this.sortDirection){
+            queryBuilder.orderBy = {
+                [this.sortBy]: this.sortDirection,
+            };
+        }
+        return queryBuilder;
+    }
+
+    createSingleFilter(field, fieldValue, operator = null)
+    {
+        let filter = {};
+        if(null === operator) {
+            filter[field] = fieldValue;
+            return filter;
+        }
+        filter[field] = {};
+        filter[field][operator] = fieldValue;
+        return filter;
+    }
+
+    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(!sc.isArray(relations) || 0 === relations.length){
+            relations = Object.keys(this.rawModel.relationsMappings || {});
+        }
+        if(0 === relations.length){
+            return entitiesCollection;
+        }
+        for(let entity of entitiesCollection){
+            await this.appendRelatedEntities(entity, relations);
+        }
+        return entitiesCollection;
+    }
+
+    async appendRelatedEntities(entity, relations)
+    {
+        // @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;
+        }
+        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);
+            }
+        }
+    }
+
+    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-data-server.js

@@ -8,6 +8,7 @@ const { BaseDataServer } = require('../base-data-server');
 const { ObjectionJsDriver } = require('./objection-js-driver');
 const { Model } = require('objection');
 const Knex = require('knex');
+const { Logger } = require('@reldens/utils');
 
 class ObjectionJsDataServer extends BaseDataServer
 {
@@ -21,26 +22,32 @@ class ObjectionJsDataServer extends BaseDataServer
         }
     }
 
-    connect()
+    async connect()
     {
         if(this.initialized){
             return this.initialized;
         }
         // initialize knex, the query builder:
-        this.knex = Knex({client: this.client, connection: this.config, pool: this.poolConfig});
+        this.knex = await Knex({client: this.client, connection: this.config, pool: this.poolConfig});
         // give the knex instance to Objection:
         this.rawModel.knex(this.knex);
         this.initialized = Date.now();
+        return this.initialized;
     }
 
-    generateEntities(rawEntities)
+    generateEntities()
     {
-        let entities = {};
-        for(let i of Object.keys(rawEntities)){
-            let rawEntity = rawEntities[i];
-            entities[i] = new ObjectionJsDriver({rawModel: rawEntity, id: i, name: i, config: rawEntity.knex});
+        if(!this.rawEntities){
+            Logger.warning('Empty raw entities array, none entities generated.');
+            return {};
         }
-        return entities;
+        this.entities = {};
+        for(let i of Object.keys(this.rawEntities)){
+            let rawEntity = this.rawEntities[i];
+            this.entities[i] = new ObjectionJsDriver({rawModel: rawEntity, id: i, name: i, config: rawEntity.knex});
+        }
+        this.entityManager.setEntities(this.entities);
+        return this.entities;
     }
 
     name()

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

@@ -10,11 +10,6 @@ const { sc } = require('@reldens/utils');
 class ObjectionJsDriver extends BaseDriver
 {
 
-    constructor(props)
-    {
-        super(props);
-    }
-
     databaseName()
     {
         return this.rawModel.knex().client.config.connection.database || '';
@@ -69,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);
     }
@@ -209,10 +211,10 @@ class ObjectionJsDriver extends BaseDriver
 
     appendRelationsToQuery(queryBuilder, relations)
     {
-        if(!sc.isArray(relations) || relations.length === 0){
+        if(!sc.isArray(relations) || 0 === relations.length){
             relations = Object.keys(this.rawModel.relationMappings || {});
         }
-        if(relations.length > 0){
+        if(0 < relations.length){
             queryBuilder.withGraphFetched('['+relations.join(',')+']');
         }
         return queryBuilder;

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@reldens/storage",
     "scope": "@reldens",
-    "version": "0.10.0-beta.29",
+    "version": "0.10.0-beta.33",
     "description": "Reldens - Storage",
     "author": "Damian A. Pastorini",
     "license": "MIT",
@@ -44,9 +44,11 @@
         "url": "https://github.com/damian-pastorini/reldens-storage/issues"
     },
     "dependencies": {
-        "@reldens/utils": "^0.10.0-beta.3",
-        "knex": "^0.95.15",
-        "objection": "^3.0.1",
-        "mysql": "^2.18.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"
     }
 }