@prism-engineer/router/dist/tests/router/multiple-route-loading.test.js

Type-safe Express.js router with automatic client generation

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const vitest_1 = require("vitest");
const router_1 = require("../../router");
const path_1 = __importDefault(require("path"));
(0, vitest_1.describe)('Router System - Multiple Route Loading', () => {
    let router;
    (0, vitest_1.beforeEach)(() => {
        router = (0, router_1.createRouter)();
        vitest_1.vi.clearAllMocks();
    });
    (0, vitest_1.it)('should load routes from multiple directories sequentially', async () => {
        const apiPath = path_1.default.join(__dirname, 'fixtures/api');
        const adminPath = path_1.default.join(__dirname, 'fixtures/admin');
        await router.loadRoutes(apiPath, /\.ts$/);
        await router.loadRoutes(adminPath, /\.ts$/);
        (0, vitest_1.expect)(router.app).toBeDefined();
    });
    (0, vitest_1.it)('should load routes from nested directory structures', async () => {
        const apiPath = path_1.default.join(__dirname, 'fixtures/api');
        const v1Path = path_1.default.join(__dirname, 'fixtures/api/v1');
        const v2Path = path_1.default.join(__dirname, 'fixtures/api/v2');
        await router.loadRoutes(apiPath, /\.ts$/);
        await router.loadRoutes(v1Path, /\.ts$/);
        await router.loadRoutes(v2Path, /\.ts$/);
        (0, vitest_1.expect)(router.app).toBeDefined();
    });
    (0, vitest_1.it)('should handle concurrent route loading from multiple directories', async () => {
        const apiPath = path_1.default.join(__dirname, 'fixtures/api');
        const adminPath = path_1.default.join(__dirname, 'fixtures/admin');
        const promises = [
            router.loadRoutes(apiPath, /\.ts$/),
            router.loadRoutes(adminPath, /\.ts$/)
        ];
        await (0, vitest_1.expect)(Promise.all(promises)).resolves.not.toThrow();
    });
    (0, vitest_1.it)('should load routes with different patterns from same directory', async () => {
        const apiPath = path_1.default.join(__dirname, 'fixtures/api');
        // Load different file patterns from same directory
        await router.loadRoutes(apiPath, /hello\.ts$/);
        await router.loadRoutes(apiPath, /users\.ts$/);
        (0, vitest_1.expect)(router.app).toBeDefined();
    });
    (0, vitest_1.it)('should load routes from multiple versioned directories', async () => {
        const v1Path = path_1.default.join(__dirname, 'fixtures/api/v1');
        const v2Path = path_1.default.join(__dirname, 'fixtures/api/v2');
        // Load same resource from different versions
        await router.loadRoutes(v1Path, /posts\.ts$/);
        await router.loadRoutes(v2Path, /posts\.ts$/);
        (0, vitest_1.expect)(router.app).toBeDefined();
    });
    (0, vitest_1.it)('should maintain route loading order across directories', async () => {
        const loadingOrder = [
            { path: path_1.default.join(__dirname, 'fixtures/api'), pattern: /hello\.ts$/ },
            { path: path_1.default.join(__dirname, 'fixtures/api'), pattern: /users\.ts$/ },
            { path: path_1.default.join(__dirname, 'fixtures/admin'), pattern: /dashboard\.ts$/ }
        ];
        for (const { path: dirPath, pattern } of loadingOrder) {
            await router.loadRoutes(dirPath, pattern);
        }
        (0, vitest_1.expect)(router.app).toBeDefined();
    });
    (0, vitest_1.it)('should handle overlapping route patterns across directories', async () => {
        const apiPath = path_1.default.join(__dirname, 'fixtures/api');
        const adminPath = path_1.default.join(__dirname, 'fixtures/admin');
        // Load all .ts files from both directories
        await router.loadRoutes(apiPath, /\.ts$/);
        await router.loadRoutes(adminPath, /\.ts$/);
        (0, vitest_1.expect)(router.app).toBeDefined();
    });
    (0, vitest_1.it)('should load routes from directories with different structures', async () => {
        const flatPath = path_1.default.join(__dirname, 'fixtures/api');
        const nestedPath = path_1.default.join(__dirname, 'fixtures/api/v1');
        await router.loadRoutes(flatPath, /\.ts$/);
        await router.loadRoutes(nestedPath, /\.ts$/);
        (0, vitest_1.expect)(router.app).toBeDefined();
    });
    (0, vitest_1.it)('should handle selective loading from multiple directories', async () => {
        const directories = [
            { path: path_1.default.join(__dirname, 'fixtures/api'), pattern: /hello\.ts$/ },
            { path: path_1.default.join(__dirname, 'fixtures/api'), pattern: /users\.ts$/ },
            { path: path_1.default.join(__dirname, 'fixtures/api/v1'), pattern: /posts\.ts$/ },
            { path: path_1.default.join(__dirname, 'fixtures/api/v2'), pattern: /posts\.ts$/ }
        ];
        for (const { path: dirPath, pattern } of directories) {
            await router.loadRoutes(dirPath, pattern);
        }
        (0, vitest_1.expect)(router.app).toBeDefined();
    });
    (0, vitest_1.it)('should load routes with mixed file extensions from multiple directories', async () => {
        const apiPath = path_1.default.join(__dirname, 'fixtures/api');
        const adminPath = path_1.default.join(__dirname, 'fixtures/admin');
        // Load TypeScript files from both
        await router.loadRoutes(apiPath, /\.ts$/);
        await router.loadRoutes(adminPath, /\.ts$/);
        // Try loading JavaScript files (should handle gracefully if none exist)
        await router.loadRoutes(apiPath, /\.js$/);
        (0, vitest_1.expect)(router.app).toBeDefined();
    });
    (0, vitest_1.it)('should handle route conflicts across multiple directories', async () => {
        const v1Path = path_1.default.join(__dirname, 'fixtures/api/v1');
        const v2Path = path_1.default.join(__dirname, 'fixtures/api/v2');
        // Both directories have posts.ts - should handle conflicts
        await router.loadRoutes(v1Path, /posts\.ts$/);
        await router.loadRoutes(v2Path, /posts\.ts$/);
        (0, vitest_1.expect)(router.app).toBeDefined();
    });
    (0, vitest_1.it)('should load routes from directories with different naming conventions', async () => {
        const directories = [
            path_1.default.join(__dirname, 'fixtures/api'), // kebab-case style
            path_1.default.join(__dirname, 'fixtures/admin'), // single word
            path_1.default.join(__dirname, 'fixtures/api/v1'), // versioned
            path_1.default.join(__dirname, 'fixtures/api/v2') // versioned
        ];
        for (const dirPath of directories) {
            await router.loadRoutes(dirPath, /\.ts$/);
        }
        (0, vitest_1.expect)(router.app).toBeDefined();
    });
    (0, vitest_1.it)('should handle error recovery when loading from multiple directories', async () => {
        const validPath = path_1.default.join(__dirname, 'fixtures/api');
        const invalidPath = path_1.default.join(__dirname, 'fixtures/nonexistent');
        const anotherValidPath = path_1.default.join(__dirname, 'fixtures/admin');
        // Should continue loading after encountering an error
        await router.loadRoutes(validPath, /\.ts$/);
        await (0, vitest_1.expect)(router.loadRoutes(invalidPath, /\.ts$/)).rejects.toThrow();
        await router.loadRoutes(anotherValidPath, /\.ts$/);
        (0, vitest_1.expect)(router.app).toBeDefined();
    });
    (0, vitest_1.it)('should load routes with complex directory hierarchies', async () => {
        const hierarchyPaths = [
            path_1.default.join(__dirname, 'fixtures'),
            path_1.default.join(__dirname, 'fixtures/api'),
            path_1.default.join(__dirname, 'fixtures/api/v1'),
            path_1.default.join(__dirname, 'fixtures/api/v2'),
            path_1.default.join(__dirname, 'fixtures/admin')
        ];
        for (const dirPath of hierarchyPaths) {
            await router.loadRoutes(dirPath, /\.ts$/);
        }
        (0, vitest_1.expect)(router.app).toBeDefined();
    });
    (0, vitest_1.it)('should handle incremental route loading', async () => {
        // Load routes incrementally
        await router.loadRoutes(path_1.default.join(__dirname, 'fixtures/api'), /hello\.ts$/);
        (0, vitest_1.expect)(router.app).toBeDefined();
        await router.loadRoutes(path_1.default.join(__dirname, 'fixtures/api'), /users\.ts$/);
        (0, vitest_1.expect)(router.app).toBeDefined();
        await router.loadRoutes(path_1.default.join(__dirname, 'fixtures/admin'), /dashboard\.ts$/);
        (0, vitest_1.expect)(router.app).toBeDefined();
    });
    (0, vitest_1.it)('should load routes from directories with different access patterns', async () => {
        const patterns = [
            /\.ts$/, // All TypeScript files
            /hello\.ts$/, // Specific file
            /^(?!.*malformed).*\.ts$/, // Exclude malformed files
            /[a-z]+\.ts$/ // Lowercase names only
        ];
        const apiPath = path_1.default.join(__dirname, 'fixtures/api');
        for (const pattern of patterns) {
            await router.loadRoutes(apiPath, pattern);
        }
        (0, vitest_1.expect)(router.app).toBeDefined();
    });
    (0, vitest_1.it)('should handle route deduplication across multiple loads', async () => {
        const apiPath = path_1.default.join(__dirname, 'fixtures/api');
        // Load same routes multiple times
        await router.loadRoutes(apiPath, /hello\.ts$/);
        await router.loadRoutes(apiPath, /hello\.ts$/);
        await router.loadRoutes(apiPath, /hello\.ts$/);
        (0, vitest_1.expect)(router.app).toBeDefined();
    });
    (0, vitest_1.it)('should handle batch loading with different configurations', async () => {
        const configurations = [
            { path: path_1.default.join(__dirname, 'fixtures/api'), pattern: /\.ts$/, description: 'API routes' },
            { path: path_1.default.join(__dirname, 'fixtures/admin'), pattern: /\.ts$/, description: 'Admin routes' },
            { path: path_1.default.join(__dirname, 'fixtures/api/v1'), pattern: /\.ts$/, description: 'V1 routes' },
            { path: path_1.default.join(__dirname, 'fixtures/api/v2'), pattern: /\.ts$/, description: 'V2 routes' }
        ];
        for (const { path: dirPath, pattern } of configurations) {
            await router.loadRoutes(dirPath, pattern);
        }
        (0, vitest_1.expect)(router.app).toBeDefined();
    });
    (0, vitest_1.it)('should maintain route registry across multiple directory loads', async () => {
        const firstLoad = router.loadRoutes(path_1.default.join(__dirname, 'fixtures/api'), /hello\.ts$/);
        const secondLoad = router.loadRoutes(path_1.default.join(__dirname, 'fixtures/admin'), /dashboard\.ts$/);
        await Promise.all([firstLoad, secondLoad]);
        // Router should maintain all loaded routes
        (0, vitest_1.expect)(router.app).toBeDefined();
    });
    (0, vitest_1.it)('should handle mixed success and failure scenarios', async () => {
        const validPath1 = path_1.default.join(__dirname, 'fixtures/api');
        const validPath2 = path_1.default.join(__dirname, 'fixtures/admin');
        // Mix valid and potentially problematic loads
        await router.loadRoutes(validPath1, /\.ts$/);
        await router.loadRoutes(validPath2, /\.ts$/);
        await router.loadRoutes(path_1.default.join(__dirname, 'fixtures'), /malformed\.ts$/);
        (0, vitest_1.expect)(router.app).toBeDefined();
    });
});
//# sourceMappingURL=multiple-route-loading.test.js.map