@reldens/storage 0.80.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

@@ -0,0 +1,260 @@
+/**
+ *
+ * Reldens - PrismaTypeCaster
+ *
+ */
+
+const { Logger, sc } = require('@reldens/utils');
+const { Prisma } = require('@prisma/client');
+
+class PrismaTypeCaster
+{
+
+    constructor(props)
+    {
+        this.idFieldType = sc.get(props, 'idFieldType', 'String');
+        this.jsonFields = sc.get(props, 'jsonFields', new Set());
+        this.fieldTypes = sc.get(props, 'fieldTypes', {});
+        this.fieldDefaults = sc.get(props, 'fieldDefaults', {});
+        this.requiredFields = sc.get(props, 'requiredFields', []);
+        this.optionalFields = sc.get(props, 'optionalFields', []);
+        this.rawModel = sc.get(props, 'rawModel', false);
+    }
+
+    updateMetadata(metadata)
+    {
+        this.idFieldType = sc.get(metadata, 'idFieldType', this.idFieldType);
+        this.jsonFields = sc.get(metadata, 'jsonFields', this.jsonFields);
+        this.fieldTypes = sc.get(metadata, 'fieldTypes', this.fieldTypes);
+        this.fieldDefaults = sc.get(metadata, 'fieldDefaults', this.fieldDefaults);
+        this.requiredFields = sc.get(metadata, 'requiredFields', this.requiredFields);
+        this.optionalFields = sc.get(metadata, 'optionalFields', this.optionalFields);
+    }
+
+    isNumericFieldType(fieldType)
+    {
+        return ('Int' === fieldType || 'BigInt' === fieldType || 'Float' === fieldType || 'Decimal' === fieldType);
+    }
+
+    isBooleanFieldType(fieldType)
+    {
+        return 'Boolean' === fieldType;
+    }
+
+    isDateTimeFieldType(fieldType)
+    {
+        return 'DateTime' === fieldType || 'Date' === fieldType;
+    }
+
+    isJsonFieldType(fieldType)
+    {
+        return 'Json' === fieldType;
+    }
+
+    isJsonFieldByName(fieldName)
+    {
+        if(this.jsonFields.has(fieldName)){
+            return true;
+        }
+        if(!this.rawModel || !this.rawModel.properties){
+            return false;
+        }
+        return 'json' === sc.get(this.rawModel.properties[fieldName], 'dbType', '');
+    }
+
+    isStringFieldType(fieldType)
+    {
+        return 'String' === fieldType;
+    }
+
+    isNullOrEmpty(value)
+    {
+        return null === value || undefined === value || '' === value;
+    }
+
+    isValidCastedValue(value)
+    {
+        return undefined !== value;
+    }
+
+    castValue(value, fieldType, fieldName = null)
+    {
+        if('id' === fieldName){
+            return this.castToIdType(value);
+        }
+        if(this.isNullOrEmpty(value)){
+            if(sc.hasOwn(this.fieldDefaults, fieldName)){
+                return undefined;
+            }
+            if(-1 !== this.optionalFields.indexOf(fieldName)){
+                return null;
+            }
+            if(-1 !== this.requiredFields.indexOf(fieldName)){
+                Logger.warning('Required field '+fieldName+' cannot be null or empty');
+                return undefined;
+            }
+            return null;
+        }
+        if(this.isJsonFieldByName(fieldName)){
+            return this.castToJsonType(value);
+        }
+        if(this.isNumericFieldType(fieldType)){
+            return this.castToNumericType(value, fieldType);
+        }
+        if(this.isBooleanFieldType(fieldType)){
+            return this.castToBooleanType(value);
+        }
+        if(this.isDateTimeFieldType(fieldType)){
+            return this.castToDateType(value);
+        }
+        if(this.isStringFieldType(fieldType)){
+            return this.castToStringType(value);
+        }
+        return value;
+    }
+
+    castToIdType(value)
+    {
+        if(this.isNullOrEmpty(value)){
+            return value;
+        }
+        if(this.isNumericFieldType(this.idFieldType)){
+            let numeric = Number(value);
+            if(!isNaN(numeric)){
+                return ('Int' === this.idFieldType || 'BigInt' === this.idFieldType) ? Math.floor(numeric) : numeric;
+            }
+            Logger.warning('Cannot cast non-numeric value "'+value+'" to ID type '+this.idFieldType);
+            return null;
+        }
+        return String(value);
+    }
+
+    castToNumericType(value, fieldType)
+    {
+        if(this.isNullOrEmpty(value)){
+            return null;
+        }
+        let numericValue = Number(value);
+        if(isNaN(numericValue)){
+            Logger.warning('Cannot convert value to numeric: '+value);
+            return null;
+        }
+        if('Int' === fieldType || 'BigInt' === fieldType){
+            return Math.floor(numericValue);
+        }
+        return numericValue;
+    }
+
+    castToBooleanType(value)
+    {
+        if(this.isNullOrEmpty(value)){
+            return null;
+        }
+        if('boolean' === typeof value){
+            return value;
+        }
+        if('number' === typeof value){
+            return 0 !== value;
+        }
+        if('string' === typeof value){
+            let lowerValue = value.toLowerCase();
+            if('true' === lowerValue || '1' === lowerValue || 'yes' === lowerValue){
+                return true;
+            }
+            if('false' === lowerValue || '0' === lowerValue || 'no' === lowerValue){
+                return false;
+            }
+        }
+        return Boolean(value);
+    }
+
+    castToDateType(dateValue)
+    {
+        if(dateValue instanceof Date){
+            return dateValue;
+        }
+        if(this.isNullOrEmpty(dateValue)){
+            return null;
+        }
+        let dateString = String(dateValue);
+        if(dateString.match(/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/)){
+            return new Date(dateString.replace(' ', 'T')+'Z');
+        }
+        if(dateString.match(/^\d{4}-\d{2}-\d{2}$/)){
+            return new Date(dateString+'T00:00:00Z');
+        }
+        try {
+            let parsedDate = new Date(dateString);
+            if(isNaN(parsedDate.getTime())){
+                Logger.warning('Invalid date value: '+dateString);
+                return null;
+            }
+            return parsedDate;
+        } catch(error) {
+            Logger.warning('Failed to convert date value: '+dateString);
+            return null;
+        }
+    }
+
+    castToJsonType(value)
+    {
+        if(this.isNullOrEmpty(value)){
+            return Prisma.DbNull;
+        }
+        if('object' === typeof value){
+            return value;
+        }
+        if('string' === typeof value){
+            if(value.startsWith('%') && value.endsWith('%')){
+                return value;
+            }
+            try {
+                return JSON.parse(value);
+            } catch(error) {
+                return value;
+            }
+        }
+        return value;
+    }
+
+    castToStringType(value)
+    {
+        if(null === value || undefined === value){
+            return null;
+        }
+        if('string' === typeof value){
+            if('null' === value){
+                return null;
+            }
+            return value;
+        }
+        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.80.0",
+    "version": "0.82.0",
     "description": "Reldens - Storage",
     "author": "Damian A. Pastorini",
     "license": "MIT",