vitek-plugin 0.1.2-beta.5 → 0.2.0-beta

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

@@ -1,371 +1,15 @@
-/**
- * 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 { createRequestHandler } from '../../core/server/request-handler.js';
-import { routesToSchema } from '../../core/types/schema.js';
-import { generateTypesFile, generateServicesFile } from '../../core/types/generate.js';
-import { generateSocketTypesFile } from '../../core/types/generate-socket-types.js';
-import { generateSocketServicesFile } from '../../core/types/generate-socket-services.js';
-import { patternToRegex } from '../../core/normalize/normalize-path.js';
-import { createSocketHandler } from '../../core/socket/socket-handler.js';
-import { generateOpenApiFile, generateApiDocsHtml } from '../../core/openapi/generate.js';
-import { generateAsyncApiFile } from '../../core/asyncapi/generate.js';
-import { API_BASE_PATH, SOCKET_BASE_PATH, GENERATED_TYPES_FILE, GENERATED_SERVICES_FILE, GENERATED_SOCKET_TYPES_FILE, GENERATED_SOCKET_SERVICES_FILE, } from '../../shared/constants.js';
-function deduplicateRoutesByKey(routes) {
-    const seen = new Set();
-    return routes.filter((r) => {
-        const key = `${r.method}:${r.pattern}`;
-        if (seen.has(key))
-            return false;
-        seen.add(key);
-        return true;
-    });
-}
-function deduplicateSocketsByPattern(sockets) {
-    const seen = new Set();
-    return sockets.filter((s) => {
-        if (seen.has(s.pattern))
-            return false;
-        seen.add(s.pattern);
-        return true;
-    });
-}
-/**
- * Development server state
- */
-class DevServerState {
-    options;
-    routes = [];
-    middlewares = [];
-    sockets = [];
-    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...');
-        }
-        const scanResult = scanApiDirectory(this.options.apiDir);
-        this.middlewares.length = 0;
-        for (const middlewareInfo of scanResult.middlewares) {
-            try {
-                const relativePath = path.relative(this.options.root, middlewareInfo.path);
-                const vitePath = `/${relativePath.replace(/\\/g, '/')}`;
-                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);
-        this.routes.length = 0;
-        for (const parsedRoute of scanResult.routes) {
-            try {
-                const relativePath = path.relative(this.options.root, parsedRoute.file);
-                const vitePath = `/${relativePath.replace(/\\/g, '/')}`;
-                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;
-                }
-                const bodyType = extractBodyTypeFromFile(parsedRoute.file);
-                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)}`);
-            }
-        }
-        this.routes = deduplicateRoutesByKey(this.routes);
-        const routesInfo = this.routes.map(r => ({
-            method: r.method,
-            pattern: r.pattern,
-        }));
-        this.options.logger.routesRegistered(routesInfo, API_BASE_PATH);
-        this.sockets.length = 0;
-        const socketsEnabled = this.options.sockets !== false;
-        if (socketsEnabled) {
-            for (const parsedSocket of scanResult.sockets) {
-                try {
-                    const relativePath = path.relative(this.options.root, parsedSocket.file);
-                    const vitePath = `/${relativePath.replace(/\\/g, '/')}`;
-                    const handlerModule = await this.options.viteServer.ssrLoadModule(vitePath);
-                    const handler = handlerModule.default ?? handlerModule.handler;
-                    if (typeof handler !== 'function') {
-                        this.options.logger.warn(`Socket file ${parsedSocket.file} does not export a handler function`);
-                        continue;
-                    }
-                    const regex = patternToRegex(parsedSocket.pattern);
-                    this.sockets.push({
-                        pattern: parsedSocket.pattern,
-                        params: parsedSocket.params,
-                        file: parsedSocket.file,
-                        regex,
-                        handler,
-                    });
-                }
-                catch (error) {
-                    this.options.logger.error(`Failed to load socket ${parsedSocket.file}: ${error instanceof Error ? error.message : String(error)}`);
-                }
-            }
-        }
-        this.sockets = deduplicateSocketsByPattern(this.sockets);
-        const socketBasePath = this.options.socketBasePath ?? SOCKET_BASE_PATH;
-        this.options.logger.socketsRegistered(this.sockets.map((s) => ({ pattern: s.pattern })), socketBasePath);
-        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);
-            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, '/')}`);
-            }
-            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, '/')}`);
-            if (this.sockets.length > 0) {
-                const socketSchema = this.sockets.map((s) => ({
-                    pattern: s.pattern,
-                    params: s.params,
-                    file: s.file,
-                }));
-                const socketBasePath = this.options.socketBasePath ?? SOCKET_BASE_PATH;
-                if (isTypeScript) {
-                    const socketTypesPath = path.join(this.options.root, 'src', GENERATED_SOCKET_TYPES_FILE);
-                    await generateSocketTypesFile(socketTypesPath, socketSchema, socketBasePath);
-                    const relativeSocketTypesPath = path.relative(this.options.root, socketTypesPath);
-                    this.options.logger.typesGenerated(`./${relativeSocketTypesPath.replace(/\\/g, '/')}`);
-                }
-                const socketServicesFileName = isTypeScript ? GENERATED_SOCKET_SERVICES_FILE : 'socket.services.js';
-                const socketServicesPath = path.join(this.options.root, 'src', socketServicesFileName);
-                await generateSocketServicesFile(socketServicesPath, socketSchema, socketBasePath, isTypeScript);
-                const relativeSocketServicesPath = path.relative(this.options.root, socketServicesPath);
-                this.options.logger.servicesGenerated(`./${relativeSocketServicesPath.replace(/\\/g, '/')}`);
-            }
-            // Generate OpenAPI spec if enabled
-            await this.generateOpenApi();
-        }
-        catch (error) {
-            this.options.logger.error(`Failed to generate types: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    /**
-     * Generates OpenAPI specification and Swagger UI
-     */
-    async generateOpenApi() {
-        const { openApi } = this.options;
-        if (!openApi) {
-            return;
-        }
-        try {
-            const openApiOptions = typeof openApi === 'boolean'
-                ? {
-                    apiBasePath: API_BASE_PATH,
-                }
-                : { ...openApi, apiBasePath: API_BASE_PATH };
-            // Generate openapi.json
-            const openApiPath = path.join(this.options.root, 'public', 'openapi.json');
-            await generateOpenApiFile(openApiPath, this.routes, openApiOptions);
-            const relativeOpenApiPath = path.relative(this.options.root, openApiPath);
-            this.options.logger.info(`OpenAPI spec generated: ./${relativeOpenApiPath.replace(/\\/g, '/')}`);
-            const port = this.options.viteServer.config.server?.port || 5173;
-            const socketBasePath = this.options.socketBasePath ?? SOCKET_BASE_PATH;
-            const hasSockets = this.sockets.length > 0;
-            if (hasSockets) {
-                const asyncApiPath = path.join(this.options.root, 'public', 'asyncapi.json');
-                await generateAsyncApiFile(asyncApiPath, this.sockets, socketBasePath, {
-                    serverUrl: `ws://localhost:${port}`,
-                });
-                const relativeAsyncPath = path.relative(this.options.root, asyncApiPath);
-                this.options.logger.info(`AsyncAPI spec generated: ./${relativeAsyncPath.replace(/\\/g, '/')}`);
-            }
-            // Generate API docs HTML (Swagger UI only, or REST + WebSockets tabs)
-            const apiDocsPath = path.join(this.options.root, 'public', 'api-docs.html');
-            const title = openApiOptions.info?.title || 'Vitek API';
-            const apiDocsHtml = generateApiDocsHtml('/openapi.json', title, {
-                asyncApiJsonPath: hasSockets ? '/asyncapi.json' : undefined,
-            });
-            fs.writeFileSync(apiDocsPath, apiDocsHtml, 'utf-8');
-            const relativeApiDocsPath = path.relative(this.options.root, apiDocsPath);
-            this.options.logger.info(`API docs at: ./${relativeApiDocsPath.replace(/\\/g, '/')} → http://localhost:${port}/api-docs.html`);
-        }
-        catch (error) {
-            this.options.logger.warn(`Failed to generate OpenAPI spec: ${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');
-}
-/**
- * Extracts a type (Body or Query) from a route file via regex. AST-based extraction could be used in a future version.
- */
-function extractTypeFromFile(filePath, typeName) {
-    try {
-        const content = fs.readFileSync(filePath, 'utf-8');
-        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 (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 {
-                    const semicolonIndex = afterEquals.indexOf(';');
-                    if (semicolonIndex !== -1) {
-                        return afterEquals.substring(0, semicolonIndex).trim();
-                    }
-                }
-            }
-        }
-        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 {
-        return undefined;
-    }
-}
+import { API_BASE_PATH } from '../../shared/constants.js';
+import { DevServerState } from './dev-server-state.js';
+import { createApiMiddleware, createSocketSetup } from './dev-server-middleware.js';
 const noopEmitter = {
     emit() { },
 };
-/**
- * Creates middleware for Vite development server
- */
 export function createViteDevServerMiddleware(options) {
     const state = new DevServerState(options);
-    const ready = state.initialize().catch(error => {
+    const ready = state.initialize().catch((error) => {
         options.logger.error(`Failed to initialize Vitek: ${error instanceof Error ? error.message : String(error)}`);
     });
-    const port = options.viteServer.config.server.port ?? 5173;
+    const port = options.viteServer.config.server?.port ?? 5173;
     const apiBaseUrl = `http://127.0.0.1:${port}${API_BASE_PATH}`;
     const api = {
         async fetch(path, fetchOptions) {
@@ -396,25 +40,9 @@ export function createViteDevServerMiddleware(options) {
     };
     return {
         ready,
-        middleware: createRequestHandler({
-            routes: state.routes,
-            middlewares: state.middlewares,
-            logger: options.logger,
-            shared,
-        }),
+        middleware: createApiMiddleware(state, options, shared),
         cleanup: () => state.cleanup(),
         reload: () => state.reload(),
-        setupSockets: (httpServer) => {
-            if (options.sockets !== false && state.sockets.length > 0) {
-                const socketBasePath = options.socketBasePath ?? SOCKET_BASE_PATH;
-                const handler = createSocketHandler({
-                    sockets: state.sockets,
-                    socketBasePath,
-                    shared,
-                    logger: options.logger,
-                });
-                httpServer.on('upgrade', handler);
-            }
-        },
+        setupSockets: createSocketSetup(state, options, shared),
     };
 }

package/dist/adapters/vite/path-utils.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Path normalization utilities for Vite plugin hooks.
+ * Centralizes logic for importer/module id resolution (file:, /, absolute).
+ */
+/**
+ * Converts an importer string (from resolveId) to an absolute filesystem path.
+ * Handles file: URLs, leading-slash paths (virtual), and absolute paths.
+ */
+export declare function normalizeImporterPath(importer: string, root: string): string;
+/**
+ * Converts a module id (from transform/resolveId) to an absolute filesystem path.
+ * Handles file: URLs and leading-slash paths (virtual).
+ */
+export declare function normalizeModuleIdPath(id: string, root: string): string;
+/**
+ * Resolves a path to an existing file, trying extensions if the path has none.
+ * Returns the resolved absolute path or null if not found.
+ */
+export declare function resolveWithExtension(filePath: string): string | null;
+//# sourceMappingURL=path-utils.d.ts.map

package/dist/adapters/vite/path-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"path-utils.d.ts","sourceRoot":"","sources":["../../../src/adapters/vite/path-utils.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAQH;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAS5E;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAOtE;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAKpE"}

package/dist/adapters/vite/path-utils.js

@@ -0,0 +1,46 @@
+/**
+ * Path normalization utilities for Vite plugin hooks.
+ * Centralizes logic for importer/module id resolution (file:, /, absolute).
+ */
+import * as path from 'path';
+import * as fs from 'fs';
+import { fileURLToPath } from 'url';
+const EXTENSIONS = ['.ts', '.tsx', '.mts', '.js', '.jsx', '.mjs'];
+/**
+ * Converts an importer string (from resolveId) to an absolute filesystem path.
+ * Handles file: URLs, leading-slash paths (virtual), and absolute paths.
+ */
+export function normalizeImporterPath(importer, root) {
+    if (importer.startsWith('file:')) {
+        return fileURLToPath(importer);
+    }
+    if (importer.startsWith('/')) {
+        const virtualPath = path.join(root, importer.replace(/^\//, ''));
+        return fs.existsSync(virtualPath) ? virtualPath : path.resolve(importer);
+    }
+    return path.resolve(importer);
+}
+/**
+ * Converts a module id (from transform/resolveId) to an absolute filesystem path.
+ * Handles file: URLs and leading-slash paths (virtual).
+ */
+export function normalizeModuleIdPath(id, root) {
+    const idPath = id.startsWith('file:') ? fileURLToPath(id) : id;
+    if (idPath.startsWith('/')) {
+        const virtualPath = path.join(root, idPath.replace(/^\//, ''));
+        return fs.existsSync(virtualPath) ? virtualPath : path.resolve(idPath);
+    }
+    return path.resolve(idPath);
+}
+/**
+ * Resolves a path to an existing file, trying extensions if the path has none.
+ * Returns the resolved absolute path or null if not found.
+ */
+export function resolveWithExtension(filePath) {
+    if (fs.existsSync(filePath))
+        return filePath;
+    const ext = EXTENSIONS.find((e) => fs.existsSync(filePath + e));
+    if (ext)
+        return filePath + ext;
+    return null;
+}

package/dist/adapters/vite/path-utils.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=path-utils.test.d.ts.map

package/dist/adapters/vite/path-utils.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"path-utils.test.d.ts","sourceRoot":"","sources":["../../../src/adapters/vite/path-utils.test.ts"],"names":[],"mappings":""}

package/dist/adapters/vite/path-utils.test.js

@@ -0,0 +1,79 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import { pathToFileURL } from 'url';
+import { normalizeImporterPath, normalizeModuleIdPath, resolveWithExtension, } from './path-utils.js';
+describe('path-utils', () => {
+    let rootDir;
+    beforeEach(() => {
+        rootDir = fs.mkdtempSync(path.join(process.cwd(), 'path-utils-test-'));
+        fs.mkdirSync(path.join(rootDir, 'src', 'api'), { recursive: true });
+        fs.mkdirSync(path.join(rootDir, 'src', 'lib'), { recursive: true });
+        fs.writeFileSync(path.join(rootDir, 'src', 'api', 'health.ts'), '', 'utf-8');
+        fs.writeFileSync(path.join(rootDir, 'src', 'lib', 'utils.ts'), '', 'utf-8');
+    });
+    afterEach(() => {
+        try {
+            fs.rmSync(rootDir, { recursive: true });
+        }
+        catch {
+            // ignore
+        }
+    });
+    describe('normalizeImporterPath', () => {
+        it('converts file: URL to absolute path', () => {
+            const filePath = path.join(rootDir, 'src', 'api', 'health.ts');
+            const fileUrl = pathToFileURL(filePath).href;
+            expect(normalizeImporterPath(fileUrl, rootDir)).toBe(filePath);
+        });
+        it('converts leading-slash path (virtual) when file exists', () => {
+            const virtualPath = '/src/api/health.ts';
+            const result = normalizeImporterPath(virtualPath, rootDir);
+            expect(result).toBe(path.join(rootDir, 'src', 'api', 'health.ts'));
+        });
+        it('converts leading-slash path when file does not exist', () => {
+            const virtualPath = '/nonexistent/file.ts';
+            const result = normalizeImporterPath(virtualPath, rootDir);
+            expect(result).toBe(path.resolve(virtualPath));
+        });
+        it('resolves absolute path', () => {
+            const absPath = path.join(rootDir, 'src', 'api', 'health.ts');
+            expect(normalizeImporterPath(absPath, rootDir)).toBe(path.resolve(absPath));
+        });
+    });
+    describe('normalizeModuleIdPath', () => {
+        it('converts file: URL to absolute path', () => {
+            const filePath = path.join(rootDir, 'src', 'lib', 'utils.ts');
+            const fileUrl = pathToFileURL(filePath).href;
+            expect(normalizeModuleIdPath(fileUrl, rootDir)).toBe(filePath);
+        });
+        it('converts leading-slash path (virtual) when file exists', () => {
+            const virtualPath = '/src/lib/utils.ts';
+            const result = normalizeModuleIdPath(virtualPath, rootDir);
+            expect(result).toBe(path.join(rootDir, 'src', 'lib', 'utils.ts'));
+        });
+        it('resolves path without leading slash', () => {
+            const relPath = path.join(rootDir, 'src', 'api', 'health.ts');
+            expect(normalizeModuleIdPath(relPath, rootDir)).toBe(path.resolve(relPath));
+        });
+    });
+    describe('resolveWithExtension', () => {
+        it('returns path when file exists without extension', () => {
+            const existingPath = path.join(rootDir, 'src', 'api', 'health.ts');
+            expect(resolveWithExtension(existingPath)).toBe(existingPath);
+        });
+        it('adds .ts when file exists with extension', () => {
+            const basePath = path.join(rootDir, 'src', 'api', 'health');
+            expect(resolveWithExtension(basePath)).toBe(basePath + '.ts');
+        });
+        it('adds .tsx when .ts does not exist but .tsx does', () => {
+            fs.writeFileSync(path.join(rootDir, 'src', 'component.tsx'), '', 'utf-8');
+            const basePath = path.join(rootDir, 'src', 'component');
+            expect(resolveWithExtension(basePath)).toBe(basePath + '.tsx');
+        });
+        it('returns null when file does not exist', () => {
+            const basePath = path.join(rootDir, 'src', 'nonexistent');
+            expect(resolveWithExtension(basePath)).toBeNull();
+        });
+    });
+});

package/dist/build/build-api-bundle.d.ts

@@ -6,6 +6,7 @@ export interface BuildApiBundleOptions {
     root: string;
     apiDir: string;
     outDir: string;
+    alias?: Record<string, string>;
 }
 /**
  * Builds the API bundle and writes it to outDir/vitek-api.mjs

package/dist/build/build-api-bundle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"build-api-bundle.d.ts","sourceRoot":"","sources":["../../src/build/build-api-bundle.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAWH,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB;AAgDD;;;GAGG;AACH,wBAAsB,cAAc,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAgD3F;AAED,wBAAgB,oBAAoB,IAAI,MAAM,CAE7C"}
+{"version":3,"file":"build-api-bundle.d.ts","sourceRoot":"","sources":["../../src/build/build-api-bundle.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAWH,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAChC;AAgFD;;;GAGG;AACH,wBAAsB,cAAc,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAmD3F;AAED,wBAAgB,oBAAoB,IAAI,MAAM,CAE7C"}

package/dist/build/build-api-bundle.js

@@ -22,7 +22,8 @@ function generateEntryContent(scanResult, entryDir) {
     scanResult.middlewares.forEach((mw, i) => {
         const rel = path.relative(entryDir, mw.path).replace(/\\/g, '/');
         const importPath = rel.startsWith('.') ? rel : `./${rel}`;
-        lines.push(`import mw_${i} from ${JSON.stringify(importPath)};`);
+        // Use namespace import so we can read both default and named export 'config' (for global pathPatterns)
+        lines.push(`import * as mw_${i}_ns from ${JSON.stringify(importPath)};`);
     });
     const routeEntries = scanResult.routes.map((parsed, i) => {
         const regex = patternToRegex(parsed.pattern);
@@ -34,7 +35,11 @@ function generateEntryContent(scanResult, entryDir) {
     lines.push(routeEntries.join(',\n'));
     lines.push('];');
     const mwEntries = scanResult.middlewares.map((mw, i) => {
-        return `  { basePattern: ${JSON.stringify(mw.basePattern)}, middleware: (() => { const m = mw_${i}; const fn = typeof m === 'function' || Array.isArray(m) ? m : (m.default ?? m.middleware); return Array.isArray(fn) ? fn : [fn]; })() }`;
+        const base = `  { basePattern: ${JSON.stringify(mw.basePattern)}, middleware: (() => { const m = mw_${i}_ns.default ?? mw_${i}_ns; const fn = typeof m === 'function' || Array.isArray(m) ? m : (m?.default ?? m?.middleware); return Array.isArray(fn) ? fn : [fn]; })()`;
+        if (mw.basePattern === '') {
+            return `${base}, pathPatterns: (() => { const c = mw_${i}_ns?.config; if (!c?.path) return undefined; const p = Array.isArray(c.path) ? c.path : [c.path]; return p.map((x) => String(x).replace(/^\\/api\\/?/, '').replace(/^\\/+|\\/+$/g, '')); })() }`;
+        }
+        return `${base} }`;
     });
     lines.push('');
     lines.push('const middlewares = [');
@@ -44,12 +49,39 @@ function generateEntryContent(scanResult, entryDir) {
     lines.push('export { routes, middlewares };');
     return lines.join('\n');
 }
+function createAliasPlugin(root, alias) {
+    const entries = Object.entries(alias)
+        .filter(([, v]) => v != null && v !== '')
+        .sort(([a], [b]) => b.length - a.length);
+    return {
+        name: 'vitek-alias',
+        setup(build) {
+            if (entries.length === 0)
+                return;
+            const b = build;
+            const filter = new RegExp('^(' + entries.map(([k]) => k.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('|') + ')(/|$)');
+            b.onResolve({ filter }, (args) => {
+                const imp = args.path;
+                for (const [key, value] of entries) {
+                    if (imp === key || imp.startsWith(key + '/')) {
+                        const rest = imp.slice(key.length).replace(/^\//, '') || '';
+                        const base = path.resolve(root, value, rest);
+                        const withExt = ['.js', '.ts', '.mjs', '.cjs'].find((ext) => fs.existsSync(base + ext));
+                        const resolved = withExt ? base + withExt : base;
+                        return { path: resolved };
+                    }
+                }
+                return null;
+            });
+        },
+    };
+}
 /**
  * Builds the API bundle and writes it to outDir/vitek-api.mjs
  * Returns the path to the written file, or null if skipped (no apiDir, no routes, or error)
  */
 export async function buildApiBundle(options) {
-    const { root, apiDir, outDir } = options;
+    const { root, apiDir, outDir, alias } = options;
     if (!fs.existsSync(apiDir)) {
         return null;
     }
@@ -69,6 +101,7 @@ export async function buildApiBundle(options) {
     if (!esbuild) {
         return null;
     }
+    const plugins = alias && Object.keys(alias).length > 0 ? [createAliasPlugin(root, alias)] : [];
     try {
         await esbuild.build({
             entryPoints: [tmpEntry],
@@ -77,6 +110,8 @@ export async function buildApiBundle(options) {
             platform: 'node',
             outfile: outFile,
             external: ['vitek-plugin'],
+            minify: true,
+            plugins,
         });
         return outFile;
     }

package/dist/build/build-api-bundle.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=build-api-bundle.test.d.ts.map

package/dist/build/build-api-bundle.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-api-bundle.test.d.ts","sourceRoot":"","sources":["../../src/build/build-api-bundle.test.ts"],"names":[],"mappings":""}