@ekodb/ekodb-client 0.1.0 → 0.1.7

package/src/client.ts

@@ -2,9 +2,9 @@
  * ekoDB TypeScript Client
  */
 
-import { QueryBuilder, Query as QueryBuilderQuery } from './query-builder';
-import { SearchQuery, SearchQueryBuilder, SearchResponse } from './search';
-import { Schema, SchemaBuilder, CollectionMetadata } from './schema';
+import { QueryBuilder, Query as QueryBuilderQuery } from "./query-builder";
+import { SearchQuery, SearchQueryBuilder, SearchResponse } from "./search";
+import { Schema, SchemaBuilder, CollectionMetadata } from "./schema";
 
 export interface Record {
   [key: string]: any;
@@ -42,9 +42,14 @@ export interface ClientConfig {
  * Rate limit error
  */
 export class RateLimitError extends Error {
-  constructor(public retryAfterSecs: number, message?: string) {
-    super(message || `Rate limit exceeded. Retry after ${retryAfterSecs} seconds`);
-    this.name = 'RateLimitError';
+  constructor(
+    public retryAfterSecs: number,
+    message?: string,
+  ) {
+    super(
+      message || `Rate limit exceeded. Retry after ${retryAfterSecs} seconds`,
+    );
+    this.name = "RateLimitError";
   }
 }
 
@@ -161,9 +166,9 @@ export interface UpdateSessionRequest {
 }
 
 export enum MergeStrategy {
-  Chronological = 'Chronological',
-  Summarized = 'Summarized',
-  LatestOnly = 'LatestOnly',
+  Chronological = "Chronological",
+  Summarized = "Summarized",
+  LatestOnly = "LatestOnly",
 }
 
 export interface MergeSessionsRequest {
@@ -183,7 +188,7 @@ export class EkoDBClient {
 
   constructor(config: string | ClientConfig, apiKey?: string) {
     // Support both old (baseURL, apiKey) and new (config object) signatures
-    if (typeof config === 'string') {
+    if (typeof config === "string") {
       this.baseURL = config;
       this.apiKey = apiKey!;
       this.shouldRetry = true;
@@ -226,8 +231,8 @@ export class EkoDBClient {
    */
   private async refreshToken(): Promise<void> {
     const response = await fetch(`${this.baseURL}/api/auth/token`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
       body: JSON.stringify({ api_key: this.apiKey }),
     });
 
@@ -235,7 +240,7 @@ export class EkoDBClient {
       throw new Error(`Auth failed with status: ${response.status}`);
     }
 
-    const result = await response.json() as { token: string };
+    const result = (await response.json()) as { token: string };
     this.token = result.token;
   }
 
@@ -243,9 +248,9 @@ export class EkoDBClient {
    * Extract rate limit information from response headers
    */
   private extractRateLimitInfo(response: Response): void {
-    const limit = response.headers.get('x-ratelimit-limit');
-    const remaining = response.headers.get('x-ratelimit-remaining');
-    const reset = response.headers.get('x-ratelimit-reset');
+    const limit = response.headers.get("x-ratelimit-limit");
+    const remaining = response.headers.get("x-ratelimit-remaining");
+    const reset = response.headers.get("x-ratelimit-reset");
 
     if (limit && remaining && reset) {
       this.rateLimitInfo = {
@@ -257,7 +262,7 @@ export class EkoDBClient {
       // Log warning if approaching rate limit
       if (this.isNearRateLimit()) {
         console.warn(
-          `Approaching rate limit: ${this.rateLimitInfo.remaining}/${this.rateLimitInfo.limit} remaining`
+          `Approaching rate limit: ${this.rateLimitInfo.remaining}/${this.rateLimitInfo.limit} remaining`,
         );
       }
     }
@@ -267,7 +272,7 @@ export class EkoDBClient {
    * Sleep for a specified number of seconds
    */
   private sleep(seconds: number): Promise<void> {
-    return new Promise(resolve => setTimeout(resolve, seconds * 1000));
+    return new Promise((resolve) => setTimeout(resolve, seconds * 1000));
   }
 
   /**
@@ -277,7 +282,7 @@ export class EkoDBClient {
     method: string,
     path: string,
     data?: any,
-    attempt: number = 0
+    attempt: number = 0,
   ): Promise<T> {
     if (!this.token) {
       await this.refreshToken();
@@ -286,8 +291,8 @@ export class EkoDBClient {
     const options: RequestInit = {
       method,
       headers: {
-        'Authorization': `Bearer ${this.token}`,
-        'Content-Type': 'application/json',
+        Authorization: `Bearer ${this.token}`,
+        "Content-Type": "application/json",
       },
     };
 
@@ -306,21 +311,30 @@ export class EkoDBClient {
 
       // Handle rate limiting (429)
       if (response.status === 429) {
-        const retryAfter = parseInt(response.headers.get('retry-after') || '60', 10);
-        
+        const retryAfter = parseInt(
+          response.headers.get("retry-after") || "60",
+          10,
+        );
+
         if (this.shouldRetry && attempt < this.maxRetries) {
           console.log(`Rate limited. Retrying after ${retryAfter} seconds...`);
           await this.sleep(retryAfter);
           return this.makeRequest<T>(method, path, data, attempt + 1);
         }
-        
+
         throw new RateLimitError(retryAfter);
       }
 
       // Handle service unavailable (503)
-      if (response.status === 503 && this.shouldRetry && attempt < this.maxRetries) {
+      if (
+        response.status === 503 &&
+        this.shouldRetry &&
+        attempt < this.maxRetries
+      ) {
         const retryDelay = 10;
-        console.log(`Service unavailable. Retrying after ${retryDelay} seconds...`);
+        console.log(
+          `Service unavailable. Retrying after ${retryDelay} seconds...`,
+        );
         await this.sleep(retryDelay);
         return this.makeRequest<T>(method, path, data, attempt + 1);
       }
@@ -330,13 +344,17 @@ export class EkoDBClient {
       throw new Error(`Request failed with status ${response.status}: ${text}`);
     } catch (error) {
       // Handle network errors with retry
-      if (error instanceof TypeError && this.shouldRetry && attempt < this.maxRetries) {
+      if (
+        error instanceof TypeError &&
+        this.shouldRetry &&
+        attempt < this.maxRetries
+      ) {
         const retryDelay = 3;
         console.log(`Network error. Retrying after ${retryDelay} seconds...`);
         await this.sleep(retryDelay);
         return this.makeRequest<T>(method, path, data, attempt + 1);
       }
-      
+
       throw error;
     }
   }
@@ -344,73 +362,92 @@ export class EkoDBClient {
   /**
    * Insert a document into a collection
    */
-  async insert(collection: string, record: Record, ttl?: string): Promise<Record> {
+  async insert(
+    collection: string,
+    record: Record,
+    ttl?: string,
+  ): Promise<Record> {
     const data = { ...record };
     if (ttl) {
       data.ttl_duration = ttl;
     }
-    return this.makeRequest<Record>('POST', `/api/insert/${collection}`, data);
+    return this.makeRequest<Record>("POST", `/api/insert/${collection}`, data);
   }
 
   /**
    * Find documents in a collection
-   * 
+   *
    * @param collection - Collection name
    * @param query - Query object or QueryBuilder instance
    * @returns Array of matching records
-   * 
+   *
    * @example
    * ```typescript
    * // Using QueryBuilder
-   * const results = await client.find("users", 
+   * const results = await client.find("users",
    *   new QueryBuilder()
    *     .eq("status", "active")
    *     .gt("age", 18)
    *     .sortDesc("created_at")
    *     .limit(10)
    * );
-   * 
+   *
    * // Using plain Query object
    * const results = await client.find("users", { limit: 10 });
    * ```
    */
-  async find(collection: string, query: Query | QueryBuilder = {}): Promise<Record[]> {
+  async find(
+    collection: string,
+    query: Query | QueryBuilder = {},
+  ): Promise<Record[]> {
     const queryObj = query instanceof QueryBuilder ? query.build() : query;
-    return this.makeRequest<Record[]>('POST', `/api/find/${collection}`, queryObj);
+    return this.makeRequest<Record[]>(
+      "POST",
+      `/api/find/${collection}`,
+      queryObj,
+    );
   }
 
   /**
    * Find a document by ID
    */
   async findByID(collection: string, id: string): Promise<Record> {
-    return this.makeRequest<Record>('GET', `/api/find/${collection}/${id}`);
+    return this.makeRequest<Record>("GET", `/api/find/${collection}/${id}`);
   }
 
   /**
    * Update a document
    */
-  async update(collection: string, id: string, record: Record): Promise<Record> {
-    return this.makeRequest<Record>('PUT', `/api/update/${collection}/${id}`, record);
+  async update(
+    collection: string,
+    id: string,
+    record: Record,
+  ): Promise<Record> {
+    return this.makeRequest<Record>(
+      "PUT",
+      `/api/update/${collection}/${id}`,
+      record,
+    );
   }
 
   /**
    * Delete a document
    */
   async delete(collection: string, id: string): Promise<void> {
-    await this.makeRequest<void>('DELETE', `/api/delete/${collection}/${id}`);
+    await this.makeRequest<void>("DELETE", `/api/delete/${collection}/${id}`);
   }
 
   /**
    * Batch insert multiple documents
    */
   async batchInsert(collection: string, records: Record[]): Promise<Record[]> {
-    const inserts = records.map(data => ({ data }));
+    const inserts = records.map((data) => ({ data }));
     const result = await this.makeRequest<BatchOperationResult>(
-      'POST',
+      "POST",
       `/api/batch/insert/${collection}`,
-      { inserts }
+      { inserts },
     );
-    return result.successful.map(id => ({ id }));
+    return result.successful.map((id) => ({ id }));
   }
 
   /**
@@ -418,25 +455,25 @@ export class EkoDBClient {
    */
   async batchUpdate(
     collection: string,
-    updates: Array<{ id: string; data: Record }>
+    updates: Array<{ id: string; data: Record }>,
   ): Promise<Record[]> {
     const result = await this.makeRequest<BatchOperationResult>(
-      'PUT',
+      "PUT",
       `/api/batch/update/${collection}`,
-      { updates }
+      { updates },
     );
-    return result.successful.map(id => ({ id }));
+    return result.successful.map((id) => ({ id }));
   }
 
   /**
    * Batch delete multiple documents
    */
   async batchDelete(collection: string, ids: string[]): Promise<number> {
-    const deletes = ids.map(id => ({ id }));
+    const deletes = ids.map((id) => ({ id }));
     const result = await this.makeRequest<BatchOperationResult>(
-      'DELETE',
+      "DELETE",
       `/api/batch/delete/${collection}`,
-      { deletes }
+      { deletes },
     );
     return result.successful.length;
   }
@@ -445,7 +482,11 @@ export class EkoDBClient {
    * Set a key-value pair
    */
   async kvSet(key: string, value: any): Promise<void> {
-    await this.makeRequest<void>('POST', `/api/kv/set/${encodeURIComponent(key)}`, { value });
+    await this.makeRequest<void>(
+      "POST",
+      `/api/kv/set/${encodeURIComponent(key)}`,
+      { value },
+    );
   }
 
   /**
@@ -453,8 +494,8 @@ export class EkoDBClient {
    */
   async kvGet(key: string): Promise<any> {
     const result = await this.makeRequest<{ value: any }>(
-      'GET',
-      `/api/kv/get/${encodeURIComponent(key)}`
+      "GET",
+      `/api/kv/get/${encodeURIComponent(key)}`,
     );
     return result.value;
   }
@@ -463,14 +504,20 @@ export class EkoDBClient {
    * Delete a key
    */
   async kvDelete(key: string): Promise<void> {
-    await this.makeRequest<void>('DELETE', `/api/kv/delete/${encodeURIComponent(key)}`);
+    await this.makeRequest<void>(
+      "DELETE",
+      `/api/kv/delete/${encodeURIComponent(key)}`,
+    );
   }
 
   /**
    * List all collections
    */
   async listCollections(): Promise<string[]> {
-    const result = await this.makeRequest<{ collections: string[] }>('GET', '/api/collections');
+    const result = await this.makeRequest<{ collections: string[] }>(
+      "GET",
+      "/api/collections",
+    );
     return result.collections;
   }
 
@@ -478,43 +525,53 @@ export class EkoDBClient {
    * Delete a collection
    */
   async deleteCollection(collection: string): Promise<void> {
-    await this.makeRequest<void>('DELETE', `/api/collections/${collection}`);
+    await this.makeRequest<void>("DELETE", `/api/collections/${collection}`);
   }
 
   /**
    * Create a collection with schema
-   * 
+   *
    * @param collection - Collection name
    * @param schema - Schema definition or SchemaBuilder instance
-   * 
+   *
    * @example
    * ```typescript
    * const schema = new SchemaBuilder()
    *   .addField("name", new FieldTypeSchemaBuilder("string").required())
    *   .addField("email", new FieldTypeSchemaBuilder("string").unique())
    *   .addField("age", new FieldTypeSchemaBuilder("number").range(0, 150));
-   * 
+   *
    * await client.createCollection("users", schema);
    * ```
    */
-  async createCollection(collection: string, schema: Schema | SchemaBuilder): Promise<void> {
+  async createCollection(
+    collection: string,
+    schema: Schema | SchemaBuilder,
+  ): Promise<void> {
     const schemaObj = schema instanceof SchemaBuilder ? schema.build() : schema;
-    await this.makeRequest<void>('POST', `/api/collections/${collection}`, schemaObj);
+    await this.makeRequest<void>(
+      "POST",
+      `/api/collections/${collection}`,
+      schemaObj,
+    );
   }
 
   /**
    * Get collection metadata and schema
-   * 
+   *
    * @param collection - Collection name
    * @returns Collection metadata including schema and analytics
    */
   async getCollection(collection: string): Promise<CollectionMetadata> {
-    return this.makeRequest<CollectionMetadata>('GET', `/api/collections/${collection}`);
+    return this.makeRequest<CollectionMetadata>(
+      "GET",
+      `/api/collections/${collection}`,
+    );
   }
 
   /**
    * Get collection schema
-   * 
+   *
    * @param collection - Collection name
    * @returns The collection schema
    */
@@ -525,11 +582,11 @@ export class EkoDBClient {
 
   /**
    * Search documents in a collection using full-text, vector, or hybrid search
-   * 
+   *
    * @param collection - Collection name
    * @param searchQuery - Search query object or SearchQueryBuilder instance
    * @returns Search response with results and metadata
-   * 
+   *
    * @example
    * ```typescript
    * // Full-text search
@@ -539,14 +596,14 @@ export class EkoDBClient {
    *     .fuzzy(true)
    *     .limit(10)
    * );
-   * 
+   *
    * // Vector search
    * const results = await client.search("documents",
    *   new SearchQueryBuilder("")
    *     .vector([0.1, 0.2, 0.3, ...])
    *     .vectorK(5)
    * );
-   * 
+   *
    * // Hybrid search
    * const results = await client.search("products",
    *   new SearchQueryBuilder("laptop")
@@ -556,9 +613,19 @@ export class EkoDBClient {
    * );
    * ```
    */
-  async search(collection: string, searchQuery: SearchQuery | SearchQueryBuilder): Promise<SearchResponse> {
-    const queryObj = searchQuery instanceof SearchQueryBuilder ? searchQuery.build() : searchQuery;
-    return this.makeRequest<SearchResponse>('POST', `/api/search/${collection}`, queryObj);
+  async search(
+    collection: string,
+    searchQuery: SearchQuery | SearchQueryBuilder,
+  ): Promise<SearchResponse> {
+    const queryObj =
+      searchQuery instanceof SearchQueryBuilder
+        ? searchQuery.build()
+        : searchQuery;
+    return this.makeRequest<SearchResponse>(
+      "POST",
+      `/api/search/${collection}`,
+      queryObj,
+    );
   }
 
   // ========== Chat Methods ==========
@@ -566,106 +633,165 @@ export class EkoDBClient {
   /**
    * Create a new chat session
    */
-  async createChatSession(request: CreateChatSessionRequest): Promise<ChatResponse> {
-    return this.makeRequest<ChatResponse>('POST', '/api/chat', request);
+  async createChatSession(
+    request: CreateChatSessionRequest,
+  ): Promise<ChatResponse> {
+    return this.makeRequest<ChatResponse>("POST", "/api/chat", request);
   }
 
   /**
    * Send a message in an existing chat session
    */
-  async chatMessage(sessionId: string, request: ChatMessageRequest): Promise<ChatResponse> {
-    return this.makeRequest<ChatResponse>('POST', `/api/chat/${sessionId}/messages`, request);
+  async chatMessage(
+    sessionId: string,
+    request: ChatMessageRequest,
+  ): Promise<ChatResponse> {
+    return this.makeRequest<ChatResponse>(
+      "POST",
+      `/api/chat/${sessionId}/messages`,
+      request,
+    );
   }
 
   /**
    * Get a chat session by ID
    */
   async getChatSession(sessionId: string): Promise<ChatSessionResponse> {
-    return this.makeRequest<ChatSessionResponse>('GET', `/api/chat/${sessionId}`);
+    return this.makeRequest<ChatSessionResponse>(
+      "GET",
+      `/api/chat/${sessionId}`,
+    );
   }
 
   /**
    * List all chat sessions
    */
-  async listChatSessions(query?: ListSessionsQuery): Promise<ListSessionsResponse> {
+  async listChatSessions(
+    query?: ListSessionsQuery,
+  ): Promise<ListSessionsResponse> {
     const params = new URLSearchParams();
-    if (query?.limit) params.append('limit', query.limit.toString());
-    if (query?.skip) params.append('skip', query.skip.toString());
-    if (query?.sort) params.append('sort', query.sort);
-    
+    if (query?.limit) params.append("limit", query.limit.toString());
+    if (query?.skip) params.append("skip", query.skip.toString());
+    if (query?.sort) params.append("sort", query.sort);
+
     const queryString = params.toString();
-    const path = queryString ? `/api/chat?${queryString}` : '/api/chat';
-    return this.makeRequest<ListSessionsResponse>('GET', path);
+    const path = queryString ? `/api/chat?${queryString}` : "/api/chat";
+    return this.makeRequest<ListSessionsResponse>("GET", path);
   }
 
   /**
    * Get messages from a chat session
    */
-  async getChatSessionMessages(sessionId: string, query?: GetMessagesQuery): Promise<GetMessagesResponse> {
+  async getChatSessionMessages(
+    sessionId: string,
+    query?: GetMessagesQuery,
+  ): Promise<GetMessagesResponse> {
     const params = new URLSearchParams();
-    if (query?.limit) params.append('limit', query.limit.toString());
-    if (query?.skip) params.append('skip', query.skip.toString());
-    if (query?.sort) params.append('sort', query.sort);
-    
+    if (query?.limit) params.append("limit", query.limit.toString());
+    if (query?.skip) params.append("skip", query.skip.toString());
+    if (query?.sort) params.append("sort", query.sort);
+
     const queryString = params.toString();
-    const path = queryString ? `/api/chat/${sessionId}/messages?${queryString}` : `/api/chat/${sessionId}/messages`;
-    return this.makeRequest<GetMessagesResponse>('GET', path);
+    const path = queryString
+      ? `/api/chat/${sessionId}/messages?${queryString}`
+      : `/api/chat/${sessionId}/messages`;
+    return this.makeRequest<GetMessagesResponse>("GET", path);
   }
 
   /**
    * Update a chat session
    */
-  async updateChatSession(sessionId: string, request: UpdateSessionRequest): Promise<ChatSessionResponse> {
-    return this.makeRequest<ChatSessionResponse>('PUT', `/api/chat/${sessionId}`, request);
+  async updateChatSession(
+    sessionId: string,
+    request: UpdateSessionRequest,
+  ): Promise<ChatSessionResponse> {
+    return this.makeRequest<ChatSessionResponse>(
+      "PUT",
+      `/api/chat/${sessionId}`,
+      request,
+    );
   }
 
   /**
    * Branch a chat session
    */
-  async branchChatSession(request: CreateChatSessionRequest): Promise<ChatResponse> {
-    return this.makeRequest<ChatResponse>('POST', '/api/chat/branch', request);
+  async branchChatSession(
+    request: CreateChatSessionRequest,
+  ): Promise<ChatResponse> {
+    return this.makeRequest<ChatResponse>("POST", "/api/chat/branch", request);
   }
 
   /**
    * Delete a chat session
    */
   async deleteChatSession(sessionId: string): Promise<void> {
-    await this.makeRequest<void>('DELETE', `/api/chat/${sessionId}`);
+    await this.makeRequest<void>("DELETE", `/api/chat/${sessionId}`);
   }
 
   /**
    * Regenerate an AI response message
    */
-  async regenerateMessage(sessionId: string, messageId: string): Promise<ChatResponse> {
-    return this.makeRequest<ChatResponse>('POST', `/api/chat/${sessionId}/messages/${messageId}/regenerate`);
+  async regenerateMessage(
+    sessionId: string,
+    messageId: string,
+  ): Promise<ChatResponse> {
+    return this.makeRequest<ChatResponse>(
+      "POST",
+      `/api/chat/${sessionId}/messages/${messageId}/regenerate`,
+    );
   }
 
   /**
    * Update a specific message
    */
-  async updateChatMessage(sessionId: string, messageId: string, content: string): Promise<void> {
-    await this.makeRequest<void>('PUT', `/api/chat/${sessionId}/messages/${messageId}`, { content });
+  async updateChatMessage(
+    sessionId: string,
+    messageId: string,
+    content: string,
+  ): Promise<void> {
+    await this.makeRequest<void>(
+      "PUT",
+      `/api/chat/${sessionId}/messages/${messageId}`,
+      { content },
+    );
   }
 
   /**
    * Delete a specific message
    */
   async deleteChatMessage(sessionId: string, messageId: string): Promise<void> {
-    await this.makeRequest<void>('DELETE', `/api/chat/${sessionId}/messages/${messageId}`);
+    await this.makeRequest<void>(
+      "DELETE",
+      `/api/chat/${sessionId}/messages/${messageId}`,
+    );
   }
 
   /**
    * Toggle the "forgotten" status of a message
    */
-  async toggleForgottenMessage(sessionId: string, messageId: string, forgotten: boolean): Promise<void> {
-    await this.makeRequest<void>('PATCH', `/api/chat/${sessionId}/messages/${messageId}/forgotten`, { forgotten });
+  async toggleForgottenMessage(
+    sessionId: string,
+    messageId: string,
+    forgotten: boolean,
+  ): Promise<void> {
+    await this.makeRequest<void>(
+      "PATCH",
+      `/api/chat/${sessionId}/messages/${messageId}/forgotten`,
+      { forgotten },
+    );
   }
 
   /**
    * Merge multiple chat sessions into one
    */
-  async mergeChatSessions(request: MergeSessionsRequest): Promise<ChatSessionResponse> {
-    return this.makeRequest<ChatSessionResponse>('POST', '/api/chat/merge', request);
+  async mergeChatSessions(
+    request: MergeSessionsRequest,
+  ): Promise<ChatSessionResponse> {
+    return this.makeRequest<ChatSessionResponse>(
+      "POST",
+      "/api/chat/merge",
+      request,
+    );
   }
 
   /**
@@ -696,22 +822,22 @@ export class WebSocketClient {
     if (this.ws) return;
 
     // Dynamic import for Node.js WebSocket
-    const WebSocket = (await import('ws')).default;
+    const WebSocket = (await import("ws")).default;
 
     let url = this.wsURL;
-    if (!url.endsWith('/api/ws')) {
-      url += '/api/ws';
+    if (!url.endsWith("/api/ws")) {
+      url += "/api/ws";
     }
 
     this.ws = new WebSocket(url, {
       headers: {
-        'Authorization': `Bearer ${this.token}`,
+        Authorization: `Bearer ${this.token}`,
       },
     });
 
     return new Promise((resolve, reject) => {
-      this.ws.on('open', () => resolve());
-      this.ws.on('error', (err: Error) => reject(err));
+      this.ws.on("open", () => resolve());
+      this.ws.on("error", (err: Error) => reject(err));
     });
   }
 
@@ -723,7 +849,7 @@ export class WebSocketClient {
 
     const messageId = Date.now().toString();
     const request = {
-      type: 'FindAll',
+      type: "FindAll",
       messageId,
       payload: { collection },
     };
@@ -731,17 +857,17 @@ export class WebSocketClient {
     return new Promise((resolve, reject) => {
       this.ws.send(JSON.stringify(request));
 
-      this.ws.once('message', (data: Buffer) => {
+      this.ws.once("message", (data: Buffer) => {
         const response = JSON.parse(data.toString());
 
-        if (response.type === 'Error') {
+        if (response.type === "Error") {
           reject(new Error(response.message));
         } else {
           resolve(response.payload?.data || []);
         }
       });
 
-      this.ws.once('error', reject);
+      this.ws.once("error", reject);
     });
   }