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

package/dist/core/file-system/watch-api-dir.js

@@ -9,32 +9,57 @@ import { ROUTE_FILE_PATTERN, MIDDLEWARE_FILE_PATTERN } from '../../shared/consta
  * Creates a watcher for the API directory using Node.js fs.watch
  * Returns a function to stop watching
  */
-export function watchApiDirectory(apiDir, callback) {
+export function watchApiDirectory(apiDir, callback, options = {}) {
     if (!fs.existsSync(apiDir)) {
         return { close: () => { } };
     }
+    const debounceMs = options.debounceMs ?? 0;
+    let pending = [];
+    let timer = null;
+    const flush = () => {
+        if (timer != null) {
+            clearTimeout(timer);
+            timer = null;
+        }
+        const toEmit = pending;
+        pending = [];
+        for (const { event, filePath } of toEmit) {
+            callback(event, filePath);
+        }
+    };
+    const schedule = (event, filePath) => {
+        pending.push({ event, filePath });
+        if (debounceMs <= 0) {
+            flush();
+            return;
+        }
+        if (timer != null)
+            clearTimeout(timer);
+        timer = setTimeout(flush, debounceMs);
+    };
     const watcher = fs.watch(apiDir, { recursive: true }, (eventType, filename) => {
         if (!filename)
             return;
         const filePath = path.join(apiDir, filename);
-        // Ignore if it's not a route file or relevant middleware
         const isRouteFile = ROUTE_FILE_PATTERN.test(filename);
         const isMiddlewareFile = MIDDLEWARE_FILE_PATTERN.test(filename);
         if (!isRouteFile && !isMiddlewareFile) {
             return;
         }
-        // Normalize event type
         let normalizedEvent;
         if (eventType === 'rename') {
-            // rename can be add or unlink, check if it exists
             normalizedEvent = fs.existsSync(filePath) ? 'add' : 'unlink';
         }
         else {
             normalizedEvent = eventType;
         }
-        callback(normalizedEvent, filePath);
+        schedule(normalizedEvent, filePath);
     });
     return {
-        close: () => watcher.close(),
+        close: () => {
+            if (timer != null)
+                clearTimeout(timer);
+            watcher.close();
+        },
     };
 }

package/dist/core/file-system/watch-api-dir.test.d.ts

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

package/dist/core/file-system/watch-api-dir.test.d.ts.map

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

package/dist/core/file-system/watch-api-dir.test.js

@@ -0,0 +1,38 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import { watchApiDirectory } from './watch-api-dir.js';
+describe('watch-api-dir', () => {
+    let tmpDir;
+    let apiDir;
+    beforeEach(() => {
+        tmpDir = fs.mkdtempSync(path.join(process.cwd(), 'watch-api-'));
+        apiDir = path.join(tmpDir, 'api');
+        fs.mkdirSync(apiDir, { recursive: true });
+    });
+    afterEach(() => {
+        try {
+            fs.rmSync(tmpDir, { recursive: true });
+        }
+        catch {
+            // ignore
+        }
+    });
+    it('returns watcher with no-op close when apiDir does not exist', () => {
+        const watcher = watchApiDirectory(path.join(tmpDir, 'nonexistent'), () => { });
+        expect(watcher).toBeDefined();
+        expect(typeof watcher.close).toBe('function');
+        watcher.close();
+    });
+    it('returns watcher with close when apiDir exists', () => {
+        const watcher = watchApiDirectory(apiDir, () => { });
+        expect(watcher).toBeDefined();
+        expect(typeof watcher.close).toBe('function');
+        watcher.close();
+    });
+    it('accepts debounceMs option', () => {
+        const watcher = watchApiDirectory(apiDir, () => { }, { debounceMs: 100 });
+        expect(watcher).toBeDefined();
+        watcher.close();
+    });
+});

package/dist/core/generation/run-file-generation.d.ts

@@ -0,0 +1,24 @@
+import type { ParsedRoute } from '../routing/route-parser.js';
+import type { ParsedSocket } from '../routing/socket-parser.js';
+import type { RouteSchema } from '../types/schema.js';
+import { type OpenApiOptions } from '../openapi/generate.js';
+export declare function parsedRoutesToSchema(parsedRoutes: ParsedRoute[]): RouteSchema[];
+export interface RunFileGenerationOptions {
+    root: string;
+    schema: RouteSchema[];
+    sockets: ParsedSocket[];
+    apiBasePath?: string;
+    socketBasePath?: string;
+    openApi?: OpenApiOptions | boolean;
+    serverPort?: number;
+    logger?: {
+        typesGenerated?: (path: string) => void;
+        servicesGenerated?: (path: string) => void;
+        info?: (message: string) => void;
+        warn?: (message: string) => void;
+    };
+    /** Callback when generation fails (e.g. OpenAPI). Does not run for types/services write errors. */
+    onGenerationError?: (error: Error) => void;
+}
+export declare function runFileGeneration(options: RunFileGenerationOptions): Promise<void>;
+//# sourceMappingURL=run-file-generation.d.ts.map

package/dist/core/generation/run-file-generation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-file-generation.d.ts","sourceRoot":"","sources":["../../../src/core/generation/run-file-generation.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAC9D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAKtD,OAAO,EAA4C,KAAK,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAgBvG,wBAAgB,oBAAoB,CAAC,YAAY,EAAE,WAAW,EAAE,GAAG,WAAW,EAAE,CAS/E;AAED,MAAM,WAAW,wBAAwB;IACvC,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,WAAW,EAAE,CAAC;IACtB,OAAO,EAAE,YAAY,EAAE,CAAC;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC;IACnC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE;QACP,cAAc,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;QACxC,iBAAiB,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;QAC3C,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;QACjC,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;KAClC,CAAC;IACF,mGAAmG;IACnG,iBAAiB,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;CAC5C;AAED,wBAAsB,iBAAiB,CAAC,OAAO,EAAE,wBAAwB,GAAG,OAAO,CAAC,IAAI,CAAC,CAuFxF"}

package/dist/core/generation/run-file-generation.js

@@ -0,0 +1,90 @@
+import * as path from 'path';
+import * as fs from 'fs';
+import { extractBodyTypeFromFile, extractQueryTypeFromFile } from '../file-system/extract-type-from-file.js';
+import { generateTypesFile, generateServicesFile } from '../types/generate.js';
+import { generateSocketTypesFile } from '../types/generate-socket-types.js';
+import { generateSocketServicesFile } from '../types/generate-socket-services.js';
+import { generateOpenApiFile, generateApiDocsHtml } from '../openapi/generate.js';
+import { generateAsyncApiFile } from '../asyncapi/generate.js';
+import { socketsToSchema } from '../types/socket-schema.js';
+import { API_BASE_PATH, GENERATED_TYPES_FILE, GENERATED_SERVICES_FILE, GENERATED_SOCKET_TYPES_FILE, GENERATED_SOCKET_SERVICES_FILE, } from '../../shared/constants.js';
+function isTypeScriptProject(root) {
+    const tsconfigPath = path.join(root, 'tsconfig.json');
+    return fs.existsSync(tsconfigPath);
+}
+export function parsedRoutesToSchema(parsedRoutes) {
+    return parsedRoutes.map((p) => ({
+        pattern: p.pattern,
+        method: p.method,
+        params: p.params,
+        file: p.file,
+        bodyType: extractBodyTypeFromFile(p.file),
+        queryType: extractQueryTypeFromFile(p.file),
+    }));
+}
+export async function runFileGeneration(options) {
+    const { root, schema, sockets, apiBasePath = API_BASE_PATH, socketBasePath = `${apiBasePath}/ws`, openApi, serverPort = 5173, logger, } = options;
+    const logTypes = logger?.typesGenerated ?? (() => { });
+    const logServices = logger?.servicesGenerated ?? (() => { });
+    const logInfo = logger?.info ?? (() => { });
+    const logWarn = logger?.warn ?? (() => { });
+    const onGenerationError = options.onGenerationError;
+    const isTypeScript = isTypeScriptProject(root);
+    const srcDir = path.join(root, 'src');
+    if (schema.length > 0) {
+        if (isTypeScript) {
+            const typesPath = path.join(srcDir, GENERATED_TYPES_FILE);
+            await generateTypesFile(typesPath, schema, apiBasePath);
+            logTypes(`./${path.relative(root, typesPath).replace(/\\/g, '/')}`);
+        }
+        const servicesFileName = isTypeScript ? GENERATED_SERVICES_FILE : 'api.services.js';
+        const servicesPath = path.join(srcDir, servicesFileName);
+        await generateServicesFile(servicesPath, schema, apiBasePath, isTypeScript);
+        logServices(`./${path.relative(root, servicesPath).replace(/\\/g, '/')}`);
+    }
+    if (sockets.length > 0) {
+        const socketSchema = socketsToSchema(sockets);
+        if (isTypeScript) {
+            const socketTypesPath = path.join(srcDir, GENERATED_SOCKET_TYPES_FILE);
+            await generateSocketTypesFile(socketTypesPath, socketSchema, socketBasePath);
+            logTypes(`./${path.relative(root, socketTypesPath).replace(/\\/g, '/')}`);
+        }
+        const socketServicesFileName = isTypeScript ? GENERATED_SOCKET_SERVICES_FILE : 'socket.services.js';
+        const socketServicesPath = path.join(srcDir, socketServicesFileName);
+        await generateSocketServicesFile(socketServicesPath, socketSchema, socketBasePath, isTypeScript);
+        logServices(`./${path.relative(root, socketServicesPath).replace(/\\/g, '/')}`);
+    }
+    if (openApi) {
+        try {
+            const openApiOptions = typeof openApi === 'boolean'
+                ? { apiBasePath }
+                : { ...openApi, apiBasePath: openApi.apiBasePath ?? apiBasePath };
+            const publicDir = path.join(root, 'public');
+            if (!fs.existsSync(publicDir)) {
+                fs.mkdirSync(publicDir, { recursive: true });
+            }
+            const openApiPath = path.join(publicDir, 'openapi.json');
+            await generateOpenApiFile(openApiPath, schema, openApiOptions);
+            logInfo(`OpenAPI spec generated: ./${path.relative(root, openApiPath).replace(/\\/g, '/')}`);
+            if (sockets.length > 0) {
+                const asyncApiPath = path.join(publicDir, 'asyncapi.json');
+                await generateAsyncApiFile(asyncApiPath, sockets, socketBasePath, {
+                    serverUrl: `ws://localhost:${serverPort}`,
+                });
+                logInfo(`AsyncAPI spec generated: ./${path.relative(root, asyncApiPath).replace(/\\/g, '/')}`);
+            }
+            const apiDocsPath = path.join(publicDir, 'api-docs.html');
+            const title = openApiOptions.info?.title ?? 'Vitek API';
+            const apiDocsHtml = generateApiDocsHtml('/openapi.json', title, {
+                asyncApiJsonPath: sockets.length > 0 ? '/asyncapi.json' : undefined,
+            });
+            fs.writeFileSync(apiDocsPath, apiDocsHtml, 'utf-8');
+            logInfo(`API docs at: ./${path.relative(root, apiDocsPath).replace(/\\/g, '/')} → http://localhost:${serverPort}/api-docs.html`);
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            logWarn(`Failed to generate OpenAPI spec: ${err.message}`);
+            onGenerationError?.(err);
+        }
+    }
+}

package/dist/core/generation/run-file-generation.test.d.ts

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

package/dist/core/generation/run-file-generation.test.d.ts.map

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

package/dist/core/generation/run-file-generation.test.js

@@ -0,0 +1,151 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import { parsedRoutesToSchema, runFileGeneration } from './run-file-generation.js';
+function parsedRoute(pattern, method, params = [], file) {
+    return {
+        method: method,
+        pattern,
+        params,
+        file: file ?? `/api/${pattern.replace(/:/g, '[id]')}.${method}.ts`,
+    };
+}
+function parsedSocket(pattern, params = []) {
+    return {
+        pattern,
+        params,
+        file: `/api/${pattern.replace(/:/g, '[id]')}.socket.ts`,
+    };
+}
+describe('parsedRoutesToSchema', () => {
+    let tmpDir;
+    beforeEach(() => {
+        tmpDir = fs.mkdtempSync(path.join(process.cwd(), 'run-file-gen-test-'));
+    });
+    afterEach(() => {
+        try {
+            fs.rmSync(tmpDir, { recursive: true });
+        }
+        catch {
+            //
+        }
+    });
+    it('returns schema with pattern, method, params', () => {
+        const routeFile = path.join(tmpDir, 'health.get.ts');
+        fs.writeFileSync(routeFile, 'export default function handler() {}', 'utf-8');
+        const routes = [
+            {
+                method: 'get',
+                pattern: 'health',
+                params: [],
+                file: routeFile,
+            },
+        ];
+        const schema = parsedRoutesToSchema(routes);
+        expect(schema).toHaveLength(1);
+        expect(schema[0].pattern).toBe('health');
+        expect(schema[0].method).toBe('get');
+        expect(schema[0].params).toEqual([]);
+    });
+    it('extracts bodyType when route file exports Body', () => {
+        const routeFile = path.join(tmpDir, 'users.post.ts');
+        fs.writeFileSync(routeFile, `export type Body = { email: string; name?: string; };
+export default function handler() {}`, 'utf-8');
+        const routes = [
+            {
+                method: 'post',
+                pattern: 'users',
+                params: [],
+                file: routeFile,
+            },
+        ];
+        const schema = parsedRoutesToSchema(routes);
+        expect(schema[0].bodyType).toBe('{ email: string; name?: string; }');
+    });
+    it('extracts queryType when route file exports Query', () => {
+        const routeFile = path.join(tmpDir, 'posts.get.ts');
+        fs.writeFileSync(routeFile, `export type Query = { limit?: number; };
+export default function handler() {}`, 'utf-8');
+        const routes = [
+            {
+                method: 'get',
+                pattern: 'posts',
+                params: [],
+                file: routeFile,
+            },
+        ];
+        const schema = parsedRoutesToSchema(routes);
+        expect(schema[0].queryType).toBe('{ limit?: number; }');
+    });
+});
+describe('runFileGeneration', () => {
+    let tmpDir;
+    beforeEach(() => {
+        tmpDir = fs.mkdtempSync(path.join(process.cwd(), 'run-file-gen-test-'));
+        fs.mkdirSync(path.join(tmpDir, 'src'), { recursive: true });
+    });
+    afterEach(() => {
+        try {
+            fs.rmSync(tmpDir, { recursive: true });
+        }
+        catch {
+            //
+        }
+    });
+    it('generates api.types.ts and api.services.ts for TypeScript project', async () => {
+        fs.writeFileSync(path.join(tmpDir, 'tsconfig.json'), '{}', 'utf-8');
+        const routeFile = path.join(tmpDir, 'src', 'api', 'health.get.ts');
+        fs.mkdirSync(path.dirname(routeFile), { recursive: true });
+        fs.writeFileSync(routeFile, 'export default function handler() {}', 'utf-8');
+        const schema = parsedRoutesToSchema([
+            { method: 'get', pattern: 'health', params: [], file: routeFile },
+        ]);
+        await runFileGeneration({
+            root: tmpDir,
+            schema,
+            sockets: [],
+            logger: {},
+        });
+        const typesPath = path.join(tmpDir, 'src', 'api.types.ts');
+        const servicesPath = path.join(tmpDir, 'src', 'api.services.ts');
+        expect(fs.existsSync(typesPath)).toBe(true);
+        expect(fs.existsSync(servicesPath)).toBe(true);
+        expect(fs.readFileSync(typesPath, 'utf-8')).toContain('VitekParams');
+        expect(fs.readFileSync(servicesPath, 'utf-8')).toContain('getHealth');
+    });
+    it('generates api.services.js only for JavaScript project', async () => {
+        const routeFile = path.join(tmpDir, 'src', 'api', 'health.get.js');
+        fs.mkdirSync(path.dirname(routeFile), { recursive: true });
+        fs.writeFileSync(routeFile, 'export default function handler() {}', 'utf-8');
+        const schema = parsedRoutesToSchema([
+            { method: 'get', pattern: 'health', params: [], file: routeFile },
+        ]);
+        await runFileGeneration({
+            root: tmpDir,
+            schema,
+            sockets: [],
+            logger: {},
+        });
+        expect(fs.existsSync(path.join(tmpDir, 'src', 'api.types.ts'))).toBe(false);
+        expect(fs.existsSync(path.join(tmpDir, 'src', 'api.services.js'))).toBe(true);
+    });
+    it('generates OpenAPI files when openApi is enabled', async () => {
+        fs.writeFileSync(path.join(tmpDir, 'tsconfig.json'), '{}', 'utf-8');
+        fs.mkdirSync(path.join(tmpDir, 'public'), { recursive: true });
+        const routeFile = path.join(tmpDir, 'src', 'api', 'health.get.ts');
+        fs.mkdirSync(path.dirname(routeFile), { recursive: true });
+        fs.writeFileSync(routeFile, 'export default function handler() {}', 'utf-8');
+        const schema = parsedRoutesToSchema([
+            { method: 'get', pattern: 'health', params: [], file: routeFile },
+        ]);
+        await runFileGeneration({
+            root: tmpDir,
+            schema,
+            sockets: [],
+            openApi: true,
+            logger: {},
+        });
+        expect(fs.existsSync(path.join(tmpDir, 'public', 'openapi.json'))).toBe(true);
+        expect(fs.existsSync(path.join(tmpDir, 'public', 'api-docs.html'))).toBe(true);
+    });
+});

package/dist/core/introspection/manifest.d.ts

@@ -0,0 +1,24 @@
+import type { ParsedRoute } from '../routing/route-parser.js';
+import type { ParsedSocket } from '../routing/socket-parser.js';
+export interface VitekManifest {
+    routes: Array<{
+        method: string;
+        pattern: string;
+        params: string[];
+        file: string;
+    }>;
+    middlewares: Array<{
+        basePattern: string;
+        path: string;
+    }>;
+    sockets: Array<{
+        pattern: string;
+        params: string[];
+        file: string;
+    }>;
+}
+export declare function getManifest(root: string, apiDir: string): VitekManifest;
+export declare function getRoutes(root: string, apiDir: string): ParsedRoute[];
+export declare function getSockets(root: string, apiDir: string): ParsedSocket[];
+export declare function writeManifest(root: string, apiDir: string, outDir: string): string;
+//# sourceMappingURL=manifest.d.ts.map

package/dist/core/introspection/manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../../../src/core/introspection/manifest.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAC9D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAEhE,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,KAAK,CAAC;QACZ,MAAM,EAAE,MAAM,CAAC;QACf,OAAO,EAAE,MAAM,CAAC;QAChB,MAAM,EAAE,MAAM,EAAE,CAAC;QACjB,IAAI,EAAE,MAAM,CAAC;KACd,CAAC,CAAC;IACH,WAAW,EAAE,KAAK,CAAC;QACjB,WAAW,EAAE,MAAM,CAAC;QACpB,IAAI,EAAE,MAAM,CAAC;KACd,CAAC,CAAC;IACH,OAAO,EAAE,KAAK,CAAC;QACb,OAAO,EAAE,MAAM,CAAC;QAChB,MAAM,EAAE,MAAM,EAAE,CAAC;QACjB,IAAI,EAAE,MAAM,CAAC;KACd,CAAC,CAAC;CACJ;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,aAAa,CAoBvE;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,WAAW,EAAE,CAIrE;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,YAAY,EAAE,CAIvE;AAED,wBAAgB,aAAa,CAC3B,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,GACb,MAAM,CAMR"}

package/dist/core/introspection/manifest.js

@@ -0,0 +1,41 @@
+import * as path from 'path';
+import * as fs from 'fs';
+import { scanApiDirectory } from '../file-system/scan-api-dir.js';
+export function getManifest(root, apiDir) {
+    const fullApiDir = path.isAbsolute(apiDir) ? apiDir : path.resolve(root, apiDir);
+    const scanResult = scanApiDirectory(fullApiDir);
+    return {
+        routes: scanResult.routes.map((r) => ({
+            method: r.method,
+            pattern: r.pattern,
+            params: r.params,
+            file: path.relative(root, r.file).replace(/\\/g, '/'),
+        })),
+        middlewares: scanResult.middlewares.map((m) => ({
+            basePattern: m.basePattern,
+            path: path.relative(root, m.path).replace(/\\/g, '/'),
+        })),
+        sockets: scanResult.sockets.map((s) => ({
+            pattern: s.pattern,
+            params: s.params,
+            file: path.relative(root, s.file).replace(/\\/g, '/'),
+        })),
+    };
+}
+export function getRoutes(root, apiDir) {
+    const fullApiDir = path.isAbsolute(apiDir) ? apiDir : path.resolve(root, apiDir);
+    const scanResult = scanApiDirectory(fullApiDir);
+    return scanResult.routes;
+}
+export function getSockets(root, apiDir) {
+    const fullApiDir = path.isAbsolute(apiDir) ? apiDir : path.resolve(root, apiDir);
+    const scanResult = scanApiDirectory(fullApiDir);
+    return scanResult.sockets;
+}
+export function writeManifest(root, apiDir, outDir) {
+    const manifest = getManifest(root, apiDir);
+    const manifestPath = path.join(outDir, 'vitek-manifest.json');
+    fs.mkdirSync(outDir, { recursive: true });
+    fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2), 'utf-8');
+    return manifestPath;
+}

package/dist/core/introspection/manifest.test.d.ts

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

package/dist/core/introspection/manifest.test.d.ts.map

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

package/dist/core/introspection/manifest.test.js

@@ -0,0 +1,62 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import { getManifest, getRoutes, getSockets, writeManifest } from './manifest.js';
+describe('manifest', () => {
+    let rootDir;
+    let apiDir;
+    beforeEach(() => {
+        rootDir = fs.mkdtempSync(path.join(process.cwd(), 'vitek-manifest-test-'));
+        apiDir = path.join(rootDir, 'src', 'api');
+        fs.mkdirSync(apiDir, { recursive: true });
+        fs.writeFileSync(path.join(apiDir, 'health.get.ts'), 'export default () => ({});');
+    });
+    afterEach(() => {
+        try {
+            fs.rmSync(rootDir, { recursive: true });
+        }
+        catch {
+            // ignore cleanup errors
+        }
+    });
+    it('getManifest returns routes, middlewares, sockets', () => {
+        const manifest = getManifest(rootDir, 'src/api');
+        expect(manifest).toHaveProperty('routes');
+        expect(manifest).toHaveProperty('middlewares');
+        expect(manifest).toHaveProperty('sockets');
+        expect(Array.isArray(manifest.routes)).toBe(true);
+        expect(Array.isArray(manifest.middlewares)).toBe(true);
+        expect(Array.isArray(manifest.sockets)).toBe(true);
+        expect(manifest.routes.length).toBeGreaterThan(0);
+    });
+    it('getRoutes returns ParsedRoute[]', () => {
+        const routes = getRoutes(rootDir, 'src/api');
+        expect(Array.isArray(routes)).toBe(true);
+        routes.forEach((r) => {
+            expect(r).toHaveProperty('method');
+            expect(r).toHaveProperty('pattern');
+            expect(r).toHaveProperty('params');
+            expect(r).toHaveProperty('file');
+        });
+    });
+    it('getSockets returns ParsedSocket[]', () => {
+        const sockets = getSockets(rootDir, 'src/api');
+        expect(Array.isArray(sockets)).toBe(true);
+    });
+    it('getManifest with non-existent apiDir returns empty arrays', () => {
+        const manifest = getManifest(rootDir, 'non-existent-dir');
+        expect(manifest.routes).toEqual([]);
+        expect(manifest.middlewares).toEqual([]);
+        expect(manifest.sockets).toEqual([]);
+    });
+    it('writeManifest writes vitek-manifest.json', () => {
+        const outDir = path.join(rootDir, 'dist');
+        const written = writeManifest(rootDir, 'src/api', outDir);
+        expect(written).toBe(path.join(outDir, 'vitek-manifest.json'));
+        expect(fs.existsSync(written)).toBe(true);
+        const content = JSON.parse(fs.readFileSync(written, 'utf-8'));
+        expect(content).toHaveProperty('routes');
+        expect(content).toHaveProperty('middlewares');
+        expect(content).toHaveProperty('sockets');
+    });
+});

package/dist/core/middleware/get-applicable-middlewares.d.ts

@@ -9,7 +9,14 @@ import type { Middleware } from '../routing/route-types.js';
 export interface LoadedMiddleware {
     middleware: Middleware[];
     basePattern: string;
+    /** Optional path matcher for global middleware (basePattern ''). Only routes matching one of these patterns get this middleware. E.g. ['protected/*', 'admin'] */
+    pathPatterns?: string[];
 }
+/**
+ * Returns true if routePattern matches a single path pattern.
+ * Pattern may be exact ('admin') or prefix with * ('admin/*'). No leading slash.
+ */
+export declare function matchPathPattern(routePattern: string, configPattern: string): boolean;
 /**
  * Returns the middlewares applicable to a route, ordered from most generic to most specific
  */

package/dist/core/middleware/get-applicable-middlewares.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"get-applicable-middlewares.d.ts","sourceRoot":"","sources":["../../../src/core/middleware/get-applicable-middlewares.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAG5D;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,UAAU,EAAE,UAAU,EAAE,CAAC;IACzB,WAAW,EAAE,MAAM,CAAC;CACrB;AAuCD;;GAEG;AACH,wBAAgB,wBAAwB,CACtC,WAAW,EAAE,gBAAgB,EAAE,EAC/B,YAAY,EAAE,MAAM,GACnB,UAAU,EAAE,CAUd"}
+{"version":3,"file":"get-applicable-middlewares.d.ts","sourceRoot":"","sources":["../../../src/core/middleware/get-applicable-middlewares.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAG5D;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,UAAU,EAAE,UAAU,EAAE,CAAC;IACzB,WAAW,EAAE,MAAM,CAAC;IACpB,kKAAkK;IAClK,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;CACzB;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,YAAY,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,OAAO,CAQrF;AA+BD;;GAEG;AACH,wBAAgB,wBAAwB,CACtC,WAAW,EAAE,gBAAgB,EAAE,EAC/B,YAAY,EAAE,MAAM,GACnB,UAAU,EAAE,CAUd"}

package/dist/core/middleware/get-applicable-middlewares.js

@@ -2,35 +2,43 @@
  * Determines which middlewares are applicable to a route based on the pattern
  * Core logic - no dependencies
  */
+/**
+ * Returns true if routePattern matches a single path pattern.
+ * Pattern may be exact ('admin') or prefix with * ('admin/*'). No leading slash.
+ */
+export function matchPathPattern(routePattern, configPattern) {
+    const route = routePattern.replace(/^\/+|\/+$/g, '');
+    const pattern = configPattern.replace(/^\/+|\/+$/g, '');
+    if (pattern.endsWith('/*')) {
+        const prefix = pattern.slice(0, -2);
+        return route === prefix || route.startsWith(prefix + '/');
+    }
+    return route === pattern || route.startsWith(pattern + '/');
+}
 /**
  * Checks if a middleware base pattern applies to a route pattern
  * A middleware applies if its basePattern is a prefix of the routePattern
- *
- * Examples:
- * - basePattern: "" → applies to all routes (global)
- * - basePattern: "posts" → applies to "posts", "posts/:id", "posts/:id/comments", etc
- * - basePattern: "posts/:id" → applies to "posts/:id", "posts/:id/comments", but not to "posts"
+ * For global middleware (basePattern '') with pathPatterns, applies only if route matches one of them.
  */
-function isMiddlewareApplicable(basePattern, routePattern) {
-    // Global middleware (empty basePattern) applies to all routes
+function isMiddlewareApplicable(loaded, routePattern) {
+    const { basePattern, pathPatterns } = loaded;
+    // Global middleware (empty basePattern)
     if (basePattern === '') {
+        if (pathPatterns != null && pathPatterns.length > 0) {
+            return pathPatterns.some((p) => matchPathPattern(routePattern, p));
+        }
         return true;
     }
     // If route is empty (root), only global middleware applies
     if (routePattern === '') {
         return false;
     }
-    // Normalize patterns for comparison (remove leading/trailing slashes)
     const normalizedBase = basePattern.replace(/^\/+|\/+$/g, '');
     const normalizedRoute = routePattern.replace(/^\/+|\/+$/g, '');
-    // Check if basePattern is an exact prefix of routePattern
-    // Or if route starts with basePattern followed by /
-    if (normalizedRoute === normalizedBase) {
+    if (normalizedRoute === normalizedBase)
         return true;
-    }
-    if (normalizedRoute.startsWith(normalizedBase + '/')) {
+    if (normalizedRoute.startsWith(normalizedBase + '/'))
         return true;
-    }
     return false;
 }
 /**
@@ -39,7 +47,7 @@ function isMiddlewareApplicable(basePattern, routePattern) {
 export function getApplicableMiddlewares(middlewares, routePattern) {
     const applicable = [];
     for (const loadedMiddleware of middlewares) {
-        if (isMiddlewareApplicable(loadedMiddleware.basePattern, routePattern)) {
+        if (isMiddlewareApplicable(loadedMiddleware, routePattern)) {
             applicable.push(...loadedMiddleware.middleware);
         }
     }