serverpreconfigured 1.0.0

package/.sequelizerc

@@ -0,0 +1,6 @@
+const path = require('path');
+
+module.exports = {
+  'config': path.resolve(__dirname,'dist','settings','database','database.js'),
+  'migrations-path': path.resolve(__dirname, 'migrations'),
+}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Rafael Floriani Pinto
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,2 @@
+# Node-Server-Preconfigured
+Node Server Preconfigured

package/dist/auth/auth.d.ts

@@ -0,0 +1 @@
+export declare function userIsLogged(req: any): boolean;

package/dist/auth/auth.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const secureget_1 = require("../sessions/secureget");
+const config_1 = require("./config");
+function userIsLogged(req) {
+    let user = secureget_1.getSessionValue(req, config_1.SESSION_LOGGED_DATA);
+    if (user)
+        return true;
+    return false;
+}
+exports.userIsLogged = userIsLogged;

package/dist/auth/config.d.ts

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

package/dist/auth/config.js

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

package/dist/database/database.d.ts

@@ -0,0 +1 @@
+export declare const dataBase: any;

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 });
+//@ts-ignore
+//@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,4 @@
+import { Model } from "sequelize";
+export declare class User extends Model {
+    static init(sequelize: any): void;
+}

package/dist/database/models/User.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const sequelize_1 = require("sequelize");
+const sequelize_2 = require("sequelize");
+class User extends sequelize_1.Model {
+    static init(sequelize) {
+        super.init({
+            first_name: sequelize_2.DataTypes.STRING,
+            email: sequelize_2.DataTypes.STRING,
+            is_active: sequelize_2.DataTypes.BOOLEAN,
+            password_hash: sequelize_2.DataTypes.STRING,
+        }, {
+            sequelize: sequelize,
+            tableName: 'users',
+        });
+    }
+}
+exports.User = User;

package/dist/modules/initcors.d.ts

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

package/dist/modules/initcors.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 });
+const cors_1 = __importDefault(require("cors"));
+const env_1 = __importDefault(require("../settings/env"));
+function initCors(app) {
+    if (env_1.default.ALLOW_CORS)
+        app.use(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,11 @@
+"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"));
+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,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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(express_session_1.default({
+        secret: 'keyboard cat',
+        resave: false,
+        saveUninitialized: true,
+        cookie: { secure: env_1.default.NODE_ENV == 'development' ? false : true,
+            httpOnly: true,
+        },
+    }));
+}
+exports.initSessions = initSessions;

package/dist/routes/auth.d.ts

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

package/dist/routes/auth.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 });
+const express_1 = __importDefault(require("express"));
+const secureset_1 = require("../sessions/secureset");
+const config_1 = require("../auth/config");
+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");
+var LoginErrorCode;
+(function (LoginErrorCode) {
+    LoginErrorCode[LoginErrorCode["NoError"] = 0] = "NoError";
+    LoginErrorCode[LoginErrorCode["InvalidParams"] = 1] = "InvalidParams";
+    LoginErrorCode[LoginErrorCode["InvalidPassword"] = 2] = "InvalidPassword";
+})(LoginErrorCode || (LoginErrorCode = {}));
+const router = express_1.default.Router();
+router.post('/logout', (req, res) => {
+    let is_ok = false;
+    if (auth_1.userIsLogged(req)) {
+        secureset_1.deleteSessionValue(req, config_1.SESSION_LOGGED_DATA);
+        is_ok = true;
+    }
+    res.send(response_1.JSONResponse(is_ok, 0, is_ok ? "" : "User Must be logged", {}));
+});
+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.send(response_1.JSONResponse(false, LoginErrorCode.InvalidParams, "Must have 'email' and 'password' params"));
+    }
+    if (password == "" || email == "")
+        return res.send(response_1.JSONResponse(false, LoginErrorCode.InvalidParams, "Must have 'email' and 'password' params"));
+    const checkPass = yield users_1.checkUserPassword(email, password);
+    if (checkPass) {
+        secureset_1.setSessionValue(req, config_1.SESSION_LOGGED_DATA, email);
+        return res.send(response_1.JSONResponse(true, LoginErrorCode.NoError, "Login Ok"));
+    }
+    return res.send(response_1.JSONResponse(false, LoginErrorCode.InvalidPassword, "Invalid Password"));
+}));
+exports.default = router;

package/dist/server.d.ts

@@ -0,0 +1,10 @@
+export default class ExpressServer {
+    app: any;
+    authBaseUrl: string;
+    usePort: number;
+    constructor();
+    listen(port?: any): void;
+    initModules(): void;
+    initAuthSystem(baseUrl?: string): void;
+    getApp(): any;
+}

package/dist/server.js

@@ -0,0 +1,37 @@
+"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 auth_1 = __importDefault(require("./routes/auth"));
+class ExpressServer {
+    constructor() {
+        this.authBaseUrl = "";
+        this.usePort = env_1.default.PORT;
+        this.app = express_1.default();
+        this.initModules();
+    }
+    listen(port = null) {
+        if (port != null)
+            this.usePort = parseInt(port);
+        this.app.listen(this.usePort);
+    }
+    initModules() {
+        sessions_1.initSessions(this.app);
+        postreader_1.initPostReader(this.app);
+        initcors_1.initCors(this.app);
+    }
+    initAuthSystem(baseUrl = '/user') {
+        this.authBaseUrl = baseUrl;
+        this.app.use(this.authBaseUrl, auth_1.default);
+    }
+    getApp() {
+        return this.app;
+    }
+}
+exports.default = ExpressServer;

package/dist/sessions/secureget.d.ts

@@ -0,0 +1 @@
+export declare function getSessionValue(req: any, get: string): any;

package/dist/sessions/secureget.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function getSessionValue(req, get) {
+    return req.session[get];
+}
+exports.getSessionValue = getSessionValue;

package/dist/sessions/secureset.d.ts

@@ -0,0 +1,2 @@
+export declare function setSessionValue(req: any, to: string, value: any): void;
+export declare function deleteSessionValue(req: any, to: string): void;

package/dist/sessions/secureset.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function setSessionValue(req, to, value) {
+    req.session[to] = value;
+}
+exports.setSessionValue = setSessionValue;
+function deleteSessionValue(req, to) {
+    setSessionValue(req, to, undefined);
+}
+exports.deleteSessionValue = deleteSessionValue;

package/dist/settings/database/database.d.ts

@@ -0,0 +1,10 @@
+export declare const dialect: string;
+export declare const host: string;
+export declare const database: string;
+export declare const username: string;
+export declare const password: string;
+export declare namespace define {
+    export const underscored: boolean;
+    export const timestamps: boolean;
+}
+export declare const logging: boolean;

package/dist/settings/database/database.js

@@ -0,0 +1,14 @@
+"use strict";
+const ENV = require("./../env").default;
+module.exports = {
+    dialect: ENV.DATABASE.dialect,
+    host: ENV.DATABASE.host,
+    database: ENV.DATABASE.database,
+    username: ENV.DATABASE.username,
+    password: ENV.DATABASE.password,
+    define: {
+        underscored: true,
+        timestamps: true,
+    },
+    logging: false,
+};

package/dist/settings/env.d.ts

@@ -0,0 +1,13 @@
+declare const ENV: {
+    NODE_ENV: string;
+    ALLOW_CORS: boolean;
+    PORT: number;
+    DATABASE: {
+        dialect: string;
+        host: string;
+        database: string;
+        username: string;
+        password: string;
+    };
+};
+export default ENV;

package/dist/settings/env.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ENV = {
+    NODE_ENV: process.env.SERVER_ENV == 'development' ? 'development' : 'production',
+    ALLOW_CORS: process.env.ALLOW_CORS == 'ALLOW' ? true : false,
+    PORT: process.env.SERVER_PORT ? parseInt(process.env.SERVER_PORT) : 3000,
+    DATABASE: {
+        dialect: process.env.DATABASE_DIALECT ? process.env.DATABASE_DIALECT : 'postgres',
+        host: process.env.DATABASE_HOST ? process.env.DATABASE_HOST : 'localhost',
+        database: process.env.DATABASE_DATABASE ? process.env.DATABASE_DATABASE : 'postgres',
+        username: process.env.DATABASE_USERNAME ? process.env.DATABASE_USERNAME : 'postgres',
+        password: process.env.DATABASE_PASSWORD ? process.env.DATABASE_PASSWORD : '',
+    }
+};
+exports.default = ENV;

package/dist/users/password.d.ts

@@ -0,0 +1,2 @@
+export declare function createArgon2Hash(password_string: string): Promise<string | false>;
+export declare function checkArgon2Password(password_hash: string, password_string: string): Promise<"Match" | "Dont Match">;

package/dist/users/password.js

@@ -0,0 +1,40 @@
+"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 argon2_1 = __importDefault(require("argon2"));
+function createArgon2Hash(password_string) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            let hash = yield argon2_1.default.hash(password_string);
+            return hash;
+        }
+        catch (e) {
+            return false;
+        }
+    });
+}
+exports.createArgon2Hash = createArgon2Hash;
+function checkArgon2Password(password_hash, password_string) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            if (yield argon2_1.default.verify(password_hash, password_string))
+                return "Match";
+            return "Dont Match";
+        }
+        catch (e) {
+            return "Dont Match";
+        }
+    });
+}
+exports.checkArgon2Password = checkArgon2Password;

package/dist/users/types.d.ts

@@ -0,0 +1,6 @@
+export interface UserCreateInterface {
+    first_name: string;
+    email: string;
+    password_string: string;
+}
+export declare type PasswordVerifyResult = 'Match' | 'Dont Match';

package/dist/users/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+;

package/dist/users/users.d.ts

@@ -0,0 +1,7 @@
+import { UserCreateInterface } from "./types";
+export declare function getUserById(id: Number): Promise<any>;
+export declare function getUserByEmail(email: string): Promise<any>;
+export declare function deleteUserById(id: Number): Promise<any>;
+export declare function isUserExist(email: string): Promise<boolean>;
+export declare function createUser(data: UserCreateInterface): Promise<any>;
+export declare function checkUserPassword(email: string, password_string: string): Promise<boolean>;

package/dist/users/users.js

@@ -0,0 +1,92 @@
+"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 });
+const database_1 = require("./../database/database");
+const User_1 = require("./../database/models/User");
+const password_1 = require("./password");
+User_1.User.init(database_1.dataBase);
+function getUserById(id) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let result = yield User_1.User.findOne({ where: { id: id.toString() } });
+        return (result);
+    });
+}
+exports.getUserById = getUserById;
+function getUserByEmail(email) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let result = yield User_1.User.findOne({ where: { email: email } });
+        return (result);
+    });
+}
+exports.getUserByEmail = getUserByEmail;
+function deleteUserById(id) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let result = yield User_1.User.destroy({ where: { id: id.toString() } });
+        return result;
+    });
+}
+exports.deleteUserById = deleteUserById;
+function isUserExist(email) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            let user = yield getUserByEmail(email);
+            return Boolean(user);
+        }
+        catch (e) {
+            throw (e);
+        }
+    });
+}
+exports.isUserExist = isUserExist;
+function createUser(data) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let user_exist = false;
+        try {
+            user_exist = yield isUserExist(data.email);
+        }
+        catch (e) {
+            throw (e);
+        }
+        if (user_exist)
+            throw "User exist";
+        let hash = yield password_1.createArgon2Hash(data.password_string);
+        if (!hash)
+            throw "Create argon2 hash error";
+        try {
+            let user_instance = yield User_1.User.create({ email: data.email,
+                first_name: data.first_name,
+                password_hash: hash });
+            return user_instance;
+        }
+        catch (e) {
+            throw e;
+        }
+    });
+}
+exports.createUser = createUser;
+function checkUserPassword(email, password_string) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let user;
+        try {
+            user = yield getUserByEmail(email);
+        }
+        catch (e) {
+            return false;
+        }
+        if (!user)
+            return false;
+        let hash = user.dataValues.password_hash;
+        if ((yield password_1.checkArgon2Password(hash, password_string)) == 'Match')
+            return true;
+        return false;
+    });
+}
+exports.checkUserPassword = checkUserPassword;

package/dist/utils/response.d.ts

@@ -0,0 +1 @@
+export declare function JSONResponse(is_ok: boolean, error_code?: number, error_message?: string, data?: any): string;

package/dist/utils/response.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function JSONResponse(is_ok, error_code = 0, error_message = '', data = {}) {
+    const ret_data = {
+        is_ok: is_ok,
+        error_code: error_code,
+        error_message: error_message,
+        data: data,
+    };
+    return JSON.stringify(ret_data);
+}
+exports.JSONResponse = JSONResponse;

package/migrations/20220314190413-new.js

@@ -0,0 +1,44 @@
+'use strict';
+
+module.exports = {
+  async up (queryInterface, Sequelize) {
+
+     return await queryInterface.createTable('users', 
+      { id: {
+           type:Sequelize.INTEGER,
+           primaryKey:true,
+           autoIncrement:true,
+           allowNull:false 
+         },
+        first_name:{
+          type:Sequelize.STRING,
+          allowNull:false,
+        } ,
+        email:{
+          type:Sequelize.STRING,
+          unique:true,
+          allowNull:false,
+        },
+        password_hash:{
+          type:Sequelize.STRING(500),
+        },
+        is_active:{
+          type:Sequelize.BOOLEAN,
+          defaultValue:true,
+        },
+        created_at:{
+          type:Sequelize.DATE,
+          allowNull:false,
+        },
+        updated_at:{
+          type:Sequelize.DATE,
+          allowNull:false,
+        },
+      });
+
+  },
+
+  async down (queryInterface, Sequelize) {
+     return await queryInterface.dropTable('users');
+  }
+};

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "serverpreconfigured",
+  "version": "1.0.0",
+  "description": "\"Pre-configured server with authentication system and database integration\"",
+  "main": "dist/server.js",
+  "type": "commonjs",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "start": "node ./dist/server.js",
+    "dev": "npx nodemon"
+  },
+  "author": "Rafael Floriani Pinto",
+  "license": "MIT",
+  "dependencies": {
+    "@types/cors": "^2.8.12",
+    "@types/express": "^4.17.13",
+    "@types/express-session": "^1.17.4",
+    "argon2": "^0.28.5",
+    "body-parser": "^1.19.2",
+    "cors": "^2.8.5",
+    "express": "^4.17.3",
+    "express-session": "^1.17.2",
+    "meta-sanitizer": "^2.0.2",
+    "nodemon": "^2.0.15",
+    "pg": "^8.7.3",
+    "pg-hstore": "^2.3.4",
+    "sequelize": "^7.0.0-alpha.9",
+    "sequelize-cli": "^6.4.1",
+    "sucrase": "^3.20.3",
+    "typescript": "^4.6.2"
+  },
+  "devDependencies": {
+    "@types/node": "^17.0.21"
+  }
+}

package/src/auth/auth.ts

@@ -0,0 +1,8 @@
+import { getSessionValue } from "../sessions/secureget";
+import { SESSION_LOGGED_DATA } from "./config";
+export function userIsLogged(req:any):boolean{
+    let user=getSessionValue(req,SESSION_LOGGED_DATA);
+    if(user)
+      return true;
+    return false;
+}

package/src/auth/config.ts

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

package/src/database/database.ts

@@ -0,0 +1,5 @@
+//@ts-ignore
+//@ts-nocheck
+import {Sequelize}  from "sequelize";
+import config from "./../settings/database/database";
+export const dataBase=new Sequelize(config);

package/src/database/models/User.ts

@@ -0,0 +1,20 @@
+import { Model } from "sequelize";
+import { DataTypes } from "sequelize";
+
+export class User extends Model{
+    static init(sequelize:any){
+        super.init({
+            first_name:DataTypes.STRING,
+            email:DataTypes.STRING,
+            is_active:DataTypes.BOOLEAN,
+            password_hash:DataTypes.STRING,
+        },
+        { 
+          sequelize:sequelize,  
+          tableName: 'users',  
+        }
+        );
+    }
+}
+
+

package/src/modules/initcors.ts

@@ -0,0 +1,7 @@
+import cors from 'cors';
+import ENV  from '../settings/env';
+
+export function initCors(app:any){
+    if(ENV.ALLOW_CORS) 
+         app.use(cors());
+}

package/src/modules/postreader.ts

@@ -0,0 +1,5 @@
+import  express  from "express";
+export function initPostReader(app:any){
+    app.use(express.json());
+    app.use(express.urlencoded({extended:true}));
+}

package/src/modules/sessions.ts

@@ -0,0 +1,14 @@
+import session from "express-session";
+import  ENV  from "../settings/env";
+export function initSessions(app:any){
+    app.set('trust proxy', 1) // trust first proxy
+    app.use(session({
+        secret: 'keyboard cat',
+        resave: false,
+        saveUninitialized: true,
+        cookie: { secure: ENV.NODE_ENV=='development'?false:true,
+                  httpOnly:true,               
+                },
+    }));
+
+}

package/src/routes/auth.ts

@@ -0,0 +1,42 @@
+import  express  from "express";
+import { deleteSessionValue ,setSessionValue} from "../sessions/secureset";
+import { SESSION_LOGGED_DATA } from "../auth/config";
+import { JSONResponse } from "../utils/response";
+import { userIsLogged } from "../auth/auth";
+import meta_sanitizer from 'meta-sanitizer';
+import { checkUserPassword } from "../users/users";
+enum LoginErrorCode{
+    NoError=0,
+    InvalidParams,
+    InvalidPassword,
+
+}
+const router=express.Router();
+router.post('/logout',(req,res)=>{
+   let is_ok=false;
+   if(userIsLogged(req)){
+       deleteSessionValue(req,SESSION_LOGGED_DATA);
+       is_ok=true;
+   }
+   res.send(JSONResponse(is_ok,0,is_ok?"":"User Must be logged",{}));
+});
+router.post('/login',async (req,res)=>{
+    let email="";
+    let password="";
+    try{
+      email=meta_sanitizer.sanitizeEmail(req.body.email);
+      password=meta_sanitizer.queryProtector(req.body.password);
+    }catch(e){
+      return res.send(JSONResponse(false,LoginErrorCode.InvalidParams,"Must have 'email' and 'password' params"))
+    }
+    if(password==""||email=="")
+      return res.send(JSONResponse(false,LoginErrorCode.InvalidParams,"Must have 'email' and 'password' params"));
+    const checkPass=await checkUserPassword(email,password);
+    if(checkPass){
+       setSessionValue(req,SESSION_LOGGED_DATA,email);
+       return res.send(JSONResponse(true,LoginErrorCode.NoError,"Login Ok"));
+    }
+    return res.send(JSONResponse(false,LoginErrorCode.InvalidPassword,"Invalid Password"));
+});
+
+export default router;

package/src/server.ts

@@ -0,0 +1,36 @@
+import express from "express";
+import { initSessions } from "./modules/sessions";
+import { initPostReader } from "./modules/postreader";
+import { initCors } from "./modules/initcors";
+import  ENV  from "./settings/env";
+import authRouter from "./routes/auth";
+export default class ExpressServer{
+     app:any;
+     authBaseUrl:string;
+     usePort:number;
+     constructor(){
+        this.authBaseUrl="";
+        this.usePort=ENV.PORT;
+        this.app=express();
+        this.initModules();
+     }
+     listen(port:any=null){
+        if(port!=null)
+           this.usePort=parseInt(port);
+        this.app.listen(this.usePort);  
+     }
+
+     initModules(){
+       initSessions(this.app);
+       initPostReader(this.app);
+       initCors(this.app);
+     }
+     initAuthSystem(baseUrl:string='/user'){
+        this.authBaseUrl=baseUrl;
+        this.app.use(this.authBaseUrl,authRouter);
+     }
+
+     getApp(){
+       return this.app;
+     }
+}

package/src/sessions/secureget.ts

@@ -0,0 +1,3 @@
+export function getSessionValue(req:any,get:string){
+    return req.session[get];
+}

package/src/sessions/secureset.ts

@@ -0,0 +1,7 @@
+export function setSessionValue(req:any,to:string,value:any){
+   req.session[to]=value;
+}
+
+export function deleteSessionValue(req:any,to:string){
+   setSessionValue(req,to,undefined);
+}

package/src/settings/database/database.js

@@ -0,0 +1,14 @@
+const ENV=require("./../env").default;
+module.exports={
+    dialect:ENV.DATABASE.dialect,
+    host:ENV.DATABASE.host,
+    database:ENV.DATABASE.database,
+    username:ENV.DATABASE.username,
+    password:ENV.DATABASE.password,
+    define:{
+        underscored:true,
+        timestamps:true,
+    },
+    logging:false,
+    
+};

package/src/settings/env.ts

@@ -0,0 +1,13 @@
+const ENV={
+    NODE_ENV:process.env.SERVER_ENV=='development'?'development':'production',
+    ALLOW_CORS:process.env.ALLOW_CORS=='ALLOW'?true:false,
+    PORT:process.env.SERVER_PORT?parseInt(process.env.SERVER_PORT):3000,
+    DATABASE:{
+        dialect:process.env.DATABASE_DIALECT?process.env.DATABASE_DIALECT:'postgres',
+        host:process.env.DATABASE_HOST?process.env.DATABASE_HOST:'localhost',
+        database:process.env.DATABASE_DATABASE?process.env.DATABASE_DATABASE:'postgres',
+        username:process.env.DATABASE_USERNAME?process.env.DATABASE_USERNAME:'postgres',
+        password:process.env.DATABASE_PASSWORD?process.env.DATABASE_PASSWORD:'',
+    }
+};
+export default ENV;

package/src/users/password.ts

@@ -0,0 +1,20 @@
+import  argon2  from "argon2";
+import {PasswordVerifyResult} from './types';
+export async function createArgon2Hash(password_string:string){
+   try{
+       let hash=await argon2.hash(password_string);
+       return hash;
+   }catch(e){
+       return false;
+   }
+}
+
+export async function checkArgon2Password(password_hash:string,password_string:string){
+  try{
+     if(await argon2.verify(password_hash,password_string))
+        return "Match";
+     return "Dont Match";   
+  }catch(e){
+     return "Dont Match";
+  }
+}

package/src/users/types.ts

@@ -0,0 +1,6 @@
+export interface UserCreateInterface{
+    first_name:string,
+    email:string,
+    password_string:string
+};
+export type PasswordVerifyResult='Match'|'Dont Match';

package/src/users/users.ts

@@ -0,0 +1,64 @@
+import {dataBase} from "./../database/database";
+import { User } from "./../database/models/User";
+import { createArgon2Hash,checkArgon2Password } from "./password";
+import {UserCreateInterface} from "./types";
+User.init(dataBase);
+export async function getUserById(id:Number){
+     let result=await User.findOne({where:{id:id.toString()}});
+     return (result);
+}
+
+export async function getUserByEmail(email:string){
+     let result=await User.findOne({where:{email:email}});
+     return (result);
+}
+
+export async function deleteUserById(id:Number){
+     let result=await User.destroy({where:{id:id.toString()}});
+     return result;
+}
+export async function isUserExist(email:string) {
+     try{
+          let user=await getUserByEmail(email);
+          return Boolean(user);
+     }catch(e){
+          throw (e);
+     }     
+}
+
+export async function createUser(data:UserCreateInterface){
+     let user_exist=false;
+     try{
+          user_exist=await isUserExist(data.email);
+     }catch(e){
+          throw(e);
+     }
+     if(user_exist)
+       throw "User exist";
+     let hash=await createArgon2Hash(data.password_string);
+     if(!hash)
+       throw "Create argon2 hash error";
+     try{  
+          let user_instance=await User.create({email:data.email,
+                                        first_name:data.first_name,
+                                        password_hash:hash});
+          return user_instance;                              
+     }catch(e){
+        throw e;
+     }
+}
+
+export async function checkUserPassword(email:string,password_string:string):Promise<boolean>{
+    let user;
+    try{
+         user=await getUserByEmail(email);
+    }catch(e){
+         return false;
+    }
+    if(!user)
+      return false;
+    let hash=user.dataValues.password_hash;
+    if(await checkArgon2Password(hash,password_string)=='Match')
+       return true;
+    return false;     
+}

package/src/utils/response.ts

@@ -0,0 +1,9 @@
+export function JSONResponse(is_ok:boolean,error_code:number=0,error_message:string='',data:any={}){
+    const ret_data={
+        is_ok:is_ok,
+        error_code:error_code,
+        error_message:error_message,
+        data:data,
+    };
+    return JSON.stringify(ret_data);
+}

package/tsconfig.json

@@ -0,0 +1,68 @@
+{
+  "compilerOptions": {
+    "target": "es6",                          /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', 'ES2018', 'ES2019', 'ES2020', or 'ESNEXT'. */
+    "module": "commonjs",                     /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', 'es2020', or 'ESNext'. */
+    "skipLibCheck": true,
+    // "lib": [],                             /* Specify library files to be included in the compilation. */
+    "allowJs": true,                       /* Allow javascript files to be compiled. */
+     "checkJs": false,                       /* Report errors in .js files. */
+    // "jsx": "preserve",                     /* Specify JSX code generation: 'preserve', 'react-native', or 'react'. */
+     "declaration": true,                   /* Generates corresponding '.d.ts' file. */
+    // "declarationMap": true,                /* Generates a sourcemap for each corresponding '.d.ts' file. */
+    // "sourceMap": true,                     /* Generates corresponding '.map' file. */
+    // "outFile": "./",                       /* Concatenate and emit output to single file. */
+     "outDir": "./dist",                        /* Redirect output structure to the directory. */
+     "rootDir": "./src",                       /* Specify the root directory of input files. Use to control the output directory structure with --outDir. */
+    // "composite": true,                     /* Enable project compilation */
+    // "tsBuildInfoFile": "./",               /* Specify file to store incremental compilation information */
+    // "removeComments": true,                /* Do not emit comments to output. */
+    // "noEmit": true,                        /* Do not emit outputs. */
+    // "importHelpers": true,                 /* Import emit helpers from 'tslib'. */
+    // "downlevelIteration": true,            /* Provide full support for iterables in 'for-of', spread, and destructuring when targeting 'ES5' or 'ES3'. */
+    // "isolatedModules": true,               /* Transpile each file as a separate module (similar to 'ts.transpileModule'). */
+
+    /* Strict Type-Checking Options */
+    "strict": true,                           /* Enable all strict type-checking options. */
+    // "noImplicitAny": true,                 /* Raise error on expressions and declarations with an implied 'any' type. */
+    // "strictNullChecks": true,              /* Enable strict null checks. */
+    // "strictFunctionTypes": true,           /* Enable strict checking of function types. */
+    // "strictBindCallApply": true,           /* Enable strict 'bind', 'call', and 'apply' methods on functions. */
+    // "strictPropertyInitialization": true,  /* Enable strict checking of property initialization in classes. */
+    // "noImplicitThis": true,                /* Raise error on 'this' expressions with an implied 'any' type. */
+    // "alwaysStrict": true,                  /* Parse in strict mode and emit "use strict" for each source file. */
+
+    /* Additional Checks */
+    // "noUnusedLocals": true,                /* Report errors on unused locals. */
+    // "noUnusedParameters": true,            /* Report errors on unused parameters. */
+    // "noImplicitReturns": true,             /* Report error when not all code paths in function return a value. */
+    // "noFallthroughCasesInSwitch": true,    /* Report errors for fallthrough cases in switch statement. */
+
+    /* Module Resolution Options */
+    // "moduleResolution": "node",            /* Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6). */
+    // "baseUrl": "./",                       /* Base directory to resolve non-absolute module names. */
+    // "paths": {},                           /* A series of entries which re-map imports to lookup locations relative to the 'baseUrl'. */
+    // "rootDirs": [],                        /* List of root folders whose combined content represents the structure of the project at runtime. */
+    "typeRoots": ["./typings"],                       /* List of folders to include type definitions from. */
+    // "types": [],                           /* Type declaration files to be included in compilation. */
+    // "allowSyntheticDefaultImports": true,  /* Allow default imports from modules with no default export. This does not affect code emit, just typechecking. */
+    "esModuleInterop": true,                  /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */
+    // "preserveSymlinks": true,              /* Do not resolve the real path of symlinks. */
+    // "allowUmdGlobalAccess": true,          /* Allow accessing UMD globals from modules. */
+
+    /* Source Map Options */
+    // "sourceRoot": "",                      /* Specify the location where debugger should locate TypeScript files instead of source locations. */
+    // "mapRoot": "",                         /* Specify the location where debugger should locate map files instead of generated locations. */
+    // "inlineSourceMap": true,               /* Emit a single file with source maps instead of having a separate file. */
+    // "inlineSources": true,                 /* Emit the source alongside the sourcemaps within a single file; requires '--inlineSourceMap' or '--sourceMap' to be set. */
+
+    /* Experimental Options */
+    // "experimentalDecorators": true,        /* Enables experimental support for ES7 decorators. */
+    // "emitDecoratorMetadata": true,         /* Enables experimental support for emitting type metadata for decorators. */
+
+    /* Advanced Options */
+    "forceConsistentCasingInFileNames": true  /* Disallow inconsistently-cased references to the same file. */
+  },
+  "exclude": ["node_modules"],
+  "include": ["src"]
+
+}