@functional-systems/lambdadb 0.3.4 → 0.4.1

package/test/integration/qdrant-compat-live.test.mjs

@@ -0,0 +1,122 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+  QdrantCompatClient,
+  UnsupportedQdrantFeatureError,
+  models,
+} from "../../dist/esm/compat/qdrant.js";
+
+const shouldRun = process.env.LAMBDADB_RUN_LIVE_TESTS === "1";
+const projectApiKey = process.env.LAMBDADB_PROJECT_API_KEY;
+const projectName = process.env.LAMBDADB_PROJECT_NAME || "playground";
+const baseUrl = process.env.LAMBDADB_BASE_URL || "https://api.lambdadb.ai";
+
+test("qdrant compatibility live smoke", {
+  skip: shouldRun && projectApiKey
+    ? false
+    : "Set LAMBDADB_RUN_LIVE_TESTS=1 and LAMBDADB_PROJECT_API_KEY to run live tests",
+}, async () => {
+  const client = new QdrantCompatClient({
+    projectApiKey,
+    projectName,
+    baseUrl,
+  });
+  const collectionName = `qdrant-live-${Date.now()}`;
+
+  try {
+    await client.createCollection(collectionName, {
+      vectorsConfig: new models.VectorParams({
+        size: 3,
+        distance: models.Distance.COSINE,
+      }),
+      payloadSchema: {
+        tenant: models.PayloadSchemaType.KEYWORD,
+      },
+    });
+
+    assert.equal(await client.collectionExists(collectionName), true);
+
+    const upsertResult = await client.upsert(collectionName, {
+      points: [
+        new models.PointStruct({
+          id: 1,
+          vector: [1.0, 0.0, 0.0],
+          payload: { tenant: "acme", title: "alpha" },
+        }),
+        new models.PointStruct({
+          id: 2,
+          vector: [0.0, 1.0, 0.0],
+          payload: { tenant: "acme", title: "beta" },
+        }),
+        new models.PointStruct({
+          id: 3,
+          vector: [0.0, 0.0, 1.0],
+          payload: { tenant: "other", title: "gamma" },
+        }),
+      ],
+    });
+    assert.equal(upsertResult.status, models.UpdateStatus.COMPLETED);
+
+    const queryResult = await client.queryPoints(collectionName, {
+      query: [1.0, 0.0, 0.0],
+      queryFilter: new models.Filter({
+        must: [
+          new models.FieldCondition({
+            key: "tenant",
+            match: new models.MatchValue({ value: "acme" }),
+          }),
+        ],
+      }),
+      limit: 2,
+    });
+    assert.ok(queryResult.points.length > 0);
+    assert.equal(queryResult.points[0].payload?.tenant, "acme");
+
+    const records = await client.retrieve(collectionName, { ids: [1] });
+    assert.equal(records[0]?.id, 1);
+    assert.equal(records[0]?.payload?.tenant, "acme");
+
+    const deleteResult = await client.delete(collectionName, {
+      pointsSelector: [1],
+    });
+    assert.equal(deleteResult.status, models.UpdateStatus.COMPLETED);
+
+    const deleteByFilterResult = await client.delete(collectionName, {
+      pointsSelector: {
+        filter: new models.Filter({
+          must: [
+            new models.FieldCondition({
+              key: "tenant",
+              match: new models.MatchValue({ value: "other" }),
+            }),
+          ],
+        }),
+      },
+    });
+    assert.equal(deleteByFilterResult.status, models.UpdateStatus.COMPLETED);
+
+    const deletedByFilterRecords = await client.retrieve(collectionName, { ids: [3] });
+    assert.equal(deletedByFilterRecords.length, 0);
+
+    await assert.rejects(
+      client.scroll(collectionName, {
+        scrollFilter: new models.Filter({
+          must: [
+            new models.FieldCondition({
+              key: "tenant",
+              match: new models.MatchValue({ value: "acme" }),
+            }),
+          ],
+        }),
+      }),
+      UnsupportedQdrantFeatureError,
+    );
+  } finally {
+    try {
+      await client.deleteCollection(collectionName);
+    } catch (error) {
+      if (error?.name !== "ResourceNotFoundError") throw error;
+    }
+  }
+});

package/test/qdrant-compat.test.mjs

@@ -0,0 +1,455 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+  QdrantClient,
+  QdrantCompatClient,
+  UnsupportedQdrantFeatureError,
+  models,
+} from "../dist/esm/compat/qdrant.js";
+import { PointStruct } from "../dist/esm/compat/qdrant/models.js";
+
+class FakeDocs {
+  constructor() {
+    this.upserts = [];
+    this.deletes = [];
+    this.fetches = [];
+    this.lists = [];
+  }
+
+  async upsert(body) {
+    this.upserts.push(body);
+    return { message: "ok" };
+  }
+
+  async fetch(body) {
+    this.fetches.push(body);
+    return {
+      docs: [
+        {
+          collection: "docs",
+          doc: {
+            id: "1",
+            _qdrant_id: 1,
+            _qdrant_vector: [0.1, 0.2],
+            tenant: "acme",
+          },
+        },
+      ],
+    };
+  }
+
+  async delete(body) {
+    this.deletes.push(body);
+    return { message: "ok" };
+  }
+
+  async list(body = {}) {
+    this.lists.push(body);
+    return {
+      docs: [
+        {
+          collection: "docs",
+          doc: { id: "1", _qdrant_id: 1, tenant: "acme" },
+        },
+      ],
+      nextPageToken: undefined,
+    };
+  }
+}
+
+class FakeCollection {
+  constructor(owner, name) {
+    this.owner = owner;
+    this.name = name;
+    this.docs = new FakeDocs();
+    this.queries = [];
+    this.updates = [];
+    this.deletes = [];
+  }
+
+  async get() {
+    this.owner.gets.push({ collectionName: this.name });
+    return {
+      collection: {
+        collectionName: this.name,
+        indexConfigs: this.owner.indexConfigs,
+        numDocs: this.owner.numDocs,
+        collectionStatus: "ACTIVE",
+      },
+    };
+  }
+
+  async update(body) {
+    this.updates.push(body);
+    this.owner.indexConfigs = body.indexConfigs;
+    return { collection: { collectionName: this.name, indexConfigs: body.indexConfigs } };
+  }
+
+  async delete() {
+    this.deletes.push({});
+    return { message: "ok" };
+  }
+
+  async query(body) {
+    this.queries.push(body);
+    return {
+      docs: [
+        {
+          collection: this.name,
+          score: 0.9,
+          doc: {
+            id: "1",
+            _qdrant_id: 1,
+            _qdrant_vector: [0.1, 0.2],
+            tenant: "acme",
+          },
+        },
+      ],
+    };
+  }
+}
+
+class FakeLambdaDB {
+  constructor() {
+    this.created = [];
+    this.gets = [];
+    this.indexConfigs = {};
+    this.numDocs = 0;
+    this.collectionsByName = new Map();
+  }
+
+  async createCollection(body) {
+    this.created.push(body);
+    this.indexConfigs = body.indexConfigs ?? {};
+    return { collection: { collectionName: body.collectionName } };
+  }
+
+  collection(name) {
+    if (!this.collectionsByName.has(name)) {
+      this.collectionsByName.set(name, new FakeCollection(this, name));
+    }
+    return this.collectionsByName.get(name);
+  }
+}
+
+test("qdrant compatibility exports public client and models", () => {
+  assert.equal(QdrantClient, QdrantCompatClient);
+  assert.equal(models.PointStruct, PointStruct);
+
+  const point = new models.PointStruct({
+    id: 1,
+    vector: [0.1, 0.2],
+    payload: { tenant: "acme" },
+  });
+  assert.equal(point.id, 1);
+});
+
+test("createCollection maps vector params and payload schema", async () => {
+  const fake = new FakeLambdaDB();
+  const client = new QdrantCompatClient(fake);
+
+  assert.equal(
+    await client.createCollection("docs", {
+      vectorsConfig: new models.VectorParams({
+        size: 3,
+        distance: models.Distance.DOT,
+      }),
+      payloadSchema: {
+        tenant: models.PayloadSchemaType.KEYWORD,
+        views: models.PayloadSchemaType.INTEGER,
+        score: models.PayloadSchemaType.FLOAT,
+        active: models.PayloadSchemaType.BOOL,
+      },
+    }),
+    true,
+  );
+
+  assert.deepEqual(fake.created, [
+    {
+      collectionName: "docs",
+      indexConfigs: {
+        _qdrant_vector: {
+          type: "vector",
+          dimensions: 3,
+          similarity: "dot_product",
+        },
+        tenant: { type: "keyword" },
+        views: { type: "long" },
+        score: { type: "double" },
+        active: { type: "boolean" },
+      },
+    },
+  ]);
+});
+
+test("createPayloadIndex merges existing configs and rejects non-empty backfill", async () => {
+  const fake = new FakeLambdaDB();
+  fake.indexConfigs = {
+    _qdrant_vector: {
+      type: "vector",
+      dimensions: 3,
+      similarity: "cosine",
+    },
+  };
+  const client = new QdrantCompatClient(fake);
+
+  assert.equal(
+    await client.createPayloadIndex(
+      "docs",
+      "tenant",
+      models.PayloadSchemaType.KEYWORD,
+    ),
+    true,
+  );
+
+  assert.deepEqual(fake.collection("docs").updates, [
+    {
+      indexConfigs: {
+        _qdrant_vector: {
+          type: "vector",
+          dimensions: 3,
+          similarity: "cosine",
+        },
+        tenant: { type: "keyword" },
+      },
+    },
+  ]);
+
+  fake.numDocs = 3;
+  await assert.rejects(
+    client.createPayloadIndex("docs", "views", models.PayloadSchemaType.INTEGER),
+    UnsupportedQdrantFeatureError,
+  );
+});
+
+test("upsert maps qdrant points to LambdaDB documents", async () => {
+  const fake = new FakeLambdaDB();
+  const client = new QdrantCompatClient(fake);
+
+  const result = await client.upsert("docs", {
+    points: [
+      new models.PointStruct({
+        id: 1,
+        vector: [0.1, 0.2],
+        payload: { tenant: "acme" },
+      }),
+    ],
+  });
+
+  assert.equal(result.status, models.UpdateStatus.COMPLETED);
+  assert.deepEqual(fake.collection("docs").docs.upserts, [
+    {
+      docs: [
+        {
+          id: "1",
+          _qdrant_id: 1,
+          _qdrant_vector: [0.1, 0.2],
+          tenant: "acme",
+        },
+      ],
+    },
+  ]);
+
+  await assert.rejects(
+    client.upsert("docs", {
+      points: [{ id: 1, vector: [0.1], payload: { _qdrant_vector: [0.2] } }],
+    }),
+    /reserved prefix/,
+  );
+
+  await assert.rejects(
+    client.upsert("docs", {
+      points: [
+        {
+          id: 1,
+          vector: {
+            sparse: new models.SparseVector({ indices: [1], values: [0.9] }),
+          },
+        },
+      ],
+    }),
+    UnsupportedQdrantFeatureError,
+  );
+});
+
+test("queryPoints maps dense vectors, filters, and responses", async () => {
+  const fake = new FakeLambdaDB();
+  const client = new QdrantCompatClient(fake);
+
+  const response = await client.queryPoints("docs", {
+    query: [0.1, 0.2],
+    queryFilter: new models.Filter({
+      must: [
+        new models.FieldCondition({
+          key: "tenant",
+          match: new models.MatchValue({ value: "acme" }),
+        }),
+      ],
+      mustNot: [
+        new models.FieldCondition({
+          key: "status",
+          match: new models.MatchValue({ value: "deleted" }),
+        }),
+      ],
+    }),
+    limit: 5,
+    withVectors: true,
+  });
+
+  assert.equal(response.points[0].id, 1);
+  assert.equal(response.points[0].score, 0.9);
+  assert.deepEqual(response.points[0].payload, { tenant: "acme" });
+  assert.deepEqual(response.points[0].vector, [0.1, 0.2]);
+  assert.deepEqual(fake.collection("docs").queries, [
+    {
+      query: {
+        knn: {
+          field: "_qdrant_vector",
+          k: 5,
+          queryVector: [0.1, 0.2],
+          filter: {
+            bool: [
+              { queryString: { query: "tenant:acme" }, occur: "filter" },
+              { queryString: { query: "status:deleted" }, occur: "must_not" },
+            ],
+          },
+        },
+      },
+      size: 5,
+      consistentRead: true,
+      includeVectors: true,
+    },
+  ]);
+
+  await assert.rejects(
+    client.queryPoints("docs", { query: [0.1], offset: 1 }),
+    UnsupportedQdrantFeatureError,
+  );
+});
+
+test("payload and vector selectors map to LambdaDB fields and qdrant responses", async () => {
+  const fake = new FakeLambdaDB();
+  const collection = fake.collection("docs");
+  collection.query = async function query(body) {
+    this.queries.push(body);
+    return {
+      docs: [
+        {
+          collection: this.name,
+          score: 0.9,
+          doc: {
+            id: "1",
+            _qdrant_id: 1,
+            _qdrant_vector: [0.1, 0.2],
+            _qdrant_vector_title: [0.3, 0.4],
+            tenant: "acme",
+            hidden: "value",
+          },
+        },
+      ],
+    };
+  };
+  const client = new QdrantCompatClient(fake);
+
+  const response = await client.queryPoints("docs", {
+    query: [0.1, 0.2],
+    limit: 1,
+    withPayload: ["tenant"],
+    withVectors: ["title"],
+  });
+
+  assert.deepEqual(response.points[0].payload, { tenant: "acme" });
+  assert.deepEqual(response.points[0].vector, { title: [0.3, 0.4] });
+  assert.deepEqual(collection.queries[0].fields, {
+    include: ["_qdrant_id", "tenant", "_qdrant_vector_title"],
+  });
+  assert.equal(collection.queries[0].includeVectors, true);
+
+  const records = await client.retrieve("docs", {
+    ids: [1],
+    withPayload: ["tenant"],
+    withVectors: false,
+  });
+  assert.deepEqual(records[0].payload, { tenant: "acme" });
+  assert.equal(records[0].vector, undefined);
+  assert.deepEqual(collection.docs.fetches.at(-1), {
+    ids: ["1"],
+    consistentRead: true,
+    includeVectors: false,
+    fields: { include: ["_qdrant_id", "tenant"] },
+  });
+});
+
+test("retrieve, delete, scroll, count, and getCollection return qdrant-style objects", async () => {
+  const fake = new FakeLambdaDB();
+  fake.indexConfigs = {
+    _qdrant_vector: {
+      type: "vector",
+      dimensions: 2,
+      similarity: "cosine",
+    },
+  };
+  fake.numDocs = 12;
+  const client = new QdrantCompatClient(fake);
+
+  const collection = await client.getCollection("docs");
+  assert.equal(collection.config.params.vectors.size, 2);
+  assert.equal(collection.config.params.vectors.distance, models.Distance.COSINE);
+
+  const records = await client.retrieve("docs", { ids: [1], withVectors: true });
+  assert.equal(records[0].id, 1);
+  assert.deepEqual(records[0].payload, { tenant: "acme" });
+  assert.deepEqual(records[0].vector, [0.1, 0.2]);
+  assert.deepEqual(fake.collection("docs").docs.fetches, [
+    { ids: ["1"], consistentRead: true, includeVectors: true },
+  ]);
+
+  const deleteResult = await client.delete("docs", { pointsSelector: [1] });
+  assert.equal(deleteResult.status, models.UpdateStatus.COMPLETED);
+  assert.deepEqual(fake.collection("docs").docs.deletes, [{ ids: ["1"] }]);
+
+  await client.delete("docs", {
+    filter: new models.Filter({
+      must: [
+        new models.FieldCondition({
+          key: "tenant",
+          match: new models.MatchValue({ value: "acme" }),
+        }),
+      ],
+    }),
+  });
+  await client.delete("docs", {
+    pointsSelector: {
+      filter: {
+        must: [
+          {
+            key: "status",
+            match: { value: "archived" },
+          },
+        ],
+      },
+    },
+  });
+  assert.deepEqual(fake.collection("docs").docs.deletes, [
+    { ids: ["1"] },
+    {
+      filter: {
+        queryString: { query: "tenant:acme" },
+      },
+    },
+    {
+      filter: {
+        queryString: { query: "status:archived" },
+      },
+    },
+  ]);
+
+  const [scrollRecords, nextOffset] = await client.scroll("docs", { limit: 3 });
+  assert.equal(scrollRecords[0].id, 1);
+  assert.equal(nextOffset, undefined);
+  assert.deepEqual(fake.collection("docs").docs.lists, [{ size: 3 }]);
+
+  const count = await client.count("docs");
+  assert.equal(count.count, 12);
+});