@reldens/storage 0.116.0 → 0.118.0

package/.claude/test-architecture.md

@@ -52,6 +52,16 @@ let dataServer = new PrismaDataServer(serverConfig);
 - 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`
+- Only `knex` and `mysql2` ship with the package. The other drivers are opt in, each behind its own flag and install:
+  - `RELDENS_TEST_OBJECTION_ENABLED=1` with `npm install --no-save objection@3.1.5`
+  - `RELDENS_TEST_MIKRO_ORM_ENABLED=1` with `npm install --no-save @mikro-orm/core@7.2.0 @mikro-orm/mysql@7.2.0`
+  - `RELDENS_TEST_KYSELY_ENABLED=1` with `npm install --no-save kysely`
+  - `RELDENS_TEST_DRIZZLE_ENABLED=1` with `npm install --no-save drizzle-orm`
+  - Global installs (`npm install -g ...`) work for every driver except Prisma, `TestHelpers.registerNpmGlobalPaths()` adds the npm global root and the project `node_modules` to `NODE_PATH` before the loaders resolve the packages, but `prisma generate` only resolves `@prisma/client` from the project
+  - Everything in one command: `npm install --no-save objection@3.1.5 @mikro-orm/core@7.2.0 @mikro-orm/mysql@7.2.0 @mikro-orm/mongodb@7.2.0 kysely drizzle-orm prisma@7.10.0 @prisma/client@7.10.0 @prisma/adapter-mariadb@7.10.0`
+  - Always use that single command: any later `npm install`, with or without `--no-save`, prunes the `--no-save` packages from a previous run
+  - Run every driver: `RELDENS_TEST_OBJECTION_ENABLED=1 RELDENS_TEST_MIKRO_ORM_ENABLED=1 RELDENS_TEST_PRISMA_ENABLED=1 RELDENS_TEST_KYSELY_ENABLED=1 RELDENS_TEST_DRIZZLE_ENABLED=1 npm run test`
+- `TestHelpers.getTestDbConfig()` sets `connectionLimit: 2` and every test data server passes `poolConfig: {min: 0, max: 2}`, so six drivers plus the sample data servers stay under the MySQL connection limit
 - Full setup, enable and run instructions: `.claude/prisma-setup.md`
 
 **Key Points:**
@@ -189,7 +199,7 @@ describe('Driver: '+driverName, () => {
 
 ### Flow: Connection → Tables → Entity Generation → Repositories
 
-All three drivers follow this pattern:
+Every active driver follows this pattern:
 
 ```
 1. new DataServer({config, rawEntities})
@@ -396,7 +406,7 @@ static async generateTestEntities(dataServer, driverName)
             await dataServer.connect();
         }
     }
-    // Run EntitiesGenerator — introspects DB, writes entity + model files to generated-entities/
+    // Run EntitiesGenerator: introspects DB, writes entity + model files to generated-entities/
     await this.runEntitiesGenerator(dataServer, driverName);
     this.fixGeneratedRequirePaths();
     this.compareGeneratedWithExpected(driverName, 'entities');
@@ -413,7 +423,7 @@ static async generateTestEntities(dataServer, driverName)
 
 ### Entity Generation Flow
 
-`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.
+`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.
 
 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.
 
@@ -623,13 +633,13 @@ 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
+**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:**
+**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()`.
 
@@ -642,9 +652,9 @@ async testCreateOperations() {
 }
 ```
 
-**3. Teardown — runs once per driver (`DriverRegistry.cleanup()`):**
-- `dropTestTables()` — DROP all test 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
 
@@ -762,9 +772,9 @@ async testCreateOperations() {
 
 ## Summary: The Complete Flow
 
-**For each driver (objection-js, mikro-orm, prisma):**
+**For each active driver (knex always, the others behind their `RELDENS_TEST_*_ENABLED` flag):**
 
-**Initialization — once per driver:**
+**Initialization, once per driver:**
 
 1. Connect to database
    - ObjectionJS: create Knex instance
@@ -782,7 +792,7 @@ async testCreateOperations() {
    - 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:**
+**Per test group, cleanDatabase() at start of each group method:**
 - SET FOREIGN_KEY_CHECKS=0
 - DELETE FROM test_reviews
 - DELETE FROM test_products
@@ -791,7 +801,7 @@ async testCreateOperations() {
 
 **Per test:** create test data, perform operations, assert results.
 
-**Teardown — once per driver:**
+**Teardown, once per driver:**
 
 1. Drop all tables
    - SET FOREIGN_KEY_CHECKS=0
@@ -830,7 +840,7 @@ async testCreateOperations() {
 - ✅ Added error checking for entity generation
 
 **test-raw-queries.js:**
-- ✅ Added — covers rawQuery with single and multiple SQL statements
+- Added, covers rawQuery with single and multiple SQL statements
 
 ### Test Helpers (All Fixed)
 

package/CLAUDE.md

@@ -19,7 +19,7 @@
 ## Package Overview
 
 **@reldens/storage** is the database abstraction layer for Reldens. It provides:
-- Multi-ORM support (objection-js, mikro-orm, prisma)
+- Multi-ORM support (knex by default, plus kysely, drizzle, objection-js, mikro-orm and prisma as optional drivers)
 - Entity/model generation from database schemas
 - Unified API across different ORM drivers
 - Database connection management
@@ -166,6 +166,58 @@ npx reldens-storage-prisma --host=<host> --database=<db> --user=<user> --passwor
   - `_runtimeDataModel` in Prisma 7 is pruned: fields only contain `{ name, kind, type, relationName, dbName }` - `isId`, `isRequired`, `hasDefaultValue` are stripped. ID field detection falls back to `field.name === 'id' && field.kind === 'scalar'`
   - `prisma.config.js` at project root is generated automatically by `PrismaSchemaGenerator.generateConfigFile()` and cleaned up after tests
 
+**Knex, Kysely and Drizzle Drivers** (`lib/knex/`, `lib/kysely/`, `lib/drizzle/`):
+- All three extend `QueryBuilderDriver` (`lib/query-builder-driver.js`), which implements 26 of the 30
+  `BaseDriver` methods once as compositions of five primitives: `insertRow()`, `selectRows()`, `update()`,
+  `delete()`, `count()`. Each concrete driver implements only those five plus its own filter translation.
+- `RelationsLoader` (`lib/relations-loader.js`) loads relations with one extra query per relation level
+  (`WHERE to_column IN (parent values)`), reading the plain `relationMappings` data
+  (`{relation, tableName, from, to}`) emitted into the generated models. `HasManyRelation` yields an array,
+  `BelongsToOneRelation` and `HasOneRelation` yield one row or `null`. Nested paths (`a.b`) recurse through the
+  related driver's own loader. It also implements `createWithRelations()`, creating BelongsToOne parents before
+  the row and HasOne/HasMany children after it.
+- Relation filters become `IN (SELECT to_column FROM related WHERE ...)` sub queries, so `countWithRelations()`
+  equals `count()` and joins never inflate the counts.
+- `Mysql2ConnectionConfig` (`lib/mysql2-connection-config.js`) holds the mysql2 option whitelist that used to
+  live inside `ObjectionJsDataServer`; the Knex, Kysely and Drizzle data servers all sanitize through it.
+- `ObjectionJsDataServer` now extends `KnexDataServer`; the Knex connection code exists once.
+  `connectionErrorMessage()` is overridden so a failed Objection connection still logs
+  `'Connection failed, Objection JS error.'`.
+- Knex is the only driver package shipped as a dependency and the default driver. Objection, MikroORM, Kysely,
+  Drizzle and Prisma are NOT: the consumer passes `objectionModules` (`{Model}`), `mikroOrmModules`
+  (`{MikroORM, EntityCaseNamingStrategy, Collection, MySqlDriver|MongoDriver}`), `kyselyModules`
+  (`{Kysely, MysqlDialect, sql, db}`), `drizzleModules` (`{drizzle, orm, db}`) or `prismaModules`, each validated
+  on `connect()` by its `*ModulesValidator`. When the object is missing the data server resolves the packages from
+  the project `node_modules` through the matching `*ModulesLoader` (all built on `PackageResolver`).
+- Model generation: `QueryBuilderModelsGeneration` (`lib/query-builder-models-generation.js`) serves `knex` and
+  `kysely`, `DrizzleModelsGeneration` (`lib/drizzle/drizzle-models-generation.js`) extends it and emits the
+  `drizzle-orm/mysql-core` column builders through `TypeMapper.mapDbTypeToDrizzleBuilder()`. Both are registered
+  in `ModelsGeneration.driversGeneration`. Templates: `query-builder-model.template`, `drizzle-model.template`.
+- `parseEnumValues()` moved from `EntitiesGeneration` to `BaseGenerator` so the Drizzle `mysqlEnum` builder can
+  use it.
+- Tests: the `knex` driver runs on every `npm run test`. Every other driver runs only when its flag is `1` and its
+  packages resolve, locally or from the npm global root (`TestHelpers.registerNpmGlobalPaths()` adds
+  `npm root -g` and the project `node_modules` to `NODE_PATH`): `RELDENS_TEST_OBJECTION_ENABLED`,
+  `RELDENS_TEST_MIKRO_ORM_ENABLED`, `RELDENS_TEST_PRISMA_ENABLED`, `RELDENS_TEST_KYSELY_ENABLED`,
+  `RELDENS_TEST_DRIZZLE_ENABLED`. Install every optional driver in one go without touching `package.json`
+  (Prisma must be local, `prisma generate` never resolves `@prisma/client` from the global root):
+
+  ```bash
+  npm install --no-save objection@3.1.5 @mikro-orm/core@7.2.0 @mikro-orm/mysql@7.2.0 @mikro-orm/mongodb@7.2.0 kysely drizzle-orm prisma@7.10.0 @prisma/client@7.10.0 @prisma/adapter-mariadb@7.10.0
+  ```
+
+  Then run all six drivers:
+
+  ```bash
+  RELDENS_TEST_OBJECTION_ENABLED=1 RELDENS_TEST_MIKRO_ORM_ENABLED=1 RELDENS_TEST_PRISMA_ENABLED=1 RELDENS_TEST_KYSELY_ENABLED=1 RELDENS_TEST_DRIZZLE_ENABLED=1 npm run test
+  ```
+
+  Always install them in that single command: every `npm install`, with or without `--no-save`, prunes the
+  `--no-save` packages left by a previous run, so installing them in separate commands removes the earlier
+  ones. The cross driver equivalence suite runs
+  only when two or more drivers are active, and the benchmark table at the end of the run covers the drivers,
+  queries and CRUD suites of every active driver.
+
 ### Generators
 
 **EntitiesGeneration** (`lib/generators/entities-generation.js`):
@@ -454,8 +506,9 @@ The `prepareDataWithRelations()` method (lines 156-199) automatically converts F
 - ENUM changes: entity updates with new available values
 
 ### Driver-Specific Notes
-- **ObjectionJS**: Recommended driver, mature and stable
-- **MikroORM**: Use for MongoDB or NoSQL requirements
+- **Knex**: Default driver, the only one bundled with the package, fastest in the test benchmarks
+- **ObjectionJS**: Optional, no npm release in about two years, kept for existing projects
+- **MikroORM**: Optional, use for MongoDB or NoSQL requirements
 - **Prisma**: Requires schema generation first, then entity generation
 - Cannot mix drivers - regenerate all when switching drivers
 - Each driver has different relation syntax in generated models
@@ -517,10 +570,11 @@ Using the default connection from schema:
 ```javascript
 const { PrismaClientLoader } = require('@reldens/storage');
 const { PrismaMariaDb } = require('@prisma/adapter-mariadb');
+const { Logger } = require('@reldens/utils');
 
 let prismaModules = PrismaClientLoader.load(process.cwd(), null, null, {PrismaAdapter: PrismaMariaDb});
 if(!prismaModules){
-    console.error('Failed to load Prisma client');
+    Logger.error('Failed to load Prisma client');
     process.exit(1);
 }
 ```
@@ -529,6 +583,7 @@ Using custom connection:
 ```javascript
 const { PrismaClientLoader } = require('@reldens/storage');
 const { PrismaMariaDb } = require('@prisma/adapter-mariadb');
+const { Logger } = require('@reldens/utils');
 
 let prismaModules = PrismaClientLoader.load(
     process.cwd(),
@@ -545,7 +600,7 @@ let prismaModules = PrismaClientLoader.load(
 );
 
 if(!prismaModules){
-    console.error('Failed to load Prisma client');
+    Logger.error('Failed to load Prisma client');
     process.exit(1);
 }
 ```
@@ -598,7 +653,7 @@ not mentioned in the test output at all. Install them locally without saving:
 
 ### DataServer Flow
 
-All three drivers follow this pattern:
+Every driver follows this pattern:
 
 ```
 1. new DataServer({config, rawEntities})
@@ -608,10 +663,10 @@ All three drivers follow this pattern:
 3. await executeRawSQL(dataServer, schemaSql)  ← Tables must exist before next step
    ↓
 4. await generateTestEntities(dataServer, driverName)
-   ├─ Introspects database schema
-   ├─ Creates models from tables
-   ├─ [Prisma only]: Generate schema + client + reconnect
-   └─ Calls dataServer.generateEntities()
+   - Introspects database schema
+   - Creates models from tables
+   - [Prisma only]: Generate schema + client + reconnect
+   - Calls dataServer.generateEntities()
    ↓
 5. dataServer.getEntity('entityName')  ← Returns repository
 ```
@@ -646,7 +701,8 @@ This happens ONCE during the `before()` hook inside `generateTestEntities()`.
 ### Test Files
 
 **Integration tests:**
-- `tests/integration/test-cross-driver-compatibility.js`: Full CRUD cycle for all 3 drivers
+- `tests/integration/test-drivers.js`: Full CRUD cycle for every active driver
+- `tests/integration/test-cross-driver-equivalence.js`: Same call on every active driver, fails on any divergence
 - `tests/integration/test-nested-filters.js`: Complex filter syntax (AND/OR/NOT/IN/LIKE)
 - `tests/integration/test-relations.js`: Relation loading and nested relations
 

package/README.md

@@ -9,18 +9,71 @@ It ensures consistent data access methods across different database types and OR
 ## Features
 
 ### ORM Support
-- **Objection JS** (via Knex) - For SQL databases (recommended)
+- **Knex** - SQL query builder, the default driver and the only one bundled with the package
+  - MySQL/MariaDB through mysql2
+  - Same filter grammar as the Objection JS driver
+- **Kysely** - Type safe SQL query builder (optional)
+  - MySQL/MariaDB through mysql2
+  - Injected by the consumer through the `kyselyModules` object
+- **Drizzle** - Modern TypeScript ORM (optional)
+  - MySQL/MariaDB through mysql2
+  - Injected by the consumer through the `drizzleModules` object
+- **Objection JS** (via Knex) - For SQL databases (optional)
   - MySQL, MariaDB, PostgreSQL support
   - Complex relation mappings
-  - Query builder with filtering and sorting
-- **Mikro-ORM** - For MongoDB/NoSQL support
+  - Injected by the consumer through the `objectionModules` object
+- **Mikro-ORM** - For MongoDB/NoSQL support (optional)
   - MongoDB native support
   - Entity metadata decorators
-  - Automatic schema synchronization
-- **Prisma** - Modern database toolkit
+  - Injected by the consumer through the `mikroOrmModules` object
+- **Prisma** - Modern database toolkit (optional)
   - Type-safe queries
   - Schema-first approach
-  - Introspection and migration tools
+  - Injected by the consumer through the `prismaModules` object
+
+### Driver packages
+
+The package only depends on `@reldens/utils`, `@reldens/server-utils`, `knex` and `mysql2`. Every other driver
+expects its packages installed in the consumer project. Install the one you need:
+
+```bash
+# Kysely
+npm install kysely
+
+# Drizzle
+npm install drizzle-orm
+
+# Objection JS
+npm install objection@3.1.5
+
+# Mikro-ORM for MySQL/MariaDB
+npm install @mikro-orm/core@7.2.0 @mikro-orm/mysql@7.2.0
+
+# Mikro-ORM for MongoDB
+npm install @mikro-orm/core@7.2.0 @mikro-orm/mongodb@7.2.0
+
+# Prisma
+npm install prisma @prisma/client @prisma/adapter-mariadb
+```
+
+Each data server accepts the driver classes through its `[driver]Modules` option, validated on `connect()`.
+When the option is missing, the data server resolves the packages from the project `node_modules` through the
+matching `*ModulesLoader` (`KyselyModulesLoader`, `DrizzleModulesLoader`, `ObjectionModulesLoader`,
+`MikroOrmModulesLoader`), all exported by the package.
+
+To try every driver at once without touching `package.json`, for example to run the full test suite:
+
+```bash
+npm install --no-save objection@3.1.5 @mikro-orm/core@7.2.0 @mikro-orm/mysql@7.2.0 @mikro-orm/mongodb@7.2.0 kysely drizzle-orm prisma@7.10.0 @prisma/client@7.10.0 @prisma/adapter-mariadb@7.10.0
+RELDENS_TEST_OBJECTION_ENABLED=1 RELDENS_TEST_MIKRO_ORM_ENABLED=1 RELDENS_TEST_PRISMA_ENABLED=1 RELDENS_TEST_KYSELY_ENABLED=1 RELDENS_TEST_DRIZZLE_ENABLED=1 npm run test
+```
+
+Keep all the packages in that one command: any later `npm install`, with or without `--no-save`, prunes the
+`--no-save` packages from a previous run. Without the flags `npm run test` only exercises the bundled knex driver.
+
+The Knex, Kysely and Drizzle drivers share `QueryBuilderDriver` and load relations with one extra query per
+relation level, using the `relationMappings` data emitted into the generated models. Relation filters become
+`IN (SELECT ...)` sub queries, so counts are never inflated by joins.
 
 ### Entity Management
 - Standardized CRUD operations across all drivers
@@ -35,14 +88,14 @@ It ensures consistent data access methods across different database types and OR
 
 **Generate entity files directly from your database structure:**
 ```bash
-npx reldens-storage generateEntities --user=[dbuser] --pass=[dbpass] --database=[dbname] --driver=[objection-js]
+npx reldens-storage generateEntities --user=[dbuser] --pass=[dbpass] --database=[dbname] --driver=[knex]
 ```
 
 **Entity Generation Options:**
 - `--user=[username]` - Database username (required)
 - `--pass=[password]` - Database password (required)
 - `--database=[name]` - Database name (required)
-- `--driver=[driver]` - ORM driver: objection-js, mikro-orm, or prisma (default: objection-js)
+- `--driver=[driver]` - ORM driver: knex, kysely, drizzle, objection-js, mikro-orm or prisma (default: knex). Only knex ships with the package, every other driver expects its packages installed in the project and passed as `[driver]Modules`, or resolved from the project `node_modules`.
 - `--client=[client]` - Database client: mysql, mysql2, or mongodb (default: mysql2)
 - `--host=[host]` - Database host (default: localhost)
 - `--port=[port]` - Database port (default: 3306)
@@ -103,10 +156,17 @@ RELDENS_DB_PARAMS="authPlugin=mysql_native_password&sslmode=require&sslcert=ca-c
 ## Usage Examples
 
 ### SQL with Objection JS
+
+Objection is not installed by this package, install it in your project first:
+```bash
+npm install objection@3.1.5
+```
+
 ```javascript
 const { ObjectionJsDataServer } = require('@reldens/storage');
+const { Model } = require('objection');
 
-const server = new ObjectionJsDataServer({
+let server = new ObjectionJsDataServer({
     client: 'mysql2',
     config: {
         user: 'reldens',
@@ -114,18 +174,34 @@ const server = new ObjectionJsDataServer({
         database: 'reldens',
         host: 'localhost',
         port: 3306
-    }
+    },
+    rawEntities: yourEntities,
+    objectionModules: {Model}
 });
 
 await server.connect();
-const entities = server.generateEntities();
+let entities = server.generateEntities();
 ```
 
+The `objectionModules` object only needs `Model`, the Objection base model class. The generated Objection models
+read it from the package export `ObjectionJsRawModel`, which resolves `objection` from the project when it is
+installed and is `false` otherwise.
+
 ### MongoDB with Mikro-ORM
+
+Mikro-ORM is not installed by this package, install the core plus the driver for your database:
+```bash
+npm install @mikro-orm/core@7.2.0 @mikro-orm/mongodb@7.2.0
+# or, for MySQL/MariaDB:
+npm install @mikro-orm/core@7.2.0 @mikro-orm/mysql@7.2.0
+```
+
 ```javascript
 const { MikroOrmDataServer } = require('@reldens/storage');
+const { MikroORM, EntityCaseNamingStrategy, Collection } = require('@mikro-orm/core');
+const { MongoDriver } = require('@mikro-orm/mongodb');
 
-const server = new MikroOrmDataServer({
+let server = new MikroOrmDataServer({
     client: 'mongodb',
     config: {
         user: 'reldens',
@@ -135,13 +211,117 @@ const server = new MikroOrmDataServer({
         port: 27017
     },
     connectStringOptions: 'authSource=reldens&readPreference=primary&ssl=false',
+    rawEntities: yourEntities,
+    mikroOrmModules: {MikroORM, EntityCaseNamingStrategy, Collection, MongoDriver}
+});
+
+await server.connect();
+let entities = server.generateEntities();
+```
+
+The `mikroOrmModules` object:
+- `MikroORM`, `EntityCaseNamingStrategy`, `Collection`: from `@mikro-orm/core` (required)
+- `MongoDriver`: from `@mikro-orm/mongodb`, required when `client` is `mongodb`
+- `MySqlDriver`: from `@mikro-orm/mysql`, required for any other client
+
+The generated Mikro-ORM models read `EntitySchema` from the package export `MikroOrmCore`, which resolves
+`@mikro-orm/core` from the project when it is installed and is `false` otherwise.
+
+### SQL with Knex
+
+Knex is already a dependency of this package, nothing extra to install:
+
+```javascript
+const { KnexDataServer } = require('@reldens/storage');
+
+let server = new KnexDataServer({
+    client: 'mysql2',
+    config: {
+        user: 'reldens',
+        password: 'reldens',
+        database: 'reldens',
+        host: 'localhost',
+        port: 3306
+    },
     rawEntities: yourEntities
 });
 
 await server.connect();
-const entities = server.generateEntities();
+let entities = server.generateEntities();
+```
+
+### Using Kysely
+
+Kysely is not installed by this package, install it in your project first:
+```bash
+npm install kysely
+```
+
+```javascript
+const { KyselyDataServer } = require('@reldens/storage');
+const { Kysely, MysqlDialect, sql } = require('kysely');
+
+let server = new KyselyDataServer({
+    config: {
+        user: 'reldens',
+        password: 'reldens',
+        database: 'reldens',
+        host: 'localhost',
+        port: 3306
+    },
+    rawEntities: yourEntities,
+    kyselyModules: {Kysely, MysqlDialect, sql}
+});
+
+await server.connect();
+let entities = server.generateEntities();
 ```
 
+The `kyselyModules` object:
+- `sql`: the Kysely `sql` tag, used for the raw queries (required)
+- `Kysely`: the Kysely class (required unless `db` is passed)
+- `MysqlDialect`: the Kysely MySQL dialect (required unless `db` is passed)
+- `db`: an already instantiated Kysely instance (optional, skips the instance construction)
+
+Kysely is an ESM only package, so Node.js 22.12 or later is required to require it from CommonJS.
+
+### Using Drizzle
+
+Drizzle is not installed by this package, install it in your project first:
+```bash
+npm install drizzle-orm
+```
+
+```javascript
+const { DrizzleDataServer } = require('@reldens/storage');
+const { drizzle } = require('drizzle-orm/mysql2');
+const DrizzleOrm = require('drizzle-orm');
+
+let server = new DrizzleDataServer({
+    config: {
+        user: 'reldens',
+        password: 'reldens',
+        database: 'reldens',
+        host: 'localhost',
+        port: 3306
+    },
+    rawEntities: yourEntities,
+    drizzleModules: {drizzle, orm: DrizzleOrm}
+});
+
+await server.connect();
+let entities = server.generateEntities();
+```
+
+The `drizzleModules` object:
+- `orm`: the `drizzle-orm` namespace, used for the conditions and the `sql` tag (required)
+- `drizzle`: the factory exported by `drizzle-orm/mysql2` (required unless `db` is passed)
+- `db`: an already instantiated Drizzle instance (optional, skips the instance construction)
+
+Both objects are validated on `connect()`, the drivers refuse to start when a required class or method is missing.
+The generated Drizzle models require `drizzle-orm/mysql-core` directly, so the package must be installed in the
+project that loads them.
+
 ### Using Prisma
 
 Prisma is not installed by this package. Install it in your project first:
@@ -175,7 +355,7 @@ const { PrismaDataServer } = require('@reldens/storage');
 const { PrismaClient, Prisma } = require('./prisma/client');
 const { PrismaMariaDb } = require('@prisma/adapter-mariadb');
 
-const server = new PrismaDataServer({
+let server = new PrismaDataServer({
     client: 'mysql',
     config: {
         user: 'reldens',
@@ -189,7 +369,7 @@ const server = new PrismaDataServer({
 });
 
 await server.connect();
-const entities = server.generateEntities();
+let entities = server.generateEntities();
 ```
 
 The `prismaModules` object:
@@ -211,10 +391,11 @@ Using the default connection from schema:
 ```javascript
 const { PrismaClientLoader } = require('@reldens/storage');
 const { PrismaMariaDb } = require('@prisma/adapter-mariadb');
+const { Logger } = require('@reldens/utils');
 
 let prismaModules = PrismaClientLoader.load(process.cwd(), null, null, {PrismaAdapter: PrismaMariaDb});
 if(!prismaModules){
-    console.error('Failed to load Prisma client');
+    Logger.error('Failed to load Prisma client');
     process.exit(1);
 }
 ```
@@ -223,6 +404,7 @@ Using custom connection:
 ```javascript
 const { PrismaClientLoader } = require('@reldens/storage');
 const { PrismaMariaDb } = require('@prisma/adapter-mariadb');
+const { Logger } = require('@reldens/utils');
 
 let prismaModules = PrismaClientLoader.load(
     process.cwd(),
@@ -239,7 +421,7 @@ let prismaModules = PrismaClientLoader.load(
 );
 
 if(!prismaModules){
-    console.error('Failed to load Prisma client');
+    Logger.error('Failed to load Prisma client');
     process.exit(1);
 }
 ```
@@ -292,8 +474,8 @@ class CustomDriver extends BaseDriver {
 const { ServerManager } = require('@reldens/server');
 const CustomDataServer = require('./custom-data-server');
 
-const customDriver = new CustomDataServer(options);
-const appServer = new ServerManager(serverConfig, eventsManager, customDriver);
+let customDriver = new CustomDataServer(options);
+let appServer = new ServerManager(serverConfig, eventsManager, customDriver);
 ```
 
 ### Required Methods
@@ -349,11 +531,11 @@ All relations use the `related_*` prefix:
 Example usage:
 ```javascript
 // Load user with related player
-const user = await dataServer.getEntity('users')
+let user = await dataServer.getEntity('users')
     .loadByIdWithRelations(userId, ['related_player']);
 
 // Access nested relations
-const player = await dataServer.getEntity('players')
+let player = await dataServer.getEntity('players')
     .loadByIdWithRelations(playerId, ['related_state', 'related_scenes']);
 ```
 
@@ -376,7 +558,7 @@ const player = await dataServer.getEntity('players')
 
 ### Database Support
 
-- **MySQL/MariaDB**: Via ObjectionJS or Prisma
+- **MySQL/MariaDB**: Via Knex (default), Kysely, Drizzle, ObjectionJS, MikroORM or Prisma
 - **PostgreSQL**: Via Prisma
 - **MongoDB**: Via MikroORM