@ekodb/ekodb-client 0.7.1 → 0.8.0

package/dist/client.test.js

@@ -0,0 +1,702 @@
+"use strict";
+/**
+ * Unit tests for ekoDB TypeScript client
+ *
+ * These tests use vitest and mock fetch to test client methods
+ * without requiring a running ekoDB server.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const client_1 = require("./client");
+// Mock fetch globally
+const mockFetch = vitest_1.vi.fn();
+global.fetch = mockFetch;
+// ============================================================================
+// Test Helpers
+// ============================================================================
+function createTestClient() {
+    return new client_1.EkoDBClient({
+        baseURL: "http://localhost:8080",
+        apiKey: "test-api-key",
+        format: client_1.SerializationFormat.Json,
+        shouldRetry: false,
+    });
+}
+function mockTokenResponse() {
+    mockFetch.mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        json: async () => ({ token: "test-jwt-token" }),
+        headers: new Headers(),
+    });
+}
+function mockJsonResponse(data, status = 200) {
+    mockFetch.mockResolvedValueOnce({
+        ok: status >= 200 && status < 300,
+        status,
+        json: async () => data,
+        text: async () => JSON.stringify(data),
+        headers: new Headers({
+            "content-type": "application/json",
+        }),
+    });
+}
+function mockErrorResponse(status, message) {
+    mockFetch.mockResolvedValueOnce({
+        ok: false,
+        status,
+        json: async () => ({ error: message }),
+        text: async () => message,
+        headers: new Headers(),
+    });
+}
+// ============================================================================
+// Setup/Teardown
+// ============================================================================
+(0, vitest_1.beforeEach)(() => {
+    mockFetch.mockReset();
+});
+(0, vitest_1.afterEach)(() => {
+    vitest_1.vi.clearAllMocks();
+});
+// ============================================================================
+// Client Configuration Tests
+// ============================================================================
+(0, vitest_1.describe)("EkoDBClient configuration", () => {
+    (0, vitest_1.it)("creates client with required config", () => {
+        const client = new client_1.EkoDBClient({
+            baseURL: "http://localhost:8080",
+            apiKey: "test-key",
+        });
+        (0, vitest_1.expect)(client).toBeInstanceOf(client_1.EkoDBClient);
+    });
+    (0, vitest_1.it)("creates client with all options", () => {
+        const client = new client_1.EkoDBClient({
+            baseURL: "http://localhost:8080",
+            apiKey: "test-key",
+            timeout: 60000,
+            maxRetries: 5,
+            shouldRetry: true,
+            format: client_1.SerializationFormat.Json,
+        });
+        (0, vitest_1.expect)(client).toBeInstanceOf(client_1.EkoDBClient);
+    });
+});
+// ============================================================================
+// Health Check Tests
+// ============================================================================
+// Note: Health check tests require specific response format matching
+// Covered by integration tests
+// ============================================================================
+// Insert Tests
+// ============================================================================
+(0, vitest_1.describe)("EkoDBClient insert", () => {
+    (0, vitest_1.it)("inserts record successfully", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({ id: "record_123", name: "Test" });
+        const result = await client.insert("users", { name: "Test" });
+        (0, vitest_1.expect)(result).toHaveProperty("id", "record_123");
+        (0, vitest_1.expect)(mockFetch).toHaveBeenCalledTimes(2);
+    });
+    (0, vitest_1.it)("inserts record with TTL", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({ id: "record_123", name: "Test", ttl: "30m" });
+        const result = await client.insert("users", { name: "Test", ttl: "30m" });
+        (0, vitest_1.expect)(result).toHaveProperty("id");
+    });
+});
+// ============================================================================
+// Find Tests
+// ============================================================================
+(0, vitest_1.describe)("EkoDBClient find", () => {
+    (0, vitest_1.it)("finds records with query", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse([
+            { id: "user_1", name: "Alice" },
+            { id: "user_2", name: "Bob" },
+        ]);
+        const result = await client.find("users", { limit: 10 });
+        (0, vitest_1.expect)(result).toHaveLength(2);
+        (0, vitest_1.expect)(result[0]).toHaveProperty("name", "Alice");
+    });
+    (0, vitest_1.it)("finds record by ID", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({ id: "user_123", name: "Alice" });
+        const result = await client.findById("users", "user_123");
+        (0, vitest_1.expect)(result).toHaveProperty("id", "user_123");
+    });
+    (0, vitest_1.it)("throws error for not found record", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockErrorResponse(404, "Not found");
+        await (0, vitest_1.expect)(client.findById("users", "nonexistent")).rejects.toThrow();
+    });
+});
+// ============================================================================
+// Update Tests
+// ============================================================================
+(0, vitest_1.describe)("EkoDBClient update", () => {
+    (0, vitest_1.it)("updates record successfully", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({ id: "user_123", name: "Updated" });
+        const result = await client.update("users", "user_123", {
+            name: "Updated",
+        });
+        (0, vitest_1.expect)(result).toHaveProperty("name", "Updated");
+    });
+});
+// ============================================================================
+// Delete Tests
+// ============================================================================
+(0, vitest_1.describe)("EkoDBClient delete", () => {
+    (0, vitest_1.it)("deletes record successfully", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({ id: "user_123", deleted: true });
+        await (0, vitest_1.expect)(client.delete("users", "user_123")).resolves.not.toThrow();
+    });
+});
+// ============================================================================
+// Batch Operations Tests
+// ============================================================================
+(0, vitest_1.describe)("EkoDBClient batch operations", () => {
+    (0, vitest_1.it)("batch inserts records", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({
+            successful: ["id_1", "id_2", "id_3"],
+            failed: [],
+        });
+        const records = [{ name: "A" }, { name: "B" }, { name: "C" }];
+        const result = await client.batchInsert("users", records);
+        (0, vitest_1.expect)(result.successful).toHaveLength(3);
+        (0, vitest_1.expect)(result.failed).toHaveLength(0);
+    });
+    (0, vitest_1.it)("batch deletes records", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({
+            successful: ["id_1", "id_2"],
+            failed: [],
+        });
+        const result = await client.batchDelete("users", ["id_1", "id_2"]);
+        (0, vitest_1.expect)(result.successful).toHaveLength(2);
+    });
+});
+// ============================================================================
+// KV Store Tests
+// ============================================================================
+(0, vitest_1.describe)("EkoDBClient KV store", () => {
+    (0, vitest_1.it)("sets KV value", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({ success: true });
+        await (0, vitest_1.expect)(client.kvSet("my_key", { data: "value" })).resolves.not.toThrow();
+    });
+    (0, vitest_1.it)("gets KV value", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({ value: { data: "stored_value" } });
+        const result = await client.kvGet("my_key");
+        (0, vitest_1.expect)(result).toEqual({ data: "stored_value" });
+    });
+    (0, vitest_1.it)("deletes KV value", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({ deleted: true });
+        await (0, vitest_1.expect)(client.kvDelete("my_key")).resolves.not.toThrow();
+    });
+    (0, vitest_1.it)("checks KV exists", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({ value: "something" });
+        const result = await client.kvExists("my_key");
+        (0, vitest_1.expect)(result).toBe(true);
+    });
+});
+// ============================================================================
+// Transaction Tests
+// ============================================================================
+(0, vitest_1.describe)("EkoDBClient transactions", () => {
+    (0, vitest_1.it)("begins transaction", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({ transaction_id: "tx_123456" });
+        const txId = await client.beginTransaction();
+        (0, vitest_1.expect)(txId).toBe("tx_123456");
+    });
+    (0, vitest_1.it)("commits transaction", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({ status: "committed" });
+        await (0, vitest_1.expect)(client.commitTransaction("tx_123")).resolves.not.toThrow();
+    });
+    (0, vitest_1.it)("rolls back transaction", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({ status: "rolled_back" });
+        await (0, vitest_1.expect)(client.rollbackTransaction("tx_123")).resolves.not.toThrow();
+    });
+});
+// ============================================================================
+// Collection Management Tests
+// ============================================================================
+(0, vitest_1.describe)("EkoDBClient collections", () => {
+    (0, vitest_1.it)("lists collections", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({ collections: ["users", "posts", "comments"] });
+        const result = await client.listCollections();
+        (0, vitest_1.expect)(result).toContain("users");
+        (0, vitest_1.expect)(result).toHaveLength(3);
+    });
+    (0, vitest_1.it)("deletes collection", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({ status: "deleted" });
+        await (0, vitest_1.expect)(client.deleteCollection("test_collection")).resolves.not.toThrow();
+    });
+});
+// ============================================================================
+// Restore Operations Tests
+// ============================================================================
+(0, vitest_1.describe)("EkoDBClient restore operations", () => {
+    (0, vitest_1.it)("restores deleted record", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({ status: "restored" });
+        await (0, vitest_1.expect)(client.restoreRecord("users", "record_123")).resolves.not.toThrow();
+    });
+    // Note: restoreCollection return type may vary - covered by integration tests
+});
+// ============================================================================
+// Search Tests
+// ============================================================================
+(0, vitest_1.describe)("EkoDBClient search", () => {
+    (0, vitest_1.it)("performs search", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({
+            results: [
+                { id: "doc_1", score: 0.95 },
+                { id: "doc_2", score: 0.85 },
+            ],
+            total: 2,
+        });
+        const result = await client.search("documents", { query: "test" });
+        (0, vitest_1.expect)(result.results).toHaveLength(2);
+        (0, vitest_1.expect)(result.total).toBe(2);
+    });
+    // Note: textSearch and hybridSearch require specific mock setup - covered by integration tests
+});
+// ============================================================================
+// Functions/Scripts Tests
+// ============================================================================
+(0, vitest_1.describe)("EkoDBClient functions", () => {
+    (0, vitest_1.it)("calls script", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({
+            results: [{ id: "user_1", name: "Alice" }],
+        });
+        const result = await client.callScript("my_function", { limit: 10 });
+        (0, vitest_1.expect)(result).toHaveProperty("results");
+    });
+    (0, vitest_1.it)("lists scripts", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse([
+            { id: "func_1", label: "function_1" },
+            { id: "func_2", label: "function_2" },
+        ]);
+        const result = await client.listScripts();
+        (0, vitest_1.expect)(result).toHaveLength(2);
+    });
+    (0, vitest_1.it)("deletes script", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({ status: "deleted" });
+        await (0, vitest_1.expect)(client.deleteScript("func_123")).resolves.not.toThrow();
+    });
+});
+// ============================================================================
+// Chat Tests
+// ============================================================================
+(0, vitest_1.describe)("EkoDBClient chat", () => {
+    (0, vitest_1.it)("creates chat session", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({
+            chat_id: "chat_123",
+            message_id: "msg_001",
+            responses: ["Hello!"],
+        });
+        const result = await client.createChatSession({
+            collections: [{ collection_name: "documents" }],
+            llm_provider: "openai",
+            llm_model: "gpt-4",
+        });
+        (0, vitest_1.expect)(result).toHaveProperty("chat_id", "chat_123");
+    });
+    (0, vitest_1.it)("sends chat message", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({
+            chat_id: "chat_123",
+            message_id: "msg_002",
+            responses: ["Here is my response."],
+        });
+        const request = { message: "What is the answer?" };
+        const result = await client.chatMessage("chat_123", request);
+        (0, vitest_1.expect)(result).toHaveProperty("message_id");
+    });
+    (0, vitest_1.it)("lists chat sessions", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({
+            sessions: [
+                { id: "chat_1", created_at: "2024-01-01T00:00:00Z" },
+                { id: "chat_2", created_at: "2024-01-02T00:00:00Z" },
+            ],
+            total: 2,
+        });
+        const result = await client.listChatSessions();
+        (0, vitest_1.expect)(result.sessions).toHaveLength(2);
+    });
+    (0, vitest_1.it)("gets chat session", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({
+            id: "chat_123",
+            created_at: "2024-01-01T00:00:00Z",
+            messages: [],
+        });
+        const result = await client.getChatSession("chat_123");
+        (0, vitest_1.expect)(result).toHaveProperty("id", "chat_123");
+    });
+    (0, vitest_1.it)("deletes chat session", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({ status: "deleted" });
+        await (0, vitest_1.expect)(client.deleteChatSession("chat_123")).resolves.not.toThrow();
+    });
+});
+// ============================================================================
+// Error Handling Tests
+// ============================================================================
+(0, vitest_1.describe)("EkoDBClient error handling", () => {
+    (0, vitest_1.it)("handles server error", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockErrorResponse(500, "Internal Server Error");
+        await (0, vitest_1.expect)(client.insert("users", { name: "Test" })).rejects.toThrow();
+    });
+    (0, vitest_1.it)("handles rate limit error", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockFetch.mockResolvedValueOnce({
+            ok: false,
+            status: 429,
+            json: async () => ({ error: "Rate limit exceeded" }),
+            text: async () => "Rate limit exceeded",
+            headers: new Headers({
+                "Retry-After": "60",
+            }),
+        });
+        await (0, vitest_1.expect)(client.insert("users", { name: "Test" })).rejects.toThrow();
+    });
+    (0, vitest_1.it)("handles authentication error", async () => {
+        mockFetch.mockResolvedValueOnce({
+            ok: false,
+            status: 401,
+            json: async () => ({ error: "Invalid API key" }),
+            text: async () => "Invalid API key",
+            headers: new Headers(),
+        });
+        const client = createTestClient();
+        await (0, vitest_1.expect)(client.insert("users", { name: "Test" })).rejects.toThrow();
+    });
+});
+// Note: Rate limit info tests require actual HTTP response headers
+// which are handled differently in the real client vs mocks
+// Covered by integration tests
+// ============================================================================
+// Additional Missing Method Tests - Added Jan 4, 2026
+// ============================================================================
+// Note: findAll/findAllWithLimit use WebSocket, not HTTP - covered by integration tests
+(0, vitest_1.describe)("EkoDBClient batchUpdate", () => {
+    (0, vitest_1.it)("batch updates records", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({
+            successful: ["id_1", "id_2"],
+            failed: [],
+        });
+        const updates = [
+            { id: "id_1", data: { name: "Updated 1" } },
+            { id: "id_2", data: { name: "Updated 2" } },
+        ];
+        const result = await client.batchUpdate("users", updates);
+        (0, vitest_1.expect)(result.successful).toHaveLength(2);
+    });
+});
+(0, vitest_1.describe)("EkoDBClient collection management", () => {
+    (0, vitest_1.it)("creates collection", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({ status: "created" });
+        await (0, vitest_1.expect)(client.createCollection("new_collection", { fields: {} })).resolves.not.toThrow();
+    });
+    (0, vitest_1.it)("gets collection metadata", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({
+            collection: { fields: { name: { field_type: "String" } } },
+        });
+        const result = await client.getCollection("users");
+        (0, vitest_1.expect)(result).toBeDefined();
+    });
+    // Note: getSchema requires specific response format - covered by integration tests
+});
+(0, vitest_1.describe)("EkoDBClient KV advanced", () => {
+    (0, vitest_1.it)("queries KV by pattern", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse([
+            { key: "config:app", value: "value1" },
+            { key: "config:db", value: "value2" },
+        ]);
+        const result = await client.kvFind({ pattern: "config:*" });
+        (0, vitest_1.expect)(result).toHaveLength(2);
+    });
+});
+(0, vitest_1.describe)("EkoDBClient scripts advanced", () => {
+    (0, vitest_1.it)("saves script", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({ id: "func_123", label: "my_function" });
+        const script = {
+            label: "my_function",
+            name: "my_function",
+            parameters: {},
+            functions: [],
+        };
+        const result = await client.saveScript(script);
+        (0, vitest_1.expect)(result).toBeDefined();
+    });
+    (0, vitest_1.it)("gets script by ID", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({ id: "func_123", label: "my_function" });
+        const result = await client.getScript("func_123");
+        (0, vitest_1.expect)(result).toBeDefined();
+    });
+    (0, vitest_1.it)("updates script", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({ id: "func_123", label: "updated_function" });
+        const script = {
+            label: "updated_function",
+            name: "updated_function",
+            parameters: {},
+            functions: [],
+        };
+        await (0, vitest_1.expect)(client.updateScript("func_123", script)).resolves.not.toThrow();
+    });
+});
+(0, vitest_1.describe)("EkoDBClient chat advanced", () => {
+    (0, vitest_1.it)("gets chat session messages", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({
+            messages: [
+                { id: "msg_1", role: "user", content: "Hello" },
+                { id: "msg_2", role: "assistant", content: "Hi" },
+            ],
+        });
+        const result = await client.getChatSessionMessages("chat_123");
+        (0, vitest_1.expect)(result).toBeDefined();
+    });
+    (0, vitest_1.it)("updates chat session", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({ id: "chat_123", updated: true });
+        await (0, vitest_1.expect)(client.updateChatSession("chat_123", { system_prompt: "New prompt" })).resolves.not.toThrow();
+    });
+    (0, vitest_1.it)("branches chat session", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({ chat_id: "chat_456", branched_from: "chat_123" });
+        const result = await client.branchChatSession({
+            collections: [{ collection_name: "documents" }],
+            llm_provider: "openai",
+        });
+        (0, vitest_1.expect)(result).toBeDefined();
+    });
+    (0, vitest_1.it)("merges chat sessions", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({ chat_id: "chat_123", merged: true });
+        const result = await client.mergeChatSessions({
+            source_chat_ids: ["chat_456"],
+            target_chat_id: "chat_123",
+            merge_strategy: "Interleaved",
+        });
+        (0, vitest_1.expect)(result).toBeDefined();
+    });
+    (0, vitest_1.it)("deletes chat message", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({ deleted: true });
+        await (0, vitest_1.expect)(client.deleteChatMessage("chat_123", "msg_001")).resolves.not.toThrow();
+    });
+    (0, vitest_1.it)("updates chat message", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({ message_id: "msg_001", updated: true });
+        await (0, vitest_1.expect)(client.updateChatMessage("chat_123", "msg_001", "Updated content")).resolves.not.toThrow();
+    });
+    (0, vitest_1.it)("regenerates chat message", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({ message_id: "msg_002", content: "Regenerated" });
+        const result = await client.regenerateMessage("chat_123", "msg_001");
+        (0, vitest_1.expect)(result).toBeDefined();
+    });
+    (0, vitest_1.it)("toggles forgotten message", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({ message_id: "msg_001", forgotten: true });
+        await (0, vitest_1.expect)(client.toggleForgottenMessage("chat_123", "msg_001", true)).resolves.not.toThrow();
+    });
+});
+(0, vitest_1.describe)("EkoDBClient transaction status", () => {
+    (0, vitest_1.it)("gets transaction status", async () => {
+        const client = createTestClient();
+        mockTokenResponse();
+        mockJsonResponse({ transaction_id: "tx_123", status: "active" });
+        const result = await client.getTransactionStatus("tx_123");
+        (0, vitest_1.expect)(result).toBeDefined();
+    });
+});
+// ============================================================================
+// Convenience Methods Tests
+// ============================================================================
+(0, vitest_1.describe)("Convenience methods", () => {
+    (0, vitest_1.describe)("upsert", () => {
+        (0, vitest_1.it)("inserts when record not found", async () => {
+            mockTokenResponse();
+            // Mock update returning 404
+            mockErrorResponse(404, "Not found");
+            // Mock insert succeeding
+            mockJsonResponse({ id: "user123", name: "John Doe" });
+            const client = createTestClient();
+            await client.init();
+            const result = await client.upsert("users", "user123", {
+                name: "John Doe",
+            });
+            (0, vitest_1.expect)(result).toEqual({ id: "user123", name: "John Doe" });
+        });
+        (0, vitest_1.it)("updates when record exists", async () => {
+            mockTokenResponse();
+            // Mock update succeeding
+            mockJsonResponse({ id: "user123", name: "John Doe Updated" });
+            const client = createTestClient();
+            await client.init();
+            const result = await client.upsert("users", "user123", {
+                name: "John Doe Updated",
+            });
+            (0, vitest_1.expect)(result).toEqual({ id: "user123", name: "John Doe Updated" });
+        });
+        (0, vitest_1.it)("throws on non-404 errors", async () => {
+            mockTokenResponse();
+            // Mock update with server error
+            mockErrorResponse(500, "Internal server error");
+            const client = createTestClient();
+            await client.init();
+            await (0, vitest_1.expect)(client.upsert("users", "user123", { name: "John Doe" })).rejects.toThrow();
+        });
+    });
+    (0, vitest_1.describe)("findOne", () => {
+        (0, vitest_1.it)("returns record when found", async () => {
+            mockTokenResponse();
+            mockJsonResponse([
+                { id: "user123", email: "test@example.com", name: "John" },
+            ]);
+            const client = createTestClient();
+            await client.init();
+            const result = await client.findOne("users", "email", "test@example.com");
+            (0, vitest_1.expect)(result).toEqual({
+                id: "user123",
+                email: "test@example.com",
+                name: "John",
+            });
+        });
+        (0, vitest_1.it)("returns null when not found", async () => {
+            mockTokenResponse();
+            mockJsonResponse([]);
+            const client = createTestClient();
+            await client.init();
+            const result = await client.findOne("users", "email", "notfound@example.com");
+            (0, vitest_1.expect)(result).toBeNull();
+        });
+    });
+    (0, vitest_1.describe)("exists", () => {
+        (0, vitest_1.it)("returns true when record exists", async () => {
+            mockTokenResponse();
+            mockJsonResponse({ id: "user123", name: "John" });
+            const client = createTestClient();
+            await client.init();
+            const result = await client.exists("users", "user123");
+            (0, vitest_1.expect)(result).toBe(true);
+        });
+        (0, vitest_1.it)("returns false when record not found", async () => {
+            mockTokenResponse();
+            mockErrorResponse(404, "Not found");
+            const client = createTestClient();
+            await client.init();
+            const result = await client.exists("users", "user123");
+            (0, vitest_1.expect)(result).toBe(false);
+        });
+        (0, vitest_1.it)("throws on non-404 errors", async () => {
+            mockTokenResponse();
+            mockErrorResponse(500, "Internal server error");
+            const client = createTestClient();
+            await client.init();
+            await (0, vitest_1.expect)(client.exists("users", "user123")).rejects.toThrow();
+        });
+    });
+    (0, vitest_1.describe)("paginate", () => {
+        (0, vitest_1.it)("calculates skip correctly for page 2", async () => {
+            mockTokenResponse();
+            mockJsonResponse([{ id: "user11", name: "User 11" }]);
+            const client = createTestClient();
+            await client.init();
+            const result = await client.paginate("users", 2, 10);
+            (0, vitest_1.expect)(result).toHaveLength(1);
+            (0, vitest_1.expect)(result[0]).toEqual({ id: "user11", name: "User 11" });
+        });
+        (0, vitest_1.it)("skips zero records for page 1", async () => {
+            mockTokenResponse();
+            mockJsonResponse([{ id: "user1", name: "User 1" }]);
+            const client = createTestClient();
+            await client.init();
+            const result = await client.paginate("users", 1, 10);
+            (0, vitest_1.expect)(result).toHaveLength(1);
+            (0, vitest_1.expect)(result[0]).toEqual({ id: "user1", name: "User 1" });
+        });
+        (0, vitest_1.it)("returns empty array when no records", async () => {
+            mockTokenResponse();
+            mockJsonResponse([]);
+            const client = createTestClient();
+            await client.init();
+            const result = await client.paginate("users", 5, 10);
+            (0, vitest_1.expect)(result).toHaveLength(0);
+        });
+    });
+});