@reldens/storage 0.78.0 → 0.80.0

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

@@ -13,7 +13,7 @@ class {{modelClassName}} extends ObjectionJsRawModel
     {
         return '{{tableName}}';
     }
-    {{modelRelations}}
+{{idColumn}}{{modelRelations}}
 }
 
 module.exports.{{modelClassName}} = {{modelClassName}};

package/lib/generators/models-generation.js

@@ -41,13 +41,15 @@ class ModelsGeneration extends BaseGenerator
             .join('\n        ');
         let modelRelations = this.generateModelRelations(tableName, tableData, relationMetadata, driverKey);
         let entityPropertiesDefinition = this.getEntityPropertiesDefinition(tableData.columns, driverKey);
+        let idColumn = this.generateIdColumn(tableData.columns, driverKey);
         let replacements = {
             modelClassName,
             tableName: 'prisma' === driverKey ? tableName.toLowerCase() : tableName,
             modelPropertiesList,
             modelPropertiesConstructor,
             modelRelations,
-            entityPropertiesDefinition
+            entityPropertiesDefinition,
+            idColumn
         };
         let modelContent = this.applyReplacements(modelTemplateContent, replacements);
         let fileName = sc.kebabCase(tableName)+'-model.js';
@@ -67,6 +69,29 @@ class ModelsGeneration extends BaseGenerator
         return true;
     }
 
+    generateIdColumn(columns, driverKey)
+    {
+        if('objection-js' !== driverKey){
+            return '';
+        }
+        let primaryKeyColumn = this.detectPrimaryKeyColumn(columns);
+        if(!primaryKeyColumn || 'id' === primaryKeyColumn){
+            return '';
+        }
+        return '\n    static get idColumn()\n    {\n        return \''+primaryKeyColumn+'\';\n    }\n';
+    }
+
+    detectPrimaryKeyColumn(columns)
+    {
+        for(let columnName of Object.keys(columns)){
+            let column = columns[columnName];
+            if('PRI' === column.key){
+                return columnName;
+            }
+        }
+        return null;
+    }
+
     setAllTablesData(allTablesData)
     {
         this.allTablesData = allTablesData;

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

@@ -120,7 +120,7 @@ class PrismaDataServer extends BaseDataServer
             return await this.prisma.$queryRawUnsafe(statement);
         }
         let result = await this.prisma.$executeRawUnsafe(statement);
-        Logger.debug('Raw result from Prisma: ' + result);
+        //Logger.debug('Raw result from Prisma: ' + result);
         if(
             trimmedStatement.startsWith('CREATE')
             || trimmedStatement.startsWith('ALTER')

package/lib/prisma/prisma-driver.js

@@ -129,6 +129,29 @@ class PrismaDriver extends BaseDriver
         return Object.keys(this.relationMetadata || {});
     }
 
+    normalizeRelationName(relationName)
+    {
+        if(sc.hasOwn(this.relationMetadata, relationName)){
+            return relationName;
+        }
+        if(relationName.startsWith('related_')){
+            let withoutPrefix = relationName.substring(8);
+            if(sc.hasOwn(this.relationMetadata, withoutPrefix)){
+                return withoutPrefix;
+            }
+        }
+        let availableRelations = Object.keys(this.relationMetadata);
+        for(let availableRelation of availableRelations){
+            if(relationName.endsWith(availableRelation)){
+                return availableRelation;
+            }
+            if(availableRelation.endsWith(relationName.replace('related_', ''))){
+                return availableRelation;
+            }
+        }
+        return relationName;
+    }
+
     isNumericFieldType(fieldType)
     {
         return ('Int' === fieldType || 'BigInt' === fieldType || 'Float' === fieldType || 'Decimal' === fieldType);
@@ -466,18 +489,18 @@ class PrismaDriver extends BaseDriver
         return value;
     }
 
-    transformRelationResults(result, includeConfig)
+    transformRelationResults(result, includeConfig, relationMapping)
     {
         if(!result || !includeConfig){
             return result;
         }
         if(sc.isArray(result)){
-            return result.map(item => this.transformSingleResult(item, includeConfig));
+            return result.map(item => this.transformSingleResult(item, includeConfig, relationMapping));
         }
-        return this.transformSingleResult(result, includeConfig);
+        return this.transformSingleResult(result, includeConfig, relationMapping);
     }
 
-    transformSingleResult(item, includeConfig)
+    transformSingleResult(item, includeConfig, relationMapping)
     {
         if(!item || !sc.isObject(item)){
             return item;
@@ -493,11 +516,15 @@ class PrismaDriver extends BaseDriver
             }
             let relationValue = transformed[relationName];
             if('one' === relationMeta.type && sc.isArray(relationValue)){
-                transformed[relationName] = 0 < relationValue.length ? relationValue[0] : null;
-                continue;
+                relationValue = 0 < relationValue.length ? [...relationValue].shift() : null;
             }
             if('many' === relationMeta.type && !sc.isArray(relationValue)){
-                transformed[relationName] = relationValue ? [relationValue] : [];
+                relationValue = relationValue ? [relationValue] : [];
+            }
+            let originalName = sc.get(relationMapping, relationName, relationName);
+            transformed[originalName] = relationValue;
+            if(originalName !== relationName){
+                delete transformed[relationName];
             }
         }
         return transformed;
@@ -526,26 +553,33 @@ class PrismaDriver extends BaseDriver
         this.ensureRequiredFields(preparedData);
         let createData = {data: preparedData};
         if(0 < relations.length){
-            let includeConfig = this.buildIncludeObject(relations);
-            createData.include = includeConfig;
+            let includeData = this.buildIncludeObjectWithMapping(relations);
+            createData.include = includeData.include;
             for(let relation of relations){
-                if(!sc.hasOwn(params, relation)){
+                let normalizedRelation = this.normalizeRelationName(relation);
+                if(!sc.hasOwn(params, relation) && !sc.hasOwn(params, normalizedRelation)){
                     continue;
                 }
-                let relationData = params[relation];
+                let relationData = sc.get(params, relation, sc.get(params, normalizedRelation, null));
                 if(sc.isArray(relationData)){
-                    createData.data[relation] = {
+                    createData.data[normalizedRelation] = {
                         connect: relationData.map(item => ({id: this.castToIdType(item.id)}))
                     };
                     continue;
                 }
-                createData.data[relation] = {
+                createData.data[normalizedRelation] = {
                     connect: {id: this.castToIdType(relationData.id)}
                 };
             }
+            try {
+                return this.transformRelationResults(await this.model.create(createData), includeData.include, includeData.mapping);
+            } catch(error) {
+                Logger.error('Create with relations error: '+error.message);
+                return false;
+            }
         }
         try {
-            return this.transformRelationResults(await this.model.create(createData), createData.include);
+            return await this.model.create(createData);
         } catch(error) {
             Logger.error('Create with relations error: '+error.message);
             return false;
@@ -692,7 +726,7 @@ class PrismaDriver extends BaseDriver
             where: processedFilters
         };
         if(0 < relations.length){
-            query.include = this.buildIncludeObject(relations);
+            query.include = this.buildIncludeObjectWithMapping(relations).include;
         }
         try {
             return await this.model.count(query);
@@ -714,22 +748,13 @@ class PrismaDriver extends BaseDriver
 
     async loadAllWithRelations(relations)
     {
-        if(!sc.isArray(relations) || 0 === relations.length){
-            relations = this.getAllRelations();
-        }
-        let query = this.buildQueryOptions();
-        let includeConfig = {};
-        if(0 < relations.length){
-            includeConfig = this.buildIncludeObject(relations);
-            query.include = includeConfig;
-        }
-        try {
-            let results = await this.model.findMany(query);
-            return this.transformRelationResults(results, includeConfig);
-        } catch(error) {
-            Logger.error('Load all with relations error: '+error.message);
-            return [];
-        }
+        return this.executeQueryWithRelations(
+            (q) => this.model.findMany(q),
+            this.buildQueryOptions(),
+            relations,
+            'Load all with relations error: ',
+            []
+        );
     }
 
     async load(filters)
@@ -747,24 +772,15 @@ class PrismaDriver extends BaseDriver
 
     async loadWithRelations(filters, relations)
     {
-        if(!sc.isArray(relations) || 0 === relations.length){
-            relations = this.getAllRelations();
-        }
-        let processedFilters = this.processFilters(filters);
         let query = this.buildQueryOptions();
-        query.where = processedFilters;
-        let includeConfig = {};
-        if(0 < relations.length){
-            includeConfig = this.buildIncludeObject(relations);
-            query.include = includeConfig;
-        }
-        try {
-            let results = await this.model.findMany(query);
-            return this.transformRelationResults(results, includeConfig);
-        } catch(error) {
-            Logger.error('Load with relations error: '+error.message);
-            return [];
-        }
+        query.where = this.processFilters(filters);
+        return this.executeQueryWithRelations(
+            (q) => this.model.findMany(q),
+            query,
+            relations,
+            'Load with relations error: ',
+            []
+        );
     }
 
     async loadBy(field, fieldValue, operator = null)
@@ -782,24 +798,15 @@ class PrismaDriver extends BaseDriver
 
     async loadByWithRelations(field, fieldValue, relations, operator = null)
     {
-        if(!sc.isArray(relations) || 0 === relations.length){
-            relations = this.getAllRelations();
-        }
-        let filter = this.createSingleFilter(field, fieldValue, operator);
         let query = this.buildQueryOptions();
-        query.where = filter;
-        let includeConfig = {};
-        if(0 < relations.length){
-            includeConfig = this.buildIncludeObject(relations);
-            query.include = includeConfig;
-        }
-        try {
-            let results = await this.model.findMany(query);
-            return this.transformRelationResults(results, includeConfig);
-        } catch(error) {
-            Logger.error('Load by with relations error: '+error.message);
-            return [];
-        }
+        query.where = this.createSingleFilter(field, fieldValue, operator);
+        return this.executeQueryWithRelations(
+            (q) => this.model.findMany(q),
+            query,
+            relations,
+            'Load by with relations error: ',
+            []
+        );
     }
 
     async loadById(id)
@@ -817,25 +824,13 @@ class PrismaDriver extends BaseDriver
 
     async loadByIdWithRelations(id, relations)
     {
-        if(!sc.isArray(relations) || 0 === relations.length){
-            relations = this.getAllRelations();
-        }
-        let castedId = this.castToIdType(id);
-        let query = {
-            where: {id: castedId}
-        };
-        let includeConfig = {};
-        if(0 < relations.length){
-            includeConfig = this.buildIncludeObject(relations);
-            query.include = includeConfig;
-        }
-        try {
-            let result = await this.model.findUnique(query);
-            return this.transformRelationResults(result, includeConfig);
-        } catch(error) {
-            Logger.error('Load by ID with relations error: '+error.message);
-            return null;
-        }
+        return this.executeQueryWithRelations(
+            (q) => this.model.findUnique(q),
+            {where: {id: this.castToIdType(id)}},
+            relations,
+            'Load by ID with relations error: ',
+            null
+        );
     }
 
     async loadByIds(ids)
@@ -868,24 +863,15 @@ class PrismaDriver extends BaseDriver
 
     async loadOneWithRelations(filters, relations)
     {
-        if(!sc.isArray(relations) || 0 === relations.length){
-            relations = this.getAllRelations();
-        }
-        let processedFilters = this.processFilters(filters);
         let query = this.buildQueryOptions(false);
-        query.where = processedFilters;
-        let includeConfig = {};
-        if(0 < relations.length){
-            includeConfig = this.buildIncludeObject(relations);
-            query.include = includeConfig;
-        }
-        try {
-            let result = await this.model.findFirst(query);
-            return this.transformRelationResults(result, includeConfig);
-        } catch(error) {
-            Logger.error('Load one with relations error: '+error.message);
-            return null;
-        }
+        query.where = this.processFilters(filters);
+        return this.executeQueryWithRelations(
+            (q) => this.model.findFirst(q),
+            query,
+            relations,
+            'Load one with relations error: ',
+            null
+        );
     }
 
     async loadOneBy(field, fieldValue, operator = null)
@@ -903,24 +889,15 @@ class PrismaDriver extends BaseDriver
 
     async loadOneByWithRelations(field, fieldValue, relations, operator = null)
     {
-        if(!sc.isArray(relations) || 0 === relations.length){
-            relations = this.getAllRelations();
-        }
-        let filter = this.createSingleFilter(field, fieldValue, operator);
         let query = this.buildQueryOptions(false);
-        query.where = filter;
-        let includeConfig = {};
-        if(0 < relations.length){
-            includeConfig = this.buildIncludeObject(relations);
-            query.include = includeConfig;
-        }
-        try {
-            let result = await this.model.findFirst(query);
-            return this.transformRelationResults(result, includeConfig);
-        } catch(error) {
-            Logger.error('Load one by with relations error: '+error.message);
-            return null;
-        }
+        query.where = this.createSingleFilter(field, fieldValue, operator);
+        return this.executeQueryWithRelations(
+            (q) => this.model.findFirst(q),
+            query,
+            relations,
+            'Load one by with relations error: ',
+            null
+        );
     }
 
     buildQueryOptions(useLimit = true)
@@ -999,13 +976,39 @@ class PrismaDriver extends BaseDriver
         };
     }
 
-    buildIncludeObject(relations)
+    async executeQueryWithRelations(modelMethod, query, relations, errorMessage, defaultReturn)
+    {
+        if(!sc.isArray(relations) || 0 === relations.length){
+            relations = this.getAllRelations();
+        }
+        let includeData = this.buildIncludeObjectWithMapping(relations);
+        if(0 < Object.keys(includeData.include).length){
+            query.include = includeData.include;
+        }
+        try {
+            return this.transformRelationResults(await modelMethod(query), includeData.include, includeData.mapping);
+        } catch(error) {
+            Logger.error(errorMessage+error.message);
+            return defaultReturn;
+        }
+    }
+
+    buildIncludeObjectWithMapping(relations)
     {
         let include = {};
+        let mapping = {};
         for(let relation of relations){
-            include[relation] = true;
+            let normalizedRelation = this.normalizeRelationName(relation);
+            if(!sc.hasOwn(this.relationMetadata, normalizedRelation)){
+                //Logger.debug('Relation "'+relation+'" (normalized: "'+normalizedRelation+'") not found in model '+this.tableName());
+                continue;
+            }
+            include[normalizedRelation] = true;
+            if(relation !== normalizedRelation){
+                mapping[normalizedRelation] = relation;
+            }
         }
-        return include;
+        return {include, mapping};
     }
 
 }

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

@@ -1,182 +1,182 @@
-/**
- *
- * Reldens - PrismaSchemaGenerator
- *
- */
-
-const { execSync } = require('child_process');
-const { FileHandler } = require('@reldens/server-utils');
-const { Logger, sc } = require('@reldens/utils');
-
-class PrismaSchemaGenerator
-{
-
-    constructor(props)
-    {
-        this.config = sc.get(props, 'config', {});
-        this.client = sc.get(props, 'client', 'mysql');
-        this.debug = sc.get(props, 'debug', false);
-        this.dataProxy = sc.get(props, 'dataProxy', false);
-        this.checkInterval = sc.get(props, 'checkInterval', 1000);
-        this.maxWaitTime = sc.get(props, 'maxWaitTime', 30000);
-        this.prismaSchemaPath = sc.get(props, 'prismaSchemaPath', FileHandler.joinPaths(process.cwd(), 'prisma'));
-        this.schemaFilePath = FileHandler.joinPaths(this.prismaSchemaPath, 'schema.prisma');
-        this.clientOutputPath = sc.get(props, 'clientOutputPath', '');
-        this.generateBinaryTargets = sc.get(props, 'generateBinaryTargets', ['native', 'debian-openssl-1.1.x']);
-        this.dbParams = sc.get(props, 'dbParams', process.env.RELDENS_DB_PARAMS || '');
-    }
-
-    async generate()
-    {
-        FileHandler.createFolder(this.prismaSchemaPath);
-        this.generateSchemaFile();
-        Logger.info('Running prisma introspect "npx prisma db pull"...');
-        try {
-            execSync('npx prisma db pull', { stdio: 'inherit' });
-        } catch(error) {
-            Logger.critical('Failed to pull database schema: ' + error.message);
-            return false;
-        }
-        let generateCommand = 'npx prisma generate';
-        if(this.dataProxy){
-            generateCommand += ' --data-proxy';
-        }
-        Logger.info('Running prisma generate "'+generateCommand+'"...');
-        try {
-            execSync(generateCommand, { stdio: 'inherit' });
-        } catch(error) {
-            let errorString = error.toString();
-            if(errorString.includes('EPERM') && errorString.includes('query_engine-windows.dll.node')){
-                Logger.warning('Windows permission error detected with query engine file.');
-                Logger.warning('This is a known Prisma issue on Windows.');
-                Logger.warning('Please manually run: ' + generateCommand);
-                Logger.warning('You may need to close any processes using the Prisma client first.');
-                return false;
-            }
-            Logger.critical('Generate command failed: ' + error.message);
-            return false;
-        }
-        await this.waitForSchemaGeneration();
-        return true;
-    }
-
-    async waitForSchemaGeneration()
-    {
-        let clientPath = this.clientOutputPath || 'node_modules/.prisma/client';
-        let generatedClientPath = this.resolveClientPath(clientPath);
-        let clientIndexPath = FileHandler.joinPaths(generatedClientPath, 'index.js');
-        let startTime = Date.now();
-        return new Promise((resolve) => {
-            let interval = setInterval(() => {
-                let awaitTime = Date.now() - startTime;
-                Logger.info('Awaiting on schema generation: ' + clientIndexPath, (awaitTime/1000).toFixed(0));
-                if(FileHandler.exists(clientIndexPath)){
-                    clearInterval(interval);
-                    resolve();
-                    return;
-                }
-                if(awaitTime > this.maxWaitTime){
-                    clearInterval(interval);
-                    Logger.warning('Schema generation wait timeout reached.');
-                    resolve();
-                }
-            }, this.checkInterval);
-        });
-    }
-
-    resolveClientPath(clientPath)
-    {
-        if(clientPath.match(/^[a-zA-Z]:/) || clientPath.startsWith('/')){
-            return clientPath;
-        }
-        if(clientPath.startsWith('node_modules')){
-            return FileHandler.joinPaths(process.cwd(), clientPath);
-        }
-        return FileHandler.joinPaths(this.prismaSchemaPath, clientPath);
-    }
-
-    generateSchemaFile()
-    {
-        let datasourceProvider = this.getDatasourceProvider();
-        let schemaContent = this.buildSchemaContent(
-            datasourceProvider,
-            this.buildConnectionString(datasourceProvider),
-            this.buildDirectConnectionString(datasourceProvider)
-        );
-        FileHandler.writeFile(this.schemaFilePath, schemaContent);
-        Logger.info('Generated Prisma schema file at: '+this.schemaFilePath);
-    }
-
-    getDatasourceProvider()
-    {
-        if('postgresql' === this.client || 'postgres' === this.client){
-            return 'postgresql';
-        }
-        if('mongodb' === this.client){
-            return 'mongodb';
-        }
-        return 'mysql';
-    }
-
-    buildConnectionString(datasourceProvider)
-    {
-        if(this.dataProxy){
-            datasourceProvider = 'prisma';
-        }
-        return datasourceProvider + this.buildConnectionDataString();
-    }
-
-    buildDirectConnectionString(datasourceProvider)
-    {
-        if(!this.dataProxy){
-            return '';
-        }
-        return datasourceProvider + this.buildConnectionDataString();
-    }
-
-    buildConnectionDataString()
-    {
-        return '://' + this.config.user + ':' + this.config.password
-            + '@' + this.config.host+':' + this.config.port
-            + '/' + this.config.database
-            + (this.dbParams ? '?' + this.dbParams : '');
-    }
-
-    buildSchemaContent(datasourceProvider, connectionString, directConnectionString)
-    {
-        return this.buildGeneratorBlock() + '\n\n'
-            + this.buildDatasourceBlock(datasourceProvider, connectionString, directConnectionString) + '\n';
-    }
-
-    buildGeneratorBlock()
-    {
-        let generatorContent = 'generator client {\n';
-        generatorContent += '  provider = "prisma-client-js"\n';
-        if(this.clientOutputPath){
-            let normalizedPath = this.clientOutputPath.replace(/\\/g, '/');
-            generatorContent += '  output = "' + normalizedPath + '"\n';
-        }
-        if(0 < this.generateBinaryTargets.length){
-            generatorContent += '  binaryTargets = [' +
-                this.generateBinaryTargets.map(target => '"' + target + '"').join(', ')
-                + ']\n';
-        }
-        generatorContent += '}';
-        return generatorContent;
-    }
-
-    buildDatasourceBlock(datasourceProvider, connectionString, directConnectionString)
-    {
-        let datasourceContent = 'datasource db {\n';
-        datasourceContent += '  provider = "' + datasourceProvider + '"\n';
-        datasourceContent += '  url      = "' + connectionString + '"\n';
-        if('' !== directConnectionString){
-            datasourceContent += '  directUrl = "' + directConnectionString + '"\n';
-        }
-        datasourceContent += '}';
-        return datasourceContent;
-    }
-
-}
-
-module.exports.PrismaSchemaGenerator = PrismaSchemaGenerator;
+/**
+ *
+ * Reldens - PrismaSchemaGenerator
+ *
+ */
+
+const { execSync } = require('child_process');
+const { FileHandler } = require('@reldens/server-utils');
+const { Logger, sc } = require('@reldens/utils');
+
+class PrismaSchemaGenerator
+{
+
+    constructor(props)
+    {
+        this.config = sc.get(props, 'config', {});
+        this.client = sc.get(props, 'client', 'mysql');
+        this.debug = sc.get(props, 'debug', false);
+        this.dataProxy = sc.get(props, 'dataProxy', false);
+        this.checkInterval = sc.get(props, 'checkInterval', 1000);
+        this.maxWaitTime = sc.get(props, 'maxWaitTime', 30000);
+        this.prismaSchemaPath = sc.get(props, 'prismaSchemaPath', FileHandler.joinPaths(process.cwd(), 'prisma'));
+        this.schemaFilePath = FileHandler.joinPaths(this.prismaSchemaPath, 'schema.prisma');
+        this.clientOutputPath = sc.get(props, 'clientOutputPath', '');
+        this.generateBinaryTargets = sc.get(props, 'generateBinaryTargets', ['native', 'debian-openssl-1.1.x']);
+        this.dbParams = sc.get(props, 'dbParams', process.env.RELDENS_DB_PARAMS || '');
+    }
+
+    async generate()
+    {
+        FileHandler.createFolder(this.prismaSchemaPath);
+        this.generateSchemaFile();
+        Logger.info('Running prisma introspect "npx prisma db pull"...');
+        try {
+            execSync('npx prisma db pull', { stdio: 'inherit' });
+        } catch(error) {
+            Logger.critical('Failed to pull database schema: ' + error.message);
+            return false;
+        }
+        let generateCommand = 'npx prisma generate';
+        if(this.dataProxy){
+            generateCommand += ' --data-proxy';
+        }
+        Logger.info('Running prisma generate "'+generateCommand+'"...');
+        try {
+            execSync(generateCommand, { stdio: 'inherit' });
+        } catch(error) {
+            let errorString = error.toString();
+            if(errorString.includes('EPERM') && errorString.includes('query_engine-windows.dll.node')){
+                Logger.warning('Windows permission error detected with query engine file.');
+                Logger.warning('This is a known Prisma issue on Windows.');
+                Logger.warning('Please manually run: ' + generateCommand);
+                Logger.warning('You may need to close any processes using the Prisma client first.');
+                return false;
+            }
+            Logger.critical('Generate command failed: ' + error.message);
+            return false;
+        }
+        await this.waitForSchemaGeneration();
+        return true;
+    }
+
+    async waitForSchemaGeneration()
+    {
+        let clientPath = this.clientOutputPath || 'node_modules/.prisma/client';
+        let generatedClientPath = this.resolveClientPath(clientPath);
+        let clientIndexPath = FileHandler.joinPaths(generatedClientPath, 'index.js');
+        let startTime = Date.now();
+        return new Promise((resolve) => {
+            let interval = setInterval(() => {
+                let awaitTime = Date.now() - startTime;
+                Logger.info('Awaiting on schema generation: ' + clientIndexPath, (awaitTime/1000).toFixed(0));
+                if(FileHandler.exists(clientIndexPath)){
+                    clearInterval(interval);
+                    resolve();
+                    return;
+                }
+                if(awaitTime > this.maxWaitTime){
+                    clearInterval(interval);
+                    Logger.warning('Schema generation wait timeout reached.');
+                    resolve();
+                }
+            }, this.checkInterval);
+        });
+    }
+
+    resolveClientPath(clientPath)
+    {
+        if(clientPath.match(/^[a-zA-Z]:/) || clientPath.startsWith('/')){
+            return clientPath;
+        }
+        if(clientPath.startsWith('node_modules')){
+            return FileHandler.joinPaths(process.cwd(), clientPath);
+        }
+        return FileHandler.joinPaths(this.prismaSchemaPath, clientPath);
+    }
+
+    generateSchemaFile()
+    {
+        let datasourceProvider = this.getDatasourceProvider();
+        let schemaContent = this.buildSchemaContent(
+            datasourceProvider,
+            this.buildConnectionString(datasourceProvider),
+            this.buildDirectConnectionString(datasourceProvider)
+        );
+        FileHandler.writeFile(this.schemaFilePath, schemaContent);
+        Logger.info('Generated Prisma schema file at: '+this.schemaFilePath);
+    }
+
+    getDatasourceProvider()
+    {
+        if('postgresql' === this.client || 'postgres' === this.client){
+            return 'postgresql';
+        }
+        if('mongodb' === this.client){
+            return 'mongodb';
+        }
+        return 'mysql';
+    }
+
+    buildConnectionString(datasourceProvider)
+    {
+        if(this.dataProxy){
+            datasourceProvider = 'prisma';
+        }
+        return datasourceProvider + this.buildConnectionDataString();
+    }
+
+    buildDirectConnectionString(datasourceProvider)
+    {
+        if(!this.dataProxy){
+            return '';
+        }
+        return datasourceProvider + this.buildConnectionDataString();
+    }
+
+    buildConnectionDataString()
+    {
+        return '://' + this.config.user + ':' + this.config.password
+            + '@' + this.config.host+':' + this.config.port
+            + '/' + this.config.database
+            + (this.dbParams ? '?' + this.dbParams : '');
+    }
+
+    buildSchemaContent(datasourceProvider, connectionString, directConnectionString)
+    {
+        return this.buildGeneratorBlock() + '\n\n'
+            + this.buildDatasourceBlock(datasourceProvider, connectionString, directConnectionString) + '\n';
+    }
+
+    buildGeneratorBlock()
+    {
+        let generatorContent = 'generator client {\n';
+        generatorContent += '  provider = "prisma-client-js"\n';
+        if(this.clientOutputPath){
+            let normalizedPath = this.clientOutputPath.replace(/\\/g, '/');
+            generatorContent += '  output = "' + normalizedPath + '"\n';
+        }
+        if(0 < this.generateBinaryTargets.length){
+            generatorContent += '  binaryTargets = [' +
+                this.generateBinaryTargets.map(target => '"' + target + '"').join(', ')
+                + ']\n';
+        }
+        generatorContent += '}';
+        return generatorContent;
+    }
+
+    buildDatasourceBlock(datasourceProvider, connectionString, directConnectionString)
+    {
+        let datasourceContent = 'datasource db {\n';
+        datasourceContent += '  provider = "' + datasourceProvider + '"\n';
+        datasourceContent += '  url      = "' + connectionString + '"\n';
+        if('' !== directConnectionString){
+            datasourceContent += '  directUrl = "' + directConnectionString + '"\n';
+        }
+        datasourceContent += '}';
+        return datasourceContent;
+    }
+
+}
+
+module.exports.PrismaSchemaGenerator = PrismaSchemaGenerator;

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@reldens/storage",
     "scope": "@reldens",
-    "version": "0.78.0",
+    "version": "0.80.0",
     "description": "Reldens - Storage",
     "author": "Damian A. Pastorini",
     "license": "MIT",
@@ -42,11 +42,11 @@
         "url": "https://github.com/damian-pastorini/reldens-storage/issues"
     },
     "dependencies": {
-        "@mikro-orm/core": "6.6.0",
-        "@mikro-orm/mongodb": "6.6.0",
-        "@mikro-orm/mysql": "6.6.0",
+        "@mikro-orm/core": "6.6.1",
+        "@mikro-orm/mongodb": "6.6.1",
+        "@mikro-orm/mysql": "6.6.1",
         "@prisma/client": "6.19.0",
-        "@reldens/server-utils": "^0.40.0",
+        "@reldens/server-utils": "^0.41.0",
         "@reldens/utils": "^0.54.0",
         "knex": "3.1.0",
         "mysql": "2.18.1",