@reldens/storage 0.117.0 → 0.119.0

package/lib/kysely/kysely-driver.js

@@ -0,0 +1,176 @@
+/**
+ *
+ * Reldens - KyselyDriver
+ *
+ */
+
+const { QueryBuilderDriver } = require('../query-builder-driver');
+const { sc } = require('@reldens/utils');
+
+class KyselyDriver extends QueryBuilderDriver
+{
+
+    constructor(props)
+    {
+        super(props);
+        this.db = sc.get(props, 'db', false);
+        this.sql = sc.get(props, 'sql', false);
+    }
+
+    async insertRow(data)
+    {
+        let result = await this.db.insertInto(this.tableName()).values(data).executeTakeFirst();
+        return Number(sc.get(result, 'insertId', 0) || 0);
+    }
+
+    selectRows(filters, options)
+    {
+        let query = this.db.selectFrom(this.tableName());
+        query = 0 < options.select.length ? query.select(options.select) : query.selectAll();
+        query = this.appendFilters(query, filters);
+        if(0 < options.limit){
+            query = query.limit(options.limit);
+        }
+        if(0 < options.offset){
+            query = query.offset(options.offset);
+        }
+        if(options.sortBy && options.sortDirection){
+            query = query.orderBy(options.sortBy, options.sortDirection.toLowerCase());
+        }
+        return query.execute();
+    }
+
+    async update(filters, updatePatch)
+    {
+        let query = this.appendFilters(this.db.updateTable(this.tableName()).set(updatePatch), filters);
+        let result = await query.executeTakeFirst();
+        return Number(sc.get(result, 'numUpdatedRows', 0));
+    }
+
+    async delete(filters = {})
+    {
+        let result = await this.appendFilters(this.db.deleteFrom(this.tableName()), filters).executeTakeFirst();
+        return Number(sc.get(result, 'numDeletedRows', 0));
+    }
+
+    async count(filters = {})
+    {
+        let query = this.db.selectFrom(this.tableName()).select(builder => builder.fn.countAll().as('count'));
+        let result = await this.appendFilters(query, filters).executeTakeFirst();
+        if(!result){
+            return 0;
+        }
+        return Number(result.count);
+    }
+
+    appendFilters(query, filters = {})
+    {
+        if(0 === Object.keys(filters).length){
+            return query;
+        }
+        return query.where(builder => this.filtersExpression(builder, filters) || builder.lit(true));
+    }
+
+    filtersExpression(builder, filters)
+    {
+        let expressions = [];
+        for(let key of Object.keys(filters)){
+            expressions = this.appendExpression(builder, expressions, key, filters[key]);
+        }
+        if(0 === expressions.length){
+            return null;
+        }
+        return builder.and(expressions);
+    }
+
+    appendExpression(builder, expressions, key, filter)
+    {
+        if(('AND' === key || 'OR' === key) && sc.isArray(filter)){
+            return this.appendGroupExpression(builder, expressions, key, filter);
+        }
+        let operator = sc.get(filter, 'operator', '').toUpperCase();
+        if('OR' === operator){
+            return this.appendOrValueExpression(builder, expressions, key, filter);
+        }
+        if(operator){
+            expressions.push(this.operatorExpression(builder, key, operator, filter));
+            return expressions;
+        }
+        if(sc.hasOwn(this.relationsLoader.relationMappings, key) && sc.isObject(filter)){
+            let mapping = this.relationsLoader.relationMappings[key];
+            expressions.push(builder(mapping.from, 'in', this.relationSubQuery(builder, mapping, filter)));
+            return expressions;
+        }
+        if(null === filter){
+            expressions.push(builder(key, 'is', null));
+            return expressions;
+        }
+        expressions.push(builder(key, '=', filter));
+        return expressions;
+    }
+
+    appendGroupExpression(builder, expressions, key, conditions)
+    {
+        let nested = [];
+        for(let condition of conditions){
+            let expression = this.filtersExpression(builder, condition);
+            if(expression){
+                nested.push(expression);
+            }
+        }
+        if(0 === nested.length){
+            return expressions;
+        }
+        expressions.push('AND' === key ? builder.and(nested) : builder.or(nested));
+        return expressions;
+    }
+
+    appendOrValueExpression(builder, expressions, key, filter)
+    {
+        let orExpression = builder(key, '=', filter.value);
+        if(0 === expressions.length){
+            return [orExpression];
+        }
+        return [builder.or([builder.and(expressions), orExpression])];
+    }
+
+    operatorExpression(builder, field, operator, filter)
+    {
+        if('IN' === operator){
+            return builder(field, 'in', filter.value);
+        }
+        if('NOT' === operator){
+            return builder.not(builder(field, '=', filter.value));
+        }
+        if('LIKE' === operator){
+            return this.likeExpression(builder, field, filter.value);
+        }
+        return builder(field, sc.get(this.operatorsMap, operator, filter.operator), filter.value);
+    }
+
+    likeExpression(builder, field, value)
+    {
+        let likeValue = '%'+String(value).replace(/%/g, '')+'%';
+        if(this.isJsonField(field)){
+            return builder(builder.cast(field, 'char'), 'like', likeValue);
+        }
+        return builder(field, 'like', likeValue);
+    }
+
+    relationSubQuery(builder, mapping, nestedFilters)
+    {
+        let subQuery = builder.selectFrom(mapping.tableName).select(mapping.to);
+        let relatedDriver = this.relationsLoader.relatedDriver(mapping);
+        if(!relatedDriver){
+            return subQuery;
+        }
+        let expression = relatedDriver.filtersExpression(builder, nestedFilters);
+        if(!expression){
+            return subQuery;
+        }
+        return subQuery.where(expression);
+    }
+
+}
+
+module.exports.KyselyDriver = KyselyDriver;

package/lib/kysely/kysely-modules-loader.js

@@ -0,0 +1,28 @@
+/**
+ *
+ * Reldens - Storage - KyselyModulesLoader
+ *
+ */
+
+const { KyselyModulesValidator } = require('./kysely-modules-validator');
+const { PackageResolver } = require('../package-resolver');
+
+class KyselyModulesLoader
+{
+
+    static load(projectPath)
+    {
+        let kysely = PackageResolver.loadPackage('kysely', projectPath);
+        if(!kysely){
+            return false;
+        }
+        let kyselyModules = {Kysely: kysely.Kysely, MysqlDialect: kysely.MysqlDialect, sql: kysely.sql};
+        if(!KyselyModulesValidator.validate(kyselyModules)){
+            return false;
+        }
+        return kyselyModules;
+    }
+
+}
+
+module.exports.KyselyModulesLoader = KyselyModulesLoader;

package/lib/kysely/kysely-modules-validator.js

@@ -0,0 +1,53 @@
+/**
+ *
+ * Reldens - KyselyModulesValidator
+ *
+ */
+
+const { Logger, sc } = require('@reldens/utils');
+
+class KyselyModulesValidator
+{
+
+    static validate(kyselyModules)
+    {
+        if(!sc.isObject(kyselyModules)){
+            Logger.critical('Missing "kyselyModules" object.');
+            return false;
+        }
+        if(!sc.isFunction(kyselyModules.sql)){
+            Logger.critical('Invalid "kyselyModules.sql".');
+            return false;
+        }
+        if(!sc.isFunction(kyselyModules.sql.raw)){
+            Logger.critical('Invalid "kyselyModules.sql", "raw" not found.');
+            return false;
+        }
+        if(kyselyModules.db){
+            return KyselyModulesValidator.validateDbInstance(kyselyModules.db);
+        }
+        if(!sc.isFunction(kyselyModules.Kysely)){
+            Logger.critical('Invalid "kyselyModules.Kysely".');
+            return false;
+        }
+        if(!sc.isFunction(kyselyModules.MysqlDialect)){
+            Logger.critical('Invalid "kyselyModules.MysqlDialect".');
+            return false;
+        }
+        return true;
+    }
+
+    static validateDbInstance(db)
+    {
+        let requiredMethods = ['selectFrom', 'insertInto', 'updateTable', 'deleteFrom', 'destroy'];
+        let missingMethods = requiredMethods.filter(method => !sc.isFunction(db[method]));
+        if(0 < missingMethods.length){
+            Logger.critical('Invalid Kysely instance, missing: '+missingMethods.join(', '));
+            return false;
+        }
+        return true;
+    }
+
+}
+
+module.exports.KyselyModulesValidator = KyselyModulesValidator;

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

@@ -7,46 +7,49 @@
 const { MikroOrmDriver } = require('./mikro-orm-driver');
 const { BaseDataServer } = require('../base-data-server');
 const { MySQLTablesProvider } = require('../mysql-tables-provider');
-const { MikroORM } = require('@mikro-orm/core');
-const { MySqlDriver } = require('@mikro-orm/mysql');
-const { MongoDriver } = require('@mikro-orm/mongodb');
+const { MikroOrmModulesValidator } = require('./mikro-orm-modules-validator');
+const { MikroOrmModulesLoader } = require('./mikro-orm-modules-loader');
 const { Logger, sc } = require('@reldens/utils');
 
 class MikroOrmDataServer extends BaseDataServer
 {
 
     orm = {};
-    clientsMapped = {
-        mysql: MySqlDriver,
-        mongodb: MongoDriver
-    };
+    mysqlClients = ['mysql', 'mysql2'];
 
     constructor(props)
     {
         super(props);
         this.entitiesPath = props.entitiesPath;
         this.warnWhenNoEntities = Boolean(props.warnWhenNoEntities);
+        this.mikroOrmModules = sc.get(props, 'mikroOrmModules', false);
+    }
+
+    clientDriver()
+    {
+        if('mongodb' === this.client){
+            return this.mikroOrmModules.MongoDriver;
+        }
+        return this.mikroOrmModules.MySqlDriver;
     }
 
     getEntitiesToRegister()
     {
         if(this.entitiesPath){
-            //Logger.debug('MikroORM using entitiesPath');
             return this.entitiesPath;
         }
         if(0 < Object.keys(this.entities).length){
-            //Logger.debug('MikroORM using this.entities: '+Object.keys(this.entities).join(', '));
             return this.entities;
         }
         if(!this.rawEntities){
-            //Logger.debug('MikroORM has no entities!');
             return [];
         }
-        let entities = Object.values(this.rawEntities);
-        //Logger.debug('MikroORM extracting from rawEntities, count: '+entities.length);
-        return entities.map(rawEntity => {
-            return (rawEntity && rawEntity.schema) ? rawEntity.schema : rawEntity;
-        });
+        let entities = [];
+        for(let i of Object.keys(this.rawEntities)){
+            let rawEntity = this.rawEntities[i];
+            entities.push((rawEntity && rawEntity.schema) ? rawEntity.schema : rawEntity);
+        }
+        return entities;
     }
 
     async connect()
@@ -54,16 +57,29 @@ class MikroOrmDataServer extends BaseDataServer
         if(this.initialized){
             return this.initialized;
         }
+        if(!this.client){
+            this.client = 'mongodb';
+        }
+        if(!this.mikroOrmModules){
+            this.mikroOrmModules = MikroOrmModulesLoader.load(this.projectRoot, this.client);
+        }
+        if(!MikroOrmModulesValidator.validate(this.mikroOrmModules, this.client)){
+            return false;
+        }
         let providedSetup = {
-            driver: this.clientsMapped[(this.client || 'mongodb')],
+            driver: this.clientDriver(),
             dbName: this.config.database,
             clientUrl: this.connectString,
             allowGlobalContext: true,
-            multipleStatements: this.multipleStatements
+            multipleStatements: this.multipleStatements,
+            namingStrategy: this.mikroOrmModules.EntityCaseNamingStrategy
         };
+        if(0 < Object.keys(this.poolConfig).length){
+            providedSetup.pool = this.poolConfig;
+        }
         providedSetup.entities = this.getEntitiesToRegister();
         providedSetup.discovery = {warnWhenNoEntities: this.warnWhenNoEntities};
-        this.orm = await MikroORM.init(providedSetup);
+        this.orm = await this.mikroOrmModules.MikroORM.init(providedSetup);
         this.initialized = Date.now();
         return this.initialized;
     }
@@ -97,7 +113,8 @@ class MikroOrmDataServer extends BaseDataServer
                 name: i,
                 config: { dbName: this.orm.config.get('dbName') },
                 orm: this.orm,
-                server: this
+                server: this,
+                mikroOrmModules: this.mikroOrmModules
             });
         }
         this.entityManager.setEntities(this.entities);
@@ -137,19 +154,11 @@ class MikroOrmDataServer extends BaseDataServer
             return false;
         }
         try {
-            if('mysql' === this.client){
+            if(-1 !== this.mysqlClients.indexOf(this.client)){
                 return await MySQLTablesProvider.fetchTables(this);
             }
             if('mongodb' === this.client){
-                let tables = {};
-                let collections = await this.orm.em.getDriver().getConnection().db().listCollections().toArray();
-                for(let collection of collections){
-                    tables[collection.name] = {
-                        name: collection.name,
-                        columns: {}
-                    };
-                }
-                return tables;
+                return await this.fetchMongoCollections();
             }
             Logger.critical('Unsupported client type: '+this.client);
         } catch(error) {
@@ -158,6 +167,16 @@ class MikroOrmDataServer extends BaseDataServer
         return false;
     }
 
+    async fetchMongoCollections()
+    {
+        let tables = {};
+        let collections = await this.orm.em.getDriver().getConnection().db().listCollections().toArray();
+        for(let collection of collections){
+            tables[collection.name] = {name: collection.name, columns: {}};
+        }
+        return tables;
+    }
+
 }
 
 module.exports.MikroOrmDataServer = MikroOrmDataServer;