equipped 4.0.0-alpha-10

package/lib/errors/types/validationError.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidationError = void 0;
+const customError_1 = require("../customError");
+const express_1 = require("../../express");
+class ValidationError extends customError_1.CustomError {
+    constructor(errors) {
+        super('Invalid request parameters', errors.map((e) => ({ field: e.field, message: e.messages.join('\n') })));
+        this.statusCode = express_1.StatusCodes.ValidationError;
+    }
+}
+exports.ValidationError = ValidationError;

package/lib/events/events.d.ts

@@ -0,0 +1,17 @@
+import { IEventTypes, Enum } from '../enums/types';
+import { pubAndSub } from './rabbit';
+export interface Events extends Record<Enum<IEventTypes>, {
+    topic: Enum<IEventTypes>;
+    data: any;
+}> {
+}
+export declare class EventBus {
+    ps: ReturnType<typeof pubAndSub>;
+    constructor();
+    createPublisher<Event extends Events[keyof Events]>(topic: Event['topic']): {
+        publish: (data: Event['data']) => Promise<void>;
+    };
+    createSubscriber<Event extends Events[keyof Events]>(topic: Event['topic'], onMessage: (data: Event['data']) => void): {
+        subscribe: () => Promise<void>;
+    };
+}

package/lib/events/events.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventBus = void 0;
+const rabbit_1 = require("./rabbit");
+class EventBus {
+    constructor() {
+        this.ps = (0, rabbit_1.pubAndSub)();
+    }
+    createPublisher(topic) {
+        const { ps } = this;
+        const publish = async (data) => {
+            await (await ps).publish(topic, JSON.stringify(data));
+        };
+        return { publish };
+    }
+    createSubscriber(topic, onMessage) {
+        const { ps } = this;
+        const subscribe = async () => {
+            await (await ps).subscribe(topic, (data) => {
+                onMessage(JSON.parse(data));
+            });
+        };
+        return { subscribe };
+    }
+}
+exports.EventBus = EventBus;

package/lib/events/rabbit.d.ts

@@ -0,0 +1,4 @@
+export declare const pubAndSub: () => Promise<{
+    publish: (topic: string, data: any) => Promise<void>;
+    subscribe: (topic: string, cb: (data: string, topic: string) => void) => Promise<void>;
+}>;

package/lib/events/rabbit.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pubAndSub = void 0;
+const amqplib_1 = __importDefault(require("amqplib"));
+const exit_1 = require("../exit");
+const instance_1 = require("../instance");
+const pubAndSub = async () => {
+    const column = instance_1.Instance.get().settings.rabbitColumnName;
+    const con = await amqplib_1.default.connect(instance_1.Instance.get().settings.rabbitURI);
+    con.on('error', (err) => {
+        instance_1.Instance.get().logger.error('Amqp error:', err.message);
+        process.exit(1);
+    });
+    const channel = await con.createChannel();
+    (0, exit_1.addWaitBeforeExit)(channel.close);
+    await channel.assertExchange(column, 'direct', { durable: true });
+    await channel.prefetch(1);
+    const publish = async (topic, data) => {
+        channel.publish(column, topic, Buffer.from(data), { persistent: true });
+    };
+    const subscribe = async (topic, cb) => {
+        const queue = `${instance_1.Instance.get().settings.appId}-${topic}`;
+        await channel.assertQueue(queue, { durable: true });
+        await channel.bindQueue(queue, column, topic);
+        channel.consume(queue, (msg) => {
+            if (msg) {
+                try {
+                    cb(msg.content.toString(), msg.fields.routingKey);
+                    channel.ack(msg);
+                }
+                catch (err) {
+                    channel.nack(msg);
+                }
+            }
+        }, {
+            noAck: false
+        }).then();
+    };
+    return { publish, subscribe };
+};
+exports.pubAndSub = pubAndSub;

package/lib/exit.d.ts

@@ -0,0 +1 @@
+export declare const addWaitBeforeExit: (fn: any) => void;

package/lib/exit.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addWaitBeforeExit = void 0;
+const listeners = [];
+const addWaitBeforeExit = (fn) => {
+    listeners.push(fn);
+};
+exports.addWaitBeforeExit = addWaitBeforeExit;
+const signals = {
+    SIGHUP: 1,
+    SIGINT: 2,
+    SIGTERM: 15
+};
+Object.entries(signals).forEach(([signal, code]) => {
+    process.on(signal, async () => {
+        await Promise.all(listeners.map(async (l) => {
+            try {
+                await typeof l === 'function' ? l() : l;
+            }
+            catch (err) {
+            }
+        }));
+        process.exit(128 + code);
+    });
+});

package/lib/express/app.d.ts

@@ -0,0 +1,16 @@
+import { Listener } from '../listeners';
+import { Controller } from './controllers';
+type MethodTypes = 'get' | 'post' | 'put' | 'delete' | 'all';
+export type Route = {
+    path: string;
+    method: MethodTypes;
+    controllers: Controller[];
+};
+export declare class Server {
+    #private;
+    constructor();
+    get listener(): Listener;
+    set routes(routes: Route[]);
+    start(port: number): Promise<boolean>;
+}
+export {};

package/lib/express/app.js

@@ -0,0 +1,127 @@
+"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 _Server_expressApp, _Server_httpServer, _Server_listener;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Server = void 0;
+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 http_1 = __importDefault(require("http"));
+const morgan_1 = __importDefault(require("morgan"));
+const path_1 = __importDefault(require("path"));
+const socket_io_1 = __importDefault(require("socket.io"));
+const exit_1 = require("../exit");
+const instance_1 = require("../instance");
+const listeners_1 = require("../listeners");
+const controllers_1 = require("./controllers");
+const middlewares_1 = require("./middlewares");
+const parseAuthUser_1 = require("./middlewares/parseAuthUser");
+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: [middlewares_1.notFoundHandler]
+    },
+    {
+        path: '',
+        method: 'all',
+        controllers: [middlewares_1.errorHandler]
+    }
+];
+class Server {
+    constructor() {
+        _Server_expressApp.set(this, void 0);
+        _Server_httpServer.set(this, void 0);
+        _Server_listener.set(this, void 0);
+        const settings = instance_1.Instance.get().settings;
+        __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(express_1.default.json());
+        __classPrivateFieldGet(this, _Server_expressApp, "f").use((0, cookie_parser_1.default)());
+        __classPrivateFieldGet(this, _Server_expressApp, "f").use((0, cors_1.default)({ origin: '*' }));
+        __classPrivateFieldGet(this, _Server_expressApp, "f").use(express_1.default.urlencoded({ extended: false }));
+        __classPrivateFieldGet(this, _Server_expressApp, "f").use(express_1.default.static(path_1.default.join(process.cwd(), 'public')));
+        if (settings.useRateLimit)
+            __classPrivateFieldGet(this, _Server_expressApp, "f").use((0, express_rate_limit_1.default)({
+                windowMs: settings.rateLimitPeriodInMs,
+                max: settings.rateLimit,
+                handler: (_, res) => res.status(statusCodes_1.StatusCodes.TooManyRequests).json([{ message: 'Too Many Requests' }])
+            }));
+        if (settings.useSlowDown)
+            __classPrivateFieldGet(this, _Server_expressApp, "f").use((0, express_slow_down_1.default)({
+                windowMs: settings.slowDownPeriodInMs,
+                delayAfter: settings.slowDownAfter,
+                delayMs: settings.slowDownDelayInMs
+            }));
+        __classPrivateFieldGet(this, _Server_expressApp, "f").use((0, express_fileupload_1.default)({
+            limits: { fileSize: settings.maxFileUploadSizeInMb * 1024 * 1024 },
+            useTempFiles: false
+        }));
+        const socket = new socket_io_1.default.Server(__classPrivateFieldGet(this, _Server_httpServer, "f"), { cors: { origin: '*' } });
+        __classPrivateFieldSet(this, _Server_listener, new listeners_1.Listener(socket, {
+            onConnect: async () => { },
+            onDisconnect: async () => { }
+        }), "f");
+    }
+    get listener() {
+        return __classPrivateFieldGet(this, _Server_listener, "f");
+    }
+    set routes(routes) {
+        const allRoutes = [...routes, ...postRoutes()];
+        allRoutes.forEach(({ method, path, controllers }) => {
+            controllers = [parseAuthUser_1.parseAuthUser, ...controllers];
+            if (path)
+                __classPrivateFieldGet(this, _Server_expressApp, "f")[method]?.(formatPath(path), ...controllers);
+            else
+                __classPrivateFieldGet(this, _Server_expressApp, "f").use(...controllers);
+        });
+    }
+    async start(port) {
+        return await new Promise((resolve, reject) => {
+            try {
+                const app = __classPrivateFieldGet(this, _Server_httpServer, "f").listen(port, () => resolve(true));
+                (0, exit_1.addWaitBeforeExit)(app.close);
+            }
+            catch (err) {
+                reject(err);
+            }
+        });
+    }
+}
+exports.Server = Server;
+_Server_expressApp = new WeakMap(), _Server_httpServer = new WeakMap(), _Server_listener = new WeakMap();
+const formatPath = (path) => `/${path}/`
+    .replaceAll('///', '/')
+    .replaceAll('//', '/');

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

@@ -0,0 +1,13 @@
+import { ErrorRequestHandler, Handler } from 'express';
+import { SupportedStatusCodes } from '../statusCodes';
+import { Request as CustomRequest } from './request';
+type CustomResponse = {
+    status: SupportedStatusCodes;
+    result: any;
+    headers?: Record<string, any>;
+};
+export type Controller = Handler | ErrorRequestHandler;
+export declare const makeController: (cb: (_: CustomRequest) => Promise<CustomResponse>) => Controller;
+export declare const makeMiddleware: (cb: (_: CustomRequest) => Promise<void>) => Controller;
+export declare const makeErrorMiddleware: (cb: (_: CustomRequest, __: Error) => Promise<CustomResponse>) => Controller;
+export {};

package/lib/express/controllers/index.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeErrorMiddleware = exports.makeMiddleware = exports.makeController = void 0;
+const media_1 = require("../../utils/media");
+const statusCodes_1 = require("../statusCodes");
+const request_1 = require("./request");
+const makeController = (cb) => {
+    return async (req, res, next) => {
+        try {
+            const { status = statusCodes_1.StatusCodes.Ok, result, headers = {} } = await cb(await extractRequest(req));
+            Object.entries(headers).forEach(([key, value]) => res.header(key, value));
+            return res.status(status).json(result).end();
+        }
+        catch (e) {
+            next(e);
+            return;
+        }
+    };
+};
+exports.makeController = makeController;
+const makeMiddleware = (cb) => {
+    return async (req, _, next) => {
+        try {
+            await cb(await extractRequest(req));
+            return next();
+        }
+        catch (e) {
+            return next(e);
+        }
+    };
+};
+exports.makeMiddleware = makeMiddleware;
+const makeErrorMiddleware = (cb) => {
+    return async (err, req, res, _) => {
+        const { status = statusCodes_1.StatusCodes.BadRequest, result, headers = {} } = await cb(await extractRequest(req), err);
+        Object.entries(headers).forEach(([key, value]) => res.header(key, value));
+        return res.status(status).json(result).end();
+    };
+};
+exports.makeErrorMiddleware = makeErrorMiddleware;
+const extractRequest = async (req) => {
+    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 fileArray = [];
+        if (file)
+            await Promise.all((Array.isArray(file) ? file : [file]).map(async (f) => fileArray.push({
+                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];
+    })));
+    const request = req.savedReq ?? new request_1.Request({
+        body: req.body ?? {},
+        cookies: req.cookies ?? {},
+        params: req.params ?? {},
+        query: req.query ?? {},
+        method: req.method,
+        path: req.path,
+        headers, files,
+        data: {}
+    });
+    req.savedReq = request;
+    return request;
+};

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

@@ -0,0 +1,31 @@
+import { CustomError } from '../../errors';
+import { StorageFile } from '../../storage';
+import { AuthUser, RefreshUser } from '../../utils/authUser';
+type HeaderKeys = 'AccessToken' | 'RefreshToken' | 'Referer' | 'ContentType' | 'UserAgent';
+export declare class Request {
+    #private;
+    readonly method: string;
+    readonly path: string;
+    readonly body: Record<string, any>;
+    readonly cookies: Record<string, any>;
+    readonly rawBody: Record<string, any>;
+    readonly params: Record<string, string>;
+    readonly query: Record<string, string>;
+    readonly headers: Record<HeaderKeys | string, any>;
+    readonly files: Record<string, StorageFile[]>;
+    authUser: null | AuthUser;
+    refreshUser: null | RefreshUser;
+    pendingError: null | CustomError;
+    constructor({ body, cookies, params, query, method, path, headers, files, data }: {
+        body: Record<string, any>;
+        cookies: Record<string, any>;
+        params: Record<string, any>;
+        query: Record<string, any>;
+        headers: Record<HeaderKeys, any>;
+        files: Record<string, StorageFile[]>;
+        method: string;
+        path: string;
+        data: Record<string, any>;
+    });
+}
+export {};

package/lib/express/controllers/request.js

@@ -0,0 +1,48 @@
+"use strict";
+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 _Request_instances, _Request_parseQueryStrings;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Request = void 0;
+const parseJSON = (body) => Object.fromEntries(Object.entries(body).map(([key, value]) => {
+    try {
+        return [key, JSON.parse(value)];
+    }
+    catch {
+        return [key, value];
+    }
+}));
+class Request {
+    constructor({ body, cookies, params, query, method, path, headers, files, data }) {
+        _Request_instances.add(this);
+        this.authUser = null;
+        this.refreshUser = null;
+        this.pendingError = null;
+        this.method = method;
+        this.path = path;
+        this.rawBody = body;
+        this.body = parseJSON(body);
+        this.cookies = cookies;
+        this.params = params;
+        this.query = Object.fromEntries(Object.entries(query ?? {})
+            .map(([key, val]) => [key, __classPrivateFieldGet(this, _Request_instances, "m", _Request_parseQueryStrings).call(this, val)]));
+        this.headers = headers;
+        this.files = files;
+        this.authUser = data.authUser ?? null;
+        this.refreshUser = data.refreshUser ?? null;
+    }
+}
+exports.Request = Request;
+_Request_instances = new WeakSet(), _Request_parseQueryStrings = function _Request_parseQueryStrings(value) {
+    if (Array.isArray(value))
+        return value.map(__classPrivateFieldGet(this, _Request_instances, "m", _Request_parseQueryStrings));
+    try {
+        return JSON.parse(value);
+    }
+    catch (e) {
+        return value;
+    }
+};

package/lib/express/index.d.ts

@@ -0,0 +1,5 @@
+export type { Route } from './app';
+export * from './controllers';
+export * from './controllers/request';
+export * from './middlewares';
+export * from './statusCodes';

package/lib/express/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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 });
+__exportStar(require("./controllers"), exports);
+__exportStar(require("./controllers/request"), exports);
+__exportStar(require("./middlewares"), exports);
+__exportStar(require("./statusCodes"), exports);

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

@@ -0,0 +1 @@
+export declare const errorHandler: import("../controllers").Controller;

package/lib/express/middlewares/errorHandler.js

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

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

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

package/lib/express/middlewares/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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 });
+__exportStar(require("./requireAuthUser"), exports);
+__exportStar(require("./requireRefreshUser"), exports);
+__exportStar(require("./notFoundHandler"), exports);
+__exportStar(require("./errorHandler"), exports);

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

@@ -0,0 +1 @@
+export declare const notFoundHandler: import("../controllers").Controller;

package/lib/express/middlewares/notFoundHandler.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.notFoundHandler = void 0;
+const controllers_1 = require("../controllers");
+const errors_1 = require("../../errors");
+exports.notFoundHandler = (0, controllers_1.makeMiddleware)(async (_) => {
+    throw new errors_1.NotFoundError('Route not found');
+});

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

@@ -0,0 +1 @@
+export declare const parseAuthUser: import("../controllers").Controller;

package/lib/express/middlewares/parseAuthUser.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseAuthUser = void 0;
+const controllers_1 = require("../controllers");
+const tokens_1 = require("../../utils/tokens");
+const errors_1 = require("../../errors");
+exports.parseAuthUser = (0, controllers_1.makeMiddleware)(async (request) => {
+    const accessToken = request.headers.AccessToken;
+    if (accessToken)
+        request.authUser = await (0, tokens_1.verifyAccessToken)(accessToken).catch((err) => {
+            if (err instanceof errors_1.CustomError)
+                request.pendingError = err;
+            return null;
+        });
+});

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

@@ -0,0 +1,2 @@
+import { Request } from '../controllers/request';
+export declare const requireAuthUser: (request: Request) => Promise<void>;

package/lib/express/middlewares/requireAuthUser.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requireAuthUser = void 0;
+const errors_1 = require("../../errors");
+const requireAuthUser = async (request) => {
+    if (request.pendingError)
+        throw request.pendingError;
+    if (!request.authUser)
+        throw new errors_1.NotAuthenticatedError();
+};
+exports.requireAuthUser = requireAuthUser;

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

@@ -0,0 +1,2 @@
+import { Request } from '../controllers/request';
+export declare const requireRefreshUser: (request: Request) => Promise<void>;

package/lib/express/middlewares/requireRefreshUser.js

@@ -0,0 +1,14 @@
+"use strict";
+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 refreshToken = request.headers.RefreshToken;
+    if (!refreshToken)
+        throw new errors_1.NotAuthorizedError();
+    request.refreshUser = await (0, tokens_1.verifyRefreshToken)(refreshToken);
+    if (!request.refreshUser)
+        throw new errors_1.NotAuthorizedError();
+};
+exports.requireRefreshUser = requireRefreshUser;

package/lib/express/statusCodes.d.ts

@@ -0,0 +1,16 @@
+import { Enum } from '../enums/types';
+export declare const StatusCodes: {
+    readonly Ok: 200;
+    readonly BadRequest: 400;
+    readonly NotAuthenticated: 401;
+    readonly NotAuthorized: 403;
+    readonly NotFound: 404;
+    readonly ValidationError: 422;
+    readonly TooManyRequests: 429;
+    readonly ServerError: 500;
+    readonly AccountNotVerified: 460;
+    readonly AccessTokenExpired: 461;
+    readonly RefreshTokenMisused: 462;
+    readonly InvalidToken: 463;
+};
+export type SupportedStatusCodes = Enum<typeof StatusCodes>;

package/lib/express/statusCodes.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StatusCodes = void 0;
+exports.StatusCodes = {
+    Ok: 200,
+    BadRequest: 400,
+    NotAuthenticated: 401,
+    NotAuthorized: 403,
+    NotFound: 404,
+    ValidationError: 422,
+    TooManyRequests: 429,
+    ServerError: 500,
+    AccountNotVerified: 460,
+    AccessTokenExpired: 461,
+    RefreshTokenMisused: 462,
+    InvalidToken: 463
+};