@bepalo/spine 1.2.11 → 1.4.13

package/dist/cjs/router.js

@@ -28,7 +28,7 @@ var __asyncValues = (this && this.__asyncValues) || function (o) {
 };
 var _Router_instances, _Router_config, _Router_routes, _Router_processPath, _Router_getRouteEntries, _Router_InitEntries, _Router_initRoutes;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Router = exports.HANDLER_TYPES = exports.HTTP_METHODS_UPPER = exports.CRUD_METHODS = exports.HTTP_METHODS = exports.REGISTER_PATH_REGEX = exports.PATH_PART_REGEX = void 0;
+exports.translateRouteFilePath = exports.Router = exports.HANDLER_TYPES = exports.HTTP_METHODS_UPPER = exports.CRUD_METHODS = exports.HTTP_METHODS = exports.REGISTER_PATH_REGEX = exports.PATH_PART_REGEX = void 0;
 const status_ts_1 = require("./status.js");
 const types_ts_1 = require("./types.js");
 const utils_node_ts_1 = require("./utils.node.js");
@@ -101,7 +101,7 @@ class Router {
     respond(request, ctxInit) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a, _b, _c, _d, _e, _f;
-            const requestTimestamp = performance.now();
+            const requestTimestamp = Date.now();
             const method = request.method;
             const url = new URL(request.url);
             let pathname;
@@ -331,7 +331,7 @@ class Router {
                 response = new Response(response.body, Object.assign(Object.assign({}, response), { status: response.status, statusText: (0, status_ts_1.getHttpStatusText)(response.status), headers: ctx.headers }));
             }
             ctx.response = response;
-            ctx.timestamps.response = performance.now();
+            ctx.timestamps.response = Date.now();
             // afters
             if ((_f = __classPrivateFieldGet(this, _Router_config, "f").enable) === null || _f === void 0 ? void 0 : _f.after) {
                 const afterRoutes = __classPrivateFieldGet(this, _Router_instances, "m", _Router_getRouteEntries).call(this, pathname, parts, __classPrivateFieldGet(this, _Router_routes, "f").after[method], false);
@@ -394,7 +394,7 @@ class Router {
                             const pathname = !node.parent
                                 ? `/${processedName}`
                                 : `/${node.parent}/${processedName}`;
-                            const path = this.translateRouteFilePath(pathname);
+                            const path = (0, exports.translateRouteFilePath)(pathname, __classPrivateFieldGet(this, _Router_config, "f").maxPath);
                             for (const _method of Object.keys(handlersImp)) {
                                 const _definition = handlersImp[_method];
                                 let method;
@@ -466,62 +466,172 @@ class Router {
         });
     }
     generateOpenAPI(info) {
+        const { title = "API", version = "1.0.0", description, servers = [{ url: "/", description: "Current server" }], security, components: globalComponents, } = info !== null && info !== void 0 ? info : {};
         return new Promise((resolve) => {
-            var _a, _b, _c, _d;
-            const { title = "API", version = "1.0.0" } = info !== null && info !== void 0 ? info : {};
-            const paths = {};
+            var _a, _b, _c;
             const handlers = __classPrivateFieldGet(this, _Router_routes, "f").handler;
+            const paths = {};
+            const schemas = {};
+            const securitySchemes = {};
+            // Group routes by path
+            const routeGroups = new Map();
+            // Collect all routes
             for (const method of Object.keys(handlers)) {
                 const methodHandlers = handlers[method];
                 for (const entries of [
                     methodHandlers.entries,
                     methodHandlers.globs,
                     methodHandlers.superGlobs,
-                    // methodHandlers.superGlobsWithGlobs,
-                ])
+                ]) {
                     for (const bucket of entries) {
-                        if (bucket == null) {
+                        if (bucket == null)
                             continue;
-                        }
-                        for (const key of bucket.keys()) {
-                            const entry = bucket.get(key);
-                            if (entry == null) {
+                        for (const [, entry] of bucket) {
+                            if (entry == null)
+                                continue;
+                            // Skip super glob routes for OpenAPI (they're catch-alls)
+                            if (entry.path.endsWith("/**")) {
                                 continue;
                             }
-                            const pathname = entry.openApiPath;
-                            const openApi = entry.openApi;
-                            if (openApi != null) {
-                                if (paths[pathname] == null) {
-                                    paths[pathname] = {};
-                                }
-                                const methodLower = method.toLowerCase();
-                                const parameters = (_c = (_a = openApi.parameters) !== null && _a !== void 0 ? _a : (_b = entry.params) === null || _b === void 0 ? void 0 : _b.map(([, paramId]) => ({
-                                    name: paramId,
-                                    in: "path",
-                                    required: true,
-                                    schema: { type: "string" },
-                                }))) !== null && _c !== void 0 ? _c : [];
-                                const responses = (_d = openApi.responses) !== null && _d !== void 0 ? _d : {
-                                    "200": {
-                                        description: "OK",
-                                        content: {
-                                            "application/json": {
-                                                schema: { type: "object" },
+                            let pathMethods = routeGroups.get(entry.openApiPath);
+                            if (!pathMethods) {
+                                pathMethods = new Map();
+                                routeGroups.set(entry.openApiPath, pathMethods);
+                            }
+                            pathMethods.set(method, entry);
+                        }
+                    }
+                }
+            }
+            // Build paths
+            for (const [pathname, methods] of routeGroups) {
+                const pathItem = {};
+                paths[pathname] = pathItem;
+                for (const [method, entry] of methods) {
+                    const openApi = (_a = entry.openApi) !== null && _a !== void 0 ? _a : {};
+                    const methodLower = method.toLowerCase();
+                    // Build parameters - only include path params that are actually in the path
+                    // console.log(entry);
+                    const pathParams = [];
+                    if (entry.params != null) {
+                        for (const [idx, paramId] of entry.params) {
+                            // if(entry.pathParts[idx])
+                            console.log([idx, paramId, entry.pathParts[idx]]);
+                            pathParams.push({
+                                name: paramId,
+                                in: "path",
+                                required: true,
+                                schema: { type: "string" },
+                            });
+                        }
+                    }
+                    // Combine with user-defined parameters
+                    const userParams = (_b = openApi.parameters) !== null && _b !== void 0 ? _b : [];
+                    const allParams = [...userParams, ...pathParams];
+                    // Remove duplicates (by name + in combination)
+                    const paramSet = new Set();
+                    const parameters = [];
+                    for (const param of allParams) {
+                        const key = `${param.name}:${param.in}`;
+                        if (!paramSet.has(key)) {
+                            paramSet.add(key);
+                            parameters.push(param);
+                        }
+                    }
+                    // Build request body
+                    const requestBody = openApi.requestBody;
+                    // Build responses
+                    const responses = {};
+                    if (openApi.responses) {
+                        Object.assign(responses, openApi.responses);
+                    }
+                    else {
+                        // Infer responses from HTTP method
+                        if (method !== "DELETE" && method !== "HEAD") {
+                            responses["200"] = {
+                                description: "Successful response",
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object",
+                                            properties: {
+                                                data: { type: "object" },
+                                                message: { type: "string" },
                                             },
                                         },
                                     },
-                                };
-                                paths[pathname][methodLower] = Object.assign(Object.assign({}, openApi), { parameters,
-                                    responses });
-                            }
+                                },
+                            };
+                        }
+                        else if (method === "DELETE") {
+                            responses["204"] = {
+                                description: "Resource deleted successfully",
+                            };
+                        }
+                        // Add common error responses
+                        if ((_c = entry.params) === null || _c === void 0 ? void 0 : _c.length) {
+                            responses["404"] = {
+                                description: "Resource not found",
+                            };
                         }
+                        responses["400"] = {
+                            description: "Bad request",
+                        };
+                        responses["500"] = {
+                            description: "Internal server error",
+                        };
                     }
+                    // Build security
+                    let operationSecurity = openApi.security;
+                    if (!operationSecurity && security) {
+                        operationSecurity = security;
+                    }
+                    // Generate clean operation ID
+                    const operationId = openApi.operationId || generateOperationId(method, pathname);
+                    // Build operation object
+                    const operation = {
+                        summary: openApi.summary,
+                        description: openApi.description,
+                        tags: openApi.tags,
+                        parameters: parameters.length > 0 ? parameters : undefined,
+                        requestBody,
+                        responses,
+                        security: operationSecurity,
+                        operationId,
+                    };
+                    // Remove undefined properties
+                    const cleanedOperation = Object.fromEntries(Object.entries(operation).filter(([_, value]) => value !== undefined));
+                    pathItem[methodLower] = cleanedOperation;
+                }
             }
-            resolve({
+            // Merge global components with any collected schemas
+            const components = {};
+            if (globalComponents === null || globalComponents === void 0 ? void 0 : globalComponents.schemas) {
+                Object.assign(schemas, globalComponents.schemas);
+            }
+            if (Object.keys(schemas).length > 0) {
+                components.schemas = schemas;
+            }
+            if (globalComponents === null || globalComponents === void 0 ? void 0 : globalComponents.securitySchemes) {
+                Object.assign(securitySchemes, globalComponents.securitySchemes);
+            }
+            if (Object.keys(securitySchemes).length > 0) {
+                components.securitySchemes = securitySchemes;
+            }
+            const result = {
                 openapi: "3.0.0",
-                info: { title, version },
+                info: Object.assign({ title,
+                    version }, (description && { description })),
+                servers,
                 paths,
-            });
+            };
+            if (Object.keys(components).length > 0) {
+                result.components = components;
+            }
+            if (security && security.length > 0) {
+                result.security = security;
+            }
+            resolve(result);
         });
     }
     all(paths, pipe, options) {
@@ -1069,106 +1179,6 @@ class Router {
         }
         return count;
     }
-    translateRouteFilePath(pathname) {
-        const parts = pathname.split("/", __classPrivateFieldGet(this, _Router_config, "f").maxPath + 1);
-        const parts_len_1 = parts.length - 1;
-        let lastPartIsEscaped = false;
-        for (let i = 1; i < parts.length; i++) {
-            const part = parts[i];
-            if (part == null) {
-                parts[i] = "";
-                continue;
-            }
-            // validate part
-            if (!exports.PATH_PART_REGEX.test(part)) {
-                throw new types_ts_1.RouterError(`Invalid path ${pathname} -> ${part}`);
-            }
-            // parse part
-            switch (part) {
-                case "":
-                    break;
-                case "[#]":
-                    parts[i] = "*";
-                    break;
-                case "[##]":
-                    parts[i] = "**";
-                    break;
-                case "[[#]]":
-                    parts[i] = "*!";
-                    break;
-                case "[[##]]":
-                    parts[i] = "**!";
-                    break;
-                default:
-                    if (part.startsWith("#")) {
-                        if (i === parts_len_1) {
-                            lastPartIsEscaped = true;
-                        }
-                        parts[i] = part.substring(1);
-                    }
-                    else if (part.startsWith("[") && part.endsWith("]")) {
-                        const nextBracketIdx = part.indexOf("[", 1);
-                        if (nextBracketIdx < 0) {
-                            const extractedPart = part.substring(1, part.length - 1);
-                            // check for ## name
-                            if (extractedPart.startsWith("##")) {
-                                parts[i] = "::" + extractedPart.substring(2).trim();
-                            }
-                            else {
-                                // [name]
-                                parts[i] = ":" + extractedPart;
-                            }
-                        }
-                        else {
-                            // [[##name]] | [[## name! ]] | [[a,b]name!] | [[a,b] name ] | [[a,b] [name] ]
-                            const lastBracketIdx = part.indexOf("]", 1);
-                            const separatorIdx = lastBracketIdx >= 0 ? lastBracketIdx : part.length;
-                            const paths = part.substring(nextBracketIdx + 1, separatorIdx);
-                            // [[##name]] | [[## name]]
-                            if (paths.startsWith("##")) {
-                                const paramId = paths.substring(2).trim();
-                                parts[i] = `::${paramId}!`;
-                            }
-                            else {
-                                const paramId = part
-                                    .substring(separatorIdx + 1, part.length - 1)
-                                    .trim();
-                                // split values a,b,c and replace , with |
-                                let newPaths = "";
-                                let lastI = 0;
-                                for (let i = 0; i < paths.length;) {
-                                    const cc = paths.charCodeAt(i);
-                                    if (cc === 44) {
-                                        newPaths += paths.substring(lastI, i) + "|";
-                                        lastI = ++i;
-                                        continue;
-                                    }
-                                    i++;
-                                }
-                                if (lastI < paths.length) {
-                                    newPaths += paths.substring(lastI);
-                                }
-                                if (paramId.startsWith("[") && paramId.endsWith("]")) {
-                                    const extrParamId = paramId
-                                        .substring(1, paramId.length - 1)
-                                        .trim();
-                                    parts[i] = `${newPaths}:${extrParamId}!`;
-                                }
-                                else {
-                                    parts[i] = newPaths + ":" + paramId;
-                                }
-                            }
-                        }
-                    }
-            }
-        }
-        if (!lastPartIsEscaped &&
-            parts.length > 1 &&
-            parts[parts_len_1] === "index") {
-            parts[parts_len_1] = "";
-        }
-        return parts.join("/");
-    }
 }
 exports.Router = Router;
 _Router_config = new WeakMap(), _Router_routes = new WeakMap(), _Router_instances = new WeakSet(), _Router_processPath = function _Router_processPath(path) {
@@ -1391,5 +1401,118 @@ const parseParams = (superGlobIndex, params, pathname, parts) => {
     }
     return paramsRec;
 };
+const translateRouteFilePath = (pathname, maxPath = 64) => {
+    const parts = pathname.split("/", maxPath + 1);
+    const parts_len_1 = parts.length - 1;
+    let lastPartIsEscaped = false;
+    for (let i = 1; i < parts.length; i++) {
+        const part = parts[i];
+        if (part == null) {
+            parts[i] = "";
+            continue;
+        }
+        // validate part
+        if (!exports.PATH_PART_REGEX.test(part)) {
+            throw new types_ts_1.RouterError(`Invalid path ${pathname} -> ${part}`);
+        }
+        // parse part
+        switch (part) {
+            case "":
+                break;
+            case "[#]":
+                parts[i] = "*";
+                break;
+            case "[##]":
+                parts[i] = "**";
+                break;
+            case "[[#]]":
+                parts[i] = "*!";
+                break;
+            case "[[##]]":
+                parts[i] = "**!";
+                break;
+            default:
+                if (part.startsWith("#")) {
+                    if (i === parts_len_1) {
+                        lastPartIsEscaped = true;
+                    }
+                    parts[i] = part.substring(1);
+                }
+                else if (part.startsWith("[") && part.endsWith("]")) {
+                    const nextBracketIdx = part.indexOf("[", 1);
+                    if (nextBracketIdx < 0) {
+                        const extractedPart = part.substring(1, part.length - 1);
+                        // check for ## name
+                        if (extractedPart.startsWith("##")) {
+                            parts[i] = "::" + extractedPart.substring(2).trim();
+                        }
+                        else {
+                            // [name]
+                            parts[i] = ":" + extractedPart;
+                        }
+                    }
+                    else {
+                        // [[##name]] | [[## name! ]] | [[a,b]name!] | [[a,b] name ] | [[a,b] [name] ]
+                        const lastBracketIdx = part.indexOf("]", 1);
+                        const separatorIdx = lastBracketIdx >= 0 ? lastBracketIdx : part.length;
+                        const paths = part.substring(nextBracketIdx + 1, separatorIdx);
+                        // [[##name]] | [[## name]]
+                        if (paths.startsWith("##")) {
+                            const paramId = paths.substring(2).trim();
+                            parts[i] = `::${paramId}!`;
+                        }
+                        else {
+                            const paramId = part
+                                .substring(separatorIdx + 1, part.length - 1)
+                                .trim();
+                            // split values a,b,c and replace , with |
+                            let newPaths = "";
+                            let lastI = 0;
+                            for (let i = 0; i < paths.length;) {
+                                const cc = paths.charCodeAt(i);
+                                if (cc === 44) {
+                                    newPaths += paths.substring(lastI, i) + "|";
+                                    lastI = ++i;
+                                    continue;
+                                }
+                                i++;
+                            }
+                            if (lastI < paths.length) {
+                                newPaths += paths.substring(lastI);
+                            }
+                            if (paramId.startsWith("[") && paramId.endsWith("]")) {
+                                const extrParamId = paramId
+                                    .substring(1, paramId.length - 1)
+                                    .trim();
+                                parts[i] = `${newPaths}:${extrParamId}!`;
+                            }
+                            else {
+                                parts[i] = newPaths + ":" + paramId;
+                            }
+                        }
+                    }
+                }
+        }
+    }
+    if (!lastPartIsEscaped &&
+        parts.length > 1 &&
+        parts[parts_len_1] === "index") {
+        parts[parts_len_1] = "";
+    }
+    return parts.join("/");
+};
+exports.translateRouteFilePath = translateRouteFilePath;
+const generateOperationId = (method, path) => {
+    // Remove all special characters and format properly
+    const cleanPath = path
+        .replace(/[{}]/g, "")
+        .replace(/\*/g, "")
+        .replace(/[^a-zA-Z0-9\/]/g, "")
+        .split("/")
+        .filter(Boolean)
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join("");
+    return `${method.toLowerCase()}${cleanPath}`;
+};
 exports.default = Router;
 //# sourceMappingURL=router.js.map