@bridgerust/embex 0.1.13 → 0.1.15

package/dist/src/tests/integration/adapters.test.js

@@ -0,0 +1,372 @@
+"use strict";
+/**
+ * Embex Integration Tests - Node.js
+ * Tests all adapter implementations against real database instances.
+ *
+ * Run Docker Compose first: docker-compose up -d
+ *
+ * Usage:
+ *   cd bindings/node/@bridgerust/embex
+ *   npm run build
+ *   npm test tests/integration/
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const index_1 = require("../../index");
+const crypto_1 = require("crypto");
+const os_1 = require("os");
+const path_1 = require("path");
+const TEST_DIMENSION = 128;
+const TEST_COLLECTION = "embex_integration_test_node";
+function randomVector(dim = TEST_DIMENSION) {
+    return Array.from({ length: dim }, () => Math.random());
+}
+(0, vitest_1.describe)("Qdrant Adapter", () => {
+    let client;
+    let collection;
+    (0, vitest_1.beforeAll)(() => {
+        client = new index_1.EmbexClient("qdrant", "http://localhost:6334");
+        collection = client.collection(TEST_COLLECTION);
+    });
+    (0, vitest_1.afterAll)(async () => {
+        try {
+            await collection.deleteCollection();
+        }
+        catch (e) { }
+    });
+    (0, vitest_1.it)("should create collection", async () => {
+        try {
+            await collection.deleteCollection();
+        }
+        catch (e) { }
+        await collection.create(TEST_DIMENSION, "cosine");
+    });
+    (0, vitest_1.it)("should insert and search points", async () => {
+        try {
+            await collection.deleteCollection();
+        }
+        catch (e) { }
+        await collection.create(TEST_DIMENSION, "cosine");
+        const points = [
+            { id: (0, crypto_1.randomUUID)(), vector: randomVector(), metadata: { category: "A" } },
+            { id: (0, crypto_1.randomUUID)(), vector: randomVector(), metadata: { category: "B" } },
+            { id: (0, crypto_1.randomUUID)(), vector: randomVector(), metadata: { category: "A" } },
+        ];
+        await collection.insert(points);
+        const results = await collection.query(randomVector(), { limit: 2 });
+        (0, vitest_1.expect)(results.results.length).toBe(2);
+    });
+    (0, vitest_1.it)("should use search() method with direct parameters", async () => {
+        try {
+            await collection.deleteCollection();
+        }
+        catch (e) { }
+        await collection.create(TEST_DIMENSION, "cosine");
+        const points = [
+            { id: (0, crypto_1.randomUUID)(), vector: randomVector(), metadata: { category: "A" } },
+            { id: (0, crypto_1.randomUUID)(), vector: randomVector(), metadata: { category: "B" } },
+        ];
+        await collection.insert(points);
+        const results = await collection.search(randomVector(), 2, null, true, false);
+        (0, vitest_1.expect)(results.results.length).toBe(2);
+        (0, vitest_1.expect)(results.results[0].id).toBeDefined();
+        (0, vitest_1.expect)(results.results[0].score).toBeDefined();
+    });
+    (0, vitest_1.it)("should search with filters", async () => {
+        try {
+            await collection.deleteCollection();
+        }
+        catch (e) { }
+        await collection.create(TEST_DIMENSION, "cosine");
+        const points = [
+            {
+                id: (0, crypto_1.randomUUID)(),
+                vector: randomVector(),
+                metadata: { status: "active", score: 10 },
+            },
+            {
+                id: (0, crypto_1.randomUUID)(),
+                vector: randomVector(),
+                metadata: { status: "inactive", score: 20 },
+            },
+            {
+                id: (0, crypto_1.randomUUID)(),
+                vector: randomVector(),
+                metadata: { status: "active", score: 30 },
+            },
+        ];
+        await collection.insert(points);
+        const filter = {
+            op: "key",
+            args: ["status", { eq: "active" }],
+        };
+        const results = await collection.search(randomVector(), 10, filter, true, false);
+        (0, vitest_1.expect)(results.results.length).toBeGreaterThanOrEqual(2);
+        results.results.forEach((r) => {
+            (0, vitest_1.expect)(r.metadata?.status).toBe("active");
+        });
+    });
+    (0, vitest_1.it)("should use search builder pattern", async () => {
+        try {
+            await collection.deleteCollection();
+        }
+        catch (e) { }
+        await collection.create(TEST_DIMENSION, "cosine");
+        const points = [
+            { id: (0, crypto_1.randomUUID)(), vector: randomVector(), metadata: { type: "test" } },
+        ];
+        await collection.insert(points);
+        const builder = collection.buildSearch(randomVector());
+        const results = await builder
+            .limit(5)
+            .includeMetadata(true)
+            .includeVector(false)
+            .execute();
+        (0, vitest_1.expect)(results.results).toBeDefined();
+        (0, vitest_1.expect)(Array.isArray(results.results)).toBe(true);
+    });
+    (0, vitest_1.it)("should insert batch with parallel option", async () => {
+        try {
+            await collection.deleteCollection();
+        }
+        catch (e) { }
+        await collection.create(TEST_DIMENSION, "cosine");
+        const points = Array.from({ length: 50 }, () => ({
+            id: (0, crypto_1.randomUUID)(),
+            vector: randomVector(),
+            metadata: { batch: "test" },
+        }));
+        await collection.insertBatch(points, 10, 3);
+        const results = await collection.query(randomVector(), { limit: 50 });
+        (0, vitest_1.expect)(results.results.length).toBeGreaterThanOrEqual(50);
+    });
+    (0, vitest_1.it)("should delete points", async () => {
+        try {
+            await collection.deleteCollection();
+        }
+        catch (e) { }
+        await collection.create(TEST_DIMENSION, "cosine");
+        const delId = (0, crypto_1.randomUUID)();
+        await collection.insert([
+            { id: delId, vector: randomVector(), metadata: {} },
+        ]);
+        await collection.delete([delId]);
+        const results = await collection.query(randomVector(), { limit: 10 });
+        const ids = results.results.map((r) => r.id);
+        (0, vitest_1.expect)(ids).not.toContain(delId);
+    });
+});
+(0, vitest_1.describe)("Chroma Adapter", () => {
+    let client;
+    let collection;
+    (0, vitest_1.beforeAll)(() => {
+        client = new index_1.EmbexClient("chroma", "http://localhost:8000");
+        collection = client.collection(TEST_COLLECTION);
+    });
+    (0, vitest_1.afterAll)(async () => {
+        try {
+            await collection.deleteCollection();
+        }
+        catch (e) { }
+    });
+    (0, vitest_1.it)("should perform CRUD operations", async () => {
+        try {
+            await collection.deleteCollection();
+        }
+        catch (e) { }
+        await collection.create(TEST_DIMENSION, "cosine");
+        const points = [
+            { id: "c1", vector: randomVector(), metadata: { type: "test" } },
+            { id: "c2", vector: randomVector(), metadata: { type: "test" } },
+        ];
+        await collection.insert(points);
+        const results = await collection.query(randomVector(), { limit: 2 });
+        (0, vitest_1.expect)(results.results.length).toBe(2);
+    });
+    (0, vitest_1.it)("should use search() method", async () => {
+        try {
+            await collection.deleteCollection();
+        }
+        catch (e) { }
+        await collection.create(TEST_DIMENSION, "cosine");
+        const points = [
+            { id: "c3", vector: randomVector(), metadata: { type: "search" } },
+        ];
+        await collection.insert(points);
+        const results = await collection.search(randomVector(), 1);
+        (0, vitest_1.expect)(results.results.length).toBeGreaterThanOrEqual(1);
+    });
+    (0, vitest_1.it)("should create collection with auto dimension inference", async () => {
+        try {
+            await collection.deleteCollection();
+        }
+        catch (e) { }
+        await collection.createAuto(undefined, "cosine");
+        const points = [
+            { id: "c4", vector: randomVector(), metadata: { type: "auto" } },
+            { id: "c5", vector: randomVector(), metadata: { type: "auto" } },
+        ];
+        await collection.insert(points);
+        const results = await collection.query(randomVector(), { limit: 2 });
+        (0, vitest_1.expect)(results.results.length).toBe(2);
+        await collection.deleteCollection();
+    });
+});
+(0, vitest_1.describe)("Weaviate Adapter", () => {
+    let client;
+    let collection;
+    (0, vitest_1.beforeAll)(() => {
+        client = new index_1.EmbexClient("weaviate", "http://localhost:8080");
+        collection = client.collection("EmbexNodeTest");
+    });
+    (0, vitest_1.afterAll)(async () => {
+        try {
+            await collection.deleteCollection();
+        }
+        catch (e) { }
+    });
+    (0, vitest_1.it)("should perform CRUD operations", async () => {
+        try {
+            await collection.deleteCollection();
+        }
+        catch (e) { }
+        await collection.create(TEST_DIMENSION, "cosine");
+        const points = [
+            { id: "w1", vector: randomVector(), metadata: { name: "test1" } },
+            { id: "w2", vector: randomVector(), metadata: { name: "test2" } },
+        ];
+        await collection.insert(points);
+        const results = await collection.query(randomVector(), { limit: 2 });
+        (0, vitest_1.expect)(results.results.length).toBeGreaterThanOrEqual(1);
+    });
+});
+(0, vitest_1.describe)("Milvus Adapter", () => {
+    let client;
+    let collection;
+    (0, vitest_1.beforeAll)(async () => {
+        // Milvus requires async initialization
+        client = await index_1.EmbexClient.newAsync("milvus", "http://localhost:19530");
+        collection = client.collection(TEST_COLLECTION);
+    });
+    (0, vitest_1.afterAll)(async () => {
+        try {
+            await collection.deleteCollection();
+        }
+        catch (e) { }
+    });
+    (0, vitest_1.it)("should perform CRUD operations", async () => {
+        try {
+            await collection.deleteCollection();
+        }
+        catch (e) { }
+        await collection.create(TEST_DIMENSION, "cosine");
+        const points = [
+            { id: "m1", vector: randomVector(), metadata: {} },
+            { id: "m2", vector: randomVector(), metadata: {} },
+        ];
+        await collection.insert(points);
+        const results = await collection.query(randomVector(), { limit: 2 });
+        (0, vitest_1.expect)(results.results.length).toBeGreaterThanOrEqual(1);
+    });
+    (0, vitest_1.it)("should use search() method", async () => {
+        try {
+            await collection.deleteCollection();
+        }
+        catch (e) { }
+        await collection.create(TEST_DIMENSION, "cosine");
+        const points = [
+            { id: "m3", vector: randomVector(), metadata: { test: "milvus" } },
+        ];
+        await collection.insert(points);
+        const results = await collection.search(randomVector(), 1);
+        (0, vitest_1.expect)(results.results.length).toBeGreaterThanOrEqual(1);
+    });
+});
+(0, vitest_1.describe)("pgvector Adapter", () => {
+    let client;
+    let collection;
+    (0, vitest_1.beforeAll)(async () => {
+        // pgvector requires async initialization
+        client = await index_1.EmbexClient.newAsync("pgvector", "postgresql://embex:embex_test@localhost:5432/embex_test");
+        collection = client.collection(TEST_COLLECTION);
+    });
+    (0, vitest_1.afterAll)(async () => {
+        try {
+            await collection.deleteCollection();
+        }
+        catch (e) { }
+    });
+    (0, vitest_1.it)("should perform CRUD operations", async () => {
+        try {
+            await collection.deleteCollection();
+        }
+        catch (e) { }
+        await collection.create(TEST_DIMENSION, "cosine");
+        const points = [
+            { id: "pg1", vector: randomVector(), metadata: { info: "test" } },
+            { id: "pg2", vector: randomVector(), metadata: { info: "test" } },
+        ];
+        await collection.insert(points);
+        const results = await collection.query(randomVector(), { limit: 2 });
+        (0, vitest_1.expect)(results.results.length).toBeGreaterThanOrEqual(1);
+    });
+    (0, vitest_1.it)("should use search() method with filters", async () => {
+        try {
+            await collection.deleteCollection();
+        }
+        catch (e) { }
+        await collection.create(TEST_DIMENSION, "cosine");
+        const points = [
+            { id: "pg3", vector: randomVector(), metadata: { status: "active" } },
+        ];
+        await collection.insert(points);
+        const filter = {
+            op: "key",
+            args: ["status", { eq: "active" }],
+        };
+        const results = await collection.search(randomVector(), 5, filter, true, false);
+        (0, vitest_1.expect)(results.results.length).toBeGreaterThanOrEqual(1);
+    });
+});
+(0, vitest_1.describe)("LanceDB Adapter", () => {
+    let client;
+    let collection;
+    const dbPath = (0, path_1.join)((0, os_1.tmpdir)(), `lancedb_node_test_${Date.now()}`);
+    (0, vitest_1.beforeAll)(async () => {
+        client = await index_1.EmbexClient.newAsync("lancedb", dbPath);
+        collection = client.collection(TEST_COLLECTION);
+    });
+    (0, vitest_1.afterAll)(async () => {
+        try {
+            await collection.deleteCollection();
+        }
+        catch (e) { }
+    });
+    (0, vitest_1.it)("should perform CRUD operations", async () => {
+        try {
+            await collection.deleteCollection();
+        }
+        catch (e) { }
+        await collection.create(TEST_DIMENSION, "cosine");
+        const points = [
+            { id: "l1", vector: randomVector(), metadata: { name: "lance1" } },
+            { id: "l2", vector: randomVector(), metadata: { name: "lance2" } },
+        ];
+        await collection.insert(points);
+        const results = await collection.query(randomVector(), { limit: 2 });
+        (0, vitest_1.expect)(results.results.length).toBeGreaterThanOrEqual(1);
+    });
+    (0, vitest_1.it)("should use search() method", async () => {
+        try {
+            await collection.deleteCollection();
+        }
+        catch (e) { }
+        await collection.create(TEST_DIMENSION, "cosine");
+        const points = [
+            { id: "l3", vector: randomVector(), metadata: { name: "lance3" } },
+        ];
+        await collection.insert(points);
+        const results = await collection.search(randomVector(), 1, null, true, false);
+        (0, vitest_1.expect)(results.results.length).toBeGreaterThanOrEqual(1);
+    });
+});

package/dist/src/tests/integration/aggregations.test.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Aggregation Integration Tests
+ * Tests aggregation functionality (count, etc.)
+ */
+export {};
+//# sourceMappingURL=aggregations.test.d.ts.map

package/dist/src/tests/integration/aggregations.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregations.test.d.ts","sourceRoot":"","sources":["../../../../src/tests/integration/aggregations.test.ts"],"names":[],"mappings":"AAAA;;;GAGG"}

package/dist/src/tests/integration/aggregations.test.js

@@ -0,0 +1,96 @@
+"use strict";
+/**
+ * Aggregation Integration Tests
+ * Tests aggregation functionality (count, etc.)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const index_1 = require("../../index");
+const crypto_1 = require("crypto");
+const TEST_DIMENSION = 128;
+const TEST_COLLECTION = "embex_aggregation_test";
+function randomVector(dim = TEST_DIMENSION) {
+    return Array.from({ length: dim }, () => Math.random());
+}
+(0, vitest_1.describe)("Aggregations", () => {
+    let client;
+    let collection;
+    (0, vitest_1.beforeAll)(() => {
+        client = new index_1.EmbexClient("qdrant", "http://localhost:6334");
+        collection = client.collection(TEST_COLLECTION);
+    });
+    (0, vitest_1.afterAll)(async () => {
+        try {
+            await collection.deleteCollection();
+        }
+        catch (e) { }
+    });
+    (0, vitest_1.it)("should return count aggregation", async () => {
+        try {
+            await collection.deleteCollection();
+        }
+        catch (e) { }
+        await collection.create(TEST_DIMENSION, "cosine");
+        const points = Array.from({ length: 10 }, () => ({
+            id: (0, crypto_1.randomUUID)(),
+            vector: randomVector(),
+            metadata: {},
+        }));
+        await collection.insert(points);
+        const builder = collection.buildSearch(randomVector());
+        const results = await builder.limit(5).aggregation("count").execute();
+        (0, vitest_1.expect)(results.aggregations).toBeDefined();
+        (0, vitest_1.expect)(results.aggregations.count).toBeDefined();
+        (0, vitest_1.expect)(typeof results.aggregations.count).toBe("number");
+        (0, vitest_1.expect)(results.aggregations.count).toBeGreaterThanOrEqual(10);
+    });
+    (0, vitest_1.it)("should return count with filters", async () => {
+        try {
+            await collection.deleteCollection();
+        }
+        catch (e) { }
+        await collection.create(TEST_DIMENSION, "cosine");
+        const points = [
+            { id: (0, crypto_1.randomUUID)(), vector: randomVector(), metadata: { type: "A" } },
+            { id: (0, crypto_1.randomUUID)(), vector: randomVector(), metadata: { type: "A" } },
+            { id: (0, crypto_1.randomUUID)(), vector: randomVector(), metadata: { type: "B" } },
+        ];
+        await collection.insert(points);
+        const filter = {
+            op: "key",
+            args: ["type", { eq: "A" }],
+        };
+        const builder = collection.buildSearch(randomVector());
+        const results = await builder
+            .limit(10)
+            .filter(filter)
+            .aggregation("count")
+            .execute();
+        (0, vitest_1.expect)(results.aggregations.count).toBeGreaterThanOrEqual(2);
+    });
+    (0, vitest_1.it)("should return count for filter-only queries", async () => {
+        try {
+            await collection.deleteCollection();
+        }
+        catch (e) { }
+        await collection.create(TEST_DIMENSION, "cosine");
+        const points = Array.from({ length: 5 }, () => ({
+            id: (0, crypto_1.randomUUID)(),
+            vector: randomVector(),
+            metadata: { status: "active" },
+        }));
+        await collection.insert(points);
+        const filter = {
+            op: "key",
+            args: ["status", { eq: "active" }],
+        };
+        const builder = collection.buildQuery();
+        const results = await builder
+            .filter(filter)
+            .limit(10)
+            .aggregation("count")
+            .execute();
+        (0, vitest_1.expect)(results.aggregations).toBeDefined();
+        (0, vitest_1.expect)(results.aggregations.count).toBeGreaterThanOrEqual(5);
+    });
+});

package/dist/src/tests/integration/api_parity.test.d.ts

@@ -0,0 +1,6 @@
+/**
+ * API Parity Tests
+ * Verifies that Node.js bindings have feature parity with Python bindings
+ */
+export {};
+//# sourceMappingURL=api_parity.test.d.ts.map

package/dist/src/tests/integration/api_parity.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api_parity.test.d.ts","sourceRoot":"","sources":["../../../../src/tests/integration/api_parity.test.ts"],"names":[],"mappings":"AAAA;;;GAGG"}

package/dist/src/tests/integration/api_parity.test.js

@@ -0,0 +1,99 @@
+"use strict";
+/**
+ * API Parity Tests
+ * Verifies that Node.js bindings have feature parity with Python bindings
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const index_1 = require("../../index");
+(0, vitest_1.describe)("API Parity with Python", () => {
+    (0, vitest_1.it)("should support all core methods", () => {
+        const client = new index_1.EmbexClient("qdrant", "http://localhost:6334", null);
+        const collection = client.collection("parity_test");
+        (0, vitest_1.expect)(typeof collection.create).toBe("function");
+        (0, vitest_1.expect)(typeof collection.deleteCollection).toBe("function");
+        (0, vitest_1.expect)(typeof collection.insert).toBe("function");
+        (0, vitest_1.expect)(typeof collection.insertBatch).toBe("function");
+        (0, vitest_1.expect)(typeof collection.query).toBe("function");
+        (0, vitest_1.expect)(typeof collection.search).toBe("function");
+        (0, vitest_1.expect)(typeof collection.delete).toBe("function");
+        (0, vitest_1.expect)(typeof collection.updateMetadata).toBe("function");
+        (0, vitest_1.expect)(typeof collection.buildSearch).toBe("function");
+        (0, vitest_1.expect)(typeof collection.buildQuery).toBe("function");
+    });
+    (0, vitest_1.it)("should support async client initialization", async () => {
+        const client = await index_1.EmbexClient.newAsync("lancedb", "/tmp/test");
+        (0, vitest_1.expect)(client).toBeDefined();
+        (0, vitest_1.expect)(client.collection).toBeDefined();
+    });
+    (0, vitest_1.it)("should support search builder pattern", () => {
+        const client = new index_1.EmbexClient("qdrant", "http://localhost:6334", null);
+        const collection = client.collection("parity_test");
+        const builder = collection.buildSearch([0.1, 0.2, 0.3]);
+        (0, vitest_1.expect)(builder).toBeDefined();
+        (0, vitest_1.expect)(typeof builder.limit).toBe("function");
+        (0, vitest_1.expect)(typeof builder.filter).toBe("function");
+        (0, vitest_1.expect)(typeof builder.includeMetadata).toBe("function");
+        (0, vitest_1.expect)(typeof builder.includeVector).toBe("function");
+        (0, vitest_1.expect)(typeof builder.aggregation).toBe("function");
+        (0, vitest_1.expect)(typeof builder.execute).toBe("function");
+    });
+    (0, vitest_1.it)("should support query builder pattern", () => {
+        const client = new index_1.EmbexClient("qdrant", "http://localhost:6334", null);
+        const collection = client.collection("parity_test");
+        const builder = collection.buildQuery();
+        (0, vitest_1.expect)(builder).toBeDefined();
+        (0, vitest_1.expect)(typeof builder.limit).toBe("function");
+        (0, vitest_1.expect)(typeof builder.filter).toBe("function");
+        (0, vitest_1.expect)(typeof builder.includeMetadata).toBe("function");
+        (0, vitest_1.expect)(typeof builder.includeVector).toBe("function");
+        (0, vitest_1.expect)(typeof builder.offset).toBe("function");
+        (0, vitest_1.expect)(typeof builder.aggregation).toBe("function");
+        (0, vitest_1.expect)(typeof builder.execute).toBe("function");
+    });
+    (0, vitest_1.it)("should support batch operations with parallel option", () => {
+        const client = new index_1.EmbexClient("qdrant", "http://localhost:6334", null);
+        const collection = client.collection("parity_test");
+        (0, vitest_1.expect)(typeof collection.insertBatch).toBe("function");
+    });
+    (0, vitest_1.it)("should support all distance metrics", async () => {
+        const client = new index_1.EmbexClient("qdrant", "http://localhost:6334", null);
+        const collection = client.collection("parity_test");
+        const metrics = ["cosine", "euclidean", "dot"];
+        for (const metric of metrics) {
+            try {
+                await collection.deleteCollection();
+            }
+            catch (e) { }
+            try {
+                await collection.create(128, metric);
+                (0, vitest_1.expect)(true).toBe(true);
+            }
+            catch (e) {
+                if (e.message && e.message.includes("Invalid distance metric")) {
+                    throw e;
+                }
+            }
+        }
+    });
+    (0, vitest_1.it)("should support filter operations", () => {
+        const client = new index_1.EmbexClient("qdrant", "http://localhost:6334", null);
+        const collection = client.collection("parity_test");
+        const filter = {
+            op: "key",
+            args: ["status", { op: "eq", args: "active" }],
+        };
+        (0, vitest_1.expect)(typeof collection.query).toBe("function");
+    });
+    (0, vitest_1.it)("should support metadata operations", () => {
+        const client = new index_1.EmbexClient("qdrant", "http://localhost:6334", null);
+        const collection = client.collection("parity_test");
+        (0, vitest_1.expect)(typeof collection.updateMetadata).toBe("function");
+    });
+    (0, vitest_1.it)("should support aggregations", () => {
+        const client = new index_1.EmbexClient("qdrant", "http://localhost:6334", null);
+        const collection = client.collection("parity_test");
+        const builder = collection.buildSearch([0.1, 0.2]);
+        (0, vitest_1.expect)(typeof builder.aggregation).toBe("function");
+    });
+});

package/dist/src/tests/integration/batch.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=batch.test.d.ts.map

package/dist/src/tests/integration/batch.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"batch.test.d.ts","sourceRoot":"","sources":["../../../../src/tests/integration/batch.test.ts"],"names":[],"mappings":""}

package/dist/src/tests/integration/batch.test.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Integration tests for batch operations
+ */
+const vitest_1 = require("vitest");
+const index_1 = require("../../index");
+const crypto_1 = require("crypto");
+(0, vitest_1.describe)("Batch Operations", () => {
+    const client = new index_1.EmbexClient("qdrant", "http://localhost:6334");
+    const collectionName = `batch_test_${(0, crypto_1.randomUUID)()}`;
+    let collection;
+    (0, vitest_1.beforeAll)(async () => {
+        collection = client.collection(collectionName);
+        try {
+            await collection.deleteCollection();
+        }
+        catch (e) {
+            // Ignore if doesn't exist
+        }
+        await collection.create(4, "cosine");
+    });
+    (0, vitest_1.afterAll)(async () => {
+        try {
+            await collection.deleteCollection();
+        }
+        catch (e) {
+            // Ignore cleanup errors
+        }
+    });
+    (0, vitest_1.it)("should insert points in batches", async () => {
+        const points = [];
+        const expectedIds = [];
+        for (let i = 0; i < 50; i++) {
+            const id = (0, crypto_1.randomUUID)();
+            expectedIds.push(id);
+            points.push({
+                id,
+                vector: [0.1, 0.2, 0.3, 0.4],
+                metadata: { index: i },
+            });
+        }
+        await collection.insertBatch(points, 10);
+        // Wait for indexing
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+        const results = await collection.search([0.1, 0.2, 0.3, 0.4], 100);
+        (0, vitest_1.expect)(results.results.length).toBeGreaterThanOrEqual(50);
+        const foundIds = new Set(results.results.map((r) => r.id));
+        for (const id of expectedIds) {
+            (0, vitest_1.expect)(foundIds.has(id)).toBe(true);
+        }
+    });
+});

package/dist/src/tests/integration/errors.test.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Error Handling Integration Tests
+ * Tests error handling and edge cases
+ */
+export {};
+//# sourceMappingURL=errors.test.d.ts.map

package/dist/src/tests/integration/errors.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.test.d.ts","sourceRoot":"","sources":["../../../../src/tests/integration/errors.test.ts"],"names":[],"mappings":"AAAA;;;GAGG"}