ydb-qdrant 6.0.0 → 7.0.1

package/README.md

@@ -37,7 +37,7 @@ Architecture diagrams: [docs page](http://ydb-qdrant.tech/docs/)
 - **Evaluation, CI, and release process**: [docs/evaluation-and-ci.md](docs/evaluation-and-ci.md)
 
 ## Requirements
-- Node.js 18+
+- Node.js >=20.19.0
 - A YDB endpoint and database path
 - One of the supported auth methods (via environment)
 
@@ -54,7 +54,7 @@ npm install
 ```
 
 ## Configure credentials
-The server uses `getCredentialsFromEnv()` and supports these env vars (first match wins):
+The server resolves credentials via `@ydbjs/auth` (plus a service-account key-file provider) and supports these env vars (first match wins):
 
 - Service account key file (recommended)
   ```bash

package/dist/config/env.d.ts

@@ -3,8 +3,14 @@ export declare const YDB_ENDPOINT: string;
 export declare const YDB_DATABASE: string;
 export declare const PORT: number;
 export declare const LOG_LEVEL: string;
-export declare const GLOBAL_POINTS_AUTOMIGRATE_ENABLED: boolean;
-export declare const USE_BATCH_DELETE_FOR_COLLECTIONS: boolean;
+export declare enum QueryStatsMode {
+    None = "none",
+    Basic = "basic",
+    Full = "full",
+    Profile = "profile"
+}
+export declare const QUERY_STATS_MODE: QueryStatsMode;
+export declare const QUERY_RETRY_LOG_ENABLED: boolean;
 export declare enum SearchMode {
     Exact = "exact",
     Approximate = "approximate"
@@ -12,7 +18,6 @@ export declare enum SearchMode {
 export declare function resolveSearchMode(raw: string | undefined): SearchMode;
 export declare const SEARCH_MODE: SearchMode;
 export declare const OVERFETCH_MULTIPLIER: number;
-export declare const CLIENT_SIDE_SERIALIZATION_ENABLED: boolean;
 export declare const UPSERT_BATCH_SIZE: number;
 export declare const SESSION_POOL_MIN_SIZE: number;
 export declare const SESSION_POOL_MAX_SIZE: number;

package/dist/config/env.js

@@ -1,4 +1,5 @@
 import "dotenv/config";
+import { z } from "zod";
 export const YDB_ENDPOINT = process.env.YDB_ENDPOINT ?? "";
 export const YDB_DATABASE = process.env.YDB_DATABASE ?? "";
 export const PORT = process.env.PORT ? Number(process.env.PORT) : 8080;
@@ -34,8 +35,18 @@ function parseBooleanEnv(value, defaultValue) {
     }
     return true;
 }
-export const GLOBAL_POINTS_AUTOMIGRATE_ENABLED = parseBooleanEnv(process.env.YDB_QDRANT_GLOBAL_POINTS_AUTOMIGRATE, false);
-export const USE_BATCH_DELETE_FOR_COLLECTIONS = parseBooleanEnv(process.env.YDB_QDRANT_USE_BATCH_DELETE, false);
+export var QueryStatsMode;
+(function (QueryStatsMode) {
+    QueryStatsMode["None"] = "none";
+    QueryStatsMode["Basic"] = "basic";
+    QueryStatsMode["Full"] = "full";
+    QueryStatsMode["Profile"] = "profile";
+})(QueryStatsMode || (QueryStatsMode = {}));
+const QueryStatsModeSchema = z
+    .nativeEnum(QueryStatsMode)
+    .catch(QueryStatsMode.None);
+export const QUERY_STATS_MODE = QueryStatsModeSchema.parse(process.env.YDB_QDRANT_QUERY_STATS_MODE?.trim().toLowerCase());
+export const QUERY_RETRY_LOG_ENABLED = parseBooleanEnv(process.env.YDB_QDRANT_QUERY_RETRY_LOG, false);
 export var SearchMode;
 (function (SearchMode) {
     SearchMode["Exact"] = "exact";
@@ -57,7 +68,6 @@ function resolveSearchModeEnv() {
 }
 export const SEARCH_MODE = resolveSearchModeEnv();
 export const OVERFETCH_MULTIPLIER = parseIntegerEnv(process.env.YDB_QDRANT_OVERFETCH_MULTIPLIER, 10, { min: 1 });
-export const CLIENT_SIDE_SERIALIZATION_ENABLED = parseBooleanEnv(process.env.YDB_QDRANT_CLIENT_SIDE_SERIALIZATION_ENABLED, false);
 export const UPSERT_BATCH_SIZE = parseIntegerEnv(process.env.YDB_QDRANT_UPSERT_BATCH_SIZE, 100, { min: 1 });
 // Session pool configuration
 const RAW_SESSION_POOL_MIN_SIZE = parseIntegerEnv(process.env.YDB_SESSION_POOL_MIN_SIZE, 5, { min: 1, max: 500 });
@@ -69,6 +79,6 @@ export const SESSION_POOL_MIN_SIZE = NORMALIZED_SESSION_POOL_MIN_SIZE;
 export const SESSION_POOL_MAX_SIZE = RAW_SESSION_POOL_MAX_SIZE;
 export const SESSION_KEEPALIVE_PERIOD_MS = parseIntegerEnv(process.env.YDB_SESSION_KEEPALIVE_PERIOD_MS, 5000, { min: 1000, max: 60000 });
 export const STARTUP_PROBE_SESSION_TIMEOUT_MS = parseIntegerEnv(process.env.YDB_QDRANT_STARTUP_PROBE_SESSION_TIMEOUT_MS, 5000, { min: 1000 });
-export const UPSERT_OPERATION_TIMEOUT_MS = parseIntegerEnv(process.env.YDB_QDRANT_UPSERT_TIMEOUT_MS, 5000, { min: 1000 });
-export const SEARCH_OPERATION_TIMEOUT_MS = parseIntegerEnv(process.env.YDB_QDRANT_SEARCH_TIMEOUT_MS, 10000, { min: 1000 });
+export const UPSERT_OPERATION_TIMEOUT_MS = parseIntegerEnv(process.env.YDB_QDRANT_UPSERT_TIMEOUT_MS, 20000, { min: 1000 });
+export const SEARCH_OPERATION_TIMEOUT_MS = parseIntegerEnv(process.env.YDB_QDRANT_SEARCH_TIMEOUT_MS, 20000, { min: 1000 });
 export const LAST_ACCESS_MIN_WRITE_INTERVAL_MS = parseIntegerEnv(process.env.YDB_QDRANT_LAST_ACCESS_MIN_WRITE_INTERVAL_MS, 60000, { min: 1000 });

package/dist/package/api.d.ts

@@ -1,4 +1,4 @@
-import type { IAuthService } from "ydb-sdk";
+import type { CredentialsProvider } from "@ydbjs/auth";
 import { createCollection as serviceCreateCollection, deleteCollection as serviceDeleteCollection, getCollection as serviceGetCollection, putCollectionIndex as servicePutCollectionIndex } from "../services/CollectionService.js";
 import { upsertPoints as serviceUpsertPoints, searchPoints as serviceSearchPoints, deletePoints as serviceDeletePoints } from "../services/PointsService.js";
 export { QdrantServiceError } from "../services/errors.js";
@@ -15,7 +15,7 @@ export interface YdbQdrantClientOptions {
     endpoint?: string;
     database?: string;
     connectionString?: string;
-    authService?: IAuthService;
+    credentialsProvider?: CredentialsProvider;
 }
 export interface YdbQdrantTenantClient {
     createCollection(collection: string, body: unknown): Promise<CreateCollectionResult>;

package/dist/package/api.js

@@ -33,12 +33,12 @@ export async function createYdbQdrantClient(options = {}) {
     if (options.endpoint !== undefined ||
         options.database !== undefined ||
         options.connectionString !== undefined ||
-        options.authService !== undefined) {
+        options.credentialsProvider !== undefined) {
         configureDriver({
             endpoint: options.endpoint,
             database: options.database,
             connectionString: options.connectionString,
-            authService: options.authService,
+            credentialsProvider: options.credentialsProvider,
         });
     }
     await readyOrThrow();

package/dist/qdrant/QdrantTypes.d.ts

@@ -0,0 +1,19 @@
+import type { Schemas } from "@qdrant/js-client-rest";
+/**
+ * Centralized Qdrant OpenAPI-derived types (via @qdrant/js-client-rest), narrowed to the
+ * subset of shapes that ydb-qdrant currently supports.
+ *
+ * Important:
+ * - Qdrant's schema types are intentionally broad (named vectors, multi-vectors, sparse vectors, inference objects).
+ * - Internally we support dense vectors only (`number[]`), so we narrow types accordingly.
+ */
+export type QdrantDistance = Schemas["Distance"];
+export type QdrantPointId = Schemas["ExtendedPointId"];
+export type QdrantDenseVector = Extract<Schemas["VectorStruct"], number[]>;
+export type QdrantPayload = Record<string, unknown>;
+export type QdrantPointStructDense = Omit<Schemas["PointStruct"], "vector" | "payload"> & {
+    vector: QdrantDenseVector;
+    payload?: QdrantPayload;
+};
+export type QdrantScoredPoint = Schemas["ScoredPoint"];
+export type QdrantQueryResponse = Schemas["QueryResponse"];

package/dist/qdrant/QdrantTypes.js

@@ -0,0 +1 @@
+export {};

package/dist/repositories/collectionsRepo.d.ts

@@ -1,4 +1,5 @@
-import type { DistanceKind, VectorType, CollectionMeta } from "../types";
+import { type CollectionMeta, type DistanceKind, type VectorType } from "../types.js";
+export declare function __resetCachesForTests(): void;
 export declare function createCollection(metaKey: string, dim: number, distance: DistanceKind, vectorType: VectorType): Promise<void>;
 export declare function getCollectionMeta(metaKey: string): Promise<CollectionMeta | null>;
 export declare function verifyCollectionsQueryCompilationForStartup(): Promise<void>;

package/dist/repositories/collectionsRepo.js

@@ -1,11 +1,50 @@
-import { TypedValues, withSession, createExecuteQuerySettings, withStartupProbeSession, createExecuteQuerySettingsWithTimeout, } from "../ydb/client.js";
-import { STARTUP_PROBE_SESSION_TIMEOUT_MS, LAST_ACCESS_MIN_WRITE_INTERVAL_MS, } from "../config/env.js";
+import { withSession, withStartupProbeSession } from "../ydb/client.js";
+import { STARTUP_PROBE_SESSION_TIMEOUT_MS, UPSERT_OPERATION_TIMEOUT_MS, LAST_ACCESS_MIN_WRITE_INTERVAL_MS, } from "../config/env.js";
 import { logger } from "../logging/logger.js";
 import { uidFor } from "../utils/tenant.js";
-import { createCollectionOneTable, deleteCollectionOneTable, } from "./collectionsRepo.one-table.js";
+import { attachQueryDiagnostics } from "../ydb/QueryDiagnostics.js";
 import { withRetry, isTransientYdbError } from "../utils/retry.js";
+import { createCollectionOneTable, deleteCollectionOneTable, } from "./collectionsRepo.one-table.js";
+import { Timestamp, Utf8 } from "@ydbjs/value/primitive";
+import { DistanceKindSchema, VectorTypeSchema, } from "../types.js";
 const lastAccessWriteCache = new Map();
 const LAST_ACCESS_CACHE_MAX_SIZE = 10000;
+const collectionMetaCache = new Map();
+const COLLECTION_META_CACHE_MAX_SIZE = 10000;
+// Meta lookups are on the hot path for *every* request (upsert/search/delete).
+// Under sustained ingestion, YDB can get busy and even a single-row SELECT can stall.
+// Keep meta cached long enough to avoid turning that into a constant DB read load.
+const COLLECTION_META_CACHE_TTL_MS = 5 * 60_000;
+function evictOldestCollectionMetaEntry() {
+    if (collectionMetaCache.size < COLLECTION_META_CACHE_MAX_SIZE) {
+        return;
+    }
+    const oldestKey = collectionMetaCache.keys().next().value;
+    if (oldestKey !== undefined) {
+        collectionMetaCache.delete(oldestKey);
+    }
+}
+function getCachedCollectionMeta(metaKey) {
+    const entry = collectionMetaCache.get(metaKey);
+    if (!entry)
+        return null;
+    if (Date.now() >= entry.expiresAtMs) {
+        collectionMetaCache.delete(metaKey);
+        return null;
+    }
+    return entry.meta;
+}
+function setCachedCollectionMeta(metaKey, meta) {
+    evictOldestCollectionMetaEntry();
+    collectionMetaCache.set(metaKey, {
+        meta,
+        expiresAtMs: Date.now() + COLLECTION_META_CACHE_TTL_MS,
+    });
+}
+// Test-only: keep repository unit tests isolated since this module maintains in-memory caches.
+export function __resetCachesForTests() {
+    collectionMetaCache.clear();
+}
 function evictOldestLastAccessEntry() {
     if (lastAccessWriteCache.size < LAST_ACCESS_CACHE_MAX_SIZE) {
         return;
@@ -24,34 +63,39 @@ function shouldWriteLastAccess(nowMs, key) {
 }
 export async function createCollection(metaKey, dim, distance, vectorType) {
     await createCollectionOneTable(metaKey, dim, distance, vectorType);
+    collectionMetaCache.delete(metaKey);
 }
 export async function getCollectionMeta(metaKey) {
-    const qry = `
-    DECLARE $collection AS Utf8;
-    SELECT
-      table_name,
-      vector_dimension,
-      distance,
-      vector_type,
-      CAST(last_accessed_at AS Utf8) AS last_accessed_at
-    FROM qdr__collections
-    WHERE collection = $collection;
-  `;
-    const res = await withSession(async (s) => {
-        const settings = createExecuteQuerySettings();
-        return await s.executeQuery(qry, {
-            $collection: TypedValues.utf8(metaKey),
-        }, undefined, settings);
+    const cached = getCachedCollectionMeta(metaKey);
+    if (cached) {
+        return cached;
+    }
+    const [rows] = await withSession(async (sql, signal) => {
+        const q = attachQueryDiagnostics(sql `
+      SELECT
+        table_name,
+        vector_dimension,
+        distance,
+        vector_type,
+        CAST(last_accessed_at AS Utf8) AS last_accessed_at
+      FROM qdr__collections
+      WHERE collection = $collection;
+    `, { operation: "getCollectionMeta", metaKey })
+            .idempotent(true)
+            // Collection metadata is required for upserts as well; use the more forgiving timeout.
+            .timeout(UPSERT_OPERATION_TIMEOUT_MS)
+            .signal(signal)
+            .parameter("collection", new Utf8(metaKey));
+        return await q;
     });
-    const rowset = res.resultSets?.[0];
-    if (!rowset || rowset.rows?.length !== 1)
+    if (rows.length !== 1)
         return null;
-    const row = rowset.rows[0];
-    const table = row.items?.[0]?.textValue;
-    const dimension = Number(row.items?.[1]?.uint32Value ?? row.items?.[1]?.textValue);
-    const distance = row.items?.[2]?.textValue ?? "Cosine";
-    const vectorType = row.items?.[3]?.textValue ?? "float";
-    const lastAccessRaw = row.items?.[4]?.textValue;
+    const row = rows[0];
+    const table = row.table_name;
+    const dimension = Number(row.vector_dimension);
+    const distance = DistanceKindSchema.catch("Cosine").parse(row.distance);
+    const vectorType = VectorTypeSchema.catch("float").parse(row.vector_type);
+    const lastAccessRaw = row.last_accessed_at;
     const lastAccessedAt = typeof lastAccessRaw === "string" && lastAccessRaw.length > 0
         ? new Date(lastAccessRaw)
         : undefined;
@@ -64,37 +108,35 @@ export async function getCollectionMeta(metaKey) {
     if (lastAccessedAt) {
         result.lastAccessedAt = lastAccessedAt;
     }
+    setCachedCollectionMeta(metaKey, result);
     return result;
 }
 export async function verifyCollectionsQueryCompilationForStartup() {
     const probeKey = "__startup_probe__/__startup_probe__";
-    const qry = `
-    DECLARE $collection AS Utf8;
-    SELECT
-      table_name,
-      vector_dimension,
-      distance,
-      vector_type,
-      CAST(last_accessed_at AS Utf8) AS last_accessed_at
-    FROM qdr__collections
-    WHERE collection = $collection;
-  `;
     await withRetry(async () => {
-        await withStartupProbeSession(async (s) => {
-            const settings = createExecuteQuerySettingsWithTimeout({
-                keepInCache: true,
-                idempotent: true,
-                timeoutMs: STARTUP_PROBE_SESSION_TIMEOUT_MS,
-            });
-            await s.executeQuery(qry, {
-                $collection: TypedValues.utf8(probeKey),
-            }, undefined, settings);
+        await withStartupProbeSession(async (sql, signal) => {
+            await sql `
+          SELECT
+            table_name,
+            vector_dimension,
+            distance,
+            vector_type,
+            CAST(last_accessed_at AS Utf8) AS last_accessed_at
+          FROM qdr__collections
+          WHERE collection = $collection;
+        `
+                .idempotent(true)
+                .timeout(STARTUP_PROBE_SESSION_TIMEOUT_MS)
+                .signal(signal)
+                .parameter("collection", new Utf8(probeKey));
         });
     }, {
-        isTransient: isTransientYdbError,
         maxRetries: 2,
         baseDelayMs: 200,
-        context: { probe: "collections_startup_compilation" },
+        isTransient: isTransientYdbError,
+        context: {
+            operation: "verifyCollectionsQueryCompilationForStartup",
+        },
     });
 }
 export async function deleteCollection(metaKey, uid) {
@@ -110,6 +152,7 @@ export async function deleteCollection(metaKey, uid) {
         effectiveUid = uidFor(tenant, collection);
     }
     await deleteCollectionOneTable(metaKey, effectiveUid);
+    collectionMetaCache.delete(metaKey);
 }
 /**
  * Best-effort metadata update for a collection's last_accessed_at timestamp.
@@ -124,20 +167,18 @@ export async function touchCollectionLastAccess(metaKey, now = new Date()) {
     if (!shouldWriteLastAccess(nowMs, metaKey)) {
         return;
     }
-    const qry = `
-    DECLARE $collection AS Utf8;
-    DECLARE $last_accessed AS Timestamp;
-    UPDATE qdr__collections
-    SET last_accessed_at = $last_accessed
-    WHERE collection = $collection;
-  `;
     try {
-        await withSession(async (s) => {
-            const settings = createExecuteQuerySettings();
-            await s.executeQuery(qry, {
-                $collection: TypedValues.utf8(metaKey),
-                $last_accessed: TypedValues.timestamp(now),
-            }, undefined, settings);
+        await withSession(async (sql, signal) => {
+            await sql `
+        UPDATE qdr__collections
+        SET last_accessed_at = $last_accessed
+        WHERE collection = $collection;
+      `
+                .idempotent(true)
+                .timeout(UPSERT_OPERATION_TIMEOUT_MS)
+                .signal(signal)
+                .parameter("collection", new Utf8(metaKey))
+                .parameter("last_accessed", new Timestamp(now));
         });
         evictOldestLastAccessEntry();
         lastAccessWriteCache.set(metaKey, nowMs);

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

@@ -1,139 +1,57 @@
-import { TypedValues, Types, withSession, createExecuteQuerySettings, } from "../ydb/client.js";
+import { withSession } from "../ydb/client.js";
 import { GLOBAL_POINTS_TABLE, ensureGlobalPointsTable } from "../ydb/schema.js";
-import { upsertCollectionMeta } from "./collectionsRepo.shared.js";
-import { withRetry, isTransientYdbError } from "../utils/retry.js";
-import { USE_BATCH_DELETE_FOR_COLLECTIONS } from "../config/env.js";
-const DELETE_COLLECTION_BATCH_SIZE = 10000;
-function isOutOfBufferMemoryYdbError(error) {
-    const msg = error instanceof Error ? error.message : String(error);
-    if (/Out of buffer memory/i.test(msg)) {
-        return true;
-    }
-    if (typeof error === "object" && error !== null) {
-        const issues = error.issues;
-        if (issues !== undefined) {
-            const issuesText = typeof issues === "string" ? issues : JSON.stringify(issues);
-            return /Out of buffer memory/i.test(issuesText);
-        }
-    }
-    return false;
-}
-async function deletePointsForUidInChunks(s, uid) {
-    const selectYql = `
-    DECLARE $uid AS Utf8;
-    DECLARE $limit AS Uint32;
-    SELECT point_id
-    FROM ${GLOBAL_POINTS_TABLE}
-    WHERE uid = $uid
-    LIMIT $limit;
-  `;
-    const deleteBatchYql = `
-    DECLARE $uid AS Utf8;
-    DECLARE $ids AS List<Utf8>;
-    DELETE FROM ${GLOBAL_POINTS_TABLE}
-    WHERE uid = $uid AND point_id IN $ids;
-  `;
-    // Best‑effort loop: stop when there are no more rows for this uid.
-    // Each iteration only touches a limited number of rows to avoid
-    // hitting YDB's per‑operation buffer limits.
-    let iterations = 0;
-    const MAX_ITERATIONS = 1000;
-    const settings = createExecuteQuerySettings();
-    while (iterations++ < MAX_ITERATIONS) {
-        const rs = (await s.executeQuery(selectYql, {
-            $uid: TypedValues.utf8(uid),
-            $limit: TypedValues.uint32(DELETE_COLLECTION_BATCH_SIZE),
-        }, undefined, settings));
-        const rowset = rs.resultSets?.[0];
-        const rows = rowset?.rows ?? [];
-        const ids = rows
-            .map((row) => row.items?.[0]?.textValue)
-            .filter((id) => typeof id === "string");
-        if (ids.length === 0) {
-            break;
-        }
-        const idsValue = TypedValues.list(Types.UTF8, ids);
-        await s.executeQuery(deleteBatchYql, {
-            $uid: TypedValues.utf8(uid),
-            $ids: idsValue,
-        }, undefined, settings);
-    }
+import { UPSERT_OPERATION_TIMEOUT_MS } from "../config/env.js";
+import { Timestamp, Uint32, Utf8 } from "@ydbjs/value/primitive";
+async function upsertCollectionMeta(metaKey, dim, distance, vectorType, tableName) {
+    const now = new Date();
+    await withSession(async (sql, signal) => {
+        await sql `
+      UPSERT INTO qdr__collections (
+        collection,
+        table_name,
+        vector_dimension,
+        distance,
+        vector_type,
+        created_at,
+        last_accessed_at
+      )
+      VALUES ($collection, $table, $dim, $distance, $vtype, $created, $last_accessed);
+    `
+            .idempotent(true)
+            .timeout(UPSERT_OPERATION_TIMEOUT_MS)
+            .signal(signal)
+            .parameter("collection", new Utf8(metaKey))
+            .parameter("table", new Utf8(tableName))
+            .parameter("dim", new Uint32(dim))
+            .parameter("distance", new Utf8(distance))
+            .parameter("vtype", new Utf8(vectorType))
+            .parameter("created", new Timestamp(now))
+            .parameter("last_accessed", new Timestamp(now));
+    });
 }
 export async function createCollectionOneTable(metaKey, dim, distance, vectorType) {
     await upsertCollectionMeta(metaKey, dim, distance, vectorType, GLOBAL_POINTS_TABLE);
 }
 export async function deleteCollectionOneTable(metaKey, uid) {
     await ensureGlobalPointsTable();
-    if (USE_BATCH_DELETE_FOR_COLLECTIONS) {
-        const batchDeletePointsYql = `
-      DECLARE $uid AS Utf8;
-      BATCH DELETE FROM ${GLOBAL_POINTS_TABLE}
+    await withSession(async (sql, signal) => {
+        await sql `
+      BATCH DELETE FROM ${sql.identifier(GLOBAL_POINTS_TABLE)}
       WHERE uid = $uid;
-    `;
-        await withRetry(() => withSession(async (s) => {
-            const settings = createExecuteQuerySettings();
-            try {
-                await s.executeQuery(batchDeletePointsYql, {
-                    $uid: TypedValues.utf8(uid),
-                }, undefined, settings);
-            }
-            catch (err) {
-                if (!isOutOfBufferMemoryYdbError(err)) {
-                    throw err;
-                }
-                // BATCH DELETE already deletes in chunks per partition, but if YDB
-                // still reports an out-of-buffer-memory condition, fall back to
-                // the same per-uid chunked deletion strategy as the legacy path.
-                await deletePointsForUidInChunks(s, uid);
-            }
-        }), {
-            isTransient: isTransientYdbError,
-            context: {
-                operation: "deleteCollectionOneTable",
-                tableName: GLOBAL_POINTS_TABLE,
-                metaKey,
-                uid,
-                mode: "batch_delete",
-            },
-        });
-    }
-    else {
-        const deletePointsYql = `
-      DECLARE $uid AS Utf8;
-      DELETE FROM ${GLOBAL_POINTS_TABLE} WHERE uid = $uid;
-    `;
-        await withRetry(() => withSession(async (s) => {
-            const settings = createExecuteQuerySettings();
-            try {
-                await s.executeQuery(deletePointsYql, {
-                    $uid: TypedValues.utf8(uid),
-                }, undefined, settings);
-            }
-            catch (err) {
-                if (!isOutOfBufferMemoryYdbError(err)) {
-                    throw err;
-                }
-                await deletePointsForUidInChunks(s, uid);
-            }
-        }), {
-            isTransient: isTransientYdbError,
-            context: {
-                operation: "deleteCollectionOneTable",
-                tableName: GLOBAL_POINTS_TABLE,
-                metaKey,
-                uid,
-                mode: "legacy_chunked",
-            },
-        });
-    }
-    const delMeta = `
-    DECLARE $collection AS Utf8;
-    DELETE FROM qdr__collections WHERE collection = $collection;
-  `;
-    await withSession(async (s) => {
-        const settings = createExecuteQuerySettings();
-        await s.executeQuery(delMeta, {
-            $collection: TypedValues.utf8(metaKey),
-        }, undefined, settings);
+    `
+            .idempotent(true)
+            .timeout(UPSERT_OPERATION_TIMEOUT_MS)
+            .signal(signal)
+            .parameter("uid", new Utf8(uid));
+    });
+    await withSession(async (sql, signal) => {
+        await sql `
+      DELETE FROM qdr__collections
+      WHERE collection = $collection;
+    `
+            .idempotent(true)
+            .timeout(UPSERT_OPERATION_TIMEOUT_MS)
+            .signal(signal)
+            .parameter("collection", new Utf8(metaKey));
     });
 }

package/dist/repositories/pointsRepo.d.ts

@@ -1,12 +1,10 @@
 import type { DistanceKind } from "../types";
-export declare function upsertPoints(tableName: string, points: Array<{
-    id: string | number;
-    vector: number[];
-    payload?: Record<string, unknown>;
-}>, dimension: number, uid: string): Promise<number>;
-export declare function searchPoints(tableName: string, queryVector: number[], top: number, withPayload: boolean | undefined, distance: DistanceKind, dimension: number, uid: string): Promise<Array<{
+import type { QdrantPayload, QdrantPointStructDense } from "../qdrant/QdrantTypes.js";
+export declare function upsertPoints(tableName: string, points: QdrantPointStructDense[], dimension: number, uid: string): Promise<number>;
+export declare function searchPoints(tableName: string, queryVector: number[], top: number, withPayload: boolean | undefined, distance: DistanceKind, dimension: number, uid: string, filterPaths?: Array<Array<string>>): Promise<Array<{
     id: string;
     score: number;
-    payload?: Record<string, unknown>;
+    payload?: QdrantPayload;
 }>>;
 export declare function deletePoints(tableName: string, ids: Array<string | number>, uid: string): Promise<number>;
+export declare function deletePointsByPathSegments(tableName: string, uid: string, paths: Array<Array<string>>): Promise<number>;

package/dist/repositories/pointsRepo.js

@@ -1,12 +1,15 @@
 import { SEARCH_MODE, OVERFETCH_MULTIPLIER, } from "../config/env.js";
-import { upsertPointsOneTable, searchPointsOneTable, deletePointsOneTable, } from "./pointsRepo.one-table.js";
+import { upsertPointsOneTable, searchPointsOneTable, deletePointsOneTable, deletePointsByPathSegmentsOneTable, } from "./pointsRepo.one-table.js";
 export async function upsertPoints(tableName, points, dimension, uid) {
     return await upsertPointsOneTable(tableName, points, dimension, uid);
 }
-export async function searchPoints(tableName, queryVector, top, withPayload, distance, dimension, uid) {
+export async function searchPoints(tableName, queryVector, top, withPayload, distance, dimension, uid, filterPaths) {
     const mode = SEARCH_MODE;
-    return await searchPointsOneTable(tableName, queryVector, top, withPayload, distance, dimension, uid, mode, OVERFETCH_MULTIPLIER);
+    return await searchPointsOneTable(tableName, queryVector, top, withPayload, distance, dimension, uid, mode, OVERFETCH_MULTIPLIER, filterPaths);
 }
 export async function deletePoints(tableName, ids, uid) {
     return await deletePointsOneTable(tableName, ids, uid);
 }
+export async function deletePointsByPathSegments(tableName, uid, paths) {
+    return await deletePointsByPathSegmentsOneTable(tableName, uid, paths);
+}

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

@@ -0,0 +1,2 @@
+export declare function deletePointsOneTable(tableName: string, ids: Array<string | number>, uid: string): Promise<number>;
+export declare function deletePointsByPathSegmentsOneTable(tableName: string, uid: string, paths: Array<Array<string>>): Promise<number>;