alepha 0.14.1 → 0.14.3

package/src/logger/services/Logger.spec.ts

@@ -0,0 +1,295 @@
+import { Alepha } from "alepha";
+import { describe, it } from "vitest";
+import {
+  LogDestinationProvider,
+  LogFormatterProvider,
+  MemoryDestinationProvider,
+  PrettyFormatterProvider,
+} from "../index.ts";
+import { Logger } from "../services/Logger.ts";
+
+describe("Logger", () => {
+  const createLogger = (service = "TestService", module = "test.module") => {
+    const alepha = Alepha.create({
+      env: { LOG_LEVEL: "info" },
+    })
+      .with({
+        provide: LogDestinationProvider,
+        use: MemoryDestinationProvider,
+      })
+      .with({
+        provide: LogFormatterProvider,
+        use: PrettyFormatterProvider,
+      });
+
+    return alepha.inject(Logger, {
+      lifetime: "transient",
+      args: [service, module],
+    });
+  };
+
+  describe("parseLevel", () => {
+    it("should return global level when no matching module found", ({
+      expect,
+    }) => {
+      const logger = createLogger();
+      // When no module-specific config matches, it falls back to global level
+      expect(logger.parseLevel("debug", "non.matching.module")).toBe("DEBUG");
+      expect(
+        logger.parseLevel("specific.module:trace,warn", "non.matching.module"),
+      ).toBe("WARN");
+    });
+
+    it("should parse simple global level", ({ expect }) => {
+      const logger = createLogger();
+      expect(logger.parseLevel("debug", "any.module")).toBe("DEBUG");
+      expect(logger.parseLevel("trace", "any.module")).toBe("TRACE");
+      expect(logger.parseLevel("warn", "any.module")).toBe("WARN");
+      expect(logger.parseLevel("error", "any.module")).toBe("ERROR");
+      expect(logger.parseLevel("silent", "any.module")).toBe("SILENT");
+    });
+
+    it("should parse module-specific level with colon separator", ({
+      expect,
+    }) => {
+      const logger = createLogger();
+      expect(logger.parseLevel("test:debug,info", "test.module")).toBe("DEBUG");
+      expect(logger.parseLevel("alepha:trace,warn", "alepha.core")).toBe(
+        "TRACE",
+      );
+      expect(logger.parseLevel("my.app:error,info", "my.app.service")).toBe(
+        "ERROR",
+      );
+    });
+
+    it("should parse module-specific level with equals separator", ({
+      expect,
+    }) => {
+      const logger = createLogger();
+      expect(logger.parseLevel("test=debug,info", "test.module")).toBe("DEBUG");
+      expect(logger.parseLevel("alepha=TRACE,warn", "alepha.core")).toBe(
+        "TRACE",
+      );
+      expect(logger.parseLevel("my.app=error,info", "my.app.service")).toBe(
+        "ERROR",
+      );
+    });
+
+    it("should handle multiple module configurations", ({ expect }) => {
+      const logger = createLogger();
+      const config = "alepha.core:trace,alepha.server:debug,my.app:error,info";
+
+      expect(logger.parseLevel(config, "alepha.core")).toBe("TRACE");
+      expect(logger.parseLevel(config, "alepha.server")).toBe("DEBUG");
+      expect(logger.parseLevel(config, "my.app")).toBe("ERROR");
+      expect(logger.parseLevel(config, "other.module")).toBe("INFO");
+    });
+
+    it("should handle semicolon separators", ({ expect }) => {
+      const logger = createLogger();
+      const config = "alepha:trace;my.app:error;info";
+
+      expect(logger.parseLevel(config, "alepha.core")).toBe("TRACE");
+      expect(logger.parseLevel(config, "my.app")).toBe("ERROR");
+      expect(logger.parseLevel(config, "other.module")).toBe("INFO");
+    });
+
+    it("should use startsWith matching for modules", ({ expect }) => {
+      const logger = createLogger();
+      const config = "alepha:debug,info";
+
+      expect(logger.parseLevel(config, "alepha")).toBe("DEBUG");
+      expect(logger.parseLevel(config, "alepha.core")).toBe("DEBUG");
+      expect(logger.parseLevel(config, "alepha.server.cache")).toBe("DEBUG");
+      expect(logger.parseLevel(config, "other.alepha")).toBe("INFO");
+    });
+
+    it("should prioritize first matching module", ({ expect }) => {
+      const logger = createLogger();
+      const config = "alepha:debug,alepha.core:trace,info";
+
+      // alepha.core matches both "alepha" and "alepha.core", but first match wins
+      expect(logger.parseLevel(config, "alepha.core")).toBe("DEBUG");
+    });
+
+    it("should handle case insensitive levels", ({ expect }) => {
+      const logger = createLogger();
+      expect(logger.parseLevel("DEBUG", "any.module")).toBe("DEBUG");
+      expect(logger.parseLevel("Test:TRACE,INFO", "test.module")).toBe("TRACE");
+    });
+
+    it("should handle whitespace around separators", ({ expect }) => {
+      const logger = createLogger();
+      const config = " alepha : debug , my.app : error , info ";
+
+      expect(logger.parseLevel(config, "alepha.core")).toBe("DEBUG");
+      expect(logger.parseLevel(config, "my.app")).toBe("ERROR");
+      expect(logger.parseLevel(config, "other")).toBe("INFO");
+    });
+
+    it("should fall back to global level when no module match", ({
+      expect,
+    }) => {
+      const logger = createLogger();
+      const config = "specific.module:debug,trace";
+
+      expect(logger.parseLevel(config, "other.module")).toBe("TRACE");
+    });
+
+    it("should handle empty parts gracefully", ({ expect }) => {
+      const logger = createLogger();
+      // Empty parts are now skipped gracefully
+      expect(logger.parseLevel(",,debug,,", "any.module")).toBe("DEBUG");
+      expect(logger.parseLevel("alepha:trace,,info", "alepha.core")).toBe(
+        "TRACE",
+      );
+      expect(logger.parseLevel("alepha:trace,,", "other.module")).toBe("INFO");
+      expect(logger.parseLevel("   ,  , debug ,  ", "any.module")).toBe(
+        "DEBUG",
+      );
+    });
+
+    it("should provide better error messages", ({ expect }) => {
+      const logger = createLogger();
+      expect(() =>
+        logger.parseLevel("alepha:invalid,info", "alepha.core"),
+      ).toThrow("Invalid log level 'invalid' for module pattern 'alepha'");
+      expect(() => logger.parseLevel("badlevel", "any.module")).toThrow(
+        'Invalid global log level "badlevel"',
+      );
+    });
+
+    it("should support wildcard patterns", ({ expect }) => {
+      const logger = createLogger();
+
+      // Basic wildcard matching
+      expect(logger.parseLevel("alepha.*:debug,info", "alepha.core")).toBe(
+        "DEBUG",
+      );
+      expect(logger.parseLevel("alepha.*:debug,info", "alepha.server")).toBe(
+        "DEBUG",
+      );
+      expect(logger.parseLevel("alepha.*:debug,info", "other.module")).toBe(
+        "INFO",
+      );
+
+      // More specific patterns
+      expect(
+        logger.parseLevel("*.test:silent,*.core:trace,info", "alepha.test"),
+      ).toBe("SILENT");
+      expect(
+        logger.parseLevel("*.test:silent,*.core:trace,info", "my.core"),
+      ).toBe("TRACE");
+      expect(
+        logger.parseLevel("*.test:silent,*.core:trace,info", "other.module"),
+      ).toBe("INFO");
+
+      // Exact prefix match still works (existing behavior)
+      expect(logger.parseLevel("alepha.core:debug,info", "alepha.core")).toBe(
+        "DEBUG",
+      );
+      expect(
+        logger.parseLevel("alepha.core:debug,info", "alepha.core.service"),
+      ).toBe("DEBUG"); // startsWith behavior
+    });
+
+    it("should prioritize more specific wildcard matches", ({ expect }) => {
+      const logger = createLogger();
+      // First match wins, so order matters
+      const config = "alepha.*:debug,alepha.core.*:trace,info";
+      expect(logger.parseLevel(config, "alepha.core.service")).toBe("DEBUG"); // matches alepha.* first
+
+      // Reverse order
+      const config2 = "alepha.core.*:trace,alepha.*:debug,info";
+      expect(logger.parseLevel(config2, "alepha.core.service")).toBe("TRACE"); // matches alepha.core.* first
+    });
+  });
+
+  describe("asLogLevel", () => {
+    it("should return valid log levels", ({ expect }) => {
+      const logger = createLogger();
+      expect(logger.asLogLevel("trace")).toBe("TRACE");
+      expect(logger.asLogLevel("debug")).toBe("DEBUG");
+      expect(logger.asLogLevel("info")).toBe("INFO");
+      expect(logger.asLogLevel("warn")).toBe("WARN");
+      expect(logger.asLogLevel("error")).toBe("ERROR");
+      expect(logger.asLogLevel("silent")).toBe("SILENT");
+    });
+
+    it("should handle whitespace", ({ expect }) => {
+      const logger = createLogger();
+      expect(logger.asLogLevel(" debug ")).toBe("DEBUG");
+      expect(logger.asLogLevel("  trace  ")).toBe("TRACE");
+    });
+
+    it("should throw error for invalid levels", ({ expect }) => {
+      const logger = createLogger();
+      expect(() => logger.asLogLevel("invalid")).toThrow(
+        "Invalid log level: invalid",
+      );
+      expect(() => logger.asLogLevel("")).toThrow("Invalid log level: ");
+      expect(() => logger.asLogLevel("DEBUqG")).toThrow(
+        "Invalid log level: DEBUqG",
+      );
+    });
+  });
+
+  describe("level getter", () => {
+    it("should update logLevel when state changes", ({ expect }) => {
+      const alepha = Alepha.create({
+        env: { LOG_LEVEL: "info" },
+      })
+        .with({
+          provide: LogDestinationProvider,
+          use: MemoryDestinationProvider,
+        })
+        .with({
+          provide: LogFormatterProvider,
+          use: PrettyFormatterProvider,
+        });
+
+      const logger = alepha.inject(Logger, {
+        lifetime: "transient",
+        args: ["TestService", "test.module"],
+      });
+
+      // Initial state
+      expect(logger.level).toBe("INFO");
+
+      // Change state
+      alepha.store.set("alepha.logger.level", "debug");
+      expect(logger.level).toBe("DEBUG");
+
+      // Change to module-specific config
+      alepha.store.set("alepha.logger.level", "test:trace,warn");
+      expect(logger.level).toBe("TRACE");
+    });
+
+    it("should cache parsed level until state changes", ({ expect }) => {
+      const alepha = Alepha.create({
+        env: { LOG_LEVEL: "info" },
+      })
+        .with({
+          provide: LogDestinationProvider,
+          use: MemoryDestinationProvider,
+        })
+        .with({
+          provide: LogFormatterProvider,
+          use: PrettyFormatterProvider,
+        });
+
+      const logger = alepha.inject(Logger, {
+        lifetime: "transient",
+        args: ["TestService", "test.module"],
+      });
+
+      alepha.store.set("alepha.logger.level", "test:debug,info");
+      const level1 = logger.level;
+      const level2 = logger.level;
+
+      expect(level1).toBe("DEBUG");
+      expect(level2).toBe("DEBUG");
+      expect(level1).toBe(level2); // Should be same instance/value
+    });
+  });
+});

package/src/mcp/__tests__/errors.spec.ts

@@ -0,0 +1,175 @@
+import { describe, expect, test } from "vitest";
+import {
+  JsonRpcErrorCodes,
+  McpError,
+  McpInvalidParamsError,
+  McpMethodNotFoundError,
+  McpPromptNotFoundError,
+  McpResourceNotFoundError,
+  McpToolNotFoundError,
+} from "../index.ts";
+
+// ---------------------------------------------------------------------------------------------------------------------
+
+describe("McpError", () => {
+  test("should be an instance of Error", () => {
+    const error = new McpError("Test error");
+    expect(error).toBeInstanceOf(Error);
+  });
+
+  test("should have correct name", () => {
+    const error = new McpError("Test error");
+    expect(error.name).toBe("McpError");
+  });
+
+  test("should have correct message", () => {
+    const error = new McpError("Test error message");
+    expect(error.message).toBe("Test error message");
+  });
+
+  test("should default to INTERNAL_ERROR code", () => {
+    const error = new McpError("Test error");
+    expect(error.code).toBe(JsonRpcErrorCodes.INTERNAL_ERROR);
+  });
+
+  test("should accept custom error code", () => {
+    const error = new McpError("Test error", -32000);
+    expect(error.code).toBe(-32000);
+  });
+});
+
+// ---------------------------------------------------------------------------------------------------------------------
+
+describe("McpMethodNotFoundError", () => {
+  test("should be an instance of McpError", () => {
+    const error = new McpMethodNotFoundError("unknown/method");
+    expect(error).toBeInstanceOf(McpError);
+    expect(error).toBeInstanceOf(Error);
+  });
+
+  test("should have correct name", () => {
+    const error = new McpMethodNotFoundError("unknown/method");
+    expect(error.name).toBe("McpMethodNotFoundError");
+  });
+
+  test("should include method name in message", () => {
+    const error = new McpMethodNotFoundError("custom/method");
+    expect(error.message).toBe("Method not found: custom/method");
+  });
+
+  test("should have METHOD_NOT_FOUND code", () => {
+    const error = new McpMethodNotFoundError("test");
+    expect(error.code).toBe(JsonRpcErrorCodes.METHOD_NOT_FOUND);
+  });
+});
+
+// ---------------------------------------------------------------------------------------------------------------------
+
+describe("McpToolNotFoundError", () => {
+  test("should be an instance of McpError", () => {
+    const error = new McpToolNotFoundError("unknown-tool");
+    expect(error).toBeInstanceOf(McpError);
+  });
+
+  test("should have correct name", () => {
+    const error = new McpToolNotFoundError("test-tool");
+    expect(error.name).toBe("McpToolNotFoundError");
+  });
+
+  test("should include tool name in message", () => {
+    const error = new McpToolNotFoundError("my-tool");
+    expect(error.message).toBe("Tool not found: my-tool");
+  });
+
+  test("should store tool name as property", () => {
+    const error = new McpToolNotFoundError("calculator");
+    expect(error.tool).toBe("calculator");
+  });
+
+  test("should have METHOD_NOT_FOUND code", () => {
+    const error = new McpToolNotFoundError("test");
+    expect(error.code).toBe(JsonRpcErrorCodes.METHOD_NOT_FOUND);
+  });
+});
+
+// ---------------------------------------------------------------------------------------------------------------------
+
+describe("McpResourceNotFoundError", () => {
+  test("should be an instance of McpError", () => {
+    const error = new McpResourceNotFoundError("file:///test");
+    expect(error).toBeInstanceOf(McpError);
+  });
+
+  test("should have correct name", () => {
+    const error = new McpResourceNotFoundError("file:///test");
+    expect(error.name).toBe("McpResourceNotFoundError");
+  });
+
+  test("should include URI in message", () => {
+    const error = new McpResourceNotFoundError("config://app");
+    expect(error.message).toBe("Resource not found: config://app");
+  });
+
+  test("should store URI as property", () => {
+    const error = new McpResourceNotFoundError("db://users/123");
+    expect(error.uri).toBe("db://users/123");
+  });
+
+  test("should have METHOD_NOT_FOUND code", () => {
+    const error = new McpResourceNotFoundError("test://");
+    expect(error.code).toBe(JsonRpcErrorCodes.METHOD_NOT_FOUND);
+  });
+});
+
+// ---------------------------------------------------------------------------------------------------------------------
+
+describe("McpPromptNotFoundError", () => {
+  test("should be an instance of McpError", () => {
+    const error = new McpPromptNotFoundError("unknown-prompt");
+    expect(error).toBeInstanceOf(McpError);
+  });
+
+  test("should have correct name", () => {
+    const error = new McpPromptNotFoundError("test-prompt");
+    expect(error.name).toBe("McpPromptNotFoundError");
+  });
+
+  test("should include prompt name in message", () => {
+    const error = new McpPromptNotFoundError("greeting");
+    expect(error.message).toBe("Prompt not found: greeting");
+  });
+
+  test("should store prompt name as property", () => {
+    const error = new McpPromptNotFoundError("code-review");
+    expect(error.prompt).toBe("code-review");
+  });
+
+  test("should have METHOD_NOT_FOUND code", () => {
+    const error = new McpPromptNotFoundError("test");
+    expect(error.code).toBe(JsonRpcErrorCodes.METHOD_NOT_FOUND);
+  });
+});
+
+// ---------------------------------------------------------------------------------------------------------------------
+
+describe("McpInvalidParamsError", () => {
+  test("should be an instance of McpError", () => {
+    const error = new McpInvalidParamsError("Invalid params");
+    expect(error).toBeInstanceOf(McpError);
+  });
+
+  test("should have correct name", () => {
+    const error = new McpInvalidParamsError("test");
+    expect(error.name).toBe("McpInvalidParamsError");
+  });
+
+  test("should have provided message", () => {
+    const error = new McpInvalidParamsError("Missing required parameter: name");
+    expect(error.message).toBe("Missing required parameter: name");
+  });
+
+  test("should have INVALID_PARAMS code", () => {
+    const error = new McpInvalidParamsError("test");
+    expect(error.code).toBe(JsonRpcErrorCodes.INVALID_PARAMS);
+  });
+});