equipped 4.4.6 → 5.0.0-beta-1

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

@@ -0,0 +1,16 @@
+import express from 'express';
+import { Defined } from '../../types';
+import { Request, Response } from '../requests';
+import { Route } from '../types';
+import { FullRoute, Server } from './base';
+export declare class ExpressServer extends Server<express.Request, express.Response> {
+    #private;
+    constructor();
+    protected registerRoute(route: FullRoute): void;
+    protected startServer(port: number): Promise<boolean>;
+    protected onLoad(): Promise<void>;
+    protected parse(req: express.Request, res: express.Response): Promise<any>;
+    makeController(cb: Defined<Route['handler']>): (req: express.Request, res: express.Response, next: express.NextFunction) => Promise<void>;
+    makeMiddleware(cb: Defined<Route['middlewares']>[number]['cb']): (req: express.Request, res: express.Response, next: express.NextFunction) => Promise<void>;
+    makeErrorMiddleware(cb: Defined<Route['onError']>['cb']): (err: Error, req: express.Request, res: express.Response, _next: express.NextFunction) => Promise<void>;
+}

package/lib/server/impls/express.js

@@ -0,0 +1,183 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _ExpressServer_expressApp, _ExpressServer_oapi, _ExpressServer_ref;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExpressServer = void 0;
+const utils_1 = require("@fastify/swagger/lib/spec/openapi/utils");
+const openapi_1 = __importDefault(require("@wesleytodd/openapi"));
+const cookie_parser_1 = __importDefault(require("cookie-parser"));
+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"));
+const pino_http_1 = require("pino-http");
+const errors_1 = require("../../errors");
+const exit_1 = require("../../exit");
+const instance_1 = require("../../instance");
+const media_1 = require("../../utils/media");
+const middlewares_1 = require("../middlewares");
+const requests_1 = require("../requests");
+const types_1 = require("../types");
+const base_1 = require("./base");
+class ExpressServer extends base_1.Server {
+    constructor() {
+        const app = (0, express_1.default)();
+        super(http_1.default.createServer(app));
+        _ExpressServer_expressApp.set(this, void 0);
+        _ExpressServer_oapi.set(this, (0, openapi_1.default)(`${this.settings.openapiDocsUrl}/json`, this.baseOpenapiDoc, { coerce: false }));
+        _ExpressServer_ref.set(this, (0, json_schema_resolver_1.default)({ clone: true }));
+        __classPrivateFieldSet(this, _ExpressServer_expressApp, app, "f");
+        app.disable('x-powered-by');
+        if (this.settings.logRequests)
+            app.use((0, pino_http_1.pinoHttp)({ logger: instance_1.Instance.get().logger }));
+        app.use(express_1.default.json());
+        app.use(express_1.default.text());
+        app.use((0, cookie_parser_1.default)());
+        app.use(helmet_1.default.crossOriginResourcePolicy({ policy: 'cross-origin' }));
+        app.use((0, cors_1.default)({ origin: '*' }));
+        app.use(express_1.default.urlencoded({ extended: false }));
+        app.use(express_1.default.static(this.staticPath));
+        app.use(__classPrivateFieldGet(this, _ExpressServer_oapi, "f"));
+        app.use(this.settings.openapiDocsUrl, __classPrivateFieldGet(this, _ExpressServer_oapi, "f").swaggerui());
+        app.use((0, express_fileupload_1.default)({
+            limits: { fileSize: this.settings.maxFileUploadSizeInMb * 1024 * 1024 },
+            useTempFiles: false
+        }));
+        if (this.settings.useRateLimit)
+            app.use((0, express_rate_limit_1.default)({
+                windowMs: this.settings.rateLimitPeriodInMs,
+                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);
+        const controllers = [
+            ...route.middlewares.map((m) => this.makeMiddleware(m.cb)),
+            this.makeController(route.handler)
+        ];
+        if (!route.schema.hide)
+            controllers.unshift(__classPrivateFieldGet(this, _ExpressServer_oapi, "f")[this.settings.requestSchemaValidation ? 'validPath' : 'path'](openapi), (error, _, __, next) => {
+                if ('validationErrors' in error) {
+                    const validationErrors = error.validationErrors;
+                    throw new errors_1.ValidationError(validationErrors.map((error) => ({
+                        messages: [error.message ?? ''],
+                        field: error.instancePath.replaceAll('/', '.').split('.').filter(Boolean).join('.')
+                    })));
+                }
+                next();
+            });
+        if (route.onError)
+            controllers.push(this.makeErrorMiddleware(route.onError.cb));
+        __classPrivateFieldGet(this, _ExpressServer_expressApp, "f")[route.method]?.(route.path, ...controllers);
+    }
+    async startServer(port) {
+        __classPrivateFieldGet(this, _ExpressServer_expressApp, "f").use(this.makeMiddleware(middlewares_1.notFoundHandler.cb));
+        __classPrivateFieldGet(this, _ExpressServer_expressApp, "f").use(this.makeErrorMiddleware(middlewares_1.errorHandler.cb));
+        return await new Promise((resolve, reject) => {
+            try {
+                const app = this.server.listen(port, async () => resolve(true));
+                (0, exit_1.addWaitBeforeExit)(app.close);
+            }
+            catch (err) {
+                reject(err);
+            }
+        });
+    }
+    async onLoad() { }
+    async parse(req, res) {
+        const allHeaders = Object.fromEntries(Object.entries(req.headers).map(([key, val]) => [key, val ?? null]));
+        const headers = {
+            ...allHeaders,
+            AccessToken: req.get('Access-Token') ?? null,
+            RefreshToken: req.get('Refresh-Token') ?? null,
+            ContentType: req.get('Content-Type') ?? null,
+            Referer: req.get('referer') ?? null,
+            UserAgent: req.get('User-Agent') ?? null
+        };
+        const files = Object.fromEntries(await Promise.all(Object.entries(req.files ?? {}).map(async ([key, file]) => {
+            const uploads = Array.isArray(file) ? file : [file];
+            const fileArray = await Promise.all(uploads.map(async (f) => ({
+                name: f.name,
+                type: f.mimetype,
+                size: f.size,
+                isTruncated: f.truncated,
+                data: f.data,
+                duration: await (0, media_1.getMediaDuration)(f.data),
+            })));
+            return [key, fileArray];
+        })));
+        return req.savedReq || (req.savedReq = new requests_1.Request({
+            ip: req.ip,
+            body: req.body ?? {},
+            cookies: req.cookies ?? {},
+            params: req.params ?? {},
+            query: req.query ?? {},
+            method: req.method,
+            path: req.path,
+            headers, files,
+        }, res));
+    }
+    makeController(cb) {
+        return async (req, res, next) => {
+            try {
+                const rawResponse = await cb(await this.parse(req, res));
+                const response = rawResponse instanceof requests_1.Response ? rawResponse : new requests_1.Response({ body: rawResponse });
+                if (!response.piped) {
+                    Object.entries(response.headers).forEach(([key, value]) => res.header(key, value));
+                    const type = response.shouldJSONify ? 'json' : 'send';
+                    res.status(response.status)[type](response.body).end();
+                }
+            }
+            catch (e) {
+                next(e);
+            }
+        };
+    }
+    makeMiddleware(cb) {
+        return async (req, res, next) => {
+            try {
+                await cb(await this.parse(req, res));
+                return next();
+            }
+            catch (e) {
+                return next(e);
+            }
+        };
+    }
+    makeErrorMiddleware(cb) {
+        return async (err, req, res, _next) => {
+            const rawResponse = await cb(await this.parse(req, res), err);
+            const response = rawResponse instanceof requests_1.Response ? rawResponse : new requests_1.Response({ body: rawResponse, status: types_1.StatusCodes.BadRequest });
+            if (!response.piped) {
+                Object.entries(response.headers).forEach(([key, value]) => res.header(key, value));
+                res.status(response.status).send(response.body).end();
+            }
+        };
+    }
+}
+exports.ExpressServer = ExpressServer;
+_ExpressServer_expressApp = new WeakMap(), _ExpressServer_oapi = new WeakMap(), _ExpressServer_ref = new WeakMap();

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

@@ -0,0 +1,23 @@
+/// <reference types="node/http" />
+/// <reference types="pino-http" />
+import { FastifyReply, FastifyRequest, preHandlerHookHandler, RouteHandlerMethod } from 'fastify';
+import { Defined } from '../../types';
+import { Request } from '../requests';
+import { Route } from '../types';
+import { FullRoute, Server } from './base';
+export declare class FastifyServer extends Server<FastifyRequest, FastifyReply> {
+    #private;
+    constructor();
+    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>>;
+    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;
+}
+declare module 'fastify' {
+    interface FastifyRequest {
+        savedReq: Request | null;
+    }
+}

package/lib/server/impls/fastify.js

@@ -0,0 +1,182 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _FastifyServer_fastifyApp;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FastifyServer = void 0;
+const cookie_1 = __importDefault(require("@fastify/cookie"));
+const cors_1 = __importDefault(require("@fastify/cors"));
+const formbody_1 = __importDefault(require("@fastify/formbody"));
+const helmet_1 = __importDefault(require("@fastify/helmet"));
+const multipart_1 = __importDefault(require("@fastify/multipart"));
+const rate_limit_1 = __importDefault(require("@fastify/rate-limit"));
+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");
+const instance_1 = require("../../instance");
+const media_1 = require("../../utils/media");
+const middlewares_1 = require("../middlewares");
+const requests_1 = require("../requests");
+const types_1 = require("../types");
+const base_1 = require("./base");
+function getFastifyApp() {
+    const instance = instance_1.Instance.get();
+    return (0, fastify_1.default)({
+        logger: instance.settings.logRequests ? instance.logger : false,
+        ajv: { customOptions: { coerceTypes: false } },
+        schemaErrorFormatter: (errors, data) => new errors_1.ValidationError(errors.map((error) => ({ messages: [error.message ?? ''], field: `${data}${error.instancePath}`.replaceAll('/', '.') })))
+    });
+}
+class FastifyServer extends base_1.Server {
+    constructor() {
+        const app = getFastifyApp();
+        super(app.server);
+        _FastifyServer_fastifyApp.set(this, void 0);
+        __classPrivateFieldSet(this, _FastifyServer_fastifyApp, app, "f");
+        app.decorateRequest('savedReq', null);
+        app.register(static_1.default, { root: this.staticPath });
+        app.register(cookie_1.default, {});
+        app.register(cors_1.default, { origin: '*' });
+        app.register(swagger_1.default, { openapi: this.baseOpenapiDoc });
+        app.register(swagger_ui_1.default, { routePrefix: this.settings.openapiDocsUrl });
+        app.register(formbody_1.default, { parser: (str) => qs_1.default.parse(str) });
+        app.register(helmet_1.default, { crossOriginResourcePolicy: { policy: 'cross-origin' } });
+        app.register(multipart_1.default, {
+            attachFieldsToBody: 'keyValues',
+            throwFileSizeLimit: false,
+            limits: { fileSize: this.settings.maxFileUploadSizeInMb * 1024 * 1024 },
+            onFile: async (f) => {
+                const buffer = await f.toBuffer();
+                const parsed = {
+                    name: f.filename,
+                    type: f.mimetype,
+                    size: buffer.byteLength,
+                    isTruncated: f.file.truncated,
+                    data: buffer,
+                    duration: await (0, media_1.getMediaDuration)(buffer),
+                };
+                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,
+                timeWindow: this.settings.rateLimitPeriodInMs,
+                errorResponseBuilder: (_, context) => ({
+                    statusCode: types_1.StatusCodes.TooManyRequests,
+                    message: JSON.stringify([{ message: `Too Many Requests. Retry in ${context.after}` }])
+                })
+            });
+        if (!this.settings.requestSchemaValidation) {
+            app.setValidatorCompiler(() => () => true);
+            app.setSerializerCompiler(() => (data) => JSON.stringify(data));
+        }
+    }
+    async onLoad() {
+        await __classPrivateFieldGet(this, _FastifyServer_fastifyApp, "f").ready();
+    }
+    registerRoute(route) {
+        __classPrivateFieldGet(this, _FastifyServer_fastifyApp, "f").register(async (inst) => {
+            inst.route({
+                url: route.path,
+                method: route.method,
+                handler: this.makeController(route.handler),
+                preHandler: route.middlewares.map((m) => this.makeMiddleware(m.cb)),
+                errorHandler: route.onError ? this.makeErrorMiddleware(route.onError.cb) : undefined,
+                schema: route.schema,
+            });
+        });
+    }
+    async startServer(port) {
+        __classPrivateFieldGet(this, _FastifyServer_fastifyApp, "f").setNotFoundHandler(this.makeController(middlewares_1.notFoundHandler.cb));
+        __classPrivateFieldGet(this, _FastifyServer_fastifyApp, "f").setErrorHandler(this.makeErrorMiddleware(middlewares_1.errorHandler.cb));
+        await __classPrivateFieldGet(this, _FastifyServer_fastifyApp, "f").listen({ port });
+        (0, exit_1.addWaitBeforeExit)(__classPrivateFieldGet(this, _FastifyServer_fastifyApp, "f").close);
+        return true;
+    }
+    async parse(req, res) {
+        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,
+            Referer: req.headers['referer']?.toString() ?? null,
+            UserAgent: req.headers['User-Agent']?.toString() ?? null
+        };
+        const { body, files } = excludeBufferKeys(req.body ?? {});
+        return req.savedReq || (req.savedReq = new requests_1.Request({
+            ip: req.ip,
+            body,
+            cookies: req.cookies ?? {},
+            params: req.params ?? {},
+            query: req.query ?? {},
+            method: req.method,
+            path: req.url,
+            headers,
+            files,
+        }, res.raw));
+    }
+    makeController(cb) {
+        const handler = async (req, reply) => {
+            const rawResponse = await cb(await this.parse(req, reply));
+            const response = rawResponse instanceof requests_1.Response ? rawResponse : new requests_1.Response({ body: rawResponse });
+            const type = response.shouldJSONify ? 'json' : 'send';
+            if (!response.piped)
+                reply.status(response.status).headers(response.headers)[type](response.body);
+        };
+        return handler;
+    }
+    makeMiddleware(cb) {
+        const handler = async (req, reply) => {
+            await cb(await this.parse(req, reply));
+        };
+        return handler;
+    }
+    makeErrorMiddleware(cb) {
+        const handler = async (error, req, reply) => {
+            const rawResponse = await cb(await this.parse(req, reply), error);
+            const response = rawResponse instanceof requests_1.Response ? rawResponse : new requests_1.Response({ body: rawResponse, status: types_1.StatusCodes.BadRequest });
+            if (!response.piped)
+                reply.status(response.status).headers(response.headers).send(response.body);
+        };
+        return handler;
+    }
+}
+exports.FastifyServer = FastifyServer;
+_FastifyServer_fastifyApp = new WeakMap();
+function excludeBufferKeys(body) {
+    if (typeof body !== 'object')
+        return { body: body, files: {} };
+    const entries = Object.entries(body ?? {});
+    const isFile = (val) => Array.isArray(val) ? isFile(val.at(0)) : Buffer.isBuffer(val?.data);
+    const fileEntries = entries.filter(([_, value]) => isFile(value)).map(([key, value]) => [key, Array.isArray(value) ? value : [value]]);
+    const nonFileEntries = entries.filter(([_, value]) => !isFile(value));
+    return {
+        body: Object.fromEntries(nonFileEntries),
+        files: Object.fromEntries(fileEntries)
+    };
+}

package/lib/server/index.d.ts

@@ -1,7 +1,8 @@
-export * from './controllers';
-export * from './controllers/request';
-export * from './controllers/response';
 export * from './middlewares';
-export { Router, groupRoutes } from './routes';
-export type { Route } from './routes';
-export * from './statusCodes';
+export * from './requests';
+export * from './routes';
+export * from './types';
+import { Server } from './impls/base';
+export type { Server };
+export type ServerTypes = 'express' | 'fastify';
+export declare const serverTypes: Record<ServerTypes, () => Server>;

package/lib/server/index.js

@@ -14,12 +14,14 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.groupRoutes = exports.Router = void 0;
-__exportStar(require("./controllers"), exports);
-__exportStar(require("./controllers/request"), exports);
-__exportStar(require("./controllers/response"), exports);
+exports.serverTypes = void 0;
 __exportStar(require("./middlewares"), exports);
-var routes_1 = require("./routes");
-Object.defineProperty(exports, "Router", { enumerable: true, get: function () { return routes_1.Router; } });
-Object.defineProperty(exports, "groupRoutes", { enumerable: true, get: function () { return routes_1.groupRoutes; } });
-__exportStar(require("./statusCodes"), exports);
+__exportStar(require("./requests"), exports);
+__exportStar(require("./routes"), exports);
+__exportStar(require("./types"), exports);
+const express_1 = require("./impls/express");
+const fastify_1 = require("./impls/fastify");
+exports.serverTypes = {
+    express: () => new express_1.ExpressServer(),
+    fastify: () => new fastify_1.FastifyServer(),
+};

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

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

package/lib/server/middlewares/errorHandler.js

@@ -1,22 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.errorHandler = void 0;
+const errors_1 = require("../../errors");
 const instance_1 = require("../../instance");
-const controllers_1 = require("../controllers");
-const response_1 = require("../controllers/response");
-const statusCodes_1 = require("../statusCodes");
-exports.errorHandler = (0, controllers_1.makeErrorMiddleware)(async (_, err) => {
-    const error = err;
-    if (error.isCustomError)
-        return new response_1.Response({
+const requests_1 = require("../requests");
+const types_1 = require("../types");
+exports.errorHandler = (0, types_1.makeErrorMiddleware)(async (_, error) => {
+    if (error instanceof errors_1.CustomError)
+        return new requests_1.Response({
             body: error.serializedErrors,
             status: error.statusCode
         });
     else {
-        await instance_1.Instance.get().logger.error(err);
-        return new response_1.Response({
-            body: [{ message: 'Something went wrong', data: err.message }],
-            status: statusCodes_1.StatusCodes.BadRequest
+        await instance_1.Instance.get().logger.error(error);
+        return new requests_1.Response({
+            body: [{ message: 'Something went wrong', data: error.message }],
+            status: types_1.StatusCodes.BadRequest
         });
     }
 });

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

@@ -1,4 +1,5 @@
 export * from './errorHandler';
 export * from './notFoundHandler';
+export * from './parseAuthUser';
 export * from './requireAuthUser';
 export * from './requireRefreshUser';

package/lib/server/middlewares/index.js

@@ -16,5 +16,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./errorHandler"), exports);
 __exportStar(require("./notFoundHandler"), exports);
+__exportStar(require("./parseAuthUser"), exports);
 __exportStar(require("./requireAuthUser"), exports);
 __exportStar(require("./requireRefreshUser"), exports);

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

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

package/lib/server/middlewares/notFoundHandler.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.notFoundHandler = void 0;
 const errors_1 = require("../../errors");
-const controllers_1 = require("../controllers");
-exports.notFoundHandler = (0, controllers_1.makeMiddleware)(async (_) => {
-    throw new errors_1.NotFoundError('Route not found');
+const types_1 = require("../types");
+exports.notFoundHandler = (0, types_1.makeMiddleware)(async (req) => {
+    throw new errors_1.NotFoundError(`Route ${req.path} not found`);
 });

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

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

package/lib/server/middlewares/parseAuthUser.js

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseAuthUser = void 0;
 const errors_1 = require("../../errors");
 const tokens_1 = require("../../utils/tokens");
-const controllers_1 = require("../controllers");
-exports.parseAuthUser = (0, controllers_1.makeMiddleware)(async (request) => {
+const types_1 = require("../types");
+exports.parseAuthUser = (0, types_1.makeMiddleware)(async (request) => {
     const accessToken = request.headers.AccessToken;
     if (accessToken)
         request.authUser = await (0, tokens_1.verifyAccessToken)(accessToken).catch((err) => {

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

@@ -1,2 +1,4 @@
-import { Request } from '../controllers/request';
-export declare const requireAuthUser: (request: Request) => Promise<void>;
+export declare const requireAuthUser: {
+    cb: import("../types").RouteMiddlewareHandler<import("../types").Api<unknown, string, import("../types").MethodTypes, unknown, unknown, unknown, import("../types").SupportedStatusCodes>>;
+    onSetup?: import("../types").HandlerSetup | undefined;
+};

package/lib/server/middlewares/requireAuthUser.js

@@ -2,10 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.requireAuthUser = void 0;
 const errors_1 = require("../../errors");
-const requireAuthUser = async (request) => {
+const types_1 = require("../types");
+exports.requireAuthUser = (0, types_1.makeMiddleware)(async (request) => {
     if (request.pendingError)
         throw request.pendingError;
+    if (!request.headers.AccessToken)
+        throw new errors_1.NotAuthenticatedError('Access-Token header missing');
     if (!request.authUser)
         throw new errors_1.NotAuthenticatedError();
-};
-exports.requireAuthUser = requireAuthUser;
+}, (route) => {
+    route.security ?? (route.security = []);
+    route.security.push({ AccessToken: [] });
+});

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

@@ -1,2 +1,4 @@
-import { Request } from '../controllers/request';
-export declare const requireRefreshUser: (request: Request) => Promise<void>;
+export declare const requireRefreshUser: {
+    cb: import("../types").RouteMiddlewareHandler<import("../types").Api<unknown, string, import("../types").MethodTypes, unknown, unknown, unknown, import("../types").SupportedStatusCodes>>;
+    onSetup?: import("../types").HandlerSetup | undefined;
+};

package/lib/server/middlewares/requireRefreshUser.js

@@ -3,12 +3,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.requireRefreshUser = void 0;
 const errors_1 = require("../../errors");
 const tokens_1 = require("../../utils/tokens");
-const requireRefreshUser = async (request) => {
+const types_1 = require("../types");
+exports.requireRefreshUser = (0, types_1.makeMiddleware)(async (request) => {
     const refreshToken = request.headers.RefreshToken;
     if (!refreshToken)
-        throw new errors_1.NotAuthorizedError();
+        throw new errors_1.NotAuthorizedError('Refresh-Token header missing');
     request.refreshUser = await (0, tokens_1.verifyRefreshToken)(refreshToken);
     if (!request.refreshUser)
         throw new errors_1.NotAuthorizedError();
-};
-exports.requireRefreshUser = requireRefreshUser;
+}, (route) => {
+    route.security ?? (route.security = []);
+    route.security.push({ RefreshToken: [] });
+});