ydb-qdrant 8.1.0 → 9.0.3

package/dist/middleware/upsertRequestTimeout.js

@@ -0,0 +1,158 @@
+import { UPSERT_BODY_TIMEOUT_MS, UPSERT_HTTP_TIMEOUT_MS, } from "../config/env.js";
+const UPSERT_REQUEST_TIMEOUT_STATE = Symbol("upsertRequestTimeoutState");
+const RETRY_AFTER_SECONDS = "1";
+const TIMEOUT_ERROR_MESSAGE = "upsert request timed out";
+const UPSERT_POINTS_PATH_RE = /^\/collections\/[^/]+\/points\/?$/;
+const UPSERT_POINTS_ALIAS_PATH_RE = /^\/collections\/[^/]+\/points\/upsert\/?$/;
+function asTimeoutAwareRequest(req) {
+    return req;
+}
+function getRequestPath(req) {
+    const originalUrl = req.originalUrl;
+    if (typeof originalUrl !== "string" || originalUrl.length === 0) {
+        return "";
+    }
+    return originalUrl.split("?", 1)[0] ?? "";
+}
+function getOrCreateTimeoutState(req) {
+    const request = asTimeoutAwareRequest(req);
+    request[UPSERT_REQUEST_TIMEOUT_STATE] ??= {
+        timedOut: false,
+    };
+    return request[UPSERT_REQUEST_TIMEOUT_STATE];
+}
+function getTimeoutState(req) {
+    return asTimeoutAwareRequest(req)[UPSERT_REQUEST_TIMEOUT_STATE];
+}
+export function isUpsertRequestTarget(req) {
+    const path = getRequestPath(req);
+    if (req.method === "PUT") {
+        return UPSERT_POINTS_PATH_RE.test(path);
+    }
+    if (req.method === "POST") {
+        return UPSERT_POINTS_ALIAS_PATH_RE.test(path);
+    }
+    return false;
+}
+export function markUpsertRequestTimedOut(req, timeoutMs, timeoutPhase) {
+    const state = getOrCreateTimeoutState(req);
+    // Preserve armed clear callbacks on the existing state object.
+    state.timedOut = true;
+    state.timeoutMs = timeoutMs;
+    state.timeoutPhase = timeoutPhase;
+}
+export function isUpsertRequestTimedOut(req) {
+    return getTimeoutState(req)?.timedOut === true;
+}
+export function getUpsertRequestTimeoutMs(req) {
+    return getTimeoutState(req)?.timeoutMs;
+}
+export function getUpsertRequestTimeoutPhase(req) {
+    return getTimeoutState(req)?.timeoutPhase;
+}
+function clearUpsertTimeout(req, phase) {
+    const state = getTimeoutState(req);
+    if (!state) {
+        return;
+    }
+    const clearFn = phase === "body" ? state.clearBodyTimeout : state.clearProcessingTimeout;
+    if (clearFn) {
+        clearFn();
+    }
+    if (phase === "body") {
+        state.clearBodyTimeout = undefined;
+        return;
+    }
+    state.clearProcessingTimeout = undefined;
+}
+function closeSocketAfterResponse(res) {
+    const socket = res.socket;
+    if (!socket || socket.destroyed) {
+        return;
+    }
+    if (typeof socket.destroySoon === "function") {
+        socket.destroySoon();
+        return;
+    }
+    socket.end();
+    const forceDestroyTimer = setTimeout(() => {
+        if (!socket.destroyed) {
+            socket.destroy();
+        }
+    }, 50);
+    forceDestroyTimer.unref?.();
+}
+export function respondUpsertRequestTimedOut(args) {
+    const state = getOrCreateTimeoutState(args.req);
+    if (args.res.headersSent || args.res.writableEnded || state.timedOut) {
+        return false;
+    }
+    clearUpsertTimeout(args.req, args.timeoutPhase === "processing" ? "processing" : "body");
+    markUpsertRequestTimedOut(args.req, args.timeoutMs, args.timeoutPhase);
+    args.res.setHeader("Retry-After", RETRY_AFTER_SECONDS);
+    args.res.setHeader("Connection", "close");
+    args.res.status(503).json({
+        status: "error",
+        error: TIMEOUT_ERROR_MESSAGE,
+    });
+    args.res.once("finish", () => {
+        closeSocketAfterResponse(args.res);
+    });
+    return true;
+}
+function installUpsertTimeout(args) {
+    if (args.timeoutMs <= 0) {
+        return;
+    }
+    const state = getOrCreateTimeoutState(args.req);
+    let timer;
+    const clearTimer = () => {
+        if (timer) {
+            clearTimeout(timer);
+            timer = undefined;
+        }
+    };
+    timer = setTimeout(() => {
+        respondUpsertRequestTimedOut(args);
+    }, args.timeoutMs);
+    timer.unref?.();
+    args.res.once("finish", clearTimer);
+    args.res.once("close", clearTimer);
+    if (args.timeoutPhase === "body") {
+        state.clearBodyTimeout = clearTimer;
+        return;
+    }
+    state.clearProcessingTimeout = clearTimer;
+}
+export function markUpsertBodyPhaseCompleted(req) {
+    clearUpsertTimeout(req, "body");
+}
+export function upsertBodyTimeout(req, res, next) {
+    if (!isUpsertRequestTarget(req)) {
+        next();
+        return;
+    }
+    installUpsertTimeout({
+        req,
+        res,
+        timeoutMs: UPSERT_BODY_TIMEOUT_MS,
+        timeoutPhase: "body",
+    });
+    next();
+}
+export function upsertProcessingTimeout(req, res, next) {
+    if (!isUpsertRequestTarget(req)) {
+        next();
+        return;
+    }
+    if (res.headersSent || res.writableEnded) {
+        return;
+    }
+    installUpsertTimeout({
+        req,
+        res,
+        timeoutMs: UPSERT_HTTP_TIMEOUT_MS,
+        timeoutPhase: "processing",
+    });
+    next();
+}

package/dist/package/api.d.ts

@@ -1,9 +1,10 @@
 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";
+import { upsertPoints as serviceUpsertPoints, searchPoints as serviceSearchPoints, deletePoints as serviceDeletePoints, retrievePoints as serviceRetrievePoints } 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";
+export { CreateCollectionReq, UpsertPointsReq, SearchReq, DeletePointsReq, RetrievePointsReq, } from "../qdrant/Requests.js";
+export type { UpsertPointsBody, SearchPointsBody } from "../qdrant/Requests.js";
+import type { UpsertPointsBody, SearchPointsBody } from "../qdrant/Requests.js";
 type CreateCollectionResult = Awaited<ReturnType<typeof serviceCreateCollection>>;
 type GetCollectionResult = Awaited<ReturnType<typeof serviceGetCollection>>;
 type DeleteCollectionResult = Awaited<ReturnType<typeof serviceDeleteCollection>>;
@@ -11,25 +12,32 @@ type PutIndexResult = Awaited<ReturnType<typeof servicePutCollectionIndex>>;
 type UpsertPointsResult = Awaited<ReturnType<typeof serviceUpsertPoints>>;
 type SearchPointsResult = Awaited<ReturnType<typeof serviceSearchPoints>>;
 type DeletePointsResult = Awaited<ReturnType<typeof serviceDeletePoints>>;
-export interface YdbQdrantClientOptions {
-    defaultTenant?: string;
+type RetrievePointsResult = Awaited<ReturnType<typeof serviceRetrievePoints>>;
+type YdbQdrantClientDriverOptions = {
     endpoint?: string;
     database?: string;
     connectionString?: string;
     authService?: IAuthService;
-}
-export interface YdbQdrantTenantClient {
+};
+type YdbQdrantClientApiKeyOptions = YdbQdrantClientDriverOptions & {
+    apiKey: string;
+    userUid?: never;
+};
+type YdbQdrantClientUserUidOptions = YdbQdrantClientDriverOptions & {
+    userUid: string;
+    apiKey?: never;
+};
+export type YdbQdrantClientOptions = YdbQdrantClientApiKeyOptions | YdbQdrantClientUserUidOptions;
+export interface YdbQdrantClient {
     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: UpsertPointsBody): Promise<UpsertPointsResult>;
     upsertPoints(collection: string, body: unknown): Promise<UpsertPointsResult>;
-    searchPoints(collection: string, body: import("../types.js").SearchPointsBody): Promise<SearchPointsResult>;
+    searchPoints(collection: string, body: SearchPointsBody): Promise<SearchPointsResult>;
     searchPoints(collection: string, body: unknown): Promise<SearchPointsResult>;
     deletePoints(collection: string, body: unknown): Promise<DeletePointsResult>;
-}
-export interface YdbQdrantClient extends YdbQdrantTenantClient {
-    forTenant(tenant: string): YdbQdrantTenantClient;
+    retrievePoints(collection: string, body: unknown): Promise<RetrievePointsResult>;
 }
 export declare function createYdbQdrantClient(options?: YdbQdrantClientOptions): Promise<YdbQdrantClient>;

package/dist/package/api.js

@@ -1,55 +1,84 @@
 import { readyOrThrow, configureDriver } from "../ydb/client.js";
 import { ensureMetaTable } from "../ydb/schema.js";
 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";
+import { upsertPoints as serviceUpsertPoints, searchPoints as serviceSearchPoints, deletePoints as serviceDeletePoints, retrievePoints as serviceRetrievePoints, } from "../services/PointsService.js";
+import { deriveUserUidFromApiKey } from "../utils/tenant.js";
 export { QdrantServiceError } from "../services/errors.js";
-export { CreateCollectionReq, UpsertPointsReq, SearchReq, DeletePointsReq, } from "../types.js";
-function buildTenantClient(resolveTenant) {
+export { CreateCollectionReq, UpsertPointsReq, SearchReq, DeletePointsReq, RetrievePointsReq, } from "../qdrant/Requests.js";
+function buildClient(userUid, apiKey) {
     return {
         createCollection(collection, body) {
-            return serviceCreateCollection({ tenant: resolveTenant(), collection }, body);
+            return serviceCreateCollection({ userUid, collection, apiKey }, body);
         },
         getCollection(collection) {
-            return serviceGetCollection({ tenant: resolveTenant(), collection });
+            return serviceGetCollection({
+                userUid,
+                collection,
+                apiKey,
+            });
         },
         deleteCollection(collection) {
-            return serviceDeleteCollection({ tenant: resolveTenant(), collection });
+            return serviceDeleteCollection({
+                userUid,
+                collection,
+                apiKey,
+            });
         },
         putCollectionIndex(collection) {
-            return servicePutCollectionIndex({ tenant: resolveTenant(), collection });
+            return servicePutCollectionIndex({
+                userUid,
+                collection,
+                apiKey,
+            });
         },
         upsertPoints(collection, body) {
-            return serviceUpsertPoints({ tenant: resolveTenant(), collection }, body);
+            return serviceUpsertPoints({ userUid, collection, apiKey }, body);
         },
         searchPoints(collection, body) {
-            return serviceSearchPoints({ tenant: resolveTenant(), collection }, body);
+            return serviceSearchPoints({ userUid, collection, apiKey }, body);
         },
         deletePoints(collection, body) {
-            return serviceDeletePoints({ tenant: resolveTenant(), collection }, body);
+            return serviceDeletePoints({ userUid, collection, apiKey }, body);
+        },
+        retrievePoints(collection, body) {
+            return serviceRetrievePoints({ userUid, collection, apiKey }, body);
         },
     };
 }
-export async function createYdbQdrantClient(options = {}) {
-    if (options.endpoint !== undefined ||
-        options.database !== undefined ||
-        options.connectionString !== undefined ||
-        options.authService !== undefined) {
+function resolveClientIdentity(options) {
+    const providedUserUid = options?.userUid?.trim();
+    const apiKey = options?.apiKey?.trim();
+    if (providedUserUid && apiKey) {
+        throw new Error("createYdbQdrantClient accepts exactly one of apiKey or userUid");
+    }
+    if (apiKey) {
+        return {
+            userUid: deriveUserUidFromApiKey(apiKey),
+            signingKey: apiKey,
+        };
+    }
+    if (providedUserUid) {
+        return {
+            userUid: providedUserUid,
+            signingKey: providedUserUid,
+        };
+    }
+    throw new Error("createYdbQdrantClient requires either userUid or apiKey");
+}
+export async function createYdbQdrantClient(options) {
+    if (options?.endpoint !== undefined ||
+        options?.database !== undefined ||
+        options?.connectionString !== undefined ||
+        options?.authService !== undefined) {
         configureDriver({
-            endpoint: options.endpoint,
-            database: options.database,
-            connectionString: options.connectionString,
-            authService: options.authService,
+            endpoint: options?.endpoint,
+            database: options?.database,
+            connectionString: options?.connectionString,
+            authService: options?.authService,
         });
     }
     await readyOrThrow();
     await ensureMetaTable();
-    const defaultTenant = options.defaultTenant ?? "default";
-    const baseClient = buildTenantClient(() => defaultTenant);
-    const client = {
-        ...baseClient,
-        forTenant(tenantId) {
-            return buildTenantClient(() => tenantId);
-        },
-    };
-    return client;
+    const { userUid, signingKey } = resolveClientIdentity(options);
+    return buildClient(userUid, signingKey);
 }

package/dist/qdrant/QdrantRestTypes.d.ts

@@ -21,6 +21,10 @@ 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 DistanceKind = QdrantDistance;
+export type VectorType = "float";
+export type Payload = QdrantPayload;
+export type WithPayload = QdrantWithPayloadInterface;
 export type YdbQdrantPointId = Extract<QdrantExtendedPointId, string | number>;
 export type YdbQdrantVector = number[];
 export type YdbQdrantUpsertPoint = Omit<QdrantPointStruct, "id" | "vector" | "payload"> & {

package/dist/qdrant/Requests.d.ts

@@ -0,0 +1,97 @@
+import { z } from "zod";
+import type { DistanceKind, Payload, WithPayload, YdbQdrantPointId, YdbQdrantUpsertPoint } from "./QdrantRestTypes.js";
+export declare const RETRIEVE_POINTS_IDS_MAX = 1000;
+export declare const CreateCollectionReq: z.ZodObject<{
+    vectors: z.ZodObject<{
+        size: z.ZodNumber;
+        distance: z.ZodType<DistanceKind>;
+        data_type: z.ZodOptional<z.ZodEnum<{
+            float: "float";
+        }>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const UpsertPointsReq: z.ZodObject<{
+    points: z.ZodArray<z.ZodObject<{
+        id: z.ZodType<YdbQdrantPointId>;
+        vector: z.ZodArray<z.ZodNumber>;
+        payload: z.ZodType<Payload | undefined>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type UpsertPoint = YdbQdrantUpsertPoint;
+export type UpsertPointsBody = {
+    points: UpsertPoint[];
+};
+export declare const SearchReq: z.ZodObject<{
+    vector: z.ZodArray<z.ZodNumber>;
+    top: z.ZodNumber;
+    with_payload: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type SearchPointsBody = {
+    vector: number[];
+    top?: number;
+    limit?: number;
+    with_payload?: WithPayload;
+    score_threshold?: number | null;
+};
+export declare const DeletePointsByIdsReq: z.ZodObject<{
+    points: z.ZodArray<z.ZodType<YdbQdrantPointId, unknown, z.core.$ZodTypeInternals<YdbQdrantPointId, unknown>>>;
+}, z.core.$strip>;
+export declare const DeletePointsByFilterReq: z.ZodObject<{
+    filter: z.ZodUnion<readonly [z.ZodObject<{
+        must: z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            match: z.ZodObject<{
+                value: z.ZodString;
+            }, z.core.$strip>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        should: z.ZodArray<z.ZodObject<{
+            must: z.ZodArray<z.ZodObject<{
+                key: z.ZodString;
+                match: z.ZodObject<{
+                    value: z.ZodString;
+                }, z.core.$strip>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        must: z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            match: z.ZodObject<{
+                value: z.ZodString;
+            }, z.core.$strip>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>]>;
+}, z.core.$strip>;
+export declare const DeletePointsReq: z.ZodUnion<readonly [z.ZodObject<{
+    points: z.ZodArray<z.ZodType<YdbQdrantPointId, unknown, z.core.$ZodTypeInternals<YdbQdrantPointId, unknown>>>;
+}, z.core.$strip>, z.ZodObject<{
+    filter: z.ZodUnion<readonly [z.ZodObject<{
+        must: z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            match: z.ZodObject<{
+                value: z.ZodString;
+            }, z.core.$strip>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        should: z.ZodArray<z.ZodObject<{
+            must: z.ZodArray<z.ZodObject<{
+                key: z.ZodString;
+                match: z.ZodObject<{
+                    value: z.ZodString;
+                }, z.core.$strip>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        must: z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            match: z.ZodObject<{
+                value: z.ZodString;
+            }, z.core.$strip>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>]>;
+}, z.core.$strip>]>;
+export declare const RetrievePointsReq: z.ZodObject<{
+    ids: z.ZodArray<z.ZodType<YdbQdrantPointId, unknown, z.core.$ZodTypeInternals<YdbQdrantPointId, unknown>>>;
+    with_payload: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    with_vector: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, z.core.$strip>;

package/dist/qdrant/Requests.js

@@ -0,0 +1,72 @@
+import { z } from "zod";
+export const RETRIEVE_POINTS_IDS_MAX = 1000;
+export const CreateCollectionReq = z.object({
+    vectors: z.object({
+        size: z.number().int().positive(),
+        distance: z.enum([
+            "Cosine",
+            "Euclid",
+            "Dot",
+            "Manhattan",
+        ]),
+        data_type: z.enum(["float"]).optional(),
+    }),
+});
+export const UpsertPointsReq = z.object({
+    points: z
+        .array(z.object({
+        id: z.union([
+            z.string(),
+            z.number(),
+        ]),
+        vector: z.array(z.number()),
+        payload: z
+            .record(z.string(), z.unknown())
+            .optional(),
+    }))
+        .min(1),
+});
+export const SearchReq = z.object({
+    vector: z.array(z.number()).min(1),
+    top: z.number().int().positive().max(1000),
+    with_payload: z.boolean().optional(),
+});
+export const DeletePointsByIdsReq = z.object({
+    points: z
+        .array(z.union([z.string(), z.number()]))
+        .min(1),
+});
+const DeletePointsFilterCondition = z.object({
+    key: z.string(),
+    match: z.object({
+        value: z.string(),
+    }),
+});
+const DeletePointsFilterMust = z.object({
+    must: z.array(DeletePointsFilterCondition).min(1),
+});
+const DeletePointsEmptyFilter = z.object({
+    must: z.array(DeletePointsFilterCondition).max(0),
+});
+const DeletePointsFilter = z.union([
+    DeletePointsFilterMust,
+    z.object({
+        should: z.array(DeletePointsFilterMust).min(1),
+    }),
+    DeletePointsEmptyFilter,
+]);
+export const DeletePointsByFilterReq = z.object({
+    filter: DeletePointsFilter,
+});
+export const DeletePointsReq = z.union([
+    DeletePointsByIdsReq,
+    DeletePointsByFilterReq,
+]);
+export const RetrievePointsReq = z.object({
+    ids: z
+        .array(z.union([z.string(), z.number()]))
+        .min(1)
+        .max(RETRIEVE_POINTS_IDS_MAX),
+    with_payload: z.boolean().optional().default(true),
+    with_vector: z.boolean().optional().default(false),
+});

package/dist/repositories/collectionsRepo.d.ts

@@ -1,8 +1,24 @@
-import type { DistanceKind, VectorType, CollectionMeta } from "../types";
-export declare function createCollection(metaKey: string, dim: number, distance: DistanceKind, vectorType: VectorType): Promise<void>;
+import type { DistanceKind, VectorType } from "../qdrant/QdrantRestTypes.js";
+/**
+ * Collection metadata from qdr__collections table.
+ *
+ * @property lastAccessedAt - Timestamp of last access; undefined for collections
+ * created before this feature, null if explicitly unset.
+ */
+export interface CollectionMeta {
+    table: string;
+    dimension: number;
+    distance: DistanceKind;
+    vectorType: VectorType;
+    lastAccessedAt?: Date | null;
+}
+export declare function createCollection(metaKey: string, dim: number, distance: DistanceKind, vectorType: VectorType, userUid?: string): Promise<void>;
 export declare function getCollectionMeta(metaKey: string): Promise<CollectionMeta | null>;
 export declare function verifyCollectionsQueryCompilationForStartup(): Promise<void>;
 export declare function deleteCollection(metaKey: string, uid?: string): Promise<void>;
+export declare function deleteAllPointsForCollection(collection: string): Promise<void>;
+export declare function hasPointsForCollection(uid: string): Promise<boolean>;
+export declare function countPointsForCollection(uid: string): Promise<number>;
 /**
  * Best-effort metadata update for a collection's last_accessed_at timestamp.
  *

package/dist/repositories/collectionsRepo.js

@@ -2,8 +2,9 @@ import { TypedValues, withSession, createExecuteQuerySettings, withStartupProbeS
 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 { createCollectionOneTable, deleteCollectionOneTable, } from "./collectionsRepo.one-table.js";
+import { createCollectionOneTable, deleteAllPointsForCollectionOneTable, deleteCollectionOneTable, } from "./collectionsRepo.one-table.js";
 import { withRetry, isTransientYdbError } from "../utils/retry.js";
+import { GLOBAL_POINTS_TABLE } from "../ydb/schema.js";
 const lastAccessWriteCache = new Map();
 const LAST_ACCESS_CACHE_MAX_SIZE = 10000;
 function evictOldestLastAccessEntry() {
@@ -22,8 +23,8 @@ function shouldWriteLastAccess(nowMs, key) {
     }
     return nowMs - last >= LAST_ACCESS_MIN_WRITE_INTERVAL_MS;
 }
-export async function createCollection(metaKey, dim, distance, vectorType) {
-    await createCollectionOneTable(metaKey, dim, distance, vectorType);
+export async function createCollection(metaKey, dim, distance, vectorType, userUid) {
+    await createCollectionOneTable(metaKey, dim, distance, vectorType, userUid);
 }
 export async function getCollectionMeta(metaKey) {
     const qry = `
@@ -49,7 +50,8 @@ export async function getCollectionMeta(metaKey) {
     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 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
@@ -103,14 +105,108 @@ export async function deleteCollection(metaKey, uid) {
         return;
     let effectiveUid = uid;
     if (!effectiveUid) {
-        const [tenant, collection] = metaKey.split("/", 2);
-        if (!tenant || !collection) {
+        const [userUid, collection] = metaKey.split("/", 2);
+        if (!userUid || !collection) {
             throw new Error(`deleteCollection: cannot derive uid from malformed metaKey=${metaKey}`);
         }
-        effectiveUid = uidFor(tenant, collection);
+        effectiveUid = uidFor(userUid, collection);
     }
     await deleteCollectionOneTable(metaKey, effectiveUid);
 }
+export async function deleteAllPointsForCollection(collection) {
+    await deleteAllPointsForCollectionOneTable(collection);
+}
+export async function hasPointsForCollection(uid) {
+    const qry = `
+    DECLARE $collection AS Utf8;
+    SELECT point_id
+    FROM ${GLOBAL_POINTS_TABLE}
+    WHERE collection = $collection
+    LIMIT 1;
+  `;
+    const res = await withSession(async (s) => {
+        const settings = createExecuteQuerySettings();
+        return await s.executeQuery(qry, {
+            $collection: TypedValues.utf8(uid),
+        }, undefined, settings);
+    });
+    const rowset = res.resultSets?.[0];
+    return (rowset?.rows?.length ?? 0) > 0;
+}
+const MAX_SAFE_BIGINT = BigInt(Number.MAX_SAFE_INTEGER);
+function bigintToSafeNumberOrNull(value) {
+    if (value > MAX_SAFE_BIGINT || value < -MAX_SAFE_BIGINT) {
+        return null;
+    }
+    return Number(value);
+}
+function longLikeToBigInt(value) {
+    const low = BigInt(value.low >>> 0);
+    const high = BigInt(value.high >>> 0);
+    let n = low + (high << 32n);
+    const isUnsigned = value.unsigned === true;
+    const signBitSet = (value.high & 0x8000_0000) !== 0;
+    if (!isUnsigned && signBitSet) {
+        n -= 1n << 64n;
+    }
+    return n;
+}
+function parsePointCountValue(value) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return value;
+    }
+    if (typeof value === "string") {
+        const parsed = Number(value);
+        if (Number.isFinite(parsed)) {
+            return parsed;
+        }
+    }
+    if (typeof value === "bigint") {
+        const parsed = bigintToSafeNumberOrNull(value);
+        if (parsed !== null) {
+            return parsed;
+        }
+    }
+    if (value && typeof value === "object") {
+        const v = value;
+        if (typeof v.low === "number" && typeof v.high === "number") {
+            const parsed = bigintToSafeNumberOrNull(longLikeToBigInt({
+                low: v.low,
+                high: v.high,
+                unsigned: v.unsigned === true,
+            }));
+            if (parsed !== null) {
+                return parsed;
+            }
+        }
+    }
+    throw new Error("Unable to parse points_count from YDB result.");
+}
+export async function countPointsForCollection(uid) {
+    const qry = `
+    DECLARE $collection AS Utf8;
+    SELECT CAST(COUNT(*) AS Uint64) AS points_count
+    FROM ${GLOBAL_POINTS_TABLE}
+    WHERE collection = $collection;
+  `;
+    const res = await withSession(async (s) => {
+        const settings = createExecuteQuerySettings();
+        return await s.executeQuery(qry, {
+            $collection: TypedValues.utf8(uid),
+        }, undefined, settings);
+    });
+    const rowset = res.resultSets?.[0];
+    const row = rowset?.rows?.[0];
+    const cell = row?.items?.[0];
+    if (!cell) {
+        return 0;
+    }
+    return parsePointCountValue(cell.uint64Value ??
+        cell.int64Value ??
+        cell.uint32Value ??
+        cell.int32Value ??
+        cell.textValue);
+}
 /**
  * Best-effort metadata update for a collection's last_accessed_at timestamp.
  *