@reldens/storage 0.10.0-beta.29 → 0.10.0-beta.30

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/mikro-orm/mikro-orm-data-server.js

@@ -4,15 +4,66 @@
  *
  */
 
+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),
+            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
+        });
+        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
+            });
+        }
+        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, sc } = require('@reldens/utils');
 
 class MikroOrmDriver extends BaseDriver
 {
@@ -12,7 +13,218 @@ class MikroOrmDriver extends BaseDriver
     constructor(props)
     {
         super(props);
-        // @TODO: implement.
+        if(!props.orm){
+            ErrorManager.error('Missing ORM on Mikro ORM driver.');
+        }
+        if(!this.rawModel){
+            ErrorManager.error('Missing raw entity on Mikro ORM driver.');
+        }
+        this.orm = props.orm;
+        this.repository = this.orm.em.getRepository(this.rawModel.entity);
+    }
+
+    databaseName()
+    {
+        return this.config.dbName || '';
+    }
+
+    id()
+    {
+        return this.rawModel.entity || this.name();
+    }
+
+    name()
+    {
+        return this.rawModel.entity || this.config.dbName;
+    }
+
+    tableName()
+    {
+        return this.rawModel.entity;
+    }
+
+    property(propertyName)
+    {
+        return this.rawModel[propertyName] || null;
+    }
+
+    create(params)
+    {
+        return this.orm.em.create(this.rawModel, params);
+    }
+
+    createWithRelations(params, relations)
+    {
+        return this.create(params, relations);
+    }
+
+    update(filters, updatePatch)
+    {
+        let queryBuilder = this.queryBuilder(true, true, true);
+        this.appendFilters(queryBuilder, filters);
+        return queryBuilder.patch(updatePatch);
+    }
+
+    updateBy(field, fieldValue, updatePatch, operator = null)
+    {
+        let queryBuilder = this.queryBuilder(true, true, true);
+        this.appendSingleFilter(queryBuilder, field, fieldValue, operator);
+        return queryBuilder.patch(updatePatch);
+    }
+
+    updateById(id, params)
+    {
+        return this.queryBuilder().patchAndFetchById(id, params);
+    }
+
+    delete(id)
+    {
+        return this.queryBuilder().deleteById(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;
+    }
+
+    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;
+    }
+
+    loadAll()
+    {
+        return this.queryBuilder();
+    }
+
+    loadAllWithRelations(relations)
+    {
+        return this.appendRelationsToQuery(this.queryBuilder(), relations);
+    }
+
+    load(filters)
+    {
+        let queryBuilder = this.queryBuilder(true, true, true);
+        this.appendFilters(queryBuilder, filters);
+        return queryBuilder;
+    }
+
+    loadWithRelations(filters, relations)
+    {
+        let queryBuilder = this.queryBuilder(true, true, true);
+        this.appendFilters(queryBuilder, filters);
+        return this.appendRelationsToQuery(queryBuilder, relations);
+    }
+
+    loadBy(field, fieldValue, operator = null)
+    {
+        let queryBuilder = this.queryBuilder(true, true, true);
+        this.appendSingleFilter(queryBuilder, field, fieldValue, operator);
+        return queryBuilder;
+    }
+
+    loadByWithRelations(field, fieldValue, relations, operator = null)
+    {
+        let queryBuilder = this.queryBuilder(true, true, true);
+        this.appendSingleFilter(queryBuilder, field, fieldValue, operator);
+        return this.appendRelationsToQuery(queryBuilder, relations);
+    }
+
+    loadById(id)
+    {
+        return this.queryBuilder().findById(id);
+    }
+
+    loadByIdWithRelations(id, relations)
+    {
+        return this.appendRelationsToQuery(this.queryBuilder().findById(id), relations);
+    }
+
+    loadByIds(ids)
+    {
+        return this.queryBuilder().findByIds(ids);
+    }
+
+    loadOne(filters)
+    {
+        let queryBuilder = this.queryBuilder(false, true, true);
+        this.appendFilters(queryBuilder, filters);
+        return queryBuilder.limit(1).first();
+    }
+
+    loadOneWithRelations(filters, relations)
+    {
+        let queryBuilder = this.queryBuilder(false, true, true);
+        this.appendFilters(queryBuilder, filters);
+        return this.appendRelationsToQuery(queryBuilder, relations).limit(1).first();
+    }
+
+    loadOneBy(field, fieldValue, operator = null)
+    {
+        let queryBuilder = this.queryBuilder(false, true, true);
+        this.appendSingleFilter(queryBuilder, field, fieldValue, operator);
+        return queryBuilder.limit(1).first();
+    }
+
+    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();
+    }
+
+    queryBuilder(useLimit = false, useOffset = false, useSort = false)
+    {
+        let queryBuilder = this.orm.em.getKnex();
+        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;
+    }
+
+    appendSingleFilter(queryBuilder, field, fieldValue, operator = null)
+    {
+        (null === operator) ? queryBuilder.where(field, fieldValue) : queryBuilder.where(field, operator, fieldValue);
+        return queryBuilder;
+    }
+
+    appendFilters(queryBuilder, filters)
+    {
+        let filtersKeys = Object.keys(filters);
+        if(0 === filtersKeys.length){
+            return queryBuilder;
+        }
+        for(let i of filtersKeys){
+            let filter = filters[i];
+            sc.hasOwn(filter, 'operator')
+                ? queryBuilder.where(i, filter.operator, filter.value)
+                : queryBuilder.where(i, filter);
+        }
+        return queryBuilder;
+    }
+
+    async appendRelationsToQuery(queryBuilder, relations)
+    {
+        if(!sc.isArray(relations) || 0 === relations.length){
+            relations = Object.keys(this.rawModel.relationMappings || {});
+        }
+        if(0 < relations.length){
+            let result = await queryBuilder;
+            return this.orm.em.populate(result, relations);
+        }
+        return queryBuilder;
     }
 
 }

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,31 @@ 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});
+        }
+        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 || '';
@@ -209,10 +204,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.30",
     "description": "Reldens - Storage",
     "author": "Damian A. Pastorini",
     "license": "MIT",
@@ -44,9 +44,11 @@
         "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": "^0.95.15",
-        "objection": "^3.0.1",
-        "mysql": "^2.18.1"
+        "knex": "^1.0.1",
+        "mysql": "^2.18.1",
+        "objection": "^3.0.1"
     }
 }