apeframework 0.2.0 → 0.4.0

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2025 Matthieu Symoens
+Copyright (c) 2026 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

@@ -43,13 +43,13 @@ yarn lint
 Tag stable release:
 
 ```
-git tag v<major>.<minor>.<patch>
+git tag framework@v<major>.<minor>.<patch>
 ```
 
 Tag dev release:
 
 ```
-git tag v0.0.0-dev.<number>
+git tag framework@v0.0.0-dev.<number>
 ```
 
 Push tags:

package/dist/db/Db.d.ts

@@ -1,3 +1,10 @@
-import type { Sequelize } from 'sequelize';
-type Db = Sequelize;
-export type { Db, };
+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

@@ -1 +1,16 @@
-export {};
+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/Migrator.d.ts

@@ -1,5 +1,6 @@
 import { MigrationStatus } from './MigrationStatus.js';
 import type { Db } from './Db.js';
+import type { Migration } from './Migration.js';
 declare class Migrator {
     private readonly umzug;
     constructor(params: {
@@ -7,6 +8,7 @@ declare class Migrator {
         modelName: string;
         directory: string;
         extension: string;
+        load: (path: string) => Promise<Migration>;
         onApply?: (name: string) => void;
         onRevert?: (name: string) => void;
     });

package/dist/db/Migrator.js

@@ -7,13 +7,13 @@ class Migrator {
         const glob = `${params.directory}/*.${params.extension}`;
         const resolve = ({ name: filename, context }) => {
             const name = basename(filename, extname(filename));
-            const up = async ({ path: file }) => {
-                const module = await import(String(file));
-                await module.migration.up(context);
+            const up = async ({ path }) => {
+                const migration = await params.load(String(path));
+                await migration.up(context);
             };
-            const down = async ({ path: file }) => {
-                const module = await import(String(file));
-                await module.migration.down(context);
+            const down = async ({ path }) => {
+                const migration = await params.load(String(path));
+                await migration.down(context);
             };
             return { name, up, down };
         };

package/dist/db/adapters/maria/MariaDb.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 MariaDb 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 { MariaDb, };

package/dist/db/adapters/maria/MariaDb.js

@@ -0,0 +1,33 @@
+import { getTls } from '../../../tls/getTls.js';
+import { Db } from '../../Db.js';
+class MariaDb extends Db {
+    constructor(params) {
+        super({
+            options: {
+                dialect: 'mariadb',
+                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 { MariaDb, };

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

@@ -1,16 +1,23 @@
-import { Sequelize } from 'sequelize';
-import type { Db } from '../../Db.js';
+import { Db } from '../../Db.js';
+import type { Tls } from '../../../tls/Tls.js';
 import type { Initializer } from '../../Initializer.js';
-declare class MysqlDb extends Sequelize implements Db {
+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[];
-        onLog?: (message: string) => void;
+        onQuery?: (message: string) => void;
     });
 }
 export { MysqlDb, };

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

@@ -1,21 +1,32 @@
-import { Sequelize } from 'sequelize';
-class MysqlDb extends Sequelize {
+import { getTls } from '../../../tls/getTls.js';
+import { Db } from '../../Db.js';
+class MysqlDb extends Db {
     constructor(params) {
-        super(params.database, params.user, params.password, {
-            dialect: 'mysql',
-            host: params.host,
-            port: params.port ?? 3306,
-            pool: {
-                max: params.maxConnections ?? 5,
+        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,
             },
-            define: {
-                freezeTableName: true,
-                timestamps: false,
-            },
-            logging: params.onLog,
-        });
-        params.initializers?.forEach((initialize) => {
-            initialize(this);
+            initializers: params.initializers,
         });
     }
 }

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/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/server/InjectParams.d.ts

@@ -0,0 +1,3 @@
+import type { InjectOptions } from 'fastify';
+type InjectParams = InjectOptions;
+export { type InjectParams, };

package/dist/server/InjectResponse.d.ts

@@ -0,0 +1,3 @@
+import type { LightMyRequestResponse } from 'fastify';
+type InjectResponse = LightMyRequestResponse;
+export { type InjectResponse, };

package/dist/server/InjectResponse.js

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

package/dist/server/Route.d.ts

@@ -2,10 +2,11 @@ import type { Handler } from './Handler.js';
 import type { Method } from './Method.js';
 import type { Schema } from './Schema.js';
 interface Route {
-    path: string;
     method: Method;
+    path: string;
     name?: string;
     description?: string;
+    tags?: string[];
     schema: Schema;
     handler: Handler;
 }

package/dist/server/Schema.d.ts

@@ -3,7 +3,7 @@ interface Schema {
     params?: OpenAPIV3.SchemaObject;
     query?: OpenAPIV3.SchemaObject;
     headers?: OpenAPIV3.SchemaObject;
-    body?: OpenAPIV3.SchemaObject;
-    response?: Record<number, OpenAPIV3.SchemaObject>;
+    body?: OpenAPIV3.RequestBodyObject;
+    response?: OpenAPIV3.ResponsesObject;
 }
 export { type Schema, };

package/dist/server/Server.d.ts

@@ -2,6 +2,8 @@ import { OpenApiFormat } from './OpenApiFormat.js';
 import type { ErrorHandler } from './ErrorHandler.js';
 import type { Format } from './Format.js';
 import type { Handler } from './Handler.js';
+import type { InjectParams } from './InjectParams.js';
+import type { InjectResponse } from './InjectResponse.js';
 import type { Route } from './Route.js';
 import type { OpenAPIV3 } from 'openapi-types';
 declare class Server {
@@ -11,13 +13,28 @@ declare class Server {
     constructor(params: {
         host: string;
         port?: number;
-        routes: Route[];
-        formats?: Format[];
         openapi?: {
             name?: string;
             version?: string;
         };
-        responseValidation?: {
+        routes: Route[];
+        formats?: Format[];
+        validateResponses?: boolean;
+        trustProxy?: boolean;
+        connectionTimeout?: number;
+        requestTimeout?: number;
+        keepAliveTimeout?: number;
+        connectionMaxUses?: number;
+        bodyMaxSize?: number;
+        form?: {
+            enabled?: boolean;
+        };
+        multipart?: {
+            enabled?: boolean;
+            maxFiles?: number;
+            fileMaxSize?: number;
+        };
+        cookies?: {
             enabled?: boolean;
         };
         compression?: {
@@ -32,9 +49,6 @@ declare class Server {
             exposedHeaders?: string[];
             allowCredentials?: boolean;
         };
-        cookies?: {
-            enabled?: boolean;
-        };
         onRequest?: Handler;
         onResponse?: Handler;
         onNotFound?: Handler;
@@ -42,6 +56,7 @@ declare class Server {
     });
     start(): Promise<string>;
     close(): Promise<void>;
+    inject(params: InjectParams): Promise<InjectResponse>;
     openapi(format: OpenApiFormat): OpenAPIV3.Document;
 }
 export { Server, };

package/dist/server/Server.js

@@ -1,6 +1,8 @@
 import compress from '@fastify/compress';
-import cookies from '@fastify/cookie';
+import cookie from '@fastify/cookie';
 import cors from '@fastify/cors';
+import formbody from '@fastify/formbody';
+import multipart from '@fastify/multipart';
 import responseValidation from '@fastify/response-validation';
 import swagger from '@fastify/swagger';
 import fastify from 'fastify';
@@ -13,7 +15,14 @@ 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,
+            bodyLimit: params.bodyMaxSize ?? 1000000,
+        });
         const ajv = getAjv(params.formats);
         this.server.setValidatorCompiler(({ schema }) => {
             return ajv.compile(schema);
@@ -27,13 +36,28 @@ class Server {
                 },
             },
         });
-        if (params.responseValidation?.enabled) {
+        if (params.validateResponses) {
             this.server.register(responseValidation, { ajv });
         }
+        if (params.form?.enabled) {
+            this.server.register(formbody);
+        }
+        if (params.multipart?.enabled) {
+            this.server.register(multipart, {
+                attachFieldsToBody: 'keyValues',
+                limits: {
+                    files: params.multipart.maxFiles ?? 1,
+                    fileSize: params.multipart.fileMaxSize ?? 1000000,
+                },
+            });
+        }
+        if (params.cookies?.enabled) {
+            this.server.register(cookie);
+        }
         if (params.compression?.enabled) {
             this.server.register(compress, {
                 global: true,
-                threshold: params.compression.threshold ?? 1024,
+                threshold: params.compression.threshold ?? 1000,
             });
         }
         if (params.cors?.enabled) {
@@ -45,22 +69,30 @@ class Server {
                 credentials: params.cors.allowCredentials,
             });
         }
-        if (params.cookies?.enabled) {
-            this.server.register(cookies);
-        }
         this.server.register((server, options, done) => {
             params.routes.forEach((route) => {
                 server.route({
-                    url: route.path,
                     method: route.method,
+                    url: route.path,
                     schema: {
                         summary: route.name ?? route.path,
                         description: route.description,
-                        ...route.schema.params ? { params: route.schema.params } : {},
-                        ...route.schema.query ? { query: route.schema.query } : {},
-                        ...route.schema.headers ? { headers: route.schema.headers } : {},
-                        ...route.schema.body ? { body: route.schema.body } : {},
-                        ...route.schema.response ? { response: route.schema.response } : {},
+                        tags: route.tags,
+                        ...route.schema.params
+                            ? { params: route.schema.params }
+                            : {},
+                        ...route.schema.query
+                            ? { query: route.schema.query }
+                            : {},
+                        ...route.schema.headers
+                            ? { headers: route.schema.headers }
+                            : {},
+                        ...route.schema.body
+                            ? { body: route.schema.body }
+                            : {},
+                        ...route.schema.response
+                            ? { response: route.schema.response }
+                            : {},
                     },
                     handler: route.handler,
                 });
@@ -89,6 +121,9 @@ class Server {
     async close() {
         await this.server.close();
     }
+    async inject(params) {
+        return this.server.inject(params);
+    }
     openapi(format) {
         return this.server.swagger({
             yaml: format === OpenApiFormat.YAML,

package/dist/server/multipartErrorCodes.d.ts

@@ -0,0 +1,2 @@
+declare const multipartErrorCodes: string[];
+export { multipartErrorCodes, };

package/dist/server/multipartErrorCodes.js

@@ -0,0 +1,12 @@
+const multipartErrorCodes = [
+    'FST_FIELDS_LIMIT',
+    'FST_FILE_BUFFER_NOT_FOUND',
+    'FST_FILES_LIMIT',
+    'FST_INVALID_JSON_FIELD_ERROR',
+    'FST_INVALID_MULTIPART_CONTENT_TYPE',
+    'FST_NO_FORM_DATA',
+    'FST_PARTS_LIMIT',
+    'FST_PROTO_VIOLATION',
+    'FST_REQ_FILE_TOO_LARGE',
+];
+export { multipartErrorCodes, };

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/package.json

@@ -1,12 +1,12 @@
 {
   "name": "apeframework",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "publishConfig": {
     "access": "public"
   },
   "license": "MIT",
   "author": "Matthieu Symoens",
-  "description": "Node.js app framework",
+  "description": "Node.js App Framework",
   "keywords": [
     "ape",
     "framework",
@@ -14,42 +14,49 @@
   ],
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/MattSyms/apeframework.git"
+    "url": "git+https://github.com/MattSyms/apeframework.git",
+    "directory": "framework"
   },
   "type": "module",
   "engines": {
     "node": ">=22"
   },
   "dependencies": {
-    "@fastify/compress": "^8.1",
+    "@fastify/compress": "^8.3",
     "@fastify/cookie": "^11.0",
-    "@fastify/cors": "^11.1",
+    "@fastify/cors": "^11.2",
+    "@fastify/formbody": "^8.0",
+    "@fastify/multipart": "^9.4",
     "@fastify/response-validation": "^3.0",
-    "@fastify/swagger": "^9.5",
+    "@fastify/swagger": "^9.7",
     "@types/fs-extra": "^11.0",
     "@types/nodemailer": "^7.0",
     "@types/yargs-parser": "^21.0",
-    "ajv": "^8.17",
+    "ajv": "^8.18",
     "argon2": "^0.44",
-    "bullmq": "^5.63",
-    "dotenv": "^17.2",
+    "bullmq": "^5.70",
+    "dotenv": "^17.3",
     "fast-uri": "^3.1",
-    "fastify": "^5.6",
+    "fastify": "^5.7",
     "fs-extra": "^11.3",
     "ical-generator": "^10.0",
-    "ioredis": "^5.8",
+    "ioredis": "^5.10",
     "jose": "^6.1",
-    "mysql2": "^3.15",
-    "nodemailer": "^7.0",
+    "mariadb": "^3.5",
+    "mysql2": "^3.18",
+    "nodemailer": "^8.0",
     "openapi-types": "^12.1",
-    "pino": "^10.1",
+    "pg": "^8.19",
+    "pg-hstore": "^2.3",
+    "pino": "^10.3",
     "pino-pretty": "^13.1",
     "sequelize": "^6.37",
+    "sqlite3": "^5.1",
     "umzug": "^3.8",
     "yargs-parser": "^22.0"
   },
   "peerDependencies": {
-    "@types/node": "^24.10",
+    "@types/node": "^25.3",
     "typescript": "^5.9"
   },
   "exports": {
@@ -263,22 +270,22 @@
         "default": "./dist/db/ReferentialAction.js"
       }
     },
-    "./db/Seed": {
+    "./db/Transaction": {
       "import": {
-        "types": "./dist/db/Seed.d.ts",
-        "default": "./dist/db/Seed.js"
+        "types": "./dist/db/Transaction.d.ts",
+        "default": "./dist/db/Transaction.js"
       }
     },
-    "./db/Seeder": {
+    "./db/adapters/maria/MariaDb": {
       "import": {
-        "types": "./dist/db/Seeder.d.ts",
-        "default": "./dist/db/Seeder.js"
+        "types": "./dist/db/adapters/maria/MariaDb.d.ts",
+        "default": "./dist/db/adapters/maria/MariaDb.js"
       }
     },
-    "./db/Transaction": {
+    "./db/adapters/mssql/MssqlDb": {
       "import": {
-        "types": "./dist/db/Transaction.d.ts",
-        "default": "./dist/db/Transaction.js"
+        "types": "./dist/db/adapters/mssql/MssqlDb.d.ts",
+        "default": "./dist/db/adapters/mssql/MssqlDb.js"
       }
     },
     "./db/adapters/mysql/MysqlDb": {
@@ -287,6 +294,24 @@
         "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",
@@ -689,6 +714,18 @@
         "default": "./dist/server/Handler.js"
       }
     },
+    "./server/InjectParams": {
+      "import": {
+        "types": "./dist/server/InjectParams.d.ts",
+        "default": "./dist/server/InjectParams.js"
+      }
+    },
+    "./server/InjectResponse": {
+      "import": {
+        "types": "./dist/server/InjectResponse.d.ts",
+        "default": "./dist/server/InjectResponse.js"
+      }
+    },
     "./server/Method": {
       "import": {
         "types": "./dist/server/Method.d.ts",
@@ -737,6 +774,12 @@
         "default": "./dist/server/getAjv.js"
       }
     },
+    "./server/multipartErrorCodes": {
+      "import": {
+        "types": "./dist/server/multipartErrorCodes.d.ts",
+        "default": "./dist/server/multipartErrorCodes.js"
+      }
+    },
     "./tls/Tls": {
       "import": {
         "types": "./dist/tls/Tls.d.ts",

package/dist/db/Seed.d.ts

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

package/dist/db/Seeder.d.ts

@@ -1,16 +0,0 @@
-import type { Db } from './Db.js';
-declare class Seeder {
-    private readonly db;
-    private readonly directory;
-    private readonly extension;
-    private readonly onApply?;
-    constructor(params: {
-        db: Db;
-        directory: string;
-        extension: string;
-        onApply?: (name: string) => void;
-    });
-    list(): string[];
-    apply(name: string): Promise<void>;
-}
-export { Seeder, };

package/dist/db/Seeder.js

@@ -1,26 +0,0 @@
-import { basename, extname, resolve } from 'node:path';
-import fs from 'fs-extra';
-class Seeder {
-    db;
-    directory;
-    extension;
-    onApply;
-    constructor(params) {
-        this.db = params.db;
-        this.directory = params.directory;
-        this.extension = params.extension;
-        this.onApply = params.onApply;
-    }
-    list() {
-        return fs.readdirSync(this.directory).map((filename) => {
-            return basename(filename, extname(filename));
-        });
-    }
-    async apply(name) {
-        this.onApply?.(name);
-        const file = resolve(this.directory, `${name}.${this.extension}`);
-        const { seed } = await import(file);
-        await seed(this.db);
-    }
-}
-export { Seeder, };