ydb-qdrant 7.0.1 → 8.1.1

package/dist/ydb/QueryDiagnostics.js

@@ -1,52 +0,0 @@
-import { StatsMode } from "@ydbjs/api/query";
-import { QUERY_RETRY_LOG_ENABLED, QUERY_STATS_MODE, QueryStatsMode, } from "../config/env.js";
-import { logger } from "../logging/logger.js";
-import { isRecord } from "../utils/typeGuards.js";
-function mapStatsMode(mode) {
-    if (mode === QueryStatsMode.Basic)
-        return StatsMode.BASIC;
-    if (mode === QueryStatsMode.Full)
-        return StatsMode.FULL;
-    if (mode === QueryStatsMode.Profile)
-        return StatsMode.PROFILE;
-    return null;
-}
-function pickStatsSummary(stats) {
-    if (!isRecord(stats)) {
-        return {};
-    }
-    const phase = stats.queryPhaseStats;
-    if (!isRecord(phase)) {
-        return {};
-    }
-    return {
-        cpuTimeUs: phase.cpuTimeUs,
-        durationUs: phase.durationUs,
-    };
-}
-export function attachQueryDiagnostics(q, context) {
-    const statsMode = mapStatsMode(QUERY_STATS_MODE);
-    let out = q;
-    if (statsMode) {
-        out = out.withStats(statsMode);
-        out.on("stats", (stats) => {
-            logger.info({
-                ...context,
-                queryStatsMode: QUERY_STATS_MODE,
-                ...pickStatsSummary(stats),
-            }, `${context.operation}: stats`);
-        });
-    }
-    if (QUERY_RETRY_LOG_ENABLED) {
-        out.on("retry", (ctx) => {
-            logger.warn({
-                ...context,
-                attempt: ctx.attempt,
-                err: ctx.error instanceof Error
-                    ? ctx.error
-                    : new Error(String(ctx.error)),
-            }, `${context.operation}: retry`);
-        });
-    }
-    return out;
-}

package/dist/ydb/SessionPool.d.ts

@@ -1,36 +0,0 @@
-import type { Driver } from "@ydbjs/core";
-export type PooledQuerySession = {
-    nodeId: bigint;
-    sessionId: string;
-};
-export declare class SessionPool {
-    private readonly driver;
-    private readonly available;
-    private readonly inUse;
-    private readonly waiters;
-    private keepaliveTimer;
-    private isClosed;
-    constructor(driver: Driver);
-    /**
-     * Test-only escape hatch to inspect and drive internal state without unsafe casts.
-     * Not part of the public API surface.
-     */
-    __getInternalsForTests(): {
-        available: Array<{
-            sessionId: string;
-            lastCheckedAtMs: number;
-        }>;
-        keepaliveTick: () => Promise<void>;
-        inUse: Set<string>;
-    };
-    start(): void;
-    close(): Promise<void>;
-    warmup(signal: AbortSignal): Promise<void>;
-    acquire(signal: AbortSignal): Promise<PooledQuerySession>;
-    release(session: PooledQuerySession): void;
-    discard(session: PooledQuerySession): Promise<void>;
-    private totalSize;
-    private createAndAttachSession;
-    private deleteSessionBestEffort;
-    private keepaliveTick;
-}

package/dist/ydb/SessionPool.js

@@ -1,248 +0,0 @@
-import { StatusIds_StatusCode } from "@ydbjs/api/operation";
-import { QueryServiceDefinition } from "@ydbjs/api/query";
-import { YDBError } from "@ydbjs/error";
-import { logger } from "../logging/logger.js";
-import { SESSION_KEEPALIVE_PERIOD_MS, SESSION_POOL_MAX_SIZE, SESSION_POOL_MIN_SIZE, STARTUP_PROBE_SESSION_TIMEOUT_MS, } from "../config/env.js";
-function isSuccessStatus(status) {
-    return status === StatusIds_StatusCode.SUCCESS;
-}
-function asAttachSessionResponse(value) {
-    if (typeof value === "object" && value !== null) {
-        return value;
-    }
-    return {};
-}
-function toStatusCode(status) {
-    return typeof status === "number"
-        ? status
-        : StatusIds_StatusCode.STATUS_CODE_UNSPECIFIED;
-}
-const EMPTY_ISSUES = [];
-function nowMs() {
-    return Date.now();
-}
-export class SessionPool {
-    driver;
-    available = [];
-    inUse = new Set();
-    waiters = [];
-    keepaliveTimer = null;
-    isClosed = false;
-    constructor(driver) {
-        this.driver = driver;
-    }
-    /**
-     * Test-only escape hatch to inspect and drive internal state without unsafe casts.
-     * Not part of the public API surface.
-     */
-    __getInternalsForTests() {
-        return {
-            available: this.available,
-            keepaliveTick: () => this.keepaliveTick(),
-            inUse: this.inUse,
-        };
-    }
-    start() {
-        if (this.keepaliveTimer)
-            return;
-        this.keepaliveTimer = setInterval(() => {
-            void this.keepaliveTick();
-        }, SESSION_KEEPALIVE_PERIOD_MS);
-        // Don't keep the Node process alive just because of keepalive.
-        this.keepaliveTimer.unref();
-    }
-    async close() {
-        this.isClosed = true;
-        if (this.keepaliveTimer) {
-            clearInterval(this.keepaliveTimer);
-            this.keepaliveTimer = null;
-        }
-        for (const w of this.waiters.splice(0)) {
-            w.reject(new Error("SessionPool is closed"));
-        }
-        const toDelete = this.available.splice(0);
-        for (const s of toDelete) {
-            await this.deleteSessionBestEffort(s);
-        }
-        this.inUse.clear();
-    }
-    async warmup(signal) {
-        const target = SESSION_POOL_MIN_SIZE;
-        if (target <= 0)
-            return;
-        while (!this.isClosed && this.totalSize() < target) {
-            const s = await this.createAndAttachSession(signal);
-            this.available.push({
-                ...s,
-                lastUsedAtMs: nowMs(),
-                lastCheckedAtMs: 0,
-            });
-        }
-    }
-    async acquire(signal) {
-        if (this.isClosed) {
-            throw new Error("SessionPool is closed");
-        }
-        // Prefer an existing idle session.
-        const existing = this.available.pop();
-        if (existing) {
-            this.inUse.add(existing.sessionId);
-            existing.lastUsedAtMs = nowMs();
-            return { nodeId: existing.nodeId, sessionId: existing.sessionId };
-        }
-        // Create a new one if we are under the max.
-        if (this.totalSize() < SESSION_POOL_MAX_SIZE) {
-            const created = await this.createAndAttachSession(signal);
-            const internal = {
-                ...created,
-                lastUsedAtMs: nowMs(),
-                lastCheckedAtMs: 0,
-            };
-            this.inUse.add(internal.sessionId);
-            return { nodeId: internal.nodeId, sessionId: internal.sessionId };
-        }
-        // Otherwise, wait for a release.
-        return await new Promise((resolve, reject) => {
-            const cleanup = () => {
-                signal.removeEventListener("abort", onAbort);
-            };
-            const waiter = {
-                fulfill: (s) => {
-                    cleanup();
-                    this.inUse.add(s.sessionId);
-                    s.lastUsedAtMs = nowMs();
-                    resolve({ nodeId: s.nodeId, sessionId: s.sessionId });
-                },
-                reject: (err) => {
-                    cleanup();
-                    reject(err);
-                },
-                cleanup,
-            };
-            const onAbort = () => {
-                const idx = this.waiters.indexOf(waiter);
-                if (idx >= 0) {
-                    this.waiters.splice(idx, 1);
-                }
-                waiter.reject(new Error("SessionPool acquire aborted"));
-            };
-            if (signal.aborted)
-                return onAbort();
-            signal.addEventListener("abort", onAbort);
-            this.waiters.push(waiter);
-        });
-    }
-    release(session) {
-        if (this.isClosed) {
-            this.inUse.delete(session.sessionId);
-            void this.deleteSessionBestEffort(session);
-            return;
-        }
-        if (!this.inUse.has(session.sessionId)) {
-            return;
-        }
-        this.inUse.delete(session.sessionId);
-        const internal = {
-            ...session,
-            lastUsedAtMs: nowMs(),
-            lastCheckedAtMs: 0,
-        };
-        const waiter = this.waiters.shift();
-        if (waiter) {
-            waiter.fulfill(internal);
-            return;
-        }
-        this.available.push(internal);
-        // Soft cap: if we exceed max (shouldn't happen), evict extras.
-        while (this.totalSize() > SESSION_POOL_MAX_SIZE &&
-            this.available.length > 0) {
-            const victim = this.available.shift();
-            if (victim) {
-                void this.deleteSessionBestEffort(victim);
-            }
-        }
-    }
-    async discard(session) {
-        this.inUse.delete(session.sessionId);
-        await this.deleteSessionBestEffort(session);
-    }
-    totalSize() {
-        return this.available.length + this.inUse.size;
-    }
-    async createAndAttachSession(signal) {
-        await this.driver.ready(signal);
-        const client = this.driver.createClient(QueryServiceDefinition);
-        const sessionResponse = await client.createSession({}, { signal });
-        if (!isSuccessStatus(sessionResponse.status)) {
-            throw new YDBError(sessionResponse.status, sessionResponse.issues);
-        }
-        const nodeId = sessionResponse.nodeId;
-        const sessionId = sessionResponse.sessionId;
-        const nodeClient = this.driver.createClient(QueryServiceDefinition, nodeId);
-        const attachStream = nodeClient.attachSession({ sessionId }, { signal });
-        const attach = attachStream[Symbol.asyncIterator]();
-        const first = await attach.next();
-        const attachResp = asAttachSessionResponse(first.value);
-        const code = toStatusCode(attachResp.status);
-        if (!isSuccessStatus(code)) {
-            throw new YDBError(code, EMPTY_ISSUES);
-        }
-        return { nodeId, sessionId };
-    }
-    async deleteSessionBestEffort(session) {
-        try {
-            const client = this.driver.createClient(QueryServiceDefinition, session.nodeId);
-            await client.deleteSession({ sessionId: session.sessionId }, { signal: AbortSignal.timeout(STARTUP_PROBE_SESSION_TIMEOUT_MS) });
-        }
-        catch (err) {
-            logger.warn({ err }, "SessionPool: failed to delete session (ignored)");
-        }
-    }
-    async keepaliveTick() {
-        if (this.isClosed)
-            return;
-        if (this.available.length === 0)
-            return;
-        // Probe at most one idle session per tick to bound overhead.
-        const idx = this.available.reduce((best, cur, i, arr) => {
-            const bestAt = arr[best]?.lastCheckedAtMs ?? 0;
-            return cur.lastCheckedAtMs < bestAt ? i : best;
-        }, 0);
-        const s = this.available[idx];
-        if (!s)
-            return;
-        const sessionId = s.sessionId;
-        const nodeId = s.nodeId;
-        const now = nowMs();
-        if (now - s.lastCheckedAtMs < SESSION_KEEPALIVE_PERIOD_MS) {
-            return;
-        }
-        s.lastCheckedAtMs = now;
-        try {
-            const signal = AbortSignal.timeout(STARTUP_PROBE_SESSION_TIMEOUT_MS);
-            const client = this.driver.createClient(QueryServiceDefinition, s.nodeId);
-            const attachStream = client.attachSession({ sessionId: s.sessionId }, { signal });
-            const attach = attachStream[Symbol.asyncIterator]();
-            const first = await attach.next();
-            const attachResp = asAttachSessionResponse(first.value);
-            const code = toStatusCode(attachResp.status);
-            if (!isSuccessStatus(code)) {
-                throw new YDBError(code, EMPTY_ISSUES);
-            }
-        }
-        catch {
-            // Session likely dead; evict from pool and delete best-effort.
-            // Important: `this.available` may have been modified while awaiting the probe.
-            // Avoid using the pre-await index, and never delete a session that is currently leased.
-            if (this.inUse.has(sessionId)) {
-                return;
-            }
-            const availableIdx = this.available.findIndex((x) => x.sessionId === sessionId);
-            if (availableIdx === -1) {
-                return;
-            }
-            this.available.splice(availableIdx, 1);
-            void this.deleteSessionBestEffort({ nodeId, sessionId });
-        }
-    }
-}

package/dist/ydb/bulkUpsert.d.ts

@@ -1,6 +0,0 @@
-import type { List } from "@ydbjs/value/list";
-export declare function bulkUpsertRowsOnce(args: {
-    tableName: string;
-    rowsValue: List;
-    timeoutMs: number;
-}): Promise<void>;

package/dist/ydb/bulkUpsert.js

@@ -1,52 +0,0 @@
-import { create } from "@bufbuild/protobuf";
-import { StatusIds_StatusCode } from "@ydbjs/api/operation";
-import { OperationServiceDefinition } from "@ydbjs/api/operation";
-import { TableServiceDefinition } from "@ydbjs/api/table";
-import { TypedValueSchema } from "@ydbjs/api/value";
-import { YDBError } from "@ydbjs/error";
-import { setTimeout as sleep } from "node:timers/promises";
-import { __getDriverForInternalUse } from "./client.js";
-function tablePath(database, tableName) {
-    const db = database.endsWith("/") ? database.slice(0, -1) : database;
-    const t = tableName.startsWith("/") ? tableName : `/${tableName}`;
-    return `${db}${t}`;
-}
-async function waitOperationReady(args) {
-    for (;;) {
-        const resp = await args.operationClient.getOperation({ id: args.operationId }, { signal: args.signal });
-        const op = resp.operation;
-        if (!op) {
-            throw new Error("BulkUpsert: getOperation returned no operation");
-        }
-        if (op.ready) {
-            return { status: op.status, issues: op.issues };
-        }
-        // Small delay before next poll.
-        await sleep(25, undefined, { signal: args.signal });
-    }
-}
-export async function bulkUpsertRowsOnce(args) {
-    const d = __getDriverForInternalUse();
-    const fullTablePath = tablePath(d.database, args.tableName);
-    const signal = AbortSignal.timeout(args.timeoutMs);
-    await d.ready(signal);
-    const tableClient = d.createClient(TableServiceDefinition);
-    const operationClient = d.createClient(OperationServiceDefinition);
-    const typedRows = create(TypedValueSchema, {
-        type: args.rowsValue.type.encode(),
-        value: args.rowsValue.encode(),
-    });
-    const resp = await tableClient.bulkUpsert({ table: fullTablePath, rows: typedRows }, { signal });
-    const op = resp.operation;
-    if (!op) {
-        throw new Error("BulkUpsert: response has no operation");
-    }
-    const final = op.ready
-        ? { status: op.status, issues: op.issues }
-        : op.id
-            ? await waitOperationReady({ operationClient, operationId: op.id, signal })
-            : { status: op.status, issues: op.issues };
-    if (final.status !== StatusIds_StatusCode.SUCCESS) {
-        throw new YDBError(final.status, final.issues);
-    }
-}