@esaio/esa-mcp-server 0.2.1 → 0.2.3

package/src/__tests__/index.test.ts

@@ -1,216 +0,0 @@
-import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import type { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import type { MockInstance } from "vitest";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-describe("MCP Server", () => {
-  let consoleErrorSpy: MockInstance<typeof console.error>;
-  let processExitSpy: MockInstance<typeof process.exit>;
-
-  const createMockConfig = (behavior?: { shouldThrow?: boolean }) => ({
-    config: {
-      server: {
-        name: "test-server",
-        version: "1.0.0",
-      },
-      esa: {
-        apiAccessToken: "test-token",
-        apiBaseUrl: "https://api.esa.example.com",
-      },
-    },
-    validateConfig: vi.fn().mockImplementation(() => {
-      if (behavior?.shouldThrow) {
-        throw new Error("Invalid config");
-      }
-    }),
-  });
-
-  const createMockServer = (behavior?: { shouldFailConnect?: boolean }) => {
-    const mockConnect = behavior?.shouldFailConnect
-      ? vi.fn().mockRejectedValue(new Error("Connection failed"))
-      : vi.fn().mockResolvedValue(undefined);
-
-    return {
-      connect: mockConnect,
-    } as unknown as McpServer;
-  };
-
-  const createMockTransport = () =>
-    ({
-      onclose: undefined as (() => void) | undefined,
-      onerror: undefined as ((error: Error) => void) | undefined,
-    }) as unknown as StdioServerTransport;
-
-  const setupServerMocks = (
-    mockConfig: ReturnType<typeof createMockConfig>,
-    mockServer: ReturnType<typeof createMockServer>,
-    mockTransport: ReturnType<typeof createMockTransport>,
-    setupFunctions?: {
-      setupTools?: ReturnType<typeof vi.fn>;
-      setupResources?: ReturnType<typeof vi.fn>;
-      setupPrompts?: ReturnType<typeof vi.fn>;
-      initI18n?: ReturnType<typeof vi.fn>;
-    },
-  ) => {
-    // Use function keyword for constructor mocks (required in vitest v4)
-    // biome-ignore lint/complexity/useArrowFunction: Constructor mocks in vitest v4 require function keyword, not arrow functions
-    const MockMcpServer = vi.fn(function (..._args: unknown[]) {
-      return mockServer;
-    });
-    // biome-ignore lint/complexity/useArrowFunction: Constructor mocks in vitest v4 require function keyword, not arrow functions
-    const MockStdioServerTransport = vi.fn(function (..._args: unknown[]) {
-      return mockTransport;
-    });
-
-    vi.doMock("../config/index.js", () => mockConfig);
-    vi.doMock("@modelcontextprotocol/sdk/server/mcp.js", () => ({
-      McpServer: MockMcpServer,
-    }));
-    vi.doMock("@modelcontextprotocol/sdk/server/stdio.js", () => ({
-      StdioServerTransport: MockStdioServerTransport,
-    }));
-    vi.doMock("../tools/index.js", () => ({
-      setupTools: setupFunctions?.setupTools ?? vi.fn(),
-    }));
-    vi.doMock("../resources/index.js", () => ({
-      setupResources: setupFunctions?.setupResources ?? vi.fn(),
-    }));
-    vi.doMock("../prompts/index.js", () => ({
-      setupPrompts: setupFunctions?.setupPrompts ?? vi.fn(),
-    }));
-    vi.doMock("../i18n/index.js", () => ({
-      initI18n:
-        setupFunctions?.initI18n ?? vi.fn().mockResolvedValue(undefined),
-    }));
-
-    return { MockMcpServer, MockStdioServerTransport };
-  };
-
-  beforeEach(() => {
-    vi.resetModules();
-    vi.clearAllMocks();
-
-    consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
-    processExitSpy = vi
-      .spyOn(process, "exit")
-      .mockImplementation(() => undefined as never);
-  });
-
-  afterEach(() => {
-    consoleErrorSpy.mockRestore();
-    processExitSpy.mockRestore();
-    vi.resetModules();
-  });
-
-  it("should validate config on startup", async () => {
-    const mockConfig = createMockConfig();
-    const mockServer = createMockServer();
-    const mockTransport = createMockTransport();
-
-    setupServerMocks(mockConfig, mockServer, mockTransport);
-
-    await import("../index.js");
-
-    expect(mockConfig.validateConfig).toHaveBeenCalled();
-  });
-
-  it("should exit with error when config validation fails", async () => {
-    const mockConfig = createMockConfig({ shouldThrow: true });
-
-    vi.doMock("../config/index.js", () => mockConfig);
-
-    try {
-      await import("../index.js");
-    } catch (_error) {
-      // Expected to throw due to config validation
-    }
-
-    expect(consoleErrorSpy).toHaveBeenCalledWith(
-      "Configuration error:",
-      expect.any(Error),
-    );
-    expect(processExitSpy).toHaveBeenCalledWith(1);
-  });
-
-  it("should create MCP server and connect", async () => {
-    const mockConfig = createMockConfig();
-    const mockServer = createMockServer();
-    const mockTransport = createMockTransport();
-
-    // Track setup function calls
-    const mockSetupTools = vi.fn();
-    const mockSetupResources = vi.fn();
-    const mockSetupPrompts = vi.fn();
-
-    const { MockMcpServer } = setupServerMocks(
-      mockConfig,
-      mockServer,
-      mockTransport,
-      {
-        setupTools: mockSetupTools,
-        setupResources: mockSetupResources,
-        setupPrompts: mockSetupPrompts,
-      },
-    );
-
-    await import("../index.js");
-
-    expect(MockMcpServer).toHaveBeenCalledWith({
-      name: "test-server",
-      version: "1.0.0",
-    });
-
-    const expectedEsaConfig = {
-      apiAccessToken: "test-token",
-      apiBaseUrl: "https://api.esa.example.com",
-    };
-
-    expect(mockSetupTools).toHaveBeenCalledWith(mockServer, expectedEsaConfig);
-    expect(mockSetupResources).toHaveBeenCalledWith(
-      mockServer,
-      expectedEsaConfig,
-    );
-    expect(mockSetupPrompts).toHaveBeenCalledWith(
-      mockServer,
-      expectedEsaConfig,
-    );
-    expect(mockServer.connect).toHaveBeenCalled();
-    expect(consoleErrorSpy).toHaveBeenCalledWith("test-server v1.0.0 started");
-  });
-
-  it("should set up transport error handlers", async () => {
-    const mockConfig = createMockConfig();
-    const mockServer = createMockServer();
-    const mockTransport = createMockTransport();
-
-    setupServerMocks(mockConfig, mockServer, mockTransport);
-
-    await import("../index.js");
-
-    expect(mockTransport.onclose).toBeDefined();
-    expect(mockTransport.onerror).toBeDefined();
-
-    mockTransport.onclose?.();
-    expect(consoleErrorSpy).toHaveBeenCalledWith("Transport closed");
-
-    const testError = new Error("Test error");
-    mockTransport.onerror?.(testError);
-    expect(consoleErrorSpy).toHaveBeenCalledWith("Transport error:", testError);
-  });
-
-  it("should handle server startup errors", async () => {
-    const mockConfig = createMockConfig();
-    const mockServer = createMockServer({ shouldFailConnect: true });
-    const mockTransport = createMockTransport();
-
-    setupServerMocks(mockConfig, mockServer, mockTransport);
-
-    await import("../index.js");
-
-    expect(consoleErrorSpy).toHaveBeenCalledWith(
-      "Server startup error:",
-      expect.any(Error),
-    );
-    expect(processExitSpy).toHaveBeenCalledWith(1);
-  });
-});

package/src/api_client/__tests__/index.test.ts

@@ -1,149 +0,0 @@
-import createClient from "openapi-fetch";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import packageJson from "../../../package.json" with { type: "json" };
-import type { paths } from "../../generated/api-types.js";
-import { createEsaClient } from "../index.js";
-
-// Mock openapi-fetch to test client configuration without actual HTTP calls
-vi.mock("openapi-fetch", () => ({
-  default: vi.fn(),
-}));
-
-describe("createEsaClient", () => {
-  // Create mock client with use method to verify middleware registration
-  const createMockClient = () =>
-    ({
-      use: vi.fn(),
-    }) as unknown as ReturnType<typeof createClient<paths>>;
-
-  // Setup test environment with configurable parameters for different test scenarios
-  const setupTest = (overrides?: {
-    apiBaseUrl?: string;
-    apiAccessToken?: string;
-  }) => {
-    const config = {
-      apiBaseUrl: overrides?.apiBaseUrl ?? "https://api.esa.example.com",
-      apiAccessToken: overrides?.apiAccessToken ?? "test-token",
-    };
-
-    const mockClient = createMockClient();
-    const mockCreateClient = vi.mocked(createClient);
-    mockCreateClient.mockReturnValue(mockClient);
-
-    return { config, mockClient, mockCreateClient };
-  };
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it("should create client with correct baseUrl", () => {
-    const { config, mockCreateClient } = setupTest();
-
-    createEsaClient(config.apiAccessToken, config.apiBaseUrl);
-
-    expect(mockCreateClient).toHaveBeenCalledWith({
-      baseUrl: config.apiBaseUrl,
-    });
-  });
-
-  it("should add User-Agent and Auth middleware to client", () => {
-    const { config, mockClient } = setupTest();
-
-    createEsaClient(config.apiAccessToken, config.apiBaseUrl);
-
-    expect(mockClient.use).toHaveBeenCalledTimes(2);
-    expect(mockClient.use).toHaveBeenNthCalledWith(
-      1,
-      expect.objectContaining({
-        onRequest: expect.any(Function),
-      }),
-    );
-    expect(mockClient.use).toHaveBeenNthCalledWith(
-      2,
-      expect.objectContaining({
-        onRequest: expect.any(Function),
-      }),
-    );
-  });
-
-  it("should return the configured client", () => {
-    const { config, mockClient } = setupTest();
-
-    const result = createEsaClient(config.apiAccessToken, config.apiBaseUrl);
-
-    expect(result).toBe(mockClient);
-  });
-
-  it("should set User-Agent header in middleware", async () => {
-    const { config, mockClient } = setupTest();
-
-    createEsaClient(config.apiAccessToken, config.apiBaseUrl);
-
-    // Get the User-Agent middleware function (first one registered)
-    const useMock = mockClient.use as ReturnType<typeof vi.fn>;
-    const userAgentMiddleware = useMock.mock.calls[0][0];
-
-    // Create mock request to verify User-Agent header is set
-    const mockRequest = {
-      headers: {
-        set: vi.fn(),
-      },
-    };
-
-    await userAgentMiddleware.onRequest({ request: mockRequest });
-
-    expect(mockRequest.headers.set).toHaveBeenCalledWith(
-      "User-Agent",
-      `esa-mcp-server/${packageJson.version} (official)`,
-    );
-  });
-
-  it("should set Authorization header in middleware", async () => {
-    const { config, mockClient } = setupTest();
-
-    createEsaClient(config.apiAccessToken, config.apiBaseUrl);
-
-    // Get the Auth middleware function (second one registered)
-    const useMock = mockClient.use as ReturnType<typeof vi.fn>;
-    const authMiddleware = useMock.mock.calls[1][0];
-
-    // Create mock request to verify Authorization header is set
-    const mockRequest = {
-      headers: {
-        set: vi.fn(),
-      },
-    };
-
-    await authMiddleware.onRequest({ request: mockRequest });
-
-    expect(mockRequest.headers.set).toHaveBeenCalledWith(
-      "Authorization",
-      `Bearer ${config.apiAccessToken}`,
-    );
-  });
-
-  it("should create separate client instances for different tokens", () => {
-    const { config, mockCreateClient, mockClient } = setupTest();
-    const token1 = "token-1";
-    const token2 = "token-2";
-
-    createEsaClient(token1, config.apiBaseUrl);
-    createEsaClient(token2, config.apiBaseUrl);
-
-    expect(mockCreateClient).toHaveBeenCalledTimes(2);
-    expect(mockClient.use).toHaveBeenCalledTimes(4); // 2 middlewares × 2 clients
-  });
-
-  it("should create separate client instances for different base URLs", () => {
-    const { config, mockCreateClient } = setupTest();
-    const url1 = "https://api.esa.example.com";
-    const url2 = "https://api.example.com";
-
-    createEsaClient(config.apiAccessToken, url1);
-    createEsaClient(config.apiAccessToken, url2);
-
-    expect(mockCreateClient).toHaveBeenCalledWith({ baseUrl: url1 });
-    expect(mockCreateClient).toHaveBeenCalledWith({ baseUrl: url2 });
-  });
-});

package/src/api_client/__tests__/middleware.test.ts

@@ -1,120 +0,0 @@
-import type { MockInstance } from "vitest";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { createAuthMiddleware } from "../middleware.js";
-
-describe("createAuthMiddleware", () => {
-  // Mock console.error to verify rate limit and error logging without console output
-  let consoleErrorSpy: MockInstance<typeof console.error>;
-
-  // Create test request for authorization header testing
-  const createTestRequest = (url = "https://api.esa.example.com/test") =>
-    new Request(url);
-
-  // Create test response with optional rate limit headers
-  const createTestResponse = (rateLimitHeaders?: {
-    limit?: string;
-    remaining?: string;
-  }) => {
-    const headers: Record<string, string> = {};
-    if (rateLimitHeaders?.limit) {
-      headers["x-ratelimit-limit"] = rateLimitHeaders.limit;
-    }
-    if (rateLimitHeaders?.remaining) {
-      headers["x-ratelimit-remaining"] = rateLimitHeaders.remaining;
-    }
-    return new Response(null, { headers });
-  };
-
-  // Helper to call middleware methods with minimal required context using as unknown as pattern
-  const callOnRequest = (
-    middleware: ReturnType<typeof createAuthMiddleware>,
-    request: Request,
-  ) =>
-    middleware.onRequest?.({
-      request,
-      schemaPath: "/test",
-      params: {},
-      id: "test-id",
-      options: { baseUrl: "https://api.esa.example.com" },
-    } as unknown as Parameters<NonNullable<typeof middleware.onRequest>>[0]);
-
-  const callOnResponse = (
-    middleware: ReturnType<typeof createAuthMiddleware>,
-    response: Response,
-  ) =>
-    middleware.onResponse?.({
-      request: createTestRequest(),
-      response,
-      schemaPath: "/test",
-      params: {},
-      id: "test-id",
-      options: { baseUrl: "https://api.esa.example.com" },
-    } as unknown as Parameters<NonNullable<typeof middleware.onResponse>>[0]);
-
-  const callOnError = (
-    middleware: ReturnType<typeof createAuthMiddleware>,
-    error: Error,
-  ) =>
-    middleware.onError?.({
-      request: createTestRequest(),
-      error,
-      schemaPath: "/test",
-      params: {},
-      id: "test-id",
-      options: { baseUrl: "https://api.esa.example.com" },
-    } as unknown as Parameters<NonNullable<typeof middleware.onError>>[0]);
-
-  beforeEach(() => {
-    consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
-  });
-
-  afterEach(() => {
-    consoleErrorSpy.mockRestore();
-  });
-
-  it("should add authorization header", async () => {
-    const middleware = createAuthMiddleware("test-token");
-    const request = createTestRequest();
-
-    expect(middleware.onRequest).toBeDefined();
-    expect(request.headers.get("Authorization")).toBeNull();
-
-    await callOnRequest(middleware, request);
-
-    expect(request.headers.get("Authorization")).toBe("Bearer test-token");
-  });
-
-  it("should log rate limit info when present", async () => {
-    const middleware = createAuthMiddleware("test-token");
-    const response = createTestResponse({ limit: "75", remaining: "50" });
-
-    await callOnResponse(middleware, response);
-    expect(consoleErrorSpy).toHaveBeenCalledWith("Rate limit: 50/75");
-  });
-
-  it("should handle response without rate limit headers", async () => {
-    const middleware = createAuthMiddleware("test-token");
-    const response = createTestResponse();
-
-    await callOnResponse(middleware, response);
-    expect(consoleErrorSpy).not.toHaveBeenCalled();
-  });
-
-  it("should log network errors", async () => {
-    const middleware = createAuthMiddleware("test-token");
-    const error = new Error("Network failed");
-
-    await callOnError(middleware, error);
-    expect(consoleErrorSpy).toHaveBeenCalledWith("Network Error:", error);
-  });
-
-  it("should return the modified request", async () => {
-    const middleware = createAuthMiddleware("test-token");
-    const request = createTestRequest();
-
-    const result = await callOnRequest(middleware, request);
-
-    expect(result).toBe(request);
-    expect(request.headers.get("Authorization")).toBe("Bearer test-token");
-  });
-});

package/src/api_client/__tests__/with-context.test.ts

@@ -1,98 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { createEsaClient } from "../index.js";
-import { withContext } from "../with-context.js";
-
-// Mock createEsaClient to test context handling without real API client creation
-vi.mock("../index.js", () => ({
-  createEsaClient: vi.fn(),
-}));
-
-describe("withContext", () => {
-  const mockCreateEsaClient = vi.mocked(createEsaClient);
-
-  // Mock client instance to verify it's passed to handlers correctly
-  const mockClient: Partial<ReturnType<typeof createEsaClient>> = {};
-
-  // Mock handler function to verify arguments and return values
-  const mockHandler = vi.fn();
-
-  // Create test context with default values and optional overrides
-  const createTestContext = (overrides?: {
-    apiAccessToken?: string;
-    apiBaseUrl?: string;
-  }) => ({
-    apiAccessToken: overrides?.apiAccessToken ?? "test-token",
-    apiBaseUrl: overrides?.apiBaseUrl ?? "https://api.esa.example.com",
-  });
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    mockCreateEsaClient.mockReturnValue(
-      mockClient as ReturnType<typeof createEsaClient>,
-    );
-  });
-
-  it("should create client and call handler for StdioContext", async () => {
-    const context = createTestContext();
-    const expectedResult = { success: true };
-    mockHandler.mockResolvedValue(expectedResult);
-
-    const result = await withContext(context, mockHandler, "arg1", "arg2");
-
-    expect(mockCreateEsaClient).toHaveBeenCalledWith(
-      context.apiAccessToken,
-      context.apiBaseUrl,
-    );
-    expect(mockHandler).toHaveBeenCalledWith(mockClient, "arg1", "arg2");
-    expect(result).toBe(expectedResult);
-  });
-
-  it("should work with different apiBaseUrl", async () => {
-    const context = createTestContext({
-      apiBaseUrl: "https://api.example.com",
-    });
-
-    await withContext(context, mockHandler);
-
-    expect(mockCreateEsaClient).toHaveBeenCalledWith(
-      context.apiAccessToken,
-      context.apiBaseUrl,
-    );
-  });
-
-  it("should throw error for unsupported context type", async () => {
-    // Create invalid context missing required apiAccessToken property
-    const invalidContext = {
-      someOtherProperty: "value",
-    };
-
-    await expect(
-      withContext(
-        invalidContext as unknown as Parameters<typeof withContext>[0],
-        mockHandler,
-      ),
-    ).rejects.toThrow(
-      "Unsupported context type. Only StdioContext is currently supported.",
-    );
-  });
-
-  it("should handle handler errors correctly", async () => {
-    const context = createTestContext();
-    const handlerError = new Error("Handler failed");
-    mockHandler.mockRejectedValue(handlerError);
-
-    await expect(withContext(context, mockHandler)).rejects.toThrow(
-      "Handler failed",
-    );
-  });
-
-  it("should pass through handler arguments correctly", async () => {
-    const context = createTestContext();
-    const args = [{ page: 1 }, { per_page: 20 }, "extra"];
-    mockHandler.mockResolvedValue("success");
-
-    await withContext(context, mockHandler, ...args);
-
-    expect(mockHandler).toHaveBeenCalledWith(mockClient, ...args);
-  });
-});

package/src/api_client/index.ts

@@ -1,29 +0,0 @@
-import createClient from "openapi-fetch";
-import packageJson from "../../package.json" with { type: "json" };
-import type { paths } from "../generated/api-types.js";
-import { createAuthMiddleware } from "./middleware.js";
-
-const packageVersion = packageJson.version;
-
-function createUserAgentMiddleware(version: string) {
-  return {
-    async onRequest({ request }: { request: Request }) {
-      request.headers.set("User-Agent", `esa-mcp-server/${version} (official)`);
-      return request;
-    },
-  };
-}
-
-export function createEsaClient(
-  apiAccessToken: string,
-  apiBaseUrl: string = "https://api.esa.io",
-) {
-  const client = createClient<paths>({
-    baseUrl: apiBaseUrl,
-  });
-
-  client.use(createUserAgentMiddleware(packageVersion));
-  client.use(createAuthMiddleware(apiAccessToken));
-
-  return client;
-}

package/src/api_client/middleware.ts

@@ -1,21 +0,0 @@
-import type { Middleware } from "openapi-fetch";
-
-export function createAuthMiddleware(apiAccessToken: string): Middleware {
-  return {
-    async onRequest({ request }) {
-      request.headers.set("Authorization", `Bearer ${apiAccessToken}`);
-      return request;
-    },
-    async onResponse({ response }) {
-      const rateLimit = response.headers.get("x-ratelimit-limit");
-      const remaining = response.headers.get("x-ratelimit-remaining");
-      if (rateLimit && remaining) {
-        console.error(`Rate limit: ${remaining}/${rateLimit}`);
-      }
-      return response;
-    },
-    async onError({ error }) {
-      console.error("Network Error:", error);
-    },
-  };
-}

package/src/api_client/with-context.ts

@@ -1,26 +0,0 @@
-import { createEsaClient } from "../api_client/index.js";
-import type { MCPContext } from "../context/mcp-context.js";
-
-export async function withContext<T extends unknown[], R>(
-  context: MCPContext,
-  handler: (
-    client: ReturnType<typeof createEsaClient>,
-    ...args: T
-  ) => Promise<R>,
-  ...args: T
-): Promise<R> {
-  let client: ReturnType<typeof createEsaClient>;
-
-  if ("apiAccessToken" in context && "apiBaseUrl" in context) {
-    client = createEsaClient(
-      context.apiAccessToken as string,
-      context.apiBaseUrl as string,
-    );
-  } else {
-    throw new Error(
-      "Unsupported context type. Only StdioContext is currently supported.",
-    );
-  }
-
-  return handler(client, ...args);
-}