@reldens/storage 0.81.0 → 0.82.0

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

@@ -21,7 +21,7 @@ class PrismaSchemaGenerator
         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.clientOutputPath = sc.get(props, 'clientOutputPath', './client');
         this.generateBinaryTargets = sc.get(props, 'generateBinaryTargets', ['native', 'debian-openssl-1.1.x']);
         this.dbParams = sc.get(props, 'dbParams', process.env.RELDENS_DB_PARAMS || '');
     }
@@ -30,11 +30,12 @@ class PrismaSchemaGenerator
     {
         FileHandler.createFolder(this.prismaSchemaPath);
         this.generateSchemaFile();
+        this.setDatabaseEnvironmentVariables();
         Logger.info('Running prisma introspect "npx prisma db pull"...');
         try {
-            execSync('npx prisma db pull', { stdio: 'inherit' });
+            execSync('npx prisma db pull', {stdio: 'inherit'});
         } catch(error) {
-            Logger.critical('Failed to pull database schema: ' + error.message);
+            Logger.critical('Failed to pull database schema: '+error.message);
             return false;
         }
         let generateCommand = 'npx prisma generate';
@@ -43,33 +44,42 @@ class PrismaSchemaGenerator
         }
         Logger.info('Running prisma generate "'+generateCommand+'"...');
         try {
-            execSync(generateCommand, { stdio: 'inherit' });
+            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('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);
+            Logger.critical('Generate command failed: '+error.message);
             return false;
         }
         await this.waitForSchemaGeneration();
         return true;
     }
 
+    setDatabaseEnvironmentVariables()
+    {
+        let datasourceProvider = this.getDatasourceProvider();
+        process.env.RELDENS_DB_URL = this.buildConnectionString(datasourceProvider);
+        if(this.dataProxy){
+            process.env.RELDENS_DB_DIRECT_URL = this.buildDirectConnectionString(datasourceProvider);
+        }
+    }
+
     async waitForSchemaGeneration()
     {
-        let clientPath = this.clientOutputPath || 'node_modules/.prisma/client';
+        let clientPath = this.clientOutputPath || './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));
+                Logger.info('Awaiting on schema generation: '+clientIndexPath, (awaitTime/1000).toFixed(0));
                 if(FileHandler.exists(clientIndexPath)){
                     clearInterval(interval);
                     resolve();
@@ -98,11 +108,7 @@ class PrismaSchemaGenerator
     generateSchemaFile()
     {
         let datasourceProvider = this.getDatasourceProvider();
-        let schemaContent = this.buildSchemaContent(
-            datasourceProvider,
-            this.buildConnectionString(datasourceProvider),
-            this.buildDirectConnectionString(datasourceProvider)
-        );
+        let schemaContent = this.buildSchemaContent(datasourceProvider);
         FileHandler.writeFile(this.schemaFilePath, schemaContent);
         Logger.info('Generated Prisma schema file at: '+this.schemaFilePath);
     }
@@ -123,7 +129,7 @@ class PrismaSchemaGenerator
         if(this.dataProxy){
             datasourceProvider = 'prisma';
         }
-        return datasourceProvider + this.buildConnectionDataString();
+        return datasourceProvider+this.buildConnectionDataString();
     }
 
     buildDirectConnectionString(datasourceProvider)
@@ -131,47 +137,48 @@ class PrismaSchemaGenerator
         if(!this.dataProxy){
             return '';
         }
-        return datasourceProvider + this.buildConnectionDataString();
+        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 : '');
+        return '://'+this.config.user+':'+this.config.password
+            +'@'+this.config.host+':'+this.config.port
+            +'/'+this.config.database
+            +(this.dbParams ? '?'+this.dbParams : '');
     }
 
-    buildSchemaContent(datasourceProvider, connectionString, directConnectionString)
+    buildSchemaContent(datasourceProvider)
     {
-        return this.buildGeneratorBlock() + '\n\n'
-            + this.buildDatasourceBlock(datasourceProvider, connectionString, directConnectionString) + '\n';
+        return this.buildGeneratorBlock()+'\n\n'
+            +this.buildDatasourceBlock(datasourceProvider)+'\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';
+        let outputPath = this.clientOutputPath || './client';
+        if(!outputPath.startsWith('./')){
+            outputPath = './client';
         }
+        generatorContent += '  output = "'+outputPath+'"\n';
         if(0 < this.generateBinaryTargets.length){
-            generatorContent += '  binaryTargets = [' +
-                this.generateBinaryTargets.map(target => '"' + target + '"').join(', ')
-                + ']\n';
+            generatorContent += '  binaryTargets = ['
+                +this.generateBinaryTargets.map(target => '"'+target+'"').join(', ')
+                +']\n';
         }
         generatorContent += '}';
         return generatorContent;
     }
 
-    buildDatasourceBlock(datasourceProvider, connectionString, directConnectionString)
+    buildDatasourceBlock(datasourceProvider)
     {
         let datasourceContent = 'datasource db {\n';
-        datasourceContent += '  provider = "' + datasourceProvider + '"\n';
-        datasourceContent += '  url      = "' + connectionString + '"\n';
-        if('' !== directConnectionString){
-            datasourceContent += '  directUrl = "' + directConnectionString + '"\n';
+        datasourceContent += '  provider = "'+datasourceProvider+'"\n';
+        datasourceContent += '  url      = env("RELDENS_DB_URL")\n';
+        if(this.dataProxy){
+            datasourceContent += '  directUrl = env("RELDENS_DB_DIRECT_URL")\n';
         }
         datasourceContent += '}';
         return datasourceContent;

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

@@ -72,6 +72,11 @@ class PrismaTypeCaster
         return null === value || undefined === value || '' === value;
     }
 
+    isValidCastedValue(value)
+    {
+        return undefined !== value;
+    }
+
     castValue(value, fieldType, fieldName = null)
     {
         if('id' === fieldName){
@@ -226,6 +231,30 @@ class PrismaTypeCaster
         return String(value);
     }
 
+    normalizeReturnData(data)
+    {
+        if(null === data || undefined === data){
+            return data;
+        }
+        if('bigint' === typeof data){
+            return Number(data);
+        }
+        if(data instanceof Date){
+            return data;
+        }
+        if(sc.isArray(data)){
+            return data.map(item => this.normalizeReturnData(item));
+        }
+        if(sc.isObject(data)){
+            let result = {};
+            for(let key of Object.keys(data)){
+                result[key] = this.normalizeReturnData(data[key]);
+            }
+            return result;
+        }
+        return data;
+    }
+
 }
 
 module.exports.PrismaTypeCaster = PrismaTypeCaster;

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@reldens/storage",
     "scope": "@reldens",
-    "version": "0.81.0",
+    "version": "0.82.0",
     "description": "Reldens - Storage",
     "author": "Damian A. Pastorini",
     "license": "MIT",