@webda/core 4.0.0-beta.2 → 4.0.0-beta.4

package/lib/rest/router.service.js

@@ -0,0 +1,843 @@
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+import uriTemplates from "uri-templates";
+import { useApplication, useModelId } from "../application/hooks.js";
+import { Command } from "../services/command.js";
+import { useLog, useOutput } from "../loggers/hooks.js";
+import { useParameters } from "../application/hooks.js";
+import { useDynamicService } from "../core/hooks.js";
+import { deepmerge } from "deepmerge-ts";
+import { Service } from "../services/service.js";
+import { ServiceParameters } from "../services/serviceparameters.js";
+import { getMetadata } from "@webda/decorators";
+import { templateVariables } from "../templates/templates.js";
+import { emitCoreEvent, useCoreEvents } from "../events/events.js";
+import { useInstanceStorage } from "../core/instancestorage.js";
+import { FileUtils } from "@webda/utils";
+/** Parameters for the Router service */
+export class RouterParameters extends ServiceParameters {
+    /**
+     * Display a WARNING if a route is overriden
+     */
+    overrideWarning;
+}
+/**
+ * Manage Route resolution
+ * @category CoreFeatures
+ *
+ * @WebdaModda
+ */
+let Router = (() => {
+    let _classSuper = Service;
+    let _instanceExtraInitializers = [];
+    let _openapi_decorators;
+    return class Router extends _classSuper {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _openapi_decorators = [Command("openapi", { description: "Export the OpenAPI definition", requires: ["router", "rest-domain"] })];
+            __esDecorate(this, null, _openapi_decorators, { kind: "method", name: "openapi", static: false, private: false, access: { has: obj => "openapi" in obj, get: obj => obj.openapi }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        /**
+         * Routes
+         */
+        routes = (__runInitializers(this, _instanceExtraInitializers), new Map());
+        /**
+         *
+         */
+        pathMap;
+        models = new Map();
+        /**
+         * Request filters to apply
+         */
+        _requestFilters = [];
+        /**
+         * Request filters to apply for CORS
+         */
+        _requestCORSFilters = [];
+        /**
+         * Registration of a model
+         * @param model - the model to use
+         * @param url - the URL
+         */
+        registerModelUrl(model, url) {
+            this.models.set(model, url);
+        }
+        /**
+         * Resolve dependencies and wire up core lifecycle listeners.
+         *
+         * The Router pulls its inputs from events rather than being driven by
+         * `Core.init()` directly:
+         *  - `Webda.Init.Services` — scan every resolved service for
+         *    `@Route` metadata and filter capabilities.
+         *  - `Webda.Init` — finalize the URI template index after all routes
+         *    (dynamic or decorator-based) have been registered.
+         *
+         * @returns the result
+         */
+        resolve() {
+            // Register as the instance router
+            useInstanceStorage().router = this;
+            // Discover routes + filters once every service is resolved and initialized
+            useCoreEvents("Webda.Init.Services", services => {
+                const list = Object.values(services);
+                this.discoverFilters(list);
+                this.discoverRoutes(list);
+            });
+            // Remap route
+            useCoreEvents("Webda.Init", () => {
+                this.remapRoutes();
+            });
+            return super.resolve();
+        }
+        /**
+         * Return the route for model
+         * @param model - the model to use
+         * @returns the result
+         */
+        getModelUrl(model) {
+            if (typeof model !== "string") {
+                model = useModelId(model);
+            }
+            return this.models.get(model);
+        }
+        /**
+         * Include prefix to the url if not present
+         * @param url - the URL
+         * @returns the result string
+         */
+        getFinalUrl(url) {
+            // We have to replace all @ by %40 as it is allowed in url rfc (https://www.rfc-editor.org/rfc/rfc3986#page-22)
+            // But disallowed in https://www.rfc-editor.org/rfc/rfc6570#section-3.2.1
+            // Similar for / in query string
+            url = url.replace(/@/g, "%40");
+            if (url.includes("?")) {
+                url = url.substring(0, url.indexOf("?")) + "?" + url.substring(url.indexOf("?") + 1).replace(/\//g, "%2F");
+            }
+            const prefix = useParameters().routePrefix || "";
+            if (prefix && url.startsWith(prefix)) {
+                return url;
+            }
+            // Absolute url
+            if (url.startsWith("//")) {
+                return url.substring(1);
+            }
+            return `${prefix}${url}`;
+        }
+        /**
+         * Return routes
+         * @returns the result
+         */
+        getRoutes() {
+            return this.routes;
+        }
+        /**
+         * Add a route dynamicaly
+         *
+         * @param {String} url of the route can contains dynamic part like {uuid}
+         * @param {Object} info the type of executor
+         */
+        addRouteToRouter(url, info) {
+            const finalUrl = this.getFinalUrl(url);
+            useLog("TRACE", `Add route ${info.methods.join(",")} ${finalUrl}`);
+            info.openapi ??= {};
+            if (this.routes[finalUrl]) {
+                // If route is already added do not do anything
+                if (this.routes[finalUrl].includes(info)) {
+                    return;
+                }
+                // Check and add warning if same method is used
+                if (this.parameters.overrideWarning) {
+                    const methods = this.routes[finalUrl].map((r) => r.methods).flat();
+                    info.methods.forEach(m => {
+                        if (methods.indexOf(m) >= 0) {
+                            if (!info.override) {
+                                useLog("WARN", `${m} ${finalUrl} overlap with another defined route`);
+                            }
+                        }
+                    });
+                }
+                // Last added need to be overriding
+                this.routes[finalUrl].unshift(info);
+            }
+            else {
+                this.routes[finalUrl] = [info];
+            }
+            if (this.getState() === "running") {
+                this.remapRoutes();
+            }
+        }
+        /**
+         * Remove a route dynamicly
+         *
+         * @param {String} url to remove
+         * @param info - the information object
+         */
+        removeRoute(url, info = undefined) {
+            const finalUrl = this.getFinalUrl(url);
+            if (!info) {
+                delete this.routes[finalUrl];
+            }
+            else if (this.routes[finalUrl] && this.routes[finalUrl].includes(info)) {
+                this.routes[finalUrl].splice(this.routes[finalUrl].indexOf(info), 1);
+            }
+            this.remapRoutes();
+        }
+        /**
+         * Reinit all routes
+         *
+         * It will readd the URITemplates if needed
+         * Sort all routes again
+         */
+        remapRoutes() {
+            // Might need to ensure each routes is prefixed
+            const prefix = useParameters().routePrefix || "";
+            if (prefix) {
+                Object.keys(this.routes)
+                    .filter(k => !k.startsWith(prefix))
+                    .forEach(k => {
+                    this.routes[this.getFinalUrl(k)] = this.routes[k];
+                    delete this.routes[k];
+                });
+            }
+            this.initURITemplates(this.routes);
+            // Order path desc
+            this.pathMap = [];
+            for (const i in this.routes) {
+                // Might need to trail the query string
+                this.routes[i].forEach((config) => {
+                    this.pathMap.push({
+                        url: i,
+                        config
+                    });
+                });
+            }
+            this.pathMap.sort(this.comparePath);
+        }
+        /**
+         * Compare two route paths for sorting, prioritizing literal segments over parameters
+         * @param a - the first route
+         * @param b - the second route
+         * @returns the result number
+         */
+        comparePath(a, b) {
+            // Normal node works with localeCompare but not Lambda...
+            // Local compare { to a return: 26 on Lambda
+            const bs = b.url.replace(/\{[^{}]+}/, "{}").split("/");
+            const as = a.url.replace(/\{[^{}]+}/, "{}").split("/");
+            for (const i in as) {
+                if (bs[i] === undefined)
+                    return -1;
+                if (as[i] === bs[i])
+                    continue;
+                if (as[i][0] === "{" && bs[i][0] !== "{")
+                    return 1;
+                if (as[i][0] !== "{" && bs[i][0] === "{")
+                    return -1;
+                return bs[i] < as[i] ? -1 : 1;
+            }
+            return 1;
+        }
+        /**
+         * @hidden
+         * @param config - the configuration
+         */
+        initURITemplates(config) {
+            // Prepare tbe URI parser
+            for (const map in config) {
+                if (map.indexOf("{") !== -1) {
+                    config[map].forEach((e) => {
+                        const idx = map.indexOf("{?");
+                        let queryOptional = true;
+                        if (idx >= 0) {
+                            const query = map.substring(idx + 2, map.length - 1);
+                            e._queryParams = [];
+                            query.split(",").forEach(q => {
+                                if (q.endsWith("*")) {
+                                    e._queryCatchAll = q.substring(0, q.length - 1);
+                                    return;
+                                }
+                                else if (q.endsWith("+")) {
+                                    e._queryCatchAll = q.substring(0, q.length - 1);
+                                    queryOptional = false;
+                                    return;
+                                }
+                                else if (q.endsWith("?")) {
+                                    e._queryParams.push({ name: q.substring(0, q.length - 1), required: false });
+                                }
+                                else {
+                                    queryOptional = false;
+                                    e._queryParams.push({ name: q, required: true });
+                                }
+                            });
+                            // We do not use uri-templates for query parsing
+                            //map = map.substring(0, idx) + "?{+URITemplateQuery}";
+                            const templates = [uriTemplates(map.substring(0, idx) + "?{+URITemplateQuery}")];
+                            const pathTemplate = uriTemplates(map.substring(0, idx));
+                            if (queryOptional) {
+                                templates.push(pathTemplate);
+                            }
+                            e._uriTemplateParse = {
+                                fromUri: (url) => {
+                                    return templates.reduce((v, t) => (v ? v : t.fromUri(url)), undefined);
+                                },
+                                varNames: [...pathTemplate.varNames, ...e._queryParams.map(q => q.name)]
+                            };
+                        }
+                        else {
+                            e._uriTemplateParse = uriTemplates(map);
+                        }
+                    });
+                }
+            }
+        }
+        /**
+         * What a request URL is matched against for a route: a route declaring a
+         * query template (`{?q,page?}`, `{?rest*}`) matches the whole URL, any other
+         * route matches the path alone, so an extra query string (`?v=123`) neither
+         * prevents the match nor ends up in a path variable
+         * @param routeUrl - the route URL
+         * @param finalUrl - the request URL, from `getFinalUrl`
+         * @returns the URL to match
+         */
+        getMatchTarget(routeUrl, finalUrl) {
+            return routeUrl.includes("{?") ? finalUrl : finalUrl.split("?")[0];
+        }
+        /**
+         * Get all method for a specific url
+         * @param config - the configuration
+         * @param method - the HTTP method
+         * @param url - the URL
+         * @returns the list of results
+         */
+        getRouteMethodsFromUrl(url) {
+            const finalUrl = this.getFinalUrl(url);
+            const methods = new Set();
+            for (const i in this.pathMap) {
+                const routeUrl = this.pathMap[i].url;
+                const map = this.pathMap[i].config;
+                const target = this.getMatchTarget(routeUrl, finalUrl);
+                if (routeUrl !== target &&
+                    (map._uriTemplateParse === undefined || map._uriTemplateParse.fromUri(target, { strict: true }) === undefined)) {
+                    continue;
+                }
+                map.methods.forEach(m => methods.add(m));
+            }
+            return Array.from(methods);
+        }
+        /**
+         * Get the route from a method / url
+         * @param ctx - the operation context
+         * @param method - the HTTP method
+         * @param url - the URL
+         * @returns the result
+         */
+        getRouteFromUrl(ctx, method, url) {
+            const finalUrl = this.getFinalUrl(url);
+            // Search for the route
+            for (const i in this.pathMap) {
+                const routeUrl = this.pathMap[i].url;
+                const map = this.pathMap[i].config;
+                // Check method
+                if (map.methods.indexOf(method) === -1) {
+                    continue;
+                }
+                const target = this.getMatchTarget(routeUrl, finalUrl);
+                // If url is strictly equal
+                if (routeUrl === target) {
+                    return map;
+                }
+                // If the url
+                if (map._uriTemplateParse === undefined) {
+                    continue;
+                }
+                const parse_result = map._uriTemplateParse.fromUri(target, { strict: true });
+                if (parse_result !== undefined) {
+                    const parseUrl = new URL(`http://localhost${finalUrl}`);
+                    if (map._queryCatchAll) {
+                        parse_result[map._queryCatchAll] = {};
+                        parseUrl.searchParams.forEach((v, k) => {
+                            if (!map._queryParams?.find(q => q.name === k)) {
+                                parse_result[map._queryCatchAll][k] = v;
+                            }
+                        });
+                    }
+                    // Check for each params
+                    let mandatoryParams = true;
+                    map._queryParams?.forEach(q => {
+                        if (!parseUrl.searchParams.has(q.name)) {
+                            mandatoryParams &&= !q.required;
+                            return;
+                        }
+                        parse_result[q.name] = parseUrl.searchParams.get(q.name);
+                    });
+                    // Skip if we miss mandatory params
+                    if (!mandatoryParams) {
+                        continue;
+                    }
+                    if (parse_result.URITemplateQuery) {
+                        delete parse_result.URITemplateQuery;
+                    }
+                    ctx.setParameters(parse_result);
+                    return map;
+                }
+            }
+        }
+        /**
+         * Convert a schema name or object to an OpenAPI $ref or inline schema
+         * @param schema - the schema object
+         * @returns the result
+         */
+        getOpenAPISchema(schema) {
+            if (!schema) {
+                return {
+                    $ref: "#/components/schemas/Object"
+                };
+            }
+            else if (typeof schema === "string") {
+                return {
+                    $ref: "#/components/schemas/" + schema
+                };
+            }
+            return schema;
+        }
+        /**
+         * Add all known routes to paths
+         *
+         * @param openapi to complete
+         * @param skipHidden add hidden routes or not
+         */
+        completeOpenAPI(openapi, skipHidden = true) {
+            const hasTag = tag => openapi.tags.find(t => t.name === tag) !== undefined;
+            for (const i in this.routes) {
+                this.routes[i].forEach((route) => {
+                    route.openapi = templateVariables(route.openapi || {}, useDynamicService(route.executor).getOpenApiReplacements());
+                    if (route.openapi.hidden && skipHidden) {
+                        return;
+                    }
+                    route.openapi.hidden = false;
+                    let path = i;
+                    if (i.indexOf("{?") >= 0) {
+                        path = i.substring(0, i.indexOf("{?"));
+                    }
+                    openapi.paths[path] = openapi.paths[path] || {};
+                    if (route._uriTemplateParse) {
+                        openapi.paths[path].parameters = [];
+                        route._uriTemplateParse.varNames.forEach(varName => {
+                            const queryParam = route._queryParams?.find(i => i.name === varName);
+                            if (queryParam) {
+                                let name = varName;
+                                if (name.startsWith("*")) {
+                                    name = name.substr(1);
+                                }
+                                openapi.paths[path].parameters.push({
+                                    name,
+                                    in: "query",
+                                    required: queryParam.required,
+                                    schema: {
+                                        type: "string"
+                                    }
+                                });
+                                return;
+                            }
+                            openapi.paths[path].parameters.push({
+                                // ^[a-zA-Z0-9._$-]+$] is the official regex of AWS
+                                name: varName.replace(/[^a-zA-Z0-9._$-]/g, ""),
+                                in: "path",
+                                required: true,
+                                schema: {
+                                    type: "string"
+                                }
+                            });
+                        });
+                    }
+                    route.methods.forEach(method => {
+                        let responses;
+                        let schema;
+                        let description;
+                        let summary;
+                        let operationId;
+                        let requestBody;
+                        const tags = route.openapi.tags ?? [];
+                        // Refactor here
+                        if (route.openapi[method.toLowerCase()]) {
+                            responses = route.openapi[method.toLowerCase()].responses;
+                            schema = this.getOpenAPISchema(route.openapi[method.toLowerCase()].schemas?.output);
+                            description = route.openapi[method.toLowerCase()].description;
+                            summary = route.openapi[method.toLowerCase()].summary;
+                            operationId = route.openapi[method.toLowerCase()].operationId;
+                            tags.push(...(route.openapi[method.toLowerCase()].tags || []));
+                            requestBody = route.openapi[method.toLowerCase()].requestBody;
+                        }
+                        responses = responses || {
+                            200: {
+                                description: "Operation success"
+                            }
+                        };
+                        for (const j in responses) {
+                            // Add default answer
+                            const code = parseInt(j);
+                            if (code < 300 && code >= 200 && !responses[j].description) {
+                                responses[j].description = "Operation success";
+                                responses[j].content ??= {};
+                                responses[j].content["application/json"] = {
+                                    schema
+                                };
+                            }
+                        }
+                        // Add the service name if no tags are defined
+                        if (tags.length === 0) {
+                            tags.push(route.executor);
+                        }
+                        const desc = {
+                            tags,
+                            responses: responses,
+                            description,
+                            summary,
+                            operationId,
+                            requestBody
+                        };
+                        if (method.toLowerCase().startsWith("p") && route.openapi[method.toLowerCase()]?.schemas?.input) {
+                            // Add request schema if exist
+                            desc.requestBody ??= {
+                                content: {
+                                    "application/json": {
+                                        schema: this.getOpenAPISchema(route.openapi[method.toLowerCase()]?.schemas?.input)
+                                    }
+                                }
+                            };
+                        }
+                        openapi.paths[path][method.toLowerCase()] = desc;
+                        tags
+                            .filter(tag => !hasTag(tag))
+                            .forEach(tag => openapi.tags.push({
+                            name: tag
+                        }));
+                    });
+                });
+            }
+        }
+        /**
+         * Execute the matched route handler for a web context
+         * @param ctx - the operation context
+         */
+        async execute(ctx) {
+            const httpContext = ctx.getHttpContext();
+            const method = httpContext.getMethod();
+            // Routes are relative to the prefix (API Gateway stage, custom domain base path…)
+            const url = httpContext.getRelativeUri();
+            // Handle CORS preflight
+            if (method === "OPTIONS") {
+                const methods = this.getRouteMethodsFromUrl(url);
+                if (methods.length > 0 && (await this.checkCORSRequest(ctx))) {
+                    ctx.setHeader("Access-Control-Allow-Methods", methods.join(","));
+                    ctx.writeHead(204);
+                    return;
+                }
+                this.writeNotFound(ctx, method, url);
+                return;
+            }
+            const info = this.getRouteFromUrl(ctx, method, url);
+            if (!info) {
+                this.writeNotFound(ctx, method, url);
+                return;
+            }
+            // Check request filters (authentication, etc.)
+            if (!(await this.checkRequest(ctx))) {
+                ctx.writeHead(403);
+                return;
+            }
+            // Execute the route handler
+            if (typeof info._method === "function") {
+                await info._method(ctx);
+            }
+            else if (info._method && info.executor) {
+                const service = useDynamicService(info.executor);
+                if (service && typeof service[info._method] === "function") {
+                    await service[info._method](ctx);
+                }
+            }
+        }
+        /**
+         * Answer a request no route matches: 404 with the same error body a thrown
+         * `NotFound` gets, so clients don't receive an empty response
+         * @param ctx - the web context
+         * @param method - the HTTP method
+         * @param url - the requested URL
+         */
+        writeNotFound(ctx, method, url) {
+            emitCoreEvent("Webda.404", { context: ctx });
+            ctx.writeHead(404);
+            ctx.write({ error: { code: "NOT_FOUND", message: `No route for ${method} ${url}` } });
+        }
+        /**
+         * Verify if a request can be done
+         *
+         * @param context Context of the request
+         * @param ctx - the operation context
+         * @returns true if the condition is met
+         */
+        async checkRequest(ctx) {
+            // Do not need to filter on OPTIONS as CORS is for that
+            if (ctx.getHttpContext().getMethod() === "OPTIONS" || this._requestFilters.length === 0) {
+                return true;
+            }
+            return (await Promise.all(this._requestFilters.map(filter => filter.checkRequest(ctx, "AUTH")))).some(v => v);
+        }
+        /**
+         * Verify if an origin is allowed to do request on the API
+         *
+         * @param context Context of the request
+         * @param ctx - the operation context
+         * @returns true if the condition is met
+         */
+        async checkCORSRequest(ctx) {
+            return (await Promise.all(this._requestCORSFilters.map(filter => filter.checkRequest(ctx, "CORS")))).some(v => v);
+        }
+        /**
+         * Export the OpenAPI definition as JSON to stdout
+         * @param output - file path to write to (prints to stdout if omitted)
+         * @param includeHidden - include hidden routes in the output
+         */
+        openapi(
+        /** @alias o @description Output file path (stdout if omitted) */
+        output, 
+        /** @description Include hidden routes */
+        includeHidden) {
+            const doc = this.exportOpenAPI(!includeHidden);
+            const json = JSON.stringify(doc, undefined, 2);
+            if (output) {
+                FileUtils.save(doc, output);
+                useLog("INFO", `OpenAPI definition written to ${output}`);
+            }
+            else {
+                useOutput(json);
+            }
+        }
+        /**
+         * Export OpenAPI
+         * @param skipHidden - whether to skip hidden entries
+         * @returns the result
+         */
+        exportOpenAPI(skipHidden = true) {
+            const packageInfo = useApplication().getPackageDescription();
+            let contact;
+            if (typeof packageInfo.author === "string") {
+                contact = {
+                    name: packageInfo.author
+                };
+            }
+            else if (packageInfo.author) {
+                contact = packageInfo.author;
+            }
+            let license;
+            if (typeof packageInfo.license === "string") {
+                license = {
+                    name: packageInfo.license
+                };
+            }
+            else if (packageInfo.license) {
+                license = packageInfo.license;
+            }
+            const openapi = deepmerge({
+                openapi: "3.0.3",
+                info: {
+                    description: packageInfo.description,
+                    version: packageInfo.version || "0.0.0",
+                    title: packageInfo.title || "Webda-based application",
+                    termsOfService: packageInfo.termsOfService,
+                    contact,
+                    license
+                },
+                components: {
+                    schemas: {
+                        Object: {
+                            type: "object"
+                        }
+                    }
+                },
+                paths: {},
+                tags: []
+            }, useApplication().getCurrentConfiguration().openapi || {});
+            const app = useApplication();
+            const models = app.getModels();
+            const schemas = app.getSchemas();
+            // Copy all input/output from actions
+            for (const i in schemas) {
+                if (!(i.endsWith(".input") || i.endsWith(".output"))) {
+                    continue;
+                }
+                // @ts-ignore
+                openapi.components.schemas[i] ??= schemas[i];
+                // Not sure how to test following
+                /* c8 ignore next 5 */
+                for (const j in schemas[i].definitions) {
+                    // @ts-ignore
+                    openapi.components.schemas[j] ??= schemas[i].definitions[j];
+                }
+            }
+            for (const i in models) {
+                const model = models[i];
+                let desc = {
+                    type: "object"
+                };
+                const modelName = model.name || i.split("/").pop();
+                const schema = useApplication().getSchema(i);
+                if (schema) {
+                    for (const j in schema.definitions) {
+                        // @ts-ignore
+                        openapi.components.schemas[j] ??= schema.definitions[j];
+                    }
+                    delete schema.definitions;
+                    desc = schema;
+                }
+                // Remove empty required as openapi does not like that
+                // Our compiler is not generating this anymore but it is additional protection
+                /* c8 ignore next 3 */
+                if (desc.required && desc.required.length === 0) {
+                    delete desc.required;
+                }
+                // Remove $schema
+                delete desc.$schema;
+                // Rename all #/definitions/ by #/components/schemas/
+                openapi.components.schemas[modelName] = JSON.parse(JSON.stringify(desc).replace(/#\/definitions\//g, "#/components/schemas/"));
+            }
+            this.completeOpenAPI(openapi, skipHidden);
+            openapi.tags.sort((a, b) => a.name.toLowerCase().localeCompare(b.name.toLowerCase()));
+            const paths = {};
+            Object.keys(openapi.paths)
+                .sort()
+                .forEach(i => (paths[i] = openapi.paths[i]));
+            openapi.paths = paths;
+            return openapi;
+        }
+        /**
+         * Register a request filtering
+         *
+         * Will apply to all requests regardless of the devMode
+         * @param filter - the filter to apply
+         */
+        registerRequestFilter(filter) {
+            this._requestFilters.push(filter);
+        }
+        /**
+         * Register a CORS request filtering
+         *
+         * Does not apply in devMode
+         * @param filter - the filter to apply
+         */
+        registerCORSFilter(filter) {
+            this._requestCORSFilters.push(filter);
+        }
+        /**
+         * Auto-discover services that declare `request-filter` or `cors-filter` capabilities
+         * and register them with the Router.
+         *
+         * Called during framework initialization (after all services are resolved and
+         * initialized) to replace manual `registerRequestFilter(this)` calls. Iterates
+         * all services, checks their {@link Service.getCapabilities} return value, and
+         * registers matching services as request or CORS filters.
+         *
+         * @param services - Iterable of initialized services to scan for filter capabilities
+         *
+         * @example
+         * ```typescript
+         * // Called automatically by Core.init():
+         * router.discoverFilters(Object.values(this.services));
+         *
+         * // A service with "request-filter" capability is auto-registered:
+         * class HawkService extends Service implements RequestFilter {
+         *   // getCapabilities() returns { "request-filter": {}, "cors-filter": {} }
+         *   // → automatically registered with router as both request and CORS filter
+         * }
+         * ```
+         */
+        discoverFilters(services) {
+            for (const service of services) {
+                // Services that failed to construct are kept as undefined entries
+                if (!service)
+                    continue;
+                const caps = service.getCapabilities();
+                if ("request-filter" in caps) {
+                    this.registerRequestFilter(service);
+                }
+                if ("cors-filter" in caps) {
+                    this.registerCORSFilter(service);
+                }
+            }
+        }
+        /**
+         * Auto-discover routes declared with `@Route` (or the legacy
+         * `constructor.routes` bucket) on each service, and register them with the
+         * router. Called once from `Core.init()` after all services have resolved —
+         * services don't have to push their own routes anymore.
+         *
+         * @param services - iterable of initialized services to scan
+         */
+        discoverRoutes(services) {
+            for (const service of services) {
+                if (!service)
+                    continue;
+                // @ts-ignore — back-compat for subclasses that still populate this
+                const legacy = service.constructor.routes || {};
+                const fromMetadata = getMetadata(service.constructor)?.["webda.route"] || {};
+                const routes = { ...legacy };
+                for (const path in fromMetadata) {
+                    routes[path] = [...(routes[path] || []), ...fromMetadata[path]];
+                }
+                for (const path in routes) {
+                    for (const route of routes[path]) {
+                        const executor = service[route.executor];
+                        if (typeof executor !== "function") {
+                            useLog("WARN", `@Route on ${service.getName()} references non-method ${route.executor}`);
+                            continue;
+                        }
+                        const finalUrl = service.getUrl(path, route.methods);
+                        if (!finalUrl)
+                            continue;
+                        this.addRouteToRouter(finalUrl, {
+                            _method: executor.bind(service),
+                            executor: service.getName(),
+                            openapi: route.openapi,
+                            methods: route.methods
+                        });
+                    }
+                }
+            }
+        }
+    };
+})();
+export { Router };
+//# sourceMappingURL=router.service.js.map