@reldens/storage 0.117.0 → 0.119.0

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

@@ -0,0 +1,31 @@
+/**
+ *
+ * Reldens - ObjectionModulesValidator
+ *
+ */
+
+const { Logger, sc } = require('@reldens/utils');
+
+class ObjectionModulesValidator
+{
+
+    static validate(objectionModules)
+    {
+        if(!sc.isObject(objectionModules)){
+            Logger.critical('Missing "objectionModules" object.');
+            return false;
+        }
+        if(!sc.isFunction(objectionModules.Model)){
+            Logger.critical('Invalid "objectionModules.Model".');
+            return false;
+        }
+        if(!sc.isFunction(objectionModules.Model.knex)){
+            Logger.critical('Invalid "objectionModules.Model", "knex" not found.');
+            return false;
+        }
+        return true;
+    }
+
+}
+
+module.exports.ObjectionModulesValidator = ObjectionModulesValidator;

package/lib/package-resolver.js

@@ -0,0 +1,45 @@
+/**
+ *
+ * Reldens - PackageResolver
+ *
+ */
+
+const { Logger } = require('@reldens/utils');
+
+class PackageResolver
+{
+
+    static loadPackage(packageName, projectPath)
+    {
+        try {
+            return require(PackageResolver.resolvePath(packageName, projectPath));
+        } catch(error) {
+            Logger.critical(
+                'Package "'+packageName+'" not found, install it in the project: npm install '+packageName,
+                error.message
+            );
+            return false;
+        }
+    }
+
+    static optionalPackage(packageName, projectPath)
+    {
+        try {
+            return require(PackageResolver.resolvePath(packageName, projectPath));
+        } catch(error) {
+            Logger.debug('Optional package "'+packageName+'" is not available.', error.message);
+            return false;
+        }
+    }
+
+    static resolvePath(packageName, projectPath)
+    {
+        if(!projectPath){
+            return packageName;
+        }
+        return require.resolve(packageName, {paths: [projectPath]});
+    }
+
+}
+
+module.exports.PackageResolver = PackageResolver;

package/lib/prisma/prisma-client-loader.js

@@ -40,7 +40,8 @@ class PrismaClientLoader
             +(connectionData.password ? ':'+connectionData.password : '')
             +'@'+connectionData.host
             +':'+connectionData.port
-            +'/'+connectionData.database;
+            +'/'+connectionData.database
+            +PrismaClientLoader.connectionLimitParameter(connectionData);
         Logger.info('Creating PrismaClient with connection to: '+connectionData.database);
         return PrismaClientLoader.createWithAdapter(completedModules, connectionString);
     }
@@ -50,6 +51,15 @@ class PrismaClientLoader
      * @param {string} connectionUrl
      * @returns {Object|null}
      */
+    static connectionLimitParameter(connectionData)
+    {
+        let connectionLimit = sc.get(connectionData, 'connectionLimit', false);
+        if(!connectionLimit){
+            return '';
+        }
+        return '?connectionLimit='+connectionLimit;
+    }
+
     static createWithAdapter(prismaModules, connectionUrl)
     {
         if(!PrismaModulesValidator.validate(prismaModules)){

package/lib/prisma/prisma-driver.js

@@ -237,6 +237,9 @@ class PrismaDriver extends BaseDriver
 
     async createWithRelations(params, relations)
     {
+        if(sc.isString(relations)){
+            relations = this.parseRelationsString(relations);
+        }
         if(!sc.isArray(relations) || 0 === relations.length){
             relations = this.getAllRelations();
         }
@@ -343,11 +346,15 @@ class PrismaDriver extends BaseDriver
     async delete(filters = {})
     {
         let processedFilters = this.filterProcessor.processFilters(filters);
-        return this.executeWithNormalization(
+        let deleteResult = await this.executeWithNormalization(
             () => this.model.deleteMany({where: processedFilters}),
             'Delete error: ',
             false
         );
+        if(!deleteResult){
+            return deleteResult;
+        }
+        return sc.get(deleteResult, 'count', 0);
     }
 
     async deleteById(id)
@@ -357,11 +364,15 @@ class PrismaDriver extends BaseDriver
         if(!found){
             return false;
         }
-        return this.executeWithNormalization(
+        let deleteResult = await this.executeWithNormalization(
             () => this.model.delete({where: {[this.idFieldName]: castedId}}),
             'Delete by ID error: ',
             false
         );
+        if(!deleteResult){
+            return deleteResult;
+        }
+        return 1;
     }
 
     async count(filters)
@@ -540,6 +551,9 @@ class PrismaDriver extends BaseDriver
 
     async executeQueryWithRelations(modelMethod, query, relations, errorMessage, defaultReturn)
     {
+        if(sc.isString(relations)){
+            relations = this.parseRelationsString(relations);
+        }
         if(!sc.isArray(relations) || 0 === relations.length){
             relations = this.getAllRelations();
         }

package/lib/prisma/prisma-filter-processor.js

@@ -35,12 +35,11 @@ class PrismaFilterProcessor
         let processedFilters = {};
         for(let key of Object.keys(filters)){
             let value = filters[key];
-            if('AND' === key && sc.isArray(value)){
-                processedFilters.AND = value.map(condition => this.processFilters(condition));
-                continue;
-            }
-            if('OR' === key && sc.isArray(value)){
-                processedFilters.OR = value.map(condition => this.processFilters(condition));
+            if(('AND' === key || 'OR' === key) && sc.isArray(value)){
+                if(0 === value.length){
+                    continue;
+                }
+                processedFilters[key] = value.map(condition => this.processFilters(condition));
                 continue;
             }
             let translatedKey = this.translateRelationKey(key);

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

@@ -0,0 +1,236 @@
+/**
+ *
+ * Reldens - PrismaModelsGeneration
+ *
+ */
+
+const { sc } = require('@reldens/utils');
+const { TypeMapper } = require('../type-mapper');
+const { RELATION_PREFIX } = require('../relation-key');
+
+class PrismaModelsGeneration
+{
+
+    constructor(relationsDetection)
+    {
+        this.relationsDetection = relationsDetection;
+    }
+
+    modelTableName(tableName)
+    {
+        return tableName.toLowerCase();
+    }
+
+    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';
+    }
+
+    generateEntityProperties(columns, tableName, tableData)
+    {
+        let prismaProps = [];
+        for(let columnName of Object.keys(columns)){
+            let column = columns[columnName];
+            let propDef = columnName+': {\n            type: \''+TypeMapper.mapDbTypeToPrismaType(column.type)+'\'';
+            if('PRI' === column.key){
+                propDef += ',\n            id: true';
+            }
+            if(column.nullable){
+                propDef += ',\n            optional: true';
+            }
+            prismaProps.push(propDef+'\n        }');
+        }
+        return prismaProps.join(',\n        ');
+    }
+
+    generateRelations(tableName, tableData, relationMetadata)
+    {
+        if(!relationMetadata || 0 === Object.keys(relationMetadata).length){
+            return '';
+        }
+        let relationTypesArray = [];
+        for(let prismaRelationName of Object.keys(relationMetadata)){
+            relationTypesArray.push(
+                '            '+prismaRelationName+': \''+relationMetadata[prismaRelationName].type+'\''
+            );
+        }
+        let allMappings = Object.assign(
+            {},
+            this.buildForwardMappings(tableData, relationMetadata),
+            this.buildReverseMappings(tableName, relationMetadata)
+        );
+        let relationMappingsArray = [];
+        for(let reldensKey of Object.keys(allMappings)){
+            relationMappingsArray.push('            \''+reldensKey+'\': \''+allMappings[reldensKey]+'\'');
+        }
+        return this.staticGetter('relationTypes', relationTypesArray)
+            +this.staticGetter('relationMappings', relationMappingsArray);
+    }
+
+    staticGetter(getterName, entries)
+    {
+        if(0 === entries.length){
+            return '';
+        }
+        return '\n\n    static get '+getterName+'()\n    {\n        return {\n'+entries.join(',\n')+'\n        };\n    }';
+    }
+
+    buildForwardMappings(tableData, relationMetadata)
+    {
+        let mappings = {};
+        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;
+            }
+            let prismaName = this.findRelationForFk(columnName, column.referencedTable, relationMetadata);
+            if(!prismaName){
+                continue;
+            }
+            let reldensKey = this.relationsDetection.generateForwardRelationKey(
+                column.referencedTable,
+                columnName,
+                referenceCounts
+            );
+            mappings[reldensKey] = prismaName;
+        }
+        return mappings;
+    }
+
+    findRelationForFk(columnName, referencedTable, relationMetadata)
+    {
+        let lowerColumn = columnName.toLowerCase();
+        let candidates = this.singleRelationCandidates(referencedTable, relationMetadata);
+        for(let prismaName of candidates){
+            let lowerPrisma = prismaName.toLowerCase();
+            if(lowerPrisma.includes(lowerColumn.replace('_id', ''))){
+                return prismaName;
+            }
+            if(lowerPrisma.includes(lowerColumn)){
+                return prismaName;
+            }
+        }
+        if(0 === candidates.length){
+            return null;
+        }
+        return [...candidates].shift();
+    }
+
+    singleRelationCandidates(referencedTable, relationMetadata)
+    {
+        let lowerTable = referencedTable.toLowerCase();
+        let candidates = [];
+        for(let prismaName of Object.keys(relationMetadata)){
+            let relation = relationMetadata[prismaName];
+            if(relation.model.toLowerCase() !== lowerTable){
+                continue;
+            }
+            if(relation.isList){
+                continue;
+            }
+            candidates.push(prismaName);
+        }
+        return candidates;
+    }
+
+    buildReverseMappings(tableName, relationMetadata)
+    {
+        let mappings = {};
+        let reverseRelations = this.groupReverseRelationsByTable(relationMetadata);
+        for(let relatedTable of Object.keys(reverseRelations)){
+            Object.assign(
+                mappings,
+                this.tableReverseMappings(relatedTable, reverseRelations[relatedTable], tableName)
+            );
+        }
+        return mappings;
+    }
+
+    tableReverseMappings(relatedTable, relations, tableName)
+    {
+        let mappings = {};
+        for(let relInfo of relations){
+            let reldensKey = this.reverseRelationKey(relatedTable, relInfo.prismaName, tableName, relations.length);
+            mappings[reldensKey] = relInfo.prismaName;
+        }
+        return mappings;
+    }
+
+    groupReverseRelationsByTable(relationMetadata)
+    {
+        let reverseRelations = {};
+        for(let prismaName of Object.keys(relationMetadata)){
+            let relation = relationMetadata[prismaName];
+            if(this.isForwardRelation(relation)){
+                continue;
+            }
+            let relatedTable = relation.model.toLowerCase();
+            if(!reverseRelations[relatedTable]){
+                reverseRelations[relatedTable] = [];
+            }
+            reverseRelations[relatedTable].push({prismaName, relation});
+        }
+        return reverseRelations;
+    }
+
+    isForwardRelation(relation)
+    {
+        return sc.hasOwn(relation, 'foreignKeys')
+            && sc.isArray(relation.foreignKeys)
+            && 0 < relation.foreignKeys.length;
+    }
+
+    reverseRelationKey(relatedTable, prismaName, tableName, referenceCount)
+    {
+        if(1 === referenceCount){
+            return RELATION_PREFIX+relatedTable;
+        }
+        let columnHint = this.extractColumnHint(prismaName, relatedTable, tableName);
+        if(columnHint){
+            return RELATION_PREFIX+relatedTable+'_'+columnHint;
+        }
+        return RELATION_PREFIX+relatedTable;
+    }
+
+    extractColumnHint(prismaName, relatedTable, tableName)
+    {
+        let lowerName = prismaName.toLowerCase();
+        let lowerTable = tableName.toLowerCase();
+        let lowerRelated = relatedTable.toLowerCase();
+        let toSuffix = 'to'+lowerTable;
+        if(!lowerName.endsWith(toSuffix)){
+            toSuffix = 'to'+lowerRelated;
+            if(!lowerName.endsWith(toSuffix)){
+                return null;
+            }
+        }
+        let withoutSuffix = prismaName.slice(0, -toSuffix.length);
+        let prefixes = [
+            lowerRelated+'_'+lowerRelated+'_',
+            lowerRelated+'_',
+            lowerTable+'_'
+        ];
+        for(let prefix of prefixes){
+            if(withoutSuffix.toLowerCase().startsWith(prefix)){
+                withoutSuffix = withoutSuffix.slice(prefix.length);
+            }
+        }
+        if(withoutSuffix.endsWith('_id')){
+            withoutSuffix = withoutSuffix.slice(0, -3);
+        }
+        return withoutSuffix.toLowerCase();
+    }
+
+}
+
+module.exports.PrismaModelsGeneration = PrismaModelsGeneration;

package/lib/prisma/prisma-schema-generator.js

@@ -139,7 +139,11 @@ class PrismaSchemaGenerator
 
     generateConfigFile()
     {
-        let configContent = 'process.loadEnvFile(\'.env\');\n'
+        let configContent = 'try {\n'
+            +'    process.loadEnvFile(\'.env\');\n'
+            +'} catch(error) {\n'
+            +'    process.env.RELDENS_PRISMA_ENV_ERROR = error.message;\n'
+            +'}\n'
             +'module.exports = { datasource: { url: process.env.RELDENS_DB_URL } };\n';
         let configPath = FileHandler.joinPaths(process.cwd(), 'prisma.config.js');
         FileHandler.writeFile(configPath, configContent);

package/lib/prisma/prisma-type-caster.js

@@ -248,6 +248,17 @@ class PrismaTypeCaster
         return casted;
     }
 
+    isDecimalInstance(value)
+    {
+        if(!sc.isObject(value) || !sc.isFunction(value.toString)){
+            return false;
+        }
+        if(!sc.hasOwn(value, 'd') || !sc.hasOwn(value, 'e') || !sc.hasOwn(value, 's')){
+            return false;
+        }
+        return sc.isArray(value.d);
+    }
+
     normalizeReturnData(data)
     {
         if(null === data || undefined === data){
@@ -262,6 +273,9 @@ class PrismaTypeCaster
         if(data instanceof Date){
             return data;
         }
+        if(this.isDecimalInstance(data)){
+            return data.toString();
+        }
         if(sc.isArray(data)){
             return data.map(item => this.normalizeReturnData(item));
         }

package/lib/query-builder-driver.js

@@ -0,0 +1,210 @@
+/**
+ *
+ * Reldens - QueryBuilderDriver
+ *
+ */
+
+const { BaseDriver } = require('./base-driver');
+const { RelationsLoader } = require('./relations-loader');
+const { ErrorManager, sc } = require('@reldens/utils');
+
+class QueryBuilderDriver extends BaseDriver
+{
+
+    constructor(props)
+    {
+        super(props);
+        this.server = sc.get(props, 'server', false);
+        this.relationsLoader = new RelationsLoader({driver: this, server: this.server});
+    }
+
+    databaseName()
+    {
+        return sc.get(this.config, 'database', '');
+    }
+
+    id()
+    {
+        return this.rawId || this.rawModel.tableName;
+    }
+
+    name()
+    {
+        return this.rawName || this.rawModel.tableName;
+    }
+
+    tableName()
+    {
+        return this.rawModel.tableName;
+    }
+
+    idColumn()
+    {
+        return sc.get(this.rawModel, 'idColumn', 'id');
+    }
+
+    property(propertyName)
+    {
+        return this.rawModel[propertyName] || null;
+    }
+
+    insertRow(data)
+    {
+        ErrorManager.error('QueryBuilderDriver insertRow() not implemented.');
+    }
+
+    selectRows(filters, options)
+    {
+        ErrorManager.error('QueryBuilderDriver selectRows() not implemented.');
+    }
+
+    selectOptions(useLimit)
+    {
+        return {
+            select: this.select,
+            limit: useLimit ? this.limit : 0,
+            offset: this.offset,
+            sortBy: this.sortBy,
+            sortDirection: this.sortDirection
+        };
+    }
+
+    createSingleFilter(field, fieldValue, operator = null)
+    {
+        if(null === operator){
+            return {[field]: fieldValue};
+        }
+        return {[field]: {operator, value: fieldValue}};
+    }
+
+    async create(params)
+    {
+        let insertId = await this.insertRow(params);
+        let createdId = insertId ? insertId : sc.get(params, this.idColumn(), false);
+        if(!createdId){
+            return false;
+        }
+        return await this.loadById(createdId);
+    }
+
+    createWithRelations(params, relations)
+    {
+        return this.relationsLoader.createWithRelations(params, relations);
+    }
+
+    updateBy(field, fieldValue, updatePatch, operator = null)
+    {
+        return this.update(this.createSingleFilter(field, fieldValue, operator), updatePatch);
+    }
+
+    async updateById(id, params)
+    {
+        await this.update({[this.idColumn()]: id}, params);
+        return await this.loadById(id);
+    }
+
+    async upsert(params, filters)
+    {
+        let idColumn = this.idColumn();
+        let providedId = sc.get(params, idColumn, false);
+        if(providedId){
+            let existentById = await this.loadById(providedId);
+            if(existentById){
+                return await this.updateById(providedId, params);
+            }
+        }
+        if(filters){
+            let existent = await this.loadOne(filters);
+            if(existent){
+                return await this.updateById(existent[idColumn], params);
+            }
+        }
+        return await this.create(params);
+    }
+
+    deleteById(id)
+    {
+        return this.delete({[this.idColumn()]: id});
+    }
+
+    countWithRelations(filters, relations)
+    {
+        return this.count(filters);
+    }
+
+    loadAll()
+    {
+        return this.selectRows({}, this.selectOptions(true));
+    }
+
+    load(filters = {})
+    {
+        return this.selectRows(filters, this.selectOptions(true));
+    }
+
+    async loadOne(filters)
+    {
+        let options = this.selectOptions(false);
+        options.limit = 1;
+        let rows = await this.selectRows(filters, options);
+        return rows.shift() || null;
+    }
+
+    loadBy(field, fieldValue, operator = null)
+    {
+        return this.load(this.createSingleFilter(field, fieldValue, operator));
+    }
+
+    loadOneBy(field, fieldValue, operator = null)
+    {
+        return this.loadOne(this.createSingleFilter(field, fieldValue, operator));
+    }
+
+    loadById(id)
+    {
+        return this.loadOne({[this.idColumn()]: id});
+    }
+
+    loadByIds(ids)
+    {
+        return this.load({[this.idColumn()]: {operator: 'IN', value: ids}});
+    }
+
+    async loadAllWithRelations(relations)
+    {
+        return await this.relationsLoader.populate(await this.loadAll(), relations);
+    }
+
+    async loadWithRelations(filters, relations)
+    {
+        return await this.relationsLoader.populate(await this.load(filters), relations);
+    }
+
+    async loadByWithRelations(field, fieldValue, relations, operator = null)
+    {
+        return await this.relationsLoader.populate(await this.loadBy(field, fieldValue, operator), relations);
+    }
+
+    async loadByIdWithRelations(id, relations)
+    {
+        return await this.relationsLoader.populate(await this.loadById(id), relations);
+    }
+
+    async loadOneWithRelations(filters, relations)
+    {
+        return await this.relationsLoader.populate(await this.loadOne(filters), relations);
+    }
+
+    async loadOneByWithRelations(field, fieldValue, relations, operator = null)
+    {
+        return await this.relationsLoader.populate(await this.loadOneBy(field, fieldValue, operator), relations);
+    }
+
+    rawQuery(content)
+    {
+        return this.server.rawQuery(content);
+    }
+
+}
+
+module.exports.QueryBuilderDriver = QueryBuilderDriver;