@j3r3mcdev/oast-server 1.0.0

package/dist/api/sse/events.stream.js

@@ -0,0 +1,63 @@
+"use strict";
+// src/api/sse/event-stream.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventStreamManager = void 0;
+class EventStreamManager {
+    constructor(config = {}) {
+        this.clients = new Map();
+        this.heartbeatTimer = null;
+        this.config = {
+            retry: config.retry ?? 2000,
+            heartbeatInterval: config.heartbeatInterval ?? 15000,
+            logger: config.logger ?? console,
+        };
+        this.startHeartbeat();
+    }
+    startHeartbeat() {
+        if (process.env.NODE_ENV === "test")
+            return;
+        this.heartbeatTimer = setInterval(() => {
+            for (const client of this.clients.values()) {
+                client.res.write(`: heartbeat\n\n`);
+            }
+        }, this.config.heartbeatInterval);
+    }
+    addClient(res, channels = []) {
+        const id = crypto.randomUUID();
+        const client = {
+            id,
+            res,
+            channels: new Set(channels),
+            connectedAt: Date.now(),
+        };
+        this.clients.set(id, client);
+        res.write(`retry: ${this.config.retry}\n`);
+        res.write(`event: connected\ndata: {"id":"${id}"}\n\n`);
+        res.on("close", () => this.removeClient(id));
+        this.config.logger.info(`SSE client connected: ${id}`);
+        return id;
+    }
+    removeClient(id) {
+        if (this.clients.has(id)) {
+            this.clients.delete(id);
+            this.config.logger.info(`SSE client disconnected: ${id}`);
+        }
+    }
+    broadcast(channel, event, data) {
+        const payload = `event: ${event}\n` +
+            `data: ${JSON.stringify(data)}\n` +
+            `channel: ${channel}\n\n`;
+        for (const client of this.clients.values()) {
+            if (client.channels.has(channel)) {
+                client.res.write(payload);
+            }
+        }
+    }
+    broadcastAll(event, data) {
+        const payload = `event: ${event}\n` + `data: ${JSON.stringify(data)}\n\n`;
+        for (const client of this.clients.values()) {
+            client.res.write(payload);
+        }
+    }
+}
+exports.EventStreamManager = EventStreamManager;

package/dist/config/constants.js

@@ -0,0 +1 @@
+"use strict";

package/dist/config/env.js

@@ -0,0 +1 @@
+"use strict";

package/dist/core/__tests__/core-router.test.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const router_1 = require("../router");
+const memory_storage_1 = require("../../storage-adapters/adapters/memory.storage");
+const globals_1 = require("@jest/globals");
+(0, globals_1.describe)("CoreRouter", () => {
+    const event = {
+        id: "abc",
+        type: "http",
+        timestamp: 111,
+        sourceIp: "1.1.1.1",
+        request: {
+            method: "GET",
+            path: "/",
+            headers: {},
+            query: {},
+            body: {},
+        },
+    };
+    (0, globals_1.it)("appelle les hooks", async () => {
+        const hook = globals_1.jest.fn((e) => { }); // ← FIX
+        const router = new router_1.CoreRouter(new memory_storage_1.MemoryStorage(), { hooks: [hook] });
+        await router.dispatch(event);
+        (0, globals_1.expect)(hook).toHaveBeenCalledWith(event);
+    });
+});

package/dist/core/__tests__/core-server.test.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const server_1 = require("../../core/server");
+const storage_1 = require("../../core/storage");
+const logger_1 = require("../../core/logger");
+const globals_1 = require("@jest/globals");
+class FakeListener {
+    constructor() {
+        this.started = false;
+        this.stopped = false;
+    }
+    async start() {
+        this.started = true;
+    }
+    async stop() {
+        this.stopped = true;
+    }
+}
+(0, globals_1.describe)("CoreServer", () => {
+    (0, globals_1.it)("démarre et arrête les listeners", async () => {
+        const listener = new FakeListener();
+        const server = new server_1.CoreServer({
+            storage: new storage_1.StorageManager(),
+            logger: new logger_1.Logger({ enabled: false }),
+            listeners: [listener],
+        });
+        await server.start();
+        (0, globals_1.expect)(listener.started).toBe(true);
+        await server.stop();
+        (0, globals_1.expect)(listener.stopped).toBe(true);
+    });
+    (0, globals_1.it)("expose le router", () => {
+        const server = new server_1.CoreServer({
+            storage: new storage_1.StorageManager(),
+        });
+        const router = server.getRouter();
+        (0, globals_1.expect)(router).toBeDefined();
+    });
+});

package/dist/core/__tests__/event.normalizer.test.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const event_normalizer_1 = require("../event.normalizer");
+const globals_1 = require("@jest/globals");
+const id_generator_1 = require("../id-generator");
+(0, globals_1.describe)("EventNormalizer.normalizeHttp", () => {
+    (0, globals_1.it)("normalise correctement une requête HTTP", () => {
+        // Mock du timestamp
+        const fakeNow = 1234567890;
+        globals_1.jest.spyOn(Date, "now").mockReturnValue(fakeNow);
+        // Mock de l'ID
+        globals_1.jest.spyOn(id_generator_1.IdGenerator, "generate").mockReturnValue("uuid-test");
+        const req = {
+            ip: "9.9.9.9",
+            method: "POST",
+            path: "/test",
+            headers: { "x-forwarded-for": "9.9.9.9" },
+            query: { a: "1" },
+            body: { hello: "world" },
+            raw: {}, // obligatoire
+        };
+        const event = event_normalizer_1.EventNormalizer.normalizeHttp(req);
+        (0, globals_1.expect)(event).toEqual({
+            id: "uuid-test",
+            type: "http",
+            timestamp: fakeNow,
+            sourceIp: "9.9.9.9",
+            request: {
+                method: "POST",
+                path: "/test",
+                headers: { "x-forwarded-for": "9.9.9.9" },
+                query: { a: "1" },
+                body: { hello: "world" },
+            },
+        });
+    });
+    (0, globals_1.it)("retourne 'unknown' si aucune IP n'est trouvée", () => {
+        const req = {
+            ip: "",
+            method: "GET",
+            path: "/",
+            headers: {},
+            query: {},
+            body: {},
+            raw: {},
+        };
+        const event = event_normalizer_1.EventNormalizer.normalizeHttp(req);
+        (0, globals_1.expect)(event.sourceIp).toBe("unknown");
+    });
+});

package/dist/core/__tests__/event.router.test.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const event_router_1 = require("../event.router");
+const event_normalizer_1 = require("../event.normalizer");
+const globals_1 = require("@jest/globals");
+class MockStorage {
+    constructor() {
+        this.save = globals_1.jest.fn();
+        this.getEvent = globals_1.jest.fn();
+        this.listEvents = globals_1.jest.fn();
+        this.deleteEvent = globals_1.jest.fn();
+        this.clearEvents = globals_1.jest.fn();
+        this.getStats = globals_1.jest.fn();
+        this.getAll = globals_1.jest.fn();
+    }
+}
+(0, globals_1.describe)("EventRouter", () => {
+    (0, globals_1.it)("enregistre un événement HTTP normalisé", async () => {
+        const mockStorage = new MockStorage();
+        const fakeEvent = {
+            id: "123",
+            type: "http",
+            timestamp: 111,
+            sourceIp: "1.1.1.1",
+            request: {
+                method: "GET",
+                path: "/",
+                headers: {},
+                query: {},
+                body: {},
+            },
+        };
+        globals_1.jest.spyOn(event_normalizer_1.EventNormalizer, "normalizeHttp").mockReturnValue(fakeEvent);
+        const router = new event_router_1.EventRouter(mockStorage);
+        const req = {
+            ip: "1.1.1.1",
+            method: "GET",
+            path: "/",
+            headers: {},
+            query: {},
+            body: {},
+            raw: {},
+        };
+        const result = await router.handleHttp(req);
+        (0, globals_1.expect)(event_normalizer_1.EventNormalizer.normalizeHttp).toHaveBeenCalledWith(req);
+        (0, globals_1.expect)(mockStorage.save).toHaveBeenCalledWith(fakeEvent);
+        (0, globals_1.expect)(result).toEqual(fakeEvent);
+    });
+    (0, globals_1.it)("propagate une erreur si normalizeHttp throw", async () => {
+        const mockStorage = new MockStorage();
+        globals_1.jest.spyOn(event_normalizer_1.EventNormalizer, "normalizeHttp").mockImplementation(() => {
+            throw new Error("Boom");
+        });
+        const router = new event_router_1.EventRouter(mockStorage);
+        await (0, globals_1.expect)(router.handleHttp({})).rejects.toThrow("Boom");
+        (0, globals_1.expect)(mockStorage.save).not.toHaveBeenCalled();
+    });
+    (0, globals_1.it)("propagate une erreur si storage.save throw", async () => {
+        const mockStorage = new MockStorage();
+        const fakeEvent = { id: "x", type: "http" };
+        globals_1.jest.spyOn(event_normalizer_1.EventNormalizer, "normalizeHttp").mockReturnValue(fakeEvent);
+        mockStorage.save.mockRejectedValue(new Error("DB error"));
+        const router = new event_router_1.EventRouter(mockStorage);
+        await (0, globals_1.expect)(router.handleHttp({})).rejects.toThrow("DB error");
+    });
+});

package/dist/core/__tests__/logger.test.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const logger_1 = require("../../core/logger");
+const globals_1 = require("@jest/globals");
+(0, globals_1.describe)("Logger", () => {
+    (0, globals_1.it)("appelle les hooks", () => {
+        const hook = globals_1.jest.fn();
+        const logger = new logger_1.Logger({ hooks: [hook], enabled: true });
+        logger.info("hello");
+        (0, globals_1.expect)(hook).toHaveBeenCalled();
+        (0, globals_1.expect)(hook.mock.calls[0][0].message).toBe("hello");
+    });
+    (0, globals_1.it)("respecte le niveau de logs", () => {
+        const hook = globals_1.jest.fn();
+        const logger = new logger_1.Logger({ level: "warn", hooks: [hook] });
+        logger.info("should not log");
+        logger.error("should log");
+        (0, globals_1.expect)(hook).toHaveBeenCalledTimes(1);
+        (0, globals_1.expect)(hook.mock.calls[0][0].level).toBe("error");
+    });
+    (0, globals_1.it)("crée un logger enfant avec contexte", () => {
+        const logger = new logger_1.Logger({ context: "root" });
+        const child = logger.withContext("child");
+        (0, globals_1.expect)(child).not.toBe(logger);
+    });
+});

package/dist/core/__tests__/storage-manager.test.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const globals_1 = require("@jest/globals");
+const storage_1 = require("../storage"); // si ton fichier s'appelle storage-manager.ts
+function makeHttpEvent(id) {
+    return {
+        id,
+        type: "http",
+        timestamp: Date.now(),
+        sourceIp: "127.0.0.1",
+        request: {
+            method: "GET",
+            path: "/",
+            headers: {},
+            query: {},
+            body: "",
+        },
+    };
+}
+(0, globals_1.describe)("StorageManager", () => {
+    (0, globals_1.test)("save + getEvent", async () => {
+        const storage = new storage_1.StorageManager();
+        const event = makeHttpEvent("1");
+        await storage.save(event);
+        const found = await storage.getEvent("1");
+        (0, globals_1.expect)(found).not.toBeNull();
+        (0, globals_1.expect)(found?.id).toBe("1");
+    });
+    (0, globals_1.test)("listEvents returns events", async () => {
+        const storage = new storage_1.StorageManager();
+        await storage.save(makeHttpEvent("1"));
+        const list = await storage.listEvents({});
+        (0, globals_1.expect)(list.length).toBe(1);
+    });
+    (0, globals_1.test)("deleteEvent removes event", async () => {
+        const storage = new storage_1.StorageManager();
+        await storage.save(makeHttpEvent("1"));
+        let list = await storage.listEvents({});
+        (0, globals_1.expect)(list.length).toBe(1);
+        await storage.deleteEvent("1");
+        list = await storage.listEvents({});
+        (0, globals_1.expect)(list.length).toBe(0);
+    });
+    (0, globals_1.test)("clearEvents empties storage", async () => {
+        const storage = new storage_1.StorageManager();
+        await storage.save(makeHttpEvent("1"));
+        await storage.clearEvents();
+        const list = await storage.listEvents({});
+        (0, globals_1.expect)(list.length).toBe(0);
+    });
+    (0, globals_1.test)("getStats returns correct structure", async () => {
+        const storage = new storage_1.StorageManager();
+        const stats = await storage.getStats();
+        (0, globals_1.expect)(stats.total).toBe(0);
+        (0, globals_1.expect)(stats.byType).toEqual({});
+    });
+});

package/dist/core/event.normalizer.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventNormalizer = void 0;
+const id_generator_1 = require("./id-generator");
+class EventNormalizer {
+    //
+    // -------------------------
+    // DNS
+    // -------------------------
+    //
+    static normalizeDns(event) {
+        return {
+            id: id_generator_1.IdGenerator.generate(),
+            type: "dns",
+            timestamp: Date.now(),
+            ip: event.ip ?? "",
+            query: event.query ?? "",
+            recordType: event.recordType ?? "",
+            raw: event.raw,
+        };
+    }
+    //
+    // -------------------------
+    // HTTP
+    // -------------------------
+    //
+    static normalizeHttp(event) {
+        const sourceIp = event.ip && event.ip.trim() !== "" ? event.ip : "unknown";
+        return {
+            id: id_generator_1.IdGenerator.generate(),
+            type: "http",
+            timestamp: Date.now(),
+            sourceIp,
+            request: {
+                method: event.method,
+                path: event.path,
+                headers: event.headers,
+                query: event.query,
+                body: event.body,
+            },
+        };
+    }
+    //
+    // -------------------------
+    // SMTP
+    // -------------------------
+    //
+    static normalizeSmtp(event) {
+        return {
+            id: id_generator_1.IdGenerator.generate(),
+            type: "smtp",
+            timestamp: Date.now(),
+            ip: event.ip ?? "",
+            from: event.from ?? "",
+            to: event.to ?? [],
+            subject: event.subject ?? "",
+            body: event.body ?? "",
+            raw: event.raw,
+        };
+    }
+    //
+    // -------------------------
+    // TCP
+    // -------------------------
+    //
+    static normalizeTcp(event) {
+        return {
+            id: id_generator_1.IdGenerator.generate(),
+            type: "tcp",
+            timestamp: Date.now(),
+            ip: event.ip ?? "",
+            port: event.port ?? 0,
+            data: event.data ?? "",
+            raw: event.raw,
+        };
+    }
+    //
+    // -------------------------
+    // SSRF
+    // -------------------------
+    //
+    static normalizeSsrf(raw) {
+        return {
+            id: id_generator_1.IdGenerator.generate(),
+            type: "ssrf",
+            timestamp: Date.now(),
+            sourceIp: raw.ip,
+            request: {
+                method: raw.method,
+                path: raw.path,
+                headers: raw.headers,
+                query: raw.query,
+            },
+        };
+    }
+    //
+    // -------------------------
+    // webhook
+    // -------------------------
+    //
+    static normalizeWebhook(raw) {
+        return {
+            id: id_generator_1.IdGenerator.generate(),
+            type: "webhook",
+            timestamp: Date.now(),
+            sourceIp: raw.ip,
+            headers: raw.headers,
+            body: raw.body,
+        };
+    }
+    //
+    // -------------------------
+    // websocket
+    // -------------------------
+    //
+    static normalizeWebSocket(raw) {
+        return {
+            id: id_generator_1.IdGenerator.generate(),
+            type: "websocket",
+            timestamp: Date.now(),
+            sourceIp: raw.ip,
+            message: raw.message,
+        };
+    }
+}
+exports.EventNormalizer = EventNormalizer;

package/dist/core/event.router.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventRouter = void 0;
+const event_normalizer_1 = require("./event.normalizer");
+class EventRouter {
+    constructor(storage) {
+        this.storage = storage;
+    }
+    async handleHttp(event) {
+        const normalized = event_normalizer_1.EventNormalizer.normalizeHttp(event);
+        await this.storage.save(normalized);
+        return normalized;
+    }
+}
+exports.EventRouter = EventRouter;

package/dist/core/http/__tests__/adapter-node.test.js

@@ -0,0 +1,74 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const adapter_node_1 = require("../adapter-node");
+const middleware_1 = require("../middleware");
+const router_1 = require("../router");
+const request_1 = require("../request");
+const globals_1 = require("@jest/globals");
+const Build = __importStar(require("../buildRequest"));
+(0, globals_1.describe)("NodeAdapter.handle", () => {
+    (0, globals_1.it)("appelle le handler quand la route match", async () => {
+        const router = new router_1.Router();
+        const pipeline = new middleware_1.MiddlewarePipeline();
+        // mock buildRequest
+        const buildRequestMock = globals_1.jest
+            .spyOn(Build, "buildRequest")
+            .mockImplementation((raw, params) => new request_1.Request({
+            method: "GET",
+            path: "/test",
+            headers: {},
+            params: params ?? {},
+        }));
+        const handler = globals_1.jest.fn();
+        router.match = globals_1.jest.fn(() => ({
+            handler,
+            params: { id: "42" },
+            middlewares: [],
+        }));
+        pipeline.run = globals_1.jest.fn(async () => { });
+        const res = {
+            writableEnded: false,
+            setHeader: globals_1.jest.fn(),
+            end: globals_1.jest.fn(),
+            statusCode: 200,
+        };
+        const adapter = new adapter_node_1.NodeAdapter(router, pipeline);
+        await adapter.handle({ url: "/test", method: "GET", headers: {} }, res);
+        (0, globals_1.expect)(handler).toHaveBeenCalled();
+        (0, globals_1.expect)(pipeline.run).toHaveBeenCalled();
+        (0, globals_1.expect)(buildRequestMock).toHaveBeenCalledTimes(2);
+    });
+});

package/dist/core/http/__tests__/body-parser-multipart.test.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const middleware_1 = require("../middleware");
+const request_1 = require("../request");
+const response_1 = require("../response");
+const globals_1 = require("@jest/globals");
+(0, globals_1.describe)("bodyParserMultipart", () => {
+    (0, globals_1.it)("parse un champ texte et un fichier", async () => {
+        const boundary = "----1234";
+        const raw = {
+            headers: { "content-type": `multipart/form-data; boundary=${boundary}` },
+            [Symbol.asyncIterator]: async function* () {
+                yield Buffer.from(`--${boundary}\r\n` +
+                    `Content-Disposition: form-data; name="username"\r\n\r\n` +
+                    `jeremy\r\n` +
+                    `--${boundary}\r\n` +
+                    `Content-Disposition: form-data; name="file"; filename="test.txt"\r\n` +
+                    `Content-Type: text/plain\r\n\r\n` +
+                    `Hello world\r\n` +
+                    `--${boundary}--`);
+            },
+        };
+        const req = new request_1.Request({
+            method: "POST",
+            path: "/upload",
+            headers: raw.headers,
+            raw,
+        });
+        const res = new response_1.Response({});
+        await (0, middleware_1.bodyParserMultipart)(req, res);
+        (0, globals_1.expect)(req.form?.username).toBe("jeremy");
+        (0, globals_1.expect)(req.files?.[0].filename).toBe("test.txt");
+        (0, globals_1.expect)(req.files?.[0].data.toString()).toBe("Hello world");
+    });
+});

package/dist/core/http/__tests__/body-parser-raw.test.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const middleware_1 = require("../middleware");
+const request_1 = require("../request");
+const response_1 = require("../response");
+const globals_1 = require("@jest/globals");
+(0, globals_1.describe)("bodyParserRaw", () => {
+    (0, globals_1.it)("lit le body brut", async () => {
+        const raw = {
+            headers: { "content-type": "application/octet-stream" },
+            [Symbol.asyncIterator]: async function* () {
+                yield Buffer.from([1, 2, 3, 4]);
+            },
+        };
+        const req = new request_1.Request({
+            method: "POST",
+            path: "/",
+            headers: raw.headers,
+            raw,
+        });
+        const res = new response_1.Response({});
+        await (0, middleware_1.bodyParserRaw)(req, res);
+        (0, globals_1.expect)(req.bodyRaw).toEqual(Buffer.from([1, 2, 3, 4]));
+    });
+});

package/dist/core/http/__tests__/body-parser-text.test.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const middleware_1 = require("../middleware");
+const request_1 = require("../request");
+const response_1 = require("../response");
+const globals_1 = require("@jest/globals");
+(0, globals_1.describe)("bodyParserText", () => {
+    (0, globals_1.it)("lit le body text", async () => {
+        const raw = {
+            headers: { "content-type": "text/plain" },
+            [Symbol.asyncIterator]: async function* () {
+                yield Buffer.from("Hello world");
+            },
+        };
+        const req = new request_1.Request({
+            method: "POST",
+            path: "/",
+            headers: raw.headers,
+            raw,
+        });
+        const res = new response_1.Response({});
+        await (0, middleware_1.bodyParserText)(req, res);
+        (0, globals_1.expect)(req.bodyText).toBe("Hello world");
+    });
+});

package/dist/core/http/__tests__/compile-path.test.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const compile_path_1 = require("../compile-path");
+const globals_1 = require("@jest/globals");
+(0, globals_1.describe)("compilePath", () => {
+    (0, globals_1.it)("compile un chemin simple avec segment statique", () => {
+        const result = (0, compile_path_1.compilePath)("/tasks");
+        (0, globals_1.expect)(result).toEqual([{ type: "static", value: "tasks" }]);
+    });
+    (0, globals_1.it)("compile un chemin avec paramètre", () => {
+        const result = (0, compile_path_1.compilePath)("/tasks/:id");
+        (0, globals_1.expect)(result).toEqual([
+            { type: "static", value: "tasks" },
+            { type: "param", name: "id" },
+        ]);
+    });
+    (0, globals_1.it)("compile un chemin avec paramètre", () => {
+        const result = (0, compile_path_1.compilePath)("/tasks/:id");
+        (0, globals_1.expect)(result).toEqual([
+            { type: "static", value: "tasks" },
+            { type: "param", name: "id" },
+        ]);
+    });
+    (0, globals_1.it)("compile un chemin complexe avec static, param et wildcard", () => {
+        const result = (0, compile_path_1.compilePath)("/a/:b/*/c");
+        (0, globals_1.expect)(result).toEqual([
+            { type: "static", value: "a" },
+            { type: "param", name: "b" },
+            { type: "wildcard" },
+            { type: "static", value: "c" },
+        ]);
+    });
+});