@authxyz/core/dist/middleware.js

Authxyz core package for authentication implementations and providers.

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());
    });
};
import jwt from "jsonwebtoken";
import { cookieName } from "./sign.js";
import { errorFormatter, jwtError } from "./errors.js";
function middlewareProtect(roles, secret, adapter, validationMethod) {
    const useAuthorization = middlewareValidateAuthorization({
        secret: secret,
        method: validationMethod,
    });
    return (req, res, next) => __awaiter(this, void 0, void 0, function* () {
        const isAuthenticated = yield useAuthorization(req, res, next);
        if (isAuthenticated.status !== "error" && isAuthenticated.status) {
            const user = yield adapter.getUser({ id: isAuthenticated.data.id });
            res["id"] = isAuthenticated.data.id;
            res["user"] = user;
            if (roles.includes(user === null || user === void 0 ? void 0 : user.role)) {
                return {
                    data: null,
                    status: true,
                };
            }
            res.status(401).json({ message: "Unauthorized (Missing permission)" });
            return {
                data: null,
                status: false,
            };
        }
    });
}
function middlewareValidateAuthorization({ secret, method, }) {
    return (req, res, next) => __awaiter(this, void 0, void 0, function* () {
        var _a;
        switch (method) {
            case "JWT":
                const token = (_a = req.headers.authorization) === null || _a === void 0 ? void 0 : _a.split(" ")[1];
                if (!token) {
                    res.status(401).json({ message: "Invalid Auth token" });
                    return {
                        data: null,
                        status: false,
                    };
                }
                const isValid = jwt.verify(token, secret);
                if (typeof isValid === "object") {
                    return {
                        data: {
                            id: isValid === null || isValid === void 0 ? void 0 : isValid.id,
                        },
                        status: true,
                    };
                }
                res.status(401).json({ message: "Invalid Auth token" });
                return {
                    data: null,
                    status: false,
                };
            case "COOKIE":
                const cookieInfo = req.signedCookies[cookieName];
                if (!cookieInfo) {
                    res.status(401).json({ message: "Invalid Auth token" });
                    return {
                        data: null,
                        status: false,
                    };
                }
                return {
                    data: { id: cookieInfo === null || cookieInfo === void 0 ? void 0 : cookieInfo.id },
                    status: true,
                };
        }
    });
}
function useProtect(roles, { secret, adapter, validationMethod }) {
    const useProtected = middlewareProtect(roles, secret, adapter, validationMethod);
    return (req, res, next) => __awaiter(this, void 0, void 0, function* () {
        try {
            const isAuthenticated = yield useProtected(req, res, next);
            if (isAuthenticated.status) {
                next();
            }
        }
        catch (error) {
            const response = errorFormatter(error, [jwtError]);
            res.status(response.status).json(response);
        }
    });
}
export { middlewareValidateAuthorization, middlewareProtect, useProtect };