ydb-qdrant 5.2.1 → 7.0.1

package/dist/utils/retry.js

@@ -1,4 +1,5 @@
 import { logger } from "../logging/logger.js";
+import { retry as ydbRetry } from "@ydbjs/retry";
 const DEFAULT_MAX_RETRIES = 6;
 const DEFAULT_BASE_DELAY_MS = 250;
 export function isTransientYdbError(error) {
@@ -22,26 +23,35 @@ export async function withRetry(fn, options = {}) {
     const baseDelayMs = options.baseDelayMs ?? DEFAULT_BASE_DELAY_MS;
     const isTransient = options.isTransient ?? isTransientYdbError;
     const context = options.context ?? {};
-    let attempt = 0;
-    while (true) {
-        try {
-            return await fn();
-        }
-        catch (e) {
-            if (!isTransient(e) || attempt >= maxRetries) {
-                throw e;
-            }
-            const backoffMs = Math.floor(baseDelayMs * Math.pow(2, attempt) + Math.random() * 100);
+    // We keep the public API in terms of `maxRetries`, but @ydbjs/retry uses a budget
+    // in terms of total attempts. Convert retries→attempts.
+    const attemptsBudget = Math.max(0, maxRetries) + 1;
+    const delayByAttempt = new Map();
+    return await ydbRetry({
+        budget: attemptsBudget,
+        retry: (error) => isTransient(error),
+        strategy: (ctx) => {
+            // Preserve previous backoff shape: baseDelayMs * 2^attemptIndex + jitter(0..100)
+            // where attemptIndex started at 0 for the first retry.
+            const attemptIndex = Math.max(0, ctx.attempt - 1);
+            const delayMs = Math.floor(baseDelayMs * Math.pow(2, attemptIndex) + Math.random() * 100);
+            delayByAttempt.set(ctx.attempt, delayMs);
+            return delayMs;
+        },
+        onRetry: (ctx) => {
+            const attemptIndex = Math.max(0, ctx.attempt - 1);
             logger.warn({
                 ...context,
-                attempt,
-                backoffMs,
-                err: e instanceof Error
-                    ? e
-                    : new Error(typeof e === "string" ? e : JSON.stringify(e)),
+                attempt: attemptIndex,
+                backoffMs: delayByAttempt.get(ctx.attempt),
+                err: ctx.error instanceof Error
+                    ? ctx.error
+                    : new Error(typeof ctx.error === "string"
+                        ? ctx.error
+                        : JSON.stringify(ctx.error)),
             }, "operation aborted due to transient error; retrying");
-            await new Promise((r) => setTimeout(r, backoffMs));
-            attempt += 1;
-        }
-    }
+        },
+    }, async () => {
+        return await fn();
+    });
 }

package/dist/utils/tenant.d.ts

@@ -1,6 +1,6 @@
 export declare function hashApiKey(apiKey: string | undefined): string | undefined;
-export declare function hashUserAgent(userAgent: string | undefined): string | undefined;
-export declare function sanitizeCollectionName(name: string, apiKeyHash?: string, userAgentHash?: string): string;
+export declare function normalizeUserAgent(userAgent: string | undefined): string | undefined;
+export declare function sanitizeCollectionName(name: string, apiKeyHash?: string, userAgentNormalized?: string): string;
 export declare function sanitizeTenantId(tenantId: string | undefined): string;
 export declare function tableNameFor(sanitizedTenant: string, sanitizedCollection: string): string;
 export declare function metaKeyFor(sanitizedTenant: string, sanitizedCollection: string): string;

package/dist/utils/tenant.js

@@ -5,26 +5,41 @@ export function hashApiKey(apiKey) {
     const hash = createHash("sha256").update(apiKey).digest("hex");
     return hash.slice(0, 8);
 }
-export function hashUserAgent(userAgent) {
+export function normalizeUserAgent(userAgent) {
     if (!userAgent || userAgent.trim() === "")
         return undefined;
+    let lowered = userAgent
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9_]/g, "_")
+        .replace(/_+/g, "_")
+        .replace(/^_+|_+$/g, "");
+    if (lowered.length === 0)
+        return undefined;
+    const MAX_LEN = 32;
+    if (lowered.length > MAX_LEN) {
+        lowered = lowered.slice(0, MAX_LEN).replace(/_+$/g, "");
+    }
+    if (lowered.length === 0)
+        return undefined;
     const hash = createHash("sha256").update(userAgent).digest("hex");
-    return hash.slice(0, 8);
+    const shortHash = hash.slice(0, 8);
+    return `${lowered}_${shortHash}`;
 }
-export function sanitizeCollectionName(name, apiKeyHash, userAgentHash) {
+export function sanitizeCollectionName(name, apiKeyHash, userAgentNormalized) {
     const cleaned = name.replace(/[^a-zA-Z0-9_]/g, "_").replace(/_+/g, "_");
     const lowered = cleaned.toLowerCase().replace(/^_+/, "");
     const base = lowered.length > 0 ? lowered : "collection";
     const hasApiKey = apiKeyHash !== undefined && apiKeyHash.trim().length > 0;
-    const hasUserAgent = userAgentHash !== undefined && userAgentHash.trim().length > 0;
+    const hasUserAgent = userAgentNormalized !== undefined && userAgentNormalized.trim().length > 0;
     if (hasApiKey && hasUserAgent) {
-        return `${base}_${apiKeyHash}_${userAgentHash}`;
+        return `${base}_${apiKeyHash}_${userAgentNormalized}`;
     }
     else if (hasApiKey) {
         return `${base}_${apiKeyHash}`;
     }
     else if (hasUserAgent) {
-        return `${base}_${userAgentHash}`;
+        return `${base}_${userAgentNormalized}`;
     }
     return base;
 }

package/dist/utils/typeGuards.d.ts

@@ -0,0 +1 @@
+export declare function isRecord(value: unknown): value is Record<string, unknown>;

package/dist/utils/typeGuards.js

@@ -0,0 +1,3 @@
+export function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/utils/vectorBinary.js

@@ -14,22 +14,101 @@ export function vectorToFloatBinary(vector) {
     return buffer;
 }
 export function vectorToBitBinary(vector) {
-    if (vector.length === 0) {
-        return Buffer.from([10]);
-    }
-    const byteCount = Math.ceil(vector.length / 8);
-    const buffer = Buffer.alloc(byteCount + 1);
+    // Mirrors YDB's TKnnBitVectorSerializer (Knn::ToBinaryStringBit) layout:
+    // - Packed bits as integers written in native endianness
+    // - Then 1 byte: count of unused bits in the last data byte
+    // - Then 1 byte: format marker (10 = BitVector)
+    //
+    // Source: https://raw.githubusercontent.com/ydb-platform/ydb/0b506f56e399e0b4e6a6a4267799da68a3164bf7/ydb/library/yql/udfs/common/knn/knn-serializer.h
+    const bitLen = vector.length;
+    const dataByteLen = Math.ceil(bitLen / 8);
+    const totalLen = dataByteLen + 2; // +1 unused-bit-count +1 format marker
+    const buffer = Buffer.alloc(totalLen);
+    const isLittleEndian = new Uint8Array(new Uint16Array([0x00ff]).buffer)[0] === 0xff;
+    let offset = 0;
+    const writeU64 = (v) => {
+        if (isLittleEndian) {
+            buffer.writeBigUInt64LE(v, offset);
+        }
+        else {
+            buffer.writeBigUInt64BE(v, offset);
+        }
+        offset += 8;
+    };
+    const writeU32 = (v) => {
+        if (isLittleEndian) {
+            buffer.writeUInt32LE(v, offset);
+        }
+        else {
+            buffer.writeUInt32BE(v, offset);
+        }
+        offset += 4;
+    };
+    const writeU16 = (v) => {
+        if (isLittleEndian) {
+            buffer.writeUInt16LE(v, offset);
+        }
+        else {
+            buffer.writeUInt16BE(v, offset);
+        }
+        offset += 2;
+    };
+    const writeU8 = (v) => {
+        buffer.writeUInt8(v, offset);
+        offset += 1;
+    };
+    let accumulator = 0n;
+    let filledBits = 0;
     for (let i = 0; i < vector.length; i += 1) {
         const value = vector[i];
         if (!Number.isFinite(value)) {
             throw new Error(`Non-finite value in vector at index ${i}: ${value}`);
         }
         if (value > 0) {
-            const byteIndex = Math.floor(i / 8);
-            const bitIndex = i % 8;
-            buffer[byteIndex] |= 1 << bitIndex;
+            accumulator |= 1n;
+        }
+        filledBits += 1;
+        if (filledBits === 64) {
+            writeU64(accumulator);
+            accumulator = 0n;
+            filledBits = 0;
         }
+        accumulator <<= 1n;
     }
-    buffer.writeUInt8(10, byteCount);
+    accumulator >>= 1n;
+    filledBits += 7;
+    const tailWriteIf = (bits) => {
+        if (filledBits < bits) {
+            return;
+        }
+        if (bits === 64) {
+            writeU64(accumulator & 0xffffffffffffffffn);
+            filledBits -= 64;
+            return;
+        }
+        if (bits === 32) {
+            writeU32(Number(accumulator & 0xffffffffn));
+            accumulator >>= 32n;
+            filledBits -= 32;
+            return;
+        }
+        if (bits === 16) {
+            writeU16(Number(accumulator & 0xffffn));
+            accumulator >>= 16n;
+            filledBits -= 16;
+            return;
+        }
+        writeU8(Number(accumulator & 0xffn));
+        accumulator >>= 8n;
+        filledBits -= 8;
+    };
+    tailWriteIf(64);
+    tailWriteIf(32);
+    tailWriteIf(16);
+    tailWriteIf(8);
+    // After tail writes, we must have < 8 "filledBits" left.
+    const unusedBitsInLastByte = 7 - filledBits;
+    writeU8(unusedBitsInLastByte);
+    writeU8(10);
     return buffer;
 }

package/dist/ydb/QueryDiagnostics.d.ts

@@ -0,0 +1,6 @@
+import type { Query } from "@ydbjs/query";
+type QueryDiagContext = Record<string, unknown> & {
+    operation: string;
+};
+export declare function attachQueryDiagnostics<T extends unknown[]>(q: Query<T>, context: QueryDiagContext): Query<T>;
+export {};

package/dist/ydb/QueryDiagnostics.js

@@ -0,0 +1,52 @@
+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

@@ -0,0 +1,36 @@
+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

@@ -0,0 +1,248 @@
+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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,52 @@
+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);
+    }
+}