vitek-plugin 0.1.0-beta

package/dist/adapters/vite/dev-server.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Adapter for integration with Vite development server
+ * Thin layer that connects core → Vite
+ */
+import type { Connect, ViteDevServer } from 'vite';
+import type { IncomingMessage, ServerResponse } from 'http';
+import type { VitekLogger } from './logger.js';
+export interface ViteDevServerOptions {
+    root: string;
+    apiDir: string;
+    logger: VitekLogger;
+    viteServer: ViteDevServer;
+    enableValidation?: boolean;
+}
+/**
+ * Creates middleware for Vite development server
+ */
+export declare function createViteDevServerMiddleware(options: ViteDevServerOptions): {
+    middleware: (req: IncomingMessage, res: ServerResponse, next: Connect.NextFunction) => Promise<void>;
+    cleanup: () => void;
+    reload: () => Promise<void>;
+};
+//# sourceMappingURL=dev-server.d.ts.map

package/dist/adapters/vite/dev-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dev-server.d.ts","sourceRoot":"","sources":["../../../src/adapters/vite/dev-server.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,MAAM,CAAC;AACnD,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,MAAM,CAAC;AAsB5D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAG/C,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,WAAW,CAAC;IACpB,UAAU,EAAE,aAAa,CAAC;IAC1B,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAoRD;;GAEG;AACH,wBAAgB,6BAA6B,CAAC,OAAO,EAAE,oBAAoB;sBAUhE,eAAe,OACf,cAAc,QACb,OAAO,CAAC,YAAY;;;EAoL/B"}

package/dist/adapters/vite/dev-server.js

@@ -0,0 +1,428 @@
+/**
+ * Adapter for integration with Vite development server
+ * Thin layer that connects core → Vite
+ */
+import * as path from 'path';
+import * as fs from 'fs';
+import { scanApiDirectory } from '../../core/file-system/scan-api-dir.js';
+/**
+ * Detects if the project uses TypeScript by checking if tsconfig.json exists
+ */
+function isTypeScriptProject(root) {
+    const tsconfigPath = path.join(root, 'tsconfig.json');
+    return fs.existsSync(tsconfigPath);
+}
+import { watchApiDirectory } from '../../core/file-system/watch-api-dir.js';
+import { createRoute } from '../../core/routing/route-parser.js';
+import { matchRoute } from '../../core/routing/route-matcher.js';
+import { compose } from '../../core/middleware/compose.js';
+import { getApplicableMiddlewares } from '../../core/middleware/get-applicable-middlewares.js';
+import { createContext, isVitekResponse } from '../../core/context/create-context.js';
+import { routesToSchema } from '../../core/types/schema.js';
+import { generateTypesFile, generateServicesFile } from '../../core/types/generate.js';
+import { API_BASE_PATH, GENERATED_TYPES_FILE, GENERATED_SERVICES_FILE } from '../../shared/constants.js';
+import { HttpError } from '../../shared/errors.js';
+/**
+ * Development server state
+ */
+class DevServerState {
+    options;
+    routes = [];
+    middlewares = []; // Loaded hierarchical middlewares
+    watcher = null;
+    constructor(options) {
+        this.options = options;
+    }
+    /**
+     * Initializes the server: scan, load routes and middleware
+     */
+    async initialize() {
+        await this.reload(false); // Don't show "Reloading" on initialization
+        this.setupWatcher();
+    }
+    /**
+     * Reloads routes and middleware
+     */
+    async reload(showReloadLog = true) {
+        if (showReloadLog) {
+            this.options.logger.info('Reloading API routes...');
+        }
+        // Scan directory
+        const scanResult = scanApiDirectory(this.options.apiDir);
+        // Load hierarchical middlewares
+        this.middlewares = [];
+        for (const middlewareInfo of scanResult.middlewares) {
+            try {
+                // Convert absolute path to relative path to Vite root (format /src/api/posts/middleware.ts)
+                const relativePath = path.relative(this.options.root, middlewareInfo.path);
+                const vitePath = `/${relativePath.replace(/\\/g, '/')}`;
+                // Use Vite's ssrLoadModule to process TypeScript
+                const middlewareModule = await this.options.viteServer.ssrLoadModule(vitePath);
+                const middleware = middlewareModule.default || middlewareModule.middleware;
+                let middlewareArray = [];
+                if (Array.isArray(middleware)) {
+                    middlewareArray = middleware;
+                }
+                else if (typeof middleware === 'function') {
+                    middlewareArray = [middleware];
+                }
+                if (middlewareArray.length > 0) {
+                    this.middlewares.push({
+                        middleware: middlewareArray,
+                        basePattern: middlewareInfo.basePattern,
+                    });
+                }
+            }
+            catch (error) {
+                this.options.logger.warn(`Failed to load middleware ${middlewareInfo.path}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        const totalMiddlewareCount = this.middlewares.reduce((sum, m) => sum + m.middleware.length, 0);
+        this.options.logger.middlewareLoaded(totalMiddlewareCount);
+        // Load routes
+        this.routes = [];
+        for (const parsedRoute of scanResult.routes) {
+            try {
+                // Convert absolute path to relative path to Vite root (format /src/api/users/[id].get.ts)
+                const relativePath = path.relative(this.options.root, parsedRoute.file);
+                const vitePath = `/${relativePath.replace(/\\/g, '/')}`;
+                // Use Vite's ssrLoadModule to process TypeScript
+                const handlerModule = await this.options.viteServer.ssrLoadModule(vitePath);
+                const handler = handlerModule.default || handlerModule.handler || handlerModule[parsedRoute.method];
+                if (typeof handler !== 'function') {
+                    this.options.logger.warn(`Route file ${parsedRoute.file} does not export a handler function`);
+                    continue;
+                }
+                // Extract bodyType from file (looking for export type Body or export interface Body)
+                const bodyType = extractBodyTypeFromFile(parsedRoute.file);
+                // Extract queryType from file (looking for export type Query or export interface Query)
+                const queryType = extractQueryTypeFromFile(parsedRoute.file);
+                const route = createRoute(parsedRoute, handler, bodyType, queryType);
+                this.routes.push(route);
+            }
+            catch (error) {
+                this.options.logger.error(`Failed to load route ${parsedRoute.file}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        // Log registered routes (consolidated)
+        const routesInfo = this.routes.map(r => ({
+            method: r.method,
+            pattern: r.pattern,
+        }));
+        this.options.logger.routesRegistered(routesInfo, API_BASE_PATH);
+        // Generate types
+        await this.generateTypes();
+    }
+    /**
+     * Sets up watcher to reload when files change
+     */
+    setupWatcher() {
+        if (this.watcher) {
+            this.watcher.close();
+        }
+        this.watcher = watchApiDirectory(this.options.apiDir, async (event, filePath) => {
+            this.options.logger.info(`API file ${event}: ${filePath}`);
+            await this.reload();
+        });
+    }
+    /**
+     * Generates types and services files
+     */
+    async generateTypes() {
+        try {
+            const schema = routesToSchema(this.routes);
+            const isTypeScript = isTypeScriptProject(this.options.root);
+            // Generate api.types.ts only if it's a TypeScript project
+            if (isTypeScript) {
+                const typesPath = path.join(this.options.root, 'src', GENERATED_TYPES_FILE);
+                await generateTypesFile(typesPath, schema, API_BASE_PATH);
+                const relativeTypesPath = path.relative(this.options.root, typesPath);
+                this.options.logger.typesGenerated(`./${relativeTypesPath.replace(/\\/g, '/')}`);
+            }
+            // Generate api.services.ts or api.services.js depending on the project
+            const servicesFileName = isTypeScript ? GENERATED_SERVICES_FILE : 'api.services.js';
+            const servicesPath = path.join(this.options.root, 'src', servicesFileName);
+            await generateServicesFile(servicesPath, schema, API_BASE_PATH, isTypeScript);
+            const relativeServicesPath = path.relative(this.options.root, servicesPath);
+            this.options.logger.servicesGenerated(`./${relativeServicesPath.replace(/\\/g, '/')}`);
+        }
+        catch (error) {
+            this.options.logger.error(`Failed to generate types: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Cleans up resources
+     */
+    cleanup() {
+        if (this.watcher) {
+            this.watcher.close();
+            this.watcher = null;
+        }
+    }
+}
+/**
+ * Extracts the body type from a route file
+ * Looks for export type Body = ... or export interface Body { ... }
+ * Returns the complete type definition as a string
+ */
+function extractBodyTypeFromFile(filePath) {
+    return extractTypeFromFile(filePath, 'Body');
+}
+/**
+ * Extracts the query type from a route file
+ * Looks for export type Query = ... or export interface Query { ... }
+ * Returns the complete type definition as a string
+ */
+function extractQueryTypeFromFile(filePath) {
+    return extractTypeFromFile(filePath, 'Query');
+}
+/**
+ * Helper function to extract a type from a file
+ * Uses regex-based extraction (synchronous)
+ *
+ * Note: AST-based extraction using ts-morph would be more robust but requires:
+ * 1. Making this function async
+ * 2. Adding ts-morph as optional dependency
+ * 3. Updating call sites to handle async
+ * This can be implemented in a future version when needed.
+ */
+function extractTypeFromFile(filePath, typeName) {
+    try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        // Look for export type {TypeName} = ...
+        const typeStart = content.indexOf(`export type ${typeName}`);
+        if (typeStart !== -1) {
+            const afterStart = content.substring(typeStart);
+            const equalsIndex = afterStart.indexOf('=');
+            if (equalsIndex !== -1) {
+                const afterEquals = afterStart.substring(equalsIndex + 1).trimStart();
+                // If it starts with {, need to count braces to find the correct closing
+                if (afterEquals.startsWith('{')) {
+                    let braceCount = 0;
+                    let i = 0;
+                    let foundClose = false;
+                    for (; i < afterEquals.length; i++) {
+                        if (afterEquals[i] === '{') {
+                            braceCount++;
+                        }
+                        else if (afterEquals[i] === '}') {
+                            braceCount--;
+                            if (braceCount === 0) {
+                                foundClose = true;
+                                break;
+                            }
+                        }
+                    }
+                    if (foundClose) {
+                        const typeBody = afterEquals.substring(0, i + 1).trim();
+                        return typeBody;
+                    }
+                }
+                else {
+                    // If it doesn't start with {, it's a simple type alias (e.g., string, number, etc)
+                    // Get until the first ; (but may have line breaks)
+                    const semicolonIndex = afterEquals.indexOf(';');
+                    if (semicolonIndex !== -1) {
+                        return afterEquals.substring(0, semicolonIndex).trim();
+                    }
+                }
+            }
+        }
+        // Look for export interface {TypeName} { ... }
+        const interfaceStart = content.indexOf(`export interface ${typeName}`);
+        if (interfaceStart !== -1) {
+            const afterStart = content.substring(interfaceStart);
+            const openBrace = afterStart.indexOf('{');
+            if (openBrace !== -1) {
+                let braceCount = 0;
+                let i = openBrace;
+                let foundClose = false;
+                for (; i < afterStart.length; i++) {
+                    if (afterStart[i] === '{') {
+                        braceCount++;
+                    }
+                    else if (afterStart[i] === '}') {
+                        braceCount--;
+                        if (braceCount === 0) {
+                            foundClose = true;
+                            break;
+                        }
+                    }
+                }
+                if (foundClose) {
+                    const interfaceBody = afterStart.substring(openBrace + 1, i).trim();
+                    return `{ ${interfaceBody} }`;
+                }
+            }
+        }
+        return undefined;
+    }
+    catch (error) {
+        // If unable to read the file, return undefined
+        return undefined;
+    }
+}
+/**
+ * Creates middleware for Vite development server
+ */
+export function createViteDevServerMiddleware(options) {
+    const state = new DevServerState(options);
+    // Initialize when middleware is created
+    state.initialize().catch(error => {
+        options.logger.error(`Failed to initialize Vitek: ${error instanceof Error ? error.message : String(error)}`);
+    });
+    return {
+        middleware: async (req, res, next) => {
+            // Only process requests for /api/*
+            if (!req.url?.startsWith(API_BASE_PATH)) {
+                return next();
+            }
+            const startTime = Date.now();
+            const requestMethod = req.method?.toLowerCase() || 'get';
+            const requestPath = req.url.split('?')[0]; // Path without query string
+            try {
+                // Parse URL to separate path from query string
+                const url = new URL(req.url, `http://${req.headers.host || 'localhost'}`);
+                // Remove /api from path for matching
+                const routePath = url.pathname.replace(API_BASE_PATH, '') || '/';
+                const method = requestMethod;
+                // Try to match with a route
+                const match = matchRoute(state.routes, routePath, method);
+                if (!match) {
+                    const duration = Date.now() - startTime;
+                    res.statusCode = 404;
+                    res.setHeader('Content-Type', 'application/json');
+                    res.end(JSON.stringify({ error: 'Route not found' }));
+                    options.logger.request(requestMethod, requestPath, 404, duration);
+                    return;
+                }
+                // Log route match if enabled
+                options.logger.routeMatched(match.route.pattern, method);
+                // Parse query string (url was already created above)
+                const query = {};
+                url.searchParams.forEach((value, key) => {
+                    if (query[key]) {
+                        const existing = query[key];
+                        query[key] = Array.isArray(existing) ? [...existing, value] : [existing, value];
+                    }
+                    else {
+                        query[key] = value;
+                    }
+                });
+                // Parse body if present
+                let body;
+                if (['post', 'put', 'patch'].includes(method)) {
+                    body = await new Promise((resolve) => {
+                        const chunks = [];
+                        req.on('data', (chunk) => {
+                            chunks.push(chunk);
+                        });
+                        req.on('end', () => {
+                            const rawBody = Buffer.concat(chunks).toString();
+                            if (!rawBody) {
+                                resolve(undefined);
+                                return;
+                            }
+                            try {
+                                resolve(JSON.parse(rawBody));
+                            }
+                            catch {
+                                resolve(rawBody);
+                            }
+                        });
+                    });
+                }
+                // Create context
+                const context = createContext({
+                    url: req.url,
+                    method,
+                    headers: req.headers,
+                    body,
+                }, match.params, query);
+                // Note: Validation is opt-in and can be done manually in handlers using validateBody/validateQuery
+                // Automatic validation based on TypeScript types would require AST parsing (Phase 2.2)
+                // For now, validation is available as helper functions that handlers can use
+                // Get applicable middlewares for this route
+                const applicableMiddlewares = getApplicableMiddlewares(state.middlewares, match.route.pattern);
+                // Compose middlewares + handler
+                const composed = compose(applicableMiddlewares);
+                const handler = async () => {
+                    const result = await match.route.handler(context);
+                    // Handle VitekResponse format (with status and headers)
+                    if (isVitekResponse(result)) {
+                        const response = result;
+                        const statusCode = response.status || 200;
+                        // Set headers
+                        if (response.headers) {
+                            for (const [key, value] of Object.entries(response.headers)) {
+                                res.setHeader(key, value);
+                            }
+                        }
+                        // Set default Content-Type if not specified and body exists
+                        if (!response.headers || !response.headers['Content-Type']) {
+                            if (response.body !== undefined) {
+                                res.setHeader('Content-Type', 'application/json');
+                            }
+                        }
+                        res.statusCode = statusCode;
+                        // Handle different response types
+                        if (response.body === undefined) {
+                            res.end();
+                        }
+                        else if (typeof response.body === 'string') {
+                            res.end(response.body);
+                        }
+                        else {
+                            res.end(JSON.stringify(response.body));
+                        }
+                        // Log request/response
+                        const duration = Date.now() - startTime;
+                        options.logger.request(requestMethod, requestPath, statusCode, duration);
+                    }
+                    else {
+                        // Backward compatibility: plain object/primitive → JSON response with status 200
+                        res.setHeader('Content-Type', 'application/json');
+                        res.statusCode = 200;
+                        res.end(JSON.stringify(result));
+                        // Log request/response
+                        const duration = Date.now() - startTime;
+                        options.logger.request(requestMethod, requestPath, 200, duration);
+                    }
+                };
+                await composed(context, handler);
+            }
+            catch (error) {
+                const duration = Date.now() - startTime;
+                // Handle HTTP errors with proper status codes
+                if (error instanceof HttpError) {
+                    const httpError = error;
+                    options.logger.warn(`HTTP Error ${httpError.statusCode}: ${httpError.message}`);
+                    res.statusCode = httpError.statusCode;
+                    res.setHeader('Content-Type', 'application/json');
+                    res.end(JSON.stringify({
+                        error: httpError.name,
+                        message: httpError.message,
+                        code: httpError.code,
+                    }));
+                    // Log request/response
+                    options.logger.request(requestMethod, requestPath, httpError.statusCode, duration);
+                }
+                else {
+                    // Generic error handling (backward compatible)
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    options.logger.error(`Error handling request: ${errorMessage}`);
+                    res.statusCode = 500;
+                    res.setHeader('Content-Type', 'application/json');
+                    res.end(JSON.stringify({
+                        error: 'Internal server error',
+                        message: errorMessage,
+                    }));
+                    // Log request/response
+                    options.logger.request(requestMethod, requestPath, 500, duration);
+                }
+            }
+        },
+        cleanup: () => state.cleanup(),
+        reload: () => state.reload(),
+    };
+}

package/dist/adapters/vite/logger.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Logger adapter for Vite
+ * Translates core events into Vite logs
+ */
+import type { Logger } from 'vite';
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+export interface LoggingOptions {
+    level?: LogLevel;
+    enableRequestLogging?: boolean;
+    enableRouteLogging?: boolean;
+}
+export interface VitekLogger {
+    debug(message: string, data?: Record<string, any>): void;
+    info(message: string, data?: Record<string, any>): void;
+    warn(message: string, data?: Record<string, any>): void;
+    error(message: string, data?: Record<string, any>): void;
+    routesRegistered(routes: Array<{
+        method: string;
+        pattern: string;
+    }>, apiBasePath: string): void;
+    routeMatched(pattern: string, method: string): void;
+    middlewareLoaded(count: number): void;
+    typesGenerated(outputPath: string): void;
+    servicesGenerated(outputPath: string): void;
+    request(method: string, path: string, statusCode: number, duration?: number): void;
+    response(method: string, path: string, statusCode: number, duration?: number): void;
+    getOptions(): LoggingOptions;
+}
+/**
+ * Creates a logger that uses Vite's logger
+ */
+export declare function createViteLogger(viteLogger: Logger, options?: LoggingOptions): VitekLogger;
+//# sourceMappingURL=logger.d.ts.map

package/dist/adapters/vite/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../../src/adapters/vite/logger.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAEnC,MAAM,MAAM,QAAQ,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;AAE3D,MAAM,WAAW,cAAc;IAC7B,KAAK,CAAC,EAAE,QAAQ,CAAC;IACjB,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC9B;AAoBD,MAAM,WAAW,WAAW;IAC1B,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,IAAI,CAAC;IACzD,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,IAAI,CAAC;IACxD,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,IAAI,CAAC;IACxD,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,IAAI,CAAC;IACzD,gBAAgB,CAAC,MAAM,EAAE,KAAK,CAAC;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC,EAAE,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAChG,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACpD,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACtC,cAAc,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IACzC,iBAAiB,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5C,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACnF,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACpF,UAAU,IAAI,cAAc,CAAC;CAC9B;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,WAAW,CAyH1F"}

package/dist/adapters/vite/logger.js

@@ -0,0 +1,112 @@
+/**
+ * Logger adapter for Vite
+ * Translates core events into Vite logs
+ */
+/**
+ * Formats the [vitek] tag with green color and bold
+ * Uses ANSI codes: \x1b[1m = bold, \x1b[32m = green, \x1b[0m = reset
+ */
+function formatTag(text) {
+    return `\x1b[1m\x1b[32m${text}\x1b[0m`;
+}
+/**
+ * Checks if a log level should be logged based on the configured level
+ */
+function shouldLog(level, configuredLevel) {
+    const levels = ['debug', 'info', 'warn', 'error'];
+    const levelIndex = levels.indexOf(level);
+    const configuredIndex = levels.indexOf(configuredLevel);
+    return levelIndex >= configuredIndex;
+}
+/**
+ * Creates a logger that uses Vite's logger
+ */
+export function createViteLogger(viteLogger, options) {
+    const tag = formatTag('[vitek]');
+    const logLevel = options?.level || 'info';
+    const enableRequestLogging = options?.enableRequestLogging || false;
+    const enableRouteLogging = options?.enableRouteLogging !== false; // Default true
+    const formatData = (data) => {
+        if (!data || Object.keys(data).length === 0) {
+            return '';
+        }
+        return ' ' + JSON.stringify(data);
+    };
+    return {
+        debug(message, data) {
+            if (shouldLog('debug', logLevel)) {
+                viteLogger.info(`${tag} [DEBUG] ${message}${formatData(data)}`, { timestamp: true });
+            }
+        },
+        info(message, data) {
+            if (shouldLog('info', logLevel)) {
+                viteLogger.info(`${tag} ${message}${formatData(data)}`, { timestamp: true });
+            }
+        },
+        warn(message, data) {
+            if (shouldLog('warn', logLevel)) {
+                viteLogger.warn(`${tag} ${message}${formatData(data)}`, { timestamp: true });
+            }
+        },
+        error(message, data) {
+            if (shouldLog('error', logLevel)) {
+                viteLogger.error(`${tag} ${message}${formatData(data)}`, { timestamp: true });
+            }
+        },
+        routesRegistered(routes, apiBasePath) {
+            if (routes.length === 0) {
+                if (shouldLog('info', logLevel)) {
+                    viteLogger.info(`${tag} No routes registered`, { timestamp: true });
+                }
+                return;
+            }
+            if (shouldLog('info', logLevel)) {
+                const routesList = routes
+                    .map(r => {
+                    const pattern = r.pattern === '' ? '/' : `/${r.pattern}`;
+                    return `  ${r.method.toUpperCase()} ${apiBasePath}${pattern}`;
+                })
+                    .join('\n');
+                viteLogger.info(`${tag} Registered routes:\n${routesList}`, { timestamp: true });
+            }
+        },
+        routeMatched(pattern, method) {
+            if (enableRouteLogging && shouldLog('debug', logLevel)) {
+                viteLogger.info(`${tag} [ROUTE] ${method.toUpperCase()} ${pattern}`, { timestamp: true });
+            }
+        },
+        middlewareLoaded(count) {
+            if (shouldLog('info', logLevel)) {
+                viteLogger.info(`${tag} Loaded ${count} global middleware(s)`, { timestamp: true });
+            }
+        },
+        typesGenerated(outputPath) {
+            if (shouldLog('info', logLevel)) {
+                viteLogger.info(`${tag} Generated types: ${outputPath}`, { timestamp: true });
+            }
+        },
+        servicesGenerated(outputPath) {
+            if (shouldLog('info', logLevel)) {
+                viteLogger.info(`${tag} Generated services: ${outputPath}`, { timestamp: true });
+            }
+        },
+        request(method, path, statusCode, duration) {
+            if (enableRequestLogging && shouldLog('info', logLevel)) {
+                const durationStr = duration !== undefined ? ` (${duration}ms)` : '';
+                const statusColor = statusCode >= 500 ? '\x1b[31m' : statusCode >= 400 ? '\x1b[33m' : '\x1b[32m';
+                viteLogger.info(`${tag} [REQUEST] ${method.toUpperCase()} ${path} ${statusColor}${statusCode}\x1b[0m${durationStr}`, { timestamp: true });
+            }
+        },
+        response(method, path, statusCode, duration) {
+            // Alias for request (for consistency)
+            this.request(method, path, statusCode, duration);
+        },
+        getOptions() {
+            return {
+                level: logLevel,
+                enableRequestLogging,
+                enableRouteLogging,
+            };
+        },
+    };
+}

package/dist/core/context/create-context.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Context creation for route handlers
+ * Core logic - runtime agnostic
+ */
+export interface VitekContext {
+    url: string;
+    method: string;
+    path: string;
+    query: Record<string, string | string[]>;
+    params: Record<string, string>;
+    headers: Record<string, string>;
+    body?: any;
+}
+export interface VitekRequest {
+    url: string;
+    method: string;
+    headers: Record<string, string>;
+    body?: any;
+}
+/**
+ * Response object that allows control over status code and headers
+ * If a handler returns a plain object, it will be treated as status 200 with JSON content-type
+ */
+export interface VitekResponse {
+    status?: number;
+    headers?: Record<string, string>;
+    body?: any;
+}
+/**
+ * Type guard to check if a value is a VitekResponse
+ * A VitekResponse is identified by having 'status' (number) or 'headers' (object) properties
+ * Plain objects without these properties are treated as regular JSON responses (backward compatibility)
+ */
+export declare function isVitekResponse(value: any): value is VitekResponse;
+/**
+ * Creates a context from a request and extracted parameters
+ */
+export declare function createContext(request: VitekRequest, params?: Record<string, string>, query?: Record<string, string | string[]>): VitekContext;
+//# sourceMappingURL=create-context.d.ts.map

package/dist/core/context/create-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-context.d.ts","sourceRoot":"","sources":["../../../src/core/context/create-context.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,WAAW,YAAY;IAC3B,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC,CAAC;IACzC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,IAAI,CAAC,EAAE,GAAG,CAAC;CACZ;AAED,MAAM,WAAW,YAAY;IAC3B,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,IAAI,CAAC,EAAE,GAAG,CAAC;CACZ;AAED;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,IAAI,CAAC,EAAE,GAAG,CAAC;CACZ;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,GAAG,GAAG,KAAK,IAAI,aAAa,CAWlE;AAED;;GAEG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,YAAY,EACrB,MAAM,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAM,EACnC,KAAK,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAAM,GAC5C,YAAY,CAYd"}