@wingman-ai/gateway 0.1.0

package/dist/tests/integration/finnhub-candles.integration.test.js

@@ -0,0 +1,92 @@
+import { describe, expect, it } from "vitest";
+const FINNHUB_BASE_URL = process.env.FINNHUB_BASE_URL?.trim() || "https://finnhub.io/api/v1";
+const FINNHUB_API_KEY = process.env.FINNHUB_API_KEY?.trim();
+const RUN_LIVE = "1" === process.env.FINNHUB_LIVE_TESTS;
+const describeLive = FINNHUB_API_KEY && RUN_LIVE ? describe : describe.skip;
+const secondsPerDay = 86400;
+const buildCandleUrl = (scenario)=>{
+    const to = Math.floor(Date.now() / 1000);
+    const from = to - scenario.lookbackDays * secondsPerDay;
+    const url = new URL(`${FINNHUB_BASE_URL}/stock/candle`);
+    url.searchParams.set("symbol", scenario.symbol);
+    url.searchParams.set("resolution", scenario.resolution);
+    url.searchParams.set("from", String(from));
+    url.searchParams.set("to", String(to));
+    url.searchParams.set("token", FINNHUB_API_KEY || "");
+    return url.toString();
+};
+const scenarios = [
+    {
+        label: "daily-365",
+        symbol: "AAPL",
+        resolution: "D",
+        lookbackDays: 365
+    },
+    {
+        label: "daily-180",
+        symbol: "AAPL",
+        resolution: "D",
+        lookbackDays: 180
+    },
+    {
+        label: "daily-90",
+        symbol: "AAPL",
+        resolution: "D",
+        lookbackDays: 90
+    },
+    {
+        label: "hourly-180",
+        symbol: "AAPL",
+        resolution: "60",
+        lookbackDays: 180
+    },
+    {
+        label: "hourly-90",
+        symbol: "AAPL",
+        resolution: "60",
+        lookbackDays: 90
+    },
+    {
+        label: "hourly-30",
+        symbol: "AAPL",
+        resolution: "60",
+        lookbackDays: 30
+    },
+    {
+        label: "15m-30",
+        symbol: "AAPL",
+        resolution: "15",
+        lookbackDays: 30
+    },
+    {
+        label: "1m-7",
+        symbol: "AAPL",
+        resolution: "1",
+        lookbackDays: 7
+    }
+];
+describeLive("Finnhub candle access (live)", ()=>{
+    it("does not return 403 for supported ranges", async ()=>{
+        const failures = [];
+        for (const scenario of scenarios){
+            const url = buildCandleUrl(scenario);
+            const response = await fetch(url, {
+                headers: {
+                    "User-Agent": "wingman-finnhub-test"
+                }
+            });
+            const body = await response.text();
+            console.info(`Finnhub candle ${scenario.label} -> ${response.status}`);
+            if (403 === response.status) {
+                failures.push(`403 for ${scenario.label} (${scenario.resolution}, ${scenario.lookbackDays}d): ${body.slice(0, 200)}`);
+                continue;
+            }
+            if (429 === response.status) {
+                console.warn(`Rate limited for ${scenario.label}; skipping assert.`);
+                continue;
+            }
+            expect(response.status).toBe(200);
+        }
+        if (failures.length > 0) throw new Error(failures.join("\n"));
+    });
+});

package/dist/tests/logger.test.cjs

@@ -0,0 +1,353 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_vitest_namespaceObject = require("vitest");
+const external_logger_cjs_namespaceObject = require("../logger.cjs");
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+class MockWriteStream {
+    write(chunk) {
+        this.data += chunk;
+    }
+    constructor(){
+        _define_property(this, "data", "");
+    }
+}
+(0, external_vitest_namespaceObject.describe)("Logger System", ()=>{
+    (0, external_vitest_namespaceObject.describe)("WingmanLogger", ()=>{
+        let mockStream;
+        (0, external_vitest_namespaceObject.beforeEach)(()=>{
+            mockStream = new MockWriteStream();
+        });
+        (0, external_vitest_namespaceObject.describe)("Log level filtering", ()=>{
+            (0, external_vitest_namespaceObject.it)("should only log messages at or above configured level", ()=>{
+                const logger = new external_logger_cjs_namespaceObject.WingmanLogger("warn", mockStream);
+                logger.debug("debug message");
+                logger.info("info message");
+                logger.warn("warn message");
+                logger.error("error message");
+                (0, external_vitest_namespaceObject.expect)(mockStream.data).not.toContain("debug message");
+                (0, external_vitest_namespaceObject.expect)(mockStream.data).not.toContain("info message");
+                (0, external_vitest_namespaceObject.expect)(mockStream.data).toContain("warn message");
+                (0, external_vitest_namespaceObject.expect)(mockStream.data).toContain("error message");
+            });
+            (0, external_vitest_namespaceObject.it)("should log all messages when level is debug", ()=>{
+                const logger = new external_logger_cjs_namespaceObject.WingmanLogger("debug", mockStream);
+                logger.debug("debug message");
+                logger.info("info message");
+                logger.warn("warn message");
+                logger.error("error message");
+                (0, external_vitest_namespaceObject.expect)(mockStream.data).toContain("debug message");
+                (0, external_vitest_namespaceObject.expect)(mockStream.data).toContain("info message");
+                (0, external_vitest_namespaceObject.expect)(mockStream.data).toContain("warn message");
+                (0, external_vitest_namespaceObject.expect)(mockStream.data).toContain("error message");
+            });
+            (0, external_vitest_namespaceObject.it)("should not log any messages when level is silent", ()=>{
+                const logger = new external_logger_cjs_namespaceObject.WingmanLogger("silent", mockStream);
+                logger.debug("debug message");
+                logger.info("info message");
+                logger.warn("warn message");
+                logger.error("error message");
+                (0, external_vitest_namespaceObject.expect)(mockStream.data).toBe("");
+            });
+        });
+        (0, external_vitest_namespaceObject.describe)("Log formatting", ()=>{
+            (0, external_vitest_namespaceObject.it)("should include timestamp and level in log output", ()=>{
+                const logger = new external_logger_cjs_namespaceObject.WingmanLogger("info", mockStream);
+                logger.info("test message");
+                (0, external_vitest_namespaceObject.expect)(mockStream.data).toMatch(/\[\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/);
+                (0, external_vitest_namespaceObject.expect)(mockStream.data).toContain("[INFO]");
+                (0, external_vitest_namespaceObject.expect)(mockStream.data).toContain("test message");
+            });
+            (0, external_vitest_namespaceObject.it)("should serialize additional arguments as JSON", ()=>{
+                const logger = new external_logger_cjs_namespaceObject.WingmanLogger("info", mockStream);
+                logger.info("test message", {
+                    key: "value"
+                }, [
+                    1,
+                    2,
+                    3
+                ]);
+                (0, external_vitest_namespaceObject.expect)(mockStream.data).toContain("test message");
+                (0, external_vitest_namespaceObject.expect)(mockStream.data).toContain('"key"');
+                (0, external_vitest_namespaceObject.expect)(mockStream.data).toContain('"value"');
+            });
+            (0, external_vitest_namespaceObject.it)("should serialize error arguments with message and stack", ()=>{
+                const logger = new external_logger_cjs_namespaceObject.WingmanLogger("info", mockStream);
+                const err = new Error("boom");
+                logger.error("test error", err);
+                (0, external_vitest_namespaceObject.expect)(mockStream.data).toContain("test error");
+                (0, external_vitest_namespaceObject.expect)(mockStream.data).toContain('"message"');
+                (0, external_vitest_namespaceObject.expect)(mockStream.data).toContain("boom");
+            });
+            (0, external_vitest_namespaceObject.it)("should not include args when none provided", ()=>{
+                const logger = new external_logger_cjs_namespaceObject.WingmanLogger("info", mockStream);
+                logger.info("test message");
+                const lines = mockStream.data.split("\n");
+                (0, external_vitest_namespaceObject.expect)(lines.filter((l)=>l.trim()).length).toBe(1);
+            });
+        });
+        (0, external_vitest_namespaceObject.describe)("Log levels", ()=>{
+            (0, external_vitest_namespaceObject.it)("should have debug method", ()=>{
+                const logger = new external_logger_cjs_namespaceObject.WingmanLogger("debug", mockStream);
+                (0, external_vitest_namespaceObject.expect)(logger.debug).toBeDefined();
+                (0, external_vitest_namespaceObject.expect)(typeof logger.debug).toBe("function");
+            });
+            (0, external_vitest_namespaceObject.it)("should have info method", ()=>{
+                const logger = new external_logger_cjs_namespaceObject.WingmanLogger("info", mockStream);
+                (0, external_vitest_namespaceObject.expect)(logger.info).toBeDefined();
+                (0, external_vitest_namespaceObject.expect)(typeof logger.info).toBe("function");
+            });
+            (0, external_vitest_namespaceObject.it)("should have warn method", ()=>{
+                const logger = new external_logger_cjs_namespaceObject.WingmanLogger("warn", mockStream);
+                (0, external_vitest_namespaceObject.expect)(logger.warn).toBeDefined();
+                (0, external_vitest_namespaceObject.expect)(typeof logger.warn).toBe("function");
+            });
+            (0, external_vitest_namespaceObject.it)("should have error method", ()=>{
+                const logger = new external_logger_cjs_namespaceObject.WingmanLogger("error", mockStream);
+                (0, external_vitest_namespaceObject.expect)(logger.error).toBeDefined();
+                (0, external_vitest_namespaceObject.expect)(typeof logger.error).toBe("function");
+            });
+        });
+    });
+    (0, external_vitest_namespaceObject.describe)("SilentLogger", ()=>{
+        (0, external_vitest_namespaceObject.it)("should not log any messages", ()=>{
+            const logger = new external_logger_cjs_namespaceObject.SilentLogger();
+            const consoleSpy = external_vitest_namespaceObject.vi.spyOn(console, "log");
+            logger.debug();
+            logger.info();
+            logger.warn();
+            logger.error();
+            (0, external_vitest_namespaceObject.expect)(consoleSpy).not.toHaveBeenCalled();
+            consoleSpy.mockRestore();
+        });
+        (0, external_vitest_namespaceObject.it)("should have all required logger methods", ()=>{
+            const logger = new external_logger_cjs_namespaceObject.SilentLogger();
+            (0, external_vitest_namespaceObject.expect)(logger.debug).toBeDefined();
+            (0, external_vitest_namespaceObject.expect)(logger.info).toBeDefined();
+            (0, external_vitest_namespaceObject.expect)(logger.warn).toBeDefined();
+            (0, external_vitest_namespaceObject.expect)(logger.error).toBeDefined();
+        });
+    });
+    (0, external_vitest_namespaceObject.describe)("EventLogger", ()=>{
+        let mockCallback;
+        (0, external_vitest_namespaceObject.beforeEach)(()=>{
+            mockCallback = external_vitest_namespaceObject.vi.fn();
+        });
+        (0, external_vitest_namespaceObject.describe)("Event emission", ()=>{
+            (0, external_vitest_namespaceObject.it)("should emit log events with correct structure", ()=>{
+                const logger = new external_logger_cjs_namespaceObject.EventLogger(mockCallback, "info");
+                logger.info("test message");
+                (0, external_vitest_namespaceObject.expect)(mockCallback).toHaveBeenCalledTimes(1);
+                (0, external_vitest_namespaceObject.expect)(mockCallback).toHaveBeenCalledWith({
+                    level: "info",
+                    message: "test message",
+                    timestamp: external_vitest_namespaceObject.expect.stringMatching(/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/),
+                    args: void 0
+                });
+            });
+            (0, external_vitest_namespaceObject.it)("should include args in events when provided", ()=>{
+                const logger = new external_logger_cjs_namespaceObject.EventLogger(mockCallback, "info");
+                const testArgs = [
+                    {
+                        key: "value"
+                    },
+                    [
+                        1,
+                        2,
+                        3
+                    ]
+                ];
+                logger.info("test message", ...testArgs);
+                (0, external_vitest_namespaceObject.expect)(mockCallback).toHaveBeenCalledWith({
+                    level: "info",
+                    message: "test message",
+                    timestamp: external_vitest_namespaceObject.expect.any(String),
+                    args: testArgs
+                });
+            });
+        });
+        (0, external_vitest_namespaceObject.describe)("Level filtering", ()=>{
+            (0, external_vitest_namespaceObject.it)("should respect log level filtering", ()=>{
+                const logger = new external_logger_cjs_namespaceObject.EventLogger(mockCallback, "warn");
+                logger.debug("debug");
+                logger.info("info");
+                logger.warn("warn");
+                logger.error("error");
+                (0, external_vitest_namespaceObject.expect)(mockCallback).toHaveBeenCalledTimes(2);
+                (0, external_vitest_namespaceObject.expect)(mockCallback).toHaveBeenCalledWith(external_vitest_namespaceObject.expect.objectContaining({
+                    level: "warn"
+                }));
+                (0, external_vitest_namespaceObject.expect)(mockCallback).toHaveBeenCalledWith(external_vitest_namespaceObject.expect.objectContaining({
+                    level: "error"
+                }));
+            });
+            (0, external_vitest_namespaceObject.it)("should not emit events when level is silent", ()=>{
+                const logger = new external_logger_cjs_namespaceObject.EventLogger(mockCallback, "silent");
+                logger.debug("debug");
+                logger.info("info");
+                logger.warn("warn");
+                logger.error("error");
+                (0, external_vitest_namespaceObject.expect)(mockCallback).not.toHaveBeenCalled();
+            });
+        });
+        (0, external_vitest_namespaceObject.describe)("All log levels", ()=>{
+            (0, external_vitest_namespaceObject.it)("should handle debug level", ()=>{
+                const logger = new external_logger_cjs_namespaceObject.EventLogger(mockCallback, "debug");
+                logger.debug("debug message");
+                (0, external_vitest_namespaceObject.expect)(mockCallback).toHaveBeenCalledWith(external_vitest_namespaceObject.expect.objectContaining({
+                    level: "debug",
+                    message: "debug message"
+                }));
+            });
+            (0, external_vitest_namespaceObject.it)("should handle info level", ()=>{
+                const logger = new external_logger_cjs_namespaceObject.EventLogger(mockCallback, "info");
+                logger.info("info message");
+                (0, external_vitest_namespaceObject.expect)(mockCallback).toHaveBeenCalledWith(external_vitest_namespaceObject.expect.objectContaining({
+                    level: "info",
+                    message: "info message"
+                }));
+            });
+            (0, external_vitest_namespaceObject.it)("should handle warn level", ()=>{
+                const logger = new external_logger_cjs_namespaceObject.EventLogger(mockCallback, "info");
+                logger.warn("warn message");
+                (0, external_vitest_namespaceObject.expect)(mockCallback).toHaveBeenCalledWith(external_vitest_namespaceObject.expect.objectContaining({
+                    level: "warn",
+                    message: "warn message"
+                }));
+            });
+            (0, external_vitest_namespaceObject.it)("should handle error level", ()=>{
+                const logger = new external_logger_cjs_namespaceObject.EventLogger(mockCallback, "info");
+                logger.error("error message");
+                (0, external_vitest_namespaceObject.expect)(mockCallback).toHaveBeenCalledWith(external_vitest_namespaceObject.expect.objectContaining({
+                    level: "error",
+                    message: "error message"
+                }));
+            });
+        });
+    });
+    (0, external_vitest_namespaceObject.describe)("Factory functions", ()=>{
+        (0, external_vitest_namespaceObject.describe)("createLogger", ()=>{
+            const originalEnv = process.env.WINGMAN_LOG_LEVEL;
+            (0, external_vitest_namespaceObject.afterEach)(()=>{
+                process.env.WINGMAN_LOG_LEVEL = originalEnv;
+            });
+            (0, external_vitest_namespaceObject.it)("should create WingmanLogger by default", ()=>{
+                const logger = (0, external_logger_cjs_namespaceObject.createLogger)("info");
+                (0, external_vitest_namespaceObject.expect)(logger).toBeInstanceOf(external_logger_cjs_namespaceObject.WingmanLogger);
+            });
+            (0, external_vitest_namespaceObject.it)("should create SilentLogger when level is silent", ()=>{
+                const logger = (0, external_logger_cjs_namespaceObject.createLogger)("silent");
+                (0, external_vitest_namespaceObject.expect)(logger).toBeInstanceOf(external_logger_cjs_namespaceObject.SilentLogger);
+            });
+            (0, external_vitest_namespaceObject.it)("should use WINGMAN_LOG_LEVEL env var when no level provided", ()=>{
+                process.env.WINGMAN_LOG_LEVEL = "debug";
+                const logger = (0, external_logger_cjs_namespaceObject.createLogger)();
+                (0, external_vitest_namespaceObject.expect)(logger).toBeInstanceOf(external_logger_cjs_namespaceObject.WingmanLogger);
+            });
+            (0, external_vitest_namespaceObject.it)("should default to info level when env var not set", ()=>{
+                delete process.env.WINGMAN_LOG_LEVEL;
+                const logger = (0, external_logger_cjs_namespaceObject.createLogger)();
+                (0, external_vitest_namespaceObject.expect)(logger).toBeInstanceOf(external_logger_cjs_namespaceObject.WingmanLogger);
+            });
+        });
+        (0, external_vitest_namespaceObject.describe)("createEventLogger", ()=>{
+            (0, external_vitest_namespaceObject.it)("should create EventLogger with callback", ()=>{
+                const callback = external_vitest_namespaceObject.vi.fn();
+                const logger = (0, external_logger_cjs_namespaceObject.createEventLogger)(callback, "info");
+                (0, external_vitest_namespaceObject.expect)(logger).toBeInstanceOf(external_logger_cjs_namespaceObject.EventLogger);
+            });
+            (0, external_vitest_namespaceObject.it)("should create EventLogger with default info level", ()=>{
+                const callback = external_vitest_namespaceObject.vi.fn();
+                const logger = (0, external_logger_cjs_namespaceObject.createEventLogger)(callback);
+                logger.info("test");
+                (0, external_vitest_namespaceObject.expect)(callback).toHaveBeenCalledWith(external_vitest_namespaceObject.expect.objectContaining({
+                    level: "info"
+                }));
+            });
+        });
+        (0, external_vitest_namespaceObject.describe)("createLoggerFromConfig", ()=>{
+            (0, external_vitest_namespaceObject.it)("should create logger from serializable config", ()=>{
+                const logger = (0, external_logger_cjs_namespaceObject.createLoggerFromConfig)({
+                    level: "debug"
+                });
+                (0, external_vitest_namespaceObject.expect)(logger).toBeInstanceOf(external_logger_cjs_namespaceObject.WingmanLogger);
+            });
+            (0, external_vitest_namespaceObject.it)("should create silent logger from silent config", ()=>{
+                const logger = (0, external_logger_cjs_namespaceObject.createLoggerFromConfig)({
+                    level: "silent"
+                });
+                (0, external_vitest_namespaceObject.expect)(logger).toBeInstanceOf(external_logger_cjs_namespaceObject.SilentLogger);
+            });
+        });
+    });
+    (0, external_vitest_namespaceObject.describe)("Log level hierarchy", ()=>{
+        (0, external_vitest_namespaceObject.it)("should respect level hierarchy: debug < info < warn < error", ()=>{
+            const testCases = [
+                {
+                    level: "debug",
+                    shouldLog: {
+                        debug: true,
+                        info: true,
+                        warn: true,
+                        error: true
+                    }
+                },
+                {
+                    level: "info",
+                    shouldLog: {
+                        debug: false,
+                        info: true,
+                        warn: true,
+                        error: true
+                    }
+                },
+                {
+                    level: "warn",
+                    shouldLog: {
+                        debug: false,
+                        info: false,
+                        warn: true,
+                        error: true
+                    }
+                },
+                {
+                    level: "error",
+                    shouldLog: {
+                        debug: false,
+                        info: false,
+                        warn: false,
+                        error: true
+                    }
+                }
+            ];
+            for (const testCase of testCases){
+                const callback = external_vitest_namespaceObject.vi.fn();
+                const logger = new external_logger_cjs_namespaceObject.EventLogger(callback, testCase.level);
+                logger.debug("debug");
+                logger.info("info");
+                logger.warn("warn");
+                logger.error("error");
+                const debugCalls = callback.mock.calls.filter(([event])=>"debug" === event.level).length;
+                const infoCalls = callback.mock.calls.filter(([event])=>"info" === event.level).length;
+                const warnCalls = callback.mock.calls.filter(([event])=>"warn" === event.level).length;
+                const errorCalls = callback.mock.calls.filter(([event])=>"error" === event.level).length;
+                (0, external_vitest_namespaceObject.expect)(debugCalls).toBe(testCase.shouldLog.debug ? 1 : 0);
+                (0, external_vitest_namespaceObject.expect)(infoCalls).toBe(testCase.shouldLog.info ? 1 : 0);
+                (0, external_vitest_namespaceObject.expect)(warnCalls).toBe(testCase.shouldLog.warn ? 1 : 0);
+                (0, external_vitest_namespaceObject.expect)(errorCalls).toBe(testCase.shouldLog.error ? 1 : 0);
+            }
+        });
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/tests/logger.test.d.ts

@@ -0,0 +1 @@
+export {};