connectbase-client 0.8.0 → 0.9.0

package/dist/index.js

@@ -226,6 +226,22 @@ var HttpClient = class {
     });
     return this.handleResponse(response);
   }
+  /**
+   * Raw fetch 요청 (SSE 스트리밍 등에 사용)
+   * 인증 헤더가 자동으로 추가됩니다.
+   */
+  async fetchRaw(url, init) {
+    const headers = await this.prepareHeaders();
+    const mergedHeaders = new Headers(headers);
+    if (init?.headers) {
+      const extra = new Headers(init.headers);
+      extra.forEach((value, key) => mergedHeaders.set(key, value));
+    }
+    return fetch(`${this.config.baseUrl}${url}`, {
+      ...init,
+      headers: mergedHeaders
+    });
+  }
 };
 
 // src/api/auth.ts
@@ -4375,7 +4391,7 @@ var SubscriptionAPI = class {
    *     order_name: '추가 결제'
    * })
    *
-   * if (result.status === 'DONE') {
+   * if (result.status === 'done') {
    *     console.log('결제 완료!')
    * }
    * ```
@@ -4431,71 +4447,48 @@ var PushAPI = class {
   /**
    * 디바이스 등록 해제
    *
-   * @param deviceId 디바이스 ID
+   * @param deviceToken 디바이스 토큰
    *
    * @example
    * ```typescript
-   * await cb.push.unregisterDevice('device-id-here')
+   * await cb.push.unregisterDevice('fcm-token-here')
    * ```
    */
-  async unregisterDevice(deviceId) {
-    const prefix = this.getPublicPrefix();
-    await this.http.delete(`${prefix}/push/devices/${deviceId}`);
-  }
-  /**
-   * 현재 등록된 디바이스 목록 조회
-   *
-   * @returns 디바이스 목록
-   */
-  async getDevices() {
+  async unregisterDevice(deviceToken) {
     const prefix = this.getPublicPrefix();
-    const response = await this.http.get(`${prefix}/push/devices`);
-    return response.devices || [];
+    await this.http.delete(`${prefix}/push/devices/${deviceToken}`);
   }
   // ============ Topic Subscription ============
   /**
    * 토픽 구독
    *
+   * @param deviceToken 디바이스 토큰
    * @param topicName 토픽 이름
    *
    * @example
    * ```typescript
-   * // 공지사항 토픽 구독
-   * await cb.push.subscribeTopic('announcements')
-   *
-   * // 마케팅 토픽 구독
-   * await cb.push.subscribeTopic('marketing')
+   * await cb.push.subscribeTopic('fcm-token-here', 'announcements')
    * ```
    */
-  async subscribeTopic(topicName) {
+  async subscribeTopic(deviceToken, topicName) {
     const prefix = this.getPublicPrefix();
     const request = { topic_name: topicName };
-    await this.http.post(`${prefix}/push/topics/subscribe`, request);
+    await this.http.post(`${prefix}/push/devices/${deviceToken}/topics/subscribe`, request);
   }
   /**
    * 토픽 구독 해제
    *
+   * @param deviceToken 디바이스 토큰
    * @param topicName 토픽 이름
    *
    * @example
    * ```typescript
-   * await cb.push.unsubscribeTopic('marketing')
+   * await cb.push.unsubscribeTopic('fcm-token-here', 'marketing')
    * ```
    */
-  async unsubscribeTopic(topicName) {
+  async unsubscribeTopic(deviceToken, topicName) {
     const prefix = this.getPublicPrefix();
-    const request = { topic_name: topicName };
-    await this.http.post(`${prefix}/push/topics/unsubscribe`, request);
-  }
-  /**
-   * 구독 중인 토픽 목록 조회
-   *
-   * @returns 구독 중인 토픽 이름 목록
-   */
-  async getSubscribedTopics() {
-    const prefix = this.getPublicPrefix();
-    const response = await this.http.get(`${prefix}/push/topics/subscribed`);
-    return response.topics || [];
+    await this.http.delete(`${prefix}/push/devices/${deviceToken}/topics/${topicName}/unsubscribe`);
   }
   // ============ Web Push ============
   /**
@@ -4520,7 +4513,7 @@ var PushAPI = class {
    */
   async getVAPIDPublicKey() {
     const prefix = this.getPublicPrefix();
-    return this.http.get(`${prefix}/push/vapid-key`);
+    return this.http.get(`${prefix}/push/vapid-public-key`);
   }
   /**
    * Web Push 구독 등록
@@ -4562,17 +4555,19 @@ var PushAPI = class {
       device_name: this.getBrowserName(),
       os_version: this.getOSInfo()
     };
-    return this.http.post(`${prefix}/push/devices/web`, {
+    return this.http.post(`${prefix}/push/devices`, {
       ...request,
       web_push_subscription: webPushData
     });
   }
   /**
    * Web Push 구독 해제
+   *
+   * @param deviceToken Web Push endpoint URL (등록 시 사용한 endpoint)
    */
-  async unregisterWebPush() {
+  async unregisterWebPush(deviceToken) {
     const prefix = this.getPublicPrefix();
-    await this.http.delete(`${prefix}/push/devices/web`);
+    await this.http.delete(`${prefix}/push/devices/${encodeURIComponent(deviceToken)}`);
   }
   // ============ Helper Methods ============
   /**
@@ -4646,6 +4641,146 @@ var VideoProcessingError = class extends Error {
 var VideoAPI = class {
   constructor(http, videoBaseUrl) {
     this.http = http;
+    // ========== Storage Operations ==========
+    // Storage methods use core-server proxy (main API URL), not video-server directly
+    /**
+     * Storage sub-namespace for video storage container operations
+     */
+    this.storage = {
+      /**
+       * Create a video storage container
+       */
+      create: async (data) => {
+        return this.http.post("/v1/public/storages/videos", data);
+      },
+      /**
+       * List video storage containers
+       */
+      list: async () => {
+        return this.http.get("/v1/public/storages/videos");
+      },
+      /**
+       * Get a video storage container
+       */
+      get: async (storageId) => {
+        return this.http.get(`/v1/public/storages/videos/${storageId}`);
+      },
+      /**
+       * Update a video storage container
+       */
+      update: async (storageId, data) => {
+        return this.http.put(`/v1/public/storages/videos/${storageId}`, data);
+      },
+      /**
+       * Delete a video storage container
+       */
+      delete: async (storageId) => {
+        await this.http.delete(`/v1/public/storages/videos/${storageId}`);
+      },
+      /**
+       * Upload a video to a specific storage via core-server proxy (chunked)
+       */
+      upload: async (storageId, file, options) => {
+        const session = await this.http.post(
+          `/v1/public/storages/videos/${storageId}/uploads/init`,
+          {
+            filename: file.name,
+            size: file.size,
+            mime_type: file.type,
+            title: options.title,
+            description: options.description,
+            visibility: options.visibility || "private",
+            tags: options.tags
+          }
+        );
+        const chunkSize = session.chunk_size || DEFAULT_CHUNK_SIZE;
+        const totalChunks = Math.ceil(file.size / chunkSize);
+        let uploadedChunks = 0;
+        let lastProgressTime = Date.now();
+        let lastUploadedBytes = 0;
+        for (let i = 0; i < totalChunks; i++) {
+          const start = i * chunkSize;
+          const end = Math.min(start + chunkSize, file.size);
+          const chunk = file.slice(start, end);
+          const formData = new FormData();
+          formData.append("chunk", chunk);
+          formData.append("chunk_index", String(i));
+          await this.http.post(
+            `/v1/public/storages/videos/${storageId}/uploads/${session.session_id}/chunk`,
+            formData
+          );
+          uploadedChunks++;
+          const now = Date.now();
+          const timeDiff = (now - lastProgressTime) / 1e3;
+          const uploadedBytes = end;
+          const bytesDiff = uploadedBytes - lastUploadedBytes;
+          const currentSpeed = timeDiff > 0 ? bytesDiff / timeDiff : 0;
+          lastProgressTime = now;
+          lastUploadedBytes = uploadedBytes;
+          if (options.onProgress) {
+            options.onProgress({
+              phase: "uploading",
+              uploadedChunks,
+              totalChunks,
+              percentage: Math.round(uploadedChunks / totalChunks * 100),
+              currentSpeed
+            });
+          }
+        }
+        const result = await this.http.post(
+          `/v1/public/storages/videos/${storageId}/uploads/${session.session_id}/complete`,
+          {}
+        );
+        return result.video;
+      },
+      /**
+       * List videos in a specific storage
+       */
+      listVideos: async (storageId, options) => {
+        const params = new URLSearchParams();
+        if (options?.status) params.set("status", options.status);
+        if (options?.visibility) params.set("visibility", options.visibility);
+        if (options?.search) params.set("search", options.search);
+        if (options?.page) params.set("page", String(options.page));
+        if (options?.limit) params.set("limit", String(options.limit));
+        const query = params.toString();
+        return this.http.get(
+          `/v1/public/storages/videos/${storageId}/videos${query ? `?${query}` : ""}`
+        );
+      },
+      /**
+       * Get a video in a specific storage
+       */
+      getVideo: async (storageId, videoId) => {
+        return this.http.get(
+          `/v1/public/storages/videos/${storageId}/videos/${videoId}`
+        );
+      },
+      /**
+       * Delete a video from a specific storage
+       */
+      deleteVideo: async (storageId, videoId) => {
+        await this.http.delete(
+          `/v1/public/storages/videos/${storageId}/videos/${videoId}`
+        );
+      },
+      /**
+       * Get streaming URL for a video in a specific storage
+       */
+      getStreamUrl: async (storageId, videoId) => {
+        return this.http.get(
+          `/v1/public/storages/videos/${storageId}/videos/${videoId}/stream`
+        );
+      },
+      /**
+       * Get transcode status for a video in a specific storage
+       */
+      getTranscodeStatus: async (storageId, videoId) => {
+        return this.http.get(
+          `/v1/public/storages/videos/${storageId}/videos/${videoId}/transcode`
+        );
+      }
+    };
     this.videoBaseUrl = videoBaseUrl || this.getDefaultVideoUrl();
   }
   getDefaultVideoUrl() {
@@ -6123,6 +6258,183 @@ var GameAPI = class {
       expiresAt: inv.expires_at
     }));
   }
+  // --- Party API ---
+  async createParty(playerId, maxSize) {
+    const id = this.appId || "";
+    const response = await fetch(`${this.gameServerUrl}/v1/game/${id}/parties`, {
+      method: "POST",
+      headers: { ...this.getHeaders(), "Content-Type": "application/json" },
+      body: JSON.stringify({ player_id: playerId, max_size: maxSize || 4 })
+    });
+    if (!response.ok) throw new Error(`Failed to create party: ${response.statusText}`);
+    return response.json();
+  }
+  async joinParty(partyId, playerId) {
+    const id = this.appId || "";
+    const response = await fetch(`${this.gameServerUrl}/v1/game/${id}/parties/${partyId}/join`, {
+      method: "POST",
+      headers: { ...this.getHeaders(), "Content-Type": "application/json" },
+      body: JSON.stringify({ player_id: playerId })
+    });
+    if (!response.ok) throw new Error(`Failed to join party: ${response.statusText}`);
+    return response.json();
+  }
+  async leaveParty(partyId, playerId) {
+    const id = this.appId || "";
+    const response = await fetch(`${this.gameServerUrl}/v1/game/${id}/parties/${partyId}/leave`, {
+      method: "POST",
+      headers: { ...this.getHeaders(), "Content-Type": "application/json" },
+      body: JSON.stringify({ player_id: playerId })
+    });
+    if (!response.ok) throw new Error(`Failed to leave party: ${response.statusText}`);
+  }
+  async kickFromParty(partyId, playerId) {
+    const id = this.appId || "";
+    const response = await fetch(`${this.gameServerUrl}/v1/game/${id}/parties/${partyId}/kick/${playerId}`, {
+      method: "POST",
+      headers: this.getHeaders()
+    });
+    if (!response.ok) throw new Error(`Failed to kick from party: ${response.statusText}`);
+  }
+  async inviteToParty(partyId, inviterId, inviteeId) {
+    const id = this.appId || "";
+    const response = await fetch(`${this.gameServerUrl}/v1/game/${id}/parties/${partyId}/invite/${inviteeId}`, {
+      method: "POST",
+      headers: { ...this.getHeaders(), "Content-Type": "application/json" },
+      body: JSON.stringify({ inviter_id: inviterId })
+    });
+    if (!response.ok) throw new Error(`Failed to invite to party: ${response.statusText}`);
+    return response.json();
+  }
+  async sendPartyChat(partyId, playerId, message) {
+    const id = this.appId || "";
+    const response = await fetch(`${this.gameServerUrl}/v1/game/${id}/parties/${partyId}/chat`, {
+      method: "POST",
+      headers: { ...this.getHeaders(), "Content-Type": "application/json" },
+      body: JSON.stringify({ player_id: playerId, message })
+    });
+    if (!response.ok) throw new Error(`Failed to send party chat: ${response.statusText}`);
+  }
+  // --- Spectator API ---
+  async joinSpectator(roomId, playerId) {
+    const id = this.appId || "";
+    const response = await fetch(`${this.gameServerUrl}/v1/game/${id}/rooms/${roomId}/spectate`, {
+      method: "POST",
+      headers: { ...this.getHeaders(), "Content-Type": "application/json" },
+      body: JSON.stringify({ player_id: playerId })
+    });
+    if (!response.ok) throw new Error(`Failed to join spectator: ${response.statusText}`);
+    return response.json();
+  }
+  async leaveSpectator(roomId, spectatorId) {
+    const id = this.appId || "";
+    const response = await fetch(`${this.gameServerUrl}/v1/game/${id}/rooms/${roomId}/spectate/stop`, {
+      method: "POST",
+      headers: { ...this.getHeaders(), "Content-Type": "application/json" },
+      body: JSON.stringify({ spectator_id: spectatorId })
+    });
+    if (!response.ok) throw new Error(`Failed to leave spectator: ${response.statusText}`);
+  }
+  async getSpectators(roomId) {
+    const id = this.appId || "";
+    const response = await fetch(`${this.gameServerUrl}/v1/game/${id}/rooms/${roomId}/spectators`, {
+      headers: this.getHeaders()
+    });
+    if (!response.ok) throw new Error(`Failed to get spectators: ${response.statusText}`);
+    const data = await response.json();
+    return data.spectators || [];
+  }
+  // --- Ranking/Leaderboard API ---
+  async getLeaderboard(top) {
+    const id = this.appId || "";
+    const limit = top || 100;
+    const response = await fetch(`${this.gameServerUrl}/v1/game/${id}/ranking/leaderboard/top?limit=${limit}`, {
+      headers: this.getHeaders()
+    });
+    if (!response.ok) throw new Error(`Failed to get leaderboard: ${response.statusText}`);
+    const data = await response.json();
+    return data.entries || [];
+  }
+  async getPlayerStats(playerId) {
+    const id = this.appId || "";
+    const response = await fetch(`${this.gameServerUrl}/v1/game/${id}/ranking/players/${playerId}/stats`, {
+      headers: this.getHeaders()
+    });
+    if (!response.ok) throw new Error(`Failed to get player stats: ${response.statusText}`);
+    return response.json();
+  }
+  async getPlayerRank(playerId) {
+    const id = this.appId || "";
+    const response = await fetch(`${this.gameServerUrl}/v1/game/${id}/ranking/players/${playerId}/rank`, {
+      headers: this.getHeaders()
+    });
+    if (!response.ok) throw new Error(`Failed to get player rank: ${response.statusText}`);
+    return response.json();
+  }
+  // --- Voice API ---
+  async joinVoiceChannel(roomId, playerId) {
+    const id = this.appId || "";
+    const response = await fetch(`${this.gameServerUrl}/v1/game/${id}/voice/rooms/${roomId}/join`, {
+      method: "POST",
+      headers: { ...this.getHeaders(), "Content-Type": "application/json" },
+      body: JSON.stringify({ player_id: playerId })
+    });
+    if (!response.ok) throw new Error(`Failed to join voice channel: ${response.statusText}`);
+    return response.json();
+  }
+  async leaveVoiceChannel(roomId, playerId) {
+    const id = this.appId || "";
+    const response = await fetch(`${this.gameServerUrl}/v1/game/${id}/voice/rooms/${roomId}/leave`, {
+      method: "POST",
+      headers: { ...this.getHeaders(), "Content-Type": "application/json" },
+      body: JSON.stringify({ player_id: playerId })
+    });
+    if (!response.ok) throw new Error(`Failed to leave voice channel: ${response.statusText}`);
+  }
+  async setMute(playerId, muted) {
+    const id = this.appId || "";
+    const response = await fetch(`${this.gameServerUrl}/v1/game/${id}/voice/mute`, {
+      method: "POST",
+      headers: { ...this.getHeaders(), "Content-Type": "application/json" },
+      body: JSON.stringify({ player_id: playerId, muted })
+    });
+    if (!response.ok) throw new Error(`Failed to set mute: ${response.statusText}`);
+  }
+  // --- Replay API ---
+  async listReplays(roomId) {
+    const id = this.appId || "";
+    let url = `${this.gameServerUrl}/v1/game/${id}/replays`;
+    if (roomId) url += `?room_id=${roomId}`;
+    const response = await fetch(url, { headers: this.getHeaders() });
+    if (!response.ok) throw new Error(`Failed to list replays: ${response.statusText}`);
+    const data = await response.json();
+    return data.replays || [];
+  }
+  async getReplay(replayId) {
+    const id = this.appId || "";
+    const response = await fetch(`${this.gameServerUrl}/v1/game/${id}/replays/${replayId}`, {
+      headers: this.getHeaders()
+    });
+    if (!response.ok) throw new Error(`Failed to get replay: ${response.statusText}`);
+    return response.json();
+  }
+  async downloadReplay(replayId) {
+    const id = this.appId || "";
+    const response = await fetch(`${this.gameServerUrl}/v1/game/${id}/replays/${replayId}/download`, {
+      headers: this.getHeaders()
+    });
+    if (!response.ok) throw new Error(`Failed to download replay: ${response.statusText}`);
+    return response.arrayBuffer();
+  }
+  async getReplayHighlights(replayId) {
+    const id = this.appId || "";
+    const response = await fetch(`${this.gameServerUrl}/v1/game/${id}/replays/${replayId}/highlights`, {
+      headers: this.getHeaders()
+    });
+    if (!response.ok) throw new Error(`Failed to get highlights: ${response.statusText}`);
+    const data = await response.json();
+    return data.highlights || [];
+  }
   getHeaders() {
     const headers = {};
     const apiKey = this.http.getApiKey();
@@ -6813,6 +7125,106 @@ var KnowledgeAPI = class {
       `/v1/public/knowledge-bases/${kbID}/search?${params.toString()}`
     );
   }
+  // ========== Chat (RAG) ==========
+  /**
+   * RAG 챗 (동기)
+   *
+   * 지식 베이스의 문서를 검색하고 AI가 답변을 생성합니다.
+   *
+   * @param kbID - 지식 베이스 ID
+   * @param request - 챗 요청
+   * @returns AI 답변 + 참조 소스
+   *
+   * @example
+   * ```typescript
+   * const response = await cb.knowledge.chat('kb-id', {
+   *     message: '환불 정책이 어떻게 되나요?',
+   *     top_k: 5
+   * })
+   * console.log(response.answer)
+   * console.log('참조:', response.sources)
+   * ```
+   */
+  async chat(kbID, request) {
+    return this.http.post(
+      `/v1/public/knowledge-bases/${kbID}/chat`,
+      request
+    );
+  }
+  /**
+   * RAG 챗 스트리밍 (SSE)
+   *
+   * AI 답변을 실시간으로 토큰 단위로 수신합니다.
+   *
+   * @param kbID - 지식 베이스 ID
+   * @param request - 챗 요청
+   * @param callbacks - 스트리밍 콜백
+   *
+   * @example
+   * ```typescript
+   * await cb.knowledge.chatStream('kb-id', {
+   *     message: '환불 정책이 어떻게 되나요?'
+   * }, {
+   *     onSources: (sources, model) => console.log('참조:', sources),
+   *     onToken: (content) => process.stdout.write(content),
+   *     onDone: (usage) => console.log('\\n완료:', usage),
+   *     onError: (error) => console.error('에러:', error)
+   * })
+   * ```
+   */
+  async chatStream(kbID, request, callbacks) {
+    const response = await this.http.fetchRaw(
+      `/v1/public/knowledge-bases/${kbID}/chat/stream`,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(request)
+      }
+    );
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({ error: "Stream request failed" }));
+      callbacks.onError?.(errorData.error || "Stream request failed");
+      return;
+    }
+    const reader = response.body?.getReader();
+    if (!reader) {
+      callbacks.onError?.("ReadableStream not supported");
+      return;
+    }
+    const decoder = new TextDecoder();
+    let buffer = "";
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        if (!line.startsWith("data: ")) continue;
+        const data = line.slice(6).trim();
+        if (data === "[DONE]") {
+          callbacks.onDone?.();
+          return;
+        }
+        try {
+          const event = JSON.parse(data);
+          switch (event.type) {
+            case "sources":
+              callbacks.onSources?.(event.sources, event.model);
+              break;
+            case "token":
+              if (event.content) callbacks.onToken?.(event.content);
+              if (event.done) callbacks.onDone?.(event.usage);
+              break;
+            case "error":
+              callbacks.onError?.(event.error || "Unknown error");
+              return;
+          }
+        } catch {
+        }
+      }
+    }
+  }
 };
 
 // src/api/queue.ts