galileo-generated 0.2.6 → 0.2.8

package/src/tests/lib/galileo-config.test.ts

@@ -13,6 +13,11 @@ const ENV_KEYS = [
   'GALILEO_PROJECT_NAME',
   'GALILEO_LOG_STREAM',
   'GALILEO_LOG_STREAM_NAME',
+  'GALILEO_CA_CERT_PATH',
+  'GALILEO_CA_CERT_CONTENT',
+  'GALILEO_CLIENT_CERT_PATH',
+  'GALILEO_CLIENT_KEY_PATH',
+  'GALILEO_REJECT_UNAUTHORIZED',
 ] as const;
 
 function clearGalileoEnv(): void {
@@ -233,4 +238,109 @@ describe('GalileoConfig', () => {
     expect(() => config.logConfig()).not.toThrow();
     spy.mockRestore();
   });
+
+  test('test getCertConfig returns cert fields from overrides', () => {
+    GalileoConfig.reset();
+    const config = GalileoConfig.get({
+      apiKey: 'key',
+      apiUrl: 'https://api.example.com',
+      caCertPath: '/path/to/ca.pem',
+      caCertContent: '-----BEGIN CERTIFICATE-----',
+      clientCertPath: '/path/to/client.pem',
+      clientKeyPath: '/path/to/key.pem',
+      rejectUnauthorized: false,
+    });
+    const cert = config.getCertConfig();
+    expect(cert).not.toBeNull();
+    if (!cert) throw new Error("unreachable");
+    expect(cert.caCertPath).toBe('/path/to/ca.pem');
+    expect(cert.caCertContent).toBe('-----BEGIN CERTIFICATE-----');
+    expect(cert.clientCertPath).toBe('/path/to/client.pem');
+    expect(cert.clientKeyPath).toBe('/path/to/key.pem');
+    expect(cert.rejectUnauthorized).toBe(false);
+  });
+
+  test('test getCertConfig empty when no cert set', () => {
+    GalileoConfig.reset();
+    const config = GalileoConfig.get({
+      apiKey: 'key',
+      apiUrl: 'https://api.example.com',
+    });
+    const cert = config.getCertConfig();
+    expect(cert).toBeNull();
+  });
+
+  test('test snapshot includes cert when set', () => {
+    GalileoConfig.reset();
+    const config = GalileoConfig.get({
+      apiKey: 'key',
+      apiUrl: 'https://api.example.com',
+      caCertPath: '/ca.pem',
+      rejectUnauthorized: true,
+    });
+    expect(config.snapshot.cert).toEqual({
+      caCertPath: '/ca.pem',
+      rejectUnauthorized: true,
+    });
+  });
+
+  test('test cert from env', () => {
+    GalileoConfig.reset();
+    process.env['GALILEO_API_KEY'] = 'env-key';
+    process.env['GALILEO_CA_CERT_PATH'] = '/env/ca.pem';
+    process.env['GALILEO_REJECT_UNAUTHORIZED'] = 'false';
+    const config = GalileoConfig.get({});
+    const cert = config.getCertConfig();
+    expect(cert).not.toBeNull();
+    if (!cert) throw new Error("unreachable");
+    expect(cert.caCertPath).toBe('/env/ca.pem');
+    expect(cert.rejectUnauthorized).toBe(false);
+  });
+
+  test('test empty GALILEO_REJECT_UNAUTHORIZED treated as undefined', () => {
+    GalileoConfig.reset();
+    process.env['GALILEO_API_KEY'] = 'env-key';
+    process.env['GALILEO_REJECT_UNAUTHORIZED'] = '';
+    const config = GalileoConfig.get({});
+    const cert = config.getCertConfig();
+    expect(cert).toBeNull();
+  });
+
+  test('test empty NODE_TLS_REJECT_UNAUTHORIZED treated as undefined', () => {
+    GalileoConfig.reset();
+    process.env['GALILEO_API_KEY'] = 'env-key';
+    process.env['NODE_TLS_REJECT_UNAUTHORIZED'] = '';
+    const config = GalileoConfig.get({});
+    const cert = config.getCertConfig();
+    expect(cert).toBeNull();
+  });
+
+  test('test explicit rejectUnauthorized values', () => {
+    GalileoConfig.reset();
+    process.env['GALILEO_API_KEY'] = 'env-key';
+    
+    // Test "true" string
+    process.env['GALILEO_REJECT_UNAUTHORIZED'] = 'true';
+    let config = GalileoConfig.get({});
+    let cert = config.getCertConfig();
+    expect(cert?.rejectUnauthorized).toBe(true);
+    
+    GalileoConfig.reset();
+    process.env['GALILEO_REJECT_UNAUTHORIZED'] = '1';
+    config = GalileoConfig.get({});
+    cert = config.getCertConfig();
+    expect(cert?.rejectUnauthorized).toBe(true);
+    
+    GalileoConfig.reset();
+    process.env['GALILEO_REJECT_UNAUTHORIZED'] = 'false';
+    config = GalileoConfig.get({});
+    cert = config.getCertConfig();
+    expect(cert?.rejectUnauthorized).toBe(false);
+    
+    GalileoConfig.reset();
+    process.env['GALILEO_REJECT_UNAUTHORIZED'] = '0';
+    config = GalileoConfig.get({});
+    cert = config.getCertConfig();
+    expect(cert?.rejectUnauthorized).toBe(false);
+  });
 });

package/src/tests/lib/sdk-logger.test.ts

@@ -0,0 +1,518 @@
+import { describe, test, expect, beforeEach, vi } from "vitest";
+import {
+  getSdkLogger,
+  enableLogging,
+  disableLogging,
+  setCustomLogger,
+  resetSdkLogger,
+} from "../../lib/sdk-logger.js";
+import { GalileoConfig } from "../../lib/galileo-config.js";
+import type { GalileoSdkLogger } from "../../types/sdk-logger.types.js";
+
+const GALILEO_LOG_LEVEL = "GALILEO_LOG_LEVEL";
+
+function clearGalileoEnv(): void {
+  delete process.env[GALILEO_LOG_LEVEL];
+}
+
+describe("SdkLogger", () => {
+  beforeEach(() => {
+    // Reset all singletons and environment to ensure clean test state
+    GalileoConfig.reset();
+    clearGalileoEnv();
+    setCustomLogger(undefined);
+    resetSdkLogger();
+  });
+
+  describe("initialization", () => {
+    test("default log level is silent", () => {
+      const logger = getSdkLogger();
+      // Debug should be silenced by default
+      const debugSpy = vi.spyOn(console, "debug").mockImplementation(() => {});
+      logger.debug("test message");
+      expect(debugSpy).not.toHaveBeenCalled();
+      debugSpy.mockRestore();
+    });
+
+    test("respects GALILEO_LOG_LEVEL environment variable", () => {
+      process.env[GALILEO_LOG_LEVEL] = "debug";
+      // GalileoConfig requires at least one auth credential to process the config
+      process.env["GALILEO_API_KEY"] = "test-key";
+      GalileoConfig.reset();
+      resetSdkLogger();
+      const logger = getSdkLogger();
+
+      const debugSpy = vi.spyOn(console, "debug").mockImplementation(() => {});
+      logger.debug("test message");
+      expect(debugSpy).toHaveBeenCalledWith("test message");
+      debugSpy.mockRestore();
+    });
+
+    test("normalizes log level to lowercase", () => {
+      process.env[GALILEO_LOG_LEVEL] = "DEBUG";
+      // GalileoConfig requires at least one auth credential to process the config
+      process.env["GALILEO_API_KEY"] = "test-key";
+      GalileoConfig.reset();
+      resetSdkLogger();
+      const logger = getSdkLogger();
+
+      const debugSpy = vi.spyOn(console, "debug").mockImplementation(() => {});
+      logger.debug("test message");
+      expect(debugSpy).toHaveBeenCalledWith("test message");
+      debugSpy.mockRestore();
+    });
+
+    test("ignores invalid log levels", () => {
+      process.env[GALILEO_LOG_LEVEL] = "invalid";
+      GalileoConfig.reset();
+      resetSdkLogger();
+      const logger = getSdkLogger();
+
+      const debugSpy = vi.spyOn(console, "debug").mockImplementation(() => {});
+      logger.debug("test message");
+      expect(debugSpy).not.toHaveBeenCalled();
+      debugSpy.mockRestore();
+    });
+  });
+
+  describe("logging levels", () => {
+    test("silent level blocks all logs", () => {
+      const logger = getSdkLogger();
+      enableLogging("silent");
+
+      const debugSpy = vi.spyOn(console, "debug").mockImplementation(() => {});
+      const infoSpy = vi.spyOn(console, "info").mockImplementation(() => {});
+      const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+      const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+
+      logger.debug("debug");
+      logger.info("info");
+      logger.warn("warn");
+      logger.error("error");
+
+      expect(debugSpy).not.toHaveBeenCalled();
+      expect(infoSpy).not.toHaveBeenCalled();
+      expect(warnSpy).not.toHaveBeenCalled();
+      expect(errorSpy).not.toHaveBeenCalled();
+
+      debugSpy.mockRestore();
+      infoSpy.mockRestore();
+      warnSpy.mockRestore();
+      errorSpy.mockRestore();
+    });
+
+    test("error level only logs errors", () => {
+      const logger = getSdkLogger();
+      enableLogging("error");
+
+      const debugSpy = vi.spyOn(console, "debug").mockImplementation(() => {});
+      const infoSpy = vi.spyOn(console, "info").mockImplementation(() => {});
+      const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+      const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+
+      logger.debug("debug");
+      logger.info("info");
+      logger.warn("warn");
+      logger.error("error");
+
+      expect(debugSpy).not.toHaveBeenCalled();
+      expect(infoSpy).not.toHaveBeenCalled();
+      expect(warnSpy).not.toHaveBeenCalled();
+      expect(errorSpy).toHaveBeenCalledWith("error");
+
+      debugSpy.mockRestore();
+      infoSpy.mockRestore();
+      warnSpy.mockRestore();
+      errorSpy.mockRestore();
+    });
+
+    test("warn level logs warn and error", () => {
+      const logger = getSdkLogger();
+      enableLogging("warn");
+
+      const debugSpy = vi.spyOn(console, "debug").mockImplementation(() => {});
+      const infoSpy = vi.spyOn(console, "info").mockImplementation(() => {});
+      const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+      const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+
+      logger.debug("debug");
+      logger.info("info");
+      logger.warn("warn");
+      logger.error("error");
+
+      expect(debugSpy).not.toHaveBeenCalled();
+      expect(infoSpy).not.toHaveBeenCalled();
+      expect(warnSpy).toHaveBeenCalledWith("warn");
+      expect(errorSpy).toHaveBeenCalledWith("error");
+
+      debugSpy.mockRestore();
+      infoSpy.mockRestore();
+      warnSpy.mockRestore();
+      errorSpy.mockRestore();
+    });
+
+    test("info level logs info, warn, and error", () => {
+      const logger = getSdkLogger();
+      enableLogging("info");
+
+      const debugSpy = vi.spyOn(console, "debug").mockImplementation(() => {});
+      const infoSpy = vi.spyOn(console, "info").mockImplementation(() => {});
+      const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+      const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+
+      logger.debug("debug");
+      logger.info("info");
+      logger.warn("warn");
+      logger.error("error");
+
+      expect(debugSpy).not.toHaveBeenCalled();
+      expect(infoSpy).toHaveBeenCalledWith("info");
+      expect(warnSpy).toHaveBeenCalledWith("warn");
+      expect(errorSpy).toHaveBeenCalledWith("error");
+
+      debugSpy.mockRestore();
+      infoSpy.mockRestore();
+      warnSpy.mockRestore();
+      errorSpy.mockRestore();
+    });
+
+    test("debug level logs all messages", () => {
+      const logger = getSdkLogger();
+      enableLogging("debug");
+
+      const debugSpy = vi.spyOn(console, "debug").mockImplementation(() => {});
+      const infoSpy = vi.spyOn(console, "info").mockImplementation(() => {});
+      const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+      const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+
+      logger.debug("debug");
+      logger.info("info");
+      logger.warn("warn");
+      logger.error("error");
+
+      expect(debugSpy).toHaveBeenCalledWith("debug");
+      expect(infoSpy).toHaveBeenCalledWith("info");
+      expect(warnSpy).toHaveBeenCalledWith("warn");
+      expect(errorSpy).toHaveBeenCalledWith("error");
+
+      debugSpy.mockRestore();
+      infoSpy.mockRestore();
+      warnSpy.mockRestore();
+      errorSpy.mockRestore();
+    });
+  });
+
+  describe("enableLogging and disableLogging", () => {
+    test("enableLogging sets the log level", () => {
+      const logger = getSdkLogger();
+      enableLogging("debug");
+
+      const debugSpy = vi.spyOn(console, "debug").mockImplementation(() => {});
+      logger.debug("test");
+      expect(debugSpy).toHaveBeenCalledWith("test");
+      debugSpy.mockRestore();
+    });
+
+    test("enableLogging defaults to info level", () => {
+      const logger = getSdkLogger();
+      enableLogging();
+
+      const infoSpy = vi.spyOn(console, "info").mockImplementation(() => {});
+      const debugSpy = vi.spyOn(console, "debug").mockImplementation(() => {});
+
+      logger.info("info");
+      logger.debug("debug");
+
+      expect(infoSpy).toHaveBeenCalledWith("info");
+      expect(debugSpy).not.toHaveBeenCalled();
+
+      infoSpy.mockRestore();
+      debugSpy.mockRestore();
+    });
+
+    test("disableLogging silences all output", () => {
+      const logger = getSdkLogger();
+      enableLogging("debug");
+      disableLogging();
+
+      const debugSpy = vi.spyOn(console, "debug").mockImplementation(() => {});
+      const infoSpy = vi.spyOn(console, "info").mockImplementation(() => {});
+
+      logger.debug("debug");
+      logger.info("info");
+
+      expect(debugSpy).not.toHaveBeenCalled();
+      expect(infoSpy).not.toHaveBeenCalled();
+
+      debugSpy.mockRestore();
+      infoSpy.mockRestore();
+    });
+  });
+
+  describe("custom logger", () => {
+    test("routes logs to custom logger when set", () => {
+      const logger = getSdkLogger();
+      enableLogging("info");
+
+      const customLogger: GalileoSdkLogger = {
+        debug: vi.fn(),
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+      };
+
+      setCustomLogger(customLogger);
+      logger.info("test message");
+
+      expect(customLogger.info).toHaveBeenCalledWith("test message");
+    });
+
+    test("uses custom logger for all log levels", () => {
+      const logger = getSdkLogger();
+      enableLogging("debug");
+
+      const customLogger: GalileoSdkLogger = {
+        debug: vi.fn(),
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+      };
+
+      setCustomLogger(customLogger);
+
+      logger.debug("debug");
+      logger.info("info");
+      logger.warn("warn");
+      logger.error("error");
+
+      expect(customLogger.debug).toHaveBeenCalledWith("debug");
+      expect(customLogger.info).toHaveBeenCalledWith("info");
+      expect(customLogger.warn).toHaveBeenCalledWith("warn");
+      expect(customLogger.error).toHaveBeenCalledWith("error");
+    });
+
+    test("respects log level filtering with custom logger", () => {
+      const logger = getSdkLogger();
+      enableLogging("warn");
+
+      const customLogger: GalileoSdkLogger = {
+        debug: vi.fn(),
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+      };
+
+      setCustomLogger(customLogger);
+
+      logger.debug("debug");
+      logger.info("info");
+      logger.warn("warn");
+      logger.error("error");
+
+      expect(customLogger.debug).not.toHaveBeenCalled();
+      expect(customLogger.info).not.toHaveBeenCalled();
+      expect(customLogger.warn).toHaveBeenCalledWith("warn");
+      expect(customLogger.error).toHaveBeenCalledWith("error");
+    });
+
+    test("clears custom logger when set to undefined", () => {
+      const logger = getSdkLogger();
+      enableLogging("info");
+
+      const customLogger: GalileoSdkLogger = {
+        debug: vi.fn(),
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+      };
+
+      setCustomLogger(customLogger);
+      logger.info("first");
+      expect(customLogger.info).toHaveBeenCalledWith("first");
+
+      setCustomLogger(undefined);
+
+      const infoSpy = vi.spyOn(console, "info").mockImplementation(() => {});
+      logger.info("second");
+
+      expect(infoSpy).toHaveBeenCalledWith("second");
+      expect(customLogger.info).toHaveBeenCalledTimes(1);
+
+      infoSpy.mockRestore();
+    });
+
+    test("falls back to console when custom logger not set", () => {
+      const logger = getSdkLogger();
+      enableLogging("info");
+
+      const infoSpy = vi.spyOn(console, "info").mockImplementation(() => {});
+      logger.info("console output");
+
+      expect(infoSpy).toHaveBeenCalledWith("console output");
+      infoSpy.mockRestore();
+    });
+  });
+
+  describe("logger with multiple arguments", () => {
+    test("passes all arguments to console log", () => {
+      const logger = getSdkLogger();
+      enableLogging("info");
+
+      const infoSpy = vi.spyOn(console, "info").mockImplementation(() => {});
+      logger.info("message", { key: "value" }, 123);
+
+      expect(infoSpy).toHaveBeenCalledWith("message", { key: "value" }, 123);
+      infoSpy.mockRestore();
+    });
+
+    test("passes all arguments to custom logger", () => {
+      const logger = getSdkLogger();
+      enableLogging("info");
+
+      const customLogger: GalileoSdkLogger = {
+        debug: vi.fn(),
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+      };
+
+      setCustomLogger(customLogger);
+      logger.info("message", { key: "value" }, 123);
+
+      expect(customLogger.info).toHaveBeenCalledWith(
+        "message",
+        { key: "value" },
+        123,
+      );
+    });
+  });
+
+  describe("environment variable integration", () => {
+    test("reads log level from GALILEO_LOG_LEVEL env var on startup", () => {
+      process.env[GALILEO_LOG_LEVEL] = "info";
+      // GalileoConfig requires at least one auth credential to process the config
+      process.env["GALILEO_API_KEY"] = "test-key";
+      GalileoConfig.reset();
+      resetSdkLogger();
+      const logger = getSdkLogger();
+
+      const infoSpy = vi.spyOn(console, "info").mockImplementation(() => {});
+      const debugSpy = vi.spyOn(console, "debug").mockImplementation(() => {});
+
+      logger.info("info");
+      logger.debug("debug");
+
+      expect(infoSpy).toHaveBeenCalledWith("info");
+      expect(debugSpy).not.toHaveBeenCalled();
+
+      infoSpy.mockRestore();
+      debugSpy.mockRestore();
+    });
+
+    test("handles mixed case env var value", () => {
+      process.env[GALILEO_LOG_LEVEL] = "DeBuG";
+      // GalileoConfig requires at least one auth credential to process the config
+      process.env["GALILEO_API_KEY"] = "test-key";
+      GalileoConfig.reset();
+      resetSdkLogger();
+      const logger = getSdkLogger();
+
+      const debugSpy = vi.spyOn(console, "debug").mockImplementation(() => {});
+      logger.debug("test");
+
+      expect(debugSpy).toHaveBeenCalledWith("test");
+      debugSpy.mockRestore();
+    });
+
+    test("ignores invalid env var and defaults to silent", () => {
+      process.env[GALILEO_LOG_LEVEL] = "notarealevel";
+      GalileoConfig.reset();
+      resetSdkLogger();
+      const logger = getSdkLogger();
+
+      const debugSpy = vi.spyOn(console, "debug").mockImplementation(() => {});
+      logger.debug("test");
+
+      expect(debugSpy).not.toHaveBeenCalled();
+      debugSpy.mockRestore();
+    });
+
+    test("respects GalileoConfig override", () => {
+      GalileoConfig.reset();
+      GalileoConfig.get({ logLevel: "debug" });
+      resetSdkLogger();
+      const logger = getSdkLogger();
+
+      const debugSpy = vi.spyOn(console, "debug").mockImplementation(() => {});
+      logger.debug("test");
+
+      expect(debugSpy).toHaveBeenCalledWith("test");
+      debugSpy.mockRestore();
+    });
+  });
+
+  describe("singleton behavior", () => {
+    test("getSdkLogger returns the same instance", () => {
+      const logger1 = getSdkLogger();
+      const logger2 = getSdkLogger();
+      expect(logger1).toBe(logger2);
+    });
+
+    test("state persists across getSdkLogger calls", () => {
+      getSdkLogger();
+      enableLogging("debug");
+
+      const debugSpy = vi.spyOn(console, "debug").mockImplementation(() => {});
+
+      const logger2 = getSdkLogger();
+      logger2.debug("test");
+
+      expect(debugSpy).toHaveBeenCalledWith("test");
+      debugSpy.mockRestore();
+    });
+  });
+
+  describe("edge cases", () => {
+    test("empty string log message works", () => {
+      const logger = getSdkLogger();
+      enableLogging("info");
+
+      const infoSpy = vi.spyOn(console, "info").mockImplementation(() => {});
+      logger.info("");
+
+      expect(infoSpy).toHaveBeenCalledWith("");
+      infoSpy.mockRestore();
+    });
+
+    test("null and undefined in args are passed through", () => {
+      const logger = getSdkLogger();
+      enableLogging("info");
+
+      const infoSpy = vi.spyOn(console, "info").mockImplementation(() => {});
+      logger.info("message", null, undefined);
+
+      expect(infoSpy).toHaveBeenCalledWith("message", null, undefined);
+      infoSpy.mockRestore();
+    });
+
+    test("changing level multiple times works correctly", () => {
+      const logger = getSdkLogger();
+
+      const debugSpy = vi.spyOn(console, "debug").mockImplementation(() => {});
+
+      enableLogging("silent");
+      logger.debug("1");
+      expect(debugSpy).not.toHaveBeenCalled();
+
+      enableLogging("debug");
+      logger.debug("2");
+      expect(debugSpy).toHaveBeenCalledWith("2");
+
+      enableLogging("silent");
+      logger.debug("3");
+      expect(debugSpy).toHaveBeenCalledTimes(1);
+
+      debugSpy.mockRestore();
+    });
+  });
+});

package/src/types/sdk-logger.types.ts

@@ -0,0 +1,43 @@
+/**
+ * Log level for SDK logging output.
+ *
+ * - `silent`: Disables all logging
+ * - `error`: Only error messages
+ * - `warn`: Warnings and errors
+ * - `info`: Info, warnings, and errors (default when logging is enabled)
+ * - `debug`: All messages including debug information
+ */
+export type LogLevel = "silent" | "error" | "warn" | "info" | "debug";
+
+/**
+ * Log level priority mapping for filtering log output.
+ *
+ * Higher numbers indicate more verbose output. Used internally
+ * to determine which messages should be logged based on the current level.
+ */
+export const LOG_LEVEL_PRIORITY: Record<LogLevel, number> = {
+  silent: -1,
+  error: 0,
+  warn: 1,
+  info: 2,
+  debug: 3,
+};
+
+/**
+ * Logger interface for SDK logging output.
+ *
+ * Used as:
+ * - The public contract for getSdkLogger() (what callers use for logging)
+ * - The interface that custom loggers must implement for setCustomLogger()
+ *
+ * Implement this interface to integrate SDK logging with custom loggers
+ * (e.g., Winston, Pino, or other structured logging libraries).
+ * Pass an implementation to setCustomLogger() to use it instead of console.
+ */
+export interface GalileoSdkLogger {
+  debug: (message: string, ...args: unknown[]) => void;
+  info: (message: string, ...args: unknown[]) => void;
+  warn: (message: string, ...args: unknown[]) => void;
+  error: (message: string, ...args: unknown[]) => void;
+}
+