@reldens/storage 0.32.0 → 0.34.0

package/lib/entity-templates/mikro-orm-model.template

@@ -0,0 +1,37 @@
+/**
+ *
+ * Reldens - {{modelClassName}}
+ *
+ */
+
+const { MikroOrmCore } = require('@reldens/storage');
+const { EntitySchema } = MikroOrmCore;
+
+class {{modelClassName}}
+{
+
+    constructor({{modelPropertiesList}})
+    {
+        {{modelPropertiesConstructor}}
+    }
+
+    static createByProps(props)
+    {
+        const {{{modelPropertiesList}}} = props;
+        return new this({{modelPropertiesList}});
+    }
+    {{modelRelations}}
+}
+
+const schema = new EntitySchema({
+    class: {{modelClassName}},
+    properties: {
+        {{entityPropertiesDefinition}}
+    },
+});
+
+module.exports = {
+    {{modelClassName}},
+    entity: {{modelClassName}},
+    schema: schema
+};

package/lib/entity-templates/objection-js-model.template

@@ -0,0 +1,19 @@
+/**
+ *
+ * Reldens - {{modelClassName}}
+ *
+ */
+
+const { ObjectionJsRawModel } = require('@reldens/storage');
+
+class {{modelClassName}} extends ObjectionJsRawModel
+{
+
+    static get tableName()
+    {
+        return '{{tableName}}';
+    }
+    {{modelRelations}}
+}
+
+module.exports.{{modelClassName}} = {{modelClassName}};

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

@@ -0,0 +1,32 @@
+/**
+ *
+ * Reldens - {{modelClassName}}
+ *
+ */
+
+const { PrismaClient } = require('@prisma/client');
+
+class {{modelClassName}}
+{
+
+    constructor({{modelPropertiesList}})
+    {
+        {{modelPropertiesConstructor}}
+    }
+
+    static get client()
+    {
+        if(!this._client){
+            this._client = new PrismaClient();
+        }
+        return this._client;
+    }
+
+    static get model()
+    {
+        return this.client['{{tableName}}'];
+    }
+    {{modelRelations}}
+}
+
+module.exports.{{modelClassName}} = {{modelClassName}};

package/lib/entity-templates/registered-models.template

@@ -0,0 +1,19 @@
+/**
+ *
+ * Reldens - Registered Models
+ *
+ */
+
+{{registeredModels}}
+const { entitiesConfig } = require('../../entities-config');
+const { entitiesTranslations } = require('../../entities-translations');
+
+let rawRegisteredEntities = {
+    {{registeredEntitiesObject}}
+};
+
+module.exports.rawRegisteredEntities = rawRegisteredEntities;
+
+module.exports.entitiesConfig = entitiesConfig;
+
+module.exports.entitiesTranslations = entitiesTranslations;

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

@@ -6,10 +6,11 @@
 
 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 { Logger, ErrorManager } = require('@reldens/utils');
+const { ErrorManager, Logger, sc } = require('@reldens/utils');
 
 class MikroOrmDataServer extends BaseDataServer
 {
@@ -22,9 +23,9 @@ class MikroOrmDataServer extends BaseDataServer
 
     constructor(props)
     {
-        // @TODO - BETA - Finish implementation.
         super(props);
         this.entitiesPath = props.entitiesPath;
+        this.warnWhenNoEntities = Boolean(props.warnWhenNoEntities);
     }
 
     async connect()
@@ -36,7 +37,7 @@ class MikroOrmDataServer extends BaseDataServer
             driver: this.clientsMapped[(this.client || 'mongodb')],
             dbName: this.config.database,
             clientUrl: this.connectString,
-            allowGlobalContext: true
+            allowGlobalContext: true,
         };
         if(this.rawEntities){
             providedSetup.entities = Object.values(this.rawEntities);
@@ -47,6 +48,7 @@ class MikroOrmDataServer extends BaseDataServer
         if(this.entitiesPath){
             providedSetup.entities = this.entitiesPath;
         }
+        providedSetup.discovery = {warnWhenNoEntities: this.warnWhenNoEntities};
         this.orm = await MikroORM.init(providedSetup);
         this.initialized = Date.now();
         return this.initialized;
@@ -85,8 +87,43 @@ class MikroOrmDataServer extends BaseDataServer
 
     async rawQuery(content)
     {
-        // @TODO - BETA - Implement.
-        ErrorManager.error('MikroORM rawQuery() not implemented.');
+        try {
+            let queryResult = await this.orm.em.execute(content);
+            if(!sc.isArray(queryResult) || 0 === queryResult.length){
+                return false;
+            }
+            return queryResult;
+        } catch(error) {
+            Logger.error('Raw query failed: '+error.message);
+            return false;
+        }
+    }
+
+    async fetchEntitiesFromDatabase()
+    {
+        if(!this.initialized){
+            Logger.error('Connection was not initialized, please use the connect method first.');
+            return false;
+        }
+        try {
+            if('mysql' === 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;
+            }
+            ErrorManager.error('Unsupported client type: '+this.client);
+        } catch(error) {
+            ErrorManager.error('Failed to fetch tables from database: ' + error.message);
+        }
     }
 
 }

package/lib/mikro-orm/mikro-orm-driver.js

@@ -123,7 +123,7 @@ class MikroOrmDriver extends BaseDriver
         if (!entries){
             return false;
         }
-        for(let entry of Object.keys(entries)){
+        for(let entry of entries){
             await this.repository.nativeDelete(entry.id);
         }
     }

package/lib/mysql-tables-provider.js

@@ -0,0 +1,87 @@
+/**
+ *
+ * Reldens - MySQLTablesProvider
+ *
+ */
+
+const { ErrorManager, sc } = require('@reldens/utils');
+
+class MySQLTablesProvider
+{
+
+    static async fetchTables(server)
+    {
+        let tablesQuery = 
+            'SELECT ' +
+            '    TABLE_NAME, ' +
+            '    COLUMN_NAME, ' +
+            '    DATA_TYPE, ' +
+            '    CHARACTER_MAXIMUM_LENGTH, ' +
+            '    COLUMN_TYPE, ' +
+            '    IS_NULLABLE, ' +
+            '    COLUMN_KEY, ' +
+            '    EXTRA, ' +
+            '    COLUMN_DEFAULT ' +
+            'FROM ' +
+            '    information_schema.COLUMNS ' +
+            'WHERE ' +
+            '    TABLE_SCHEMA = \'' + server.config.database + '\' ' +
+            'ORDER BY ' +
+            '    TABLE_NAME, ORDINAL_POSITION';
+        try {
+            let result = await server.rawQuery(tablesQuery);
+            if(!sc.isArray(result) || 0 === result.length){
+                ErrorManager.error('No tables found in the database.');
+            }
+            let tables = {};
+            for(let row of result){
+                if(!tables[row.TABLE_NAME]){
+                    tables[row.TABLE_NAME] = {
+                        name: row.TABLE_NAME,
+                        columns: {}
+                    };
+                }
+                tables[row.TABLE_NAME].columns[row.COLUMN_NAME] = {
+                    name: row.COLUMN_NAME,
+                    type: row.DATA_TYPE,
+                    columnType: row.COLUMN_TYPE,
+                    length: row.CHARACTER_MAXIMUM_LENGTH,
+                    nullable: 'YES' === row.IS_NULLABLE,
+                    key: row.COLUMN_KEY,
+                    extra: row.EXTRA,
+                    default: row.COLUMN_DEFAULT
+                };
+            }
+            let foreignKeysQuery = 
+                'SELECT ' +
+                '    TABLE_NAME, ' +
+                '    COLUMN_NAME, ' +
+                '    REFERENCED_TABLE_NAME, ' +
+                '    REFERENCED_COLUMN_NAME ' +
+                'FROM ' +
+                '    information_schema.KEY_COLUMN_USAGE ' +
+                'WHERE ' +
+                '    TABLE_SCHEMA = \'' + server.config.database + '\' ' +
+                '    AND REFERENCED_TABLE_NAME IS NOT NULL';
+            
+            let foreignKeysResult = await server.rawQuery(foreignKeysQuery);
+            if(sc.isArray(foreignKeysResult) && 0 < foreignKeysResult.length){
+                for(let row of foreignKeysResult){
+                    if(
+                        tables[row.TABLE_NAME] && 
+                        tables[row.TABLE_NAME].columns[row.COLUMN_NAME]
+                    ){
+                        tables[row.TABLE_NAME].columns[row.COLUMN_NAME].referencedTable = row.REFERENCED_TABLE_NAME;
+                        tables[row.TABLE_NAME].columns[row.COLUMN_NAME].referencedColumn = row.REFERENCED_COLUMN_NAME;
+                    }
+                }
+            }
+            return tables;
+        } catch(error) {
+            ErrorManager.error('Failed to fetch tables from database: '+error.message);
+        }
+    }
+
+}
+
+module.exports.MySQLTablesProvider = MySQLTablesProvider;

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

@@ -6,6 +6,7 @@
 
 const { BaseDataServer } = require('../base-data-server');
 const { ObjectionJsDriver } = require('./objection-js-driver');
+const { MySQLTablesProvider } = require('../mysql-tables-provider');
 const { Model } = require('objection');
 const Knex = require('knex');
 const { Logger } = require('@reldens/utils');
@@ -72,7 +73,17 @@ class ObjectionJsDataServer extends BaseDataServer
 
     async rawQuery(content)
     {
-        return await this.knex.raw(content);
+        let result = await this.knex.raw(content);
+        return result[0] || 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);
     }
 
 }

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

@@ -0,0 +1,114 @@
+/**
+ *
+ * Reldens - PrismaDataServer
+ *
+ */
+
+const { BaseDataServer } = require('../base-data-server');
+const { PrismaDriver } = require('./prisma-driver');
+const { MySQLTablesProvider } = require('../mysql-tables-provider');
+const { ErrorManager, Logger, sc } = require('@reldens/utils');
+
+class PrismaDataServer extends BaseDataServer
+{
+
+    constructor(props)
+    {
+        super(props);
+        this.prisma = false;
+    }
+
+    async connect()
+    {
+        if(this.initialized){
+            return this.initialized;
+        }
+        try {
+            let { PrismaClient } = require('@prisma/client');
+            this.prisma = new PrismaClient({
+                log: this.debug ? ['query', 'info', 'warn', 'error'] : ['error']
+            });
+            await this.prisma.$connect();
+            this.initialized = Date.now();
+            return this.initialized;
+        } catch(error) {
+            Logger.critical('Connection failed, Prisma error: '+error.message);
+        }
+        return false;
+    }
+
+    generateEntities()
+    {
+        if(!this.initialized){
+            Logger.warning('Connection was not initialized, please use the connect method first.');
+            return {};
+        }
+        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];
+            let modelName = i.toLowerCase();
+            if(!this.prisma[modelName]){
+                Logger.critical('Invalid raw entity "'+i+'". No matching Prisma model found.');
+                continue;
+            }
+            this.entities[i] = new PrismaDriver({
+                rawModel: rawEntity,
+                id: i,
+                name: i,
+                config: this.config,
+                prisma: this.prisma,
+                model: this.prisma[modelName],
+                server: this
+            });
+        }
+        this.entityManager.setEntities(this.entities);
+        return this.entities;
+    }
+
+    name()
+    {
+        return this.name || 'Prisma Data Server Driver';
+    }
+
+    async rawQuery(content)
+    {
+        try {
+            let queryResult = await this.prisma.$queryRawUnsafe(content);
+            if(!sc.isArray(queryResult) || 0 === queryResult.length){
+                return false;
+            }
+            return queryResult;
+        } catch(error) {
+            Logger.error('Raw query failed: '+error.message);
+            return false;
+        }
+    }
+
+    async fetchEntitiesFromDatabase()
+    {
+        if(!this.initialized){
+            Logger.error('Connection was not initialized, please use the connect method first.');
+            return false;
+        }
+        try {
+            return await MySQLTablesProvider.fetchTables(this);
+        } catch(error) {
+            ErrorManager.error('Failed to fetch tables from database: '+error.message);
+        }
+    }
+
+    async disconnect()
+    {
+        if(this.prisma){
+            await this.prisma.$disconnect();
+        }
+        this.initialized = false;
+    }
+
+}
+
+module.exports.PrismaDataServer = PrismaDataServer;