@esaio/esa-mcp-server 0.2.0 → 0.2.2

package/src/__tests__/fixtures/mock-comment.ts

@@ -1,90 +0,0 @@
-import type { components } from "../../generated/api-types.js";
-import { transformComment } from "../../transformers/comment-transformer.js";
-
-export function createMockComment(
-  overrides?: Partial<components["schemas"]["Comment"]>,
-): components["schemas"]["Comment"] {
-  return {
-    id: 123,
-    post_number: 456,
-    body_md: "This is a test comment content",
-    body_html: "<p>This is a test comment content</p>",
-    created_at: "2024-01-01T00:00:00+09:00",
-    updated_at: "2024-01-01T01:00:00+09:00",
-    url: "https://test-team.esa.example.com/posts/456#comment-123",
-    created_by: {
-      name: "Test User",
-      screen_name: "testuser",
-      icon: "https://example.com/icon.png",
-      myself: true,
-    },
-    stargazers_count: 5,
-    star: true,
-    stargazers: [
-      {
-        created_at: "2024-01-01T02:00:00+09:00",
-        body: "Great comment!",
-        user: {
-          name: "Stargazer User",
-          screen_name: "stargazer",
-          icon: "https://example.com/star-icon.png",
-          myself: false,
-        },
-        name: "Stargazer User",
-        screen_name: "stargazer",
-        icon: "https://example.com/star-icon.png",
-        myself: false,
-        email: "stargazer@example.com",
-        role: "member" as const,
-        posts_count: 10,
-        joined_at: "2024-01-01T00:00:00+09:00",
-        last_accessed_at: "2024-01-01T02:00:00+09:00",
-      },
-    ],
-    ...overrides,
-  };
-}
-
-export function createLongContentComment(
-  length: number,
-): components["schemas"]["Comment"] {
-  const longContent = "a".repeat(length);
-  return createMockComment({
-    body_md: longContent,
-    body_html: `<p>${longContent}</p>`,
-  });
-}
-
-export function createNullBodyComment(
-  overrides?: Partial<components["schemas"]["Comment"]>,
-): components["schemas"]["Comment"] {
-  return createMockComment({
-    body_md: "",
-    body_html: "",
-    ...overrides,
-  });
-}
-
-export function createExpectedTransformedComment(
-  comment: components["schemas"]["Comment"],
-) {
-  return transformComment(comment);
-}
-
-export function createMockCommentList(
-  overrides?: Partial<components["schemas"]["CommentList"]>,
-): components["schemas"]["CommentList"] {
-  return {
-    comments: [
-      createMockComment({ id: 1, post_number: 123, body_md: "First comment" }),
-      createMockComment({ id: 2, post_number: 124, body_md: "Second comment" }),
-    ],
-    prev_page: null,
-    next_page: 2,
-    total_count: 10,
-    page: 1,
-    per_page: 20,
-    max_per_page: 100,
-    ...overrides,
-  };
-}

package/src/__tests__/fixtures/mock-post.ts

@@ -1,79 +0,0 @@
-import type { components } from "../../generated/api-types.js";
-import {
-  type PostTransformOptions,
-  transformPost,
-} from "../../transformers/post-transformer.js";
-
-export const createMockPost = (
-  overrides: Partial<components["schemas"]["Post"]> = {},
-): components["schemas"]["Post"] => ({
-  number: 123,
-  name: "test-post.md",
-  tags: ["tag1", "tag2"],
-  category: "dev",
-  full_name: "dev/test-post.md #tag1 #tag2",
-  wip: false,
-  body_md: "# Test Post\n\nThis is a test post content.",
-  body_html: "<h1>Test Post</h1><p>This is a test post content.</p>",
-  created_at: "2024-01-01T00:00:00+09:00",
-  updated_at: "2024-01-02T00:00:00+09:00",
-  message: "Update test post",
-  url: "https://test-team.esa.example.com/posts/123",
-  revision_number: 3,
-  created_by: {
-    name: "user1",
-    screen_name: "user1",
-    icon: "https://example.com/icon1.png",
-    myself: false,
-  },
-  updated_by: {
-    name: "user2",
-    screen_name: "user2",
-    icon: "https://example.com/icon2.png",
-    myself: false,
-  },
-  kind: "stock",
-  comments_count: 5,
-  tasks_count: 3,
-  done_tasks_count: 2,
-  stargazers_count: 10,
-  watchers_count: 8,
-  star: true,
-  watch: false,
-  ...overrides,
-});
-
-export const createWipPost = (
-  overrides: Partial<components["schemas"]["Post"]> = {},
-): components["schemas"]["Post"] =>
-  createMockPost({
-    wip: true,
-    number: 456,
-    name: "wip-post.md",
-    full_name: "docs/wip-post.md #wip",
-    url: "https://test-team.esa.example.com/posts/456",
-    kind: "flow",
-    ...overrides,
-  });
-
-export const createLongContentPost = (
-  contentLength = 600,
-): components["schemas"]["Post"] =>
-  createMockPost({
-    body_md: "a".repeat(contentLength),
-    body_html: `<p>${"a".repeat(contentLength)}</p>`,
-  });
-
-export const createNullBodyPost = (
-  overrides: Partial<components["schemas"]["Post"]> = {},
-): components["schemas"]["Post"] =>
-  createMockPost({
-    body_md: undefined,
-    body_html: undefined,
-    ...overrides,
-  });
-
-export const createExpectedTransformed = (
-  post: components["schemas"]["Post"],
-  options: PostTransformOptions = {},
-) => transformPost(post, options);

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");
-  });
-});