@mandujs/cli 0.15.1 → 0.15.2

package/templates/realtime-chat/src/shared/contracts/chat.ts

@@ -0,0 +1,29 @@
+export interface ChatMessage {
+  id: string;
+  role: "user" | "assistant";
+  text: string;
+  createdAt: string;
+}
+
+export interface ChatMessagePayload {
+  text: string;
+}
+
+export interface ChatMessageResponse {
+  message: ChatMessage;
+}
+
+export interface ChatHistoryResponse {
+  messages: ChatMessage[];
+}
+
+export interface ChatStreamEvent {
+  type: "snapshot" | "message" | "heartbeat";
+  data: ChatMessage[] | ChatMessage | { ts: string };
+}
+
+export function isChatMessagePayload(value: unknown): value is ChatMessagePayload {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value as Partial<ChatMessagePayload>;
+  return typeof candidate.text === "string" && candidate.text.trim().length > 0;
+}

package/templates/realtime-chat/src/shared/contracts/index.ts

@@ -0,0 +1 @@
+export * from "./chat";

package/templates/realtime-chat/src/shared/env/index.ts

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

package/templates/realtime-chat/src/shared/schema/index.ts

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

package/templates/realtime-chat/src/shared/types/index.ts

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

package/templates/realtime-chat/src/shared/utils/client/index.ts

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

package/templates/realtime-chat/src/shared/utils/server/index.ts

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

package/templates/realtime-chat/tests/chat-api.sse.test.ts

@@ -0,0 +1,151 @@
+import { describe, expect, it } from "bun:test";
+import { openChatStream } from "@/client/features/chat/chat-api";
+import type { ChatStreamEvent } from "@/shared/contracts/chat";
+
+type MessageEventLike = { data: string };
+
+class FakeEventSource {
+  onopen: ((event: Event) => void) | null = null;
+  onmessage: ((event: MessageEventLike) => void) | null = null;
+  onerror: ((event: Event) => void) | null = null;
+  closed = false;
+
+  constructor(readonly url: string) {}
+
+  emitOpen() {
+    this.onopen?.(new Event("open"));
+  }
+
+  emitMessage(data: string) {
+    this.onmessage?.({ data });
+  }
+
+  emitError() {
+    this.onerror?.(new Event("error"));
+  }
+
+  close() {
+    this.closed = true;
+  }
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+describe("openChatStream", () => {
+  it("reconnects with capped retries when stream errors", async () => {
+    const sources: FakeEventSource[] = [];
+    const stop = openChatStream(() => {}, {
+      baseDelayMs: 5,
+      maxDelayMs: 20,
+      jitterRatio: 0,
+      maxRetries: 2,
+      eventSourceFactory: (url) => {
+        const source = new FakeEventSource(url);
+        sources.push(source);
+        return source as unknown as EventSource;
+      },
+    });
+
+    expect(sources.length).toBe(1);
+    expect(sources[0]?.url).toBe("/api/chat/stream");
+
+    sources[0]?.emitError();
+    await sleep(8);
+    expect(sources.length).toBe(2);
+
+    sources[1]?.emitError();
+    await sleep(12);
+    expect(sources.length).toBe(3);
+
+    sources[2]?.emitError();
+    await sleep(25);
+    expect(sources.length).toBe(3);
+
+    stop();
+  });
+
+  it("notifies connection state changes and terminal failure", async () => {
+    const states: Array<"connecting" | "connected" | "reconnecting" | "failed" | "closed"> = [];
+    const sources: FakeEventSource[] = [];
+
+    const stop = openChatStream(() => {}, {
+      baseDelayMs: 5,
+      maxDelayMs: 5,
+      jitterRatio: 0,
+      maxRetries: 1,
+      onConnectionStateChange: (state) => {
+        states.push(state);
+      },
+      eventSourceFactory: (url) => {
+        const source = new FakeEventSource(url);
+        sources.push(source);
+        return source as unknown as EventSource;
+      },
+    });
+
+    expect(states).toEqual(["connecting"]);
+
+    sources[0]?.emitOpen();
+    expect(states).toEqual(["connecting", "connected"]);
+
+    sources[0]?.emitError();
+    expect(states).toEqual(["connecting", "connected", "reconnecting"]);
+
+    await sleep(8);
+    expect(states).toEqual(["connecting", "connected", "reconnecting", "connecting"]);
+
+    sources[1]?.emitError();
+    expect(states).toEqual(["connecting", "connected", "reconnecting", "connecting", "failed"]);
+
+    stop();
+    expect(states).toEqual(["connecting", "connected", "reconnecting", "connecting", "failed", "closed"]);
+  });
+
+  it("cleans up source and pending reconnect timer on stop", async () => {
+    const sources: FakeEventSource[] = [];
+    const stop = openChatStream(() => {}, {
+      baseDelayMs: 20,
+      maxDelayMs: 20,
+      jitterRatio: 0,
+      maxRetries: 3,
+      eventSourceFactory: (url) => {
+        const source = new FakeEventSource(url);
+        sources.push(source);
+        return source as unknown as EventSource;
+      },
+    });
+
+    expect(sources.length).toBe(1);
+
+    sources[0]?.emitError();
+    stop();
+
+    await sleep(30);
+    expect(sources.length).toBe(1);
+    expect(sources[0]?.closed).toBe(true);
+  });
+
+  it("forwards valid payload and ignores malformed payload", () => {
+    const events: ChatStreamEvent[] = [];
+    const sources: FakeEventSource[] = [];
+
+    const stop = openChatStream((event) => {
+      events.push(event);
+    }, {
+      eventSourceFactory: (url) => {
+        const source = new FakeEventSource(url);
+        sources.push(source);
+        return source as unknown as EventSource;
+      },
+    });
+
+    sources[0]?.emitMessage("{not-json");
+    sources[0]?.emitMessage(JSON.stringify({ type: "message" }));
+
+    expect(events).toEqual([{ type: "message" }]);
+
+    stop();
+  });
+});

package/templates/realtime-chat/tests/chat-starter.test.ts

@@ -0,0 +1,149 @@
+import { beforeEach, describe, expect, it } from "bun:test";
+import { GET as getMessages, POST as postMessage } from "../app/api/chat/messages/route";
+import { GET as getStream } from "../app/api/chat/stream/route";
+import {
+  __resetChatStoreForTests,
+  appendMessage,
+  getMessages as getStoreMessages,
+  MAX_HISTORY_MESSAGES,
+} from "../src/server/application/chat-store";
+import { getAIAdapter, setAIAdapter } from "../src/server/application/ai-adapter";
+import { createTestRequest, parseJsonResponse } from "./helpers";
+
+describe("realtime chat starter template", () => {
+  const originalAdapter = getAIAdapter();
+
+  beforeEach(() => {
+    __resetChatStoreForTests();
+    setAIAdapter(originalAdapter);
+  });
+
+  it("returns empty history by default", async () => {
+    const request = createTestRequest("http://localhost:3000/api/chat/messages");
+    const response = getMessages(request);
+    expect(response.status).toBe(200);
+
+    const json = await parseJsonResponse<{ messages: unknown[] }>(response);
+    expect(Array.isArray(json.messages)).toBe(true);
+    expect(json.messages.length).toBe(0);
+  });
+
+  it("rejects invalid message payload", async () => {
+    const request = createTestRequest("http://localhost:3000/api/chat/messages", {
+      method: "POST",
+      body: { text: "   " },
+    });
+
+    const response = await postMessage(request);
+    expect(response.status).toBe(400);
+  });
+
+  it("rejects malformed json payload", async () => {
+    const request = new Request("http://localhost:3000/api/chat/messages", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: "{not-valid-json",
+    });
+
+    const response = await postMessage(request);
+    expect(response.status).toBe(400);
+  });
+
+  it("accepts valid payload and appends assistant reply", async () => {
+    const request = createTestRequest("http://localhost:3000/api/chat/messages", {
+      method: "POST",
+      body: { text: "hello" },
+    });
+
+    const response = await postMessage(request);
+    expect(response.status).toBe(201);
+
+    const historyRequest = createTestRequest("http://localhost:3000/api/chat/messages");
+    const history = getMessages(historyRequest);
+    const json = await parseJsonResponse<{ messages: Array<{ role: string }> }>(history);
+
+    expect(json.messages.length).toBe(2);
+    expect(json.messages.at(-1)?.role).toBe("assistant");
+  });
+
+  it("keeps user message when adapter completion fails", async () => {
+    setAIAdapter({
+      async complete() {
+        throw new Error("adapter-failure");
+      },
+    });
+
+    const request = createTestRequest("http://localhost:3000/api/chat/messages", {
+      method: "POST",
+      body: { text: "hello" },
+    });
+
+    const response = await postMessage(request);
+    expect(response.status).toBe(201);
+
+    const messages = getStoreMessages();
+    expect(messages.length).toBe(1);
+    expect(messages[0]?.role).toBe("user");
+  });
+
+  it("caps in-memory history size", () => {
+    for (let i = 0; i < MAX_HISTORY_MESSAGES + 25; i++) {
+      appendMessage("user", `msg-${i}`);
+    }
+
+    const messages = getStoreMessages();
+    expect(messages.length).toBe(MAX_HISTORY_MESSAGES);
+    expect(messages[0]?.text).toBe("msg-25");
+  });
+
+  it("exposes SSE stream endpoint", () => {
+    const request = createTestRequest("http://localhost:3000/api/chat/stream");
+    const response = getStream(request);
+    expect(response.status).toBe(200);
+    expect(response.headers.get("Content-Type")).toContain("text/event-stream");
+  });
+
+  it("SSE stream emits snapshot and live message events", async () => {
+    const abortController = new AbortController();
+    const request = new Request("http://localhost:3000/api/chat/stream", {
+      signal: abortController.signal,
+    });
+
+    const response = getStream(request);
+    const reader = response.body?.getReader();
+    expect(reader).toBeDefined();
+
+    const decoder = new TextDecoder();
+
+    try {
+      const firstChunk = await reader!.read();
+      expect(firstChunk.done).toBe(false);
+      const firstText = decoder.decode(firstChunk.value);
+      expect(firstText).toContain('"type":"snapshot"');
+
+      appendMessage("user", "live-event");
+
+      const secondChunk = await reader!.read();
+      expect(secondChunk.done).toBe(false);
+      const secondText = decoder.decode(secondChunk.value);
+      expect(secondText).toContain('"type":"message"');
+      expect(secondText).toContain('"text":"live-event"');
+    } finally {
+      abortController.abort();
+    }
+  });
+
+  it("includes essential ARIA attributes in chat UI", async () => {
+    const source = await Bun.file(
+      new URL("../src/client/features/chat/realtime-chat-starter.client.tsx", import.meta.url),
+    ).text();
+
+    expect(source).toContain('role="log"');
+    expect(source).toContain('aria-live="polite"');
+    expect(source).toContain('aria-label="Chat messages"');
+    expect(source).toContain('aria-label="Chat message input"');
+    expect(source).toContain('aria-describedby="chat-input-description"');
+    expect(source).toContain('id="chat-input-description"');
+    expect(source).toContain('aria-label="Send message"');
+  });
+});

package/templates/realtime-chat/tests/chat-store.concurrency.test.ts

@@ -0,0 +1,39 @@
+import { beforeEach, describe, expect, it } from "bun:test";
+import {
+  __resetChatStoreForTests,
+  __setSubscribeCommitHookForTests,
+  appendMessage,
+  subscribeWithSnapshot,
+} from "@/server/application/chat-store";
+
+describe("chat-store concurrency", () => {
+  beforeEach(() => {
+    __resetChatStoreForTests();
+    __setSubscribeCommitHookForTests(undefined);
+  });
+
+  it("keeps snapshot/subscription consistent when write happens during subscribe", () => {
+    let hookTriggered = false;
+
+    __setSubscribeCommitHookForTests(() => {
+      if (hookTriggered) return;
+      hookTriggered = true;
+      appendMessage("user", "racing-message");
+    });
+
+    const seen: string[] = [];
+    const subscription = subscribeWithSnapshot((message) => {
+      seen.push(message.text);
+    });
+
+    expect(subscription.snapshot.some((message) => message.text === "racing-message")).toBe(true);
+
+    // listener 활성화
+    const unsubscribe = subscription.commit();
+
+    appendMessage("assistant", "after-subscribe");
+    expect(seen).toContain("after-subscribe");
+
+    unsubscribe();
+  });
+});

package/templates/realtime-chat/tests/example.test.ts

@@ -0,0 +1,58 @@
+// Mandu Example Test
+// 이 파일은 테스트 작성 방법을 보여주는 예제입니다.
+
+import { describe, it, expect } from "bun:test";
+import { createTestRequest, parseJsonResponse, assertStatus } from "./helpers";
+
+describe("Example Tests", () => {
+  describe("Basic Assertions", () => {
+    it("should pass basic equality test", () => {
+      expect(1 + 1).toBe(2);
+    });
+
+    it("should pass object equality test", () => {
+      const obj = { status: "ok", data: { message: "hello" } };
+      expect(obj).toEqual({
+        status: "ok",
+        data: { message: "hello" },
+      });
+    });
+  });
+
+  describe("Test Helpers", () => {
+    it("should create test request", () => {
+      const req = createTestRequest("http://localhost:3000/api/test", {
+        method: "POST",
+        body: { name: "test" },
+      });
+
+      expect(req.method).toBe("POST");
+      expect(req.url).toBe("http://localhost:3000/api/test");
+    });
+
+    it("should parse JSON response", async () => {
+      const mockResponse = new Response(
+        JSON.stringify({ status: "ok" }),
+        { status: 200 }
+      );
+
+      const data = await parseJsonResponse<{ status: string }>(mockResponse);
+      expect(data.status).toBe("ok");
+    });
+  });
+});
+
+// API 핸들러 테스트 예제 (실제 핸들러 import 후 사용)
+// import handler from "../.mandu/generated/server/routes/health.route";
+//
+// describe("API: GET /api/health", () => {
+//   it("should return 200 with status ok", async () => {
+//     const req = createTestRequest("http://localhost:3000/api/health");
+//     const response = handler(req, {});
+//
+//     assertStatus(response, 200);
+//
+//     const data = await parseJsonResponse<{ status: string }>(response);
+//     expect(data.status).toBe("ok");
+//   });
+// });

package/templates/realtime-chat/tests/helpers.ts

@@ -0,0 +1,52 @@
+// Mandu Test Helpers
+// 테스트에서 사용할 유틸리티 함수들
+
+import type { Request } from "bun";
+
+/**
+ * API 핸들러 테스트용 Request 생성
+ */
+export function createTestRequest(
+  url: string,
+  options?: {
+    method?: string;
+    body?: unknown;
+    headers?: Record<string, string>;
+  }
+): Request {
+  const { method = "GET", body, headers = {} } = options || {};
+
+  return new Request(url, {
+    method,
+    headers: {
+      "Content-Type": "application/json",
+      ...headers,
+    },
+    body: body ? JSON.stringify(body) : undefined,
+  });
+}
+
+/**
+ * Response를 JSON으로 파싱
+ */
+export async function parseJsonResponse<T = unknown>(response: Response): Promise<T> {
+  return response.json() as Promise<T>;
+}
+
+/**
+ * Response 상태 검증
+ */
+export function assertStatus(response: Response, expectedStatus: number): void {
+  if (response.status !== expectedStatus) {
+    throw new Error(
+      `Expected status ${expectedStatus}, got ${response.status}`
+    );
+  }
+}
+
+/**
+ * 테스트용 라우트 파라미터 생성
+ */
+export function createParams(params: Record<string, string>): Record<string, string> {
+  return params;
+}

package/templates/realtime-chat/tests/setup.ts

@@ -0,0 +1,9 @@
+// Mandu Test Setup
+// Bun 테스트 환경 설정
+
+// 테스트 타임아웃 설정 (필요 시)
+// import { setDefaultTimeout } from "bun:test";
+// setDefaultTimeout(10000);
+
+// 환경 변수 설정
+process.env.NODE_ENV = "test";

package/templates/realtime-chat/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "jsx": "react-jsx",
+    "types": ["bun-types"],
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  },
+  "include": [
+    "app/**/*.ts",
+    "app/**/*.tsx",
+    "src/**/*.ts",
+    "src/**/*.tsx"
+  ],
+  "exclude": ["node_modules"]
+}