@reldens/storage 0.117.0 → 0.119.0

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

@@ -0,0 +1,74 @@
+/**
+ *
+ * Reldens - DrizzleModulesValidator
+ *
+ */
+
+const { Logger, sc } = require('@reldens/utils');
+
+let requiredOrmFunctions = [
+    'eq', 'ne', 'gt', 'gte', 'lt', 'lte', 'inArray', 'like', 'isNull', 'and', 'or', 'not', 'asc', 'desc', 'count'
+];
+
+class DrizzleModulesValidator
+{
+
+    static validate(drizzleModules)
+    {
+        if(!sc.isObject(drizzleModules)){
+            Logger.critical('Missing "drizzleModules" object.');
+            return false;
+        }
+        if(!DrizzleModulesValidator.validateOrm(drizzleModules.orm)){
+            return false;
+        }
+        if(drizzleModules.db){
+            return DrizzleModulesValidator.validateDbInstance(drizzleModules.db);
+        }
+        if(!sc.isFunction(drizzleModules.drizzle)){
+            Logger.critical('Invalid "drizzleModules.drizzle".');
+            return false;
+        }
+        return true;
+    }
+
+    static validateOrm(orm)
+    {
+        if(!sc.isObject(orm)){
+            Logger.critical('Missing "drizzleModules.orm" namespace.');
+            return false;
+        }
+        let missingFunctions = requiredOrmFunctions.filter(ormFunction => !sc.isFunction(orm[ormFunction]));
+        if(0 < missingFunctions.length){
+            Logger.critical('Invalid "drizzleModules.orm", missing: '+missingFunctions.join(', '));
+            return false;
+        }
+        if(!sc.isFunction(orm.sql)){
+            Logger.critical('Invalid "drizzleModules.orm", "sql" not found.');
+            return false;
+        }
+        if(!sc.isFunction(orm.sql.raw)){
+            Logger.critical('Invalid "drizzleModules.orm", "sql.raw" not found.');
+            return false;
+        }
+        return true;
+    }
+
+    static validateDbInstance(db)
+    {
+        let requiredMethods = ['select', 'insert', 'update', 'delete', 'execute'];
+        let missingMethods = requiredMethods.filter(method => !sc.isFunction(db[method]));
+        if(0 < missingMethods.length){
+            Logger.critical('Invalid Drizzle instance, missing: '+missingMethods.join(', '));
+            return false;
+        }
+        if(!sc.isObjectFunction(db.$client, 'end')){
+            Logger.critical('Invalid Drizzle instance, "$client.end" not found.');
+            return false;
+        }
+        return true;
+    }
+
+}
+
+module.exports.DrizzleModulesValidator = DrizzleModulesValidator;

package/lib/entities-generator.js

@@ -9,6 +9,9 @@ const { Logger, sc } = require('@reldens/utils');
 const { ObjectionJsDataServer } = require('./objection-js/objection-js-data-server');
 const { MikroOrmDataServer } = require('./mikro-orm/mikro-orm-data-server');
 const { PrismaDataServer } = require('./prisma/prisma-data-server');
+const { KnexDataServer } = require('./knex/knex-data-server');
+const { KyselyDataServer } = require('./kysely/kysely-data-server');
+const { DrizzleDataServer } = require('./drizzle/drizzle-data-server');
 const { PrismaRelationsMetadataExtractor } = require('./prisma/prisma-relations-metadata-extractor');
 const { EntitiesGeneration } = require('./generators/entities-generation');
 const { ModelsGeneration } = require('./generators/models-generation');
@@ -25,6 +28,9 @@ class EntitiesGenerator
             'objection-js': FileHandler.joinPaths(this.templatesFolderPath, 'objection-js-model.template'),
             'mikro-orm': FileHandler.joinPaths(this.templatesFolderPath, 'mikro-orm-model.template'),
             'prisma': FileHandler.joinPaths(this.templatesFolderPath, 'prisma-model.template'),
+            'knex': FileHandler.joinPaths(this.templatesFolderPath, 'query-builder-model.template'),
+            'kysely': FileHandler.joinPaths(this.templatesFolderPath, 'query-builder-model.template'),
+            'drizzle': FileHandler.joinPaths(this.templatesFolderPath, 'drizzle-model.template'),
             'entity': FileHandler.joinPaths(this.templatesFolderPath, 'entity.template'),
             'entities-config': FileHandler.joinPaths(this.templatesFolderPath, 'entities-config.template'),
             'entities-translations': FileHandler.joinPaths(this.templatesFolderPath, 'entities-translations.template'),
@@ -39,17 +45,36 @@ class EntitiesGenerator
         this.driverMap = {
             'objection-js': ObjectionJsDataServer,
             'mikro-orm': MikroOrmDataServer,
-            'prisma': PrismaDataServer
+            'prisma': PrismaDataServer,
+            'knex': KnexDataServer,
+            'kysely': KyselyDataServer,
+            'drizzle': DrizzleDataServer
         };
         this.driversClassMap = {
             'ObjectionJsDataServer': 'objection-js',
             'MikroOrmDataServer': 'mikro-orm',
-            'PrismaDataServer': 'prisma'
+            'PrismaDataServer': 'prisma',
+            'KnexDataServer': 'knex',
+            'KyselyDataServer': 'kysely',
+            'DrizzleDataServer': 'drizzle'
         };
         this.server = sc.get(props, 'server', false);
         this.connectionData = sc.get(props, 'connectionData', false);
         this.isOverride = sc.get(props, 'isOverride', false);
+        this.driverModulesProps = {
+            'objection-js': 'objectionModules',
+            'mikro-orm': 'mikroOrmModules',
+            'prisma': 'prismaModules',
+            'knex': 'knexModules',
+            'kysely': 'kyselyModules',
+            'drizzle': 'drizzleModules'
+        };
         this.prismaModules = sc.get(props, 'prismaModules', false);
+        this.kyselyModules = sc.get(props, 'kyselyModules', false);
+        this.drizzleModules = sc.get(props, 'drizzleModules', false);
+        this.objectionModules = sc.get(props, 'objectionModules', false);
+        this.knexModules = sc.get(props, 'knexModules', false);
+        this.mikroOrmModules = sc.get(props, 'mikroOrmModules', false);
         this.generatedEntities = {};
         this.existingEntities = {};
         this.existingEntityFields = {};
@@ -64,7 +89,10 @@ class EntitiesGenerator
             templates: {
                 'objection-js': this.templates['objection-js'],
                 'mikro-orm': this.templates['mikro-orm'],
-                'prisma': this.templates['prisma']
+                'prisma': this.templates['prisma'],
+                'knex': this.templates['knex'],
+                'kysely': this.templates['kysely'],
+                'drizzle': this.templates['drizzle']
             }
         });
         this.entitiesConfigGeneration = new EntitiesConfigGeneration({
@@ -288,7 +316,7 @@ class EntitiesGenerator
             Logger.critical('Failed to fetch driver key.');
             return false;
         }
-        this.modelsGeneration.setAllTablesData(tables);
+        this.modelsGeneration.relationsDetection.allTablesData = tables;
         let tablesToGenerate = this.filterTablesToGenerate(tables, driverKey);
         if(0 === Object.keys(tablesToGenerate).length && !this.isOverride){
             return true;
@@ -340,7 +368,7 @@ class EntitiesGenerator
         if(this.server){
             return this.server;
         }
-        let driverKey = sc.get(this.connectionData, 'driver', 'objection-js');
+        let driverKey = sc.get(this.connectionData, 'driver', 'knex');
         let driverClassMapped = this.driverMap[driverKey];
         if(!driverClassMapped){
             Logger.critical('Unsupported driver: '+driverKey);
@@ -357,8 +385,9 @@ class EntitiesGenerator
             },
             projectRoot: this.projectPath
         };
-        if('prisma' === driverKey && this.prismaModules){
-            serverConfig.prismaModules = this.prismaModules;
+        let modulesProp = sc.get(this.driverModulesProps, driverKey, false);
+        if(modulesProp && this[modulesProp]){
+            serverConfig[modulesProp] = this[modulesProp];
         }
         this.server = new driverClassMapped(serverConfig);
         return this.server;

package/lib/entity-templates/drizzle-model.template

@@ -0,0 +1,28 @@
+/**
+ *
+ * Reldens - {{modelClassName}}
+ *
+ */
+
+const DrizzleMysqlCore = require('drizzle-orm/mysql-core');
+
+let table = DrizzleMysqlCore.mysqlTable('{{tableName}}', {
+    {{entityPropertiesDefinition}}
+});
+
+class {{modelClassName}}
+{
+
+    static get tableName()
+    {
+        return '{{tableName}}';
+    }
+
+    static get table()
+    {
+        return table;
+    }
+{{idColumn}}{{modelRelations}}
+}
+
+module.exports.{{modelClassName}} = {{modelClassName}};

package/lib/entity-templates/query-builder-model.template

@@ -0,0 +1,17 @@
+/**
+ *
+ * Reldens - {{modelClassName}}
+ *
+ */
+
+class {{modelClassName}}
+{
+
+    static get tableName()
+    {
+        return '{{tableName}}';
+    }
+{{idColumn}}{{modelRelations}}
+}
+
+module.exports.{{modelClassName}} = {{modelClassName}};

package/lib/generators/base-generator.js

@@ -25,6 +25,19 @@ class BaseGenerator
         props.push('onDelete: \''+deleteRule+'\'');
     }
 
+    parseEnumValues(columnType)
+    {
+        if(!columnType){
+            return [];
+        }
+        let match = columnType.match(/^enum\('(.+)'\)$/i);
+        if(!match){
+            return [];
+        }
+        let valuesString = match[1];
+        return valuesString.split('\',\'');
+    }
+
     mapDeleteRule(deleteRule)
     {
         if(!deleteRule){

package/lib/generators/entities-generation.js

@@ -277,19 +277,6 @@ class EntitiesGeneration extends BaseGenerator
         );
     }
 
-    parseEnumValues(columnType)
-    {
-        if(!columnType){
-            return [];
-        }
-        let match = columnType.match(/^enum\('(.+)'\)$/i);
-        if(!match){
-            return [];
-        }
-        let valuesString = match[1];
-        return valuesString.split('\',\'');
-    }
-
     addRequiredAttribute(props, column)
     {
         if(!column.nullable && !column.default){