@reldens/storage 0.95.0 → 0.96.0

package/.claude/driver-methods-complete-analysis.md

@@ -1667,38 +1667,47 @@ async rawQuery(content)
 
 **Return type:** Array or false
 
-#### Prisma Implementation (prisma-data-server.js:118-134)
+#### Prisma Implementation (prisma-data-server.js:119-138)
 
 ```javascript
 async rawQuery(content)
 {
     try {
-        let statements = this.splitSqlStatements(content);
-        let results = [];
-        for(let statement of statements){
-            if(!statement.trim()){
-                continue;
-            }
-            let result = await this.prisma.$executeRawUnsafe(statement);
-            results.push(result);
+        let statements = this.splitSqlStatements(content)
+            .map(s => s.trim())
+            .filter(s => '' !== s);
+        if(0 === statements.length){
+            return false;
         }
-        return results;
-    } catch(error){
-        Logger.error('Prisma raw query error:', error.message);
+        let results = [];
+        await this.prisma.$transaction(
+            async (tx) => { results = await this.executeStatements(statements, tx); },
+            {timeout: 60000}
+        );
+        return 1 === results.length ? results[0] : results;
+    } catch(error) {
+        Logger.error('Raw query failed: '+error.message);
         return false;
     }
 }
 ```
 
-**Uses:** Prisma.$executeRawUnsafe()
-**Special:** Splits statements and executes separately
+**Uses:** `$transaction` wrapping `executeStatements()`, which calls `executeStatement()` per statement:
+- SELECT / SHOW → `$queryRawUnsafe` → returns rows array
+- CREATE / ALTER / DROP → `$executeRawUnsafe` → returns `{affectedRows: N}`
+- INSERT / UPDATE / DELETE → `$executeRawUnsafe` → returns affected row count
 
-**Return type:** Array or false
+**Return type:**
+- Empty content → `false`
+- Single statement → the result directly (not wrapped in array)
+- Multiple statements → array of results
+- Error → `false`
 
 **Consistency Analysis:**
-- ✅ **ALL CONSISTENT** - Return array or false
 - ✅ All execute raw SQL
-- ⚠️ Prisma splits multi-statement queries
+- ✅ All return false on error or empty input
+- ⚠️ **RETURN TYPE DIFFERS for single statements**: ObjectionJS and MikroORM always return array or false; Prisma returns the result directly (not in an array) for a single statement, and an array only for multiple statements
+- ⚠️ Prisma is the only driver that explicitly splits multi-statement strings and runs them atomically in a transaction
 
 ---
 

package/.claude/test-architecture.md

@@ -365,107 +365,48 @@ async fetchEntitiesFromDatabase() {
 
 ### Critical: Tables Must Exist First!
 
-**File:** `tests/utils/test-helpers.js` (lines 389-416)
+**File:** `tests/utils/test-helpers.js`
 
 ```javascript
 static async generateTestEntities(dataServer, driverName)
 {
-    // Step 1: Introspect database (REQUIRES tables to exist!)
-    let models = await this.createModelsFromDatabase(dataServer, driverName);
-    if(!models || 0 === Object.keys(models).length){
-        throw new Error('Failed to create models from database for '+driverName);
-    }
-
-    // Step 2: PRISMA ONLY - Generate schema + client
+    // Prisma only: generate schema + client if not already present
     if('prisma' === driverName){
         let config = this.getTestDbConfig();
         config.client = 'mysql';
-
-        // Subprocess 1: Generate schema.prisma from database
-        if(!await this.generatePrismaSchema(config)){
-            throw new Error('Failed to generate Prisma schema');
-        }
-
-        // Subprocess 2: Generate PrismaClient code
-        if(!await this.generatePrismaClient()){
-            throw new Error('Failed to generate Prisma client');
-        }
-
-        // Step 3: Disconnect old client
-        await dataServer.disconnect();
-
-        // Step 4: Clear Node.js module cache
-        delete require.cache[require.resolve('@prisma/client')];
-
-        // Step 5: Reconnect with new client
-        if(!await dataServer.connect()){
-            throw new Error('Failed to reconnect Prisma client');
+        let schemaPath = FileHandler.joinPaths(process.cwd(), 'prisma', 'schema.prisma');
+        if(!FileHandler.exists(schemaPath)){
+            if(!await this.generatePrismaSchema(config)){
+                throw new Error('Failed to generate Prisma schema');
+            }
+            if(!await this.generatePrismaClient()){
+                throw new Error('Failed to generate Prisma client');
+            }
+            await dataServer.disconnect();
+            delete require.cache[require.resolve(FileHandler.joinPaths(process.cwd(), 'prisma', 'client'))];
+            await dataServer.connect();
         }
     }
-
-    // Step 3: Set rawEntities and generate driver instances
-    dataServer.rawEntities = models;
-    let result = await dataServer.generateEntities();
-    if(0 === Object.keys(dataServer.entities).length){
-        throw new Error('No entities were generated for '+driverName);
+    // Run EntitiesGenerator — introspects DB, writes entity + model files to generated-entities/
+    await this.runEntitiesGenerator(dataServer, driverName);
+    this.fixGeneratedRequirePaths();
+    this.compareGeneratedWithExpected(driverName, 'entities');
+    this.compareGeneratedWithExpected(driverName, 'models/'+driverName);
+    if('objection-js' === driverName){
+        this.compareGeneratedWithExpected(driverName, 'entities-config.js');
+        this.compareGeneratedWithExpected(driverName, 'entities-translations.js');
     }
-
+    // Load generated registered-models file and populate entity manager
+    await this.loadGeneratedEntities(dataServer, driverName);
     return true;
 }
 ```
 
-### createModelsFromDatabase Flow
-
-**Lines 31-69:**
-
-```javascript
-static async createModelsFromDatabase(dataServer, driverName)
-{
-    // CRITICAL: This calls fetchEntitiesFromDatabase which reads actual tables
-    let tables = await dataServer.fetchEntitiesFromDatabase();
-    if(!tables){
-        return {};
-    }
-
-    let models = {};
-
-    if('objection-js' === driverName){
-        for(let tableName of Object.keys(tables)){
-            let entityName = sc.camelCase(tableName.replace('test_', ''));
-            // Creates dynamic Model class extending Objection Model
-            class DynamicModel extends Model {
-                static get tableName(){
-                    return tableName;
-                }
-            }
-            if(dataServer.knex){
-                DynamicModel.knex(dataServer.knex);
-            }
-            let modelKey = 'test'+sc.capitalizedCamelCase(entityName);
-            models[modelKey] = DynamicModel;
-        }
-        return models;
-    }
-
-    if('mikro-orm' === driverName){
-        for(let tableName of Object.keys(tables)){
-            let entityName = sc.camelCase(tableName.replace('test_', ''));
-            models['test'+sc.capitalizedCamelCase(entityName)] = {tableName: tableName};
-        }
-        return models;
-    }
+### Entity Generation Flow
 
-    if('prisma' === driverName){
-        for(let tableName of Object.keys(tables)){
-            let entityName = sc.camelCase(tableName.replace('test_', ''));
-            models['test'+sc.capitalizedCamelCase(entityName)] = {tableName: tableName};
-        }
-        return models;
-    }
+`runEntitiesGenerator()` creates an `EntitiesGenerator` instance pointed at the connected `dataServer`, calls `generator.generate()`, which internally calls `dataServer.fetchEntitiesFromDatabase()` to read real table metadata from `information_schema`. This is why tables must exist before calling `generateTestEntities()` — without tables, introspection returns empty and generation fails.
 
-    return {};
-}
-```
+After generation, `loadGeneratedEntities()` loads the `generated-entities/models/[driver]/registered-models-[driver].js` file, sets `dataServer.rawEntities`, and calls `dataServer.generateEntities()` to register all driver instances in the entity manager.
 
 **Why tables must exist first:**
 - `fetchEntitiesFromDatabase()` queries MySQL `information_schema`
@@ -673,65 +614,49 @@ static async generatePrismaClient(){
 
 ### Per Driver Test Suite
 
+**1. Initialization — runs once per driver (`DriverRegistry.initialize()`):**
+- `setupDriver()` — connect to database
+- `executeRawSQL()` — create tables from SQL schema
+- `generateTestEntities()` — introspect DB, run EntitiesGenerator, load entities
+- `dataServer.getEntity()` — obtain repository references
+
+**2. Test execution — per group method in each test class:**
+
+Each test class (DriversTest, NestedFiltersTest, RelationsTest, RawQueriesTest) has group methods. Each group method begins with `await TestHelpers.cleanDatabase(this.dataServer)` to DELETE all rows, then runs its tests via `runner.test()`.
+
+Example:
+```javascript
+async testCreateOperations() {
+    this.runner.group('CREATE Operations');
+    await TestHelpers.cleanDatabase(this.dataServer);
+    // insert fixture data, then call runner.test() for each assertion
+}
 ```
-1. before() hook - RUNS ONCE
-   ├─ setupDriver (connect to database)
-   ├─ executeRawSQL (create tables)
-   ├─ generateTestEntities (introspect + generate models)
-   └─ getEntity (get repository references)
-
-2. Test Suite Execution
-   │
-   ├─ describe('CREATE Operations')
-   │  ├─ beforeEach() → cleanDatabase (DELETE data)
-   │  ├─ it('should create single record')
-   │  ├─ beforeEach() → cleanDatabase (DELETE data)
-   │  ├─ it('should create with JSON field')
-   │  └─ ...
-   │
-   ├─ describe('UPDATE Operations')
-   │  ├─ beforeEach() → cleanDatabase (DELETE data)
-   │  ├─ it('should update by ID')
-   │  └─ ...
-   │
-   ├─ describe('QUERY Operations')
-   │  ├─ beforeEach() → cleanDatabase (DELETE data)
-   │  ├─ it('should load all records')
-   │  └─ ...
-   │
-   └─ describe('DELETE Operations')
-      ├─ beforeEach() → cleanDatabase (DELETE data)
-      ├─ it('should delete by ID')
-      └─ ...
-
-3. after() hook - RUNS ONCE
-   ├─ dropTestTables (DROP all tables)
-   └─ teardownDriver (disconnect from database)
-```
+
+**3. Teardown — runs once per driver (`DriverRegistry.cleanup()`):**
+- `dropTestTables()` — DROP all test tables
+- `teardownDriver()` — disconnect from database
 
 ### All Drivers Execution
 
-```
-Driver: objection-js
-├─ before() → Connect, Create Tables, Generate Entities
-├─ Run 147 tests (with beforeEach DELETE between each)
-└─ after() → Drop Tables, Disconnect
-
-Driver: mikro-orm
-├─ before() → Connect, Create Tables, Generate Entities
-├─ Run 147 tests (with beforeEach DELETE between each)
-└─ after() → Drop Tables, Disconnect
-
-Driver: prisma
-├─ before() → Connect, Create Tables, Generate Schema, Generate Client, Reconnect, Generate Entities
-├─ Run 147 tests (with beforeEach DELETE between each)
-└─ after() → Drop Tables, Disconnect
-```
+**Driver: objection-js**
+- Initialize: connect, create tables, generate entities
+- Run all tests (cleanDatabase at start of each group)
+- Teardown: drop tables, disconnect
+
+**Driver: mikro-orm**
+- Initialize: connect, create tables, generate entities
+- Run all tests (cleanDatabase at start of each group)
+- Teardown: drop tables, disconnect
+
+**Driver: prisma**
+- Initialize: connect, create tables, generate Prisma schema (subprocess), generate Prisma client (subprocess), reconnect, generate entities
+- Run all tests (cleanDatabase at start of each group)
+- Teardown: drop tables, disconnect
 
 **Total connections:** 3 (one per driver)
 **Total table creations:** 3 (one per driver)
 **Total entity generations:** 3 (one per driver)
-**Total test executions:** 441 (147 tests × 3 drivers)
 
 ---
 
@@ -775,7 +700,7 @@ Driver: prisma
 
 **Symptoms:**
 - `fetchEntitiesFromDatabase()` returns empty/null
-- `createModelsFromDatabase()` returns empty object
+- `EntitiesGenerator.generate()` fails or produces no entities
 - Entity generation fails with "No entities generated"
 
 **Cause:**
@@ -828,59 +753,48 @@ Driver: prisma
 
 ## Summary: The Complete Flow
 
-```
-SESSION START
-    ↓
-FOR EACH DRIVER (objection-js, mikro-orm, prisma):
-    ↓
-    before() hook - RUNS ONCE:
-        1. Connect to database
-           ├─ ObjectionJS: Create Knex instance
-           ├─ MikroORM: Initialize MikroORM
-           └─ Prisma: Create PrismaClient (if generated)
-
-        2. Create tables from SQL file
-           ├─ SET FOREIGN_KEY_CHECKS=0
-           ├─ DROP TABLE IF EXISTS (in order)
-           ├─ CREATE TABLE (with constraints)
-           └─ SET FOREIGN_KEY_CHECKS=1
-
-        3. Generate entities from database
-           ├─ Introspect database schema
-           ├─ Create model classes/objects
-           ├─ [Prisma only]: Generate schema → Generate client → Reconnect
-           ├─ Call dataServer.generateEntities()
-           └─ Get repository references
-
-    FOR EACH TEST:
-        beforeEach() hook:
-            ├─ SET FOREIGN_KEY_CHECKS=0
-            ├─ DELETE FROM test_reviews
-            ├─ DELETE FROM test_products
-            ├─ DELETE FROM test_categories
-            └─ SET FOREIGN_KEY_CHECKS=1
-
-        Run test:
-            ├─ Create test data
-            ├─ Perform operations
-            ├─ Assert results
-            └─ (Data will be cleaned in next beforeEach)
-
-    after() hook - RUNS ONCE:
-        1. Drop all tables
-           ├─ SET FOREIGN_KEY_CHECKS=0
-           ├─ DROP TABLE IF EXISTS test_reviews
-           ├─ DROP TABLE IF EXISTS test_products
-           ├─ DROP TABLE IF EXISTS test_categories
-           └─ SET FOREIGN_KEY_CHECKS=1
-
-        2. Disconnect from database
-           ├─ ObjectionJS: await knex.destroy()
-           ├─ MikroORM: await orm.close()
-           └─ Prisma: await prisma.$disconnect()
-
-SESSION END
-```
+**For each driver (objection-js, mikro-orm, prisma):**
+
+**Initialization — once per driver:**
+
+1. Connect to database
+   - ObjectionJS: create Knex instance
+   - MikroORM: initialize MikroORM
+   - Prisma: create PrismaClient (if already generated)
+
+2. Create tables from SQL file
+   - SET FOREIGN_KEY_CHECKS=0
+   - DROP TABLE IF EXISTS (cleanup from previous run)
+   - CREATE TABLE (with all constraints)
+   - SET FOREIGN_KEY_CHECKS=1
+
+3. Generate entities from database
+   - Run EntitiesGenerator (introspects DB, writes files to generated-entities/)
+   - Prisma only: generate schema.prisma (subprocess), generate PrismaClient (subprocess), reconnect
+   - Load registered-models file, call dataServer.generateEntities()
+
+**Per test group — cleanDatabase() at start of each group method:**
+- SET FOREIGN_KEY_CHECKS=0
+- DELETE FROM test_reviews
+- DELETE FROM test_products
+- DELETE FROM test_categories
+- SET FOREIGN_KEY_CHECKS=1
+
+**Per test:** create test data, perform operations, assert results.
+
+**Teardown — once per driver:**
+
+1. Drop all tables
+   - SET FOREIGN_KEY_CHECKS=0
+   - DROP TABLE IF EXISTS test_reviews
+   - DROP TABLE IF EXISTS test_products
+   - DROP TABLE IF EXISTS test_categories
+   - SET FOREIGN_KEY_CHECKS=1
+
+2. Disconnect from database
+   - ObjectionJS: `await knex.destroy()`
+   - MikroORM: `await orm.close()`
+   - Prisma: `await prisma.$disconnect()`
 
 ---
 
@@ -888,7 +802,7 @@ SESSION END
 
 ### Integration Test Files (All Fixed)
 
-**test-cross-driver-compatibility.js:**
+**test-drivers.js:**
 - ✅ Changed `beforeEach` → `before` for setup
 - ✅ Added `beforeEach` for data cleanup only
 - ✅ Changed `afterEach` → `after` for teardown
@@ -906,6 +820,9 @@ SESSION END
 - ✅ Changed `afterEach` → `after` for teardown
 - ✅ Added error checking for entity generation
 
+**test-raw-queries.js:**
+- ✅ Added — covers rawQuery with single and multiple SQL statements
+
 ### Test Helpers (All Fixed)
 
 **test-helpers.js:**
@@ -913,7 +830,7 @@ SESSION END
 - ✅ Changed `cleanDatabase()` to use DELETE instead of DROP
 - ✅ Created `dropTestTables()` for final cleanup
 - ✅ Changed `generateTestEntities()` to throw errors instead of returning false
-- ✅ Removed logging from `createModelsFromDatabase()`
+- ✅ Replaced `createModelsFromDatabase()` with `runEntitiesGenerator()` + `loadGeneratedEntities()`
 - ✅ Removed logging from `setupDriver()`
 - ✅ Removed logging from `executeRawSQL()`
 
@@ -930,30 +847,25 @@ SESSION END
 
 ### Before Fixes (Wrong Pattern)
 
-```
-Driver: objection-js
-├─ Test 1: Connect (500ms) + Create Tables (1000ms) + Generate Entities (500ms) + Run (10ms) + Teardown (100ms) = 2110ms
-├─ Test 2: Connect (500ms) + Create Tables (1000ms) + Generate Entities (500ms) + Run (10ms) + Teardown (100ms) = 2110ms
-└─ ... × 147 tests = 310,170ms (5+ minutes per driver)
-
-Total for 3 drivers: ~15+ minutes
-```
+Each test reconnected, recreated tables, and regenerated entities independently:
+- Connect: ~500ms
+- Create tables: ~1000ms
+- Generate entities: ~500ms
+- Run test: ~10ms
+- Teardown: ~100ms
+- **Total per test: ~2110ms**
+- Total for 100 tests, 3 drivers: ~10+ minutes
 
 ### After Fixes (Correct Pattern)
 
-```
-Driver: objection-js
-├─ before(): Connect (500ms) + Create Tables (1000ms) + Generate Entities (500ms) = 2000ms
-├─ Test 1: DELETE (5ms) + Run (10ms) = 15ms
-├─ Test 2: DELETE (5ms) + Run (10ms) = 15ms
-├─ ... × 147 tests = 2205ms
-└─ after(): Drop Tables (100ms) + Teardown (100ms) = 200ms
-
-Total for 1 driver: ~2.4 seconds
-Total for 3 drivers: ~7-10 seconds (includes Prisma subprocess)
-```
+Setup and teardown happen once per driver. Only data cleanup runs between tests:
+- Setup once: connect + create tables + generate entities = ~2 seconds
+- Each test: DELETE data (~5ms) + run test (~10ms) = ~15ms
+- Teardown once: drop tables + disconnect = ~200ms
+- **Total for 100 tests, 1 driver: ~3.7 seconds**
+- Total for 3 drivers: ~10-15 seconds (includes Prisma subprocess generation)
 
-**Speed improvement: 90x faster** 🚀
+**Speed improvement: ~60-90x faster**
 
 ---
 

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

@@ -119,43 +119,43 @@ class PrismaDataServer extends BaseDataServer
     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 result = await this.executeStatement(cleanStatement);
-                    results.push(result);
-                    //Logger.debug('Statement executed, result: ' + JSON.stringify(result));
-                } catch(stmtError) {
-                    Logger.error('Statement "'+cleanStatement+'" execution failed: '+stmtError.message);
-                    return false;
-                }
-            }
-            if(0 === results.length){
-                //Logger.error('Statement results length is zero.', results);
+            let statements = this.splitSqlStatements(content)
+                .map(s => s.trim())
+                .filter(s => '' !== s);
+            if(0 === statements.length){
                 return false;
             }
-            return 1 === results.length ? [...results].shift() : results;
+            let results = [];
+            await this.prisma.$transaction(
+                async (tx) => { results = await this.executeStatements(statements, tx); },
+                {timeout: 60000}
+            );
+            return 1 === results.length ? results[0] : results;
         } catch(error) {
             Logger.error('Raw query failed: '+error.message);
             return false;
         }
     }
 
-    async executeStatement(statement)
+    async executeStatements(statements, tx)
     {
-        let trimmedStatement = statement.trim().toUpperCase();
-        if(trimmedStatement.startsWith('SELECT')){
-            return await this.prisma.$queryRawUnsafe(statement);
+        let results = [];
+        for(let statement of statements){
+            let result = await this.executeStatement(statement, tx);
+            //Logger.debug('Statement executed, result: ' + JSON.stringify(result));
+            results.push(result);
         }
-        if(trimmedStatement.startsWith('SHOW')){
-            return await this.prisma.$queryRawUnsafe(statement);
+        return results;
+    }
+
+    async executeStatement(statement, prismaClient)
+    {
+        let client = prismaClient || this.prisma;
+        let trimmedStatement = statement.trim().toUpperCase();
+        if(trimmedStatement.startsWith('SELECT') || trimmedStatement.startsWith('SHOW')){
+            return await client.$queryRawUnsafe(statement);
         }
-        let result = await this.prisma.$executeRawUnsafe(statement);
+        let result = await client.$executeRawUnsafe(statement);
         //Logger.debug('Raw result from Prisma: ' + result);
         if(
             trimmedStatement.startsWith('CREATE')

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

@@ -26,6 +26,33 @@ class PrismaSchemaGenerator
         this.dbParams = sc.get(props, 'dbParams', process.env.RELDENS_DB_PARAMS || '');
     }
 
+    static ensureStubFiles(projectRoot)
+    {
+        let stubPath = FileHandler.joinPaths(projectRoot, 'node_modules', '.prisma', 'client', 'default.js');
+        if(FileHandler.exists(stubPath)){
+            Logger.info('Prisma stub files already exist.');
+            return true;
+        }
+        Logger.info('Creating Prisma stub files...');
+        try {
+            let defaultIndexPath = FileHandler.joinPaths(
+                projectRoot, 'node_modules', '@prisma', 'client', 'scripts', 'default-index.js'
+            );
+            if(!FileHandler.exists(defaultIndexPath)){
+                Logger.warning('Prisma default-index script not found at: '+defaultIndexPath);
+                return false;
+            }
+            let stubDir = FileHandler.joinPaths(projectRoot, 'node_modules', '.prisma', 'client');
+            FileHandler.createFolder(stubDir);
+            FileHandler.copyFile(defaultIndexPath, stubPath);
+            Logger.info('Prisma stub files created successfully.');
+            return true;
+        } catch(error) {
+            Logger.error('Failed to create stub files: '+error.message);
+            return false;
+        }
+    }
+
     async generate()
     {
         FileHandler.createFolder(this.prismaSchemaPath);
@@ -39,6 +66,11 @@ class PrismaSchemaGenerator
             Logger.critical('Failed to pull database schema: '+error.message);
             return false;
         }
+        return this.generateClient();
+    }
+
+    generateClient()
+    {
         let generateCommand = 'npx prisma generate';
         if(this.dataProxy){
             generateCommand += ' --data-proxy';
@@ -58,7 +90,6 @@ class PrismaSchemaGenerator
             Logger.critical('Generate command failed: '+error.message);
             return false;
         }
-        await this.waitForSchemaGeneration();
         return true;
     }
 

package/package.json

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

package/tests/integration/test-raw-queries.js

@@ -0,0 +1,117 @@
+/**
+ *
+ * Reldens - Raw Queries Integration Test
+ * Tests rawQuery with single and multiple SQL statements across all drivers
+ *
+ */
+
+const { TestRunner, assert } = require('../utils/test-runner');
+const { TestHelpers } = require('../utils/test-helpers');
+
+class RawQueriesTest
+{
+
+    constructor(dataServer, repos, driverName)
+    {
+        this.dataServer = dataServer;
+        this.driverName = driverName;
+        this.runner = new TestRunner();
+    }
+
+    async run()
+    {
+        this.runner.suite('Raw Queries - Driver: '+this.driverName);
+        await this.testSingleStatements();
+        await this.testMultipleStatements();
+        return this.runner.getResults();
+    }
+
+    async testSingleStatements()
+    {
+        this.runner.group('Single Statement');
+        await TestHelpers.cleanDatabase(this.dataServer);
+        await this.dataServer.rawQuery(
+            'INSERT INTO test_categories (id, name, slug, is_active, display_order)'
+            +' VALUES (9001, \'Raw Single Test\', \'raw-single-test\', 1, 99)'
+        );
+        await this.runner.test('should return rows from SELECT single statement', async () => {
+            let result = await this.dataServer.rawQuery(
+                'SELECT id, name, slug FROM test_categories WHERE id = 9001'
+            );
+            assert.ok(result);
+            assert.ok(Array.isArray(result));
+            assert.strictEqual(result.length, 1);
+            assert.strictEqual(result[0].name, 'Raw Single Test');
+            assert.strictEqual(result[0].slug, 'raw-single-test');
+        });
+        await this.runner.test('should execute UPDATE single statement and reflect changes', async () => {
+            await this.dataServer.rawQuery(
+                'UPDATE test_categories SET name = \'Updated Raw Single\' WHERE id = 9001'
+            );
+            let result = await this.dataServer.rawQuery(
+                'SELECT id, name FROM test_categories WHERE id = 9001'
+            );
+            assert.ok(result);
+            assert.ok(Array.isArray(result));
+            assert.strictEqual(result.length, 1);
+            assert.strictEqual(result[0].name, 'Updated Raw Single');
+        });
+        await this.runner.test('should execute DELETE single statement and remove record', async () => {
+            await this.dataServer.rawQuery('DELETE FROM test_categories WHERE id = 9001');
+            let result = await this.dataServer.rawQuery(
+                'SELECT id FROM test_categories WHERE id = 9001'
+            );
+            let isEmpty = !result || (Array.isArray(result) && 0 === result.length);
+            assert.ok(isEmpty, 'Record should not exist after DELETE');
+        });
+    }
+
+    async testMultipleStatements()
+    {
+        this.runner.group('Multiple Statements');
+        await TestHelpers.cleanDatabase(this.dataServer);
+        if('prisma' === this.driverName){
+            await this.runner.test('should execute multiple statements in one rawQuery call', async () => {
+                let results = await this.dataServer.rawQuery(
+                    'INSERT INTO test_categories (id, name, slug, is_active, display_order)'
+                    +' VALUES (9002, \'Raw Multi 1\', \'raw-multi-1\', 1, 1);'
+                    +'INSERT INTO test_categories (id, name, slug, is_active, display_order)'
+                    +' VALUES (9003, \'Raw Multi 2\', \'raw-multi-2\', 1, 2);'
+                );
+                assert.ok(results);
+                assert.ok(Array.isArray(results));
+                assert.strictEqual(results.length, 2);
+                let rows = await this.dataServer.rawQuery(
+                    'SELECT id, name FROM test_categories ORDER BY id'
+                );
+                assert.ok(rows);
+                assert.ok(Array.isArray(rows));
+                assert.strictEqual(rows.length, 2);
+                assert.strictEqual(rows[0].name, 'Raw Multi 1');
+                assert.strictEqual(rows[1].name, 'Raw Multi 2');
+            });
+        } else {
+            await this.runner.test('should execute multiple sequential rawQuery calls', async () => {
+                await this.dataServer.rawQuery(
+                    'INSERT INTO test_categories (id, name, slug, is_active, display_order)'
+                    +' VALUES (9002, \'Raw Multi 1\', \'raw-multi-1\', 1, 1)'
+                );
+                await this.dataServer.rawQuery(
+                    'INSERT INTO test_categories (id, name, slug, is_active, display_order)'
+                    +' VALUES (9003, \'Raw Multi 2\', \'raw-multi-2\', 1, 2)'
+                );
+                let result = await this.dataServer.rawQuery(
+                    'SELECT id, name FROM test_categories ORDER BY id'
+                );
+                assert.ok(result);
+                assert.ok(Array.isArray(result));
+                assert.strictEqual(result.length, 2);
+                assert.strictEqual(result[0].name, 'Raw Multi 1');
+                assert.strictEqual(result[1].name, 'Raw Multi 2');
+            });
+        }
+    }
+
+}
+
+module.exports = RawQueriesTest;

package/tests/run-tests.js

@@ -11,6 +11,7 @@ const { DriverRegistry } = require('./utils/driver-registry');
 const DriversTest = require('./integration/test-drivers');
 const NestedFiltersTest = require('./integration/test-nested-filters');
 const RelationsTest = require('./integration/test-relations');
+const RawQueriesTest = require('./integration/test-raw-queries');
 const EntityManagerTest = require('./unit/test-entity-manager');
 const TypeMapperTest = require('./unit/test-type-mapper');
 const DriversUnitTest = require('./unit/test-drivers');
@@ -156,6 +157,16 @@ class RunTests
                 Logger.critical('Driver '+driverName+' relations tests crashed: '+error.message);
                 Logger.critical(error.stack);
             }
+            try {
+                let rawQueriesTest = new RawQueriesTest(dataServer, repos, driverName);
+                let rawQueriesResult = await rawQueriesTest.run();
+                this.allCounts.total += rawQueriesResult.total;
+                this.allCounts.passed += rawQueriesResult.passed;
+                this.allCounts.failed += rawQueriesResult.failed;
+            } catch(error) {
+                Logger.critical('Driver '+driverName+' raw queries tests crashed: '+error.message);
+                Logger.critical(error.stack);
+            }
         }
     }
 

package/samples/objection.js

@@ -1,37 +0,0 @@
-const { ObjectionJsDataServer } = require('../lib/objection-js/objection-js-data-server');
-
-const { Model } = require('objection');
-
-class UsersModel extends Model
-{
-
-    static get tableName()
-    {
-        return 'your_table_name';
-    }
-
-}
-
-async function test(){
-    const entityKey = 'users';
-
-    let server = new ObjectionJsDataServer({
-        client: 'mysql',
-        config: {
-            user: 'user',
-            password: 'password',
-            database: 'database_name',
-            port : 3306,
-        },
-        rawEntities: {[entityKey]: UsersModel}
-    });
-
-    await server.connect();
-    await server.generateEntities();
-
-    console.log(await server.getEntity(entityKey).loadAll());
-
-    process.exit();
-}
-
-test();