@reldens/storage 0.117.0 → 0.119.0

package/lib/mikro-orm/mikro-orm-models-generation.js

@@ -0,0 +1,178 @@
+/**
+ *
+ * Reldens - MikroOrmModelsGeneration
+ *
+ */
+
+const { sc } = require('@reldens/utils');
+
+class MikroOrmModelsGeneration
+{
+
+    constructor(relationsDetection)
+    {
+        this.relationsDetection = relationsDetection;
+        this.relationKindMap = {
+            'BelongsToOneRelation': 'm:1',
+            'HasOneRelation': '1:1',
+            'HasManyRelation': '1:m',
+            'ManyToManyRelation': 'm:n'
+        };
+        this.columnTypesMap = {
+            'bigint': 'number'
+        };
+    }
+
+    modelTableName(tableName)
+    {
+        return tableName;
+    }
+
+    generateRelations(tableName, tableData, relationMetadata)
+    {
+        return '';
+    }
+
+    generateIdColumn(columns)
+    {
+        return '';
+    }
+
+    generateEntityProperties(columns, tableName, tableData)
+    {
+        if(!tableName || !tableData){
+            return this.columnsProperties(columns, {}).join(',\n        ');
+        }
+        let relations = this.relationsDetection.detectForwardRelations(tableName, tableData);
+        let entityProps = this.columnsProperties(columns);
+        for(let relationKey of Object.keys(relations)){
+            entityProps.push(this.forwardRelationProperty(relationKey, relations[relationKey], columns));
+        }
+        let reverseRelations = this.relationsDetection.detectReverseRelations(tableName);
+        for(let relationKey of Object.keys(reverseRelations)){
+            entityProps.push(this.reverseRelationProperty(relationKey, reverseRelations[relationKey], tableName));
+        }
+        return entityProps.join(',\n        ');
+    }
+
+    columnsProperties(columns)
+    {
+        let entityProps = [];
+        for(let columnName of Object.keys(columns)){
+            entityProps.push(this.columnProperty(columnName, columns[columnName]));
+        }
+        return entityProps;
+    }
+
+    columnProperty(columnName, column)
+    {
+        let propDef = columnName+': { type: \''+sc.get(this.columnTypesMap, column.type, column.type)+'\'';
+        if('PRI' === column.key){
+            propDef += ', primary: true';
+        }
+        if('UNI' === column.key){
+            propDef += ', unique: true';
+        }
+        if(column.nullable || this.hasDefaultValue(column)){
+            propDef += ', nullable: true';
+        }
+        return propDef+' }';
+    }
+
+    hasDefaultValue(column)
+    {
+        return null !== column.default && 'undefined' !== typeof column.default;
+    }
+
+    forwardRelationProperty(relationKey, relation, columns)
+    {
+        let relatedModelClass = sc.capitalizedCamelCase(relation.referencedTable)+'Model';
+        let relatedModelFile = sc.kebabCase(relation.referencedTable)+'-model';
+        let propDef = relationKey+': {\n';
+        propDef += '            kind: \''+this.forwardRelationKind(columns[relation.fromColumn])+'\',\n';
+        propDef += '            entity: () => require(\'./'+relatedModelFile+'\').'+relatedModelClass;
+        if(relation.fromColumn){
+            propDef += ',\n            joinColumns: [\''+relation.fromColumn+'\']';
+        }
+        if(this.isNonPrimaryReference(relation)){
+            propDef += ',\n            referencedColumnNames: [\''+relation.toColumn+'\']';
+            propDef += ',\n            targetKey: \''+relation.toColumn+'\'';
+            propDef += ',\n            cascade: [],\n            mapToPk: true';
+        }
+        if(this.isNullableColumn(columns[relation.fromColumn])){
+            propDef += ',\n            nullable: true';
+        }
+        propDef += ',\n            persist: false';
+        return propDef+'\n        }';
+    }
+
+    isNonPrimaryReference(relation)
+    {
+        if(!relation.toColumn){
+            return false;
+        }
+        return 'id' !== relation.toColumn;
+    }
+
+    isNullableColumn(column)
+    {
+        if(!column){
+            return false;
+        }
+        return Boolean(column.nullable);
+    }
+
+    forwardRelationKind(column)
+    {
+        if('HasOneRelation' === this.relationsDetection.determineRelationType(column, false)){
+            return this.relationKindMap.HasOneRelation;
+        }
+        return this.relationKindMap.BelongsToOneRelation;
+    }
+
+    reverseRelationProperty(relationKey, relation, tableName)
+    {
+        let relatedModelClass = sc.capitalizedCamelCase(relation.referencingTable)+'Model';
+        let relatedModelFile = sc.kebabCase(relation.referencingTable)+'-model';
+        let mappedBy = this.relationsDetection.findMappedByKey(tableName, relation.referencingTable, relation);
+        let propDef = relationKey+': {\n';
+        propDef += '            kind: \''+sc.get(this.relationKindMap, relation.relationType, '1:m')+'\',\n';
+        propDef += '            entity: () => require(\'./'+relatedModelFile+'\').'+relatedModelClass;
+        if(mappedBy){
+            propDef += ',\n            mappedBy: \''+mappedBy+'\'';
+        }
+        return propDef+'\n        }';
+    }
+
+    generateFkMappings(tableName, tableData)
+    {
+        if(!tableName || !tableData){
+            return '';
+        }
+        let fkMappings = {};
+        let referenceCounts = this.relationsDetection.countReferencesPerTable(tableData);
+        for(let columnName of Object.keys(tableData.columns)){
+            let column = tableData.columns[columnName];
+            if(!sc.hasOwn(column, 'referencedTable')){
+                continue;
+            }
+            fkMappings[columnName] = {
+                relationKey: this.relationsDetection.generateForwardRelationKey(
+                    column.referencedTable,
+                    columnName,
+                    referenceCounts
+                ),
+                entityName: sc.capitalizedCamelCase(column.referencedTable)+'Model',
+                referencedColumn: column.referencedColumn,
+                nullable: sc.get(column, 'nullable', false)
+            };
+        }
+        if(0 === Object.keys(fkMappings).length){
+            return '';
+        }
+        return JSON.stringify(fkMappings, null, 4);
+    }
+
+}
+
+module.exports.MikroOrmModelsGeneration = MikroOrmModelsGeneration;

package/lib/mikro-orm/mikro-orm-modules-loader.js

@@ -0,0 +1,50 @@
+/**
+ *
+ * Reldens - Storage - MikroOrmModulesLoader
+ *
+ */
+
+const { MikroOrmModulesValidator } = require('./mikro-orm-modules-validator');
+const { PackageResolver } = require('../package-resolver');
+
+class MikroOrmModulesLoader
+{
+
+    static load(projectPath, client)
+    {
+        let mikroOrmCore = PackageResolver.loadPackage('@mikro-orm/core', projectPath);
+        if(!mikroOrmCore){
+            return false;
+        }
+        let mikroOrmModules = {
+            MikroORM: mikroOrmCore.MikroORM,
+            EntityCaseNamingStrategy: mikroOrmCore.EntityCaseNamingStrategy,
+            Collection: mikroOrmCore.Collection,
+            EntitySchema: mikroOrmCore.EntitySchema
+        };
+        MikroOrmModulesLoader.appendClientDriver(mikroOrmModules, projectPath, client);
+        if(!MikroOrmModulesValidator.validate(mikroOrmModules, client)){
+            return false;
+        }
+        return mikroOrmModules;
+    }
+
+    static appendClientDriver(mikroOrmModules, projectPath, client)
+    {
+        if('mongodb' === client){
+            let mongoPackage = PackageResolver.loadPackage('@mikro-orm/mongodb', projectPath);
+            if(mongoPackage){
+                mikroOrmModules.MongoDriver = mongoPackage.MongoDriver;
+            }
+            return mikroOrmModules;
+        }
+        let mysqlPackage = PackageResolver.loadPackage('@mikro-orm/mysql', projectPath);
+        if(mysqlPackage){
+            mikroOrmModules.MySqlDriver = mysqlPackage.MySqlDriver;
+        }
+        return mikroOrmModules;
+    }
+
+}
+
+module.exports.MikroOrmModulesLoader = MikroOrmModulesLoader;

package/lib/mikro-orm/mikro-orm-modules-validator.js

@@ -0,0 +1,46 @@
+/**
+ *
+ * Reldens - MikroOrmModulesValidator
+ *
+ */
+
+const { Logger, sc } = require('@reldens/utils');
+
+let requiredCoreClasses = ['MikroORM', 'EntityCaseNamingStrategy', 'Collection'];
+
+class MikroOrmModulesValidator
+{
+
+    static validate(mikroOrmModules, client)
+    {
+        if(!sc.isObject(mikroOrmModules)){
+            Logger.critical('Missing "mikroOrmModules" object.');
+            return false;
+        }
+        let missingClasses = requiredCoreClasses.filter(coreClass => !sc.isFunction(mikroOrmModules[coreClass]));
+        if(0 < missingClasses.length){
+            Logger.critical('Invalid "mikroOrmModules", missing: '+missingClasses.join(', '));
+            return false;
+        }
+        return MikroOrmModulesValidator.validateClientDriver(mikroOrmModules, client);
+    }
+
+    static validateClientDriver(mikroOrmModules, client)
+    {
+        if('mongodb' === client){
+            if(!sc.isFunction(mikroOrmModules.MongoDriver)){
+                Logger.critical('Missing "mikroOrmModules.MongoDriver" for the "mongodb" client.');
+                return false;
+            }
+            return true;
+        }
+        if(!sc.isFunction(mikroOrmModules.MySqlDriver)){
+            Logger.critical('Missing "mikroOrmModules.MySqlDriver" for the "'+client+'" client.');
+            return false;
+        }
+        return true;
+    }
+
+}
+
+module.exports.MikroOrmModulesValidator = MikroOrmModulesValidator;

package/lib/mysql2-connection-config.js

@@ -0,0 +1,38 @@
+/**
+ *
+ * Reldens - Mysql2ConnectionConfig
+ *
+ */
+
+const { sc } = require('@reldens/utils');
+
+let validMySQL2Options = [
+    'authPlugins', 'authSwitchHandler', 'bigNumberStrings', 'charset', 'charsetNumber', 'compress',
+    'connectAttributes', 'connectTimeout', 'database', 'dateStrings', 'debug', 'decimalNumbers',
+    'enableKeepAlive', 'flags', 'host', 'insecureAuth', 'infileStreamFactory', 'isServer',
+    'keepAliveInitialDelay', 'localAddress', 'maxPreparedStatements', 'multipleStatements',
+    'namedPlaceholders', 'nestTables', 'password', 'password1', 'password2', 'password3', 'passwordSha1',
+    'pool', 'port', 'queryFormat', 'rowsAsArray', 'socketPath', 'ssl', 'stream', 'stringifyObjects',
+    'supportBigNumbers', 'timezone', 'trace', 'typeCast', 'uri', 'user', 'disableEval', 'connectionLimit',
+    'maxIdle', 'idleTimeout', 'Promise', 'queueLimit', 'waitForConnections', 'jsonStrings', 'gracefulEnd'
+];
+
+class Mysql2ConnectionConfig
+{
+
+    static sanitize(config)
+    {
+        let cleanConfig = {};
+        for(let prop of validMySQL2Options){
+            if(sc.hasOwn(config, prop)){
+                cleanConfig[prop] = config[prop];
+            }
+        }
+        return cleanConfig;
+    }
+
+}
+
+module.exports.validMySQL2Options = validMySQL2Options;
+
+module.exports.Mysql2ConnectionConfig = Mysql2ConnectionConfig;

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

@@ -1,125 +1,71 @@
-/**
- *
- * Reldens - ObjectionJsDataServer
- *
- */
-
-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, sc } = require('@reldens/utils');
-
-class ObjectionJsDataServer extends BaseDataServer
-{
-
-    constructor(props)
-    {
-        super(props);
-        this.knex = false;
-        if(!this.rawModel){
-            this.rawModel = Model;
-        }
-        this.validMySQL2Options = [
-            'authPlugins', 'authSwitchHandler', 'bigNumberStrings', 'charset', 'charsetNumber', 'compress',
-            'connectAttributes', 'connectTimeout', 'database', 'dateStrings', 'debug', 'decimalNumbers',
-            'enableKeepAlive', 'flags', 'host', 'insecureAuth', 'infileStreamFactory', 'isServer',
-            'keepAliveInitialDelay', 'localAddress', 'maxPreparedStatements', 'multipleStatements',
-            'namedPlaceholders', 'nestTables', 'password', 'password1', 'password2', 'password3', 'passwordSha1',
-            'pool', 'port', 'queryFormat', 'rowsAsArray', 'socketPath', 'ssl', 'stream', 'stringifyObjects',
-            'supportBigNumbers', 'timezone', 'trace', 'typeCast', 'uri', 'user', 'disableEval', 'connectionLimit',
-            'maxIdle', 'idleTimeout', 'Promise', 'queueLimit', 'waitForConnections', 'jsonStrings', 'gracefulEnd'
-        ];
-    }
-
-    async connect()
-    {
-        if(this.initialized){
-            return this.initialized;
-        }
-        let connectionConfig = this.sanitizeConnectionConfig(this.config);
-        this.knex = await Knex({
-            client: this.client,
-            connection: connectionConfig,
-            pool: this.poolConfig,
-            debug: this.debug,
-            multipleStatements: this.multipleStatements
-        });
-        await this.rawModel.knex(this.knex);
-        try {
-            const [[{ currentTime }]] = await this.rawModel.knex().raw(
-                'SELECT ROUND(UNIX_TIMESTAMP(NOW(6)) * 1000 + MICROSECOND(NOW(6)) / 1000) AS currentTime;'
-            );
-            this.initialized = currentTime;
-        } catch (err) {
-            Logger.critical('Connection failed, Objection JS error.', err);
-        }
-        return this.initialized;
-    }
-
-    sanitizeConnectionConfig(config)
-    {
-        if('mysql2' !== this.client){
-            return config;
-        }
-        let cleanConfig = {};
-        for(let prop of this.validMySQL2Options){
-            if(sc.hasOwn(config, prop)){
-                cleanConfig[prop] = config[prop];
-            }
-        }
-        return cleanConfig;
-    }
-
-    async disconnect()
-    {
-        if(!this.knex){
-            return false;
-        }
-        await this.knex.destroy();
-        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(!rawEntity?.knex){
-                Logger.critical('Invalid raw entity "'+i+'".');
-                continue;
-            }
-            this.entities[i] = new ObjectionJsDriver({rawModel: rawEntity, id: i, name: i, config: rawEntity.knex});
-        }
-        this.entityManager.setEntities(this.entities);
-        return this.entities;
-    }
-
-    name()
-    {
-        return this.name || 'Objection JS Data Server Driver';
-    }
-
-    async rawQuery(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);
-    }
-
-}
-
-module.exports.ObjectionJsDataServer = ObjectionJsDataServer;
+/**
+ *
+ * Reldens - ObjectionJsDataServer
+ *
+ */
+
+const { KnexDataServer } = require('../knex/knex-data-server');
+const { ObjectionJsDriver } = require('./objection-js-driver');
+const { ObjectionModulesValidator } = require('./objection-modules-validator');
+const { ObjectionModulesLoader } = require('./objection-modules-loader');
+const { Logger, sc } = require('@reldens/utils');
+
+class ObjectionJsDataServer extends KnexDataServer
+{
+
+    constructor(props)
+    {
+        super(props);
+        this.objectionModules = sc.get(props, 'objectionModules', false);
+    }
+
+    async connect()
+    {
+        if(!this.objectionModules){
+            this.objectionModules = ObjectionModulesLoader.load(this.projectRoot);
+        }
+        if(!ObjectionModulesValidator.validate(this.objectionModules)){
+            return false;
+        }
+        if(!this.rawModel){
+            this.rawModel = this.objectionModules.Model;
+        }
+        let initialized = await super.connect();
+        if(this.knex){
+            await this.rawModel.knex(this.knex);
+        }
+        return initialized;
+    }
+
+    connectionErrorMessage()
+    {
+        return 'Connection failed, Objection JS error.';
+    }
+
+    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(!rawEntity?.knex){
+                Logger.critical('Invalid raw entity "'+i+'".');
+                continue;
+            }
+            this.entities[i] = new ObjectionJsDriver({rawModel: rawEntity, id: i, name: i, config: rawEntity.knex});
+        }
+        this.entityManager.setEntities(this.entities);
+        return this.entities;
+    }
+
+    name()
+    {
+        return this.name || 'Objection JS Data Server Driver';
+    }
+
+}
+
+module.exports.ObjectionJsDataServer = ObjectionJsDataServer;

package/lib/objection-js/objection-js-driver.js

@@ -37,7 +37,7 @@ class ObjectionJsDriver extends BaseDriver
 
     create(params)
     {
-        return this.queryBuilder().insert(params);
+        return this.queryBuilder().insertAndFetch(params);
     }
 
     createWithRelations(params, relations)
@@ -359,6 +359,9 @@ class ObjectionJsDriver extends BaseDriver
 
     appendRelationsToQuery(queryBuilder, relations, relationsModifiers, useJoin = false)
     {
+        if(sc.isString(relations)){
+            relations = this.parseRelationsString(relations);
+        }
         if(!sc.isArray(relations) || 0 === relations.length){
             relations = Object.keys(this.rawModel.relationMappings || {});
         }

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

@@ -0,0 +1,98 @@
+/**
+ *
+ * Reldens - ObjectionJsModelsGeneration
+ *
+ */
+
+const { sc } = require('@reldens/utils');
+
+class ObjectionJsModelsGeneration
+{
+
+    constructor(relationsDetection)
+    {
+        this.relationsDetection = relationsDetection;
+    }
+
+    modelTableName(tableName)
+    {
+        return tableName;
+    }
+
+    generateEntityProperties(columns, tableName, tableData)
+    {
+        return '';
+    }
+
+    generateFkMappings(tableName, tableData)
+    {
+        return '';
+    }
+
+    generateIdColumn(columns)
+    {
+        let primaryKeyColumn = this.relationsDetection.detectPrimaryKeyColumn(columns);
+        if(!primaryKeyColumn || 'id' === primaryKeyColumn){
+            return '';
+        }
+        return '\n    static get idColumn()\n    {\n        return \''+primaryKeyColumn+'\';\n    }\n';
+    }
+
+    generateRelations(tableName, tableData, relationMetadata)
+    {
+        let relations = this.relationsDetection.detectForwardRelations(tableName, tableData);
+        let reverseRelations = this.relationsDetection.detectReverseRelations(tableName);
+        let allRelations = Object.assign({}, relations, reverseRelations);
+        if(0 === Object.keys(allRelations).length){
+            return '';
+        }
+        let relationMappings = [];
+        let requiredModels = [];
+        for(let relationKey of Object.keys(allRelations)){
+            let relation = allRelations[relationKey];
+            let tableReference = sc.get(relation, 'referencedTable', relation.referencingTable);
+            let relatedModelClass = sc.capitalizedCamelCase(tableReference)+'Model';
+            if(!requiredModels.find(requiredModel => requiredModel.modelClass === relatedModelClass)){
+                requiredModels.push({
+                    modelClass: relatedModelClass,
+                    fileName: sc.kebabCase(tableReference)+'-model'
+                });
+            }
+            relationMappings.push(this.relationMappingDefinition(relationKey, relation, relatedModelClass));
+        }
+        return this.relationMappingsMethod(requiredModels, relationMappings);
+    }
+
+    relationMappingDefinition(relationKey, relation, relatedModelClass)
+    {
+        let relationMapping = '            '+relationKey+': {\n';
+        relationMapping += '                relation: this.'+relation.relationType+',\n';
+        relationMapping += '                modelClass: '+relatedModelClass+',\n';
+        relationMapping += '                join: {\n';
+        relationMapping += '                    from: this.tableName+\'.'+relation.fromColumn+'\',\n';
+        relationMapping += '                    to: '+relatedModelClass+'.tableName+\'.'+relation.toColumn+'\'\n';
+        relationMapping += '                }\n';
+        relationMapping += '            }';
+        return relationMapping;
+    }
+
+    relationMappingsMethod(requiredModels, relationMappings)
+    {
+        let requireStatements = [];
+        for(let modelInfo of requiredModels){
+            requireStatements.push(
+                '        const { '+modelInfo.modelClass+' } = require(\'./'+modelInfo.fileName+'\');'
+            );
+        }
+        let relationMappingsMethod = '\n    static get relationMappings()\n    {\n';
+        relationMappingsMethod += requireStatements.join('\n')+'\n';
+        relationMappingsMethod += '        return {\n';
+        relationMappingsMethod += relationMappings.join(',\n');
+        relationMappingsMethod += '\n        };\n';
+        relationMappingsMethod += '    }';
+        return relationMappingsMethod;
+    }
+
+}
+
+module.exports.ObjectionJsModelsGeneration = ObjectionJsModelsGeneration;

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

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