@reldens/storage 0.117.0 → 0.119.0

package/bin/reldens-storage.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 
 /**
  *
@@ -8,6 +8,11 @@
 
 const { EntitiesGenerator } = require('../lib/entities-generator');
 const { PrismaClientLoader } = require('../lib/prisma/prisma-client-loader');
+const { KyselyModulesLoader } = require('../lib/kysely/kysely-modules-loader');
+const { DrizzleModulesLoader } = require('../lib/drizzle/drizzle-modules-loader');
+const { MikroOrmModulesLoader } = require('../lib/mikro-orm/mikro-orm-modules-loader');
+const { ObjectionModulesLoader } = require('../lib/objection-js/objection-modules-loader');
+const { KnexModulesLoader } = require('../lib/knex/knex-modules-loader');
 const { FileHandler } = require('@reldens/server-utils');
 const { Logger, sc } = require('@reldens/utils');
 
@@ -65,7 +70,7 @@ class StorageEntitiesGenerator
                 continue;
             }
             if('port' === key){
-                this.config[key] = parseInt(value);
+                this.config[key] = Number(value);
                 continue;
             }
             this.config[key] = value;
@@ -75,7 +80,7 @@ class StorageEntitiesGenerator
     getConnectionData()
     {
         let connectionData = {
-            driver: sc.get(this.config, 'driver', 'objection-js'),
+            driver: sc.get(this.config, 'driver', 'knex'),
             client: sc.get(this.config, 'client', 'mysql2'),
             user: sc.get(this.config, 'user', ''),
             password: sc.get(this.config, 'password', ''),
@@ -89,6 +94,12 @@ class StorageEntitiesGenerator
         if('prisma' === connectionData.driver && !this.config.client){
             connectionData.client = 'mysql';
         }
+        if('kysely' === connectionData.driver && !this.config.client){
+            connectionData.client = 'mysql';
+        }
+        if('drizzle' === connectionData.driver && !this.config.client){
+            connectionData.client = 'mysql';
+        }
         return connectionData;
     }
 
@@ -110,7 +121,7 @@ class StorageEntitiesGenerator
                 +' --pass=[db-password]'
                 +' --host=[db-host]'
                 +' --database=[db-name]'
-                +' --driver=[driver-map-key]'
+                +' --driver=[knex|kysely|drizzle|objection-js|mikro-orm|prisma] (default: knex)'
                 +' --client=[db-client]'
                 +' --prismaClientPath=[path-to-prisma-client]'
                 +' --prismaAdapter=[prisma-adapter-package-or-path]'
@@ -154,6 +165,32 @@ class StorageEntitiesGenerator
         return loadedModules;
     }
 
+    appendDriverModules(generatorProps, connectionData)
+    {
+        if('prisma' === connectionData.driver){
+            generatorProps.prismaModules = this.loadPrismaModules(connectionData);
+            return Boolean(generatorProps.prismaModules);
+        }
+        if('kysely' === connectionData.driver){
+            generatorProps.kyselyModules = KyselyModulesLoader.load(this.projectPath);
+            return Boolean(generatorProps.kyselyModules);
+        }
+        if('drizzle' === connectionData.driver){
+            generatorProps.drizzleModules = DrizzleModulesLoader.load(this.projectPath);
+            return Boolean(generatorProps.drizzleModules);
+        }
+        if('mikro-orm' === connectionData.driver){
+            generatorProps.mikroOrmModules = MikroOrmModulesLoader.load(this.projectPath, connectionData.client);
+            return Boolean(generatorProps.mikroOrmModules);
+        }
+        if('objection-js' === connectionData.driver){
+            generatorProps.objectionModules = ObjectionModulesLoader.load(this.projectPath);
+            return Boolean(generatorProps.objectionModules);
+        }
+        generatorProps.knexModules = KnexModulesLoader.load(this.projectPath);
+        return Boolean(generatorProps.knexModules);
+    }
+
     async run()
     {
         if(!this.validateCommand()){
@@ -168,12 +205,8 @@ class StorageEntitiesGenerator
             projectPath: this.projectPath,
             isOverride: this.isOverride
         };
-        if('prisma' === connectionData.driver){
-            let prismaModules = this.loadPrismaModules(connectionData);
-            if(!prismaModules){
-                return false;
-            }
-            generatorProps.prismaModules = prismaModules;
+        if(!this.appendDriverModules(generatorProps, connectionData)){
+            return false;
         }
         let generator = new EntitiesGenerator(generatorProps);
         let success = await generator.generate();

package/index.js

@@ -8,10 +8,13 @@ const { BaseDataServer } = require('./lib/base-data-server');
 const { BaseDriver } = require('./lib/base-driver');
 const { ObjectionJsDriver } = require('./lib/objection-js/objection-js-driver');
 const { ObjectionJsDataServer } = require('./lib/objection-js/objection-js-data-server');
-const { Model } = require('objection');
+const { ObjectionModulesValidator } = require('./lib/objection-js/objection-modules-validator');
+const { ObjectionModulesLoader } = require('./lib/objection-js/objection-modules-loader');
 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');
+const { MikroOrmModulesValidator } = require('./lib/mikro-orm/mikro-orm-modules-validator');
+const { MikroOrmModulesLoader } = require('./lib/mikro-orm/mikro-orm-modules-loader');
+const { PackageResolver } = require('./lib/package-resolver');
 const { EntitiesGenerator } = require('./lib/entities-generator');
 const { EntityProperties } = require('./lib/entity-properties');
 const { TypeMapper } = require('./lib/type-mapper');
@@ -21,41 +24,79 @@ const { PrismaDataServer } = require('./lib/prisma/prisma-data-server');
 const { PrismaSchemaGenerator } = require('./lib/prisma/prisma-schema-generator');
 const { PrismaClientLoader } = require('./lib/prisma/prisma-client-loader');
 const { PrismaModulesValidator } = require('./lib/prisma/prisma-modules-validator');
+const { QueryBuilderDriver } = require('./lib/query-builder-driver');
+const { RelationsLoader } = require('./lib/relations-loader');
+const { Mysql2ConnectionConfig } = require('./lib/mysql2-connection-config');
+const { KnexDriver } = require('./lib/knex/knex-driver');
+const { KnexDataServer } = require('./lib/knex/knex-data-server');
+const { KnexModulesValidator } = require('./lib/knex/knex-modules-validator');
+const { KnexModulesLoader } = require('./lib/knex/knex-modules-loader');
+const { KyselyDriver } = require('./lib/kysely/kysely-driver');
+const { KyselyDataServer } = require('./lib/kysely/kysely-data-server');
+const { KyselyModulesValidator } = require('./lib/kysely/kysely-modules-validator');
+const { KyselyModulesLoader } = require('./lib/kysely/kysely-modules-loader');
+const { DrizzleDriver } = require('./lib/drizzle/drizzle-driver');
+const { DrizzleDataServer } = require('./lib/drizzle/drizzle-data-server');
+const { DrizzleModulesValidator } = require('./lib/drizzle/drizzle-modules-validator');
+const { DrizzleModulesLoader } = require('./lib/drizzle/drizzle-modules-loader');
 const { RELATION_PREFIX } = require('./lib/relation-key');
 
+let objectionPackage = PackageResolver.optionalPackage('objection');
+let mikroOrmCorePackage = PackageResolver.optionalPackage('@mikro-orm/core');
+
 module.exports = {
-    // base:
     BaseDataServer,
     BaseDriver,
     DriversMap: {
         'objection-js': ObjectionJsDataServer,
         'mikro-orm': MikroOrmDataServer,
-        'prisma': PrismaDataServer
+        'prisma': PrismaDataServer,
+        'knex': KnexDataServer,
+        'kysely': KyselyDataServer,
+        'drizzle': DrizzleDataServer
     },
     DriversClassMap: {
         'ObjectionJsDataServer': 'objection-js',
         'MikroOrmDataServer': 'mikro-orm',
-        'PrismaDataServer': 'prisma'
+        'PrismaDataServer': 'prisma',
+        'KnexDataServer': 'knex',
+        'KyselyDataServer': 'kysely',
+        'DrizzleDataServer': 'drizzle'
     },
-    // objection-js:
+    QueryBuilderDriver,
+    RelationsLoader,
+    Mysql2ConnectionConfig,
+    KnexDataServer,
+    KnexDriver,
+    KyselyDataServer,
+    KyselyDriver,
+    KyselyModulesValidator,
+    KyselyModulesLoader,
+    DrizzleDataServer,
+    DrizzleDriver,
+    DrizzleModulesValidator,
+    DrizzleModulesLoader,
     ObjectionJsDataServer,
     ObjectionJsDriver,
-    ObjectionJsRawModel: Model,
-    // mikro-orm:
-    MikroOrmCore,
+    ObjectionModulesValidator,
+    ObjectionModulesLoader,
+    ObjectionJsRawModel: objectionPackage ? objectionPackage.Model : false,
+    MikroOrmCore: mikroOrmCorePackage,
     MikroOrmDataServer,
     MikroOrmDriver,
-    // prisma:
+    MikroOrmModulesValidator,
+    MikroOrmModulesLoader,
+    PackageResolver,
+    KnexModulesValidator,
+    KnexModulesLoader,
     PrismaDataServer,
     PrismaDriver,
     PrismaSchemaGenerator,
     PrismaClientLoader,
     PrismaModulesValidator,
-    // entities:
     EntitiesGenerator,
     EntityProperties,
     TypeMapper,
     MySQLTablesProvider,
-    // relation key:
     RELATION_PREFIX
 };

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

@@ -0,0 +1,123 @@
+/**
+ *
+ * Reldens - DrizzleDataServer
+ *
+ */
+
+const { BaseDataServer } = require('../base-data-server');
+const { DrizzleDriver } = require('./drizzle-driver');
+const { DrizzleModulesValidator } = require('./drizzle-modules-validator');
+const { MySQLTablesProvider } = require('../mysql-tables-provider');
+const { Mysql2ConnectionConfig } = require('../mysql2-connection-config');
+const { createPool } = require('mysql2/promise');
+const { Logger, sc } = require('@reldens/utils');
+
+class DrizzleDataServer extends BaseDataServer
+{
+
+    constructor(props)
+    {
+        super(props);
+        this.drizzleModules = sc.get(props, 'drizzleModules', false);
+        this.db = sc.get(this.drizzleModules, 'db', false);
+    }
+
+    async connect()
+    {
+        if(this.initialized){
+            return this.initialized;
+        }
+        if(!DrizzleModulesValidator.validate(this.drizzleModules)){
+            return false;
+        }
+        try {
+            if(!this.db){
+                this.db = this.drizzleModules.drizzle({client: createPool(this.poolConfiguration())});
+                this.drizzleModules.db = this.db;
+            }
+            await this.db.execute(this.drizzleModules.orm.sql.raw('SELECT 1'));
+            this.initialized = Date.now();
+        } catch(error) {
+            Logger.critical('Connection failed, Drizzle 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.$client.end();
+        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;
+            }
+            if(!sc.isObject(sc.get(rawEntity, 'table', false))){
+                Logger.critical('Missing Drizzle table on raw entity "'+i+'".');
+                continue;
+            }
+            this.entities[i] = new DrizzleDriver({
+                rawModel: rawEntity,
+                id: i,
+                name: i,
+                config: this.config,
+                server: this,
+                db: this.db,
+                orm: this.drizzleModules.orm
+            });
+        }
+        this.entityManager.setEntities(this.entities);
+        return this.entities;
+    }
+
+    name()
+    {
+        return this.name || 'Drizzle Data Server Driver';
+    }
+
+    async rawQuery(content)
+    {
+        return (await this.db.execute(this.drizzleModules.orm.sql.raw(content))).shift() || false;
+    }
+
+    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('Drizzle Data Server tables fetch failed. '+error.message);
+            return false;
+        }
+    }
+
+}
+
+module.exports.DrizzleDataServer = DrizzleDataServer;

package/lib/drizzle/drizzle-driver.js

@@ -0,0 +1,228 @@
+/**
+ *
+ * Reldens - DrizzleDriver
+ *
+ */
+
+const { QueryBuilderDriver } = require('../query-builder-driver');
+const { Logger, sc } = require('@reldens/utils');
+
+class DrizzleDriver extends QueryBuilderDriver
+{
+
+    constructor(props)
+    {
+        super(props);
+        this.db = sc.get(props, 'db', false);
+        this.orm = sc.get(props, 'orm', false);
+        this.table = sc.get(this.rawModel, 'table', false);
+        this.comparisonFunctions = {'=': 'eq', '!=': 'ne', '>': 'gt', '>=': 'gte', '<': 'lt', '<=': 'lte'};
+    }
+
+    column(field)
+    {
+        let column = sc.get(this.table, field, false);
+        if(!column){
+            Logger.error('Column "'+field+'" not defined on table "'+this.tableName()+'".');
+        }
+        return column;
+    }
+
+    prepareData(data)
+    {
+        let prepared = Object.assign({}, data);
+        for(let key of Object.keys(prepared)){
+            if(!sc.isString(prepared[key])){
+                continue;
+            }
+            if('json' !== sc.get(this.column(key), 'dataType', '')){
+                continue;
+            }
+            prepared[key] = sc.parseJson(prepared[key]);
+        }
+        return prepared;
+    }
+
+    async insertRow(data)
+    {
+        return Number(sc.get((await this.db.insert(this.table).values(this.prepareData(data))).shift(), 'insertId', 0));
+    }
+
+    selectRows(filters, options)
+    {
+        let query = 0 < options.select.length
+            ? this.db.select(this.selectedColumns(options.select))
+            : this.db.select();
+        query = this.appendCondition(query.from(this.table), 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(this.orderByExpression(options));
+        }
+        return query;
+    }
+
+    orderByExpression(options)
+    {
+        if('DESC' === options.sortDirection.toUpperCase()){
+            return this.orm.desc(this.column(options.sortBy));
+        }
+        return this.orm.asc(this.column(options.sortBy));
+    }
+
+    selectedColumns(select)
+    {
+        let columns = {};
+        for(let field of select){
+            columns[field] = this.column(field);
+        }
+        return columns;
+    }
+
+    appendCondition(query, filters)
+    {
+        let condition = this.filtersCondition(filters);
+        if(!condition){
+            return query;
+        }
+        return query.where(condition);
+    }
+
+    async update(filters, updatePatch)
+    {
+        let query = this.db.update(this.table).set(this.prepareData(updatePatch));
+        return Number(sc.get((await this.appendCondition(query, filters)).shift(), 'affectedRows', 0));
+    }
+
+    async delete(filters = {})
+    {
+        let deleteResult = await this.appendCondition(this.db.delete(this.table), filters);
+        return Number(sc.get(deleteResult.shift(), 'affectedRows', 0));
+    }
+
+    async count(filters = {})
+    {
+        let query = this.db.select({count: this.orm.count()}).from(this.table);
+        let rows = await this.appendCondition(query, filters);
+        let firstRow = rows.shift();
+        if(!firstRow){
+            return 0;
+        }
+        return Number(firstRow.count);
+    }
+
+    filtersCondition(filters = {})
+    {
+        let conditions = [];
+        for(let key of Object.keys(filters)){
+            conditions = this.appendFilterCondition(conditions, key, filters[key]);
+        }
+        if(0 === conditions.length){
+            return null;
+        }
+        return this.orm.and(...conditions);
+    }
+
+    appendFilterCondition(conditions, key, filter)
+    {
+        if(('AND' === key || 'OR' === key) && sc.isArray(filter)){
+            return this.appendGroupCondition(conditions, key, filter);
+        }
+        let operator = sc.get(filter, 'operator', '').toUpperCase();
+        if('OR' === operator){
+            return this.appendOrValueCondition(conditions, key, filter);
+        }
+        if(operator){
+            conditions.push(this.operatorCondition(key, operator, filter));
+            return conditions;
+        }
+        if(sc.hasOwn(this.relationsLoader.relationMappings, key) && sc.isObject(filter)){
+            let mapping = this.relationsLoader.relationMappings[key];
+            conditions.push(this.orm.inArray(this.column(mapping.from), this.relationSubQuery(mapping, filter)));
+            return conditions;
+        }
+        if(null === filter){
+            conditions.push(this.orm.isNull(this.column(key)));
+            return conditions;
+        }
+        conditions.push(this.orm.eq(this.column(key), filter));
+        return conditions;
+    }
+
+    appendGroupCondition(conditions, key, group)
+    {
+        let nested = [];
+        for(let condition of group){
+            let nestedCondition = this.filtersCondition(condition);
+            if(nestedCondition){
+                nested.push(nestedCondition);
+            }
+        }
+        if(0 === nested.length){
+            return conditions;
+        }
+        conditions.push('AND' === key ? this.orm.and(...nested) : this.orm.or(...nested));
+        return conditions;
+    }
+
+    appendOrValueCondition(conditions, key, filter)
+    {
+        let orCondition = this.orm.eq(this.column(key), filter.value);
+        if(0 === conditions.length){
+            return [orCondition];
+        }
+        return [this.orm.or(this.orm.and(...conditions), orCondition)];
+    }
+
+    operatorCondition(field, operator, filter)
+    {
+        let column = this.column(field);
+        if('IN' === operator){
+            return this.orm.inArray(column, filter.value);
+        }
+        if('NOT' === operator){
+            return this.orm.not(this.orm.eq(column, filter.value));
+        }
+        if('LIKE' === operator){
+            return this.likeCondition(column, field, filter.value);
+        }
+        let sqlOperator = sc.get(this.operatorsMap, operator, filter.operator);
+        let comparisonFunction = sc.get(this.comparisonFunctions, sqlOperator, false);
+        if(!comparisonFunction){
+            Logger.error('Unsupported operator "'+filter.operator+'" on Drizzle driver, "=" used instead.');
+            return this.orm.eq(column, filter.value);
+        }
+        return this.orm[comparisonFunction](column, filter.value);
+    }
+
+    likeCondition(column, field, value)
+    {
+        let likeValue = '%'+String(value).replace(/%/g, '')+'%';
+        if(this.isJsonField(field)){
+            let castExpression = 'CAST(`'+this.tableName()+'`.`'+field+'` AS CHAR)';
+            return this.orm.like(this.orm.sql.raw(castExpression), likeValue);
+        }
+        return this.orm.like(column, likeValue);
+    }
+
+    relationSubQuery(mapping, nestedFilters)
+    {
+        let relatedDriver = this.relationsLoader.relatedDriver(mapping);
+        if(!relatedDriver){
+            return [];
+        }
+        let subQuery = this.db.select({value: relatedDriver.column(mapping.to)}).from(relatedDriver.table);
+        let condition = relatedDriver.filtersCondition(nestedFilters);
+        if(!condition){
+            return subQuery;
+        }
+        return subQuery.where(condition);
+    }
+
+}
+
+module.exports.DrizzleDriver = DrizzleDriver;

package/lib/drizzle/drizzle-models-generation.js

@@ -0,0 +1,49 @@
+/**
+ *
+ * Reldens - DrizzleModelsGeneration
+ *
+ */
+
+const { QueryBuilderModelsGeneration } = require('../query-builder-models-generation');
+const { TypeMapper } = require('../type-mapper');
+
+class DrizzleModelsGeneration extends QueryBuilderModelsGeneration
+{
+
+    generateEntityProperties(columns, tableName, tableData)
+    {
+        let columnLines = [];
+        for(let columnName of Object.keys(columns)){
+            columnLines.push(columnName+': '+this.columnBuilder(columns[columnName]));
+        }
+        return columnLines.join(',\n    ');
+    }
+
+    columnBuilder(column)
+    {
+        let builderName = TypeMapper.mapDbTypeToDrizzleBuilder(column.type);
+        let builder = 'DrizzleMysqlCore.'+builderName+'('+this.builderArguments(builderName, column)+')';
+        if('PRI' === column.key){
+            return builder+'.primaryKey()';
+        }
+        return builder;
+    }
+
+    builderArguments(builderName, column)
+    {
+        let builderArguments = '\''+column.name+'\'';
+        if('mysqlEnum' === builderName){
+            return builderArguments+', [\''+this.parseEnumValues(column.columnType).join('\', \'')+'\']';
+        }
+        if('varchar' === builderName || 'char' === builderName || 'varbinary' === builderName){
+            return builderArguments+', {length: '+column.length+'}';
+        }
+        if('bigint' === builderName){
+            return builderArguments+', {mode: \'number\'}';
+        }
+        return builderArguments;
+    }
+
+}
+
+module.exports.DrizzleModelsGeneration = DrizzleModelsGeneration;

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

@@ -0,0 +1,32 @@
+/**
+ *
+ * Reldens - Storage - DrizzleModulesLoader
+ *
+ */
+
+const { DrizzleModulesValidator } = require('./drizzle-modules-validator');
+const { PackageResolver } = require('../package-resolver');
+
+class DrizzleModulesLoader
+{
+
+    static load(projectPath)
+    {
+        let orm = PackageResolver.loadPackage('drizzle-orm', projectPath);
+        if(!orm){
+            return false;
+        }
+        let mysql2Driver = PackageResolver.loadPackage('drizzle-orm/mysql2', projectPath);
+        if(!mysql2Driver){
+            return false;
+        }
+        let drizzleModules = {drizzle: mysql2Driver.drizzle, orm};
+        if(!DrizzleModulesValidator.validate(drizzleModules)){
+            return false;
+        }
+        return drizzleModules;
+    }
+
+}
+
+module.exports.DrizzleModulesLoader = DrizzleModulesLoader;