ydb-qdrant 7.0.1 → 8.1.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 >=20.19.0
+- Node.js 18+
 - A YDB endpoint and database path
 - One of the supported auth methods (via environment)
 
@@ -54,7 +54,7 @@ npm install
 ```
 
 ## Configure credentials
-The server resolves credentials via `@ydbjs/auth` (plus a service-account key-file provider) and supports these env vars (first match wins):
+The server uses `getCredentialsFromEnv()` and supports these env vars (first match wins):
 
 - Service account key file (recommended)
   ```bash

package/dist/config/env.d.ts

@@ -3,14 +3,6 @@ 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 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"

package/dist/config/env.js

@@ -1,5 +1,4 @@
 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;
@@ -21,32 +20,6 @@ function parseIntegerEnv(value, defaultValue, opts) {
     }
     return result;
 }
-function parseBooleanEnv(value, defaultValue) {
-    if (value === undefined) {
-        return defaultValue;
-    }
-    const normalized = value.trim().toLowerCase();
-    if (normalized === "" ||
-        normalized === "0" ||
-        normalized === "false" ||
-        normalized === "no" ||
-        normalized === "off") {
-        return false;
-    }
-    return true;
-}
-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";
@@ -79,6 +52,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, 20000, { min: 1000 });
-export const SEARCH_OPERATION_TIMEOUT_MS = parseIntegerEnv(process.env.YDB_QDRANT_SEARCH_TIMEOUT_MS, 20000, { 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 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,8 +1,9 @@
-import type { CredentialsProvider } from "@ydbjs/auth";
+import type { IAuthService } from "ydb-sdk";
 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";
 export { CreateCollectionReq, UpsertPointsReq, SearchReq, DeletePointsReq, } from "../types.js";
+export type { UpsertPointsBody, SearchPointsBody } from "../types.js";
 type CreateCollectionResult = Awaited<ReturnType<typeof serviceCreateCollection>>;
 type GetCollectionResult = Awaited<ReturnType<typeof serviceGetCollection>>;
 type DeleteCollectionResult = Awaited<ReturnType<typeof serviceDeleteCollection>>;
@@ -15,14 +16,16 @@ export interface YdbQdrantClientOptions {
     endpoint?: string;
     database?: string;
     connectionString?: string;
-    credentialsProvider?: CredentialsProvider;
+    authService?: IAuthService;
 }
 export interface YdbQdrantTenantClient {
     createCollection(collection: string, body: unknown): Promise<CreateCollectionResult>;
     getCollection(collection: string): Promise<GetCollectionResult>;
     deleteCollection(collection: string): Promise<DeleteCollectionResult>;
     putCollectionIndex(collection: string): Promise<PutIndexResult>;
+    upsertPoints(collection: string, body: import("../types.js").UpsertPointsBody): Promise<UpsertPointsResult>;
     upsertPoints(collection: string, body: unknown): Promise<UpsertPointsResult>;
+    searchPoints(collection: string, body: import("../types.js").SearchPointsBody): Promise<SearchPointsResult>;
     searchPoints(collection: string, body: unknown): Promise<SearchPointsResult>;
     deletePoints(collection: string, body: unknown): Promise<DeletePointsResult>;
 }

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.credentialsProvider !== undefined) {
+        options.authService !== undefined) {
         configureDriver({
             endpoint: options.endpoint,
             database: options.database,
             connectionString: options.connectionString,
-            credentialsProvider: options.credentialsProvider,
+            authService: options.authService,
         });
     }
     await readyOrThrow();

package/dist/qdrant/QdrantRestTypes.d.ts

@@ -0,0 +1,35 @@
+import type { Schemas } from "@qdrant/js-client-rest";
+/**
+ * Type-only surface derived from Qdrant's official REST OpenAPI schema.
+ *
+ * Important:
+ * - This module must remain type-only (no runtime imports/exports from @qdrant/*).
+ * - Prefer referencing these aliases across the codebase to keep our shapes aligned
+ *   with upstream Qdrant where appropriate, while preserving our runtime behavior.
+ */
+export type QdrantSchemas = Schemas;
+export type QdrantDistance = Schemas["Distance"];
+export type QdrantExtendedPointId = Schemas["ExtendedPointId"];
+export type QdrantPayload = Schemas["Payload"];
+export type QdrantFilter = Schemas["Filter"];
+export type QdrantPointsSelector = Schemas["PointsSelector"];
+export type QdrantPointStruct = Schemas["PointStruct"];
+export type QdrantSearchRequest = Schemas["SearchRequest"];
+export type QdrantScoredPoint = Schemas["ScoredPoint"];
+export type QdrantWithPayloadInterface = Schemas["WithPayloadInterface"];
+/**
+ * Project-specific narrowing for our Qdrant-compatible subset.
+ * These types are intentionally tighter than Qdrant's full schema.
+ */
+export type YdbQdrantPointId = Extract<QdrantExtendedPointId, string | number>;
+export type YdbQdrantVector = number[];
+export type YdbQdrantUpsertPoint = Omit<QdrantPointStruct, "id" | "vector" | "payload"> & {
+    id: YdbQdrantPointId;
+    vector: YdbQdrantVector;
+    payload?: QdrantPayload;
+};
+export type YdbQdrantScoredPoint = {
+    id: string;
+    score: QdrantScoredPoint["score"];
+    payload?: QdrantPayload;
+};

package/dist/repositories/collectionsRepo.d.ts

@@ -1,5 +1,4 @@
-import { type CollectionMeta, type DistanceKind, type VectorType } from "../types.js";
-export declare function __resetCachesForTests(): void;
+import type { DistanceKind, VectorType, CollectionMeta } from "../types";
 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,50 +1,11 @@
-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 { 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 { logger } from "../logging/logger.js";
 import { uidFor } from "../utils/tenant.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";
+import { withRetry, isTransientYdbError } from "../utils/retry.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;
@@ -63,39 +24,34 @@ 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 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 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);
     });
-    if (rows.length !== 1)
+    const rowset = res.resultSets?.[0];
+    if (!rowset || rowset.rows?.length !== 1)
         return null;
-    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 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 lastAccessedAt = typeof lastAccessRaw === "string" && lastAccessRaw.length > 0
         ? new Date(lastAccessRaw)
         : undefined;
@@ -108,35 +64,37 @@ 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 (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));
+        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);
         });
     }, {
+        isTransient: isTransientYdbError,
         maxRetries: 2,
         baseDelayMs: 200,
-        isTransient: isTransientYdbError,
-        context: {
-            operation: "verifyCollectionsQueryCompilationForStartup",
-        },
+        context: { probe: "collections_startup_compilation" },
     });
 }
 export async function deleteCollection(metaKey, uid) {
@@ -152,7 +110,6 @@ 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.
@@ -167,18 +124,20 @@ 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 (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));
+        await withSession(async (s) => {
+            const settings = createExecuteQuerySettings();
+            await s.executeQuery(qry, {
+                $collection: TypedValues.utf8(metaKey),
+                $last_accessed: TypedValues.timestamp(now),
+            }, undefined, settings);
         });
         evictOldestLastAccessEntry();
         lastAccessWriteCache.set(metaKey, nowMs);

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

@@ -1,57 +1,113 @@
-import { withSession } from "../ydb/client.js";
+import { TypedValues, Types, withSession, withQuerySession, createExecuteQuerySettings, } from "../ydb/client.js";
 import { GLOBAL_POINTS_TABLE, ensureGlobalPointsTable } from "../ydb/schema.js";
-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));
-    });
+import { upsertCollectionMeta } from "./collectionsRepo.shared.js";
+import { withRetry, isTransientYdbError } from "../utils/retry.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 = 10000;
+    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);
+    }
 }
 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();
-    await withSession(async (sql, signal) => {
-        await sql `
-      BATCH DELETE FROM ${sql.identifier(GLOBAL_POINTS_TABLE)}
-      WHERE uid = $uid;
-    `
-            .idempotent(true)
-            .timeout(UPSERT_OPERATION_TIMEOUT_MS)
-            .signal(signal)
-            .parameter("uid", new Utf8(uid));
+    const batchDeletePointsYql = `
+    DECLARE $uid AS Utf8;
+    BATCH DELETE FROM ${GLOBAL_POINTS_TABLE}
+    WHERE uid = $uid;
+  `;
+    await withRetry(async () => {
+        try {
+            await withQuerySession(async (qs) => {
+                await qs.execute({
+                    text: batchDeletePointsYql,
+                    parameters: {
+                        $uid: TypedValues.utf8(uid),
+                    },
+                });
+            });
+        }
+        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
+            // per-uid chunked deletion strategy to complete the deletion.
+            await withSession(async (s) => {
+                await deletePointsForUidInChunks(s, uid);
+            });
+        }
+    }, {
+        isTransient: isTransientYdbError,
+        context: {
+            operation: "deleteCollectionOneTable",
+            tableName: GLOBAL_POINTS_TABLE,
+            metaKey,
+            uid,
+            mode: "batch_delete",
+        },
     });
-    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));
+    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);
     });
 }

package/dist/repositories/collectionsRepo.shared.d.ts

@@ -0,0 +1,2 @@
+import type { DistanceKind, VectorType } from "../types";
+export declare function upsertCollectionMeta(metaKey: string, dim: number, distance: DistanceKind, vectorType: VectorType, tableName: string): Promise<void>;

package/dist/repositories/collectionsRepo.shared.js

@@ -0,0 +1,32 @@
+import { UPSERT_OPERATION_TIMEOUT_MS } from "../config/env.js";
+import { TypedValues, withSession, createExecuteQuerySettingsWithTimeout, } from "../ydb/client.js";
+export async function upsertCollectionMeta(metaKey, dim, distance, vectorType, tableName) {
+    const now = new Date();
+    const upsertMeta = `
+    DECLARE $collection AS Utf8;
+    DECLARE $table AS Utf8;
+    DECLARE $dim AS Uint32;
+    DECLARE $distance AS Utf8;
+    DECLARE $vtype AS Utf8;
+    DECLARE $created AS Timestamp;
+    DECLARE $last_accessed AS Timestamp;
+    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);
+  `;
+    await withSession(async (s) => {
+        const settings = createExecuteQuerySettingsWithTimeout({
+            keepInCache: true,
+            idempotent: true,
+            timeoutMs: UPSERT_OPERATION_TIMEOUT_MS,
+        });
+        await s.executeQuery(upsertMeta, {
+            $collection: TypedValues.utf8(metaKey),
+            $table: TypedValues.utf8(tableName),
+            $dim: TypedValues.uint32(dim),
+            $distance: TypedValues.utf8(distance),
+            $vtype: TypedValues.utf8(vectorType),
+            $created: TypedValues.timestamp(now),
+            $last_accessed: TypedValues.timestamp(now),
+        }, undefined, settings);
+    });
+}

package/dist/repositories/pointsRepo.d.ts

@@ -1,10 +1,6 @@
-import type { DistanceKind } from "../types";
-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?: QdrantPayload;
-}>>;
+import type { DistanceKind, UpsertPoint } from "../types.js";
+import type { YdbQdrantScoredPoint } from "../qdrant/QdrantRestTypes.js";
+export declare function upsertPoints(tableName: string, points: UpsertPoint[], 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<YdbQdrantScoredPoint[]>;
 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>;