equipped 5.0.0-beta.16 → 5.0.0-beta.7

package/CHANGELOG.md

@@ -2,75 +2,6 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
-## [5.0.0-beta.16](https://github.com/kevinand11/equipped/compare/v5.0.0-beta.15...v5.0.0-beta.16) (2024-06-03)
-
-
-### Features
-
-* support headers in schema ([85a9319](https://github.com/kevinand11/equipped/commit/85a93195ffb9b97927dc22a61d5f118f49598926))
-
-
-### Bug Fixes
-
-* error when cloning objects in toJSON ([1f4cf25](https://github.com/kevinand11/equipped/commit/1f4cf252a6924f0b2c329c11b41f5ac71c68f87b))
-
-## [5.0.0-beta.15](https://github.com/kevinand11/equipped/compare/v5.0.0-beta.14...v5.0.0-beta.15) (2024-06-02)
-
-
-### Bug Fixes
-
-* remove slowdown to avoid esm ([414b2ef](https://github.com/kevinand11/equipped/commit/414b2ef3c047a0c9843ae828b21a1aeaa10925b9))
-
-## [5.0.0-beta.14](https://github.com/kevinand11/equipped/compare/v5.0.0-beta.13...v5.0.0-beta.14) (2024-06-02)
-
-
-### Bug Fixes
-
-* use maps for registered maps for speed ([1882a24](https://github.com/kevinand11/equipped/commit/1882a24d02d666e7779212dbeb67e1022761c823))
-
-## [5.0.0-beta.13](https://github.com/kevinand11/equipped/compare/v5.0.0-beta.12...v5.0.0-beta.13) (2024-06-01)
-
-
-### Features
-
-* add description for each status code ([064a686](https://github.com/kevinand11/equipped/commit/064a68647ea91a5791aad75b1b95988accc38b32))
-
-## [5.0.0-beta.12](https://github.com/kevinand11/equipped/compare/v5.0.0-beta.11...v5.0.0-beta.12) (2024-06-01)
-
-
-### Bug Fixes
-
-* function overloading for validate function ([e1209ab](https://github.com/kevinand11/equipped/commit/e1209ab10f435514d7ac84c3c0af1788d7f3699d))
-* references to BaseEntity ([071a07a](https://github.com/kevinand11/equipped/commit/071a07a827e6c4f73b5cf43ae462541c4518df21))
-
-## [5.0.0-beta.11](https://github.com/kevinand11/equipped/compare/v5.0.0-beta.10...v5.0.0-beta.11) (2024-06-01)
-
-
-### Features
-
-* unique paths and keys for routes ([36d1776](https://github.com/kevinand11/equipped/commit/36d17762b6d31497e9f15883cc05073ff29a886e))
-
-## [5.0.0-beta.10](https://github.com/kevinand11/equipped/compare/v5.0.0-beta.9...v5.0.0-beta.10) (2024-05-31)
-
-
-### Bug Fixes
-
-* generateJSONSchema ([062360b](https://github.com/kevinand11/equipped/commit/062360bb92ccdaa1ae8fa3d167f9bbb71f156f7c))
-
-## [5.0.0-beta.9](https://github.com/kevinand11/equipped/compare/v5.0.0-beta.8...v5.0.0-beta.9) (2024-05-31)
-
-
-### Bug Fixes
-
-* generateJSONSchema ([39031fd](https://github.com/kevinand11/equipped/commit/39031fd7c8d0f18a93c55b3fc542fd33042e4e44))
-
-## [5.0.0-beta.8](https://github.com/kevinand11/equipped/compare/v5.0.0-beta.7...v5.0.0-beta.8) (2024-05-31)
-
-
-### Features
-
-* route descriptions ([26b7323](https://github.com/kevinand11/equipped/commit/26b7323b523f83aedacd55096ae01f285fff1398))
-
 ## [5.0.0-beta.7](https://github.com/kevinand11/equipped/compare/v5.0.0-beta-6...v5.0.0-beta.7) (2024-05-31)
 
 

package/lib/db/_instance.d.ts

@@ -4,14 +4,14 @@ import { DebeziumSetup } from './debezium';
 import { QueryParams, QueryResults } from './query';
 export declare abstract class Db {
     #private;
-    abstract change<Model, Entity extends BaseEntity<any, any>>(collection: any, callbacks: DbChangeCallbacks<Model, Entity>, mapper: (model: Model | null) => Entity | null): DbChange<Model, Entity>;
+    abstract change<Model, Entity extends BaseEntity>(collection: any, callbacks: DbChangeCallbacks<Model, Entity>, mapper: (model: Model | null) => Entity | null): DbChange<Model, Entity>;
     abstract query<Model>(collection: any, params: QueryParams): Promise<QueryResults<Model>>;
     protected _addToDbChanges(dbChange: DbChange<any, any>): this;
     startAllDbChanges(): Promise<void>;
     abstract start(): Promise<void>;
     abstract close(): Promise<void>;
 }
-export declare abstract class DbChange<Model, Entity extends BaseEntity<any, any>> {
+export declare abstract class DbChange<Model, Entity extends BaseEntity> {
     #private;
     constructor(callbacks: DbChangeCallbacks<Model, Entity>, mapper: (model: Model | null) => Entity | null);
     abstract start(): Promise<void>;

package/lib/db/mongoose/changes.d.ts

@@ -26,7 +26,7 @@
 import mongoose from 'mongoose';
 import { BaseEntity } from '../../structure';
 import { DbChange, DbChangeCallbacks } from '../_instance';
-export declare class MongoDbChange<Model, Entity extends BaseEntity<any, any>> extends DbChange<Model, Entity> {
+export declare class MongoDbChange<Model, Entity extends BaseEntity> extends DbChange<Model, Entity> {
     #private;
     constructor(model: mongoose.Model<Model>, callbacks: DbChangeCallbacks<Model, Entity>, mapper: (model: Model | null) => Entity | null);
     start(): Promise<void>;

package/lib/db/mongoose/index.d.ts

@@ -25,15 +25,15 @@
 /// <reference types="mongoose/types/inferrawdoctype" />
 import mongoose from 'mongoose';
 import { BaseEntity } from '../../structure';
-import { Db, DbChangeCallbacks } from '../_instance';
 import { QueryParams, QueryResults } from '../query';
+import { Db, DbChangeCallbacks } from '../_instance';
 import { MongoDbChange } from './changes';
 export declare class MongoDb extends Db {
     #private;
     get Schema(): typeof mongoose.Schema;
     get Id(): mongoose.Types.ObjectId;
     use(dbName?: string): mongoose.Connection;
-    change<Model, Entity extends BaseEntity<any, any>>(model: mongoose.Model<Model>, callbacks: DbChangeCallbacks<Model, Entity>, mapper: (model: Model | null) => Entity | null): MongoDbChange<Model, Entity>;
+    change<Model, Entity extends BaseEntity>(model: mongoose.Model<Model>, callbacks: DbChangeCallbacks<Model, Entity>, mapper: (model: Model | null) => Entity | null): MongoDbChange<Model, Entity>;
     query<Model>(model: mongoose.Model<Model>, params: QueryParams): Promise<QueryResults<Model>>;
     start(): Promise<void>;
     close(): Promise<void>;

package/lib/instance/index.js

@@ -59,9 +59,8 @@ class Instance {
         return __classPrivateFieldGet(this, _Instance_settings, "f");
     }
     static createLogger() {
-        const defaultLogLevel = 'info';
         return (0, pino_1.default)({
-            level: __classPrivateFieldGet(_a, _a, "f", _Instance_initialized) ? _a.get().settings?.logLevel ?? defaultLogLevel : defaultLogLevel,
+            level: _a.get()?.settings?.logLevel ?? 'info',
             serializers: {
                 err: pino_1.default.stdSerializers.err,
                 req: pino_1.default.stdSerializers.req,

package/lib/instance/settings.d.ts

@@ -1,6 +1,7 @@
 import { Level } from 'pino';
 import type { ServerTypes } from '../server';
 export type Settings = {
+    isDev: boolean;
     accessTokenKey: string;
     accessTokenTTL: number;
     refreshTokenKey: string;

package/lib/instance/settings.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.defaulInstanceSetting = void 0;
 exports.defaulInstanceSetting = {
+    isDev: false,
     accessTokenKey: 'accessTokenKey',
     accessTokenTTL: 60 * 60,
     refreshTokenKey: 'refreshTokenKey',
@@ -17,10 +18,10 @@ exports.defaulInstanceSetting = {
     maxFileUploadSizeInMb: 500,
     useRateLimit: false,
     rateLimitPeriodInMs: 60 * 60 * 1000,
-    rateLimit: 5000,
+    rateLimit: 2500,
     useSlowDown: false,
     slowDownPeriodInMs: 10 * 60 * 1000,
-    slowDownAfter: 2000,
+    slowDownAfter: 1000,
     slowDownDelayInMs: 500,
     hashSaltRounds: 10,
     paginationDefaultLimit: 100,

package/lib/listeners/emitter.d.ts

@@ -13,9 +13,9 @@ export declare class Listener {
     #private;
     constructor(socket: io.Server, callers: SocketCallers);
     start(): Promise<void>;
-    created<T extends BaseEntity<any, any>>(channels: string[], data: T): Promise<void>;
-    updated<T extends BaseEntity<any, any>>(channels: string[], data: T): Promise<void>;
-    deleted<T extends BaseEntity<any, any>>(channels: string[], data: T): Promise<void>;
+    created(channels: string[], data: BaseEntity): Promise<void>;
+    updated(channels: string[], data: BaseEntity): Promise<void>;
+    deleted(channels: string[], data: BaseEntity): Promise<void>;
     set callers(callers: SocketCallers);
     register(channel: string, onJoin?: OnJoinFn): this;
 }

package/lib/scripts/json-schema.d.ts

@@ -1,6 +1,2 @@
-import { Options } from 'ts-oas';
 import { RouteSchema } from '../server';
-export declare function generateJSONSchema(patterns: (string | RegExp)[], paths: string[], options?: {
-    tsConfigPath?: string | Record<string, unknown>;
-    options?: Options;
-}): Record<string, RouteSchema>;
+export declare function generateJSONSchema(patterns: (string | RegExp)[], paths: string[]): Record<string, RouteSchema>;

package/lib/scripts/json-schema.js

@@ -26,36 +26,22 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateJSONSchema = void 0;
 const ts_oas_1 = __importStar(require("ts-oas"));
 const instance_1 = require("../instance");
-const server_1 = require("../server");
 const fileSchema = { type: 'string', format: 'binary' };
-const statusCodes = Object.entries(server_1.StatusCodes);
-function generateJSONSchema(patterns, paths, options) {
-    const tsProgram = (0, ts_oas_1.createProgram)(paths, options?.tsConfigPath);
-    const logger = instance_1.Instance.createLogger();
-    const tsoas = new ts_oas_1.default(tsProgram, {
-        ref: false,
-        nullableKeyword: false,
-        ...(options?.options ?? {})
-    });
+function generateJSONSchema(patterns, paths) {
+    const tsProgram = (0, ts_oas_1.createProgram)(paths, { strictNullChecks: true });
+    const tsoas = new ts_oas_1.default(tsProgram, { ref: false, ignoreErrors: true });
     const jsonSchema = tsoas.getSchemas(patterns);
     return Object.entries(jsonSchema)
         .map(([name, { properties: def }]) => {
         try {
             const key = def?.key?.enum?.at(0) ?? name;
             if (!def || !key || !def.method)
-                return [undefined, undefined];
+                throw new Error();
             const response = def.responses.properties ?? def.responses.anyOf?.reduce((acc, cur) => {
                 if (cur.properties)
                     return { ...acc, ...cur.properties };
                 return acc;
             }, {}) ?? undefined;
-            if (response) {
-                for (const [key, value] of Object.entries(response)) {
-                    const status = statusCodes.find(([_, code]) => code.toString() === key);
-                    if (status)
-                        value['description'] = `${status[0]} Response`;
-                }
-            }
             const body = def.body ?? {};
             if (def.files?.properties) {
                 const files = def.files ?? {};
@@ -67,36 +53,32 @@ function generateJSONSchema(patterns, paths, options) {
                     body.required = [];
                 Object.entries(files.properties ?? {}).forEach(([key, value]) => {
                     const isMultiple = !!value.enum?.at(0);
-                    const fileValue = isMultiple ? { type: 'array', items: fileSchema } : fileSchema;
-                    body.properties[key] = {
-                        anyOf: [fileValue, body.properties[key]].filter(Boolean)
-                    };
-                    if (files.required?.includes(key) && !body.required?.includes(key))
+                    body.properties[key] = isMultiple ? { type: 'array', items: fileSchema } : fileSchema;
+                    if (files.required?.includes(key))
                         body.required.push(key);
                 });
             }
-            const schema = {
-                body,
-                params: def.params,
-                querystring: def.query,
-                headers: def.headers,
-                response,
-                operationId: key,
-                summary: name,
-            };
+            const schema = def
+                ? {
+                    body,
+                    params: def.params,
+                    querystring: def.query,
+                    headers: def.headers,
+                    response,
+                    operationId: key,
+                    summary: name,
+                }
+                : undefined;
             return [key, schema];
         }
         catch (err) {
-            logger.warn(`Error parsing ${name}: ${err.message}. Skipping route`);
+            instance_1.Instance.createLogger().warn(`Error parsing ${name}: ${err.message}. Skipping route`);
             return [undefined, undefined];
         }
     })
         .reduce((acc, [path, schema]) => {
-        if (!path || !schema)
-            return acc;
-        if (acc[path])
-            logger.warn(`Duplicate route key '${path}' found for '${acc[path].summary}' & '${schema.summary}'. Make sure to use unique keys for all routes because only the last one will be used.`);
-        acc[path] = stripEmptyObjects(schema);
+        if (path && schema)
+            acc[path] = stripEmptyObjects(schema);
         return acc;
     }, {});
 }

package/lib/server/impls/base.d.ts

@@ -10,7 +10,7 @@ import { Defined } from '../../types';
 import { Request } from '../requests';
 import { Router } from '../routes';
 import { Route } from '../types';
-export type FullRoute = Required<Omit<Route, 'schema' | 'groups' | 'security' | 'descriptions' | 'hideSchema' | 'onError' | 'onSetupHandler' | '__def'>> & {
+export type FullRoute = Required<Omit<Route, 'schema' | 'tags' | 'security' | 'hideSchema' | 'onError' | 'onSetupHandler' | '__def'>> & {
     schema: FastifySchema;
     onError?: Route['onError'];
 };
@@ -27,10 +27,10 @@ export declare abstract class Server<Req = any, Res = any> {
     protected abstract registerRoute(route: FullRoute): void;
     constructor(server: http.Server);
     get listener(): Listener;
-    addRouter(...routers: Router[]): void;
-    addRoute(...routes: Route[]): void;
-    addSchema(...schemas: Schemas[]): void;
+    addRoutes(routes: Route[]): void;
+    addSchema(schemas: Schemas): void;
     load(): Promise<void>;
+    register(router: Router | Router[]): void;
     test(): import("supertest/lib/agent")<supertest.SuperTestStatic.Test>;
     start(port: number): Promise<boolean>;
 }

package/lib/server/impls/base.js

@@ -13,7 +13,7 @@ var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-var _Server_instances, _Server_routesByPath, _Server_routesByKey, _Server_schemas, _Server_listener, _Server_regRoute;
+var _Server_instances, _Server_schemas, _Server_listener, _Server_regRoute;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Server = void 0;
 const socket_io_1 = __importDefault(require("socket.io"));
@@ -22,11 +22,10 @@ const path_1 = __importDefault(require("path"));
 const instance_1 = require("../../instance");
 const listeners_1 = require("../../listeners");
 const middlewares_1 = require("../middlewares");
+const routes_1 = require("../routes");
 class Server {
     constructor(server) {
         _Server_instances.add(this);
-        _Server_routesByPath.set(this, new Map());
-        _Server_routesByKey.set(this, new Map());
         _Server_schemas.set(this, {});
         _Server_listener.set(this, null);
         this.staticPath = path_1.default.join(process.cwd(), 'public');
@@ -63,32 +62,33 @@ class Server {
         }
         return __classPrivateFieldGet(this, _Server_listener, "f");
     }
-    addRouter(...routers) {
-        routers.map((router) => router.routes).forEach((routes) => this.addRoute(...routes));
-    }
-    addRoute(...routes) {
+    addRoutes(routes) {
         routes.forEach((route) => __classPrivateFieldGet(this, _Server_instances, "m", _Server_regRoute).call(this, route));
     }
-    addSchema(...schemas) {
-        schemas.forEach((schema) => Object.assign(__classPrivateFieldGet(this, _Server_schemas, "f"), schema));
+    addSchema(schemas) {
+        Object.assign(__classPrivateFieldGet(this, _Server_schemas, "f"), schemas);
     }
     async load() {
         await this.onLoad();
     }
+    register(router) {
+        const routers = Array.isArray(router) ? router : [router];
+        routers.map((router) => router.routes).forEach((routes) => this.addRoutes(routes));
+    }
     test() {
         return (0, supertest_1.default)(this.server);
     }
     async start(port) {
-        this.addRoute({
-            method: 'get',
+        const postRoutesRouter = new routes_1.Router();
+        postRoutesRouter.get({
             path: '__health',
-            handler: async () => `${this.settings.appId} service running`,
             schema: {
                 response: {
-                    200: { type: 'string' }
+                    200: { type: 'string' },
                 }
-            },
-        });
+            }
+        })(async () => `${this.settings.appId} service running`);
+        this.register(postRoutesRouter);
         const started = await this.startServer(port);
         if (started)
             await instance_1.Instance.get().logger.info(`${this.settings.appId} service listening on port ${port}`);
@@ -96,16 +96,13 @@ class Server {
     }
 }
 exports.Server = Server;
-_Server_routesByPath = new WeakMap(), _Server_routesByKey = new WeakMap(), _Server_schemas = new WeakMap(), _Server_listener = new WeakMap(), _Server_instances = new WeakSet(), _Server_regRoute = function _Server_regRoute(route) {
-    if (!route.path.startsWith('/'))
-        route.path = `/${route.path}`;
-    const middlewares = [middlewares_1.parseAuthUser, ...(route.middlewares ?? [])];
-    middlewares.forEach((m) => m.onSetup?.(route));
+_Server_schemas = new WeakMap(), _Server_listener = new WeakMap(), _Server_instances = new WeakSet(), _Server_regRoute = function _Server_regRoute(route) {
+    const { method, path, middlewares = [], handler, schema, tags = [], security = [], onError, hideSchema = false } = route;
+    const { key = `${method.toLowerCase()} ${path}` } = route;
+    const allMiddlewares = [middlewares_1.parseAuthUser, ...middlewares];
+    allMiddlewares.forEach((m) => m.onSetup?.(route));
     route.onSetupHandler?.(route);
-    route.onError?.onSetup?.(route);
-    const { method, path, handler, schema, security, onError, hideSchema = false } = route;
-    const pathKey = `(${method.toUpperCase()}) ${path}`;
-    const { key = pathKey } = route;
+    onError?.onSetup?.(route);
     const scheme = schema ?? __classPrivateFieldGet(this, _Server_schemas, "f")[key] ?? {};
     const fullRoute = {
         method, middlewares, handler, key,
@@ -115,16 +112,9 @@ _Server_routesByPath = new WeakMap(), _Server_routesByKey = new WeakMap(), _Serv
             ...scheme,
             hide: hideSchema,
             operationId: scheme.operationId ?? handler.name,
-            tags: route.groups?.length ? [route.groups.join(' > ')] : undefined,
-            description: route.descriptions?.join(' | '),
+            tags: [tags.join(' > ') || 'default'],
             security,
         }
     };
-    if (__classPrivateFieldGet(this, _Server_routesByPath, "f").get(pathKey))
-        throw new Error(`Route path ${pathKey} already registered. All route paths and methods combinations must be unique`);
-    if (__classPrivateFieldGet(this, _Server_routesByKey, "f").get(key))
-        throw new Error(`Route key ${fullRoute.key} already registered. All route keys must be unique`);
-    __classPrivateFieldGet(this, _Server_routesByPath, "f").set(pathKey, fullRoute);
-    __classPrivateFieldGet(this, _Server_routesByKey, "f").set(key, fullRoute);
     this.registerRoute(fullRoute);
 };

package/lib/server/impls/express.js

@@ -23,6 +23,7 @@ const cors_1 = __importDefault(require("cors"));
 const express_1 = __importDefault(require("express"));
 const express_fileupload_1 = __importDefault(require("express-fileupload"));
 const express_rate_limit_1 = __importDefault(require("express-rate-limit"));
+const express_slow_down_1 = __importDefault(require("express-slow-down"));
 const helmet_1 = __importDefault(require("helmet"));
 const http_1 = __importDefault(require("http"));
 const json_schema_resolver_1 = __importDefault(require("json-schema-resolver"));
@@ -65,6 +66,12 @@ class ExpressServer extends base_1.Server {
                 limit: this.settings.rateLimit,
                 handler: (_, res) => res.status(types_1.StatusCodes.TooManyRequests).json([{ message: 'Too Many Requests' }])
             }));
+        if (this.settings.useSlowDown)
+            app.use((0, express_slow_down_1.default)({
+                windowMs: this.settings.slowDownPeriodInMs,
+                delayAfter: this.settings.slowDownAfter,
+                delayMs: this.settings.slowDownDelayInMs
+            }));
     }
     registerRoute(route) {
         const openapi = (0, utils_1.prepareOpenapiMethod)(route.schema, __classPrivateFieldGet(this, _ExpressServer_ref, "f"), this.baseOpenapiDoc, route.path);

package/lib/server/impls/fastify.d.ts

@@ -11,7 +11,7 @@ export declare class FastifyServer extends Server<FastifyRequest, FastifyReply>
     protected onLoad(): Promise<void>;
     protected registerRoute(route: FullRoute): void;
     protected startServer(port: number): Promise<boolean>;
-    protected parse(req: FastifyRequest, res: FastifyReply): Promise<Request<import("../types").Api<any, string, import("../types").MethodTypes, any, Record<string, boolean>, Record<string, string>, Record<string, any>, Record<string, string | string[]>, import("../types").SupportedStatusCodes>>>;
+    protected parse(req: FastifyRequest, res: FastifyReply): Promise<Request<import("../types").Api<any, string, import("../types").MethodTypes, any, Record<string, boolean>, Record<string, string>, Record<string, any>, import("../types").SupportedStatusCodes>>>;
     makeController(cb: Defined<Route['handler']>): RouteHandlerMethod;
     makeMiddleware(cb: Defined<Route['middlewares']>[number]['cb']): preHandlerHookHandler<import("fastify").RawServerDefault, import("http").IncomingMessage, import("http").ServerResponse<import("http").IncomingMessage>, import("fastify").RouteGenericInterface, unknown, import("fastify").FastifySchema, import("fastify").FastifyTypeProviderDefault, import("fastify").FastifyBaseLogger>;
     makeErrorMiddleware(cb: Defined<Route['onError']>['cb']): (error: import("fastify").FastifyError, request: FastifyRequest<import("fastify").RouteGenericInterface, import("fastify").RawServerDefault, import("http").IncomingMessage, import("fastify").FastifySchema, import("fastify").FastifyTypeProviderDefault, unknown, import("fastify").FastifyBaseLogger, import("fastify/types/type-provider").ResolveFastifyRequestType<import("fastify").FastifyTypeProviderDefault, import("fastify").FastifySchema, import("fastify").RouteGenericInterface>>, reply: FastifyReply<import("fastify").RawServerDefault, import("http").IncomingMessage, import("http").ServerResponse<import("http").IncomingMessage>, import("fastify").RouteGenericInterface, unknown, import("fastify").FastifySchema, import("fastify").FastifyTypeProviderDefault, unknown>) => void;

package/lib/server/impls/fastify.js

@@ -26,6 +26,7 @@ const static_1 = __importDefault(require("@fastify/static"));
 const swagger_1 = __importDefault(require("@fastify/swagger"));
 const swagger_ui_1 = __importDefault(require("@fastify/swagger-ui"));
 const fastify_1 = __importDefault(require("fastify"));
+const fastify_slow_down_1 = __importDefault(require("fastify-slow-down"));
 const qs_1 = __importDefault(require("qs"));
 const errors_1 = require("../../errors");
 const exit_1 = require("../../exit");
@@ -74,6 +75,12 @@ class FastifyServer extends base_1.Server {
                 f.value = parsed;
             }
         });
+        if (this.settings.useSlowDown)
+            app.register(fastify_slow_down_1.default, {
+                timeWindow: this.settings.slowDownPeriodInMs,
+                delayAfter: this.settings.slowDownAfter,
+                delay: this.settings.slowDownDelayInMs
+            });
         if (this.settings.useRateLimit)
             app.register(rate_limit_1.default, {
                 max: this.settings.rateLimit,
@@ -114,11 +121,11 @@ class FastifyServer extends base_1.Server {
         const allHeaders = Object.fromEntries(Object.entries(req.headers).map(([key, val]) => [key, val ?? null]));
         const headers = {
             ...allHeaders,
-            AccessToken: req.headers['access-token']?.toString() ?? null,
-            RefreshToken: req.headers['refresh-token']?.toString() ?? null,
-            ContentType: req.headers['content-type']?.toString() ?? null,
+            AccessToken: req.headers['Access-Token']?.toString() ?? null,
+            RefreshToken: req.headers['Refresh-Token']?.toString() ?? null,
+            ContentType: req.headers['Content-Type']?.toString() ?? null,
             Referer: req.headers['referer']?.toString() ?? null,
-            UserAgent: req.headers['user-agent']?.toString() ?? null
+            UserAgent: req.headers['User-Agent']?.toString() ?? null
         };
         const { body, files } = excludeBufferKeys(req.body ?? {});
         return req.savedReq || (req.savedReq = new requests_1.Request({

package/lib/server/middlewares/errorHandler.d.ts

@@ -1,4 +1,4 @@
 export declare const errorHandler: {
-    cb: import("../types").ErrorHandler<import("../types").Api<any, string, import("../types").MethodTypes, any, Record<string, boolean>, Record<string, string>, Record<string, any>, Record<string, string | string[]>, import("../types").SupportedStatusCodes>>;
+    cb: import("../types").ErrorHandler<import("../types").Api<any, string, import("../types").MethodTypes, any, Record<string, boolean>, Record<string, string>, Record<string, any>, import("../types").SupportedStatusCodes>>;
     onSetup?: import("../types").HandlerSetup | undefined;
 };

package/lib/server/middlewares/notFoundHandler.d.ts

@@ -1,4 +1,4 @@
 export declare const notFoundHandler: {
-    cb: import("../types").RouteMiddlewareHandler<import("../types").Api<any, string, import("../types").MethodTypes, any, Record<string, boolean>, Record<string, string>, Record<string, any>, Record<string, string | string[]>, import("../types").SupportedStatusCodes>>;
+    cb: import("../types").RouteMiddlewareHandler<import("../types").Api<any, string, import("../types").MethodTypes, any, Record<string, boolean>, Record<string, string>, Record<string, any>, import("../types").SupportedStatusCodes>>;
     onSetup?: import("../types").HandlerSetup | undefined;
 };

package/lib/server/middlewares/parseAuthUser.d.ts

@@ -1,4 +1,4 @@
 export declare const parseAuthUser: {
-    cb: import("../types").RouteMiddlewareHandler<import("../types").Api<any, string, import("../types").MethodTypes, any, Record<string, boolean>, Record<string, string>, Record<string, any>, Record<string, string | string[]>, import("../types").SupportedStatusCodes>>;
+    cb: import("../types").RouteMiddlewareHandler<import("../types").Api<any, string, import("../types").MethodTypes, any, Record<string, boolean>, Record<string, string>, Record<string, any>, import("../types").SupportedStatusCodes>>;
     onSetup?: import("../types").HandlerSetup | undefined;
 };

package/lib/server/middlewares/requireAuthUser.d.ts

@@ -1,4 +1,4 @@
 export declare const requireAuthUser: {
-    cb: import("../types").RouteMiddlewareHandler<import("../types").Api<any, string, import("../types").MethodTypes, any, Record<string, boolean>, Record<string, string>, Record<string, any>, Record<string, string | string[]>, import("../types").SupportedStatusCodes>>;
+    cb: import("../types").RouteMiddlewareHandler<import("../types").Api<any, string, import("../types").MethodTypes, any, Record<string, boolean>, Record<string, string>, Record<string, any>, import("../types").SupportedStatusCodes>>;
     onSetup?: import("../types").HandlerSetup | undefined;
 };

package/lib/server/middlewares/requireAuthUser.js

@@ -13,6 +13,4 @@ exports.requireAuthUser = (0, types_1.makeMiddleware)(async (request) => {
 }, (route) => {
     route.security ?? (route.security = []);
     route.security.push({ AccessToken: [] });
-    route.descriptions ?? (route.descriptions = []);
-    route.descriptions.push('Requires a valid Access-Token header.');
 });

package/lib/server/middlewares/requireRefreshUser.d.ts

@@ -1,4 +1,4 @@
 export declare const requireRefreshUser: {
-    cb: import("../types").RouteMiddlewareHandler<import("../types").Api<any, string, import("../types").MethodTypes, any, Record<string, boolean>, Record<string, string>, Record<string, any>, Record<string, string | string[]>, import("../types").SupportedStatusCodes>>;
+    cb: import("../types").RouteMiddlewareHandler<import("../types").Api<any, string, import("../types").MethodTypes, any, Record<string, boolean>, Record<string, string>, Record<string, any>, import("../types").SupportedStatusCodes>>;
     onSetup?: import("../types").HandlerSetup | undefined;
 };

package/lib/server/middlewares/requireRefreshUser.js

@@ -14,6 +14,4 @@ exports.requireRefreshUser = (0, types_1.makeMiddleware)(async (request) => {
 }, (route) => {
     route.security ?? (route.security = []);
     route.security.push({ RefreshToken: [] });
-    route.descriptions ?? (route.descriptions = []);
-    route.descriptions.push('Requires a valid Refresh-Token header.');
 });

package/lib/server/routes.d.ts

@@ -4,7 +4,6 @@ export declare const groupRoutes: (config: GeneralConfig, routes: Route[]) => Ro
 export declare class Router extends ClassPropertiesWrapper<AddMethodImpls> {
     #private;
     constructor(config?: GeneralConfig);
-    add(...routes: Route[]): void;
-    nest(...routers: Router[]): void;
-    get routes(): Route<import("./types").ApiDef<import("./types").Api<any, string, import("./types").MethodTypes, any, Record<string, boolean>, Record<string, string>, Record<string, any>, Record<string, string | string[]>, import("./types").SupportedStatusCodes>>>[];
+    include(router: Router): void;
+    get routes(): Route<import("./types").ApiDef<import("./types").Api<any, string, import("./types").MethodTypes, any, Record<string, boolean>, Record<string, string>, Record<string, any>, import("./types").SupportedStatusCodes>>>[];
 }

package/lib/server/routes.js

@@ -19,8 +19,8 @@ const groupRoutes = (config, routes) => routes
     .map((route) => ({
     ...config,
     ...route,
-    path: `${config.path}/${route.path}`.replace(/(\/\s*)+/g, '/'),
-    groups: [...(config.groups ?? []), ...(route.groups ?? [])],
+    path: `${config.path}/${route.path}`,
+    tags: [...(config.tags ?? []), ...(route.tags ?? [])],
     middlewares: [...(config.middlewares ?? []), ...(route.middlewares ?? [])],
     security: [...(config.security ?? []), ...(route.security ?? [])],
 }));
@@ -36,15 +36,11 @@ class Router extends valleyed_1.ClassPropertiesWrapper {
         if (config)
             __classPrivateFieldSet(this, _Router_config, config, "f");
     }
-    add(...routes) {
-        const mapped = (0, exports.groupRoutes)(__classPrivateFieldGet(this, _Router_config, "f"), routes);
-        __classPrivateFieldGet(this, _Router_routes, "f").push(...mapped);
-    }
-    nest(...routers) {
-        routers.forEach((router) => __classPrivateFieldGet(this, _Router_children, "f").push(router));
+    include(router) {
+        __classPrivateFieldGet(this, _Router_children, "f").push(router);
     }
     get routes() {
-        const routes = [...__classPrivateFieldGet(this, _Router_routes, "f")];
+        const routes = __classPrivateFieldGet(this, _Router_routes, "f");
         __classPrivateFieldGet(this, _Router_children, "f").forEach((child) => {
             child.routes.forEach((route) => {
                 __classPrivateFieldGet(this, _Router_instances, "m", _Router_addRoute).call(this, route.method, route, routes)(route.handler);

package/lib/server/types.d.ts

@@ -25,7 +25,7 @@ export type SupportedStatusCodes = Enum<typeof StatusCodes>;
 type GoodStatusCodes = 200;
 type ApiErrors = Record<Exclude<SupportedStatusCodes, GoodStatusCodes>, JSONValue<CustomError['serializedErrors']>>;
 type ApiResponse<T, StatusCode extends SupportedStatusCodes> = Record<StatusCode, JSONValue<T>> | Omit<ApiErrors, StatusCode>;
-export interface Api<Res = any, Key extends string = string, Method extends MethodTypes = MethodTypes, Body = any, Files extends Record<string, boolean> = Record<string, boolean>, Params extends Record<string, string> = Record<string, string>, Query extends Record<string, any> = Record<string, any>, Headers extends Record<string, string | string[]> = Record<string, string | string[]>, DefaultStatus extends SupportedStatusCodes = SupportedStatusCodes> {
+export interface Api<Res = any, Key extends string = string, Method extends MethodTypes = MethodTypes, Body = any, Files extends Record<string, boolean> = Record<string, boolean>, Params extends Record<string, string> = Record<string, string>, Query extends Record<string, any> = Record<string, any>, DefaultStatus extends SupportedStatusCodes = SupportedStatusCodes> {
     key: Key;
     method: Method;
     response: Res;
@@ -33,20 +33,18 @@ export interface Api<Res = any, Key extends string = string, Method extends Meth
     files?: Files;
     params?: Params;
     query?: Query;
-    headers?: Headers;
     defaultStatusCode?: DefaultStatus;
 }
-export interface ApiDef<T extends Api> {
+export interface ApiDef<T extends AnyApi> {
     key: Defined<T['key']>;
     method: Defined<T['method']>;
     body: Defined<T['body']>;
     params: Defined<T['params']>;
     query: Defined<T['query']>;
     files: Defined<T['files']>;
-    headers: Defined<T['headers']>;
     responses: ApiResponse<T['response'], GetDefaultStatusCode<T['defaultStatusCode']>>;
 }
-type AnyApi<Method extends MethodTypes = MethodTypes> = Api<any, any, Method, any, any, any, any, any, any>;
+type AnyApi<Method extends MethodTypes = MethodTypes> = Api<any, any, Method, any, any, any, any, any>;
 type Awaitable<T> = Promise<T> | T;
 type Res<T, S extends SupportedStatusCodes> = Awaitable<Response<T, S> | T>;
 type InferApiFromApiDef<T> = T extends ApiDef<infer A> ? A : never;
@@ -55,9 +53,7 @@ export type RouteHandler<Def extends Api = Api> = (req: Request<Def>) => Res<Def
 export type ErrorHandler<Def extends Api = Api> = (req: Request<Def>, err: Error) => Res<CustomError['serializedErrors'], GetDefaultStatusCode<Def['defaultStatusCode']>>;
 export type RouteMiddlewareHandler<Def extends Api = Api> = (req: Request<Def>) => Awaitable<void>;
 export type HandlerSetup = (route: Route) => void;
-export type RouteSchema = Omit<FastifySchema, 'tags' | 'security' | 'hide' | 'description'> & {
-    descriptions?: string[];
-};
+export type RouteSchema = Omit<FastifySchema, 'tags' | 'security' | 'hide'>;
 export interface Route<Def extends ApiDef<AnyApi> = ApiDef<Api>> {
     key?: Def['key'];
     path: string;
@@ -67,8 +63,7 @@ export interface Route<Def extends ApiDef<AnyApi> = ApiDef<Api>> {
     middlewares?: ReturnType<typeof makeMiddleware>[];
     onError?: ReturnType<typeof makeErrorMiddleware>;
     schema?: RouteSchema;
-    groups?: string[];
-    descriptions?: string[];
+    tags?: string[];
     hideSchema?: boolean;
     security?: Record<string, string[]>[];
 }
@@ -83,6 +78,6 @@ declare class MiddlewareHandler<Cb extends Function> {
     private constructor();
     static make<Cb extends Function>(cb: Cb, onSetup?: HandlerSetup): MiddlewareHandler<Cb>;
 }
-export declare const makeMiddleware: <Def extends Api<any, string, MethodTypes, any, Record<string, boolean>, Record<string, string>, Record<string, any>, Record<string, string | string[]>, SupportedStatusCodes> = Api<any, string, MethodTypes, any, Record<string, boolean>, Record<string, string>, Record<string, any>, Record<string, string | string[]>, SupportedStatusCodes>>(cb: RouteMiddlewareHandler<Def>, onSetup?: HandlerSetup | undefined) => MiddlewareHandler<RouteMiddlewareHandler<Def>>;
-export declare const makeErrorMiddleware: <Def extends Api<any, string, MethodTypes, any, Record<string, boolean>, Record<string, string>, Record<string, any>, Record<string, string | string[]>, SupportedStatusCodes> = Api<any, string, MethodTypes, any, Record<string, boolean>, Record<string, string>, Record<string, any>, Record<string, string | string[]>, SupportedStatusCodes>>(cb: ErrorHandler<Def>, onSetup?: HandlerSetup | undefined) => MiddlewareHandler<ErrorHandler<Def>>;
+export declare const makeMiddleware: <Def extends AnyApi<MethodTypes> = Api<any, string, MethodTypes, any, Record<string, boolean>, Record<string, string>, Record<string, any>, SupportedStatusCodes>>(cb: RouteMiddlewareHandler<Def>, onSetup?: HandlerSetup | undefined) => MiddlewareHandler<RouteMiddlewareHandler<Def>>;
+export declare const makeErrorMiddleware: <Def extends AnyApi<MethodTypes> = Api<any, string, MethodTypes, any, Record<string, boolean>, Record<string, string>, Record<string, any>, SupportedStatusCodes>>(cb: ErrorHandler<Def>, onSetup?: HandlerSetup | undefined) => MiddlewareHandler<ErrorHandler<Def>>;
 export {};

package/lib/structure/baseEntity.d.ts

@@ -1,5 +1,5 @@
 import { ClassPropertiesWrapper } from 'valleyed';
-export declare class BaseEntity<Keys extends object = object, Ignored extends string = never> extends ClassPropertiesWrapper<Keys> {
+export declare class BaseEntity<Keys extends object = object, Ignored extends string = string> extends ClassPropertiesWrapper<Keys> {
     __hash: string;
     __type: string;
     readonly __ignoreInJSON: Ignored[];

package/lib/structure/baseEntity.js

@@ -24,11 +24,10 @@ class BaseEntity extends valleyed_1.ClassPropertiesWrapper {
         const json = {};
         Object.keys(this)
             .concat(Object.getOwnPropertyNames(Object.getPrototypeOf(this)))
+            .filter((k) => k !== 'constructor')
             .forEach((key) => {
             const value = this[key];
-            if (typeof value === 'function')
-                return;
-            json[key] = value?.toJSON?.(includeIgnored) ?? (0, utils_1.clone)(value);
+            json[key] = value?.toJSON?.(includeIgnored) ?? structuredClone(value);
         });
         if (!includeIgnored)
             this.__ignoreInJSON.concat('__ignoreInJSON').forEach((k) => deleteKeyFromObject(json, k.split('.')));

package/lib/utils/utils.d.ts

@@ -2,4 +2,3 @@ export declare class Random {
     static string(length?: number): string;
     static number(min?: number, max?: number): number;
 }
-export declare function clone<T>(value: T): T;

package/lib/utils/utils.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.clone = exports.Random = void 0;
+exports.Random = void 0;
 const crypto_1 = __importDefault(require("crypto"));
 class Random {
     static string(length = 20) {
@@ -14,12 +14,3 @@ class Random {
     }
 }
 exports.Random = Random;
-function clone(value) {
-    try {
-        return structuredClone(value);
-    }
-    catch (err) {
-        return value;
-    }
-}
-exports.clone = clone;

package/lib/validations/index.d.ts

@@ -1,7 +1,4 @@
 import * as Validate from 'valleyed';
-import { ExtractI } from 'valleyed/lib/api/base';
-import { VCore } from 'valleyed/lib/api/core';
-import { VObject } from 'valleyed/lib/api/objects';
 import { StorageFile } from '../storage';
 type Phone = {
     code: string;
@@ -13,14 +10,14 @@ export declare const Schema: {
     or: <T_2 extends Validate.VCore<any>[]>(options: T_2, err?: string | undefined) => import("valleyed/lib/api/junctions").VOr<T_2>;
     and: <I>(options: Validate.VCore<I>[], err?: string | undefined) => import("valleyed/lib/api/junctions").VAnd<I>;
     string: (err?: string | undefined) => import("valleyed/lib/api/strings").VString;
-    discriminate: <D extends Record<string, Validate.VCore<any>>>(discriminator: (val: ExtractI<D[keyof D]>) => string, schemas: D, err?: string | undefined) => import("valleyed/lib/api/junctions").VDiscriminator<D>;
+    discriminate: <D extends Record<string, Validate.VCore<any>>>(discriminator: (val: import("valleyed/lib/api/base").ExtractI<D[keyof D]>) => string, schemas: D, err?: string | undefined) => import("valleyed/lib/api/junctions").VDiscriminator<D>;
     number: (err?: string | undefined) => import("valleyed/lib/api/numbers").VNumber;
     boolean: (err?: string | undefined) => import("valleyed/lib/api/booleans").VBoolean;
     time: <T_3 extends Validate.Timeable = Validate.Timeable>(err?: string | undefined) => import("valleyed/lib/api/times").VTime<T_3>;
     file: (err?: string | undefined) => import("valleyed/lib/api/files").VFile;
     array: <I_1>(comparer: Validate.VCore<I_1>, err?: string | undefined) => import("valleyed/lib/api/arrays").VArray<I_1>;
     tuple: <T_4 extends readonly Validate.VCore<any>[]>(schema: readonly [...T_4], err?: string | undefined) => import("valleyed/lib/api/tuples").VTuple<T_4>;
-    object: <T_5 extends Record<string, Validate.VCore<any>>>(schema: T_5, trim?: boolean | undefined, err?: string | undefined) => VObject<T_5>;
+    object: <T_5 extends Record<string, Validate.VCore<any>>>(schema: T_5, trim?: boolean | undefined, err?: string | undefined) => import("valleyed/lib/api/objects").VObject<T_5>;
     record: <VI>(vCom: Validate.VCore<VI>, err?: string | undefined) => import("valleyed/lib/api/records").VRecord<VI>;
     map: <KI, VI_1>(kCom: Validate.VCore<KI>, vCom: Validate.VCore<VI_1>, err?: string | undefined) => import("valleyed/lib/api/records").VMap<KI, VI_1>;
     null: (err?: string | undefined) => Validate.VCore<null>;
@@ -45,14 +42,14 @@ export declare const Validation: {
         or: <T_2 extends Validate.VCore<any>[]>(options: T_2, err?: string | undefined) => import("valleyed/lib/api/junctions").VOr<T_2>;
         and: <I>(options: Validate.VCore<I>[], err?: string | undefined) => import("valleyed/lib/api/junctions").VAnd<I>;
         string: (err?: string | undefined) => import("valleyed/lib/api/strings").VString;
-        discriminate: <D extends Record<string, Validate.VCore<any>>>(discriminator: (val: ExtractI<D[keyof D]>) => string, schemas: D, err?: string | undefined) => import("valleyed/lib/api/junctions").VDiscriminator<D>;
+        discriminate: <D extends Record<string, Validate.VCore<any>>>(discriminator: (val: import("valleyed/lib/api/base").ExtractI<D[keyof D]>) => string, schemas: D, err?: string | undefined) => import("valleyed/lib/api/junctions").VDiscriminator<D>;
         number: (err?: string | undefined) => import("valleyed/lib/api/numbers").VNumber;
         boolean: (err?: string | undefined) => import("valleyed/lib/api/booleans").VBoolean;
         time: <T_3 extends Validate.Timeable = Validate.Timeable>(err?: string | undefined) => import("valleyed/lib/api/times").VTime<T_3>;
         file: (err?: string | undefined) => import("valleyed/lib/api/files").VFile;
         array: <I_1>(comparer: Validate.VCore<I_1>, err?: string | undefined) => import("valleyed/lib/api/arrays").VArray<I_1>;
         tuple: <T_4 extends readonly Validate.VCore<any>[]>(schema: readonly [...T_4], err?: string | undefined) => import("valleyed/lib/api/tuples").VTuple<T_4>;
-        object: <T_5 extends Record<string, Validate.VCore<any>>>(schema: T_5, trim?: boolean | undefined, err?: string | undefined) => VObject<T_5>;
+        object: <T_5 extends Record<string, Validate.VCore<any>>>(schema: T_5, trim?: boolean | undefined, err?: string | undefined) => import("valleyed/lib/api/objects").VObject<T_5>;
         record: <VI>(vCom: Validate.VCore<VI>, err?: string | undefined) => import("valleyed/lib/api/records").VRecord<VI>;
         map: <KI, VI_1>(kCom: Validate.VCore<KI>, vCom: Validate.VCore<VI_1>, err?: string | undefined) => import("valleyed/lib/api/records").VMap<KI, VI_1>;
         null: (err?: string | undefined) => Validate.VCore<null>;
@@ -157,8 +154,7 @@ export declare const Validation: {
         ignored: boolean;
     };
 };
-export declare function validate<T extends Record<string, VCore<any>>>(schema: T, value: unknown): ExtractI<VObject<T>>;
-export declare function validate<T extends VCore<any>>(schema: T, value: unknown): ExtractI<T>;
+export declare const validate: <T extends Record<string, Validate.VCore<any>>, S extends Validate.VCore<any> = Validate.VCore<any>>(schema: T | S, value: unknown) => any;
 export declare const Hash: {
     hash: (password: string) => Promise<string>;
     compare: (plainPassword: string, hashed: string) => Promise<boolean>;

package/lib/validations/index.js

@@ -47,8 +47,8 @@ const file = Validate.v.file;
 Validate.v.file = (...args) => file(...args).addRule(isNotTruncated());
 exports.Schema = Validate.v;
 exports.Validation = { ...Validate, isNotTruncated, isValidPhone };
-function validate(schema, value) {
-    const validator = Validate.v.object(schema);
+const validate = (schema, value) => {
+    const validator = schema instanceof Validate.VCore ? schema : Validate.v.object(schema);
     const validity = validator.parse(value);
     if (validity.valid)
         return validity.value;
@@ -66,7 +66,7 @@ function validate(schema, value) {
     }), {});
     throw new errors_1.ValidationError(Object.entries(errorsObject)
         .map(([key, value]) => ({ field: key, messages: value })));
-}
+};
 exports.validate = validate;
 const hash = async (password) => {
     password = password.trim();

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "equipped",
-	"version": "5.0.0-beta.16",
+	"version": "5.0.0-beta.7",
 	"private": false,
 	"description": "",
 	"main": "lib/index.js",