@reldens/storage 0.117.0 → 0.119.0

package/lib/generators/relations-detection.js

@@ -0,0 +1,171 @@
+/**
+ *
+ * Reldens - RelationsDetection
+ *
+ */
+
+const { RELATION_PREFIX } = require('../relation-key');
+const { sc } = require('@reldens/utils');
+
+class RelationsDetection
+{
+
+    constructor(props)
+    {
+        this.allTablesData = {};
+        this.removeIdFromMultipleRelations = sc.get(props, 'removeIdFromMultipleRelations', true);
+    }
+
+    detectForwardRelations(tableName, tableData)
+    {
+        let relations = {};
+        let referenceCounts = this.countReferencesPerTable(tableData);
+        for(let columnName of Object.keys(tableData.columns)){
+            let column = tableData.columns[columnName];
+            if(!sc.hasOwn(column, 'referencedTable')){
+                continue;
+            }
+            let relationKey = this.generateForwardRelationKey(column.referencedTable, columnName, referenceCounts);
+            relations[relationKey] = {
+                fromColumn: columnName,
+                toColumn: column.referencedColumn,
+                referencedTable: column.referencedTable,
+                relationType: this.determineRelationType(column, true)
+            };
+        }
+        return relations;
+    }
+
+    detectReverseRelations(tableName)
+    {
+        let reverseRelations = {};
+        for(let otherTableName of Object.keys(this.allTablesData)){
+            if(otherTableName === tableName){
+                continue;
+            }
+            Object.assign(reverseRelations, this.detectTableReverseRelations(tableName, otherTableName));
+        }
+        return reverseRelations;
+    }
+
+    detectTableReverseRelations(tableName, otherTableName)
+    {
+        let reverseRelations = {};
+        let otherTableData = this.allTablesData[otherTableName];
+        let referenceCounts = this.countReferencesToTable(tableName, otherTableData);
+        for(let columnName of Object.keys(otherTableData.columns)){
+            let column = otherTableData.columns[columnName];
+            if(!sc.hasOwn(column, 'referencedTable')){
+                continue;
+            }
+            if(column.referencedTable !== tableName){
+                continue;
+            }
+            let relationKey = this.generateReverseRelationKey(otherTableName, columnName, referenceCounts);
+            reverseRelations[relationKey] = {
+                fromColumn: column.referencedColumn,
+                toColumn: columnName,
+                referencingTable: otherTableName,
+                relationType: this.determineRelationType(column, false)
+            };
+        }
+        return reverseRelations;
+    }
+
+    determineRelationType(column, isForwardRelation)
+    {
+        if(isForwardRelation){
+            return 'BelongsToOneRelation';
+        }
+        if('PRI' === column.key || 'UNI' === column.key){
+            return 'HasOneRelation';
+        }
+        return 'HasManyRelation';
+    }
+
+    countReferencesPerTable(tableData)
+    {
+        let counts = {};
+        for(let columnName of Object.keys(tableData.columns)){
+            let column = tableData.columns[columnName];
+            if(!sc.hasOwn(column, 'referencedTable')){
+                continue;
+            }
+            if(!counts[column.referencedTable]){
+                counts[column.referencedTable] = 0;
+            }
+            counts[column.referencedTable]++;
+        }
+        return counts;
+    }
+
+    countReferencesToTable(targetTable, sourceTableData)
+    {
+        let count = 0;
+        for(let columnName of Object.keys(sourceTableData.columns)){
+            let column = sourceTableData.columns[columnName];
+            if(!sc.hasOwn(column, 'referencedTable')){
+                continue;
+            }
+            if(column.referencedTable === targetTable){
+                count++;
+            }
+        }
+        return count;
+    }
+
+    generateForwardRelationKey(referencedTable, columnName, referenceCounts)
+    {
+        if(1 === referenceCounts[referencedTable]){
+            return RELATION_PREFIX+referencedTable;
+        }
+        return RELATION_PREFIX+referencedTable+'_'+this.relationKeyColumnSuffix(columnName);
+    }
+
+    generateReverseRelationKey(referencingTable, columnName, referenceCount)
+    {
+        if(1 === referenceCount){
+            return RELATION_PREFIX+referencingTable;
+        }
+        return RELATION_PREFIX+referencingTable+'_'+this.relationKeyColumnSuffix(columnName);
+    }
+
+    relationKeyColumnSuffix(columnName)
+    {
+        if(this.removeIdFromMultipleRelations){
+            return columnName.replace(/_id$/i, '');
+        }
+        return columnName;
+    }
+
+    findMappedByKey(currentTable, referencingTable, reverseRelation)
+    {
+        if(!this.allTablesData[referencingTable]){
+            return RELATION_PREFIX+currentTable;
+        }
+        let forwardRelations = this.detectForwardRelations(referencingTable, this.allTablesData[referencingTable]);
+        for(let forwardKey of Object.keys(forwardRelations)){
+            let forward = forwardRelations[forwardKey];
+            if(forward.referencedTable !== currentTable){
+                continue;
+            }
+            if(forward.fromColumn === reverseRelation.toColumn && forward.toColumn === reverseRelation.fromColumn){
+                return forwardKey;
+            }
+        }
+        return RELATION_PREFIX+currentTable;
+    }
+
+    detectPrimaryKeyColumn(columns)
+    {
+        for(let columnName of Object.keys(columns)){
+            if('PRI' === columns[columnName].key){
+                return columnName;
+            }
+        }
+        return null;
+    }
+
+}
+
+module.exports.RelationsDetection = RelationsDetection;

package/lib/knex/knex-data-server.js

@@ -0,0 +1,128 @@
+/**
+ *
+ * Reldens - KnexDataServer
+ *
+ */
+
+const { BaseDataServer } = require('../base-data-server');
+const { KnexDriver } = require('./knex-driver');
+const { MySQLTablesProvider } = require('../mysql-tables-provider');
+const { Mysql2ConnectionConfig } = require('../mysql2-connection-config');
+const { KnexModulesValidator } = require('./knex-modules-validator');
+const { KnexModulesLoader } = require('./knex-modules-loader');
+const { Logger, sc } = require('@reldens/utils');
+
+class KnexDataServer extends BaseDataServer
+{
+
+    constructor(props)
+    {
+        super(props);
+        this.knexModules = sc.get(props, 'knexModules', false);
+        this.knex = sc.get(this.knexModules, 'knex', false);
+    }
+
+    async connect()
+    {
+        if(this.initialized){
+            return this.initialized;
+        }
+        if(!this.knexModules){
+            this.knexModules = KnexModulesLoader.load(this.projectRoot);
+        }
+        if(!KnexModulesValidator.validate(this.knexModules)){
+            return false;
+        }
+        if(!this.knex){
+            this.knex = await this.knexModules.Knex({
+                client: this.client,
+                connection: this.sanitizeConnectionConfig(this.config),
+                pool: this.poolConfig,
+                debug: this.debug,
+                multipleStatements: this.multipleStatements
+            });
+            this.knexModules.knex = this.knex;
+        }
+        try {
+            const [[{ currentTime }]] = await this.knex.raw(
+                'SELECT ROUND(UNIX_TIMESTAMP(NOW(6)) * 1000 + MICROSECOND(NOW(6)) / 1000) AS currentTime;'
+            );
+            this.initialized = currentTime;
+        } catch(error) {
+            Logger.critical(this.connectionErrorMessage(), error);
+        }
+        return this.initialized;
+    }
+
+    connectionErrorMessage()
+    {
+        return 'Connection failed, Knex error.';
+    }
+
+    sanitizeConnectionConfig(config)
+    {
+        if('mysql2' !== this.client){
+            return config;
+        }
+        return Mysql2ConnectionConfig.sanitize(config);
+    }
+
+    async disconnect()
+    {
+        if(!this.knex){
+            return false;
+        }
+        await this.knex.destroy();
+        this.knex = false;
+        this.initialized = false;
+        return true;
+    }
+
+    generateEntities()
+    {
+        if(!this.rawEntities){
+            Logger.warning('Empty raw entities array, none entities generated.');
+            return {};
+        }
+        this.entities = {};
+        for(let i of Object.keys(this.rawEntities)){
+            let rawEntity = this.rawEntities[i];
+            if(!sc.isString(sc.get(rawEntity, 'tableName', false))){
+                Logger.critical('Invalid raw entity "'+i+'".');
+                continue;
+            }
+            this.entities[i] = new KnexDriver({
+                rawModel: rawEntity,
+                id: i,
+                name: i,
+                config: this.config,
+                server: this,
+                knex: this.knex
+            });
+        }
+        this.entityManager.setEntities(this.entities);
+        return this.entities;
+    }
+
+    name()
+    {
+        return this.name || 'Knex Data Server Driver';
+    }
+
+    async rawQuery(content)
+    {
+        return (await this.knex.raw(content)).shift() || false;
+    }
+
+    async fetchEntitiesFromDatabase()
+    {
+        if(!this.initialized){
+            Logger.error('Connection was not initialized, please use the connect method first.');
+            return false;
+        }
+        return await MySQLTablesProvider.fetchTables(this);
+    }
+
+}
+
+module.exports.KnexDataServer = KnexDataServer;

package/lib/knex/knex-driver.js

@@ -0,0 +1,157 @@
+/**
+ *
+ * Reldens - KnexDriver
+ *
+ */
+
+const { QueryBuilderDriver } = require('../query-builder-driver');
+const { sc } = require('@reldens/utils');
+
+class KnexDriver extends QueryBuilderDriver
+{
+
+    constructor(props)
+    {
+        super(props);
+        this.knex = sc.get(props, 'knex', false);
+    }
+
+    queryBuilder()
+    {
+        return this.knex(this.tableName());
+    }
+
+    async insertRow(data)
+    {
+        return (await this.queryBuilder().insert(data)).shift() || 0;
+    }
+
+    selectRows(filters, options)
+    {
+        let query = this.queryBuilder();
+        this.appendFilters(query, filters);
+        if(0 < options.select.length){
+            query.select(...options.select);
+        }
+        if(0 < options.limit){
+            query.limit(options.limit);
+        }
+        if(0 < options.offset){
+            query.offset(options.offset);
+        }
+        if(options.sortBy && options.sortDirection){
+            query.orderBy(options.sortBy, options.sortDirection);
+        }
+        return query;
+    }
+
+    update(filters, updatePatch)
+    {
+        return this.appendFilters(this.queryBuilder(), filters).update(updatePatch);
+    }
+
+    delete(filters = {})
+    {
+        return this.appendFilters(this.queryBuilder(), filters).delete();
+    }
+
+    async count(filters = {})
+    {
+        let result = await this.appendFilters(this.queryBuilder(), filters).count('* as count').first();
+        if(!result){
+            return 0;
+        }
+        return Number(result.count);
+    }
+
+    appendFilters(query, filters = {})
+    {
+        for(let key of Object.keys(filters)){
+            this.appendFilter(query, key, filters[key]);
+        }
+        return query;
+    }
+
+    appendFilter(query, key, filter)
+    {
+        if('AND' === key && sc.isArray(filter)){
+            this.appendAndConditions(query, filter);
+            return;
+        }
+        if('OR' === key && sc.isArray(filter)){
+            this.appendOrConditions(query, filter);
+            return;
+        }
+        let operator = sc.get(filter, 'operator', '').toUpperCase();
+        if(operator){
+            this.appendOperatorFilter(query, key, operator, filter);
+            return;
+        }
+        if(sc.hasOwn(this.relationsLoader.relationMappings, key) && sc.isObject(filter)){
+            let mapping = this.relationsLoader.relationMappings[key];
+            query.whereIn(mapping.from, this.relationSubQuery(mapping, filter));
+            return;
+        }
+        query.where(key, filter);
+    }
+
+    appendAndConditions(query, conditions)
+    {
+        for(let condition of conditions){
+            query.where(nestedQuery => this.appendFilters(nestedQuery, condition));
+        }
+    }
+
+    appendOrConditions(query, conditions)
+    {
+        query.where(outerQuery => {
+            for(let condition of conditions){
+                outerQuery.orWhere(innerQuery => this.appendFilters(innerQuery, condition));
+            }
+        });
+    }
+
+    appendOperatorFilter(query, field, operator, filter)
+    {
+        if('OR' === operator){
+            query.orWhere(field, filter.value);
+            return;
+        }
+        if('IN' === operator){
+            query.whereIn(field, filter.value);
+            return;
+        }
+        if('NOT' === operator){
+            query.whereNot(field, filter.value);
+            return;
+        }
+        if('LIKE' === operator){
+            this.appendLikeFilter(query, field, filter.value);
+            return;
+        }
+        query.where(field, sc.get(this.operatorsMap, operator, filter.operator), filter.value);
+    }
+
+    appendLikeFilter(query, field, value)
+    {
+        let likeValue = '%'+String(value).replace(/%/g, '')+'%';
+        if(this.isJsonField(field)){
+            query.whereRaw('CAST(?? AS CHAR) LIKE ?', [field, likeValue]);
+            return;
+        }
+        query.where(field, 'like', likeValue);
+    }
+
+    relationSubQuery(mapping, nestedFilters)
+    {
+        let subQuery = this.knex(mapping.tableName).select(mapping.to);
+        let relatedDriver = this.relationsLoader.relatedDriver(mapping);
+        if(!relatedDriver){
+            return subQuery;
+        }
+        return relatedDriver.appendFilters(subQuery, nestedFilters);
+    }
+
+}
+
+module.exports.KnexDriver = KnexDriver;

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

@@ -0,0 +1,28 @@
+/**
+ *
+ * Reldens - Storage - KnexModulesLoader
+ *
+ */
+
+const { KnexModulesValidator } = require('./knex-modules-validator');
+const { PackageResolver } = require('../package-resolver');
+
+class KnexModulesLoader
+{
+
+    static load(projectPath)
+    {
+        let knex = PackageResolver.loadPackage('knex', projectPath);
+        if(!knex){
+            return false;
+        }
+        let knexModules = {Knex: knex};
+        if(!KnexModulesValidator.validate(knexModules)){
+            return false;
+        }
+        return knexModules;
+    }
+
+}
+
+module.exports.KnexModulesLoader = KnexModulesLoader;

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

@@ -0,0 +1,45 @@
+/**
+ *
+ * Reldens - KnexModulesValidator
+ *
+ */
+
+const { Logger, sc } = require('@reldens/utils');
+
+class KnexModulesValidator
+{
+
+    static validate(knexModules)
+    {
+        if(!sc.isObject(knexModules)){
+            Logger.critical('Missing "knexModules" object.');
+            return false;
+        }
+        if(knexModules.knex){
+            return KnexModulesValidator.validateKnexInstance(knexModules.knex);
+        }
+        if(!sc.isFunction(knexModules.Knex)){
+            Logger.critical('Invalid "knexModules.Knex".');
+            return false;
+        }
+        return true;
+    }
+
+    static validateKnexInstance(knexInstance)
+    {
+        if(!sc.isFunction(knexInstance)){
+            Logger.critical('Invalid Knex instance, it must be callable.');
+            return false;
+        }
+        let requiredMethods = ['raw', 'destroy'];
+        let missingMethods = requiredMethods.filter(method => !sc.isFunction(knexInstance[method]));
+        if(0 < missingMethods.length){
+            Logger.critical('Invalid Knex instance, missing: '+missingMethods.join(', '));
+            return false;
+        }
+        return true;
+    }
+
+}
+
+module.exports.KnexModulesValidator = KnexModulesValidator;

package/lib/kysely/kysely-data-server.js

@@ -0,0 +1,128 @@
+/**
+ *
+ * Reldens - KyselyDataServer
+ *
+ */
+
+const { BaseDataServer } = require('../base-data-server');
+const { KyselyDriver } = require('./kysely-driver');
+const { KyselyModulesValidator } = require('./kysely-modules-validator');
+const { MySQLTablesProvider } = require('../mysql-tables-provider');
+const { Mysql2ConnectionConfig } = require('../mysql2-connection-config');
+const { createPool } = require('mysql2');
+const { Logger, sc } = require('@reldens/utils');
+
+class KyselyDataServer extends BaseDataServer
+{
+
+    constructor(props)
+    {
+        super(props);
+        this.kyselyModules = sc.get(props, 'kyselyModules', false);
+        this.db = sc.get(this.kyselyModules, 'db', false);
+    }
+
+    async connect()
+    {
+        if(this.initialized){
+            return this.initialized;
+        }
+        if(!KyselyModulesValidator.validate(this.kyselyModules)){
+            return false;
+        }
+        try {
+            if(!this.db){
+                this.db = new this.kyselyModules.Kysely({
+                    dialect: new this.kyselyModules.MysqlDialect({pool: createPool(this.poolConfiguration())})
+                });
+                this.kyselyModules.db = this.db;
+            }
+            await this.kyselyModules.sql.raw('SELECT 1').execute(this.db);
+            this.initialized = Date.now();
+        } catch(error) {
+            Logger.critical('Connection failed, Kysely error: '+error.message);
+        }
+        return this.initialized;
+    }
+
+    poolConfiguration()
+    {
+        let poolConfiguration = Mysql2ConnectionConfig.sanitize(this.config);
+        if(this.multipleStatements){
+            poolConfiguration.multipleStatements = true;
+        }
+        return poolConfiguration;
+    }
+
+    async disconnect()
+    {
+        if(!this.db){
+            return false;
+        }
+        await this.db.destroy();
+        this.db = false;
+        this.initialized = false;
+        return true;
+    }
+
+    generateEntities()
+    {
+        if(!this.rawEntities){
+            Logger.warning('Empty raw entities array, none entities generated.');
+            return {};
+        }
+        this.entities = {};
+        for(let i of Object.keys(this.rawEntities)){
+            let rawEntity = this.rawEntities[i];
+            if(!sc.isString(sc.get(rawEntity, 'tableName', false))){
+                Logger.critical('Invalid raw entity "'+i+'".');
+                continue;
+            }
+            this.entities[i] = new KyselyDriver({
+                rawModel: rawEntity,
+                id: i,
+                name: i,
+                config: this.config,
+                server: this,
+                db: this.db,
+                sql: this.kyselyModules.sql
+            });
+        }
+        this.entityManager.setEntities(this.entities);
+        return this.entities;
+    }
+
+    name()
+    {
+        return this.name || 'Kysely Data Server Driver';
+    }
+
+    async rawQuery(content)
+    {
+        let result = await this.kyselyModules.sql.raw(content).execute(this.db);
+        if(!sc.hasOwn(result, 'numAffectedRows')){
+            return result.rows;
+        }
+        return {
+            affectedRows: Number(sc.get(result, 'numAffectedRows', 0)),
+            insertId: Number(sc.get(result, 'insertId', 0))
+        };
+    }
+
+    async fetchEntitiesFromDatabase()
+    {
+        if(!this.initialized){
+            Logger.critical('Connection was not initialized, please use the connect method first.');
+            return false;
+        }
+        try {
+            return await MySQLTablesProvider.fetchTables(this);
+        } catch(error) {
+            Logger.critical('Kysely Data Server tables fetch failed. '+error.message);
+            return false;
+        }
+    }
+
+}
+
+module.exports.KyselyDataServer = KyselyDataServer;