serverpreconfigured 2.2.15 → 2.2.17

package/dist/auth/auth.d.ts

@@ -0,0 +1,3 @@
+export declare function userIsLogged(req: any): boolean;
+export declare function setUserLogged(req: any, email: string): void;
+export declare function logoutUser(req: any): void;

package/dist/auth/auth.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logoutUser = exports.setUserLogged = exports.userIsLogged = void 0;
+const secureget_1 = require("../sessions/secureget");
+const config_1 = require("./config");
+const server_1 = require("../server");
+const server_2 = require("../server");
+function userIsLogged(req) {
+    let user = (0, secureget_1.getSessionValue)(req, config_1.SESSION_LOGGED_DATA);
+    if (user)
+        return true;
+    return false;
+}
+exports.userIsLogged = userIsLogged;
+function setUserLogged(req, email) {
+    (0, server_1.setSessionValue)(req, config_1.SESSION_LOGGED_DATA, email);
+}
+exports.setUserLogged = setUserLogged;
+function logoutUser(req) {
+    (0, server_2.deleteSessionValue)(req, config_1.SESSION_LOGGED_DATA);
+}
+exports.logoutUser = logoutUser;

package/dist/auth/config.d.ts

@@ -0,0 +1 @@
+export declare const SESSION_LOGGED_DATA = "email";

package/dist/auth/config.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SESSION_LOGGED_DATA = void 0;
+exports.SESSION_LOGGED_DATA = 'email';

package/dist/database/database.d.ts

@@ -0,0 +1,2 @@
+import { Sequelize } from "sequelize";
+export declare const dataBase: Sequelize;

package/dist/database/database.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dataBase = void 0;
+//@ts-nocheck
+const sequelize_1 = require("sequelize");
+const database_1 = __importDefault(require("./../settings/database/database"));
+exports.dataBase = new sequelize_1.Sequelize(database_1.default);

package/dist/database/models/User.d.ts

@@ -0,0 +1,9 @@
+import { Model } from "sequelize";
+export declare class User extends Model {
+    id: number;
+    email: string;
+    first_name?: string;
+    is_active: boolean;
+    password_hash: string;
+    last_action: Date;
+}

package/dist/database/models/User.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.User = void 0;
+const sequelize_1 = require("sequelize");
+const sequelize_2 = require("sequelize");
+const database_1 = require("../database");
+class User extends sequelize_1.Model {
+}
+exports.User = User;
+User.init({
+    first_name: sequelize_2.DataTypes.STRING,
+    email: sequelize_2.DataTypes.STRING,
+    is_active: sequelize_2.DataTypes.BOOLEAN,
+    password_hash: sequelize_2.DataTypes.STRING,
+    last_action: sequelize_2.DataTypes.DATE,
+}, {
+    sequelize: database_1.dataBase,
+    tableName: 'spc_users',
+});

package/dist/database/models/WSAuth.d.ts

@@ -0,0 +1,6 @@
+import { Model } from "sequelize";
+export declare class WebSocketAuth extends Model {
+    token: string;
+    expiration: Date;
+    auth_connection_token: string;
+}

package/dist/database/models/WSAuth.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketAuth = void 0;
+const sequelize_1 = require("sequelize");
+const sequelize_2 = require("sequelize");
+const database_1 = require("../database");
+class WebSocketAuth extends sequelize_1.Model {
+}
+exports.WebSocketAuth = WebSocketAuth;
+WebSocketAuth.init({
+    token: sequelize_2.DataTypes.STRING,
+    expiration: sequelize_2.DataTypes.DATE,
+    user_id: sequelize_2.DataTypes.INTEGER,
+    is_active: sequelize_2.DataTypes.BOOLEAN,
+    auth_connection_token: sequelize_2.DataTypes.STRING,
+}, {
+    sequelize: database_1.dataBase,
+    tableName: 'spc_wsauth'
+});

package/dist/expressServer.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="node" />
+import express from "express";
+import { Express } from "express";
+import { Server } from "http";
+export default class ExpressServer {
+    app: Express;
+    authUserBaseUrl: string;
+    registerUserBaseUrl: string;
+    usePort: number;
+    server?: Server;
+    wsAuthBaseUrl: string;
+    constructor();
+    listen(port?: any): void;
+    initModules(): void;
+    initUserAuthSystem(baseUrl?: string): void;
+    initUserRegisterSystem(baseUrl?: string): void;
+    initWSAuthSystem(wsBaseUrl?: string): void;
+    getApp(): express.Express;
+    getServer(): Server | undefined;
+}

package/dist/expressServer.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = __importDefault(require("express"));
+const sessions_1 = require("./modules/sessions");
+const postreader_1 = require("./modules/postreader");
+const initcors_1 = require("./modules/initcors");
+const env_1 = __importDefault(require("./settings/env"));
+const userauth_1 = __importDefault(require("./routes/userauth"));
+const wsauth_1 = require("./routes/wsauth");
+const userresgister_1 = __importDefault(require("./routes/userresgister"));
+class ExpressServer {
+    constructor() {
+        this.authUserBaseUrl = "";
+        this.wsAuthBaseUrl = "";
+        this.registerUserBaseUrl = "";
+        this.usePort = env_1.default.PORT;
+        this.app = (0, express_1.default)();
+        this.initModules();
+    }
+    listen(port = null) {
+        if (port != null)
+            this.usePort = parseInt(port);
+        this.server = this.app.listen(this.usePort);
+    }
+    initModules() {
+        (0, sessions_1.initSessions)(this.app);
+        (0, postreader_1.initPostReader)(this.app);
+        (0, initcors_1.initCors)(this.app);
+    }
+    initUserAuthSystem(baseUrl = '/user') {
+        this.authUserBaseUrl = baseUrl;
+        this.app.use(this.authUserBaseUrl, userauth_1.default);
+    }
+    initUserRegisterSystem(baseUrl = '/userregister') {
+        this.registerUserBaseUrl = baseUrl;
+        this.app.use(this.registerUserBaseUrl, userresgister_1.default);
+    }
+    initWSAuthSystem(wsBaseUrl = '/ws') {
+        this.wsAuthBaseUrl = wsBaseUrl;
+        this.app.use(this.wsAuthBaseUrl, wsauth_1.router);
+    }
+    getApp() {
+        return this.app;
+    }
+    getServer() {
+        return this.server;
+    }
+}
+exports.default = ExpressServer;

package/dist/logs/logs.d.ts

@@ -0,0 +1,29 @@
+import { Request } from 'express';
+export declare const BASE_LOG_PATH = "./logs";
+export declare enum LogSeverity {
+    danger = "danger",
+    servere = "severe",
+    moderate = "moderate",
+    info = "info"
+}
+export interface SaveLogOptions {
+    userId?: number;
+    data: string;
+    severity: LogSeverity;
+    addPath?: string;
+    filePrefix?: string;
+    penTestSuspcion?: boolean;
+    req?: Request;
+    ip?: string;
+    url?: string;
+}
+export declare function stringfyError(err: any): string;
+export declare function getIpFromRequest(req: Request): string;
+export declare function saveInternalErrorLog(req: Request, error: any, options?: {
+    penTestSuspcion?: boolean;
+    severity?: LogSeverity;
+}): Promise<void>;
+export declare function saveLog(options: SaveLogOptions): {
+    fileName: string;
+    basePath: string;
+};

package/dist/logs/logs.js

@@ -0,0 +1,132 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.saveLog = exports.saveInternalErrorLog = exports.getIpFromRequest = exports.stringfyError = exports.LogSeverity = exports.BASE_LOG_PATH = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+exports.BASE_LOG_PATH = './logs';
+var LogSeverity;
+(function (LogSeverity) {
+    LogSeverity["danger"] = "danger";
+    LogSeverity["servere"] = "severe";
+    LogSeverity["moderate"] = "moderate";
+    LogSeverity["info"] = "info";
+})(LogSeverity = exports.LogSeverity || (exports.LogSeverity = {}));
+function stringfyError(err) {
+    const type = typeof (err);
+    if (type !== 'object')
+        return err.toString();
+    let ret = stringfyObject(err, 0);
+    return ret || "";
+    function stringfyObject(obj, level = 0) {
+        if (!obj)
+            return "";
+        if (typeof (obj) !== 'object')
+            return obj.toString();
+        if (level == 5)
+            return "Is Object level max 8";
+        let ret = {};
+        for (let key of Object.keys(obj)) {
+            let value = obj[key];
+            //@ts-ignore
+            ret[key] = typeof (value) == 'object' ? stringfyObject(value, level + 1).replaceAll('\\', '') : value === null || value === void 0 ? void 0 : value.toString();
+        }
+        return JSON.stringify(ret);
+    }
+}
+exports.stringfyError = stringfyError;
+function getIpFromRequest(req) {
+    //@
+    let ips = (req.headers['cf-connecting-ip'] ||
+        req.headers['x-real-ip'] ||
+        req.headers['x-forwarded-for'] ||
+        req.ip || '');
+    if (typeof (ips) == 'string') {
+        ips = ips.split(',');
+    }
+    return ips[0].trim();
+}
+exports.getIpFromRequest = getIpFromRequest;
+function saveInternalErrorLog(req, error, options) {
+    var _a;
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const ip = getIpFromRequest(req);
+            const url = req.originalUrl;
+            //@ts-ignore
+            const userId = (_a = req.user) === null || _a === void 0 ? void 0 : _a.id;
+            let errorString = stringfyError(error);
+            saveLog({
+                ip: ip,
+                url: url,
+                userId: userId,
+                data: errorString,
+                severity: (options === null || options === void 0 ? void 0 : options.severity) || LogSeverity.info,
+                penTestSuspcion: options === null || options === void 0 ? void 0 : options.penTestSuspcion,
+            });
+        }
+        catch (e) {
+            console.log("Error ON Save Log", e);
+        }
+    });
+}
+exports.saveInternalErrorLog = saveInternalErrorLog;
+function saveLog(options) {
+    if (!fs_1.default.existsSync(exports.BASE_LOG_PATH)) {
+        fs_1.default.mkdirSync(exports.BASE_LOG_PATH);
+    }
+    let basePath = exports.BASE_LOG_PATH;
+    if (options.addPath) {
+        basePath = path_1.default.join(basePath, options.addPath);
+        if (!fs_1.default.existsSync(basePath)) {
+            fs_1.default.mkdirSync(basePath);
+        }
+    }
+    if (options.userId) {
+        basePath = path_1.default.join(basePath, options.userId.toString());
+    }
+    else {
+        basePath = path_1.default.join(basePath, "unlogged");
+    }
+    if (!fs_1.default.existsSync(basePath)) {
+        fs_1.default.mkdirSync(basePath);
+    }
+    let fileName = path_1.default.join(basePath, `${options.filePrefix ? options.filePrefix + '_' : ""}${getDateString(new Date())}.csv`);
+    let data = "";
+    if (fs_1.default.existsSync(fileName)) {
+        data = fs_1.default.readFileSync(fileName).toString() + "\n";
+    }
+    if (!data) {
+        data = 'Data;Severidade;Usuário;Dados;IP;URL;Supeita de Ataque\n';
+    }
+    data += `${new Date()};${options.severity};${options.userId || "Deslogado"};${options.data};${options.ip || "Não Informado"};${options.url || "Não Informado"};${options.penTestSuspcion ? "SIM" : "NÃO"}`;
+    fs_1.default.writeFileSync(fileName, data);
+    return {
+        fileName,
+        basePath,
+    };
+}
+exports.saveLog = saveLog;
+function getDateString(d) {
+    const year = d.getFullYear();
+    const month = zerof(d.getMonth() + 1);
+    const day = zerof(d.getDate());
+    const hour = zerof(d.getHours());
+    return `${year}_${month}_${day}_${hour}`;
+    function zerof(n) {
+        if (n > 9)
+            return n.toString();
+        return `0${n}`;
+    }
+}

package/dist/middlewares/auth.d.ts

@@ -0,0 +1,6 @@
+import { User } from "../server";
+import { Request } from "express";
+export interface RequestAuthenticated extends Request {
+    user: User;
+}
+export declare function setUserDataMiddleware(req: any, res: any, next: any): Promise<any>;

package/dist/middlewares/auth.js

@@ -0,0 +1,35 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setUserDataMiddleware = void 0;
+const server_1 = require("../server");
+const server_2 = require("../server");
+const server_3 = require("../server");
+const response_1 = require("../utils/response");
+function setUserDataMiddleware(req, res, next) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!(0, server_1.userIsLogged)(req))
+            return res.status(401).send((0, server_2.JSONResponse)({}, "User Must Be Logged"));
+        try {
+            const dealerEmail = (0, server_3.getUserSessionData)(req);
+            const user = yield server_1.User.findOne({ where: { email: dealerEmail, is_active: true } });
+            if (!user)
+                throw "Unknown user";
+            req.user = user;
+            yield (0, server_1.updateUserLastAction)(user);
+            next();
+        }
+        catch (e) {
+            return (0, response_1.sendIError)(req, res, e);
+        }
+    });
+}
+exports.setUserDataMiddleware = setUserDataMiddleware;

package/dist/middlewares/post.d.ts

@@ -0,0 +1 @@
+export declare function checkAndFilterPostParams(req: any, res: any, next: any): void;

package/dist/middlewares/post.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkAndFilterPostParams = void 0;
+function checkAndFilterPostParams(req, res, next) {
+}
+exports.checkAndFilterPostParams = checkAndFilterPostParams;

package/dist/middlewares/wsauth.d.ts

@@ -0,0 +1 @@
+export declare function checkWSAuth(ws: any, msg: any): Promise<boolean>;

package/dist/middlewares/wsauth.js

@@ -0,0 +1,56 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkWSAuth = void 0;
+const random_1 = require("../utils/string/random");
+const wsauth_1 = require("../wsauth/wsauth");
+const response_1 = require("../utils/response");
+const server_1 = require("../server");
+const meta_sanitizer_1 = __importDefault(require("meta-sanitizer"));
+const DEBUG = true;
+function checkWSAuth(ws, msg) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            if (ws.userId && ws.connectionToken) {
+                if ((yield (0, wsauth_1.checkConnectionAuth)(ws.userId, ws.connectionToken)))
+                    return true;
+            }
+            const message = JSON.parse(msg);
+            if (message.action === "Authenticate") {
+                const token = meta_sanitizer_1.default.justCharsAndNumbers(message.token, false);
+                const userId = parseInt(meta_sanitizer_1.default.justNumbers(message.userId, false));
+                const connectionToken = (0, random_1.randomString)(35);
+                if ((yield (0, server_1.authenticateWS)(userId, token, connectionToken))) {
+                    ws.userId = userId;
+                    ws.connectionToken = connectionToken;
+                    return true;
+                }
+                else {
+                    return sendError(false, "Invalid Token or UserID");
+                }
+            }
+            else {
+                return sendError(false, "Need auth", "'action'='Authenticate' and must have 'token' and 'userId'");
+            }
+        }
+        catch (e) {
+            return sendError(false, "Internal Error", "", e);
+        }
+        function sendError(isOk, message, errorMessage = "", data = {}) {
+            ws.send((0, response_1.WSResponse)(isOk, message, errorMessage, data));
+            return false;
+        }
+    });
+}
+exports.checkWSAuth = checkWSAuth;

package/dist/modules/initcors.d.ts

@@ -0,0 +1 @@
+export declare function initCors(app: any): void;

package/dist/modules/initcors.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initCors = void 0;
+const cors_1 = __importDefault(require("cors"));
+const env_1 = __importDefault(require("../settings/env"));
+function initCors(app) {
+    if (env_1.default.ALLOW_CORS)
+        app.use((0, cors_1.default)());
+}
+exports.initCors = initCors;

package/dist/modules/postreader.d.ts

@@ -0,0 +1 @@
+export declare function initPostReader(app: any): void;

package/dist/modules/postreader.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initPostReader = void 0;
+const express_1 = __importDefault(require("express"));
+function initPostReader(app) {
+    app.use(express_1.default.json());
+    app.use(express_1.default.urlencoded({ extended: true }));
+}
+exports.initPostReader = initPostReader;

package/dist/modules/sessions.d.ts

@@ -0,0 +1 @@
+export declare function initSessions(app: any): void;

package/dist/modules/sessions.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initSessions = void 0;
+const express_session_1 = __importDefault(require("express-session"));
+const env_1 = __importDefault(require("../settings/env"));
+function initSessions(app) {
+    app.set('trust proxy', 1); // trust first proxy
+    app.use((0, express_session_1.default)({
+        secret: env_1.default.SESSION_SECRET,
+        resave: false,
+        saveUninitialized: true,
+        cookie: { secure: env_1.default.NODE_ENV == 'development' ? false : true,
+            httpOnly: true,
+        },
+    }));
+}
+exports.initSessions = initSessions;

package/dist/routes/userauth.d.ts

@@ -0,0 +1,2 @@
+declare const router: import("express-serve-static-core").Router;
+export default router;

package/dist/routes/userauth.js

@@ -0,0 +1,68 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = __importDefault(require("express"));
+const response_1 = require("../utils/response");
+const auth_1 = require("../auth/auth");
+const meta_sanitizer_1 = __importDefault(require("meta-sanitizer"));
+const users_1 = require("../users/users");
+const auth_2 = require("../middlewares/auth");
+const auth_3 = require("../auth/auth");
+const auth_4 = require("../auth/auth");
+const server_1 = require("../server");
+const router = express_1.default.Router();
+router.post('/logout', (req, res) => {
+    let is_ok = false;
+    if ((0, auth_1.userIsLogged)(req)) {
+        (0, auth_4.logoutUser)(req);
+        is_ok = true;
+    }
+    res.send((0, response_1.JSONResponse)("OK"));
+});
+router.post('/login', (req, res) => __awaiter(void 0, void 0, void 0, function* () {
+    let email = "";
+    let password = "";
+    try {
+        email = meta_sanitizer_1.default.sanitizeEmail(req.body.email);
+        password = meta_sanitizer_1.default.queryProtector(req.body.password);
+    }
+    catch (e) {
+        return res.status(403).send((0, response_1.JSONResponse)({}, "Must have 'email' and 'password' params"));
+    }
+    if (password == "" || email == "")
+        return res.status(403).send((0, response_1.JSONResponse)({}, "Must have 'email' and 'password' params"));
+    email = email.toLocaleLowerCase();
+    try {
+        const checkPass = yield (0, users_1.checkUserPassword)(email, password);
+        if (checkPass) {
+            const user = yield server_1.User.findOne({ where: { email: email } });
+            if (!user)
+                throw "Dont find User";
+            if (!user.is_active) {
+                return res.status(403).send((0, response_1.JSONResponse)({}, "User deleted"));
+            }
+            (0, auth_3.setUserLogged)(req, email);
+            yield (0, users_1.updateUserLastAction)(user);
+            return res.status(200).send((0, response_1.JSONResponse)("Login Ok"));
+        }
+        return res.status(403).send((0, response_1.JSONResponse)({}, "Invalid Password"));
+    }
+    catch (e) {
+        return (0, response_1.sendIError)(req, res, e);
+    }
+}));
+router.post('/getuser', auth_2.setUserDataMiddleware, (req, res) => __awaiter(void 0, void 0, void 0, function* () {
+    res.send((0, response_1.JSONResponse)({ email: req.user.email, id: req.user.id }));
+}));
+exports.default = router;

package/dist/routes/userresgister.d.ts

@@ -0,0 +1,2 @@
+declare const router: import("express-serve-static-core").Router;
+export default router;

package/dist/routes/userresgister.js

@@ -0,0 +1,42 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = require("express");
+const email_1 = require("../utils/validators/email");
+const server_1 = require("../server");
+const server_2 = require("../server");
+const response_1 = require("../utils/response");
+const meta_sanitizer_1 = __importDefault(require("meta-sanitizer"));
+const router = (0, express_1.Router)();
+router.post('/register', (req, res) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        let email = meta_sanitizer_1.default.sanitizeEmail(req.body.email || '');
+        let password = meta_sanitizer_1.default.queryProtector(req.body.password || '');
+        let name = meta_sanitizer_1.default.SanitizerEngine(req.body.name || '', true, false, [' ']).sanitizedData;
+        if (email == "" || password == "" || name == "")
+            return res.send((0, server_2.JSONResponse)({}, "Invalid params"));
+        email = email.toLocaleLowerCase();
+        if (!(0, email_1.checkEmail)(email)) {
+            return res.status(403).send((0, server_2.JSONResponse)({}, "Invalid Email"));
+        }
+        yield (0, server_1.createUser)({ first_name: name, email: email, password_string: password });
+        return res.send((0, server_2.JSONResponse)("REGISTER OK"));
+    }
+    catch (e) {
+        if (e === "User exist")
+            return res.send((0, server_2.JSONResponse)({}, "User Exist"));
+        return (0, response_1.sendIError)(req, res, e);
+    }
+}));
+exports.default = router;

package/dist/routes/wsauth.d.ts

@@ -0,0 +1 @@
+export declare const router: import("express-serve-static-core").Router;