@reldens/storage 0.32.0 → 0.34.0

package/README.md

@@ -3,55 +3,145 @@
 # Reldens - Storage
 
 ## About this package
-This package is designed to provide a standard drivers support for managing Reldens project data.
+This package provides standardized database drivers for Reldens projects.
+It ensures consistent data access methods across different database types and ORM implementations.
 
-This way in any Reldens project we can trust that any driver implementation will have the exact same methods available to fetch and manage the project entities.
+## Features
 
-Every time you need to load, create, update or delete data in Reldens, the drivers from this package will be used.
+### ORM Support
+- **Objection JS** (via Knex) - For SQL databases (recommended)
+- **Mikro-ORM** - For MongoDB/NoSQL support
+- **Prisma** - Modern database toolkit
 
-## Current features
-The package currently has drivers to support two ORMs:
-- Objection JS (with Knex), for everything that's SQL related (this is our base and recommended package).
+### Entity Management
+- Standardized CRUD operations
+- Automatic entity generation from database schemas
+- Type mapping between database and JavaScript
+- Foreign key relationship handling
+- ENUM field support with formatted values
+
+### CLI Tools
+Generate entity files directly from your database structure:
+```bash
+npx reldens-storage generateEntities --user=dbuser --pass=dbpass --database=dbname --driver=objection-js
+```
+
+Options:
+- `--user` - Database username
+- `--pass` - Database password
+- `--host` - Database host (default: localhost)
+- `--port` - Database port (default: 3306)
+- `--database` - Database name
+- `--driver` - ORM driver (objection-js|mikro-orm)
+- `--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
 ```javascript
-let server = new ObjectionJsDataServer({
-    client: 'mysql',
+const { ObjectionJsDataServer } = require('@reldens/storage');
+
+const server = new ObjectionJsDataServer({
+    client: 'mysql2',
     config: {
         user: 'reldens',
         password: 'reldens',
         database: 'reldens',
-        port : 3306,
+        host: 'localhost',
+        port: 3306
     }
 });
+
+await server.connect();
+const entities = server.generateEntities();
 ```
-- Mikro-ORM, to offer support for nonSQL/MongoDB (this package is not finished, if you like to use it please contact us).
+
+### MongoDB with Mikro-ORM
 ```javascript
-let server = new MikroOrmDataServer({
+const { MikroOrmDataServer } = require('@reldens/storage');
+
+const server = new MikroOrmDataServer({
     client: 'mongodb',
     config: {
         user: 'reldens',
         password: 'reldens',
-        database: 'test',
-        port : 27017,
+        database: 'reldens',
+        host: 'localhost',
+        port: 27017
     },
-    connectStringOptions: 'authSource=reldens&readPreference=primary&appname=MongoDB%20Compass&ssl=false',
-    autoGenerateEntities: false,
-    rawEntities: Object.values(rawRegisteredEntities)
+    connectStringOptions: 'authSource=reldens&readPreference=primary&ssl=false',
+    rawEntities: yourEntities
 });
+
+await server.connect();
+const entities = server.generateEntities();
 ```
 
-## Custom drivers
-Through this package you can also create your own drivers (to support your own storage system) and later implement it on any Reldens project.
+### Using Prisma
 
-In order to do this, just extend the BaseDataServer and BaseDriver classes and fill all the required methods.
+First, generate your Prisma schema:
+```bash
+npx reldens-storage-prisma --user=dbuser --pass=dbpass --database=dbname
+```
 
-For last, on your Reldens implementation you just need to pass an instance of your data server to the server manager and you are done:
+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();
 ```
-const appServer = new ServerManager(serverConfig, eventsManager, yourDriverInstance);
+
+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:
+
+1. Extend `BaseDataServer` and `BaseDriver`
+2. Implement all required methods
+3. Pass your custom server instance to Reldens ServerManager:
+
+```javascript
+const { ServerManager } = require('@reldens/server');
+const YourCustomDriver = require('./your-custom-driver');
+
+const customDriver = new YourCustomDriver(options);
+const appServer = new ServerManager(serverConfig, eventsManager, customDriver);
 ```
 
-You can also check the [skeleton implementation](https://github.com/damian-pastorini/reldens-skeleton/) to see how it works.
+## Links
+- [Reldens Website](https://www.reldens.com/)
+- [GitHub Repository](https://github.com/damian-pastorini/reldens/tree/master)
 
-For reference see Reldens GitHub: [https://github.com/damian-pastorini/reldens/tree/master](https://github.com/damian-pastorini/reldens/tree/master)
+---
 
 ### [Reldens](https://www.reldens.com/ "Reldens")
 

package/bin/generate-prisma-schema.js

@@ -0,0 +1,88 @@
+#!/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

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+
+/**
+ *
+ * Reldens - Storage CLI
+ *
+ */
+
+const { EntitiesGenerator } = require('../lib/entities-generator');
+const { Logger } = require('@reldens/utils');
+
+let args = process.argv.slice(2);
+let command = args[0];
+
+if('generateEntities' !== command){
+    Logger.error('Unknown command. Available command "generateEntities".');
+    process.exit();
+}
+
+let connectionData = {
+    driver: 'objection-js',
+    client: 'mysql2',
+    user: '',
+    password: '',
+    host: 'localhost',
+    database: '',
+    port: 3306
+};
+
+let projectPath = process.cwd();
+for(let i = 1; 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.password = value;
+        continue;
+    }
+    if('path' === key){
+        projectPath = value;
+        continue;
+    }
+    connectionData[key] = value;
+}
+
+if('mikro-orm' === connectionData.driver && !args.find(arg => arg.startsWith('--client='))){
+    connectionData.client = 'mysql';
+}
+
+if(!connectionData.user || !connectionData.database){
+    Logger.error('Required parameters missing.');
+    Logger.error(
+        'Usage:',
+        'npx reldens-storage generateEntities --user=[db-username] --pass=[db-password] --host=[db-host] --database=[db-name] --driver=[driver-map-key] --client=[db-client] --path=[project-path]'
+    );
+    process.exit();
+}
+
+let generator = new EntitiesGenerator({connectionData, projectPath});
+generator.generate().then((success) => {
+    if(!success){
+        Logger.error('Entity generation failed.');
+        process.exit();
+    }
+    Logger.info('Entity generation completed successfully!');
+    process.exit();
+}).catch((error) => {
+    Logger.error('Error during entity generation: '+error.message);
+    process.exit();
+});

package/index.js

@@ -12,17 +12,38 @@ const { Model } = require('objection');
 const { MikroOrmDriver } = require('./lib/mikro-orm/mikro-orm-driver');
 const { MikroOrmDataServer } = require('./lib/mikro-orm/mikro-orm-data-server');
 const MikroOrmCore = require('@mikro-orm/core');
+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:
-    BaseDataServer: BaseDataServer,
-    BaseDriver: BaseDriver,
+    BaseDataServer,
+    BaseDriver,
+    DriversMap: {
+        'objection-js': ObjectionJsDataServer,
+        'mikro-orm': MikroOrmDataServer,
+        'prisma': PrismaDataServer
+    },
     // objection-js:
-    ObjectionJsDataServer: ObjectionJsDataServer,
-    ObjectionJsDriver: ObjectionJsDriver,
+    ObjectionJsDataServer,
+    ObjectionJsDriver,
     ObjectionJsRawModel: Model,
     // mikro-orm:
     MikroOrmCore,
-    MikroOrmDataServer: MikroOrmDataServer,
-    MikroOrmDriver: MikroOrmDriver
+    MikroOrmDataServer,
+    MikroOrmDriver,
+    // prisma:
+    PrismaDataServer,
+    PrismaDriver,
+    PrismaSchemaGenerator,
+    // entities:
+    EntitiesGenerator,
+    EntityProperties,
+    TypeMapper,
+    MySQLTablesProvider
 };

package/lib/base-data-server.js

@@ -56,6 +56,11 @@ class BaseDataServer
         ErrorManager.error('BaseDriver connect() not implemented.');
     }
 
+    async fetchEntitiesFromDatabase()
+    {
+        ErrorManager.error('BaseDriver fetchEntitiesFromDatabase() not implemented.');
+    }
+
 }
 
 module.exports.BaseDataServer = BaseDataServer;