@reldens/storage 0.111.0 → 0.113.0

package/.claude/prisma-setup.md

@@ -0,0 +1,162 @@
+# Prisma Setup For Development And Tests
+
+Prisma is not a dependency of this package. `package.json` does not list `prisma`, `@prisma/client` or
+`@prisma/adapter-mariadb`, and no file under `lib/` requires them. The Prisma driver receives everything it needs
+through the `prismaModules` object, so Prisma only has to exist in the project that uses the driver, or in this
+repo when you want to run the Prisma driver tests.
+
+## Install, Test, Uninstall Workflow
+
+The goal is to run the Prisma driver tests and leave no trace in `package.json`, `package-lock.json` or
+`node_modules`. The local `--no-save` sequence does exactly that and is the reliable one (PowerShell):
+
+```powershell
+npm install --no-save prisma@7.9.1 @prisma/client@7.9.1 @prisma/adapter-mariadb@7.9.1
+$env:RELDENS_TEST_PRISMA_ENABLED = "1"
+$env:RELDENS_LOG_LEVEL = "9"
+npm run test
+npm uninstall --no-save prisma @prisma/client @prisma/adapter-mariadb
+```
+
+Same sequence in Bash / Git Bash:
+
+```bash
+npm install --no-save prisma@7.9.1 @prisma/client@7.9.1 @prisma/adapter-mariadb@7.9.1
+RELDENS_TEST_PRISMA_ENABLED=1 RELDENS_LOG_LEVEL=9 npm run test
+npm uninstall --no-save prisma @prisma/client @prisma/adapter-mariadb
+```
+
+The global variant: global packages are never found by `require()`, so when the local resolution fails
+`TestHelpers.registerNpmGlobalPaths()` runs `npm root -g`, appends that folder and its nested
+`@prisma/client/node_modules` to `NODE_PATH`, re-initializes the module paths and stores the root in
+`RELDENS_TEST_NPM_GLOBAL_ROOT` (inherited by the Prisma subprocess worker). No manual `NODE_PATH` is needed, but
+the packages must be under the folder `npm root -g` prints (PowerShell):
+
+```powershell
+npm install -g prisma@7.9.1 @prisma/client@7.9.1 @prisma/adapter-mariadb@7.9.1
+$env:RELDENS_TEST_PRISMA_ENABLED = "1"
+$env:RELDENS_LOG_LEVEL = "9"
+npm run test
+npm uninstall -g prisma @prisma/client @prisma/adapter-mariadb
+```
+
+Only the `--no-save` sequence was executed end to end with the Prisma driver passing. The global lookup was
+executed once against a global root that did not contain the packages, so its resolution path is verified but a
+full Prisma driver run from a global install is not. If the pre-flight still says
+`Prisma package not installed`, the packages are not under the folder `npm root -g` prints.
+
+## Installing Prisma
+
+### Local install without saving (recommended)
+
+Run inside this repo, it installs the three packages into `node_modules` without touching `package.json` or
+`package-lock.json`:
+
+```bash
+npm install --no-save prisma@7.9.1 @prisma/client@7.9.1 @prisma/adapter-mariadb@7.9.1
+```
+
+A later plain `npm install` removes them again, because they are not in the lock file. Re-run the command when
+that happens.
+
+To remove them by hand:
+
+```bash
+npm uninstall --no-save prisma @prisma/client @prisma/adapter-mariadb
+```
+
+### Global install
+
+A global install alone does not work, because Node `require()` and `require.resolve()` never look into the
+global `node_modules`:
+
+- `TestHelpers.isPrismaAvailable()` resolves the three packages with `require.resolve()`.
+- `tests/utils/test-helpers.js` and `tests/utils/prisma-subprocess-worker.js` require `@prisma/adapter-mariadb`.
+- The generated client at `prisma/client` requires `@prisma/client-runtime-utils` at runtime.
+
+Only `npx prisma` finds a global CLI. The test helpers compensate: `TestHelpers.registerNpmGlobalPaths()` adds
+the `npm root -g` folder and its nested `@prisma/client/node_modules` to `NODE_PATH` at runtime when the local
+resolution fails, see the workflow section above.
+
+```bash
+npm install -g prisma@7.9.1 @prisma/client@7.9.1 @prisma/adapter-mariadb@7.9.1
+```
+
+To remove the global install:
+
+```bash
+npm uninstall -g prisma @prisma/client @prisma/adapter-mariadb
+```
+
+## Enabling The Prisma Driver In The Tests
+
+Two conditions must be true, checked by `TestHelpers.isPrismaEnabled()`:
+
+1. `RELDENS_TEST_PRISMA_ENABLED` is exactly `1`. Default is disabled: `tests/.env.test.example` ships it as `0`.
+2. `prisma`, `@prisma/client` and `@prisma/adapter-mariadb` resolve from this repo. The `prisma` CLI package is
+   resolved through `prisma/package.json`, because its `exports` entry `"."` points to `build/types.js`, a file that
+   is not shipped in 7.9.1, so `require.resolve('prisma')` throws even when the package is installed.
+
+When the flag is not `1` the pre-flight package check does not list the Prisma packages and the drivers unit test
+does not include the Prisma driver, so Prisma is not mentioned in the output at all.
+
+When either condition fails the Prisma driver is left out of `TestHelpers.activeDriverNames()`, so
+`DriverRegistry` never sets it up and `run-tests.js` never runs it. With the flag set to `1` but the packages
+missing, the pre-flight package check reports the three packages as optional warnings instead of failing.
+
+You can enable it in `tests/.env.test`:
+
+```
+RELDENS_TEST_PRISMA_ENABLED=1
+```
+
+`run-tests.js` loads `tests/.env.test` with `process.loadEnvFile()` only when `RELDENS_TEST_DB_HOST` is not
+already set, and `loadEnvFile()` never overrides variables already present in the environment, so a value set in
+the shell always wins over the file.
+
+## Running The Tests
+
+Bash / Git Bash:
+
+```bash
+RELDENS_TEST_PRISMA_ENABLED=1 RELDENS_LOG_LEVEL=9 npm run test
+```
+
+That command is correct: the two variables reach `node tests/run-tests.js`, the Prisma driver is enabled and the
+`Logger` prints everything. Without `RELDENS_LOG_LEVEL=9` the run prints only the npm header.
+
+PowerShell does not accept the `VAR=value command` prefix, use:
+
+```powershell
+$env:RELDENS_TEST_PRISMA_ENABLED = "1"
+$env:RELDENS_LOG_LEVEL = "9"
+npm run test
+```
+
+Only the Prisma driver (the `test:driver` script ends with an empty `--driver=`, so the argument must be passed
+through `npm run test`):
+
+```bash
+RELDENS_TEST_PRISMA_ENABLED=1 RELDENS_LOG_LEVEL=9 npm run test -- --driver=prisma
+```
+
+Expected pre-flight output with the flag set and Prisma installed: `Package prisma verified: 7.9.1`,
+`Package @prisma/client verified: 7.9.1` and `Package @prisma/adapter-mariadb verified: 7.9.1`. With the flag set
+and Prisma missing: three `Optional package not installed` warnings and the Prisma driver absent from the driver
+registry. With the flag unset: no Prisma line at all. Verified results: 324 tests without the Prisma driver, 406
+with it.
+
+## What The Prisma Driver Test Setup Does
+
+`TestHelpers.setupDriver('prisma')`:
+
+1. Forks `tests/utils/prisma-subprocess-worker.js`, which writes `prisma/schema.prisma` and `prisma.config.js`
+   in the repo root, runs `npx prisma db pull` and `npx prisma generate`, and disconnects.
+2. `TestHelpers.loadPrismaModules()` requires the generated client from `prisma/client`, requires
+   `@prisma/adapter-mariadb`, instantiates the client with the adapter and returns
+   `{PrismaClient, Prisma, PrismaAdapter, client}` (the tests use the MariaDB adapter, the driver accepts any).
+3. Passes that object as `prismaModules` to `PrismaDataServer`, whose `connect()` validates it with
+   `PrismaModulesValidator`.
+
+`TestHelpers.cleanupGeneratedFiles()` removes `prisma/`, `prisma.config.js` and `generated-entities/` at the
+start and at the end of a run unless `--skip-cleanup` is passed.

package/.claude/test-architecture.md

@@ -4,7 +4,7 @@
 
 ### Why Dynamic Model Creation Instead of Generated Models?
 
-**Problem:** Generated models in `.test-entities/` use `const { ObjectionJsRawModel } = require('@reldens/storage')` which loads the package index.js, which requires PrismaDataServer, which requires `@prisma/client` at top-level, which doesn't exist yet.
+**Problem:** Generated models in `.test-entities/` use `const { ObjectionJsRawModel } = require('@reldens/storage')` which loads the package index.js. The Prisma client used by the tests does not exist until the tests generate it, so nothing may depend on it at module load time. (The package index no longer requires any `@prisma/*` package, Prisma is injected through the `prismaModules` object.)
 
 **Solution:** Create dynamic models in-memory without requiring the package:
 
@@ -23,32 +23,41 @@ class DynamicModel extends Model {
 
 **Problem:** Cannot use `require('@prisma/client')` at top-level because the client doesn't exist until generated by tests.
 
-**Solution:** Generate client first, then load from specific path using PrismaClientLoader:
+**Solution:** Generate client first, then build the `prismaModules` object from the generated path and the dev installed adapter (`TestHelpers.loadPrismaModules()`):
 
 ```javascript
 // 1. Generate Prisma client (subprocess)
-await generatePrismaSchema(config);
-await generatePrismaClient();
-
-// 2. Load client from generated path (NOT '@prisma/client')
-const { PrismaClientLoader } = require('../../lib/prisma/prisma-client-loader');
-let prismaClient = PrismaClientLoader.load(process.cwd(), null, config);
-
-// 3. Pass loaded client to DataServer
-serverConfig.prismaClient = prismaClient;
+await this.runPrismaSubprocess(process.cwd(), config);
+
+// 2. Load the generated client module and the adapter (NOT '@prisma/client')
+let prismaModule = require(FileHandler.joinPaths(projectRoot, 'prisma', 'client'));
+let adapterModule = require('@prisma/adapter-mariadb');
+let client = new prismaModule.PrismaClient({adapter: new adapterModule.PrismaMariaDb(adapterConfig)});
+
+// 3. Pass the object to DataServer
+serverConfig.prismaModules = {
+    PrismaClient: prismaModule.PrismaClient,
+    Prisma: prismaModule.Prisma,
+    PrismaAdapter: adapterModule.PrismaMariaDb,
+    client
+};
 let dataServer = new PrismaDataServer(serverConfig);
 ```
 
-**This pattern is used in:**
-- `reldens-cms` installer (`bin/reldens-cms.js:87-108`)
-- `reldens` main application
-- Test suite setup
+**Prisma is optional for the test suite:**
+- `TestHelpers.isPrismaEnabled()` returns true only when `RELDENS_TEST_PRISMA_ENABLED=1` and `prisma`, `@prisma/client` and `@prisma/adapter-mariadb` resolve
+- `TestHelpers.activeDriverNames()` feeds `DriverRegistry` and `run-tests.js`, so the Prisma driver is skipped entirely otherwise
+- `verifyAllPackages()` lists the three Prisma packages only when the flag is `1`, and then as optional (warning, not failure)
+- `tests/unit/test-drivers.js` includes the Prisma driver only when `TestHelpers.isPrismaEnabled()` is true
+- The `prisma` CLI package is resolved through `prisma/package.json`, its `exports["."]` target `build/types.js` is not shipped in 7.9.1
+- When a package does not resolve locally, `TestHelpers.registerNpmGlobalPaths()` adds the `npm root -g` folder (and its nested `@prisma/client/node_modules`) to `NODE_PATH` and retries, so a global Prisma install is found too
+- Local install for the Prisma driver tests: `npm install --no-save prisma@7.9.1 @prisma/client@7.9.1 @prisma/adapter-mariadb@7.9.1`
+- Full setup, enable and run instructions: `.claude/prisma-setup.md`
 
 **Key Points:**
 - Always load Prisma client from explicit path, never default `@prisma/client`
-- Generate client via subprocess before requiring PrismaDataServer
-- Use `PrismaClientLoader.load()` to handle path resolution and connection config
-- Pass client instance to DataServer via `prismaClient` prop
+- Generate client via subprocess before connecting PrismaDataServer
+- Pass the `prismaModules` object to DataServer, `PrismaDataServer.connect()` validates it with `PrismaModulesValidator`
 
 ---
 

package/CLAUDE.md

@@ -137,6 +137,16 @@ npx reldens-storage-prisma --host=<host> --database=<db> --user=<user> --passwor
 - `prisma-type-caster.js`: Type casting and normalization
 - `prisma-relation-resolver.js`: Relation mapping and transformations
 - `prisma-client-loader.js`: Utility for loading Prisma Client instances
+- `prisma-modules-validator.js`: Validates the `prismaModules` object passed by the consumer
+- **Prisma is not a dependency of this package**: no Prisma package is listed in `package.json`, no `lib/` file
+  requires `@prisma/*`. Consumers install `prisma`, `@prisma/client` and `@prisma/adapter-mariadb` themselves and
+  pass everything through one `prismaModules` object: `{PrismaClient, Prisma, PrismaAdapter, adapter, client}`.
+  `PrismaAdapter` is any Prisma driver adapter class (instantiated with the connection string), `adapter` is an
+  already instantiated adapter used as is, the package never forces a specific adapter.
+  `PrismaDataServer.connect()` validates it with `PrismaModulesValidator` (capability checks on the instance:
+  `$connect`, `$disconnect`, `$queryRaw`, `$queryRawUnsafe`, `$executeRawUnsafe`, `$transaction`,
+  `_runtimeDataModel`) and builds the client from `PrismaClient` + `PrismaClientLoader.resolveAdapter()` only
+  when no `client` was passed. `Prisma.DbNull` is read from `prismaModules.Prisma`.
 - Features:
   - Schema-first approach with auto-introspection
   - Type-safe queries with Prisma Client
@@ -284,6 +294,26 @@ All generated entity relations follow the `related_*` prefix pattern:
 
 This pattern is consistent across all ORM drivers and is defined in `entities-config.js`.
 
+## Reference Properties Delete Rule
+
+Every generated `type: 'reference'` property also carries the foreign key referential action as
+`onDelete: '<rule>'`, so consumers can tell what a parent delete does to the child rows without querying the
+schema themselves.
+
+- `MysqlTablesProvider` joins `information_schema.REFERENTIAL_CONSTRAINTS` on the FK constraint name and stores
+  the raw `DELETE_RULE` as `column.referencedDeleteRule`.
+- `BaseGenerator.mapDeleteRule()` normalizes it to camel case, matching the Prisma vocabulary: `CASCADE` becomes
+  `cascade`, `SET NULL` becomes `setNull`, `NO ACTION` becomes `noAction`, `SET DEFAULT` becomes `setDefault`,
+  `RESTRICT` stays `restrict`.
+- `BaseGenerator.addReferenceDeleteRule()` pushes the attribute, called from
+  `EntitiesGeneration.addTypeAttribute()` right after the `alias`. Only the entities are affected, the ORM model
+  generation does not emit it.
+- The property is omitted when there is no rule to report, so an entity generated before this existed simply has
+  no `onDelete` and consumers must treat a missing value as unknown rather than assuming a default.
+
+Regenerating entities is required after changing a foreign key referential action: the rule is read live from
+`information_schema`, not from `prisma/schema.prisma`, and `prisma db pull` alone does not update it.
+
 ## Prisma Driver Validation System
 
 ### ensureRequiredFields() Method
@@ -450,7 +480,7 @@ The `prepareDataWithRelations()` method (lines 156-199) automatically converts F
 
 **Method:**
 ```javascript
-PrismaClientLoader.load(projectPath, customPath, connectionData)
+PrismaClientLoader.load(projectPath, customPath, connectionData, prismaModules)
 ```
 
 **Parameters:**
@@ -463,27 +493,33 @@ PrismaClientLoader.load(projectPath, customPath, connectionData)
   - `host` (string): Database host
   - `port` (number): Database port
   - `database` (string): Database name
+- `prismaModules` (object): Must contain a `PrismaAdapter` class or an `adapter` instance, required from the
+  consumer project (any Prisma driver adapter)
 
-**Returns:** PrismaClient instance or null on error
+**Returns:** the completed `prismaModules` object (`PrismaClient`, `Prisma`, the adapter, `client`) or null on error
 
 **Behavior:**
 - If `customPath` is provided, uses that path
 - Otherwise, uses a default path: `projectPath/prisma/client`
 - Validates that Prisma Client exists at the path
-- Requires `prismaModule.PrismaClient` export
-- If `connectionData` is null: Creates adapter using `process.env.DATABASE_URL`
-- If `connectionData` is provided: Builds connection string and creates `PrismaMariaDb` adapter
-- Returns initialized PrismaClient instance
-- **Prisma v7**: Uses `@prisma/adapter-mariadb` - `PrismaClient` constructor receives `{ adapter }` instead of `{ datasources }`
+- Requires `prismaModule.PrismaClient` export, copies `PrismaClient` and `Prisma` from it into `prismaModules`
+- If `connectionData` is null: Creates adapter using `process.env.RELDENS_DB_URL`
+- If `connectionData` is provided: Builds connection string and creates the adapter
+- `createWithAdapter(prismaModules, connectionUrl)` validates the object with `PrismaModulesValidator`, sets
+  `prismaModules.client` and returns the object
+- `resolveAdapter(prismaModules, connectionUrl)` returns `prismaModules.adapter` when present, otherwise
+  `new prismaModules.PrismaAdapter(connectionUrl)`; also used by `PrismaDataServer.connect()`
+- **Prisma v7**: `PrismaClient` constructor receives `{ adapter }` instead of `{ datasources }`
 
 **Usage Examples:**
 
 Using the default connection from schema:
 ```javascript
 const { PrismaClientLoader } = require('@reldens/storage');
+const { PrismaMariaDb } = require('@prisma/adapter-mariadb');
 
-const prismaClient = PrismaClientLoader.load(process.cwd(), null, null);
-if(!prismaClient){
+let prismaModules = PrismaClientLoader.load(process.cwd(), null, null, {PrismaAdapter: PrismaMariaDb});
+if(!prismaModules){
     console.error('Failed to load Prisma client');
     process.exit(1);
 }
@@ -492,8 +528,9 @@ if(!prismaClient){
 Using custom connection:
 ```javascript
 const { PrismaClientLoader } = require('@reldens/storage');
+const { PrismaMariaDb } = require('@prisma/adapter-mariadb');
 
-const prismaClient = PrismaClientLoader.load(
+let prismaModules = PrismaClientLoader.load(
     process.cwd(),
     null,
     {
@@ -503,15 +540,27 @@ const prismaClient = PrismaClientLoader.load(
         host: 'localhost',
         port: 3306,
         database: 'mydb'
-    }
+    },
+    {PrismaAdapter: PrismaMariaDb}
 );
 
-if(!prismaClient){
+if(!prismaModules){
     console.error('Failed to load Prisma client');
     process.exit(1);
 }
 ```
 
+**CLI:** `bin/reldens-storage.js` resolves the adapter package from `--prismaAdapter` (default
+`@prisma/adapter-mariadb`, looked up in `[path]/node_modules` or used as an absolute path) and the class from
+`--prismaAdapterClass` (default `PrismaMariaDb`), then passes `{PrismaAdapter}` to the loader and the resulting
+`prismaModules` to `EntitiesGenerator`.
+
+**Tests:** the Prisma driver runs only when `RELDENS_TEST_PRISMA_ENABLED=1` is set (in the shell or in
+`tests/.env.test`) and the three Prisma packages resolve (`TestHelpers.isPrismaEnabled()`). Otherwise Prisma is
+not mentioned in the test output at all. Install them locally without saving:
+`npm install --no-save prisma@7.9.1 @prisma/client@7.9.1 @prisma/adapter-mariadb@7.9.1`. See
+`.claude/prisma-setup.md` for the full install, run and uninstall workflow.
+
 **Used By:**
 - `bin/reldens-storage.js`: CLI entity generator
 - External packages: `@reldens/cms` CLI tools (update-password, generate-entities, generate-sitemap)

package/README.md

@@ -47,6 +47,9 @@ npx reldens-storage generateEntities --user=[dbuser] --pass=[dbpass] --database=
 - `--host=[host]` - Database host (default: localhost)
 - `--port=[port]` - Database port (default: 3306)
 - `--path=[path]` - Project path for output files (default: current directory)
+- `--prismaClientPath=[path]` - Prisma only: path to the generated Prisma client (default: `[path]/prisma/client`)
+- `--prismaAdapter=[package-or-path]` - Prisma only: driver adapter package resolved from `[path]/node_modules`, or an absolute path (default: `@prisma/adapter-mariadb`)
+- `--prismaAdapterClass=[export-name]` - Prisma only: adapter class exported by that package (default: `PrismaMariaDb`)
 - `--override` - Regenerate all files even if they exist
 
 **Smart Generation:**
@@ -141,7 +144,12 @@ const entities = server.generateEntities();
 
 ### Using Prisma
 
-First, generate your Prisma schema:
+Prisma is not installed by this package. Install it in your project first:
+```bash
+npm install prisma @prisma/client @prisma/adapter-mariadb
+```
+
+Then generate your Prisma schema:
 ```bash
 npx reldens-generate-prisma-schema --host=localhost --port=3306 --user=dbuser --password=dbpass --database=dbname
 ```
@@ -160,9 +168,12 @@ Or pass parameters directly:
 npx reldens-generate-prisma-schema --host=your-rds-host.amazonaws.com --port=3306 --user=dbuser --password=dbpass --database=dbname --dbParams="authPlugin=mysql_native_password&sslmode=require"
 ```
 
-Then, use the PrismaDataServer in your code:
+Then, pass your Prisma classes to the PrismaDataServer through the `prismaModules` object. Any Prisma driver
+adapter works, `@prisma/adapter-mariadb` is only the example:
 ```javascript
 const { PrismaDataServer } = require('@reldens/storage');
+const { PrismaClient, Prisma } = require('./prisma/client');
+const { PrismaMariaDb } = require('@prisma/adapter-mariadb');
 
 const server = new PrismaDataServer({
     client: 'mysql',
@@ -173,13 +184,23 @@ const server = new PrismaDataServer({
         host: 'localhost',
         port: 3306
     },
-    rawEntities: yourEntities
+    rawEntities: yourEntities,
+    prismaModules: {PrismaClient, Prisma, PrismaAdapter: PrismaMariaDb}
 });
 
 await server.connect();
 const entities = server.generateEntities();
 ```
 
+The `prismaModules` object:
+- `PrismaClient`: the class exported by your generated client (required unless `client` is passed)
+- `Prisma`: the namespace exported by your generated client, used for `Prisma.DbNull` (required)
+- `PrismaAdapter`: any Prisma driver adapter class, instantiated with the connection string (required unless `adapter` or `client` is passed)
+- `adapter`: an already instantiated Prisma driver adapter, used as is (optional, replaces `PrismaAdapter`)
+- `client`: an already instantiated Prisma client (optional, skips the client construction)
+
+The object is validated on `connect()`, the driver refuses to start when a required class or method is missing.
+
 Note: The PrismaDataServer requires the Prisma schema to be generated first. Make sure to run the `reldens-generate-prisma-schema` command before using PrismaDataServer.
 
 ### Loading Prisma Client Programmatically
@@ -189,9 +210,10 @@ If you need to load a Prisma Client instance in your CLI tools or applications:
 Using the default connection from schema:
 ```javascript
 const { PrismaClientLoader } = require('@reldens/storage');
+const { PrismaMariaDb } = require('@prisma/adapter-mariadb');
 
-const prismaClient = PrismaClientLoader.load(process.cwd(), null, null);
-if(!prismaClient){
+let prismaModules = PrismaClientLoader.load(process.cwd(), null, null, {PrismaAdapter: PrismaMariaDb});
+if(!prismaModules){
     console.error('Failed to load Prisma client');
     process.exit(1);
 }
@@ -200,8 +222,9 @@ if(!prismaClient){
 Using custom connection:
 ```javascript
 const { PrismaClientLoader } = require('@reldens/storage');
+const { PrismaMariaDb } = require('@prisma/adapter-mariadb');
 
-const prismaClient = PrismaClientLoader.load(
+let prismaModules = PrismaClientLoader.load(
     process.cwd(),
     null,
     {
@@ -211,10 +234,11 @@ const prismaClient = PrismaClientLoader.load(
         host: 'localhost',
         port: 3306,
         database: 'mydb'
-    }
+    },
+    {PrismaAdapter: PrismaMariaDb}
 );
 
-if(!prismaClient){
+if(!prismaModules){
     console.error('Failed to load Prisma client');
     process.exit(1);
 }
@@ -224,6 +248,9 @@ Parameters:
 - `projectPath`: Project root directory
 - `customPath`: Optional custom path to a Prisma client (null for default)
 - `connectionData`: Optional database connection configuration object (null to use schema default)
+- `prismaModules`: Object with the `PrismaAdapter` class (or an `adapter` instance)
+
+Returns the completed `prismaModules` object (`PrismaClient`, `Prisma`, the adapter and the instantiated `client`), ready to be passed to `PrismaDataServer`, or null on error.
 
 ## Custom Drivers
 

package/bin/reldens-storage.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 
 /**
  *
@@ -8,6 +8,7 @@
 
 const { EntitiesGenerator } = require('../lib/entities-generator');
 const { PrismaClientLoader } = require('../lib/prisma/prisma-client-loader');
+const { FileHandler } = require('@reldens/server-utils');
 const { Logger, sc } = require('@reldens/utils');
 
 class StorageEntitiesGenerator
@@ -21,6 +22,8 @@ class StorageEntitiesGenerator
         this.projectPath = process.cwd();
         this.isOverride = false;
         this.prismaClientPath = '';
+        this.prismaAdapter = '@prisma/adapter-mariadb';
+        this.prismaAdapterClass = 'PrismaMariaDb';
         this.parseArguments();
     }
 
@@ -49,6 +52,14 @@ class StorageEntitiesGenerator
                 this.prismaClientPath = value;
                 continue;
             }
+            if('prismaAdapter' === key){
+                this.prismaAdapter = value;
+                continue;
+            }
+            if('prismaAdapterClass' === key){
+                this.prismaAdapterClass = value;
+                continue;
+            }
             if('pass' === key){
                 this.config['password'] = value;
                 continue;
@@ -102,6 +113,8 @@ class StorageEntitiesGenerator
                 +' --driver=[driver-map-key]'
                 +' --client=[db-client]'
                 +' --prismaClientPath=[path-to-prisma-client]'
+                +' --prismaAdapter=[prisma-adapter-package-or-path]'
+                +' --prismaAdapterClass=[prisma-adapter-export-name]'
                 +' --path=[project-path] --override',
                 'Optional flags:',
                 '  --override    Regenerate all files even if they exist'
@@ -111,13 +124,34 @@ class StorageEntitiesGenerator
         return true;
     }
 
-    loadPrismaClient(connectionData)
+    loadPrismaModules(connectionData)
     {
-        let loadedClient = PrismaClientLoader.load(this.projectPath, this.prismaClientPath, connectionData);
-        if(!loadedClient){
+        let adapterPath = FileHandler.joinPaths(this.projectPath, 'node_modules', this.prismaAdapter);
+        if(!FileHandler.exists(adapterPath)){
+            adapterPath = this.prismaAdapter;
+        }
+        if(!FileHandler.exists(adapterPath)){
+            Logger.critical(
+                'Prisma adapter "'+this.prismaAdapter+'" not found in the project.'
+                +' Run: npm install prisma @prisma/client '+this.prismaAdapter
+            );
+            return null;
+        }
+        let adapterModule = require(adapterPath);
+        if(!sc.isFunction(adapterModule[this.prismaAdapterClass])){
+            Logger.critical('Prisma adapter class "'+this.prismaAdapterClass+'" not exported by: '+adapterPath);
+            return null;
+        }
+        let loadedModules = PrismaClientLoader.load(
+            this.projectPath,
+            this.prismaClientPath,
+            connectionData,
+            {PrismaAdapter: adapterModule[this.prismaAdapterClass]}
+        );
+        if(!loadedModules){
             Logger.info('Please run "npx prisma generate" first or provide --prismaClientPath argument.');
         }
-        return loadedClient;
+        return loadedModules;
     }
 
     async run()
@@ -135,11 +169,11 @@ class StorageEntitiesGenerator
             isOverride: this.isOverride
         };
         if('prisma' === connectionData.driver){
-            let prismaClient = this.loadPrismaClient(connectionData);
-            if(!prismaClient){
+            let prismaModules = this.loadPrismaModules(connectionData);
+            if(!prismaModules){
                 return false;
             }
-            generatorProps.prismaClient = prismaClient;
+            generatorProps.prismaModules = prismaModules;
         }
         let generator = new EntitiesGenerator(generatorProps);
         let success = await generator.generate();

package/index.js

@@ -20,6 +20,7 @@ const { PrismaDriver } = require('./lib/prisma/prisma-driver');
 const { PrismaDataServer } = require('./lib/prisma/prisma-data-server');
 const { PrismaSchemaGenerator } = require('./lib/prisma/prisma-schema-generator');
 const { PrismaClientLoader } = require('./lib/prisma/prisma-client-loader');
+const { PrismaModulesValidator } = require('./lib/prisma/prisma-modules-validator');
 const { RELATION_PREFIX } = require('./lib/relation-key');
 
 module.exports = {
@@ -49,6 +50,7 @@ module.exports = {
     PrismaDriver,
     PrismaSchemaGenerator,
     PrismaClientLoader,
+    PrismaModulesValidator,
     // entities:
     EntitiesGenerator,
     EntityProperties,

package/lib/entities-generator.js

@@ -49,7 +49,7 @@ class EntitiesGenerator
         this.server = sc.get(props, 'server', false);
         this.connectionData = sc.get(props, 'connectionData', false);
         this.isOverride = sc.get(props, 'isOverride', false);
-        this.prismaClient = sc.get(props, 'prismaClient', false);
+        this.prismaModules = sc.get(props, 'prismaModules', false);
         this.generatedEntities = {};
         this.existingEntities = {};
         this.existingEntityFields = {};
@@ -264,12 +264,12 @@ class EntitiesGenerator
             (this.server ? sc.get(this.driversClassMap, this.server.constructor.name, false) : false)
         );
         if('prisma' === driverKey){
-            if(!this.prismaClient && this.server.prisma){
-                this.prismaClient = this.server.prisma;
+            if(!this.prismaModules && this.server.prismaModules){
+                this.prismaModules = this.server.prismaModules;
             }
             //Logger.debug('Extract Prisma relations metadata.');
             this.prismaRelationsMetadata = new PrismaRelationsMetadataExtractor({
-                prismaClient: this.prismaClient,
+                prismaClient: sc.get(this.prismaModules, 'client', false),
                 projectRoot: this.server ? this.server.projectRoot : false,
                 projectPath: this.projectPath
             }).extract();
@@ -357,8 +357,8 @@ class EntitiesGenerator
             },
             projectRoot: this.projectPath
         };
-        if('prisma' === driverKey && this.prismaClient){
-            serverConfig.prismaClient = this.prismaClient;
+        if('prisma' === driverKey && this.prismaModules){
+            serverConfig.prismaModules = this.prismaModules;
         }
         this.server = new driverClassMapped(serverConfig);
         return this.server;

package/lib/prisma/prisma-client-loader.js

@@ -4,14 +4,14 @@
  *
  */
 
-const { Logger } = require('@reldens/utils');
+const { PrismaModulesValidator } = require('./prisma-modules-validator');
 const { FileHandler } = require('@reldens/server-utils');
-const { PrismaMariaDb } = require('@prisma/adapter-mariadb');
+const { Logger, sc } = require('@reldens/utils');
 
 class PrismaClientLoader
 {
 
-    static load(projectPath, customPath, connectionData)
+    static load(projectPath, customPath, connectionData, prismaModules)
     {
         let prismaClientPath = customPath;
         if(!prismaClientPath){
@@ -27,9 +27,13 @@ class PrismaClientLoader
             Logger.critical('PrismaClient class not found at: '+prismaClientPath);
             return null;
         }
+        let completedModules = Object.assign({}, prismaModules, {
+            PrismaClient: prismaModule.PrismaClient,
+            Prisma: prismaModule.Prisma
+        });
         if(!connectionData){
             Logger.info('Creating PrismaClient with default connection from schema');
-            return PrismaClientLoader.createWithAdapter(prismaModule.PrismaClient, process.env.RELDENS_DB_URL);
+            return PrismaClientLoader.createWithAdapter(completedModules, process.env.RELDENS_DB_URL);
         }
         let connectionString = connectionData.client+'://'
             +connectionData.user
@@ -38,17 +42,37 @@ class PrismaClientLoader
             +':'+connectionData.port
             +'/'+connectionData.database;
         Logger.info('Creating PrismaClient with connection to: '+connectionData.database);
-        return PrismaClientLoader.createWithAdapter(prismaModule.PrismaClient, connectionString);
+        return PrismaClientLoader.createWithAdapter(completedModules, connectionString);
     }
 
     /**
-     * @param {Function} PrismaClientClass
+     * @param {Object} prismaModules
+     * @param {string} connectionUrl
+     * @returns {Object|null}
+     */
+    static createWithAdapter(prismaModules, connectionUrl)
+    {
+        if(!PrismaModulesValidator.validate(prismaModules)){
+            return null;
+        }
+        prismaModules.client = new prismaModules.PrismaClient({
+            adapter: PrismaClientLoader.resolveAdapter(prismaModules, connectionUrl),
+            log: ['error']
+        });
+        return prismaModules;
+    }
+
+    /**
+     * @param {Object} prismaModules
      * @param {string} connectionUrl
      * @returns {Object}
      */
-    static createWithAdapter(PrismaClientClass, connectionUrl)
+    static resolveAdapter(prismaModules, connectionUrl)
     {
-        return new PrismaClientClass({adapter: new PrismaMariaDb(connectionUrl), log: ['error']});
+        if(sc.isObject(prismaModules.adapter)){
+            return prismaModules.adapter;
+        }
+        return new prismaModules.PrismaAdapter(connectionUrl);
     }
 
 }

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

@@ -7,9 +7,8 @@
 const { BaseDataServer } = require('../base-data-server');
 const { PrismaDriver } = require('./prisma-driver');
 const { MySQLTablesProvider } = require('../mysql-tables-provider');
-const { PrismaClient, Prisma } = require('@prisma/client');
-const { PrismaMariaDb } = require('@prisma/adapter-mariadb');
-const { FileHandler } = require('@reldens/server-utils');
+const { PrismaModulesValidator } = require('./prisma-modules-validator');
+const { PrismaClientLoader } = require('./prisma-client-loader');
 const { Logger, sc } = require('@reldens/utils');
 
 class PrismaDataServer extends BaseDataServer
@@ -18,7 +17,8 @@ class PrismaDataServer extends BaseDataServer
     constructor(props)
     {
         super(props);
-        this.prisma = sc.get(props, 'prismaClient', false);
+        this.prismaModules = sc.get(props, 'prismaModules', false);
+        this.prisma = sc.get(this.prismaModules, 'client', false);
         this.projectRoot = sc.get(props, 'projectRoot', false);
         this.allRelationMappings = {};
     }
@@ -28,16 +28,16 @@ class PrismaDataServer extends BaseDataServer
         if(this.initialized){
             return this.initialized;
         }
+        if(!PrismaModulesValidator.validate(this.prismaModules)){
+            return false;
+        }
         try {
-            if(!this.prisma && this.defaultClientIsGenerated()){
-                this.prisma = new PrismaClient({
-                    adapter: new PrismaMariaDb(this.connectString),
+            if(!this.prisma){
+                this.prisma = new this.prismaModules.PrismaClient({
+                    adapter: PrismaClientLoader.resolveAdapter(this.prismaModules, this.connectString),
                     log: this.debug ? ['query', 'info', 'warn', 'error'] : ['error']
                 });
-            }
-            if(!this.prisma){
-                Logger.error('Prisma client could not be initialized.');
-                return false;
+                this.prismaModules.client = this.prisma;
             }
             await this.prisma.$connect();
             let dbTest = await this.prisma.$queryRaw`SELECT DATABASE() as current_db`;
@@ -50,20 +50,6 @@ class PrismaDataServer extends BaseDataServer
         return false;
     }
 
-    defaultClientIsGenerated()
-    {
-        let existsFromProjectRoot = false;
-        if(this.projectRoot){
-            existsFromProjectRoot = FileHandler.exists(FileHandler.joinPaths(
-                this.projectRoot, 'node_modules', '@prisma', 'client', 'index.js'
-            ));
-        }
-        let existsFromRelativePath = FileHandler.exists(FileHandler.joinPaths(
-            __dirname, '..', '..', '..', '@prisma', 'client', 'index.js'
-        ));
-        return existsFromProjectRoot || existsFromRelativePath;
-    }
-
     generateEntities()
     {
         if(!this.initialized){
@@ -93,7 +79,7 @@ class PrismaDataServer extends BaseDataServer
                 model: prismaModel,
                 server: this,
                 allRelationMappings: this.allRelationMappings,
-                prismaDbNull: Prisma.DbNull
+                prismaDbNull: this.prismaModules.Prisma.DbNull
             });
         }
         this.entityManager.setEntities(this.entities);

package/lib/prisma/prisma-modules-validator.js

@@ -0,0 +1,63 @@
+/**
+ *
+ * Reldens - PrismaModulesValidator
+ *
+ */
+
+const { Logger, sc } = require('@reldens/utils');
+
+class PrismaModulesValidator
+{
+
+    static validate(prismaModules)
+    {
+        if(!sc.isObject(prismaModules)){
+            Logger.critical('Missing "prismaModules" object.');
+            return false;
+        }
+        if(!sc.isObject(prismaModules.Prisma) || !sc.hasOwn(prismaModules.Prisma, 'DbNull')){
+            Logger.critical('Invalid "prismaModules.Prisma", "DbNull" not found.');
+            return false;
+        }
+        if(prismaModules.client){
+            return PrismaModulesValidator.validateClientInstance(prismaModules.client);
+        }
+        if(!sc.isFunction(prismaModules.PrismaClient)){
+            Logger.critical('Invalid "prismaModules.PrismaClient".');
+            return false;
+        }
+        if(sc.isObject(prismaModules.adapter)){
+            return true;
+        }
+        if(!sc.isFunction(prismaModules.PrismaAdapter)){
+            Logger.critical('Missing "prismaModules.adapter" instance or "prismaModules.PrismaAdapter" class.');
+            return false;
+        }
+        return true;
+    }
+
+    static validateClientInstance(client)
+    {
+        let requiredMethods = [
+            '$connect',
+            '$disconnect',
+            '$queryRaw',
+            '$queryRawUnsafe',
+            '$executeRawUnsafe',
+            '$transaction'
+        ];
+        let missingMethods = requiredMethods.filter(method => !sc.isFunction(client[method]));
+        if(0 < missingMethods.length){
+            Logger.critical('Invalid Prisma client instance, missing: '+missingMethods.join(', '));
+            return false;
+        }
+        if(!sc.isObject(sc.get(client, '_runtimeDataModel', false))){
+            Logger.critical('Invalid Prisma client instance, "_runtimeDataModel" not found.');
+            return false;
+        }
+        return true;
+    }
+
+}
+
+module.exports.PrismaModulesValidator = PrismaModulesValidator;

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@reldens/storage",
     "scope": "@reldens",
-    "version": "0.111.0",
+    "version": "0.113.0",
     "description": "Reldens - Storage",
     "author": "Damian A. Pastorini",
     "license": "MIT",
@@ -51,17 +51,14 @@
         "test:driver": "node tests/run-tests.js --driver="
     },
     "dependencies": {
-        "@mikro-orm/core": "7.1.11",
-        "@mikro-orm/mongodb": "7.1.11",
-        "@mikro-orm/mysql": "7.1.11",
-        "@prisma/adapter-mariadb": "7.9.1",
-        "@prisma/client": "7.9.1",
-        "@reldens/server-utils": "^0.56.0",
+        "@mikro-orm/core": "7.1.14",
+        "@mikro-orm/mongodb": "7.1.14",
+        "@mikro-orm/mysql": "7.1.14",
+        "@reldens/server-utils": "^0.57.0",
         "@reldens/utils": "^0.57.0",
         "knex": "3.3.0",
         "mysql": "2.18.1",
-        "mysql2": "3.23.3",
-        "objection": "3.1.5",
-        "prisma": "7.9.1"
+        "mysql2": "3.24.3",
+        "objection": "3.1.5"
     }
 }

package/tests/.env.test.example

@@ -5,3 +5,4 @@ RELDENS_TEST_DB_PASSWORD=test_password
 RELDENS_TEST_DB_NAME=reldens_storage_test
 RELDENS_TEST_DB_CLIENT=mysql
 RELDENS_DB_URL=mysql://test_user:test_password@localhost:3306/reldens_storage_test
+RELDENS_TEST_PRISMA_ENABLED=0

package/tests/run-tests.js

@@ -20,7 +20,7 @@ const EntitiesGenerationTest = require('./unit/test-entities-generation');
 if(!process.env.RELDENS_TEST_DB_HOST){
     let envPath = FileHandler.joinPaths(__dirname, '.env.test');
     if(FileHandler.exists(envPath)){
-        require('dotenv').config({path: envPath});
+        process.loadEnvFile(envPath);
     }
 }
 
@@ -117,7 +117,7 @@ class RunTests
 
     async runIntegrationTests()
     {
-        let driverNames = ['objection-js', 'mikro-orm', 'prisma'];
+        let driverNames = TestHelpers.activeDriverNames();
         if(this.driver){
             driverNames = [this.driver];
         }

package/tests/unit/test-drivers.js

@@ -6,6 +6,7 @@
  */
 
 const { TestRunner, assert } = require('../utils/test-runner');
+const { TestHelpers } = require('../utils/test-helpers');
 const { ObjectionJsDriver } = require('../../lib/objection-js/objection-js-driver');
 const { MikroOrmDriver } = require('../../lib/mikro-orm/mikro-orm-driver');
 const { PrismaDriver } = require('../../lib/prisma/prisma-driver');
@@ -18,9 +19,11 @@ class DriversUnitTest
         this.runner = new TestRunner();
         this.DRIVERS = [
             {name: 'objection-js', class: ObjectionJsDriver},
-            {name: 'mikro-orm', class: MikroOrmDriver},
-            {name: 'prisma', class: PrismaDriver}
+            {name: 'mikro-orm', class: MikroOrmDriver}
         ];
+        if(TestHelpers.isPrismaEnabled()){
+            this.DRIVERS.push({name: 'prisma', class: PrismaDriver});
+        }
         this.SHARED_PUBLIC_METHODS = [
             'databaseName',
             'id',

package/tests/utils/driver-registry.js

@@ -23,7 +23,7 @@ class DriverRegistry
         };
         this.schemaPath = FileHandler.joinPaths(__dirname, '..', 'fixtures', 'sql', 'test-schema.sql');
         this.repoNames = ['testCategories', 'testProducts', 'testReviews'];
-        this.driverNames = ['objection-js', 'mikro-orm', 'prisma'];
+        this.driverNames = TestHelpers.activeDriverNames();
         this.skipGeneration = false;
     }
 

package/tests/utils/test-helpers.js

@@ -6,8 +6,10 @@
 
 const { FileHandler } = require('@reldens/server-utils');
 const { Logger, sc } = require('@reldens/utils');
-const { exec } = require('child_process');
+const { exec, execSync } = require('child_process');
 const { promisify } = require('util');
+const { delimiter } = require('path');
+const NodeModule = require('module');
 const execAsync = promisify(exec);
 
 class TestHelpers
@@ -44,11 +46,11 @@ class TestHelpers
                 rawEntities: rawEntities
             };
             if('prisma' === driverName){
-                let prismaClient = await this.loadPrismaClient(process.cwd(), config);
-                if(!prismaClient){
-                    throw new Error('Failed to load Prisma client');
+                let prismaModules = await this.loadPrismaModules(process.cwd(), config);
+                if(!prismaModules){
+                    throw new Error('Failed to load Prisma modules');
                 }
-                serverConfig.prismaClient = prismaClient;
+                serverConfig.prismaModules = prismaModules;
             }
             let DataServerClass = this.getDataServerClass(driverName);
             let dataServer = new DataServerClass(serverConfig);
@@ -253,7 +255,7 @@ class TestHelpers
         return true;
     }
 
-    static verifyPackageInstallation(packageName, version)
+    static verifyPackageInstallation(packageName, version, isOptional)
     {
         let packagePath = FileHandler.joinPaths(
             process.cwd(),
@@ -261,7 +263,18 @@ class TestHelpers
             packageName,
             'package.json'
         );
+        if(!FileHandler.exists(packagePath) && isOptional && process.env.RELDENS_TEST_NPM_GLOBAL_ROOT){
+            packagePath = FileHandler.joinPaths(
+                process.env.RELDENS_TEST_NPM_GLOBAL_ROOT,
+                packageName,
+                'package.json'
+            );
+        }
         if(!FileHandler.exists(packagePath)){
+            if(isOptional){
+                Logger.warning('Optional package not installed: '+packageName);
+                return false;
+            }
             Logger.critical('Required package not installed: '+packageName);
             return false;
         }
@@ -278,26 +291,104 @@ class TestHelpers
     static verifyAllPackages()
     {
         let required = [
-            {name: '@mikro-orm/core', version: '7.1.11'},
-            {name: '@mikro-orm/mongodb', version: '7.1.11'},
-            {name: '@mikro-orm/mysql', version: '7.1.11'},
-            {name: '@prisma/client', version: '7.9.1'},
-            {name: '@prisma/adapter-mariadb', version: '7.9.1'},
+            {name: '@mikro-orm/core', version: '7.1.14'},
+            {name: '@mikro-orm/mongodb', version: '7.1.14'},
+            {name: '@mikro-orm/mysql', version: '7.1.14'},
             {name: 'knex', version: '3.3.0'},
             {name: 'mysql', version: '2.18.1'},
-            {name: 'mysql2', version: '3.23.3'},
-            {name: 'objection', version: '3.1.5'},
-            {name: 'prisma', version: '7.9.1'}
+            {name: 'mysql2', version: '3.24.3'},
+            {name: 'objection', version: '3.1.5'}
         ];
+        if(this.isPrismaFlagEnabled()){
+            required.push({name: 'prisma', version: '7.9.1', optional: true});
+            required.push({name: '@prisma/client', version: '7.9.1', optional: true});
+            required.push({name: '@prisma/adapter-mariadb', version: '7.9.1', optional: true});
+        }
         let allVerified = true;
         for(let pkg of required){
-            if(!this.verifyPackageInstallation(pkg.name, pkg.version)){
+            let isOptional = sc.get(pkg, 'optional', false);
+            if(!this.verifyPackageInstallation(pkg.name, pkg.version, isOptional) && !isOptional){
                 allVerified = false;
             }
         }
         return allVerified;
     }
 
+    static isPrismaAvailable()
+    {
+        let resolvableEntries = {
+            'prisma': 'prisma/package.json',
+            '@prisma/client': '@prisma/client',
+            '@prisma/adapter-mariadb': '@prisma/adapter-mariadb'
+        };
+        for(let packageName of Object.keys(resolvableEntries)){
+            if(!this.canResolvePackage(resolvableEntries[packageName])){
+                Logger.warning('Prisma package not installed, Prisma driver tests skipped: '+packageName);
+                return false;
+            }
+        }
+        return true;
+    }
+
+    static canResolvePackage(specifier)
+    {
+        try {
+            require.resolve(specifier);
+            return true;
+        } catch(error) {
+            this.registerNpmGlobalPaths();
+        }
+        try {
+            require.resolve(specifier);
+            return true;
+        } catch(error) {
+            return false;
+        }
+    }
+
+    static registerNpmGlobalPaths()
+    {
+        if(process.env.RELDENS_TEST_NPM_GLOBAL_ROOT){
+            return process.env.RELDENS_TEST_NPM_GLOBAL_ROOT;
+        }
+        let globalRoot = '';
+        try {
+            globalRoot = execSync('npm root -g', {encoding: 'utf8'}).trim();
+        } catch(error) {
+            Logger.warning('Could not resolve the npm global root: '+error.message);
+            return '';
+        }
+        let extraPaths = [globalRoot, FileHandler.joinPaths(globalRoot, '@prisma', 'client', 'node_modules')];
+        let currentPaths = process.env.NODE_PATH ? process.env.NODE_PATH.split(delimiter) : [];
+        process.env.NODE_PATH = [...currentPaths, ...extraPaths].join(delimiter);
+        NodeModule._initPaths();
+        process.env.RELDENS_TEST_NPM_GLOBAL_ROOT = globalRoot;
+        Logger.info('Registered npm global root for Prisma packages: '+globalRoot);
+        return globalRoot;
+    }
+
+    static isPrismaFlagEnabled()
+    {
+        return '1' === String(process.env.RELDENS_TEST_PRISMA_ENABLED);
+    }
+
+    static isPrismaEnabled()
+    {
+        if(!this.isPrismaFlagEnabled()){
+            return false;
+        }
+        return this.isPrismaAvailable();
+    }
+
+    static activeDriverNames()
+    {
+        let driverNames = ['objection-js', 'mikro-orm'];
+        if(this.isPrismaEnabled()){
+            driverNames.push('prisma');
+        }
+        return driverNames;
+    }
+
     static async prismaClientExists()
     {
         return FileHandler.exists(FileHandler.joinPaths(
@@ -372,7 +463,7 @@ class TestHelpers
         return subprocessSuccess;
     }
 
-    static async loadPrismaClient(projectRoot, config)
+    static async loadPrismaModules(projectRoot, config)
     {
         try {
             let clientPath = FileHandler.joinPaths(projectRoot, 'prisma', 'client');
@@ -380,20 +471,25 @@ class TestHelpers
                 Logger.critical('Prisma client path does not exist: '+clientPath);
                 return false;
             }
-            let { PrismaClient } = require(clientPath);
-            if(!PrismaClient){
+            let prismaModule = require(clientPath);
+            if(!prismaModule.PrismaClient){
                 Logger.critical('PrismaClient not found in module.');
                 return false;
             }
-            let { PrismaMariaDb } = require('@prisma/adapter-mariadb');
+            let adapterModule = require('@prisma/adapter-mariadb');
             let adapterConfig = config
                 ? { host: config.host, port: config.port, user: config.user, password: config.password, database: config.database }
                 : process.env.RELDENS_DB_URL;
-            let client = new PrismaClient({ adapter: new PrismaMariaDb(adapterConfig) });
+            let client = new prismaModule.PrismaClient({ adapter: new adapterModule.PrismaMariaDb(adapterConfig) });
             await client.$connect();
-            return client;
+            return {
+                PrismaClient: prismaModule.PrismaClient,
+                Prisma: prismaModule.Prisma,
+                PrismaAdapter: adapterModule.PrismaMariaDb,
+                client
+            };
         } catch(error) {
-            Logger.critical('Failed to load Prisma client: '+error.message);
+            Logger.critical('Failed to load Prisma modules: '+error.message);
             return false;
         }
     }
@@ -562,11 +658,10 @@ class TestHelpers
             server: dataServer
         };
         if('prisma' === driverName){
-            let prismaClient = dataServer.prisma;
-            if(!prismaClient){
+            if(!dataServer.prisma){
                 throw new Error('Prisma client not available on dataServer');
             }
-            generatorProps.prismaClient = prismaClient;
+            generatorProps.prismaModules = dataServer.prismaModules;
         }
         let generator = new EntitiesGenerator(generatorProps);
         let result = await generator.generate();