ydb-qdrant 3.0.0 → 4.1.0

package/dist/repositories/pointsRepo.js

@@ -1,163 +1,20 @@
-import { TypedValues, withSession } from "../ydb/client.js";
-import { buildJsonOrEmpty, buildVectorParam } from "../ydb/helpers.js";
-import { logger } from "../logging/logger.js";
-import { notifyUpsert } from "../indexing/IndexScheduler.js";
-import { VECTOR_INDEX_BUILD_ENABLED } from "../config/env.js";
-export async function upsertPoints(tableName, points, dimension) {
-    let upserted = 0;
-    await withSession(async (s) => {
-        for (const p of points) {
-            const id = String(p.id);
-            if (p.vector.length !== dimension) {
-                throw new Error(`Vector dimension mismatch for id=${id}: got ${p.vector.length}, expected ${dimension}`);
-            }
-            const ddl = `
-        DECLARE $id AS Utf8;
-        DECLARE $vec AS List<Float>;
-        DECLARE $payload AS JsonDocument;
-        UPSERT INTO ${tableName} (point_id, embedding, payload)
-        VALUES (
-          $id,
-          Untag(Knn::ToBinaryStringFloat($vec), "FloatVector"),
-          $payload
-        );
-      `;
-            const params = {
-                $id: TypedValues.utf8(id),
-                $vec: buildVectorParam(p.vector),
-                $payload: buildJsonOrEmpty(p.payload),
-            };
-            // Retry on transient schema/metadata mismatches during index rebuild
-            const maxRetries = 6; // ~ up to ~ (0.25 + jitter) * 2^5 ≈ few seconds
-            let attempt = 0;
-            while (true) {
-                try {
-                    await s.executeQuery(ddl, params);
-                    break;
-                }
-                catch (e) {
-                    const msg = e instanceof Error ? e.message : String(e);
-                    const isTransient = /Aborted|schema version mismatch|Table metadata loading|Failed to load metadata/i.test(msg);
-                    if (!isTransient || attempt >= maxRetries) {
-                        throw e;
-                    }
-                    const backoffMs = Math.floor(250 * Math.pow(2, attempt) + Math.random() * 100);
-                    logger.warn({ tableName, id, attempt, backoffMs }, "upsert aborted due to schema/metadata change; retrying");
-                    await new Promise((r) => setTimeout(r, backoffMs));
-                    attempt += 1;
-                }
-            }
-            upserted += 1;
-        }
-    });
-    // notify scheduler for potential end-of-batch index build
-    notifyUpsert(tableName, upserted);
-    // No index rebuild; approximate search does not require it
-    return upserted;
-}
-// Removed legacy index backfill helper
-export async function searchPoints(tableName, queryVector, top, withPayload, distance, dimension) {
-    if (queryVector.length !== dimension) {
-        throw new Error(`Vector dimension mismatch: got ${queryVector.length}, expected ${dimension}`);
-    }
-    const { fn, order } = mapDistanceToKnnFn(distance);
-    // Single-phase search over embedding using vector index if present
-    const qf = buildVectorParam(queryVector);
-    const params = {
-        $qf: qf,
-        $k2: TypedValues.uint32(top),
-    };
-    const buildQuery = (useIndex) => `
-    DECLARE $qf AS List<Float>;
-    DECLARE $k2 AS Uint32;
-    $qbinf = Knn::ToBinaryStringFloat($qf);
-    SELECT point_id, ${withPayload ? "payload, " : ""}${fn}(embedding, $qbinf) AS score
-    FROM ${tableName}${useIndex ? " VIEW emb_idx" : ""}
-    ORDER BY score ${order}
-    LIMIT $k2;
-  `;
-    let rs;
-    if (VECTOR_INDEX_BUILD_ENABLED) {
-        try {
-            // Try with vector index first
-            rs = await withSession(async (s) => {
-                return await s.executeQuery(buildQuery(true), params);
-            });
-            logger.info({ tableName }, "vector index found; using index for search");
-        }
-        catch (e) {
-            const msg = e instanceof Error ? e.message : String(e);
-            const indexUnavailable = /not found|does not exist|no such index|no global index|is not ready to use/i.test(msg);
-            if (indexUnavailable) {
-                logger.info({ tableName }, "vector index not available (missing or building); falling back to table scan");
-                rs = await withSession(async (s) => {
-                    return await s.executeQuery(buildQuery(false), params);
-                });
-            }
-            else {
-                throw e;
-            }
-        }
+import { upsertPointsMultiTable, searchPointsMultiTable, deletePointsMultiTable, } from "./pointsRepo.multi-table.js";
+import { upsertPointsOneTable, searchPointsOneTable, deletePointsOneTable, } from "./pointsRepo.one-table.js";
+export async function upsertPoints(tableName, points, dimension, uid) {
+    if (uid) {
+        return await upsertPointsOneTable(tableName, points, dimension, uid);
     }
-    else {
-        // Vector index usage disabled: always use table scan
-        rs = await withSession(async (s) => {
-            return await s.executeQuery(buildQuery(false), params);
-        });
-    }
-    const rowset = rs.resultSets?.[0];
-    const rows = (rowset?.rows ?? []);
-    return rows.map((row) => {
-        const id = row.items?.[0]?.textValue;
-        if (typeof id !== "string") {
-            throw new Error("point_id is missing in YDB search result");
-        }
-        let payload;
-        let scoreIdx = 1;
-        if (withPayload) {
-            const payloadText = row.items?.[1]?.textValue;
-            if (payloadText) {
-                try {
-                    payload = JSON.parse(payloadText);
-                }
-                catch {
-                    payload = undefined;
-                }
-            }
-            scoreIdx = 2;
-        }
-        const score = Number(row.items?.[scoreIdx]?.floatValue ?? row.items?.[scoreIdx]?.textValue);
-        return { id, score, ...(payload ? { payload } : {}) };
-    });
+    return await upsertPointsMultiTable(tableName, points, dimension);
 }
-export async function deletePoints(tableName, ids) {
-    let deleted = 0;
-    await withSession(async (s) => {
-        for (const id of ids) {
-            const yql = `
-        DECLARE $id AS Utf8;
-        DELETE FROM ${tableName} WHERE point_id = $id;
-      `;
-            const params = {
-                $id: TypedValues.utf8(String(id)),
-            };
-            await s.executeQuery(yql, params);
-            deleted += 1;
-        }
-    });
-    return deleted;
+export async function searchPoints(tableName, queryVector, top, withPayload, distance, dimension, uid) {
+    if (uid) {
+        return await searchPointsOneTable(tableName, queryVector, top, withPayload, distance, dimension, uid);
+    }
+    return await searchPointsMultiTable(tableName, queryVector, top, withPayload, distance, dimension);
 }
-function mapDistanceToKnnFn(distance) {
-    switch (distance) {
-        case "Cosine":
-            return { fn: "Knn::CosineSimilarity", order: "DESC" };
-        case "Dot":
-            return { fn: "Knn::InnerProductSimilarity", order: "DESC" };
-        case "Euclid":
-            return { fn: "Knn::EuclideanDistance", order: "ASC" };
-        case "Manhattan":
-            return { fn: "Knn::ManhattanDistance", order: "ASC" };
-        default:
-            return { fn: "Knn::CosineSimilarity", order: "DESC" };
+export async function deletePoints(tableName, ids, uid) {
+    if (uid) {
+        return await deletePointsOneTable(tableName, ids, uid);
     }
+    return await deletePointsMultiTable(tableName, ids);
 }

package/dist/repositories/pointsRepo.multi-table.d.ts

@@ -0,0 +1,12 @@
+import type { DistanceKind } from "../types";
+export declare function upsertPointsMultiTable(tableName: string, points: Array<{
+    id: string | number;
+    vector: number[];
+    payload?: Record<string, unknown>;
+}>, dimension: number): Promise<number>;
+export declare function searchPointsMultiTable(tableName: string, queryVector: number[], top: number, withPayload: boolean | undefined, distance: DistanceKind, dimension: number): Promise<Array<{
+    id: string;
+    score: number;
+    payload?: Record<string, unknown>;
+}>>;
+export declare function deletePointsMultiTable(tableName: string, ids: Array<string | number>): Promise<number>;

package/dist/repositories/pointsRepo.multi-table.js

@@ -0,0 +1,129 @@
+import { TypedValues, withSession } from "../ydb/client.js";
+import { buildJsonOrEmpty, buildVectorParam } from "../ydb/helpers.js";
+import { logger } from "../logging/logger.js";
+import { notifyUpsert } from "../indexing/IndexScheduler.js";
+import { VECTOR_INDEX_BUILD_ENABLED } from "../config/env.js";
+import { mapDistanceToKnnFn } from "../utils/distance.js";
+import { withRetry, isTransientYdbError } from "../utils/retry.js";
+export async function upsertPointsMultiTable(tableName, points, dimension) {
+    let upserted = 0;
+    await withSession(async (s) => {
+        for (const p of points) {
+            const id = String(p.id);
+            if (p.vector.length !== dimension) {
+                throw new Error(`Vector dimension mismatch for id=${id}: got ${p.vector.length}, expected ${dimension}`);
+            }
+            const ddl = `
+        DECLARE $id AS Utf8;
+        DECLARE $vec AS List<Float>;
+        DECLARE $payload AS JsonDocument;
+        UPSERT INTO ${tableName} (point_id, embedding, payload)
+        VALUES (
+          $id,
+          Untag(Knn::ToBinaryStringFloat($vec), "FloatVector"),
+          $payload
+        );
+      `;
+            const params = {
+                $id: TypedValues.utf8(id),
+                $vec: buildVectorParam(p.vector),
+                $payload: buildJsonOrEmpty(p.payload),
+            };
+            await withRetry(() => s.executeQuery(ddl, params), {
+                isTransient: isTransientYdbError,
+                context: { tableName, id },
+            });
+            upserted += 1;
+        }
+    });
+    notifyUpsert(tableName, upserted);
+    return upserted;
+}
+export async function searchPointsMultiTable(tableName, queryVector, top, withPayload, distance, dimension) {
+    if (queryVector.length !== dimension) {
+        throw new Error(`Vector dimension mismatch: got ${queryVector.length}, expected ${dimension}`);
+    }
+    const { fn, order } = mapDistanceToKnnFn(distance);
+    const qf = buildVectorParam(queryVector);
+    const params = {
+        $qf: qf,
+        $k2: TypedValues.uint32(top),
+    };
+    const buildQuery = (useIndex) => `
+    DECLARE $qf AS List<Float>;
+    DECLARE $k2 AS Uint32;
+    $qbinf = Knn::ToBinaryStringFloat($qf);
+    SELECT point_id, ${withPayload ? "payload, " : ""}${fn}(embedding, $qbinf) AS score
+    FROM ${tableName}${useIndex ? " VIEW emb_idx" : ""}
+    ORDER BY score ${order}
+    LIMIT $k2;
+  `;
+    let rs;
+    if (VECTOR_INDEX_BUILD_ENABLED) {
+        try {
+            rs = await withSession(async (s) => {
+                return await s.executeQuery(buildQuery(true), params);
+            });
+            logger.info({ tableName }, "vector index found; using index for search");
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            const indexUnavailable = /not found|does not exist|no such index|no global index|is not ready to use/i.test(msg);
+            if (indexUnavailable) {
+                logger.info({ tableName }, "vector index not available (missing or building); falling back to table scan");
+                rs = await withSession(async (s) => {
+                    return await s.executeQuery(buildQuery(false), params);
+                });
+            }
+            else {
+                throw e;
+            }
+        }
+    }
+    else {
+        rs = await withSession(async (s) => {
+            return await s.executeQuery(buildQuery(false), params);
+        });
+    }
+    const rowset = rs.resultSets?.[0];
+    const rows = (rowset?.rows ?? []);
+    return rows.map((row) => {
+        const id = row.items?.[0]?.textValue;
+        if (typeof id !== "string") {
+            throw new Error("point_id is missing in YDB search result");
+        }
+        let payload;
+        let scoreIdx = 1;
+        if (withPayload) {
+            const payloadText = row.items?.[1]?.textValue;
+            if (payloadText) {
+                try {
+                    payload = JSON.parse(payloadText);
+                }
+                catch {
+                    payload = undefined;
+                }
+            }
+            scoreIdx = 2;
+        }
+        const score = Number(row.items?.[scoreIdx]?.floatValue ?? row.items?.[scoreIdx]?.textValue);
+        return { id, score, ...(payload ? { payload } : {}) };
+    });
+}
+export async function deletePointsMultiTable(tableName, ids) {
+    let deleted = 0;
+    await withSession(async (s) => {
+        for (const id of ids) {
+            const yql = `
+        DECLARE $id AS Utf8;
+        DELETE FROM ${tableName} WHERE point_id = $id;
+      `;
+            const params = {
+                $id: TypedValues.utf8(String(id)),
+            };
+            await s.executeQuery(yql, params);
+            deleted += 1;
+        }
+    });
+    return deleted;
+}

package/dist/repositories/pointsRepo.one-table.d.ts

@@ -0,0 +1,12 @@
+import type { DistanceKind } from "../types";
+export declare function upsertPointsOneTable(tableName: string, points: Array<{
+    id: string | number;
+    vector: number[];
+    payload?: Record<string, unknown>;
+}>, dimension: number, uid: string): Promise<number>;
+export declare function searchPointsOneTable(tableName: string, queryVector: number[], top: number, withPayload: boolean | undefined, distance: DistanceKind, dimension: number, uid: string): Promise<Array<{
+    id: string;
+    score: number;
+    payload?: Record<string, unknown>;
+}>>;
+export declare function deletePointsOneTable(tableName: string, ids: Array<string | number>, uid: string): Promise<number>;

package/dist/repositories/pointsRepo.one-table.js

@@ -0,0 +1,111 @@
+import { TypedValues, withSession } from "../ydb/client.js";
+import { buildJsonOrEmpty, buildVectorParam } from "../ydb/helpers.js";
+import { notifyUpsert } from "../indexing/IndexScheduler.js";
+import { mapDistanceToKnnFn } from "../utils/distance.js";
+import { withRetry, isTransientYdbError } from "../utils/retry.js";
+export async function upsertPointsOneTable(tableName, points, dimension, uid) {
+    let upserted = 0;
+    await withSession(async (s) => {
+        for (const p of points) {
+            const id = String(p.id);
+            if (p.vector.length !== dimension) {
+                throw new Error(`Vector dimension mismatch for id=${id}: got ${p.vector.length}, expected ${dimension}`);
+            }
+            const ddl = `
+        DECLARE $uid AS Utf8;
+        DECLARE $id AS Utf8;
+        DECLARE $vec AS List<Float>;
+        DECLARE $payload AS JsonDocument;
+        UPSERT INTO ${tableName} (uid, point_id, embedding, payload)
+        VALUES (
+          $uid,
+          $id,
+          Untag(Knn::ToBinaryStringFloat($vec), "FloatVector"),
+          $payload
+        );
+      `;
+            const params = {
+                $uid: TypedValues.utf8(uid),
+                $id: TypedValues.utf8(id),
+                $vec: buildVectorParam(p.vector),
+                $payload: buildJsonOrEmpty(p.payload),
+            };
+            await withRetry(() => s.executeQuery(ddl, params), {
+                isTransient: isTransientYdbError,
+                context: { tableName, id },
+            });
+            upserted += 1;
+        }
+    });
+    notifyUpsert(tableName, upserted);
+    return upserted;
+}
+export async function searchPointsOneTable(tableName, queryVector, top, withPayload, distance, dimension, uid) {
+    if (queryVector.length !== dimension) {
+        throw new Error(`Vector dimension mismatch: got ${queryVector.length}, expected ${dimension}`);
+    }
+    const { fn, order } = mapDistanceToKnnFn(distance);
+    const qf = buildVectorParam(queryVector);
+    const params = {
+        $qf: qf,
+        $k2: TypedValues.uint32(top),
+        $uid: TypedValues.utf8(uid),
+    };
+    const query = `
+    DECLARE $qf AS List<Float>;
+    DECLARE $k2 AS Uint32;
+    DECLARE $uid AS Utf8;
+    $qbinf = Knn::ToBinaryStringFloat($qf);
+    SELECT point_id, ${withPayload ? "payload, " : ""}${fn}(embedding, $qbinf) AS score
+    FROM ${tableName}
+    WHERE uid = $uid
+    ORDER BY score ${order}
+    LIMIT $k2;
+  `;
+    const rs = await withSession(async (s) => {
+        return await s.executeQuery(query, params);
+    });
+    const rowset = rs.resultSets?.[0];
+    const rows = (rowset?.rows ?? []);
+    return rows.map((row) => {
+        const id = row.items?.[0]?.textValue;
+        if (typeof id !== "string") {
+            throw new Error("point_id is missing in YDB search result");
+        }
+        let payload;
+        let scoreIdx = 1;
+        if (withPayload) {
+            const payloadText = row.items?.[1]?.textValue;
+            if (payloadText) {
+                try {
+                    payload = JSON.parse(payloadText);
+                }
+                catch {
+                    payload = undefined;
+                }
+            }
+            scoreIdx = 2;
+        }
+        const score = Number(row.items?.[scoreIdx]?.floatValue ?? row.items?.[scoreIdx]?.textValue);
+        return { id, score, ...(payload ? { payload } : {}) };
+    });
+}
+export async function deletePointsOneTable(tableName, ids, uid) {
+    let deleted = 0;
+    await withSession(async (s) => {
+        for (const id of ids) {
+            const yql = `
+        DECLARE $uid AS Utf8;
+        DECLARE $id AS Utf8;
+        DELETE FROM ${tableName} WHERE uid = $uid AND point_id = $id;
+      `;
+            const params = {
+                $uid: TypedValues.utf8(uid),
+                $id: TypedValues.utf8(String(id)),
+            };
+            await s.executeQuery(yql, params);
+            deleted += 1;
+        }
+    });
+    return deleted;
+}

package/dist/routes/collections.js

@@ -1,6 +1,7 @@
 import { Router } from "express";
 import { sanitizeCollectionName, sanitizeTenantId } from "../utils/tenant.js";
-import { QdrantServiceError, putCollectionIndex, createCollection, getCollection, deleteCollection, } from "../services/QdrantService.js";
+import { putCollectionIndex, createCollection, getCollection, deleteCollection, } from "../services/CollectionService.js";
+import { QdrantServiceError } from "../services/errors.js";
 import { logger } from "../logging/logger.js";
 export const collectionsRouter = Router();
 collectionsRouter.put("/:collection/index", async (req, res) => {

package/dist/routes/points.js

@@ -1,5 +1,6 @@
 import { Router } from "express";
-import { QdrantServiceError, upsertPoints, searchPoints, queryPoints, deletePoints, } from "../services/QdrantService.js";
+import { upsertPoints, searchPoints, queryPoints, deletePoints, } from "../services/PointsService.js";
+import { QdrantServiceError } from "../services/errors.js";
 import { logger } from "../logging/logger.js";
 export const pointsRouter = Router();
 // Qdrant-compatible: PUT /collections/:collection/points (upsert)

package/dist/services/CollectionService.d.ts

@@ -0,0 +1,35 @@
+import { type DistanceKind } from "../types.js";
+export interface CollectionContextInput {
+    tenant: string | undefined;
+    collection: string;
+}
+export interface NormalizedCollectionContext {
+    tenant: string;
+    collection: string;
+    metaKey: string;
+}
+export declare function normalizeCollectionContext(input: CollectionContextInput): NormalizedCollectionContext;
+export declare function resolvePointsTableAndUid(ctx: NormalizedCollectionContext, meta: {
+    table: string;
+}): Promise<{
+    tableName: string;
+    uid: string | undefined;
+}>;
+export declare function putCollectionIndex(ctx: CollectionContextInput): Promise<{
+    acknowledged: boolean;
+}>;
+export declare function createCollection(ctx: CollectionContextInput, body: unknown): Promise<{
+    name: string;
+    tenant: string;
+}>;
+export declare function getCollection(ctx: CollectionContextInput): Promise<{
+    name: string;
+    vectors: {
+        size: number;
+        distance: DistanceKind;
+        data_type: string;
+    };
+}>;
+export declare function deleteCollection(ctx: CollectionContextInput): Promise<{
+    acknowledged: boolean;
+}>;

package/dist/services/CollectionService.js

@@ -0,0 +1,85 @@
+import { CreateCollectionReq } from "../types.js";
+import { ensureMetaTable, GLOBAL_POINTS_TABLE } from "../ydb/schema.js";
+import { createCollection as repoCreateCollection, deleteCollection as repoDeleteCollection, getCollectionMeta, } from "../repositories/collectionsRepo.js";
+import { QdrantServiceError } from "./errors.js";
+import { normalizeCollectionContextShared, tableNameFor, } from "./CollectionService.shared.js";
+import { resolvePointsTableAndUidOneTable } from "./CollectionService.one-table.js";
+export function normalizeCollectionContext(input) {
+    return normalizeCollectionContextShared(input.tenant, input.collection);
+}
+export async function resolvePointsTableAndUid(ctx, meta) {
+    if (meta?.table === GLOBAL_POINTS_TABLE) {
+        return await resolvePointsTableAndUidOneTable(ctx);
+    }
+    return {
+        tableName: meta.table,
+        uid: undefined,
+    };
+}
+export async function putCollectionIndex(ctx) {
+    await ensureMetaTable();
+    const normalized = normalizeCollectionContext(ctx);
+    const meta = await getCollectionMeta(normalized.metaKey);
+    if (!meta) {
+        throw new QdrantServiceError(404, {
+            status: "error",
+            error: "collection not found",
+        });
+    }
+    return { acknowledged: true };
+}
+export async function createCollection(ctx, body) {
+    await ensureMetaTable();
+    const normalized = normalizeCollectionContext(ctx);
+    const parsed = CreateCollectionReq.safeParse(body);
+    if (!parsed.success) {
+        throw new QdrantServiceError(400, {
+            status: "error",
+            error: parsed.error.flatten(),
+        });
+    }
+    const dim = parsed.data.vectors.size;
+    const distance = parsed.data.vectors.distance;
+    const vectorType = parsed.data.vectors.data_type ?? "float";
+    const existing = await getCollectionMeta(normalized.metaKey);
+    if (existing) {
+        if (existing.dimension === dim &&
+            existing.distance === distance &&
+            existing.vectorType === vectorType) {
+            return { name: normalized.collection, tenant: normalized.tenant };
+        }
+        const errorMessage = `Collection already exists with different config: dimension=${existing.dimension}, distance=${existing.distance}, type=${existing.vectorType}`;
+        throw new QdrantServiceError(400, {
+            status: "error",
+            error: errorMessage,
+        });
+    }
+    const tableName = tableNameFor(normalized.tenant, normalized.collection);
+    await repoCreateCollection(normalized.metaKey, dim, distance, vectorType, tableName);
+    return { name: normalized.collection, tenant: normalized.tenant };
+}
+export async function getCollection(ctx) {
+    await ensureMetaTable();
+    const normalized = normalizeCollectionContext(ctx);
+    const meta = await getCollectionMeta(normalized.metaKey);
+    if (!meta) {
+        throw new QdrantServiceError(404, {
+            status: "error",
+            error: "collection not found",
+        });
+    }
+    return {
+        name: normalized.collection,
+        vectors: {
+            size: meta.dimension,
+            distance: meta.distance,
+            data_type: meta.vectorType,
+        },
+    };
+}
+export async function deleteCollection(ctx) {
+    await ensureMetaTable();
+    const normalized = normalizeCollectionContext(ctx);
+    await repoDeleteCollection(normalized.metaKey);
+    return { acknowledged: true };
+}

package/dist/services/CollectionService.multi-table.d.ts

@@ -0,0 +1,5 @@
+import { type NormalizedCollectionContextLike } from "./CollectionService.shared.js";
+export declare function resolvePointsTableAndUidMultiTable(ctx: NormalizedCollectionContextLike): {
+    tableName: string;
+    uid: string | undefined;
+};

package/dist/services/CollectionService.multi-table.js

@@ -0,0 +1,7 @@
+import { tableNameFor, } from "./CollectionService.shared.js";
+export function resolvePointsTableAndUidMultiTable(ctx) {
+    return {
+        tableName: tableNameFor(ctx.tenant, ctx.collection),
+        uid: undefined,
+    };
+}

package/dist/services/CollectionService.one-table.d.ts

@@ -0,0 +1,5 @@
+import { type NormalizedCollectionContextLike } from "./CollectionService.shared.js";
+export declare function resolvePointsTableAndUidOneTable(ctx: NormalizedCollectionContextLike): Promise<{
+    tableName: string;
+    uid: string | undefined;
+}>;

package/dist/services/CollectionService.one-table.js

@@ -0,0 +1,9 @@
+import { uidFor, } from "./CollectionService.shared.js";
+import { GLOBAL_POINTS_TABLE, ensureGlobalPointsTable } from "../ydb/schema.js";
+export async function resolvePointsTableAndUidOneTable(ctx) {
+    await ensureGlobalPointsTable();
+    return {
+        tableName: GLOBAL_POINTS_TABLE,
+        uid: uidFor(ctx.tenant, ctx.collection),
+    };
+}

package/dist/services/CollectionService.shared.d.ts

@@ -0,0 +1,11 @@
+export interface NormalizedCollectionContextLike {
+    tenant: string;
+    collection: string;
+}
+export declare function tableNameFor(tenantId: string, collection: string): string;
+export declare function uidFor(tenantId: string, collection: string): string;
+export declare function normalizeCollectionContextShared(tenant: string | undefined, collection: string): {
+    tenant: string;
+    collection: string;
+    metaKey: string;
+};

package/dist/services/CollectionService.shared.js

@@ -0,0 +1,17 @@
+import { sanitizeCollectionName, sanitizeTenantId, metaKeyFor, tableNameFor as tableNameForInternal, uidFor as uidForInternal, } from "../utils/tenant.js";
+export function tableNameFor(tenantId, collection) {
+    return tableNameForInternal(tenantId, collection);
+}
+export function uidFor(tenantId, collection) {
+    return uidForInternal(tenantId, collection);
+}
+export function normalizeCollectionContextShared(tenant, collection) {
+    const normalizedTenant = sanitizeTenantId(tenant);
+    const normalizedCollection = sanitizeCollectionName(collection);
+    const metaKey = metaKeyFor(normalizedTenant, normalizedCollection);
+    return {
+        tenant: normalizedTenant,
+        collection: normalizedCollection,
+        metaKey,
+    };
+}

package/dist/services/PointsService.d.ts

@@ -0,0 +1,23 @@
+import { type CollectionContextInput } from "./CollectionService.js";
+type PointsContextInput = CollectionContextInput;
+export declare function upsertPoints(ctx: PointsContextInput, body: unknown): Promise<{
+    upserted: number;
+}>;
+export declare function searchPoints(ctx: PointsContextInput, body: unknown): Promise<{
+    points: Array<{
+        id: string;
+        score: number;
+        payload?: Record<string, unknown>;
+    }>;
+}>;
+export declare function queryPoints(ctx: PointsContextInput, body: unknown): Promise<{
+    points: Array<{
+        id: string;
+        score: number;
+        payload?: Record<string, unknown>;
+    }>;
+}>;
+export declare function deletePoints(ctx: PointsContextInput, body: unknown): Promise<{
+    deleted: number;
+}>;
+export {};