equipped 4.3.2 → 4.4.0

package/CHANGELOG.md

@@ -2,6 +2,8 @@
 
 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.
 
+## [4.4.0](https://github.com/kevinand11/equipped/compare/v4.3.2...v4.4.0) (2024-02-23)
+
 ### [4.3.2](https://github.com/kevinand11/equipped/compare/v4.3.1...v4.3.2) (2024-02-21)
 
 ### [4.3.1](https://github.com/kevinand11/equipped/compare/v4.3.0...v4.3.1) (2024-02-17)

package/lib/logger/index.js

@@ -35,5 +35,7 @@ class ConsoleLogger extends Logger {
 }
 exports.ConsoleLogger = ConsoleLogger;
 _ConsoleLogger_log = new WeakMap(), _ConsoleLogger_instances = new WeakSet(), _ConsoleLogger_getTime = function _ConsoleLogger_getTime() {
-    return new Date().toJSON().split('T')[1].slice(0, 8);
+    const date = new Date().toJSON();
+    const split = date.split('T');
+    return [split[0], split[1].slice(0, 8)].join('T');
 };

package/lib/server/app.d.ts

@@ -1,11 +1,12 @@
 import supertest from 'supertest';
 import { Listener } from '../listeners';
-import { Route } from './routes';
+import { Route, Router } from './routes';
 export declare class Server {
     #private;
     constructor();
     get listener(): Listener;
     set routes(routes: Route[]);
+    register(router: Router): void;
     test(): import("supertest/lib/agent")<supertest.SuperTestStatic.Test>;
     start(port: number): Promise<boolean>;
 }

package/lib/server/app.js

@@ -31,6 +31,7 @@ const supertest_1 = __importDefault(require("supertest"));
 const exit_1 = require("../exit");
 const instance_1 = require("../instance");
 const listeners_1 = require("../listeners");
+const middlewares_1 = require("./middlewares");
 const parseAuthUser_1 = require("./middlewares/parseAuthUser");
 const routes_1 = require("./routes");
 const statusCodes_1 = require("./statusCodes");
@@ -43,8 +44,7 @@ class Server {
         __classPrivateFieldSet(this, _Server_expressApp, (0, express_1.default)(), "f");
         __classPrivateFieldGet(this, _Server_expressApp, "f").disable('x-powered-by');
         __classPrivateFieldSet(this, _Server_httpServer, http_1.default.createServer(__classPrivateFieldGet(this, _Server_expressApp, "f")), "f");
-        if (settings.isDev)
-            __classPrivateFieldGet(this, _Server_expressApp, "f").use((0, morgan_1.default)('dev'));
+        __classPrivateFieldGet(this, _Server_expressApp, "f").use((0, morgan_1.default)((tokens, req, res) => `${tokens.method(req, res)}(${tokens.status(req, res)}) ${tokens.url(req, res)} ${tokens.res(req, res, 'content-length')}b - ${tokens['response-time'](req, res)}ms`));
         __classPrivateFieldGet(this, _Server_expressApp, "f").use(express_1.default.json());
         __classPrivateFieldGet(this, _Server_expressApp, "f").use((0, cookie_parser_1.default)());
         __classPrivateFieldGet(this, _Server_expressApp, "f").use(helmet_1.default.crossOriginResourcePolicy({ policy: 'cross-origin' }));
@@ -77,11 +77,19 @@ class Server {
         return __classPrivateFieldGet(this, _Server_listener, "f");
     }
     set routes(routes) {
-        const allRoutes = [...routes, ...(0, routes_1.PostRoutes)()];
-        allRoutes.forEach(({ method, path, controllers }) => {
+        routes.forEach(({ method, path, controllers }) => {
             controllers = [parseAuthUser_1.parseAuthUser, ...controllers];
             if (path)
-                __classPrivateFieldGet(this, _Server_expressApp, "f")[method]?.(formatPath(path), ...controllers);
+                __classPrivateFieldGet(this, _Server_expressApp, "f")[method]?.((0, routes_1.formatPath)(path), ...controllers);
+            else
+                __classPrivateFieldGet(this, _Server_expressApp, "f").use(...controllers);
+        });
+    }
+    register(router) {
+        router.routes.forEach(({ method, path, controllers }) => {
+            controllers = [parseAuthUser_1.parseAuthUser, ...controllers];
+            if (path)
+                __classPrivateFieldGet(this, _Server_expressApp, "f")[method]?.(path, ...controllers);
             else
                 __classPrivateFieldGet(this, _Server_expressApp, "f").use(...controllers);
         });
@@ -90,6 +98,11 @@ class Server {
         return (0, supertest_1.default)(__classPrivateFieldGet(this, _Server_httpServer, "f"));
     }
     async start(port) {
+        const postRoutesRouter = new routes_1.Router();
+        postRoutesRouter.get({ path: '__health' })(async () => `${instance_1.Instance.get().settings.appId} service running`);
+        postRoutesRouter.all({ middlewares: [middlewares_1.notFoundHandler] })();
+        postRoutesRouter.all({ middlewares: [middlewares_1.errorHandler] })();
+        this.register(postRoutesRouter);
         return await new Promise((resolve, reject) => {
             try {
                 const app = __classPrivateFieldGet(this, _Server_httpServer, "f").listen(port, async () => {
@@ -106,6 +119,3 @@ class Server {
 }
 exports.Server = Server;
 _Server_expressApp = new WeakMap(), _Server_httpServer = new WeakMap(), _Server_listener = new WeakMap();
-const formatPath = (path) => `/${path}/`
-    .replaceAll('///', '/')
-    .replaceAll('//', '/');

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

@@ -1,19 +1,10 @@
-/// <reference types="node" />
 import { ErrorRequestHandler, Handler } from 'express';
-import { Writable } from 'stream';
-import { SupportedStatusCodes } from '../statusCodes';
 import { Request as CustomRequest } from './request';
-type CustomResponse = {
-    result: any;
-    status?: SupportedStatusCodes;
-    headers?: Record<string, any>;
-    piped?: boolean;
-};
-type ExtraArgs = {
-    pipeThrough?: Writable;
-};
+import { Response } from './response';
+type CustomResponse<T> = Response<T> | T;
 export type Controller = Handler | ErrorRequestHandler;
-export declare const makeController: (cb: (_: CustomRequest, extras: ExtraArgs) => Promise<CustomResponse>) => Controller;
-export declare const makeMiddleware: (cb: (_: CustomRequest, extras: ExtraArgs) => Promise<void>) => Controller;
-export declare const makeErrorMiddleware: (cb: (_: CustomRequest, __: Error, extras: ExtraArgs) => Promise<CustomResponse>) => Controller;
+export type RouteHandler<T> = (req: CustomRequest) => Promise<CustomResponse<T>>;
+export declare const makeController: <T>(cb: RouteHandler<T>) => Controller;
+export declare const makeMiddleware: <T>(cb: RouteHandler<T>) => Controller;
+export declare const makeErrorMiddleware: <T>(cb: (_: CustomRequest, __: Error) => Promise<CustomResponse<T>>) => Controller;
 export {};

package/lib/server/controllers/index.js

@@ -3,18 +3,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeErrorMiddleware = exports.makeMiddleware = exports.makeController = void 0;
 const statusCodes_1 = require("../statusCodes");
 const request_1 = require("./request");
-const defaultHeaders = { 'Content-Type': 'application/json' };
+const response_1 = require("./response");
 const makeController = (cb) => {
     return async (req, res, next) => {
         try {
-            const extras = {
-                pipeThrough: res
-            };
-            const { status = statusCodes_1.StatusCodes.Ok, result, headers = defaultHeaders, piped = false } = await cb(await request_1.Request.make(req), extras);
-            if (!piped) {
-                Object.entries(headers).forEach(([key, value]) => res.header(key, value));
-                const type = result === null || result == undefined ? 'json' : 'send';
-                res.status(status)[type](result).end();
+            const rawResponse = await cb(await request_1.Request.make(req, res));
+            const response = rawResponse instanceof response_1.Response ? rawResponse : new response_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) {
@@ -26,10 +24,7 @@ exports.makeController = makeController;
 const makeMiddleware = (cb) => {
     return async (req, res, next) => {
         try {
-            const extras = {
-                pipeThrough: res
-            };
-            await cb(await request_1.Request.make(req), extras);
+            await cb(await request_1.Request.make(req, res));
             return next();
         }
         catch (e) {
@@ -40,13 +35,11 @@ const makeMiddleware = (cb) => {
 exports.makeMiddleware = makeMiddleware;
 const makeErrorMiddleware = (cb) => {
     return async (err, req, res, _) => {
-        const extras = {
-            pipeThrough: res
-        };
-        const { status = statusCodes_1.StatusCodes.BadRequest, result, headers = defaultHeaders, piped = false } = await cb(await request_1.Request.make(req), err, extras);
-        if (!piped) {
-            Object.entries(headers).forEach(([key, value]) => res.header(key, value));
-            res.status(status).send(result).end();
+        const rawResponse = await cb(await request_1.Request.make(req, res), err);
+        const response = rawResponse instanceof response_1.Response ? rawResponse : new response_1.Response({ body: rawResponse, status: statusCodes_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();
         }
     };
 };

package/lib/server/controllers/request.d.ts

@@ -1,10 +1,14 @@
-import { Request as ExpressRequest } from 'express';
+/// <reference types="node" />
+import { Request as ExpressRequest, Response as ExpressResponse } from 'express';
+import { Writable } from 'stream';
 import { CustomError } from '../../errors';
 import { StorageFile } from '../../storage';
 import { AuthUser, RefreshUser } from '../../utils/authUser';
+import { Response } from './response';
 type HeaderKeys = 'AccessToken' | 'RefreshToken' | 'Referer' | 'ContentType' | 'UserAgent';
 export declare class Request {
     #private;
+    private readonly rawRes;
     readonly ip: string | undefined;
     readonly method: string;
     readonly path: string;
@@ -29,7 +33,8 @@ export declare class Request {
         method: string;
         path: string;
         data: Record<string, any>;
-    });
-    static make(req: ExpressRequest): Promise<Request>;
+    }, rawRes: ExpressResponse);
+    static make(req: ExpressRequest, res: ExpressResponse): Promise<Request>;
+    pipe(cb: (stream: Writable) => void): Response<ExpressResponse<any, Record<string, any>>>;
 }
 export {};

package/lib/server/controllers/request.js

@@ -9,9 +9,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Request = void 0;
 const json_1 = require("../../utils/json");
 const media_1 = require("../../utils/media");
+const statusCodes_1 = require("../statusCodes");
+const response_1 = require("./response");
 class Request {
-    constructor({ ip, body, cookies, params, query, method, path, headers, files, data }) {
+    constructor({ ip, body, cookies, params, query, method, path, headers, files, data }, rawRes) {
         _Request_instances.add(this);
+        this.rawRes = rawRes;
         this.authUser = null;
         this.refreshUser = null;
         this.pendingError = null;
@@ -25,12 +28,16 @@ class Request {
         this.params = params;
         this.query = Object.fromEntries(Object.entries(query ?? {})
             .map(([key, val]) => [key, __classPrivateFieldGet(this, _Request_instances, "m", _Request_parseQueryStrings).call(this, val)]));
+        if (this.query['auth'])
+            delete this.query['auth'];
+        if (this.query['authType'])
+            delete this.query['authType'];
         this.headers = headers;
         this.files = files;
         this.authUser = data.authUser ?? null;
         this.refreshUser = data.refreshUser ?? null;
     }
-    static async make(req) {
+    static async make(req, res) {
         const allHeaders = Object.fromEntries(Object.entries(req.headers).map(([key, val]) => [key, val ?? null]));
         const headers = {
             ...allHeaders,
@@ -63,7 +70,11 @@ class Request {
             path: req.path,
             headers, files,
             data: {}
-        }));
+        }, res));
+    }
+    pipe(cb) {
+        cb(this.rawRes);
+        return new response_1.Response({ piped: true, status: statusCodes_1.StatusCodes.Ok, body: this.rawRes });
     }
 }
 exports.Request = Request;

package/lib/server/controllers/response.d.ts

@@ -0,0 +1,14 @@
+import { SupportedStatusCodes } from '../statusCodes';
+export declare class Response<T> {
+    readonly body: T | undefined;
+    readonly status: SupportedStatusCodes;
+    readonly headers: Record<string, any>;
+    readonly piped: boolean;
+    constructor({ body, status, headers, piped }: {
+        body?: T;
+        status?: SupportedStatusCodes;
+        headers?: Record<string, any>;
+        piped?: boolean;
+    });
+    get shouldJSONify(): boolean;
+}

package/lib/server/controllers/response.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Response = void 0;
+const statusCodes_1 = require("../statusCodes");
+class Response {
+    constructor({ body, status = statusCodes_1.StatusCodes.Ok, headers = { 'Content-Type': 'application/json' }, piped = false }) {
+        this.body = body;
+        this.status = status;
+        this.headers = headers;
+        this.piped = piped;
+    }
+    get shouldJSONify() {
+        return this.body === null || this.body === undefined;
+    }
+}
+exports.Response = Response;

package/lib/server/index.d.ts

@@ -1,6 +1,7 @@
 export * from './controllers';
 export * from './controllers/request';
+export * from './controllers/response';
 export * from './middlewares';
-export { groupRoutes } from './routes';
+export { Router, groupRoutes } from './routes';
 export type { Route } from './routes';
 export * from './statusCodes';

package/lib/server/index.js

@@ -14,10 +14,12 @@ 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 = void 0;
+exports.groupRoutes = exports.Router = void 0;
 __exportStar(require("./controllers"), exports);
 __exportStar(require("./controllers/request"), exports);
+__exportStar(require("./controllers/response"), exports);
 __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);

package/lib/server/routes.d.ts

@@ -1,10 +1,25 @@
-import { Controller } from './controllers';
-type MethodTypes = 'get' | 'post' | 'put' | 'delete' | 'all';
+import { Controller, RouteHandler } from './controllers';
+type MethodTypes = 'get' | 'post' | 'put' | 'patch' | 'delete' | 'all';
 export type Route = {
     path: string;
     method: MethodTypes;
     controllers: Controller[];
 };
-export declare const PostRoutes: () => Route[];
+export declare const formatPath: (path: string) => string;
 export declare const groupRoutes: (parent: string, routes: Route[]) => Route[];
+type RouteConfig = Partial<Omit<Route, 'method' | 'controllers'>> & {
+    middlewares?: Route['controllers'];
+};
+export declare class Router {
+    #private;
+    readonly routes: Route[];
+    constructor(config?: RouteConfig);
+    get(route: RouteConfig): <T>(handler?: RouteHandler<T> | undefined) => void;
+    post(route: RouteConfig): <T>(handler?: RouteHandler<T> | undefined) => void;
+    put(route: RouteConfig): <T>(handler?: RouteHandler<T> | undefined) => void;
+    patch(route: RouteConfig): <T>(handler?: RouteHandler<T> | undefined) => void;
+    delete(route: RouteConfig): <T>(handler?: RouteHandler<T> | undefined) => void;
+    all(route: RouteConfig): <T>(handler?: RouteHandler<T> | undefined) => void;
+    include(router: Router): void;
+}
 export {};

package/lib/server/routes.js

@@ -1,36 +1,67 @@
 "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 _Router_instances, _Router_config, _Router_addRoute;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.groupRoutes = exports.PostRoutes = void 0;
-const instance_1 = require("../instance");
+exports.Router = exports.groupRoutes = exports.formatPath = void 0;
 const controllers_1 = require("./controllers");
-const errorHandler_1 = require("./middlewares/errorHandler");
-const notFoundHandler_1 = require("./middlewares/notFoundHandler");
-const statusCodes_1 = require("./statusCodes");
-const PostRoutes = () => [
-    {
-        path: '__health',
-        method: 'get',
-        controllers: [
-            (0, controllers_1.makeController)(async () => {
-                return {
-                    status: statusCodes_1.StatusCodes.Ok,
-                    result: `${instance_1.Instance.get().settings.appId} service running`
-                };
-            })
-        ]
-    },
-    {
-        path: '',
-        method: 'all',
-        controllers: [notFoundHandler_1.notFoundHandler]
-    },
-    {
-        path: '',
-        method: 'all',
-        controllers: [errorHandler_1.errorHandler]
-    }
-];
-exports.PostRoutes = PostRoutes;
+const formatPath = (path) => `/${path}`
+    .replaceAll('///', '/')
+    .replaceAll('//', '/');
+exports.formatPath = formatPath;
 const groupRoutes = (parent, routes) => routes
-    .map((route) => ({ ...route, path: `${parent}/${route.path}` }));
+    .map((route) => ({ ...route, path: (0, exports.formatPath)(`${parent}/${route.path}`) }));
 exports.groupRoutes = groupRoutes;
+class Router {
+    constructor(config) {
+        _Router_instances.add(this);
+        _Router_config.set(this, void 0);
+        this.routes = [];
+        __classPrivateFieldSet(this, _Router_config, config, "f");
+    }
+    get(route) {
+        return __classPrivateFieldGet(this, _Router_instances, "m", _Router_addRoute).call(this, 'get', route);
+    }
+    post(route) {
+        return __classPrivateFieldGet(this, _Router_instances, "m", _Router_addRoute).call(this, 'post', route);
+    }
+    put(route) {
+        return __classPrivateFieldGet(this, _Router_instances, "m", _Router_addRoute).call(this, 'put', route);
+    }
+    patch(route) {
+        return __classPrivateFieldGet(this, _Router_instances, "m", _Router_addRoute).call(this, 'patch', route);
+    }
+    delete(route) {
+        return __classPrivateFieldGet(this, _Router_instances, "m", _Router_addRoute).call(this, 'delete', route);
+    }
+    all(route) {
+        return __classPrivateFieldGet(this, _Router_instances, "m", _Router_addRoute).call(this, 'all', route);
+    }
+    include(router) {
+        router.routes.forEach((route) => {
+            __classPrivateFieldGet(this, _Router_instances, "m", _Router_addRoute).call(this, route.method, route)();
+        });
+    }
+}
+exports.Router = Router;
+_Router_config = new WeakMap(), _Router_instances = new WeakSet(), _Router_addRoute = function _Router_addRoute(method, route) {
+    return (handler) => {
+        const controllers = [...(__classPrivateFieldGet(this, _Router_config, "f")?.middlewares ?? []), ...(route.middlewares ?? [])];
+        if (handler)
+            controllers.push((0, controllers_1.makeController)(handler));
+        this.routes.push({
+            method,
+            controllers,
+            path: (0, exports.formatPath)(`${__classPrivateFieldGet(this, _Router_config, "f")?.path ?? ''}/${route.path ?? ''}`),
+        });
+    };
+};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "equipped",
-	"version": "4.3.2",
+	"version": "4.4.0",
 	"private": false,
 	"description": "",
 	"main": "lib/index.js",