@reldens/storage 0.33.0 → 0.35.0

package/README.md

@@ -3,7 +3,7 @@
 # Reldens - Storage
 
 ## About this package
-This package provides standardized database drivers for Reldens projects. 
+This package provides standardized database drivers for Reldens projects.
 It ensures consistent data access methods across different database types and ORM implementations.
 
 ## Features
@@ -11,6 +11,7 @@ It ensures consistent data access methods across different database types and OR
 ### ORM Support
 - **Objection JS** (via Knex) - For SQL databases (recommended)
 - **Mikro-ORM** - For MongoDB/NoSQL support
+- **Prisma** - Modern database toolkit
 
 ### Entity Management
 - Standardized CRUD operations
@@ -35,6 +36,20 @@ Options:
 - `--client` - Database client (mysql|mysql2|mongodb)
 - `--path` - Project path for output files
 
+Generate Prisma schema for Prisma database:
+```bash
+npx reldens-storage-prisma --user=dbuser --pass=dbpass --database=dbname
+```
+
+Options:
+- `--user` - Database username
+- `--pass` - Database password
+- `--host` - Database host (default: localhost)
+- `--port` - Database port (default: 3306)
+- `--database` - Database name
+- `--client` - Database client (mysql|mysql2|postgresql|mongodb)
+- `--path` - Project path for output files
+
 ## Usage Examples
 
 ### SQL with Objection JS
@@ -77,6 +92,35 @@ await server.connect();
 const entities = server.generateEntities();
 ```
 
+### Using Prisma
+
+First, generate your Prisma schema:
+```bash
+npx reldens-storage-prisma --user=dbuser --pass=dbpass --database=dbname
+```
+
+Then, use the PrismaDataServer in your code:
+```javascript
+const { PrismaDataServer } = require('@reldens/storage');
+
+const server = new PrismaDataServer({
+    client: 'mysql2',
+    config: {
+        user: 'reldens',
+        password: 'reldens',
+        database: 'reldens',
+        host: 'localhost',
+        port: 3306
+    },
+    rawEntities: yourEntities
+});
+
+await server.connect();
+const entities = server.generateEntities();
+```
+
+Note: The PrismaDataServer requires the Prisma schema to be generated first. Make sure to run the `reldens-storage-prisma` command before using PrismaDataServer.
+
 ## Custom Drivers
 
 You can create custom storage drivers by extending the base classes:
@@ -102,4 +146,3 @@ const appServer = new ServerManager(serverConfig, eventsManager, customDriver);
 ### [Reldens](https://www.reldens.com/ "Reldens")
 
 ##### [By DwDeveloper](https://www.dwdeveloper.com/ "DwDeveloper")
-

package/bin/generate-prisma-schema.js

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+
+/**
+ *
+ * Reldens - Generate Prisma Schema CLI
+ *
+ */
+
+const { PrismaSchemaGenerator } = require('../lib/prisma/prisma-schema-generator');
+const { Logger } = require('@reldens/utils');
+
+let args = process.argv.slice(2);
+
+let connectionData = {
+    client: 'mysql2',
+    config: {
+        user: '',
+        password: '',
+        host: 'localhost',
+        database: '',
+        port: 3306
+    }
+};
+
+let projectPath = process.cwd();
+for(let i = 0; i < args.length; i++){
+    let arg = args[i];
+    if(!arg.startsWith('--')){
+        continue;
+    }
+    let [key, value] = arg.substring(2).split('=');
+    if(!key || !value){
+        continue;
+    }
+    if('pass' === key){
+        connectionData.config.password = value;
+        continue;
+    }
+    if('path' === key){
+        projectPath = value;
+        continue;
+    }
+    if('user' === key){
+        connectionData.config.user = value;
+        continue;
+    }
+    if('database' === key){
+        connectionData.config.database = value;
+        continue;
+    }
+    if('host' === key){
+        connectionData.config.host = value;
+        continue;
+    }
+    if('port' === key){
+        connectionData.config.port = value;
+        continue;
+    }
+    if('client' === key){
+        connectionData.client = value;
+    }
+}
+
+if(!connectionData.config.user || !connectionData.config.database){
+    Logger.error('Required parameters missing.');
+    Logger.error(
+        'Usage:',
+        'npx reldens-storage generatePrismaSchema --user=[db-username] --pass=[db-password] --host=[db-host] --database=[db-name] --client=[db-client] --path=[project-path]'
+    );
+    process.exit();
+}
+
+let generator = new PrismaSchemaGenerator({...connectionData, prismaSchemaPath: projectPath+'/prisma'});
+
+generator.generate().then((success) => {
+    if(!success){
+        Logger.error('Prisma schema generation failed.');
+        process.exit();
+    }
+    Logger.info('Prisma schema generation completed successfully!');
+    process.exit();
+}).catch((error) => {
+    Logger.error('Error during Prisma schema generation: '+error.message);
+    process.exit();
+});

package/bin/reldens-storage.js

@@ -65,7 +65,7 @@ let generator = new EntitiesGenerator({connectionData, projectPath});
 generator.generate().then((success) => {
     if(!success){
         Logger.error('Entity generation failed.');
-        return;
+        process.exit();
     }
     Logger.info('Entity generation completed successfully!');
     process.exit();

package/index.js

@@ -16,6 +16,9 @@ const { EntitiesGenerator } = require('./lib/entities-generator');
 const { EntityProperties } = require('./lib/entity-properties');
 const { TypeMapper } = require('./lib/type-mapper');
 const { MySQLTablesProvider } = require('./lib/mysql-tables-provider');
+const { PrismaDriver } = require('./lib/prisma/prisma-driver');
+const { PrismaDataServer } = require('./lib/prisma/prisma-data-server');
+const { PrismaSchemaGenerator } = require('./lib/prisma/prisma-schema-generator');
 
 module.exports = {
     // base:
@@ -23,7 +26,8 @@ module.exports = {
     BaseDriver,
     DriversMap: {
         'objection-js': ObjectionJsDataServer,
-        'mikro-orm': MikroOrmDataServer
+        'mikro-orm': MikroOrmDataServer,
+        'prisma': PrismaDataServer
     },
     // objection-js:
     ObjectionJsDataServer,
@@ -33,6 +37,10 @@ module.exports = {
     MikroOrmCore,
     MikroOrmDataServer,
     MikroOrmDriver,
+    // prisma:
+    PrismaDataServer,
+    PrismaDriver,
+    PrismaSchemaGenerator,
     // entities:
     EntitiesGenerator,
     EntityProperties,

package/lib/entities-generator.js

@@ -8,6 +8,7 @@ const { FileHandler } = require('@reldens/server-utils');
 const { ErrorManager, Logger, sc } = require('@reldens/utils');
 const { ObjectionJsDataServer } = require('./objection-js/objection-js-data-server');
 const { MikroOrmDataServer } = require('./mikro-orm/mikro-orm-data-server');
+const { PrismaDataServer } = require('./prisma/prisma-data-server');
 const { TypeMapper } = require('./type-mapper');
 
 class EntitiesGenerator
@@ -17,8 +18,9 @@ class EntitiesGenerator
     {
         this.templatesFolderPath = FileHandler.joinPaths(__dirname, 'entity-templates');
         this.templates = {
-            'objection-js': FileHandler.joinPaths(this.templatesFolderPath, 'objection-js-entity.template'),
-            'mikro-orm': FileHandler.joinPaths(this.templatesFolderPath, 'mikro-orm-entity.template'),
+            'objection-js': FileHandler.joinPaths(this.templatesFolderPath, 'objection-js-model.template'),
+            'mikro-orm': FileHandler.joinPaths(this.templatesFolderPath, 'mikro-orm-model.template'),
+            'prisma': FileHandler.joinPaths(this.templatesFolderPath, 'prisma-model.template'),
             'entity': FileHandler.joinPaths(this.templatesFolderPath, 'entity.template'),
             'entities-config': FileHandler.joinPaths(this.templatesFolderPath, 'entities-config.template'),
             'entities-translations': FileHandler.joinPaths(this.templatesFolderPath, 'entities-translations.template'),
@@ -32,7 +34,8 @@ class EntitiesGenerator
         this.entitiesTranslationsPath = FileHandler.joinPaths(this.generationFolder, 'entities-translations.js');
         this.driverMap = {
             'objection-js': ObjectionJsDataServer,
-            'mikro-orm': MikroOrmDataServer
+            'mikro-orm': MikroOrmDataServer,
+            'prisma': PrismaDataServer
         };
         this.server = sc.get(props, 'server', false);
         this.connectionData = sc.get(props, 'connectionData', false);
@@ -324,7 +327,7 @@ class EntitiesGenerator
         let entityPropertiesDefinition = this.getEntityPropertiesDefinition(tableData.columns, driverKey);
         let replacements = {
             modelClassName,
-            tableName,
+            tableName: driverKey === 'prisma' ? tableName.toLowerCase() : tableName,
             modelPropertiesList,
             modelPropertiesConstructor,
             modelRelations,
@@ -348,25 +351,43 @@ class EntitiesGenerator
 
     getEntityPropertiesDefinition(columns, driverKey)
     {
-        if('mikro-orm' !== driverKey){
-            return '';
-        }
-        let entityProps = [];
-        for(let columnName in columns){
-            let column = columns[columnName];
-            let isPrimary = 'PRI' === column.key;
-            let type = TypeMapper.mapDbTypeToJsType(column.type);
-            let propDef = columnName+': { type: \''+type+'\'';
-            if(isPrimary){
-                propDef += ', primary: true';
+        if('mikro-orm' === driverKey){
+            let entityProps = [];
+            for(let columnName in columns){
+                let column = columns[columnName];
+                let isPrimary = 'PRI' === column.key;
+                let type = TypeMapper.mapDbTypeToJsType(column.type);
+                let propDef = columnName+': { type: \''+type+'\'';
+                if(isPrimary){
+                    propDef += ', primary: true';
+                }
+                if(column.nullable){
+                    propDef += ', nullable: true';
+                }
+                propDef += ' }';
+                entityProps.push(propDef);
             }
-            if(column.nullable){
-                propDef += ', nullable: true';
+            return entityProps.join(',\n        ');
+        }
+        if('prisma' === driverKey){
+            let prismaProps = [];
+            for(let columnName in columns){
+                let column = columns[columnName];
+                let prismaType = TypeMapper.mapDbTypeToPrismaType(column.type);
+                let isPrimary = 'PRI' === column.key;
+                let propDef = columnName+': {\n            type: \''+prismaType+'\'';
+                if(isPrimary){
+                    propDef += ',\n            id: true';
+                }
+                if(column.nullable){
+                    propDef += ',\n            optional: true';
+                }
+                propDef += '\n        }';
+                prismaProps.push(propDef);
             }
-            propDef += ' }';
-            entityProps.push(propDef);
+            return prismaProps.join(',\n        ');
         }
-        return entityProps.join(',\n        ');
+        return '';
     }
 
     generateEntitiesConfigFile()

package/lib/entity-templates/prisma-model.template

@@ -0,0 +1,32 @@
+/**
+ *
+ * Reldens - {{modelClassName}}
+ *
+ */
+
+const { PrismaClient } = require('@prisma/client');
+
+class {{modelClassName}}
+{
+
+    constructor({{modelPropertiesList}})
+    {
+        {{modelPropertiesConstructor}}
+    }
+
+    static get client()
+    {
+        if(!this._client){
+            this._client = new PrismaClient();
+        }
+        return this._client;
+    }
+
+    static get model()
+    {
+        return this.client['{{tableName}}'];
+    }
+    {{modelRelations}}
+}
+
+module.exports.{{modelClassName}} = {{modelClassName}};

package/lib/mikro-orm/mikro-orm-driver.js

@@ -123,7 +123,7 @@ class MikroOrmDriver extends BaseDriver
         if (!entries){
             return false;
         }
-        for(let entry of Object.keys(entries)){
+        for(let entry of entries){
             await this.repository.nativeDelete(entry.id);
         }
     }

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

@@ -0,0 +1,200 @@
+/**
+ *
+ * Reldens - PrismaDataServer
+ *
+ */
+
+const { BaseDataServer } = require('../base-data-server');
+const { PrismaDriver } = require('./prisma-driver');
+const { MySQLTablesProvider } = require('../mysql-tables-provider');
+const { ErrorManager, Logger, sc } = require('@reldens/utils');
+
+class PrismaDataServer extends BaseDataServer
+{
+
+    constructor(props)
+    {
+        super(props);
+        this.prisma = false;
+    }
+
+    async connect()
+    {
+        if(this.initialized){
+            return this.initialized;
+        }
+        try {
+            let { PrismaClient } = require('@prisma/client');
+            this.prisma = new PrismaClient({
+                log: this.debug ? ['query', 'info', 'warn', 'error'] : ['error']
+            });
+            await this.prisma.$connect();
+            this.initialized = Date.now();
+            return this.initialized;
+        } catch(error) {
+            Logger.critical('Connection failed, Prisma error: '+error.message);
+        }
+        return false;
+    }
+
+    generateEntities()
+    {
+        if(!this.initialized){
+            Logger.warning('Connection was not initialized, please use the connect method first.');
+            return {};
+        }
+        if(!this.rawEntities){
+            Logger.warning('Empty raw entities array, none entities generated.');
+            return {};
+        }
+        this.entities = {};
+        for(let i of Object.keys(this.rawEntities)){
+            let rawEntity = this.rawEntities[i];
+            let modelName = i.toLowerCase();
+            if(!this.prisma[modelName]){
+                Logger.critical('Invalid raw entity "'+i+'". No matching Prisma model found.');
+                continue;
+            }
+            this.entities[i] = new PrismaDriver({
+                rawModel: rawEntity,
+                id: i,
+                name: i,
+                config: this.config,
+                prisma: this.prisma,
+                model: this.prisma[modelName],
+                server: this
+            });
+        }
+        this.entityManager.setEntities(this.entities);
+        return this.entities;
+    }
+
+    name()
+    {
+        return this.name || 'Prisma Data Server Driver';
+    }
+
+    async rawQuery(content)
+    {
+        try {
+            let statements = this.splitSqlStatements(content);
+            let results = [];
+            for(let statement of statements){
+                let cleanStatement = statement.trim();
+                if('' === cleanStatement){
+                    continue;
+                }
+                try {
+                    let queryResult = await this.prisma.$executeRawUnsafe(cleanStatement);
+                    results.push(queryResult);
+                } catch(stmtError) {
+                    Logger.error('Statement "'+cleanStatement+'" execution failed: '+stmtError.message);
+                    return false;
+                }
+            }
+            if(0 === results.length){
+                return false;
+            }
+            return 1 === results.length ? results[0] : results;
+        } catch(error) {
+            Logger.error('Raw query failed: '+error.message);
+            return false;
+        }
+    }
+
+    splitSqlStatements(sqlContent)
+    {
+        let statements = [];
+        let currentStatement = '';
+        let inQuote = false;
+        let quoteChar = '';
+        let inComment = false;
+        let commentType = '';
+        for(let i = 0; i < sqlContent.length; i++){
+            let char = sqlContent.charAt(i);
+            let nextChar = i < sqlContent.length - 1 ? sqlContent.charAt(i + 1) : '';
+            if(inComment){
+                let shouldEndComment = false;
+                if('*' === commentType && '*' === char && '/' === nextChar){
+                    shouldEndComment = true;
+                    i++;
+                }
+                if('-' === commentType && '\n' === char){
+                    shouldEndComment = true;
+                }
+                if(shouldEndComment){
+                    inComment = false;
+                }
+                continue;
+            }
+            let shouldStartComment = this.shouldStartComment(char, nextChar, inQuote);
+            if(shouldStartComment){
+                inComment = true;
+                commentType = '/' === char ? '*' : '-';
+                continue;
+            }
+            let isQuoteChar = ('"' === char || '\'' === char || '`' === char);
+            let isEscaped = (i > 0 && '\\' === sqlContent.charAt(i-1));
+            if(isQuoteChar && !isEscaped){
+                if(!inQuote){
+                    inQuote = true;
+                    quoteChar = char;
+                    currentStatement += char;
+                    continue;
+                }
+                let shouldEndQuote = quoteChar === char;
+                if(shouldEndQuote){
+                    inQuote = false;
+                }
+                currentStatement += char;
+                continue;
+            }
+            let shouldEndStatement = (';' === char && !inQuote);
+            if(shouldEndStatement){
+                statements.push(currentStatement);
+                currentStatement = '';
+                continue;
+            }
+            currentStatement += char;
+        }
+        let hasRemainingStatement = '' !== currentStatement.trim();
+        if(hasRemainingStatement){
+            statements.push(currentStatement);
+        }
+        return statements;
+    }
+
+    shouldStartComment(char, nextChar, inQuote)
+    {
+        if(inQuote){
+            return false;
+        }
+        let isBlockComment = ('/' === char && '*' === nextChar);
+        let isLineComment = ('-' === char && '-' === nextChar);
+        return isBlockComment || isLineComment;
+    }
+
+    async fetchEntitiesFromDatabase()
+    {
+        if(!this.initialized){
+            Logger.error('Connection was not initialized, please use the connect method first.');
+            return false;
+        }
+        try {
+            return await MySQLTablesProvider.fetchTables(this);
+        } catch(error) {
+            ErrorManager.error('Failed to fetch tables from database: '+error.message);
+        }
+    }
+
+    async disconnect()
+    {
+        if(this.prisma){
+            await this.prisma.$disconnect();
+        }
+        this.initialized = false;
+    }
+
+}
+
+module.exports.PrismaDataServer = PrismaDataServer;

package/lib/prisma/prisma-driver.js

@@ -0,0 +1,523 @@
+/**
+ *
+ * Reldens - PrismaDriver
+ *
+ */
+
+const { BaseDriver } = require('../base-driver');
+const { ErrorManager, Logger, sc } = require('@reldens/utils');
+
+class PrismaDriver extends BaseDriver
+{
+
+    constructor(props)
+    {
+        super(props);
+        if(!props.prisma){
+            ErrorManager.error('Missing Prisma client on Prisma driver.');
+        }
+        if(!props.model){
+            ErrorManager.error('Missing Prisma model on Prisma driver.');
+        }
+        if(!props.server){
+            ErrorManager.error('Missing Server Driver on Prisma driver.');
+        }
+        this.prisma = props.prisma;
+        this.model = props.model;
+        this.server = props.server;
+        this.requiredFields = [];
+        this.fieldTypes = {};
+        this.initFieldMetadata();
+    }
+
+    initFieldMetadata()
+    {
+        try {
+            let dmmf = this.prisma._baseDmmf;
+            if(!dmmf){
+                return;
+            }
+            let modelInfo = dmmf.modelMap[this.tableName().toLowerCase()];
+            if(!modelInfo){
+                return;
+            }
+            for(let field of modelInfo.fields){
+                if(field.isRequired && !field.hasDefaultValue && !field.isId){
+                    this.requiredFields.push(field.name);
+                }
+                this.fieldTypes[field.name] = field.type;
+            }
+        } catch(error) {
+            Logger.warning('Could not initialize field metadata: '+error.message);
+        }
+    }
+
+    databaseName()
+    {
+        return this.config.database || '';
+    }
+
+    id()
+    {
+        return this.name || '';
+    }
+
+    name()
+    {
+        return this.rawName || '';
+    }
+
+    tableName()
+    {
+        return this.model._name || '';
+    }
+
+    property(propertyName)
+    {
+        return this.rawModel[propertyName] || null;
+    }
+
+    prepareData(params)
+    {
+        let data = {...params};
+        for(let key in data){
+            if('status' === key && 'number' === typeof data[key]){
+                data[key] = String(data[key]);
+            }
+        }
+        return data;
+    }
+
+    ensureRequiredFields(data)
+    {
+        let missingFields = [];
+        for(let field of this.requiredFields){
+            if(!sc.hasOwn(data, field)){
+                missingFields.push(field);
+            }
+        }
+        if(0 < missingFields.length){
+            Logger.warning('Missing required fields for '+this.tableName()+': '+missingFields.join(', '));
+        }
+        return data;
+    }
+
+    async create(params)
+    {
+        try {
+            let preparedData = this.prepareData(params);
+            this.ensureRequiredFields(preparedData);
+            return await this.model.create({
+                data: preparedData
+            });
+        } catch(error) {
+            Logger.error('Create error: '+error.message);
+            return false;
+        }
+    }
+
+    async createWithRelations(params, relations)
+    {
+        try {
+            let preparedData = this.prepareData(params);
+            this.ensureRequiredFields(preparedData);
+            let createData = {data: preparedData};
+            if(sc.isArray(relations) && 0 < relations.length){
+                for(let relation of relations){
+                    if(!sc.hasOwn(params, relation)){
+                        continue;
+                    }
+                    let relationData = params[relation];
+                    if(sc.isArray(relationData)){
+                        createData.data[relation] = {
+                            connect: relationData.map(item => ({id: item.id}))
+                        };
+                        continue;
+                    }
+                    createData.data[relation] = {
+                        connect: {id: relationData.id}
+                    };
+                }
+            }
+            return await this.model.create(createData);
+        } catch(error) {
+            Logger.error('Create with relations error: '+error.message);
+            return false;
+        }
+    }
+
+    async update(filters, updatePatch)
+    {
+        try {
+            let preparedData = this.prepareData(updatePatch);
+            return await this.model.updateMany({
+                where: filters,
+                data: preparedData
+            });
+        } catch(error) {
+            Logger.error('Update error: '+error.message);
+            return false;
+        }
+    }
+
+    async updateBy(field, fieldValue, updatePatch, operator = null)
+    {
+        let filter = this.createSingleFilter(field, fieldValue, operator);
+        try {
+            let preparedData = this.prepareData(updatePatch);
+            return await this.model.updateMany({
+                where: filter,
+                data: preparedData
+            });
+        } catch(error) {
+            Logger.error('Update by error: '+error.message);
+            return false;
+        }
+    }
+
+    async updateById(id, params)
+    {
+        try {
+            let found = await this.loadById(id);
+            if(!found){
+                return false;
+            }
+            let preparedData = this.prepareData(params);
+            return await this.model.update({
+                where: {id},
+                data: preparedData
+            });
+        } catch(error) {
+            Logger.error('Update by ID error: '+error.message);
+            return false;
+        }
+    }
+
+    async upsert(params, filters)
+    {
+        try {
+            let preparedData = this.prepareData(params);
+            let existing = false;
+            if(params.id){
+                existing = await this.loadById(params.id);
+                if(existing){
+                    let patch = Object.assign({}, preparedData);
+                    delete patch.id;
+                    return await this.model.update({
+                        where: {id: params.id},
+                        data: patch
+                    });
+                }
+            }
+            if(filters){
+                let existing = await this.loadOne(filters);
+                if(existing){
+                    return await this.model.update({
+                        where: {id: existing.id},
+                        data: preparedData
+                    });
+                }
+            }
+            return await this.create(preparedData);
+        } catch(error) {
+            Logger.error('Upsert error: '+error.message);
+            return false;
+        }
+    }
+
+    async delete(filters = {})
+    {
+        try {
+            return await this.model.deleteMany({
+                where: filters
+            });
+        } catch(error) {
+            Logger.error('Delete error: '+error.message);
+            return false;
+        }
+    }
+
+    async deleteById(id)
+    {
+        try {
+            let found = await this.loadById(id);
+            if(!found){
+                return false;
+            }
+            return await this.model.delete({
+                where: {id}
+            });
+        } catch(error) {
+            Logger.error('Delete by ID error: '+error.message);
+            return false;
+        }
+    }
+
+    async count(filters)
+    {
+        try {
+            return await this.model.count({
+                where: filters
+            });
+        } catch(error) {
+            Logger.error('Count error: '+error.message);
+            return 0;
+        }
+    }
+
+    async countWithRelations(filters, relations)
+    {
+        try {
+            let query = {
+                where: filters
+            };
+            if(sc.isArray(relations) && 0 < relations.length){
+                query.include = this.buildIncludeObject(relations);
+            }
+            return await this.model.count(query);
+        } catch(error) {
+            Logger.error('Count with relations error: '+error.message);
+            return 0;
+        }
+    }
+
+    async loadAll()
+    {
+        try {
+            return await this.model.findMany(this.buildQueryOptions());
+        } catch(error) {
+            Logger.error('Load all error: '+error.message);
+            return [];
+        }
+    }
+
+    async loadAllWithRelations(relations)
+    {
+        try {
+            let query = this.buildQueryOptions();
+            if(sc.isArray(relations) && 0 < relations.length){
+                query.include = this.buildIncludeObject(relations);
+            }
+            return await this.model.findMany(query);
+        } catch(error) {
+            Logger.error('Load all with relations error: '+error.message);
+            return [];
+        }
+    }
+
+    async load(filters)
+    {
+        try {
+            let query = this.buildQueryOptions();
+            query.where = filters;
+            return await this.model.findMany(query);
+        } catch(error) {
+            Logger.error('Load error: '+error.message);
+            return [];
+        }
+    }
+
+    async loadWithRelations(filters, relations)
+    {
+        try {
+            let query = this.buildQueryOptions();
+            query.where = filters;
+            if(sc.isArray(relations) && 0 < relations.length){
+                query.include = this.buildIncludeObject(relations);
+            }
+            return await this.model.findMany(query);
+        } catch(error) {
+            Logger.error('Load with relations error: '+error.message);
+            return [];
+        }
+    }
+
+    async loadBy(field, fieldValue, operator = null)
+    {
+        try {
+            let filter = this.createSingleFilter(field, fieldValue, operator);
+            let query = this.buildQueryOptions();
+            query.where = filter;
+            return await this.model.findMany(query);
+        } catch(error) {
+            Logger.error('Load by error: '+error.message);
+            return [];
+        }
+    }
+
+    async loadByWithRelations(field, fieldValue, relations, operator = null)
+    {
+        try {
+            let filter = this.createSingleFilter(field, fieldValue, operator);
+            let query = this.buildQueryOptions();
+            query.where = filter;
+            if(sc.isArray(relations) && 0 < relations.length){
+                query.include = this.buildIncludeObject(relations);
+            }
+            return await this.model.findMany(query);
+        } catch(error) {
+            Logger.error('Load by with relations error: '+error.message);
+            return [];
+        }
+    }
+
+    async loadById(id)
+    {
+        try {
+            return await this.model.findUnique({
+                where: {id}
+            });
+        } catch(error) {
+            Logger.error('Load by ID error: '+error.message);
+            return null;
+        }
+    }
+
+    async loadByIdWithRelations(id, relations)
+    {
+        try {
+            let query = {
+                where: {id}
+            };
+            if(sc.isArray(relations) && 0 < relations.length){
+                query.include = this.buildIncludeObject(relations);
+            }
+            return await this.model.findUnique(query);
+        } catch(error) {
+            Logger.error('Load by ID with relations error: '+error.message);
+            return null;
+        }
+    }
+
+    async loadByIds(ids)
+    {
+        try {
+            return await this.model.findMany({
+                where: {
+                    id: {in: ids}
+                }
+            });
+        } catch(error) {
+            Logger.error('Load by IDs error: '+error.message);
+            return [];
+        }
+    }
+
+    async loadOne(filters)
+    {
+        try {
+            let query = this.buildQueryOptions(false);
+            query.where = filters;
+            return await this.model.findFirst(query);
+        } catch(error) {
+            Logger.error('Load one error: '+error.message);
+            return null;
+        }
+    }
+
+    async loadOneWithRelations(filters, relations)
+    {
+        try {
+            let query = this.buildQueryOptions(false);
+            query.where = filters;
+            if(sc.isArray(relations) && 0 < relations.length){
+                query.include = this.buildIncludeObject(relations);
+            }
+            return await this.model.findFirst(query);
+        } catch(error) {
+            Logger.error('Load one with relations error: '+error.message);
+            return null;
+        }
+    }
+
+    async loadOneBy(field, fieldValue, operator = null)
+    {
+        try {
+            let filter = this.createSingleFilter(field, fieldValue, operator);
+            let query = this.buildQueryOptions(false);
+            query.where = filter;
+            return await this.model.findFirst(query);
+        } catch(error) {
+            Logger.error('Load one by error: '+error.message);
+            return null;
+        }
+    }
+
+    async loadOneByWithRelations(field, fieldValue, relations, operator = null)
+    {
+        try {
+            let filter = this.createSingleFilter(field, fieldValue, operator);
+            let query = this.buildQueryOptions(false);
+            query.where = filter;
+            if(sc.isArray(relations) && 0 < relations.length){
+                query.include = this.buildIncludeObject(relations);
+            }
+            return await this.model.findFirst(query);
+        } catch(error) {
+            Logger.error('Load one by with relations error: '+error.message);
+            return null;
+        }
+    }
+
+    buildQueryOptions(useLimit = true)
+    {
+        let queryOptions = {};
+        if(0 < this.select.length){
+            queryOptions.select = {};
+            for(let field of this.select){
+                queryOptions.select[field] = true;
+            }
+        }
+        if(useLimit && 0 !== this.limit){
+            queryOptions.take = this.limit;
+        }
+        if(0 !== this.offset){
+            queryOptions.skip = this.offset;
+        }
+        if(false !== this.sortBy && false !== this.sortDirection){
+            queryOptions.orderBy = {
+                [this.sortBy]: this.sortDirection.toLowerCase()
+            };
+        }
+        return queryOptions;
+    }
+
+    createSingleFilter(field, fieldValue, operator = null)
+    {
+        let filter = {};
+        if(null === operator){
+            filter[field] = fieldValue;
+            return filter;
+        }
+        filter[field] = this.applyOperator(fieldValue, operator);
+        return filter;
+    }
+
+    applyOperator(value, operator)
+    {
+        let operatorsMap = {
+            '=': value,
+            '!=': {not: value},
+            '>': {gt: value},
+            '>=': {gte: value},
+            '<': {lt: value},
+            '<=': {lte: value},
+            'LIKE': {contains: value},
+            'IN': {in: value},
+            'NOT IN': {notIn: value}
+        };
+        return operatorsMap[operator] || value;
+    }
+
+    buildIncludeObject(relations)
+    {
+        let include = {};
+        for(let relation of relations){
+            include[relation] = true;
+        }
+        return include;
+    }
+
+}
+
+module.exports.PrismaDriver = PrismaDriver;

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

@@ -0,0 +1,69 @@
+/**
+ *
+ * Reldens - PrismaSchemaGenerator
+ *
+ */
+
+const { ErrorManager, Logger, sc } = require('@reldens/utils');
+const { FileHandler } = require('@reldens/server-utils');
+const { execSync } = require('child_process');
+
+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.prismaSchemaPath = sc.get(props, 'prismaSchemaPath', FileHandler.joinPaths(process.cwd(), 'prisma'));
+        this.schemaFilePath = FileHandler.joinPaths(this.prismaSchemaPath, 'schema.prisma');
+    }
+
+    async generate()
+    {
+        try {
+            FileHandler.createFolder(this.prismaSchemaPath, { recursive: true });
+            this.generateSchemaFile();
+            Logger.info('Running prisma introspect "npx prisma db pull"...');
+            execSync('npx prisma db pull', { stdio: 'inherit' });
+            Logger.info('Running prisma generate "npx prisma generate"...');
+            execSync('npx prisma generate', { stdio: 'inherit' });
+            return true;
+        } catch(error) {
+            ErrorManager.error('Failed to generate Prisma schema. '+error.message);
+            return false;
+        }
+    }
+
+    generateSchemaFile()
+    {
+        let datasourceProvider = 'mysql';
+        if('postgresql' === this.client || 'postgres' === this.client){
+            datasourceProvider = 'postgresql';
+        }
+        if('mongodb' === this.client){
+            datasourceProvider = 'mongodb';
+        }
+        let connectionString = datasourceProvider + '://'
+            + this.config.user + ':' + this.config.password
+            + '@' + this.config.host + ':' + this.config.port + '/'
+            + this.config.database;
+        let schemaContent = `
+generator client {
+  provider = "prisma-client-js"
+  output   = "../node_modules/.prisma/client"
+}
+
+datasource db {
+  provider = "${datasourceProvider}"
+  url      = "${connectionString}"
+}
+`;
+        FileHandler.writeFile(this.schemaFilePath, schemaContent);
+        Logger.info('Generated Prisma schema file at: '+this.schemaFilePath);
+    }
+
+}
+
+module.exports.PrismaSchemaGenerator = PrismaSchemaGenerator;

package/lib/type-mapper.js

@@ -44,6 +44,43 @@ class TypeMapper
         return typeMap[dbType.toLowerCase()];
     }
 
+    mapDbTypeToPrismaType(dbType)
+    {
+        let typeMap = {
+            'int': 'Int',
+            'integer': 'Int',
+            'tinyint': 'Int',
+            'smallint': 'Int',
+            'mediumint': 'Int',
+            'bigint': 'BigInt',
+            'decimal': 'Decimal',
+            'float': 'Float',
+            'double': 'Float',
+            'varchar': 'String',
+            'char': 'String',
+            'text': 'String',
+            'tinytext': 'String',
+            'mediumtext': 'String',
+            'longtext': 'String',
+            'date': 'DateTime',
+            'datetime': 'DateTime',
+            'timestamp': 'DateTime',
+            'time': 'String',
+            'year': 'Int',
+            'boolean': 'Boolean',
+            'bool': 'Boolean',
+            'bit': 'Boolean',
+            'json': 'Json',
+            'binary': 'Bytes',
+            'varbinary': 'Bytes',
+            'blob': 'Bytes',
+            'tinyblob': 'Bytes',
+            'mediumblob': 'Bytes',
+            'longblob': 'Bytes'
+        };
+        return typeMap[dbType.toLowerCase()] || 'String';
+    }
+
 }
 
 module.exports.TypeMapper = new TypeMapper();

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@reldens/storage",
     "scope": "@reldens",
-    "version": "0.33.0",
+    "version": "0.35.0",
     "description": "Reldens - Storage",
     "author": "Damian A. Pastorini",
     "license": "MIT",
@@ -9,7 +9,8 @@
     "source": true,
     "main": "index.js",
     "bin": {
-        "reldens-storage": "./bin/reldens-storage.js"
+        "reldens-storage": "./bin/reldens-storage.js",
+        "reldens-storage-prisma": "./bin/generate-prisma-schema.js"
     },
     "repository": {
         "type": "git",
@@ -50,11 +51,13 @@
         "@mikro-orm/core": "^6.4.15",
         "@mikro-orm/mongodb": "^6.4.15",
         "@mikro-orm/mysql": "^6.4.15",
-        "@reldens/utils": "^0.47.0",
+        "@prisma/client": "^6.7.0",
         "@reldens/server-utils": "^0.15.0",
+        "@reldens/utils": "^0.47.0",
         "knex": "^3.1.0",
         "mysql": "^2.18.1",
         "mysql2": "^3.14.1",
-        "objection": "^3.1.5"
+        "objection": "^3.1.5",
+        "prisma": "^6.7.0"
     }
 }