vector-framework 1.1.1 → 1.2.1

package/dist/core/router.js

@@ -1,92 +1,169 @@
 import { APIError, createResponse } from '../http';
+import { STATIC_RESPONSES } from '../constants';
 import { buildRouteRegex } from '../utils/path';
+import { createValidationErrorPayload, extractThrownIssues, isStandardRouteSchema, normalizeValidationIssues, runStandardValidation, } from '../utils/schema-validation';
 export class VectorRouter {
     middlewareManager;
     authManager;
     cacheManager;
-    routes = [];
-    specificityCache = new Map();
+    routeBooleanDefaults = {};
+    developmentMode = undefined;
+    routeDefinitions = [];
+    routeTable = Object.create(null);
+    routeMatchers = [];
+    corsHeadersEntries = null;
+    corsHandler = null;
     constructor(middlewareManager, authManager, cacheManager) {
         this.middlewareManager = middlewareManager;
         this.authManager = authManager;
         this.cacheManager = cacheManager;
     }
-    getRouteSpecificity(path) {
-        const cached = this.specificityCache.get(path);
-        if (cached !== undefined)
-            return cached;
-        const STATIC_SEGMENT_WEIGHT = 1000;
-        const PARAM_SEGMENT_WEIGHT = 10;
-        const WILDCARD_WEIGHT = 1;
-        const EXACT_MATCH_BONUS = 10000;
-        let score = 0;
-        const segments = path.split('/').filter(Boolean);
-        for (const segment of segments) {
-            if (this.isStaticSegment(segment)) {
-                score += STATIC_SEGMENT_WEIGHT;
-            }
-            else if (this.isParamSegment(segment)) {
-                score += PARAM_SEGMENT_WEIGHT;
-            }
-            else if (this.isWildcardSegment(segment)) {
-                score += WILDCARD_WEIGHT;
+    setCorsHeaders(entries) {
+        this.corsHeadersEntries = entries;
+    }
+    setCorsHandler(handler) {
+        this.corsHandler = handler;
+    }
+    setRouteBooleanDefaults(defaults) {
+        this.routeBooleanDefaults = { ...defaults };
+    }
+    setDevelopmentMode(mode) {
+        this.developmentMode = mode;
+    }
+    applyRouteBooleanDefaults(options) {
+        const resolved = { ...options };
+        const defaults = this.routeBooleanDefaults;
+        const keys = ['auth', 'expose', 'rawRequest', 'validate', 'rawResponse'];
+        for (const key of keys) {
+            if (resolved[key] === undefined && defaults[key] !== undefined) {
+                resolved[key] = defaults[key];
             }
         }
-        score += path.length;
-        if (this.isExactPath(path)) {
-            score += EXACT_MATCH_BONUS;
-        }
-        this.specificityCache.set(path, score);
-        return score;
+        return resolved;
     }
-    isStaticSegment(segment) {
-        return !segment.startsWith(':') && !segment.includes('*');
+    route(options, handler) {
+        const resolvedOptions = this.applyRouteBooleanDefaults(options);
+        const method = resolvedOptions.method.toUpperCase();
+        const path = resolvedOptions.path;
+        const wrappedHandler = this.wrapHandler(resolvedOptions, handler);
+        const methodMap = this.getOrCreateMethodMap(path);
+        methodMap[method] = wrappedHandler;
+        this.routeDefinitions.push({
+            method,
+            path,
+            options: resolvedOptions,
+        });
     }
-    isParamSegment(segment) {
-        return segment.startsWith(':');
+    addRoute(entry) {
+        const [method, , handlers, path] = entry;
+        if (!path)
+            return;
+        const methodMap = this.getOrCreateMethodMap(path);
+        methodMap[method.toUpperCase()] = handlers[0];
+        const normalizedMethod = method.toUpperCase();
+        this.routeDefinitions.push({
+            method: normalizedMethod,
+            path,
+            options: {
+                method: normalizedMethod,
+                path,
+                expose: true,
+            },
+        });
     }
-    isWildcardSegment(segment) {
-        return segment.includes('*');
+    bulkAddRoutes(entries) {
+        for (const entry of entries) {
+            this.addRoute(entry);
+        }
     }
-    isExactPath(path) {
-        return !path.includes(':') && !path.includes('*');
+    addStaticRoute(path, response) {
+        const existing = this.routeTable[path];
+        if (existing && !(existing instanceof Response)) {
+            throw new Error(`Cannot register static route for path "${path}" because method routes already exist.`);
+        }
+        this.routeTable[path] = response;
+        this.removeRouteMatcher(path);
     }
-    sortRoutes() {
-        this.routes.sort((a, b) => {
-            const pathA = this.extractPath(a);
-            const pathB = this.extractPath(b);
-            const scoreA = this.getRouteSpecificity(pathA);
-            const scoreB = this.getRouteSpecificity(pathB);
-            return scoreB - scoreA;
-        });
+    getRouteTable() {
+        return this.routeTable;
     }
-    extractPath(route) {
-        const PATH_INDEX = 3;
-        return route[PATH_INDEX] || '';
+    // Legacy compatibility: returns route entries in a flat list for tests
+    getRoutes() {
+        const routes = [];
+        for (const matcher of this.routeMatchers) {
+            const value = this.routeTable[matcher.path];
+            if (!value || value instanceof Response)
+                continue;
+            for (const [method, handler] of Object.entries(value)) {
+                routes.push([method, matcher.regex, [handler], matcher.path]);
+            }
+        }
+        return routes;
     }
-    route(options, handler) {
-        const wrappedHandler = this.wrapHandler(options, handler);
-        const routeEntry = [
-            options.method.toUpperCase(),
-            this.createRouteRegex(options.path),
-            [wrappedHandler],
-            options.path,
-        ];
-        this.routes.push(routeEntry);
-        this.sortRoutes(); // Sort routes after adding
-        return routeEntry;
+    getRouteDefinitions() {
+        return [...this.routeDefinitions];
     }
-    createRouteRegex(path) {
-        return buildRouteRegex(path);
+    clearRoutes() {
+        this.routeTable = Object.create(null);
+        this.routeMatchers = [];
+        this.routeDefinitions = [];
+    }
+    // Legacy shim — no-op (Bun handles route priority natively)
+    sortRoutes() { }
+    // Compatibility handle() for unit tests — mirrors Bun's native routing without a server
+    async handle(request) {
+        let url;
+        try {
+            url = new URL(request.url);
+        }
+        catch {
+            return APIError.badRequest('Malformed request URL');
+        }
+        request._parsedUrl = url;
+        const pathname = url.pathname;
+        for (const matcher of this.routeMatchers) {
+            const path = matcher.path;
+            const value = this.routeTable[path];
+            if (!value)
+                continue;
+            if (value instanceof Response)
+                continue;
+            const methodMap = value;
+            if (request.method === 'OPTIONS' || request.method in methodMap) {
+                const match = pathname.match(matcher.regex);
+                if (match) {
+                    try {
+                        request.params = match.groups ?? {};
+                    }
+                    catch {
+                        // Request.params can be readonly on Bun-native requests.
+                    }
+                    const handler = methodMap[request.method] ?? methodMap['GET'];
+                    if (handler) {
+                        const response = await handler(request);
+                        if (response)
+                            return response;
+                    }
+                }
+            }
+        }
+        return STATIC_RESPONSES.NOT_FOUND.clone();
     }
     prepareRequest(request, options) {
-        // Initialize context if not present
         if (!request.context) {
             request.context = {};
         }
-        // Set params and route if provided
-        if (options?.params !== undefined) {
-            request.params = options.params;
+        const hasEmptyParamsObject = !!request.params &&
+            typeof request.params === 'object' &&
+            !Array.isArray(request.params) &&
+            Object.keys(request.params).length === 0;
+        if (options?.params !== undefined && (request.params === undefined || hasEmptyParamsObject)) {
+            try {
+                request.params = options.params;
+            }
+            catch {
+                // params is readonly (set by Bun natively) — use as-is
+            }
         }
         if (options?.route !== undefined) {
             request.route = options.route;
@@ -94,26 +171,42 @@ export class VectorRouter {
         if (options?.metadata !== undefined) {
             request.metadata = options.metadata;
         }
-        // Parse query parameters from URL if not already parsed
-        if (!request.query && request.url) {
-            const url = request._parsedUrl ?? new URL(request.url);
-            const query = {};
-            for (const [key, value] of url.searchParams) {
-                if (key in query) {
-                    if (Array.isArray(query[key])) {
-                        query[key].push(value);
-                    }
-                    else {
-                        query[key] = [query[key], value];
-                    }
+        if (request.query == null && request.url) {
+            try {
+                Object.defineProperty(request, 'query', {
+                    get() {
+                        const url = this._parsedUrl ?? new URL(this.url);
+                        const query = VectorRouter.parseQuery(url);
+                        Object.defineProperty(this, 'query', {
+                            value: query,
+                            writable: true,
+                            configurable: true,
+                            enumerable: true,
+                        });
+                        return query;
+                    },
+                    set(value) {
+                        Object.defineProperty(this, 'query', {
+                            value,
+                            writable: true,
+                            configurable: true,
+                            enumerable: true,
+                        });
+                    },
+                    configurable: true,
+                    enumerable: true,
+                });
+            }
+            catch {
+                const url = request._parsedUrl ?? new URL(request.url);
+                try {
+                    request.query = VectorRouter.parseQuery(url);
                 }
-                else {
-                    query[key] = value;
+                catch {
+                    // Leave query as-is when request shape is non-extensible.
                 }
             }
-            request.query = query;
         }
-        // Lazy cookie parsing — only parse the Cookie header when first accessed
         if (!Object.getOwnPropertyDescriptor(request, 'cookies')) {
             Object.defineProperty(request, 'cookies', {
                 get() {
@@ -140,86 +233,124 @@ export class VectorRouter {
             });
         }
     }
+    resolveFallbackParams(request, routeMatcher) {
+        if (!routeMatcher) {
+            return undefined;
+        }
+        const currentParams = request.params;
+        if (currentParams &&
+            typeof currentParams === 'object' &&
+            !Array.isArray(currentParams) &&
+            Object.keys(currentParams).length > 0) {
+            return undefined;
+        }
+        let pathname;
+        try {
+            pathname = (request._parsedUrl ?? new URL(request.url)).pathname;
+        }
+        catch {
+            return undefined;
+        }
+        const matched = pathname.match(routeMatcher);
+        if (!matched?.groups) {
+            return undefined;
+        }
+        return matched.groups;
+    }
     wrapHandler(options, handler) {
+        const routePath = options.path;
+        const routeMatcher = routePath.includes(':') ? buildRouteRegex(routePath) : null;
         return async (request) => {
-            // Ensure request has required properties
             const vectorRequest = request;
-            // Prepare the request with common logic
+            const fallbackParams = this.resolveFallbackParams(request, routeMatcher);
             this.prepareRequest(vectorRequest, {
+                params: fallbackParams,
+                route: routePath,
                 metadata: options.metadata,
             });
-            request = vectorRequest;
             try {
-                // Default expose to true if not specified
                 if (options.expose === false) {
                     return APIError.forbidden('Forbidden');
                 }
-                const beforeResult = await this.middlewareManager.executeBefore(request);
+                const beforeResult = await this.middlewareManager.executeBefore(vectorRequest);
                 if (beforeResult instanceof Response) {
                     return beforeResult;
                 }
-                request = beforeResult;
+                const req = beforeResult;
                 if (options.auth) {
                     try {
-                        await this.authManager.authenticate(request);
+                        await this.authManager.authenticate(req);
                     }
                     catch (error) {
                         return APIError.unauthorized(error instanceof Error ? error.message : 'Authentication failed', options.responseContentType);
                     }
                 }
-                if (!options.rawRequest && request.method !== 'GET' && request.method !== 'HEAD') {
+                if (!options.rawRequest && req.method !== 'GET' && req.method !== 'HEAD') {
+                    let parsedContent = null;
                     try {
-                        const contentType = request.headers.get('content-type');
-                        if (contentType?.includes('application/json')) {
-                            request.content = await request.json();
+                        const contentType = req.headers.get('content-type');
+                        if (contentType?.startsWith('application/json')) {
+                            parsedContent = await req.json();
                         }
-                        else if (contentType?.includes('application/x-www-form-urlencoded')) {
-                            request.content = Object.fromEntries(await request.formData());
+                        else if (contentType?.startsWith('application/x-www-form-urlencoded')) {
+                            parsedContent = Object.fromEntries(await req.formData());
                         }
-                        else if (contentType?.includes('multipart/form-data')) {
-                            request.content = await request.formData();
+                        else if (contentType?.startsWith('multipart/form-data')) {
+                            parsedContent = await req.formData();
                         }
                         else {
-                            request.content = await request.text();
+                            parsedContent = await req.text();
                         }
                     }
                     catch {
-                        request.content = null;
+                        parsedContent = null;
                     }
+                    this.setContentAndBodyAlias(req, parsedContent);
+                }
+                const inputValidationResponse = await this.validateInputSchema(req, options);
+                if (inputValidationResponse) {
+                    return inputValidationResponse;
                 }
                 let result;
                 const cacheOptions = options.cache;
-                // Create cache factory that handles Response objects
-                const cacheFactory = async () => {
-                    const res = await handler(request);
-                    // If Response, extract data for caching
-                    if (res instanceof Response) {
-                        return {
-                            _isResponse: true,
-                            body: await res.text(),
-                            status: res.status,
-                            headers: Object.fromEntries(res.headers.entries()),
-                        };
-                    }
-                    return res;
-                };
                 if (cacheOptions && typeof cacheOptions === 'number' && cacheOptions > 0) {
-                    const cacheKey = this.cacheManager.generateKey(request, {
-                        authUser: request.authUser,
+                    const cacheKey = this.cacheManager.generateKey(req, {
+                        authUser: req.authUser,
                     });
-                    result = await this.cacheManager.get(cacheKey, cacheFactory, cacheOptions);
+                    result = await this.cacheManager.get(cacheKey, async () => {
+                        const res = await handler(req);
+                        if (res instanceof Response) {
+                            return {
+                                _isResponse: true,
+                                body: await res.text(),
+                                status: res.status,
+                                headers: Object.fromEntries(res.headers.entries()),
+                            };
+                        }
+                        return res;
+                    }, cacheOptions);
                 }
                 else if (cacheOptions && typeof cacheOptions === 'object' && cacheOptions.ttl) {
                     const cacheKey = cacheOptions.key ||
-                        this.cacheManager.generateKey(request, {
-                            authUser: request.authUser,
+                        this.cacheManager.generateKey(req, {
+                            authUser: req.authUser,
                         });
-                    result = await this.cacheManager.get(cacheKey, cacheFactory, cacheOptions.ttl);
+                    result = await this.cacheManager.get(cacheKey, async () => {
+                        const res = await handler(req);
+                        if (res instanceof Response) {
+                            return {
+                                _isResponse: true,
+                                body: await res.text(),
+                                status: res.status,
+                                headers: Object.fromEntries(res.headers.entries()),
+                            };
+                        }
+                        return res;
+                    }, cacheOptions.ttl);
                 }
                 else {
-                    result = await handler(request);
+                    result = await handler(req);
                 }
-                // Reconstruct Response if it was cached
                 if (result && typeof result === 'object' && result._isResponse === true) {
                     result = new Response(result.body, {
                         status: result.status,
@@ -233,7 +364,20 @@ export class VectorRouter {
                 else {
                     response = createResponse(200, result, options.responseContentType);
                 }
-                response = await this.middlewareManager.executeFinally(response, request);
+                response = await this.middlewareManager.executeFinally(response, req);
+                // Apply pre-built CORS headers if configured
+                const entries = this.corsHeadersEntries;
+                if (entries) {
+                    for (const [k, v] of entries) {
+                        response.headers.set(k, v);
+                    }
+                }
+                else {
+                    const dynamicCors = this.corsHandler;
+                    if (dynamicCors) {
+                        response = dynamicCors(response, req);
+                    }
+                }
                 return response;
             }
             catch (error) {
@@ -245,52 +389,187 @@ export class VectorRouter {
             }
         };
     }
-    addRoute(routeEntry) {
-        this.routes.push(routeEntry);
-        this.sortRoutes(); // Sort routes after adding a new one
+    isDevelopmentMode() {
+        if (this.developmentMode !== undefined) {
+            return this.developmentMode;
+        }
+        const nodeEnv = typeof Bun !== 'undefined' ? Bun.env.NODE_ENV : process.env.NODE_ENV;
+        return nodeEnv !== 'production';
     }
-    bulkAddRoutes(entries) {
-        for (const entry of entries) {
-            this.routes.push(entry);
+    async buildInputValidationPayload(request, options) {
+        let body = request.content;
+        if (options.rawRequest && request.method !== 'GET' && request.method !== 'HEAD') {
+            try {
+                body = await request.clone().text();
+            }
+            catch {
+                body = null;
+            }
         }
-        this.sortRoutes(); // Sort once after all routes are added — O(n log n) instead of O(n²)
+        return {
+            params: request.params ?? {},
+            query: request.query ?? {},
+            headers: Object.fromEntries(request.headers.entries()),
+            cookies: request.cookies ?? {},
+            body,
+        };
     }
-    getRoutes() {
-        return this.routes;
+    applyValidatedInput(request, validatedValue) {
+        request.validatedInput = validatedValue;
+        if (!validatedValue || typeof validatedValue !== 'object') {
+            return;
+        }
+        const validated = validatedValue;
+        if ('params' in validated) {
+            try {
+                request.params = validated.params;
+            }
+            catch {
+                // Request.params can be readonly on Bun-native requests.
+            }
+        }
+        if ('query' in validated) {
+            try {
+                request.query = validated.query;
+            }
+            catch {
+                // Request.query can be readonly/non-configurable on some request objects.
+            }
+        }
+        if ('cookies' in validated) {
+            try {
+                request.cookies = validated.cookies;
+            }
+            catch {
+                // Request.cookies can be readonly/non-configurable on some request objects.
+            }
+        }
+        if ('body' in validated) {
+            this.setContentAndBodyAlias(request, validated.body);
+        }
     }
-    async handle(request) {
-        let url;
+    setContentAndBodyAlias(request, value) {
         try {
-            url = new URL(request.url);
+            request.content = value;
         }
         catch {
-            return APIError.badRequest('Malformed request URL');
+            // Request.content can be readonly/non-configurable on some request objects.
+            return;
         }
-        request._parsedUrl = url;
-        const pathname = url.pathname;
-        for (const [method, regex, handlers, path] of this.routes) {
-            if (request.method === 'OPTIONS' || request.method === method) {
-                const match = pathname.match(regex);
-                if (match) {
-                    const req = request;
-                    // Prepare the request with common logic
-                    this.prepareRequest(req, {
-                        params: match.groups || {},
-                        route: path || pathname,
-                    });
-                    for (const handler of handlers) {
-                        const response = await handler(req);
-                        if (response)
-                            return response;
-                    }
+        this.setBodyAlias(request, value);
+    }
+    setBodyAlias(request, value) {
+        try {
+            request.body = value;
+        }
+        catch {
+            // Keep request.content as source of truth when body alias is readonly.
+        }
+    }
+    async validateInputSchema(request, options) {
+        const inputSchema = options.schema?.input;
+        if (!inputSchema) {
+            return null;
+        }
+        if (options.validate === false) {
+            return null;
+        }
+        if (!isStandardRouteSchema(inputSchema)) {
+            return APIError.internalServerError('Invalid route schema configuration', options.responseContentType);
+        }
+        const includeRawIssues = this.isDevelopmentMode();
+        const payload = await this.buildInputValidationPayload(request, options);
+        try {
+            const validation = await runStandardValidation(inputSchema, payload);
+            if (validation.success === false) {
+                const issues = normalizeValidationIssues(validation.issues, includeRawIssues);
+                return createResponse(422, createValidationErrorPayload('input', issues), options.responseContentType);
+            }
+            this.applyValidatedInput(request, validation.value);
+            return null;
+        }
+        catch (error) {
+            const thrownIssues = extractThrownIssues(error);
+            if (thrownIssues) {
+                const issues = normalizeValidationIssues(thrownIssues, includeRawIssues);
+                return createResponse(422, createValidationErrorPayload('input', issues), options.responseContentType);
+            }
+            return APIError.internalServerError(error instanceof Error ? error.message : 'Validation failed', options.responseContentType);
+        }
+    }
+    getOrCreateMethodMap(path) {
+        const existing = this.routeTable[path];
+        if (existing instanceof Response) {
+            throw new Error(`Cannot register method route for path "${path}" because a static route already exists.`);
+        }
+        if (existing) {
+            return existing;
+        }
+        const methodMap = Object.create(null);
+        this.routeTable[path] = methodMap;
+        this.addRouteMatcher(path);
+        return methodMap;
+    }
+    addRouteMatcher(path) {
+        if (this.routeMatchers.some((matcher) => matcher.path === path)) {
+            return;
+        }
+        this.routeMatchers.push({
+            path,
+            regex: buildRouteRegex(path),
+            specificity: this.routeSpecificityScore(path),
+        });
+        this.routeMatchers.sort((a, b) => {
+            if (a.specificity !== b.specificity) {
+                return b.specificity - a.specificity;
+            }
+            return a.path.localeCompare(b.path);
+        });
+    }
+    removeRouteMatcher(path) {
+        this.routeMatchers = this.routeMatchers.filter((matcher) => matcher.path !== path);
+    }
+    static parseQuery(url) {
+        const query = {};
+        for (const [key, value] of url.searchParams) {
+            if (key in query) {
+                const existing = query[key];
+                if (Array.isArray(existing)) {
+                    existing.push(value);
+                }
+                else {
+                    query[key] = [existing, value];
                 }
             }
+            else {
+                query[key] = value;
+            }
         }
-        return APIError.notFound('Route not found');
+        return query;
     }
-    clearRoutes() {
-        this.routes = [];
-        this.specificityCache.clear();
+    routeSpecificityScore(path) {
+        const STATIC_SEGMENT_WEIGHT = 1000;
+        const PARAM_SEGMENT_WEIGHT = 10;
+        const WILDCARD_WEIGHT = 1;
+        const EXACT_MATCH_BONUS = 10000;
+        const segments = path.split('/').filter(Boolean);
+        let score = 0;
+        for (const segment of segments) {
+            if (segment.includes('*')) {
+                score += WILDCARD_WEIGHT;
+            }
+            else if (segment.startsWith(':')) {
+                score += PARAM_SEGMENT_WEIGHT;
+            }
+            else {
+                score += STATIC_SEGMENT_WEIGHT;
+            }
+        }
+        score += path.length;
+        if (!path.includes(':') && !path.includes('*')) {
+            score += EXACT_MATCH_BONUS;
+        }
+        return score;
     }
 }
 //# sourceMappingURL=router.js.map