@reldens/storage 0.79.0 → 0.81.0

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/lib/prisma/prisma-type-caster.js

@@ -0,0 +1,231 @@
+/**
+ *
+ * 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;
+    }
+
+    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);
+    }
+
+}
+
+module.exports.PrismaTypeCaster = PrismaTypeCaster;

package/package.json

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