apeframework 0.0.0-dev.31 → 0.0.0-dev.33

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2024 Matthieu Symoens
+Copyright (c) 2025 Matthieu Symoens
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -4,10 +4,56 @@
 
 NPM package: [apeframework](https://www.npmjs.com/package/apeframework).
 
-GitHub repository: [ApeFramework/apeframework](https://github.com/ApeFramework/apeframework).
+GitHub repository: [MattSyms/apeframework](https://github.com/MattSyms/apeframework).
 
 ## Installation
 
 ```
 yarn add apeframework
 ```
+
+## Development
+
+Install dependencies:
+
+```
+yarn
+```
+
+Update dependencies:
+
+```
+yarn update
+```
+
+Compile:
+
+```
+yarn compile
+```
+
+Lint:
+
+```
+yarn lint
+```
+
+## Release:
+
+Tag stable release:
+
+```
+git tag v<major>.<minor>.<patch>
+```
+
+Tag dev release:
+
+```
+git tag v0.0.0-dev.<number>
+```
+
+Push tags:
+
+```
+git push --tags
+```

package/dist/cipher/Cipher.js

@@ -1,4 +1,4 @@
-import { createCipheriv, createDecipheriv, randomBytes } from 'crypto';
+import { createCipheriv, createDecipheriv, randomBytes } from 'node:crypto';
 import { DecryptError } from './errors/DecryptError.js';
 import { validateSecretLength } from './validateSecretLength.js';
 class Cipher {

package/dist/cli/utils/formatList.js

@@ -1,4 +1,4 @@
-import { EOL } from 'os';
+import { EOL } from 'node:os';
 const formatList = (list) => {
     return list
         .map((item) => { return `  ${item}`; })

package/dist/cli/utils/formatTable.js

@@ -1,4 +1,4 @@
-import { EOL } from 'os';
+import { EOL } from 'node:os';
 const formatTable = (table) => {
     const colLength = [];
     table.forEach((row) => {

package/dist/cli/utils/formatText.js

@@ -1,4 +1,4 @@
-import { EOL } from 'os';
+import { EOL } from 'node:os';
 const formatText = (text) => {
     return text.join(EOL);
 };

package/dist/cli/utils/printLn.js

@@ -1,4 +1,4 @@
-import { EOL } from 'os';
+import { EOL } from 'node:os';
 const printLn = (s) => {
     process.stdout.write(`${s}${EOL}`);
 };

package/dist/db/DataType.d.ts

@@ -0,0 +1,2 @@
+import { DataTypes } from 'sequelize';
+export { DataTypes as DataType, };

package/dist/db/DataType.js

@@ -0,0 +1,2 @@
+import { DataTypes } from 'sequelize';
+export { DataTypes as DataType, };

package/dist/db/Db.d.ts

@@ -0,0 +1,10 @@
+import { Sequelize } from 'sequelize';
+import type { Initializer } from './Initializer.js';
+import type { Options } from 'sequelize';
+declare abstract class Db extends Sequelize {
+    protected constructor(params: {
+        options: Options;
+        initializers?: Initializer[];
+    });
+}
+export { Db, };

package/dist/db/Db.js

@@ -0,0 +1,16 @@
+import { Sequelize } from 'sequelize';
+class Db extends Sequelize {
+    constructor(params) {
+        super({
+            ...params.options,
+            define: {
+                freezeTableName: true,
+                timestamps: false,
+            },
+        });
+        params.initializers?.forEach((initialize) => {
+            initialize(this);
+        });
+    }
+}
+export { Db, };

package/dist/db/IndexType.d.ts

@@ -0,0 +1,6 @@
+declare enum IndexType {
+    FULLTEXT = "FULLTEXT",
+    SPATIAL = "SPATIAL",
+    UNIQUE = "UNIQUE"
+}
+export { IndexType, };

package/dist/db/IndexType.js

@@ -0,0 +1,7 @@
+var IndexType;
+(function (IndexType) {
+    IndexType["FULLTEXT"] = "FULLTEXT";
+    IndexType["SPATIAL"] = "SPATIAL";
+    IndexType["UNIQUE"] = "UNIQUE";
+})(IndexType || (IndexType = {}));
+export { IndexType, };

package/dist/db/Initializer.d.ts

@@ -0,0 +1,3 @@
+import type { Sequelize } from 'sequelize';
+type Initializer = (db: Sequelize) => void;
+export { type Initializer, };

package/dist/db/Initializer.js

@@ -0,0 +1 @@
+export {};

package/dist/db/Migration.d.ts

@@ -0,0 +1,6 @@
+import type { QueryInterface } from 'sequelize';
+interface Migration {
+    up: (db: QueryInterface) => Promise<void>;
+    down: (db: QueryInterface) => Promise<void>;
+}
+export { type Migration, };

package/dist/db/Migration.js

@@ -0,0 +1 @@
+export {};

package/dist/db/MigrationStatus.d.ts

@@ -0,0 +1,5 @@
+declare enum MigrationStatus {
+    APPLIED = "APPLIED",
+    PENDING = "PENDING"
+}
+export { MigrationStatus, };

package/dist/db/MigrationStatus.js

@@ -0,0 +1,6 @@
+var MigrationStatus;
+(function (MigrationStatus) {
+    MigrationStatus["APPLIED"] = "APPLIED";
+    MigrationStatus["PENDING"] = "PENDING";
+})(MigrationStatus || (MigrationStatus = {}));
+export { MigrationStatus, };

package/dist/db/Migrator.d.ts

@@ -0,0 +1,20 @@
+import { MigrationStatus } from './MigrationStatus.js';
+import type { Db } from './Db.js';
+declare class Migrator {
+    private readonly umzug;
+    constructor(params: {
+        db: Db;
+        modelName: string;
+        directory: string;
+        extension: string;
+        onApply?: (name: string) => void;
+        onRevert?: (name: string) => void;
+    });
+    list(status?: MigrationStatus): Promise<{
+        name: string;
+        status: MigrationStatus;
+    }[]>;
+    apply(count?: number): Promise<string[]>;
+    revert(count?: number): Promise<string[]>;
+}
+export { Migrator, };

package/dist/db/Migrator.js

@@ -0,0 +1,69 @@
+import { basename, extname } from 'node:path';
+import { SequelizeStorage, Umzug } from 'umzug';
+import { MigrationStatus } from './MigrationStatus.js';
+class Migrator {
+    umzug;
+    constructor(params) {
+        const glob = `${params.directory}/*.${params.extension}`;
+        const resolve = ({ name: filename, context }) => {
+            const name = basename(filename, extname(filename));
+            const up = async ({ path }) => {
+                const migration = await import(String(path));
+                await migration.up(context);
+            };
+            const down = async ({ path }) => {
+                const migration = await import(String(path));
+                await migration.down(context);
+            };
+            return { name, up, down };
+        };
+        this.umzug = new Umzug({
+            storage: new SequelizeStorage({
+                sequelize: params.db,
+                modelName: params.modelName,
+            }),
+            migrations: { glob, resolve },
+            context: params.db.getQueryInterface(),
+            logger: undefined,
+        });
+        this.umzug.on('migrating', (e) => {
+            params.onApply?.(e.name);
+        });
+        this.umzug.on('reverting', (e) => {
+            params.onRevert?.(e.name);
+        });
+    }
+    async list(status) {
+        return [
+            ...status === MigrationStatus.PENDING
+                ? []
+                : (await this.umzug.executed()).map((migration) => {
+                    return {
+                        name: migration.name,
+                        status: MigrationStatus.APPLIED,
+                    };
+                }),
+            ...status === MigrationStatus.APPLIED
+                ? []
+                : (await this.umzug.pending()).map((migration) => {
+                    return {
+                        name: migration.name,
+                        status: MigrationStatus.PENDING,
+                    };
+                }),
+        ];
+    }
+    async apply(count) {
+        return (await this.umzug.up(count ? { step: count } : undefined))
+            .map((migration) => {
+            return migration.name;
+        });
+    }
+    async revert(count) {
+        return (await this.umzug.down(count ? { step: count } : { to: 0 }))
+            .map((migration) => {
+            return migration.name;
+        });
+    }
+}
+export { Migrator, };

package/dist/db/Operator.d.ts

@@ -0,0 +1,2 @@
+import { Op } from 'sequelize';
+export { Op as Operator, };

package/dist/db/Operator.js

@@ -0,0 +1,2 @@
+import { Op } from 'sequelize';
+export { Op as Operator, };

package/dist/db/Order.d.ts

@@ -0,0 +1,2 @@
+import type { Order } from 'sequelize';
+export { type Order, };

package/dist/db/Order.js

@@ -0,0 +1 @@
+export {};

package/dist/db/ReferentialAction.d.ts

@@ -0,0 +1,7 @@
+declare const ReferentialAction: {
+    CASCADE: string;
+    RESTRICT: string;
+    SET_DEFAULT: string;
+    SET_NULL: string;
+};
+export { ReferentialAction, };

package/dist/db/ReferentialAction.js

@@ -0,0 +1,7 @@
+const ReferentialAction = {
+    CASCADE: 'CASCADE',
+    RESTRICT: 'RESTRICT',
+    SET_DEFAULT: 'SET DEFAULT',
+    SET_NULL: 'SET NULL',
+};
+export { ReferentialAction, };

package/dist/db/Transaction.d.ts

@@ -0,0 +1,2 @@
+import type { Transaction } from 'sequelize';
+export { type Transaction, };

package/dist/db/Transaction.js

@@ -0,0 +1 @@
+export {};

package/dist/db/adapters/mssql/MssqlDb.d.ts

@@ -0,0 +1,23 @@
+import { Db } from '../../Db.js';
+import type { Tls } from '../../../tls/Tls.js';
+import type { Initializer } from '../../Initializer.js';
+declare class MssqlDb extends Db {
+    constructor(params: {
+        host: string;
+        port?: number;
+        tls?: Tls | boolean;
+        user: string;
+        password: string;
+        database: string;
+        minConnections?: number;
+        maxConnections?: number;
+        connectionTimeout?: number;
+        connectionAcquireTimeout?: number;
+        connectionIdleTimeout?: number;
+        connectionEvictInterval?: number;
+        connectionMaxUses?: number;
+        initializers?: Initializer[];
+        onQuery?: (message: string) => void;
+    });
+}
+export { MssqlDb, };

package/dist/db/adapters/mssql/MssqlDb.js

@@ -0,0 +1,40 @@
+import { getTls } from '../../../tls/getTls.js';
+import { Db } from '../../Db.js';
+class MssqlDb extends Db {
+    constructor(params) {
+        const tls = typeof params.tls === 'boolean'
+            ? undefined
+            : getTls(params.tls);
+        super({
+            options: {
+                dialect: 'mssql',
+                dialectOptions: {
+                    options: {
+                        encrypt: typeof params.tls === 'boolean'
+                            ? params.tls
+                            : Boolean(tls),
+                        cryptoCredentialsDetails: tls,
+                        trustServerCertificate: tls?.rejectUnauthorized === false,
+                        connectTimeout: params.connectionTimeout ?? 10000,
+                    },
+                },
+                host: params.host,
+                port: params.port ?? 1433,
+                username: params.user,
+                password: params.password,
+                database: params.database,
+                pool: {
+                    min: params.minConnections ?? 0,
+                    max: params.maxConnections ?? 10,
+                    acquire: params.connectionAcquireTimeout ?? 30000,
+                    idle: params.connectionIdleTimeout ?? 30000,
+                    evict: params.connectionEvictInterval ?? 30000,
+                    maxUses: params.connectionMaxUses ?? 100,
+                },
+                logging: params.onQuery,
+            },
+            initializers: params.initializers,
+        });
+    }
+}
+export { MssqlDb, };

package/dist/db/adapters/mysql/MysqlDb.d.ts

@@ -0,0 +1,23 @@
+import { Db } from '../../Db.js';
+import type { Tls } from '../../../tls/Tls.js';
+import type { Initializer } from '../../Initializer.js';
+declare class MysqlDb extends Db {
+    constructor(params: {
+        host: string;
+        port?: number;
+        tls?: Tls | boolean;
+        user: string;
+        password: string;
+        database: string;
+        minConnections?: number;
+        maxConnections?: number;
+        connectionTimeout?: number;
+        connectionAcquireTimeout?: number;
+        connectionIdleTimeout?: number;
+        connectionEvictInterval?: number;
+        connectionMaxUses?: number;
+        initializers?: Initializer[];
+        onQuery?: (message: string) => void;
+    });
+}
+export { MysqlDb, };

package/dist/db/adapters/mysql/MysqlDb.js

@@ -0,0 +1,33 @@
+import { getTls } from '../../../tls/getTls.js';
+import { Db } from '../../Db.js';
+class MysqlDb extends Db {
+    constructor(params) {
+        super({
+            options: {
+                dialect: 'mysql',
+                dialectOptions: {
+                    ssl: typeof params.tls === 'boolean'
+                        ? params.tls
+                        : getTls(params.tls),
+                    connectTimeout: params.connectionTimeout ?? 10000,
+                },
+                host: params.host,
+                port: params.port ?? 3306,
+                username: params.user,
+                password: params.password,
+                database: params.database,
+                pool: {
+                    min: params.minConnections ?? 0,
+                    max: params.maxConnections ?? 10,
+                    acquire: params.connectionAcquireTimeout ?? 30000,
+                    idle: params.connectionIdleTimeout ?? 30000,
+                    evict: params.connectionEvictInterval ?? 30000,
+                    maxUses: params.connectionMaxUses ?? 100,
+                },
+                logging: params.onQuery,
+            },
+            initializers: params.initializers,
+        });
+    }
+}
+export { MysqlDb, };

package/dist/db/adapters/postgres/PostgresDb.d.ts

@@ -0,0 +1,23 @@
+import { Db } from '../../Db.js';
+import type { Tls } from '../../../tls/Tls.js';
+import type { Initializer } from '../../Initializer.js';
+declare class PostgresDb extends Db {
+    constructor(params: {
+        host: string;
+        port?: number;
+        tls?: Tls | boolean;
+        user: string;
+        password: string;
+        database: string;
+        minConnections?: number;
+        maxConnections?: number;
+        connectionTimeout?: number;
+        connectionAcquireTimeout?: number;
+        connectionIdleTimeout?: number;
+        connectionEvictInterval?: number;
+        connectionMaxUses?: number;
+        initializers?: Initializer[];
+        onQuery?: (message: string) => void;
+    });
+}
+export { PostgresDb, };

package/dist/db/adapters/postgres/PostgresDb.js

@@ -0,0 +1,33 @@
+import { getTls } from '../../../tls/getTls.js';
+import { Db } from '../../Db.js';
+class PostgresDb extends Db {
+    constructor(params) {
+        super({
+            options: {
+                dialect: 'postgres',
+                dialectOptions: {
+                    ssl: typeof params.tls === 'boolean'
+                        ? params.tls
+                        : getTls(params.tls),
+                    connectionTimeoutMillis: params.connectionTimeout ?? 10000,
+                },
+                host: params.host,
+                port: params.port ?? 5432,
+                username: params.user,
+                password: params.password,
+                database: params.database,
+                pool: {
+                    min: params.minConnections ?? 0,
+                    max: params.maxConnections ?? 10,
+                    acquire: params.connectionAcquireTimeout ?? 30000,
+                    idle: params.connectionIdleTimeout ?? 30000,
+                    evict: params.connectionEvictInterval ?? 30000,
+                    maxUses: params.connectionMaxUses ?? 100,
+                },
+                logging: params.onQuery,
+            },
+            initializers: params.initializers,
+        });
+    }
+}
+export { PostgresDb, };

package/dist/db/adapters/sqlite/SqliteDb.d.ts

@@ -0,0 +1,10 @@
+import { Db } from '../../Db.js';
+import type { Initializer } from '../../Initializer.js';
+declare class SqliteDb extends Db {
+    constructor(params: {
+        storage: string;
+        initializers?: Initializer[];
+        onQuery?: (message: string) => void;
+    });
+}
+export { SqliteDb, };

package/dist/db/adapters/sqlite/SqliteDb.js

@@ -0,0 +1,20 @@
+import SQLite from 'sqlite3';
+import { Db } from '../../Db.js';
+class SqliteDb extends Db {
+    constructor(params) {
+        super({
+            options: {
+                dialect: 'sqlite',
+                dialectOptions: {
+                    mode: SQLite.OPEN_FULLMUTEX
+                        | SQLite.OPEN_READWRITE
+                        | SQLite.OPEN_CREATE,
+                },
+                storage: params.storage,
+                logging: params.onQuery,
+            },
+            initializers: params.initializers,
+        });
+    }
+}
+export { SqliteDb, };

package/dist/db/adapters/sqlite/Storage.d.ts

@@ -0,0 +1,4 @@
+declare const Storage: {
+    MEMORY: string;
+};
+export { Storage, };

package/dist/db/adapters/sqlite/Storage.js

@@ -0,0 +1,4 @@
+const Storage = {
+    MEMORY: ':memory:',
+};
+export { Storage, };

package/dist/db/relationships.d.ts

@@ -0,0 +1,28 @@
+import type { Model, ModelStatic } from 'sequelize';
+declare const oneToOne: (fk: string, a: {
+    model: ModelStatic<Model>;
+    asOne: string;
+}, b: {
+    model: ModelStatic<Model>;
+    asOne: string;
+}) => void;
+declare const oneToMany: (fk: string, a: {
+    model: ModelStatic<Model>;
+    asOne: string;
+}, b: {
+    model: ModelStatic<Model>;
+    asMany: string;
+}) => void;
+declare const manyToMany: (fkA: string, fkB: string, a: {
+    model: ModelStatic<Model>;
+    asOne: string;
+    asMany: string;
+}, b: {
+    model: ModelStatic<Model>;
+    asOne: string;
+    asMany: string;
+}, through: {
+    model: ModelStatic<Model>;
+    asMany: string;
+}) => void;
+export { manyToMany, oneToMany, oneToOne, };

package/dist/db/relationships.js

@@ -0,0 +1,15 @@
+const oneToOne = (fk, a, b) => {
+    a.model.hasOne(b.model, { foreignKey: fk, as: b.asOne });
+    b.model.belongsTo(a.model, { foreignKey: fk, as: a.asOne });
+};
+const oneToMany = (fk, a, b) => {
+    a.model.hasMany(b.model, { foreignKey: fk, as: b.asMany });
+    b.model.belongsTo(a.model, { foreignKey: fk, as: a.asOne });
+};
+const manyToMany = (fkA, fkB, a, b, through) => {
+    a.model.belongsToMany(b.model, { through: through.model, foreignKey: fkA, otherKey: fkB, as: b.asMany });
+    b.model.belongsToMany(a.model, { through: through.model, foreignKey: fkB, otherKey: fkA, as: a.asMany });
+    oneToMany(fkA, a, through);
+    oneToMany(fkB, b, through);
+};
+export { manyToMany, oneToMany, oneToOne, };

package/dist/logger/adapters/file/FileLogger.js

@@ -1,4 +1,4 @@
-import { pino } from 'pino';
+import { destination, pino } from 'pino';
 import { Level } from '../../Level.js';
 import { Logger } from '../../Logger.js';
 import { initFile } from './initFile.js';
@@ -8,7 +8,7 @@ class FileLogger extends Logger {
     constructor(params) {
         super();
         initFile(params.path);
-        const stream = pino.destination(params.path);
+        const stream = destination(params.path);
         this.logger = pino({
             enabled: params.level !== Level.OFF,
             level: params.level ?? Level.INFO,

package/dist/logger/adapters/stdio/StdioLogger.js

@@ -1,4 +1,4 @@
-import { pino } from 'pino';
+import { destination, pino } from 'pino';
 import pretty from 'pino-pretty';
 import { Level } from '../../Level.js';
 import { Logger } from '../../Logger.js';
@@ -9,7 +9,7 @@ class StdioLogger extends Logger {
         super();
         const stream = params?.pretty
             ? pretty()
-            : pino.destination(process.stdout.fd);
+            : destination(process.stdout.fd);
         this.logger = pino({
             enabled: params?.level !== Level.OFF,
             level: params?.level ?? Level.INFO,

package/dist/mailer/Attachment.d.ts

@@ -1,4 +1,4 @@
-import type { Readable } from 'stream';
+import type { Readable } from 'node:stream';
 interface Attachment {
     fileName: string;
     contentType?: string;

package/dist/mailer/adapters/noop/NoopMailer.js

@@ -1,4 +1,4 @@
-import { randomUUID } from 'crypto';
+import { randomUUID } from 'node:crypto';
 import { Mailer } from '../../Mailer.js';
 class NoopMailer extends Mailer {
     async sendMail(mail) {

package/dist/mailer/adapters/smtp/SmtpMailer.js

@@ -21,7 +21,7 @@ class SmtpMailer extends Mailer {
                 }
                 : undefined,
             pool: true,
-            maxConnections: params.maxConnections ?? 5,
+            maxConnections: params.maxConnections ?? 10,
         });
     }
     async sendMail(mail) {

package/dist/mailer/adapters/smtp/getAttachments.d.ts

@@ -1,5 +1,5 @@
 import type { Attachment } from '../../Attachment.js';
-import type { Readable } from 'stream';
+import type { Readable } from 'node:stream';
 interface NodemailerAttachment {
     filename: string;
     cid: string;

package/dist/server/Server.d.ts

@@ -13,6 +13,13 @@ declare class Server {
         port?: number;
         routes: Route[];
         formats?: Format[];
+        trustProxy?: boolean;
+        connectionTimeout?: number;
+        requestTimeout?: number;
+        keepAliveTimeout?: number;
+        connectionMaxUses?: number;
+        maxParams?: number;
+        maxBodySize?: number;
         openapi?: {
             name?: string;
             version?: string;

package/dist/server/Server.js

@@ -13,7 +13,15 @@ class Server {
     constructor(params) {
         this.host = params.host;
         this.port = params.port;
-        this.server = fastify();
+        this.server = fastify({
+            trustProxy: params.trustProxy ?? false,
+            connectionTimeout: params.connectionTimeout ?? 30000,
+            requestTimeout: params.requestTimeout ?? 30000,
+            keepAliveTimeout: params.keepAliveTimeout ?? 30000,
+            maxRequestsPerSocket: params.connectionMaxUses ?? 100,
+            maxParamLength: params.maxParams ?? 100,
+            bodyLimit: params.maxBodySize ?? 1000000,
+        });
         const ajv = getAjv(params.formats);
         this.server.setValidatorCompiler(({ schema }) => {
             return ajv.compile(schema);

package/dist/tls/getTls.js

@@ -6,7 +6,7 @@ const getTls = (tls) => {
             ...tls.cert ? { cert: readFile(tls.cert) } : {},
             ...tls.ca ? { ca: readFile(tls.ca) } : {},
             ...tls.verify === undefined
-                ? {}
+                ? { rejectUnauthorized: true }
                 : { rejectUnauthorized: tls.verify },
         }
         : undefined;

package/dist/utils/getRandomHexString.js

@@ -1,4 +1,4 @@
-import { randomBytes } from 'crypto';
+import { randomBytes } from 'node:crypto';
 const getRandomHexString = (length) => {
     return randomBytes(length / 2 + 1).toString('hex').substring(0, length);
 };

package/dist/utils/getRandomIntString.js

@@ -1,4 +1,4 @@
-import { randomInt } from 'crypto';
+import { randomInt } from 'node:crypto';
 const getRandomIntString = (length) => {
     let string = '';
     for (let i = 0; i < length; i += 1) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apeframework",
-  "version": "0.0.0-dev.31",
+  "version": "0.0.0-dev.33",
   "publishConfig": {
     "access": "public"
   },
@@ -14,40 +14,47 @@
   ],
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/ApeFramework/apeframework.git"
+    "url": "git+https://github.com/MattSyms/apeframework.git"
   },
   "type": "module",
   "engines": {
     "node": ">=22"
   },
   "dependencies": {
-    "@fastify/compress": "^8.0",
+    "@fastify/compress": "^8.1",
     "@fastify/cookie": "^11.0",
-    "@fastify/cors": "^11.0",
+    "@fastify/cors": "^11.1",
     "@fastify/response-validation": "^3.0",
     "@fastify/swagger": "^9.5",
     "@types/fs-extra": "^11.0",
-    "@types/nodemailer": "^6.4",
+    "@types/nodemailer": "^7.0",
     "@types/yargs-parser": "^21.0",
     "ajv": "^8.17",
-    "argon2": "^0.43",
-    "bullmq": "^5.53",
-    "dotenv": "^16.5",
-    "fast-uri": "^3.0",
-    "fastify": "^5.3",
+    "argon2": "^0.44",
+    "bullmq": "^5.63",
+    "dotenv": "^17.2",
+    "fast-uri": "^3.1",
+    "fastify": "^5.6",
     "fs-extra": "^11.3",
-    "ical-generator": "^9.0",
-    "ioredis": "^5.6",
-    "jose": "^6.0",
+    "ical-generator": "^10.0",
+    "ioredis": "^5.8",
+    "jose": "^6.1",
+    "mariadb": "^3.4",
+    "mysql2": "^3.15",
     "nodemailer": "^7.0",
     "openapi-types": "^12.1",
-    "pino": "^9.7",
-    "pino-pretty": "^13.0",
+    "pg": "^8.16",
+    "pg-hstore": "^2.3",
+    "pino": "^10.1",
+    "pino-pretty": "^13.1",
+    "sequelize": "^6.37",
+    "sqlite3": "^5.1",
+    "umzug": "^3.8",
     "yargs-parser": "^22.0"
   },
   "peerDependencies": {
-    "@types/node": "^24.0",
-    "typescript": "^5.8"
+    "@types/node": "^24.10",
+    "typescript": "^5.9"
   },
   "exports": {
     "./cipher/Algorithm": {
@@ -200,6 +207,114 @@
         "default": "./dist/config/validatePropertyName.js"
       }
     },
+    "./db/DataType": {
+      "import": {
+        "types": "./dist/db/DataType.d.ts",
+        "default": "./dist/db/DataType.js"
+      }
+    },
+    "./db/Db": {
+      "import": {
+        "types": "./dist/db/Db.d.ts",
+        "default": "./dist/db/Db.js"
+      }
+    },
+    "./db/IndexType": {
+      "import": {
+        "types": "./dist/db/IndexType.d.ts",
+        "default": "./dist/db/IndexType.js"
+      }
+    },
+    "./db/Initializer": {
+      "import": {
+        "types": "./dist/db/Initializer.d.ts",
+        "default": "./dist/db/Initializer.js"
+      }
+    },
+    "./db/Migration": {
+      "import": {
+        "types": "./dist/db/Migration.d.ts",
+        "default": "./dist/db/Migration.js"
+      }
+    },
+    "./db/MigrationStatus": {
+      "import": {
+        "types": "./dist/db/MigrationStatus.d.ts",
+        "default": "./dist/db/MigrationStatus.js"
+      }
+    },
+    "./db/Migrator": {
+      "import": {
+        "types": "./dist/db/Migrator.d.ts",
+        "default": "./dist/db/Migrator.js"
+      }
+    },
+    "./db/Operator": {
+      "import": {
+        "types": "./dist/db/Operator.d.ts",
+        "default": "./dist/db/Operator.js"
+      }
+    },
+    "./db/Order": {
+      "import": {
+        "types": "./dist/db/Order.d.ts",
+        "default": "./dist/db/Order.js"
+      }
+    },
+    "./db/ReferentialAction": {
+      "import": {
+        "types": "./dist/db/ReferentialAction.d.ts",
+        "default": "./dist/db/ReferentialAction.js"
+      }
+    },
+    "./db/Transaction": {
+      "import": {
+        "types": "./dist/db/Transaction.d.ts",
+        "default": "./dist/db/Transaction.js"
+      }
+    },
+    "./db/adapters/maria/MariaDb": {
+      "import": {
+        "types": "./dist/db/adapters/maria/MariaDb.d.ts",
+        "default": "./dist/db/adapters/maria/MariaDb.js"
+      }
+    },
+    "./db/adapters/mssql/MssqlDb": {
+      "import": {
+        "types": "./dist/db/adapters/mssql/MssqlDb.d.ts",
+        "default": "./dist/db/adapters/mssql/MssqlDb.js"
+      }
+    },
+    "./db/adapters/mysql/MysqlDb": {
+      "import": {
+        "types": "./dist/db/adapters/mysql/MysqlDb.d.ts",
+        "default": "./dist/db/adapters/mysql/MysqlDb.js"
+      }
+    },
+    "./db/adapters/postgres/PostgresDb": {
+      "import": {
+        "types": "./dist/db/adapters/postgres/PostgresDb.d.ts",
+        "default": "./dist/db/adapters/postgres/PostgresDb.js"
+      }
+    },
+    "./db/adapters/sqlite/SqliteDb": {
+      "import": {
+        "types": "./dist/db/adapters/sqlite/SqliteDb.d.ts",
+        "default": "./dist/db/adapters/sqlite/SqliteDb.js"
+      }
+    },
+    "./db/adapters/sqlite/Storage": {
+      "import": {
+        "types": "./dist/db/adapters/sqlite/Storage.d.ts",
+        "default": "./dist/db/adapters/sqlite/Storage.js"
+      }
+    },
+    "./db/relationships": {
+      "import": {
+        "types": "./dist/db/relationships.d.ts",
+        "default": "./dist/db/relationships.js"
+      }
+    },
     "./env/Env": {
       "import": {
         "types": "./dist/env/Env.d.ts",