@ug.software/opposer 3.0.10

package/lib/cjs/server/index.js

@@ -0,0 +1,176 @@
+"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);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Context = exports.f = exports.IsPublicMethod = exports.IsPublic = exports.Payload = exports.Field = exports.Controller = exports.Method = exports.auth = void 0;
+exports.default = Server;
+const index_js_1 = __importDefault(require("./controller/index.js"));
+const index_js_2 = __importDefault(require("../system/index.js"));
+const permission_js_1 = __importDefault(require("./security/middleware/permission.js"));
+const autorization_js_1 = __importDefault(require("./security/middleware/autorization.js"));
+const auth_js_1 = __importDefault(require("./security/controller/auth.js"));
+const index_js_3 = __importDefault(require("../scheduler/index.js"));
+const index_js_4 = require("../orm/index.js");
+// Core
+const index_js_5 = __importDefault(require("./core/index.js"));
+const cors_js_1 = __importDefault(require("./core/middleware/cors.js"));
+const body_parser_js_1 = __importDefault(require("./core/middleware/body-parser.js"));
+const logger_js_1 = __importDefault(require("./core/middleware/logger.js"));
+const index_js_6 = __importDefault(require("./context/index.js"));
+// Playground
+const index_js_7 = __importDefault(require("../playground/index.js"));
+async function initializeDatabase(props, models) {
+    const settings = index_js_2.default.getSettingsFile();
+    const allModels = await index_js_2.default.getAllModels(models);
+    const entities = allModels.map((x) => x.entity);
+    let driver;
+    const type = props.type || settings.database?.type;
+    switch (type) {
+        case 'postgres':
+            driver = new index_js_4.PostgresDriver(props);
+            break;
+        case 'sqlite':
+            driver = new index_js_4.SQLiteDriver(props);
+            break;
+        case 'mysql':
+            driver = new index_js_4.MySQLDriver(props);
+            break;
+        default:
+            throw new Error(`[database] Unsupported database type: ${type}`);
+    }
+    const db = new index_js_4.OpposerDatabase(driver, entities);
+    await db.connect();
+    return db;
+}
+async function ensureManager(db, settings, models) {
+    if (!settings.auth)
+        return;
+    try {
+        const allModels = await index_js_2.default.getAllModels(models);
+        const userEntity = allModels.find((x) => x.name === 'User' || x.name === 'usr');
+        const roleEntity = allModels.find((x) => x.name === 'Role' || x.name === 'rl');
+        if (userEntity && roleEntity) {
+            const userRepository = db.getRepository(userEntity.entity);
+            const roleRepository = db.getRepository(roleEntity.entity);
+            let login = process.env.MANAGER_LOGIN || settings.manager?.login;
+            let firstName = process.env.MANAGER_FIRST_NAME || settings.manager?.firstName;
+            let lastName = process.env.MANAGER_LAST_NAME || settings.manager?.lastName;
+            let password = process.env.MANAGER_PASSWORD || settings.manager?.password;
+            let manager = await userRepository.findOne({
+                where: { lg: login },
+            });
+            if (!manager) {
+                console.log('-> Creating manager account.');
+                manager = await userRepository.insert({
+                    fn: firstName,
+                    ln: lastName,
+                    lg: login,
+                    ps: password,
+                    ac: true,
+                });
+            }
+            const hasAllRole = await roleRepository.findOne({
+                where: { usr: manager.id, sm: 'all', mt: 'all' },
+            });
+            if (!hasAllRole) {
+                console.log('-> Creating all-access role for manager.');
+                await roleRepository.insert({
+                    usr: manager.id,
+                    sm: 'all',
+                    mt: 'all',
+                });
+            }
+        }
+    }
+    catch (error) {
+        console.error('[database] Manager creation failed:', error);
+    }
+}
+async function Server(props) {
+    console.log('-> Initializing database connection.');
+    const settings = index_js_2.default.getSettingsFile();
+    if (!settings.database) {
+        throw new Error('-> It is necessary to inform database properties.');
+    }
+    const db = await initializeDatabase(settings.database, props.models);
+    await ensureManager(db, settings, props.models);
+    // Store database in server context
+    index_js_6.default.set('db', db);
+    index_js_6.default.set('models', props.models);
+    index_js_6.default.set('controllers', props.controllers);
+    console.log('-> Initializing scheduler.');
+    await index_js_3.default.initialize(props.schedules);
+    index_js_3.default.start();
+    console.log('-> Initializing core server.');
+    let url = '/opposer';
+    if (settings.url) {
+        url = settings.url;
+    }
+    // 1. Logger
+    if (settings.logger) {
+        index_js_5.default.use((0, logger_js_1.default)());
+    }
+    // 2. CORS (Global)
+    if (props.cors || settings.cors) {
+        index_js_5.default.use((0, cors_js_1.default)(props.cors || settings.cors));
+    }
+    // 3. Body Parser
+    index_js_5.default.use((0, body_parser_js_1.default)());
+    // 4. Playground
+    index_js_5.default.use(index_js_7.default);
+    // 5. Auth/Security Middlewares
+    if (settings.auth) {
+        index_js_5.default.use(autorization_js_1.default);
+        index_js_5.default.use(permission_js_1.default);
+    }
+    // 6. Main Route Handler
+    index_js_5.default.use(async (req, res, next) => {
+        if (req.url === url && req.method === 'POST') {
+            await (0, index_js_1.default)(req, res);
+        }
+        else {
+            next();
+        }
+    });
+    // 7. 404 Handler
+    index_js_5.default.use((req, res) => {
+        res.status(404).json({ message: `Route ${req.method} ${req.url} not found` });
+    });
+    function initialize() {
+        index_js_5.default.listen(settings.port, () => {
+            console.log(`⚡Opposer Core is running in port ${settings.port}`);
+        });
+    }
+    return {
+        opposer: index_js_5.default,
+        initialize,
+    };
+}
+exports.auth = { social: auth_js_1.default.social };
+__exportStar(require("./constants/index.js"), exports);
+__exportStar(require("./helpers/index.js"), exports);
+var index_js_8 = require("./decorators/index.js");
+Object.defineProperty(exports, "Method", { enumerable: true, get: function () { return index_js_8.Method; } });
+Object.defineProperty(exports, "Controller", { enumerable: true, get: function () { return index_js_8.Controller; } });
+Object.defineProperty(exports, "Field", { enumerable: true, get: function () { return index_js_8.Field; } });
+Object.defineProperty(exports, "Payload", { enumerable: true, get: function () { return index_js_8.Payload; } });
+Object.defineProperty(exports, "IsPublic", { enumerable: true, get: function () { return index_js_8.IsPublic; } });
+Object.defineProperty(exports, "IsPublicMethod", { enumerable: true, get: function () { return index_js_8.IsPublicMethod; } });
+Object.defineProperty(exports, "f", { enumerable: true, get: function () { return index_js_8.f; } });
+var index_js_9 = require("./context/index.js");
+Object.defineProperty(exports, "Context", { enumerable: true, get: function () { return __importDefault(index_js_9).default; } });

package/lib/cjs/server/security/controller/auth.d.ts

@@ -0,0 +1,76 @@
+import { PayloadAuthChangePassword, PayloadAuthForgetPassword, PayloadAuthLogin, PayloadAuthRegister, PayloadSocialLogin } from '../../../interfaces/security.js';
+import { PayloadRequest } from '../../../interfaces/controller.js';
+export default class Auth {
+    private get db();
+    register(payload: PayloadRequest<PayloadAuthRegister>): Promise<{
+        readonly success: true;
+        readonly data: any;
+    } | {
+        readonly success: false;
+        readonly error: {
+            name: string;
+            code: number;
+            message: any;
+        };
+    }>;
+    login(payload: PayloadRequest<PayloadAuthLogin>): Promise<{
+        readonly success: true;
+        readonly data: any;
+    } | {
+        readonly success: false;
+        readonly error: {
+            name: string;
+            code: number;
+            message: any;
+        };
+    }>;
+    refresh(payload: PayloadRequest<string>): Promise<{
+        readonly success: true;
+        readonly data: any;
+    } | {
+        readonly success: false;
+        readonly error: {
+            name: string;
+            code: number;
+            message: any;
+        };
+    }>;
+    logout(payload: PayloadRequest<string>): Promise<{
+        readonly success: false;
+        readonly error: {
+            name: string;
+            code: number;
+            message: any;
+        };
+    } | undefined>;
+    me(payload: PayloadRequest<any>): Promise<{
+        readonly success: true;
+        readonly data: any;
+    } | null>;
+    changePassword(payload: PayloadRequest<PayloadAuthChangePassword>): Promise<{
+        readonly success: true;
+        readonly data: any;
+    } | {
+        readonly success: false;
+        readonly error: {
+            name: string;
+            code: number;
+            message: any;
+        };
+    }>;
+    forgotPassword(payload: PayloadRequest<PayloadAuthForgetPassword>): Promise<{
+        readonly success: true;
+        readonly data: any;
+    } | {
+        readonly success: false;
+        readonly error: {
+            name: string;
+            code: number;
+            message: any;
+        };
+    }>;
+    static social(payload: PayloadRequest<PayloadSocialLogin>): Promise<{
+        readonly success: true;
+        readonly data: any;
+    }>;
+}

package/lib/cjs/server/security/controller/auth.js

@@ -0,0 +1,346 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_js_1 = require("../../decorators/index.js");
+const usr_js_1 = __importDefault(require("../models/usr.js"));
+const rl_js_1 = __importDefault(require("../models/rl.js"));
+const index_js_2 = require("../../helpers/index.js");
+const index_js_3 = require("../../constants/index.js");
+const index_js_4 = __importDefault(require("../jwt/index.js"));
+const se_js_1 = __importDefault(require("../models/se.js"));
+const crp_js_1 = __importDefault(require("../models/crp.js"));
+const index_js_5 = require("../../index.js");
+let Auth = class Auth {
+    get db() {
+        return index_js_5.Context.get('db');
+    }
+    async register(payload) {
+        var errors = (0, index_js_2.validateData)(usr_js_1.default, payload.data);
+        if (Object.keys(errors).length > 0) {
+            return (0, index_js_2.Exception)({
+                ...index_js_3.HttpStatus[400],
+                message: errors,
+            });
+        }
+        var userRepository = this.db.getRepository(usr_js_1.default);
+        if (await userRepository.findOne({ where: { lg: payload.data.lg } })) {
+            return (0, index_js_2.Exception)({
+                ...index_js_3.HttpStatus[400],
+                message: 'User with this login already exists.',
+            });
+        }
+        const result = await userRepository.insert(payload.data);
+        return (0, index_js_2.Success)(result);
+    }
+    async login(payload) {
+        if (!payload.data.lg) {
+            return (0, index_js_2.Exception)({
+                ...index_js_3.HttpStatus[400],
+                message: 'Login is required',
+            });
+        }
+        if (!payload.data.ps) {
+            return (0, index_js_2.Exception)({
+                ...index_js_3.HttpStatus[400],
+                message: 'Password is required',
+            });
+        }
+        var userRepository = this.db.getRepository(usr_js_1.default);
+        var sessionRepository = this.db.getRepository(se_js_1.default);
+        var usr = await userRepository.findOne({
+            where: { lg: payload.data.lg },
+        });
+        if (!usr) {
+            return (0, index_js_2.Exception)({
+                ...index_js_3.HttpStatus[400],
+                message: 'Invalid login or password, check the data and try again.',
+            });
+        }
+        if (!(await usr.comparePassword(payload.data.ps))) {
+            return (0, index_js_2.Exception)({
+                ...index_js_3.HttpStatus[400],
+                message: 'Invalid login or password, check the data and try again.',
+            });
+        }
+        var roleRepository = this.db.getRepository(rl_js_1.default);
+        var roles = await roleRepository.find({
+            where: { usr: usr.id },
+        });
+        var { token, refresh } = await index_js_4.default.sign({
+            fn: usr.fn,
+            id: usr.id,
+            lg: usr.lg,
+            ln: usr.ln,
+            exp: 0,
+            rl: roles.map(({ sm, mt }) => ({ sm, mt })),
+        });
+        // register new session init
+        await sessionRepository.insert({
+            ac: true,
+            ag: payload.headers.userAgent,
+            ip: payload.headers.ip,
+            loi: new Date(),
+            rt: refresh,
+            usr: usr.id,
+        });
+        const current = new Date();
+        payload.headers.cookies.set('access_token', token, {
+            httpOnly: true,
+            secure: true,
+            sameSite: 'none',
+            path: '/',
+            expires: new Date(current.getTime() + 15 * 60 * 1000), // 15 mim
+        });
+        payload.headers.cookies.set('refresh_token', refresh, {
+            httpOnly: true,
+            secure: true,
+            sameSite: 'none',
+            path: '/',
+            expires: new Date(current.getTime() + 15 * 24 * 60 * 60 * 1000), // 15 dias
+        });
+        return (0, index_js_2.Success)({
+            token,
+            refresh,
+            usr: {
+                id: usr.id,
+                fn: usr.fn,
+                ln: usr.ln,
+                lg: usr.lg,
+                rl: roles.map(({ sm, mt }) => ({ sm, mt })),
+            },
+        });
+    }
+    async refresh(payload) {
+        if (!payload.data) {
+            return (0, index_js_2.Exception)({
+                ...index_js_3.HttpStatus[400],
+                message: 'Refresh token is required.',
+            });
+        }
+        var sessionRepository = this.db.getRepository(se_js_1.default);
+        var last = await sessionRepository.findOne({
+            where: { rt: payload.data },
+        });
+        if (!last) {
+            return (0, index_js_2.Exception)({
+                ...index_js_3.HttpStatus[401],
+                message: "Don't find session.",
+            });
+        }
+        if (!last.ac) {
+            return (0, index_js_2.Exception)({
+                ...index_js_3.HttpStatus[401],
+                message: 'Refresh expired.',
+            });
+        }
+        var usr = await index_js_4.default.validate.refresh(payload.data);
+        if (!usr || typeof usr === 'string') {
+            return (0, index_js_2.Exception)({
+                ...index_js_3.HttpStatus[401],
+                message: 'Invalid token.',
+            });
+        }
+        //cancel last session and update in database;
+        await sessionRepository.update({ rt: last.rt }, {
+            ac: false,
+            lou: new Date(),
+        });
+        var { token, refresh } = await index_js_4.default.sign(usr);
+        await sessionRepository.insert({
+            ac: true,
+            ag: last.ag,
+            ip: last.ip,
+            loi: new Date(),
+            rt: refresh,
+            usr: usr.id,
+        });
+        const current = new Date();
+        payload.headers.cookies.set('access_token', token, {
+            httpOnly: true,
+            secure: true,
+            sameSite: 'none',
+            path: '/',
+            expires: new Date(current.getTime() + 15 * 60 * 1000), // 15 mim
+        });
+        payload.headers.cookies.set('refresh_token', refresh, {
+            httpOnly: true,
+            secure: true,
+            sameSite: 'none',
+            path: '/',
+            expires: new Date(current.getTime() + 15 * 24 * 60 * 60 * 1000), // 15 dias
+        });
+        return (0, index_js_2.Success)({
+            token,
+            refresh,
+            ...usr,
+        });
+    }
+    async logout(payload) {
+        const token = payload.data || payload.headers.cookies.data.refresh_token;
+        if (!token) {
+            return (0, index_js_2.Exception)({
+                ...index_js_3.HttpStatus[400],
+                message: 'Token is required for logout user.',
+            });
+        }
+        payload.headers.cookies.remove('access_token');
+        payload.headers.cookies.remove('refresh_token');
+        var sessionRepository = this.db.getRepository(se_js_1.default);
+        await sessionRepository.update({ rt: token }, {
+            ac: false,
+            lou: new Date(),
+        });
+    }
+    async me(payload) {
+        const token = payload.headers.cookies.data.refresh_token;
+        if (!token) {
+            return null;
+        }
+        var usr = await index_js_4.default.validate.refresh(token);
+        if (typeof usr === 'string') {
+            return null;
+        }
+        return (0, index_js_2.Success)(usr);
+    }
+    async changePassword(payload) {
+        var errors = (0, index_js_2.validateData)(usr_js_1.default, { ps: payload.data.ps });
+        if (Object.keys(errors).length > 0) {
+            return (0, index_js_2.Exception)({
+                ...index_js_3.HttpStatus[400],
+                message: errors,
+            });
+        }
+        if (!payload.data.tk) {
+            return (0, index_js_2.Exception)({
+                ...index_js_3.HttpStatus[400],
+                message: 'Ticket is required for change password.',
+            });
+        }
+        var ticket = await index_js_4.default.validate.recover(payload.data.tk);
+        if (typeof ticket === 'string' || !ticket) {
+            return (0, index_js_2.Exception)({
+                ...index_js_3.HttpStatus[401],
+                message: 'Invalid token.',
+            });
+        }
+        var changePasswordRepository = this.db.getRepository(crp_js_1.default);
+        var userRepository = this.db.getRepository(usr_js_1.default);
+        var usr = await userRepository.findOne({
+            where: { lg: ticket.lg },
+        });
+        if (!usr) {
+            return (0, index_js_2.Exception)({
+                ...index_js_3.HttpStatus[401],
+                message: "Don't find user, verify payload and try again.",
+            });
+        }
+        // finaly update password...
+        await userRepository.update({ lg: ticket.lg }, { ps: payload.data.ps });
+        await changePasswordRepository.update({ tk: payload.data.tk }, {
+            ud: true,
+        });
+        return (0, index_js_2.Success)({ message: 'Success for change password.' });
+    }
+    async forgotPassword(payload) {
+        if (!payload.data.lg) {
+            return (0, index_js_2.Exception)({
+                ...index_js_3.HttpStatus[400],
+                message: 'Login is required.',
+            });
+        }
+        var { token } = await index_js_4.default.forget(payload.data);
+        var changePasswordRepository = this.db.getRepository(crp_js_1.default);
+        await changePasswordRepository.insert({
+            ...payload.data,
+            tk: token,
+            ex: new Date(new Date().getTime() + 5 * 60 * 1000), // five min
+        });
+        return (0, index_js_2.Success)({ token });
+    }
+    static async social(payload) {
+        const usr = payload.data;
+        const db = index_js_5.Context.get('db');
+        var sessionRepository = db.getRepository(se_js_1.default);
+        var { token, refresh } = await index_js_4.default.sign({
+            ...usr,
+            exp: 0,
+        });
+        // register new session init
+        await sessionRepository.insert({
+            ac: true,
+            ag: payload.headers.userAgent,
+            ip: payload.headers.ip,
+            loi: new Date(),
+            rt: refresh,
+            usr: usr.id,
+        });
+        return (0, index_js_2.Success)({
+            token,
+            refresh,
+            usr: {
+                id: usr.id,
+                fn: usr.fn,
+                ln: usr.ln,
+                lg: usr.lg,
+            },
+        });
+    }
+};
+__decorate([
+    (0, index_js_1.Method)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], Auth.prototype, "register", null);
+__decorate([
+    (0, index_js_1.Method)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], Auth.prototype, "login", null);
+__decorate([
+    (0, index_js_1.Method)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], Auth.prototype, "refresh", null);
+__decorate([
+    (0, index_js_1.Method)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], Auth.prototype, "logout", null);
+__decorate([
+    (0, index_js_1.Method)(),
+    (0, index_js_1.IsPublicMethod)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], Auth.prototype, "me", null);
+__decorate([
+    (0, index_js_1.Method)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], Auth.prototype, "changePassword", null);
+__decorate([
+    (0, index_js_1.Method)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], Auth.prototype, "forgotPassword", null);
+Auth = __decorate([
+    (0, index_js_1.Controller)('auth')
+], Auth);
+exports.default = Auth;

package/lib/cjs/server/security/index.d.ts

@@ -0,0 +1,2 @@
+export { default as User } from "./models/usr.js";
+export { default as Role } from "./models/rl.js";

package/lib/cjs/server/security/index.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.Role = exports.User = void 0;
+var usr_js_1 = require("./models/usr.js");
+Object.defineProperty(exports, "User", { enumerable: true, get: function () { return __importDefault(usr_js_1).default; } });
+var rl_js_1 = require("./models/rl.js");
+Object.defineProperty(exports, "Role", { enumerable: true, get: function () { return __importDefault(rl_js_1).default; } });

package/lib/cjs/server/security/jwt/index.d.ts

@@ -0,0 +1,23 @@
+import { ForgetJwt, SignJwt } from "../../../interfaces/jwt.js";
+declare function access(token: string): Promise<string | SignJwt | undefined>;
+declare function refresh(token: string): Promise<string | SignJwt | undefined>;
+declare function sign({ exp, ...payload }: SignJwt): Promise<{
+    token: any;
+    refresh: any;
+}>;
+declare function forget(payload: ForgetJwt): Promise<{
+    token: any;
+}>;
+declare function recover(token: string): Promise<string | ForgetJwt | undefined>;
+declare function verify(token: string): Promise<string | true | undefined>;
+declare const _default: {
+    verify: typeof verify;
+    sign: typeof sign;
+    forget: typeof forget;
+    validate: {
+        access: typeof access;
+        refresh: typeof refresh;
+        recover: typeof recover;
+    };
+};
+export default _default;