@zenofolio/hyper-decor 1.0.4 → 1.0.7

package/dist/__internals/helpers/prepare.helper.js

@@ -0,0 +1,348 @@
+"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.prepareApplication = prepareApplication;
+const hyper_express_1 = require("hyper-express");
+const stores_1 = require("../../stores");
+const role_transform_1 = __importDefault(require("../transform/role.transform"));
+const scope_transfrom_1 = __importDefault(require("../transform/scope.transfrom"));
+const object_util_1 = require("../utils/object.util");
+const decorator_base_1 = require("../decorator-base");
+const constants_1 = require("../constants");
+const middleware_transform_1 = __importDefault(require("../transform/middleware.transform"));
+const tsyringe_1 = require("tsyringe");
+const path_util_1 = require("../utils/path.util");
+const imports_helper_1 = require("./imports.helper");
+const message_bus_1 = require("../../common/message-bus");
+const transport_1 = require("../../common/transport");
+const transform_registry_1 = require("../transform/transform.registry");
+const if_router = (current) => {
+    if (!current || !((current === null || current === void 0 ? void 0 : current.prototype) instanceof hyper_express_1.Router))
+        return new hyper_express_1.Router();
+    return new current();
+};
+/**
+ * Extract the data from the target class.
+ *
+ * @param target
+ * @returns
+ */
+function getData(target) {
+    var _a, _b, _c, _d, _e;
+    const app = (0, decorator_base_1.getDecorData)(constants_1.KEY_PARAMS_APP, target);
+    const module = (0, decorator_base_1.getDecorData)(constants_1.KEY_PARAMS_MODULE, target);
+    const controller = (0, decorator_base_1.getDecorData)(constants_1.KEY_TYPE_CONTROLLER, target);
+    const middlewares = (0, middleware_transform_1.default)((_a = (0, decorator_base_1.getDecorData)(constants_1.KEY_PARAMS_MIDDLEWARES, target)) !== null && _a !== void 0 ? _a : []);
+    const scopes = (_b = (0, decorator_base_1.getDecorData)(constants_1.KEY_PARAMS_SCOPE, target)) !== null && _b !== void 0 ? _b : [];
+    const roles = (_c = (0, decorator_base_1.getDecorData)(constants_1.KEY_PARAMS_ROLE, target)) !== null && _c !== void 0 ? _c : [];
+    const routes = (_d = (0, decorator_base_1.getDecorData)(constants_1.KEY_PARAMS_ROUTE, target)) !== null && _d !== void 0 ? _d : {
+        routes: [],
+    };
+    const params = (_e = (0, decorator_base_1.getDecorData)(constants_1.KEY_PARAMS_PARAM, target)) !== null && _e !== void 0 ? _e : {};
+    const pass = (0, decorator_base_1.getDecorData)(constants_1.KEY_PARAMS_PASS, target);
+    return {
+        app,
+        module,
+        controller,
+        middlewares,
+        scopes,
+        roles,
+        routes,
+        params,
+        pass,
+    };
+}
+/**
+ * Prepare the application with the given options.
+ *
+ * @param options
+ * @param Target
+ * @param app
+ * @param log
+ */
+function prepareApplication(options, Target, app, log) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c;
+        const data = getData(Target);
+        const prefix = (_a = options.prefix) !== null && _a !== void 0 ? _a : "/";
+        const imports = (_b = options.imports) !== null && _b !== void 0 ? _b : [];
+        // Register transports if provided, otherwise fallback to internal
+        const bus = tsyringe_1.container.resolve(message_bus_1.MessageBus);
+        if ((_c = options === null || options === void 0 ? void 0 : options.transports) === null || _c === void 0 ? void 0 : _c.length) {
+            options.transports.forEach((t) => bus.registerTransport(t));
+        }
+        else {
+            bus.registerTransport(new transport_1.InternalTransport());
+        }
+        let hooks = options.hooks;
+        if (typeof hooks === "function" && !(hooks instanceof hyper_express_1.Router)) {
+            if (hooks && "constructor" in hooks) {
+                if (tsyringe_1.container.isRegistered(hooks)) {
+                    tsyringe_1.container.register(hooks, hooks);
+                }
+            }
+            hooks = tsyringe_1.container.resolve(hooks);
+        }
+        const context = { target: Target, metadata: options, type: "app" };
+        yield (0, imports_helper_1.prepareImports)(Target, imports, hooks, context);
+        if (data.middlewares.length) {
+            app.use(...data.middlewares);
+            log("middleware", `${Target.name} with middlewares: ${data.middlewares
+                .map((e) => e.name)
+                .join(", ")}`);
+        }
+        (0, scope_transfrom_1.default)(data.scopes, (middleware, scopes) => {
+            stores_1.ScopeStore.addAll(scopes);
+            app.use(middleware);
+            log("middleware", `${Target.name} with scopes: ${data.scopes.join(", ")}`);
+        });
+        (0, role_transform_1.default)(data.roles, (middleware) => {
+            app.use(middleware);
+            log("middleware", `${Target.name} with roles: ${data.roles.join(", ")}`);
+        });
+        const routers = (yield Promise.all(options.modules.map((module) => __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            const data = getData(module);
+            const path = (_a = data.module) === null || _a === void 0 ? void 0 : _a.path;
+            const imports = (_c = (_b = data.module) === null || _b === void 0 ? void 0 : _b.imports) !== null && _c !== void 0 ? _c : [];
+            return prepareTarget({
+                target: module,
+                router: if_router(module),
+                namespace: `${Target.name}/${module.name}`,
+                instance: app,
+                prefix: path,
+                imports: imports,
+                log,
+                hooks: hooks,
+            });
+        })))).filter((r) => r.router);
+        routers.forEach(({ router, path }) => {
+            app.use((0, path_util_1.join)(prefix, path || "/"), router);
+        });
+    });
+}
+/**
+ * Prepare the target class
+ * HyperModule or HyperController can be used as target.
+ *
+ * @param param0
+ * @returns
+ */
+function prepareTarget(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ target, router, prefix, namespace = "", instance, imports = [], log, hooks, }) {
+        var _b, _c, _d, _e, _f, _g, _h, _j;
+        const data = getData(target);
+        if (data.module) {
+            log("modules", `${namespace} { ${prefix || "/"} }`);
+        }
+        else if (data.controller) {
+            log("controllers", `${namespace} { ${prefix || "/"} }`);
+        }
+        const modules = (_c = (_b = data.module) === null || _b === void 0 ? void 0 : _b.modules) !== null && _c !== void 0 ? _c : [];
+        const controllers = (_e = (_d = data.module) === null || _d === void 0 ? void 0 : _d.controllers) !== null && _e !== void 0 ? _e : [];
+        const routes = (_f = data.routes) !== null && _f !== void 0 ? _f : { routes: [] };
+        const middlewares = (_g = data.middlewares) !== null && _g !== void 0 ? _g : [];
+        const scopes = (_h = data.scopes) !== null && _h !== void 0 ? _h : [];
+        const roles = (_j = data.roles) !== null && _j !== void 0 ? _j : [];
+        const needsRouter = controllers.length > 0 ||
+            routes.routes.size > 0 ||
+            middlewares.length > 0 ||
+            scopes.length > 0 ||
+            roles.length > 0;
+        const _router = router !== null && router !== void 0 ? router : (needsRouter ? if_router(target) : undefined);
+        ////////////////////////////////
+        /// Prepare Imports
+        ////////////////////////////////
+        const context = { target: target, metadata: data, type: "target" };
+        yield (0, imports_helper_1.prepareImports)(target, imports, hooks, context);
+        ////////////////////////////////
+        /// Attach Middlewares & Security
+        ////////////////////////////////
+        if (_router) {
+            _router.use(...middlewares);
+            (0, scope_transfrom_1.default)(scopes, (middleware, scopes) => {
+                stores_1.ScopeStore.addAll(scopes);
+                _router.use(middleware);
+            });
+            (0, role_transform_1.default)(roles, (middleware) => _router.use(middleware));
+        }
+        ////////////////////////////////
+        /// Prepare Modules
+        ////////////////////////////////
+        yield (0, object_util_1.$each)(modules, (module) => __awaiter(this, void 0, void 0, function* () {
+            const moduleData = getData(module);
+            if (!moduleData.module)
+                return;
+            const res = yield prepareTarget({
+                target: module,
+                imports: moduleData.module.imports,
+                namespace: `${namespace}/${module.name}`,
+                prefix: moduleData.module.path,
+                instance: tsyringe_1.container.resolve(module),
+                log,
+                hooks,
+            });
+            if (res.router && _router) {
+                _router.use(res.path || "/", res.router);
+            }
+        }));
+        // ////////////////////////////////
+        // /// Prepare Controllers
+        // ////////////////////////////////
+        yield (0, object_util_1.$each)(controllers, (controller) => __awaiter(this, void 0, void 0, function* () {
+            const data = getData(controller);
+            const controllerData = data.controller;
+            if (!controllerData)
+                return;
+            const res = yield prepareTarget({
+                target: controller,
+                namespace: `${namespace}/${controller.name}`,
+                prefix: controllerData.path,
+                imports: controllerData.imports,
+                instance: tsyringe_1.container.resolve(controller),
+                log,
+                hooks,
+            });
+            if (res.router && _router) {
+                _router.use(res.path || "/", res.router);
+            }
+        }));
+        ////////////////////////////////
+        /// Prepare Routes
+        ////////////////////////////////
+        if (_router) {
+            yield (0, object_util_1.$each)(Array.from(routes.routes), (route) => __awaiter(this, void 0, void 0, function* () {
+                if (typeof route !== "object")
+                    return;
+                yield prepareRoutes({
+                    target: target,
+                    router: _router,
+                    route,
+                    namespace,
+                    instance,
+                    prefix: prefix || "/",
+                    log,
+                });
+            }));
+        }
+        return {
+            router: _router,
+            path: prefix,
+        };
+    });
+}
+/**
+ * Resolves method parameters and applies adaptive transformations.
+ * Optimized: Metadata is resolved once and passed here.
+ */
+function resolveMethodParams(req, res, params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const len = params.length;
+        const args = new Array(len);
+        for (let i = 0; i < len; i++) {
+            const param = params[i];
+            let val = yield param.resolver(req, res);
+            if (param.schema) {
+                val = yield transform_registry_1.transformRegistry.resolve({
+                    data: val,
+                    schema: param.schema,
+                    options: { isWholeSource: param.isWholeSource },
+                    req,
+                    res,
+                    from: param.key,
+                });
+            }
+            args[i] = val;
+        }
+        return args;
+    });
+}
+/**
+ * Handles output transformation and sends the response.
+ * Optimized: outputSchema is pre-resolved outside the request hotpath.
+ */
+function handleResponse(req, res, result, outputSchema) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (result === undefined || res.completed)
+            return;
+        if (outputSchema && outputSchema !== Object && outputSchema !== Promise) {
+            const transformed = yield transform_registry_1.transformRegistry.resolve({
+                data: result,
+                schema: outputSchema,
+                options: {},
+                req,
+                res,
+                from: "response",
+            });
+            if (transformed !== undefined && !res.completed) {
+                res.json(transformed);
+                return;
+            }
+        }
+        if (!res.completed) {
+            if (typeof result === "object" && result !== null) {
+                res.json(result);
+            }
+            else {
+                res.send(result);
+            }
+        }
+    });
+}
+/**
+ * Prepare the routes for the target class.
+ */
+function prepareRoutes(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ target, router, route, instance, namespace, log, }) {
+        var _b, _c, _d;
+        const { method, path, handler, propertyKey, options } = route;
+        const metadata = getData(handler);
+        const params = (_d = (_c = (_b = metadata.params) === null || _b === void 0 ? void 0 : _b.params) === null || _c === void 0 ? void 0 : _c[propertyKey]) !== null && _d !== void 0 ? _d : [];
+        const $fn = Reflect.get(router, method);
+        if (!$fn)
+            return;
+        const middlewares = [...metadata.middlewares];
+        const proto = target.prototype || target;
+        // Pre-resolve Output-Metadata
+        const outputSchema = Reflect.getMetadata(constants_1.KEY_OUTPUT_SCHEMA, proto, propertyKey) ||
+            Reflect.getMetadata(constants_1.DESIGN_RETURNTYPE, proto, propertyKey);
+        (0, role_transform_1.default)(metadata.roles, (middleware) => middlewares.push(middleware));
+        (0, scope_transfrom_1.default)(metadata.scopes, (middleware, scopes) => {
+            middlewares.push(middleware);
+            stores_1.ScopeStore.addAll(scopes);
+        });
+        log("routes", `${namespace}/${propertyKey.toString()} ${method.toUpperCase()} { ${path} }`);
+        const routeHandler = (req, res) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const args = params.length > 0
+                    ? yield resolveMethodParams(req, res, params)
+                    : [req, res];
+                const result = yield handler.apply(instance, args);
+                yield handleResponse(req, res, result, outputSchema);
+            }
+            catch (err) {
+                if (!res.completed) {
+                    res.status(500).json({
+                        error: err.message || "Internal Server Error",
+                    });
+                }
+            }
+        });
+        if (method === "ws" && options) {
+            router.ws(path, options, handler.bind(instance));
+            return;
+        }
+        $fn.call(router, path, ...middlewares, routeHandler);
+    });
+}

package/dist/__internals/helpers/tree.helper.d.ts

@@ -0,0 +1,36 @@
+import { HyperAppMetadata, HyperModuleMetadata, HyperControllerMetadata, RouteMetadata } from "../../decorators/types";
+export interface AppTree {
+    app: HyperAppMetadata & {
+        target: any;
+        fullPath: string;
+    };
+    modules: Record<string, ModuleNode>;
+    paths: Record<string, RouteNode[]>;
+    openapi?: any;
+}
+export interface ModuleNode {
+    metadata: HyperModuleMetadata;
+    target: any;
+    fullPath: string;
+    modules: Record<string, ModuleNode>;
+    controllers: Record<string, ControllerNode>;
+    services: any[];
+    openapi?: any;
+}
+export interface ControllerNode {
+    metadata: HyperControllerMetadata;
+    target: any;
+    fullPath: string;
+    routes: RouteNode[];
+    services: any[];
+    openapi?: any;
+}
+export interface RouteNode extends RouteMetadata {
+    fullPath: string;
+    params: any[];
+    openapi?: any;
+}
+/**
+ * Extracts the complete application metadata tree.
+ */
+export declare function getAppTree(Target: any): AppTree;

package/dist/__internals/helpers/tree.helper.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAppTree = getAppTree;
+const decorator_base_1 = require("../decorator-base");
+const constants_1 = require("../constants");
+const path_util_1 = require("../utils/path.util");
+const class_collector_1 = require("../../lib/openapi/collectors/class.collector");
+const metadata_registry_1 = require("../../lib/openapi/metadata.registry");
+/**
+ * Extracts the complete application metadata tree.
+ */
+function getAppTree(Target) {
+    const appMetadata = (0, decorator_base_1.getDecorData)(constants_1.KEY_PARAMS_APP, Target);
+    const prefix = (appMetadata === null || appMetadata === void 0 ? void 0 : appMetadata.prefix) || "/";
+    const tree = {
+        app: Object.assign(Object.assign({}, appMetadata), { target: Target, fullPath: prefix }),
+        modules: {},
+        paths: {}
+    };
+    ((appMetadata === null || appMetadata === void 0 ? void 0 : appMetadata.modules) || []).forEach(m => {
+        const node = getModuleNode(m, prefix, tree.paths);
+        tree.modules[m.name] = node;
+    });
+    // Apply tree processors
+    metadata_registry_1.openApiRegistry.getProcessors().forEach(processor => processor(tree));
+    return tree;
+}
+function getModuleNode(Target, parentPath = "", globalPaths = {}) {
+    const metadata = (0, decorator_base_1.getDecorData)(constants_1.KEY_PARAMS_MODULE, Target);
+    const currentPath = (0, path_util_1.join)(parentPath, (metadata === null || metadata === void 0 ? void 0 : metadata.path) || "");
+    const openapi = (0, class_collector_1.collectClassMetadata)(Target);
+    const node = {
+        metadata,
+        target: Target,
+        fullPath: currentPath,
+        modules: {},
+        controllers: {},
+        services: ((metadata === null || metadata === void 0 ? void 0 : metadata.imports) || []),
+        openapi
+    };
+    ((metadata === null || metadata === void 0 ? void 0 : metadata.modules) || []).forEach(m => {
+        node.modules[m.name] = getModuleNode(m, currentPath, globalPaths);
+    });
+    ((metadata === null || metadata === void 0 ? void 0 : metadata.controllers) || []).forEach(c => {
+        node.controllers[c.name] = getControllerNode(c, currentPath, globalPaths);
+    });
+    return node;
+}
+function getControllerNode(Target, parentPath = "", globalPaths = {}) {
+    var _a;
+    const metadata = (0, decorator_base_1.getDecorData)(constants_1.KEY_TYPE_CONTROLLER, Target);
+    const routeList = (0, decorator_base_1.getDecorData)(constants_1.KEY_PARAMS_ROUTE, Target);
+    // Param metadata can be on the constructor or the prototype
+    const paramMetadata = (_a = (0, decorator_base_1.getDecorData)(constants_1.KEY_PARAMS_PARAM, Target)) !== null && _a !== void 0 ? _a : (0, decorator_base_1.getDecorData)(constants_1.KEY_PARAMS_PARAM, Target.prototype);
+    const currentPath = (0, path_util_1.join)(parentPath, (metadata === null || metadata === void 0 ? void 0 : metadata.path) || "");
+    const openapi = (0, class_collector_1.collectClassMetadata)(Target);
+    const routes = Array.from((routeList === null || routeList === void 0 ? void 0 : routeList.routes) || []).map((route) => {
+        var _a, _b, _c, _d, _e, _f;
+        // Also try to get params from the handler itself if not in aggregated metadata
+        const params = (_e = (_b = (_a = paramMetadata === null || paramMetadata === void 0 ? void 0 : paramMetadata.params) === null || _a === void 0 ? void 0 : _a[route.propertyKey]) !== null && _b !== void 0 ? _b : (_d = (_c = (0, decorator_base_1.getDecorData)(constants_1.KEY_PARAMS_PARAM, route.handler)) === null || _c === void 0 ? void 0 : _c.params) === null || _d === void 0 ? void 0 : _d[route.propertyKey]) !== null && _e !== void 0 ? _e : [];
+        const fullPath = (0, path_util_1.join)(currentPath, route.path);
+        // Get OpenAPI metadata for the method
+        const methodOpenApi = ((_f = openapi.methods) === null || _f === void 0 ? void 0 : _f[route.propertyKey]) || {};
+        const routeNode = Object.assign(Object.assign({}, route), { fullPath,
+            params, openapi: methodOpenApi });
+        // Add to global paths map
+        if (!globalPaths[fullPath]) {
+            globalPaths[fullPath] = [];
+        }
+        globalPaths[fullPath].push(routeNode);
+        return routeNode;
+    });
+    return {
+        metadata,
+        target: Target,
+        fullPath: currentPath,
+        routes,
+        services: (metadata === null || metadata === void 0 ? void 0 : metadata.imports) || [],
+        openapi
+    };
+}

package/dist/__internals/stores/service.store.d.ts

@@ -0,0 +1 @@
+export declare const serviceStore: Set<any>;

package/dist/__internals/{transform/pass.transfrom.js → stores/service.store.js}

@@ -1,2 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.serviceStore = void 0;
+exports.serviceStore = new Set();

package/dist/__internals/transform/middleware.transform.d.ts

@@ -0,0 +1,3 @@
+import { MiddlewareHandler } from "hyper-express";
+import { MiddlewareType } from "../../decorators";
+export default function middlewareTransformer(list: MiddlewareType[]): MiddlewareHandler[];

package/dist/__internals/transform/middleware.transform.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = middlewareTransformer;
+const tsyringe_1 = require("tsyringe");
+function middlewareTransformer(list) {
+    return list
+        .map((middleware) => {
+        if (isClass(middleware)) {
+            const instance = tsyringe_1.container.resolve(middleware);
+            return instance.handle.bind(instance);
+        }
+        if (typeof middleware === "function") {
+            return middleware;
+        }
+        return null;
+    })
+        .filter((middleware) => !!middleware);
+}
+const isClass = (fn) => typeof fn === "function" && `${fn}`.indexOf("class") === 0;

package/dist/__internals/transform/role.transform.js

@@ -3,16 +3,19 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = roleTransform;
 const exeptions_1 = require("../../exeptions");
 const helpers_1 = require("../../common/helpers");
+const constants_1 = require("../constants");
 function roleTransform(list, callback) {
     const { roles, names, isEmtpy } = resolveRoles(list);
     const middleware = (req, res, next) => {
-        // if scopes is empty, then we don't need to check for scopes
+        var _a;
         if (isEmtpy)
             return next();
-        // get the user scopes
-        const requestRoles = (0, helpers_1.getRoles)(req);
-        // find the first scope that is not in the userScopes
-        const role = roles.find((scope) => requestRoles === null || requestRoles === void 0 ? void 0 : requestRoles.includes(scope.role));
+        const requestRoles = (_a = (0, helpers_1.getRoles)(req)) !== null && _a !== void 0 ? _a : [];
+        if (requestRoles.length === 0 && isEmtpy)
+            return next();
+        if (requestRoles.includes(constants_1.FULL_ACCESS))
+            return next();
+        const role = roles.some((scope) => requestRoles.includes(scope.role));
         if (role) {
             return next();
         }

package/dist/__internals/transform/scope.transfrom.d.ts

@@ -1,7 +1,5 @@
-import { MiddlewareHandler } from "hyper-express";
-import { ScopeType } from "../../decorators";
-export default function scopeTransfrom(listScopes: ScopeType[], callback?: (middleware: MiddlewareHandler, scopes: {
-    scope: string;
-    description: string;
-    message: string | null;
-}[], names: Set<string>) => void): MiddlewareHandler;
+import { MiddlewareHandler } from "hyper-express/types";
+import { ScopeMap, ScopeType } from "../../decorators";
+type Callback = (middleware: MiddlewareHandler, scopes: ScopeMap[], names: Set<string>) => void;
+export default function scopeTransfrom(listScopes: ScopeType[], ...callback: Callback[]): MiddlewareHandler;
+export {};

package/dist/__internals/transform/scope.transfrom.js

@@ -3,24 +3,29 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = scopeTransfrom;
 const exeptions_1 = require("../../exeptions");
 const helpers_1 = require("../../common/helpers");
-function scopeTransfrom(listScopes, callback) {
-    const { scopes, scopeNames, isEmtpy } = resolveScopes(listScopes);
+const constants_1 = require("../constants");
+function scopeTransfrom(listScopes, ...callback) {
+    const { scopes, scopeNames, isEmpty } = resolveScopes(listScopes);
     const middleware = (req, res, next) => {
         var _a;
-        // if scopes is empty, then we don't need to check for scopes
-        if (isEmtpy)
+        if (isEmpty)
             return next();
-        // get the user scopes
-        const userScopes = (0, helpers_1.getScopes)(req);
-        // find the first scope that is not in the userScopes
-        const error = scopes.find((scope) => !(userScopes === null || userScopes === void 0 ? void 0 : userScopes.includes(scope.scope)));
-        if (error) {
-            return next(new exeptions_1.NotScopeException((_a = error.message) !== null && _a !== void 0 ? _a : `You don't have the required scopes to access this resource`, userScopes, Array.from(scopeNames)));
+        const userScopesRaw = (0, helpers_1.getScopes)(req);
+        if (!userScopesRaw || userScopesRaw.length === 0) {
+            return next(new exeptions_1.NotScopeException(`FORBIDDEN`, [], Array.from(scopeNames)));
+        }
+        if (userScopesRaw.includes(constants_1.FULL_ACCESS))
+            return next();
+        for (const scope of scopes) {
+            if (!userScopesRaw.includes(scope.scope)) {
+                return next(new exeptions_1.NotScopeException((_a = scope.message) !== null && _a !== void 0 ? _a : `FORBIDDEN`, userScopesRaw, Array.from(scopeNames)));
+            }
         }
         return next();
     };
-    if (scopeNames.size > 0 && callback) {
-        callback(middleware, scopes, scopeNames);
+    if (!isEmpty && callback.length > 0) {
+        for (const cb of callback)
+            cb(middleware, scopes, scopeNames);
     }
     return middleware;
 }
@@ -35,38 +40,47 @@ const resolveScopes = (scopes) => {
     var _a, _b;
     const $scopes = {};
     for (const scope of scopes) {
-        if (typeof scope === "string") {
-            $scopes[scope] = {
-                scope,
-                description: "",
-                message: null,
+        const list = parseScope(scope);
+        if (list.length === 0)
+            continue;
+        for (const s of list) {
+            $scopes[s.scope] = {
+                scope: s.scope,
+                description: (_a = s.description) !== null && _a !== void 0 ? _a : "",
+                message: (_b = s.message) !== null && _b !== void 0 ? _b : `You don't have the required scopes to access this resource`,
             };
         }
-        else if (Array.isArray(scope)) {
-            for (const s of scope) {
-                switch (typeof s) {
-                    case "string":
-                        $scopes[s] = {
-                            scope: s,
-                            description: "",
-                            message: null,
-                        };
-                        break;
-                    case "object":
-                        $scopes[s.scope] = {
-                            scope: s.scope,
-                            description: (_a = s.description) !== null && _a !== void 0 ? _a : "",
-                            message: (_b = s.message) !== null && _b !== void 0 ? _b : null,
-                        };
-                        break;
-                }
-            }
-        }
     }
     const values = Object.values($scopes);
     return {
         scopes: values,
         scopeNames: new Set(Object.keys($scopes)),
-        isEmtpy: values.length === 0,
+        isEmpty: values.length === 0,
     };
 };
+/**
+ * Parse the scope to a standard format
+ *
+ * @param scope
+ * @returns
+ */
+const parseScope = (scope) => {
+    switch (typeof scope) {
+        case "string":
+            return [
+                {
+                    scope,
+                    description: "",
+                },
+            ];
+        case "object":
+            if (Array.isArray(scope)) {
+                if (scope.length === 0)
+                    return [];
+                return scope.map((s) => parseScope(s)).flat();
+            }
+            else {
+                return [scope];
+            }
+    }
+};